Model separate project calls as seaprate list items in train

For non-leaf transforms, add a separate train method that takes QList<TemplateList> as arguments, where the separate list items correspond to the separate calls to project that would be made by parent transforms during enrollment. This is basically to deal with the effects of distribute on untrainable meta transforms such as flatten, we have to maintain a consistent grouping with project, otherwise the intermediate projection results used during training won't be consistent with what they would be during enrollment.

Model separate project calls as seaprate list items in train
For non-leaf transforms, add a separate train method that takes QList<TemplateList> as arguments, where the separate list items correspond to the separate calls to project that would be made by parent transforms during enrollment. This is basically to deal with the effects of distribute on untrainable meta transforms such as flatten, we have to maintain a consistent grouping with project, otherwise the intermediate projection results used during training won't be consistent with what they would be during enrollment.
Charles Otto
1 parent f0eb0cfb
Showing 5 changed files with 66 additions and 30 deletions
openbr/core/core.cpp
openbr/openbr_plugin.h
openbr/plugins/meta.cpp
openbr/plugins/openbr_internal.h
openbr/plugins/validate.cpp
@@ -48,7 +48,9 @@ struct AlgorithmCore
  
         QTime time; time.start();
         qDebug("Training Enrollment");
-        transform->train(data);
+        QList<TemplateList> uniform;
+        uniform.append(data);
+        transform->train(uniform);
  
         if (!distance.isNull()) {
             qDebug("Projecting Enrollment");
@@ -1058,7 +1058,19 @@ public:
     static QSharedPointer<Transform> fromAlgorithm(const QString &algorithm); /*!< \brief Retrieve an algorithm's transform. */
  
     virtual Transform *clone() const; /*!< \brief Copy the transform. */
+    /*!< \brief Train the transform, separate list items represent the way calls to project would be broken up*/
+    virtual void train(const QList<TemplateList> &data)
+    {
+        TemplateList combined;
+        foreach(const TemplateList & set, data) {
+            combined.append(set);
+        }
+        train(combined);
+    }
+
+    // Terminal train, call with a complete training set when no further structure is needed
     virtual void train(const TemplateList &data) = 0; /*!< \brief Train the transform. */
+
     virtual void project(const Template &src, Template &dst) const = 0; /*!< \brief Apply the transform. */
     virtual void project(const TemplateList &src, TemplateList &dst) const; /*!< \brief Apply the transform. */
  
@@ -57,7 +57,7 @@ static TemplateList Expanded(const TemplateList &amp;templates)
     return expanded;
 }
  
-static void _train(Transform *transform, const TemplateList *data)
+static void _train(Transform *transform, const QList<TemplateList> *data)
 {
     transform->train(*data);
 }
@@ -82,18 +82,17 @@ class PipeTransform : public CompositeTransform
             *srcdst >> *transforms[i];
     }
  
-    void train(const TemplateList &data)
+    void train(const TemplateList & data)
+    {
+        (void) data;
+        qFatal("Terminal train called on interior node");
+    }
+
+    void train(const QList<TemplateList> &data)
     {
         if (!trainable) return;
  
-        TemplateList copy(data);
-        QList<TemplateList> singleItemLists;
-        for (int i=0; i < copy.size(); i++)
-        {
-            TemplateList temp;
-            temp.append(copy[i]);
-            singleItemLists.append(temp);
-        }
+        QList<TemplateList> dataLines(data);
  
         int i = 0;
         while (i < transforms.size()) {
@@ -102,23 +101,18 @@ class PipeTransform : public CompositeTransform
             // Conditional statement covers likely case that first transform is untrainable
             if (transforms[i]->trainable) {
                 fprintf(stderr, " training...");
-                transforms[i]->train(copy);
+                transforms[i]->train(dataLines);
             }
  
             // if the transform is time varying, we can't project it in parallel
             if (transforms[i]->timeVarying()) {
                 fprintf(stderr, "\n%s projecting...", qPrintable(transforms[i]->objectName()));
-                for (int j=0; j < singleItemLists.size();j++)
-                    transforms[i]->projectUpdate(singleItemLists[j], singleItemLists[j]);
+                for (int j=0; j < dataLines.size();j++)
+                    transforms[i]->projectUpdate(dataLines[j], dataLines[j]);
  
                 // advance i since we already projected for this stage.
                 i++;
  
-                // set up copy again
-                copy.clear();
-                for (int j=0; j < singleItemLists.size(); j++)
-                    copy.append(singleItemLists[j]);
-
                 // the next stage might be trainable, so continue to evaluate it.
                 continue;
             }
@@ -136,14 +130,10 @@ class PipeTransform : public CompositeTransform
  
             fprintf(stderr, " projecting...");
             QFutureSynchronizer<void> futures;
-            for (int j=0; j < singleItemLists.size(); j++)
-                futures.addFuture(QtConcurrent::run(this, &PipeTransform::_projectPartial, &singleItemLists[j], i, nextTrainableTransform));
+            for (int j=0; j < dataLines.size(); j++)
+                futures.addFuture(QtConcurrent::run(this, &PipeTransform::_projectPartial, &dataLines[j], i, nextTrainableTransform));
             futures.waitForFinished();
  
-            copy.clear();
-            for (int j=0; j < singleItemLists.size(); j++)
-                copy.append(singleItemLists[j]);
-
             i = nextTrainableTransform;
         }
     }
@@ -296,7 +286,13 @@ class ForkTransform : public CompositeTransform
 {
     Q_OBJECT
  
-    void train(const TemplateList &data)
+     void train(const TemplateList & data)
+     {
+         (void) data;
+         qFatal("Terminal train called on interior node.");
+     }
+
+    void train(const QList<TemplateList> &data)
     {
         if (!trainable) return;
         QFutureSynchronizer<void> futures;
@@ -612,9 +608,23 @@ public:
         return output;
     }
  
-    void train(const TemplateList &data)
+    void train(const TemplateList & data)
     {
-        transform->train(data);
+        (void) data;
+        qFatal("terminal train called on non-leaf transform");
+    }
+
+    void train(const QList<TemplateList> &data)
+    {
+        QList<TemplateList> separated;
+        foreach (const TemplateList & list, data) {
+            foreach(const Template & t, list) {
+                separated.append(TemplateList());
+                separated.last().append(t);
+            }
+        }
+
+        transform->train(separated);
     }
  
     void project(const Template &src, Template &dst) const
@@ -140,7 +140,13 @@ public:
         transformSource.release(aTransform);
     }
  
-    void train(const TemplateList &data)
+    void train(const TemplateList & data)
+    {
+        (void) data;
+        qFatal("terminal train called on non-leaf node");
+    }
+
+    void train(const QList<TemplateList> &data)
     {
         baseTransform->train(data);
     }
@@ -6,6 +6,11 @@
 namespace br
 {
  
+static void _train(Transform * transform, TemplateList data) // think data has to be a copy -cao
+{
+    transform->train(data);
+}
+
 /*!
  * \ingroup transforms
  * \brief Cross validate a trainable transform.
@@ -46,7 +51,8 @@ class CrossValidateTransform : public MetaTransform
                 if (partitions[j] == i)
                     partitionedData.removeAt(j);
             // Train on the remaining templates
-            futures.addFuture(QtConcurrent::run(transforms[i], &Transform::train, partitionedData));
+            //futures.addFuture(QtConcurrent::run(transforms[i], &Transform::train, partitionedData));
+            futures.addFuture(QtConcurrent::run(_train, transforms[i], partitionedData));
         }
         futures.waitForFinished();
     }