Method train

openbr/plugins/core/pipe.cpp:49–108

    }

    void train(const QList<TemplateList> &data)
    {
        if (!trainable) return;

        QList<TemplateList> dataLines(data);

        int i = 0;
        while (i < transforms.size()) {
            // Conditional statement covers likely case that first transform is untrainable
            if (transforms[i]->trainable) {
                qDebug() << "Training" << transforms[i]->description() << "\n...";
                transforms[i]->train(dataLines);
            }

            // if the transform is time varying, we can't project it in parallel
            if (transforms[i]->timeVarying()) {
                qDebug() << "Projecting" << transforms[i]->description() << "\n...";
                for (int j=0; j < dataLines.size();j++) {
                    TemplateList junk;
                    splitFTEs(dataLines[j], junk);

                    transforms[i]->projectUpdate(dataLines[j], dataLines[j]);
                }

                // advance i since we already projected for this stage.
                i++;

                // the next stage might be trainable, so continue to evaluate it.
                continue;
            }

            // We project through any subsequent untrainable transforms at once
            //   as a memory optimization in case any of these intermediate
            //   transforms allocate a lot of memory (like OpenTransform)
            //   then we don't want all the training templates to be processed
            //   by that transform at once if we can avoid it.
            int nextTrainableTransform = i+1;
            while ((nextTrainableTransform < transforms.size()) &&
                   !transforms[nextTrainableTransform]->trainable &&
                   !transforms[nextTrainableTransform]->timeVarying())
                nextTrainableTransform++;

            // No more trainable transforms? Don't need any more projects then
            if (nextTrainableTransform == transforms.size())
                break;

            fprintf(stderr, "Projecting %s", qPrintable(transforms[i]->description()));
            for (int j=i+1; j < nextTrainableTransform; j++)
                fprintf(stderr,"+%s", qPrintable(transforms[j]->description()));
            fprintf(stderr, "\n...\n");
            fflush(stderr);

            QFutureSynchronizer<void> futures;
            for (int j=0; j < dataLines.size(); j++)
                futures.addFuture(QtConcurrent::run(this, &PipeTransform::_projectPartial, &dataLines[j], i, nextTrainableTransform));
            futures.waitForFinished();

            i = nextTrainableTransform;