Merge pull request #305 from CitrineInformatics/parallel-iteration-only

Store regular Seq and cast to Par during training/transform only

Author: Sean Friedowitz

src/main/scala/io/citrine/lolo/bags/BaggedModel.scala

@@ -3,13 +3,13 @@ package io.citrine.lolo.bags
 import breeze.linalg.DenseMatrix
 import io.citrine.lolo.api.Model
 
-import scala.collection.parallel.immutable.ParSeq
+import scala.collection.parallel.CollectionConverters._
 
 /** A model holding a parallel sequence of models and the sample counts used to train them. */
 trait BaggedModel[+T] extends Model[T] {
 
   /** Models in the ensemble trained on subsets of the training data. */
-  def ensembleModels: ParSeq[Model[T]]
+  def ensembleModels: Seq[Model[T]]
 
   override def transform(inputs: Seq[Vector[Any]]): BaggedPrediction[T]
 
@@ -31,7 +31,7 @@ trait BaggedModel[+T] extends Model[T] {
 }
 
 case class BaggedRegressionModel(
-    ensembleModels: ParSeq[Model[Double]],
+    ensembleModels: Seq[Model[Double]],
     Nib: Vector[Vector[Int]],
     rescaleRatio: Double = 1.0,
     disableBootstrap: Boolean = false,
@@ -42,7 +42,7 @@ case class BaggedRegressionModel(
     assert(inputs.forall(_.size == inputs.head.size))
 
     val bias = biasModel.map(_.transform(inputs).expected)
-    val ensemblePredictions = ensembleModels.map(model => model.transform(inputs)).seq
+    val ensemblePredictions = ensembleModels.par.map(model => model.transform(inputs)).seq
 
     if (inputs.size == 1) {
       // In the special case of a single prediction on a real value, emit an optimized prediction class
@@ -65,11 +65,11 @@ case class BaggedRegressionModel(
   }
 }
 
-case class BaggedClassificationModel[T](ensembleModels: ParSeq[Model[T]]) extends BaggedModel[T] {
+case class BaggedClassificationModel[T](ensembleModels: Seq[Model[T]]) extends BaggedModel[T] {
 
   override def transform(inputs: Seq[Vector[Any]]): BaggedClassificationPrediction[T] = {
     assert(inputs.forall(_.size == inputs.head.size))
-    val ensemblePredictions = ensembleModels.map(model => model.transform(inputs)).seq
+    val ensemblePredictions = ensembleModels.par.map(model => model.transform(inputs)).seq
     BaggedClassificationPrediction(ensemblePredictions)
   }
 }

src/main/scala/io/citrine/lolo/bags/BaggedTrainingResult.scala

@@ -3,16 +3,14 @@ package io.citrine.lolo.bags
 import io.citrine.lolo.api.{Model, TrainingResult, TrainingRow}
 import io.citrine.lolo.stats.metrics.{ClassificationMetrics, RegressionMetrics}
 
-import scala.collection.parallel.immutable.ParSeq
-
 /** The result of training a [[Bagger]] to produce a [[BaggedModel]]. */
 sealed trait BaggedTrainingResult[+T] extends TrainingResult[T] {
 
   override def model: BaggedModel[T]
 }
 
 case class RegressionBaggerTrainingResult(
-    ensembleModels: ParSeq[Model[Double]],
+    ensembleModels: Seq[Model[Double]],
     Nib: Vector[Vector[Int]],
     trainingData: Seq[TrainingRow[Double]],
     override val featureImportance: Option[Vector[Double]],
@@ -50,7 +48,7 @@ case class RegressionBaggerTrainingResult(
 }
 
 case class ClassificationBaggerTrainingResult[T](
-    ensembleModels: ParSeq[Model[T]],
+    ensembleModels: Seq[Model[T]],
     Nib: Vector[Vector[Int]],
     trainingData: Seq[TrainingRow[T]],
     override val featureImportance: Option[Vector[Double]],

src/main/scala/io/citrine/lolo/bags/Bagger.scala

@@ -7,7 +7,6 @@ import io.citrine.lolo.stats.StatsUtils
 import io.citrine.random.Random
 
 import scala.collection.parallel.CollectionConverters._
-import scala.collection.parallel.immutable.ParVector
 
 sealed trait Bagger[T] extends Learner[T] {
 
@@ -66,6 +65,7 @@ sealed trait Bagger[T] extends Learner[T] {
           val meta = baseLearner.train(weightedTrainingData, thisRng)
           (meta.model, meta.featureImportance)
       }
+      .seq
       .unzip
 
     // Average the feature importance
@@ -195,7 +195,7 @@ object Bagger {
     * @tparam T type of label data for the models
     */
   protected[bags] case class BaggedEnsemble[+T](
-      models: ParVector[Model[T]],
+      models: Vector[Model[T]],
       Nib: Vector[Vector[Int]],
       averageImportance: Option[Vector[Double]]
   )

src/main/scala/io/citrine/lolo/bags/BaggerHelper.scala

@@ -3,8 +3,6 @@ package io.citrine.lolo.bags
 import io.citrine.lolo.stats.{MathUtils, StatsUtils}
 import io.citrine.lolo.api.{Model, TrainingRow}
 
-import scala.collection.parallel.immutable.ParSeq
-
 /**
   * Helper class to subsume shared functionality of [[RegressionBagger]] and [[MultiTaskBagger]].
   *
@@ -15,7 +13,7 @@ import scala.collection.parallel.immutable.ParSeq
   * @param uncertaintyCalibration whether to apply empirical uncertainty calibration
   */
 protected[bags] case class BaggerHelper(
-    models: ParSeq[Model[Double]],
+    models: Seq[Model[Double]],
     trainingData: Seq[TrainingRow[Double]],
     Nib: Vector[Vector[Int]],
     useJackknife: Boolean,

src/main/scala/io/citrine/lolo/bags/MultiTaskBagger.scala

@@ -16,7 +16,6 @@ import io.citrine.lolo.stats.StatsUtils
 import io.citrine.random.Random
 import io.citrine.lolo.stats.metrics.{ClassificationMetrics, RegressionMetrics}
 
-import scala.collection.parallel.immutable.ParSeq
 import scala.collection.parallel.CollectionConverters._
 
 /**
@@ -88,6 +87,7 @@ case class MultiTaskBagger(
             val meta = method.train(weightedTrainingData, thisRng)
             (meta.model, meta.featureImportance)
         }
+        .seq
         .unzip
 
     val averageImportance: Option[Vector[Double]] = importances
@@ -144,7 +144,7 @@ case class MultiTaskBagger(
   * @param rescaleRatios     sequence of uncertainty calibration ratios for each label
   */
 case class MultiTaskBaggedTrainingResult(
-    ensembleModels: ParSeq[MultiTaskModel],
+    ensembleModels: Seq[MultiTaskModel],
     Nib: Vector[Vector[Int]],
     trainingData: Seq[TrainingRow[Vector[Any]]],
     override val featureImportance: Option[Vector[Double]],
@@ -217,7 +217,7 @@ case class MultiTaskBaggedTrainingResult(
         val thisLabelModels = ensembleModels.map(_.models(i))
         if (isReal) {
           BaggedRegressionModel(
-            thisLabelModels.asInstanceOf[ParSeq[Model[Double]]],
+            thisLabelModels.asInstanceOf[Seq[Model[Double]]],
             Nib = Nib,
             rescaleRatio = rescaleRatios(i),
             biasModel = biasModels(i)
@@ -238,7 +238,7 @@ case class MultiTaskBaggedTrainingResult(
   * @param rescaleRatios  sequence of uncertainty calibration ratios for each label
   */
 case class MultiTaskBaggedModel(
-    ensembleModels: ParSeq[MultiTaskModel],
+    ensembleModels: Seq[MultiTaskModel],
     Nib: Vector[Vector[Int]],
     biasModels: Seq[Option[Model[Double]]],
     rescaleRatios: Seq[Double]
@@ -250,7 +250,7 @@ case class MultiTaskBaggedModel(
     val thisLabelsModels = ensembleModels.map(_.models(i))
     if (realLabels(i)) {
       BaggedRegressionModel(
-        thisLabelsModels.asInstanceOf[ParSeq[Model[Double]]],
+        thisLabelsModels.asInstanceOf[Seq[Model[Double]]],
         Nib = Nib,
         rescaleRatio = rescaleRatios(i),
         biasModel = biasModels(i)