public SequenceStreamEventStream(ISequenceStream sequenceStream)
        {
            if (sequenceStream == null)
            {
                throw new ArgumentNullException("sequenceStream");
            }

            this.sequenceStream = sequenceStream;
        }
        public IMaxentModel Train(ISequenceStream events) {

            if (!IsValid()) {
                throw new InvalidOperationException("trainParams are not valid!");
            }

            var model = DoTrain(events);

            
            AddToReport(Parameters.TrainerType, "EventModelSequence"); // EventModelSequenceTrainer.SEQUENCE_VALUE

            return model;
        }
        public IMaxentModel Train(ISequenceStream events)
        {
            if (!IsValid())
            {
                throw new InvalidOperationException("trainParams are not valid!");
            }

            var model = DoTrain(events);


            AddToReport(Parameters.TrainerType, "EventModelSequence"); // EventModelSequenceTrainer.SEQUENCE_VALUE

            return(model);
        }
        protected override IMaxentModel DoTrain(ISequenceStream events) {
            var useAvg = GetBoolParam("UseAverage", true);

            return TrainModel(Iterations, events, Cutoff, useAvg);
        }
        public AbstractModel TrainModel(int trainIterations, ISequenceStream trainStream, int cutoff,
            bool trainUseAverage) {
            iterations = trainIterations;
            useAverage = trainUseAverage;
            sequenceStream = trainStream;

            info.Append("Trained using Perceptron Sequence algorithm.\n\n");

            var di = new OnePassDataIndexer(new SequenceStreamEventStream(trainStream), cutoff, false);

            trainStream.Reset();

            numSequences = 0;

            while (trainStream.Read() != null) {
                numSequences++;
            }

            outcomeList = di.GetOutcomeList();
            predLabels = di.GetPredLabels();

            pMap = new IndexHashTable<string>(predLabels, 0.7d);

            // Incorporation indexed data for training...


            numEvents = di.GetNumEvents();

            outcomeLabels = di.GetOutcomeLabels();
            oMap = new Dictionary<string, int>();
            for (var i = 0; i < outcomeLabels.Length; i++) {
                oMap.Add(outcomeLabels[i], i);
            }

            outcomeList = di.GetOutcomeList();
            numPreds = predLabels.Length;
            numOutcomes = outcomeLabels.Length;

            if (trainUseAverage) {
                updates = new int[numPreds][][];
                for (var i = 0; i < numPreds; i++) {
                    updates[i] = new int[numOutcomes][];
                    for (var j = 0; j < numOutcomes; j++) {
                        updates[i][j] = new int[3];
                    }
                }
            }

            // done.
            Display("done.\n");

            info.Append("Number of Event Tokens: {0}\n" +
                        "    Number of Outcomes: {1}\n" +
                        "  Number of Predicates: {2}\n", numEvents, numOutcomes, numPreds);

            Display("\tNumber of Event Tokens: " + numEvents);
            Display("\t    Number of Outcomes: " + numOutcomes);
            Display("\t  Number of Predicates: " + numPreds);

            param = new MutableContext[numPreds];
            if (trainUseAverage)
                averageParams = new MutableContext[numPreds];

            allOutcomesPattern = new int[numOutcomes];
            for (var i = 0; i < numOutcomes; i++) {
                allOutcomesPattern[i] = i;
            }

            for (var pi = 0; pi < numPreds; pi++) {
                param[pi] = new MutableContext(allOutcomesPattern, new double[numOutcomes]);
                if (trainUseAverage)
                    averageParams[pi] = new MutableContext(allOutcomesPattern, new double[numOutcomes]);

                for (var aoi = 0; aoi < numOutcomes; aoi++) {
                    param[pi].SetParameter(aoi, 0.0d);
                    if (trainUseAverage)
                        averageParams[pi].SetParameter(aoi, 0.0d);
                }
            }

            Display("Computing model parameters...");
            FindParameters();
            Display("...done.");

            /*************** Create and return the model ******************/

            // ReSharper disable CoVariantArrayConversion
            if (trainUseAverage)
                return new PerceptronModel(averageParams, predLabels, outcomeLabels) {
                    info = info
                };

            return new PerceptronModel(param, predLabels, outcomeLabels) {               
                info = info
            };
            // ReSharper restore CoVariantArrayConversion
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="SequenceStreamEventStream"/> class.
 /// </summary>
 /// <param name="sequenceStream">The sequence stream.</param>
 public SequenceStreamEventStream(ISequenceStream<Event> sequenceStream)
 {
     _enumerator = sequenceStream.GetEnumerator();
     EventIndex = -1;
 }
        protected override IMaxentModel DoTrain(ISequenceStream events)
        {
            var useAvg = GetBoolParam("UseAverage", true);

            return(TrainModel(Iterations, events, Cutoff, useAvg));
        }
        public AbstractModel TrainModel(int trainIterations, ISequenceStream trainStream, int cutoff,
                                        bool trainUseAverage)
        {
            iterations     = trainIterations;
            useAverage     = trainUseAverage;
            sequenceStream = trainStream;

            info.Append("Trained using Perceptron Sequence algorithm.\n\n");

            var di = new OnePassDataIndexer(new SequenceStreamEventStream(trainStream), cutoff, false);

            trainStream.Reset();

            numSequences = 0;

            while (trainStream.Read() != null)
            {
                numSequences++;
            }

            outcomeList = di.GetOutcomeList();
            predLabels  = di.GetPredLabels();

            pMap = new IndexHashTable <string>(predLabels, 0.7d);

            // Incorporation indexed data for training...


            numEvents = di.GetNumEvents();

            outcomeLabels = di.GetOutcomeLabels();
            oMap          = new Dictionary <string, int>();
            for (var i = 0; i < outcomeLabels.Length; i++)
            {
                oMap.Add(outcomeLabels[i], i);
            }

            outcomeList = di.GetOutcomeList();
            numPreds    = predLabels.Length;
            numOutcomes = outcomeLabels.Length;

            if (trainUseAverage)
            {
                updates = new int[numPreds][][];
                for (var i = 0; i < numPreds; i++)
                {
                    updates[i] = new int[numOutcomes][];
                    for (var j = 0; j < numOutcomes; j++)
                    {
                        updates[i][j] = new int[3];
                    }
                }
            }

            // done.
            Display("done.\n");

            info.Append("Number of Event Tokens: {0}\n" +
                        "    Number of Outcomes: {1}\n" +
                        "  Number of Predicates: {2}\n", numEvents, numOutcomes, numPreds);

            Display("\tNumber of Event Tokens: " + numEvents);
            Display("\t    Number of Outcomes: " + numOutcomes);
            Display("\t  Number of Predicates: " + numPreds);

            param = new MutableContext[numPreds];
            if (trainUseAverage)
            {
                averageParams = new MutableContext[numPreds];
            }

            allOutcomesPattern = new int[numOutcomes];
            for (var i = 0; i < numOutcomes; i++)
            {
                allOutcomesPattern[i] = i;
            }

            for (var pi = 0; pi < numPreds; pi++)
            {
                param[pi] = new MutableContext(allOutcomesPattern, new double[numOutcomes]);
                if (trainUseAverage)
                {
                    averageParams[pi] = new MutableContext(allOutcomesPattern, new double[numOutcomes]);
                }

                for (var aoi = 0; aoi < numOutcomes; aoi++)
                {
                    param[pi].SetParameter(aoi, 0.0d);
                    if (trainUseAverage)
                    {
                        averageParams[pi].SetParameter(aoi, 0.0d);
                    }
                }
            }

            Display("Computing model parameters...");
            FindParameters();
            Display("...done.");

            /*************** Create and return the model ******************/

            // ReSharper disable CoVariantArrayConversion
            if (trainUseAverage)
            {
                return new PerceptronModel(averageParams, predLabels, outcomeLabels)
                       {
                           info = info
                       }
            }
            ;

            return(new PerceptronModel(param, predLabels, outcomeLabels)
            {
                info = info
            });
            // ReSharper restore CoVariantArrayConversion
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="SequenceStreamEventStream"/> class.
 /// </summary>
 /// <param name="sequenceStream">The sequence stream.</param>
 public SequenceStreamEventStream(ISequenceStream <Event> sequenceStream)
 {
     _enumerator = sequenceStream.GetEnumerator();
     EventIndex  = -1;
 }
 protected abstract IMaxentModel DoTrain(ISequenceStream events);
 protected abstract IMaxentModel DoTrain(ISequenceStream events);