コード例 #1
0
        public void Setup()
        {
            monitorOutputLogMock = Mock.Of <IOutputLog>();
            Mock.Get(monitorOutputLogMock).Setup(x => x.LogMessage(It.IsAny <string>()));

            config = new ConfigProvider("127.0.0.1", 4321, 1);
            var m = new MonitorProject.Monitor(config, monitorOutputLogMock);

            monitorServiceThread = Task.Run(() => m.Start());
        }
コード例 #2
0
        /// <summary>
        /// Runs State Machine demo. This is the main function.
        /// For each demo case defined in xml file function calls PerformDemoCase.
        /// </summary>
        /// <param name="log">Into this interface demo writes output to be displayed</param>
        /// <param name="demoSettingsXmlFile">Xml file containing definitions of demo cases to be prformed</param>
        public static void RunDemo(IOutputLog log, string demoSettingsXmlFile)
        {
            log.Write("State Machine demo started", false);
            //Instantiate demo settings from the xml file
            DemoSettings demoSettings = new DemoSettings(demoSettingsXmlFile);

            //Loop through all demo cases
            foreach (DemoSettings.CaseSettings demoCaseParams in demoSettings.CaseCfgCollection)
            {
                //Execute the demo case
                PerformDemoCase(log, demoCaseParams);
            }
            log.Write("State Machine demo finished", false);
            log.Write(string.Empty);
            return;
        }
コード例 #3
0
ファイル: SMDemo.cs プロジェクト: HDUfang/NET
        /// <summary>
        /// Runs State Machine demo. This is the main function.
        /// For each demo case defined in xml file function calls PerformDemoCase.
        /// </summary>
        /// <param name="log">Into this interface demo writes output to be displayed</param>
        /// <param name="demoSettingsXmlFile">Xml file containing definitions of demo cases to be prformed</param>
        public static void RunDemo(IOutputLog log, string demoSettingsXmlFile)
        {
            log.Write("State Machine demo started");
            //Instantiate demo settings from the xml file
            DemoSettings demoSettings = new DemoSettings(demoSettingsXmlFile);
            //Loop through all demo cases
            Stopwatch sw = new Stopwatch();

            foreach (DemoSettings.CaseSettings demoCaseParams in demoSettings.CaseCfgCollection)
            {
                sw.Reset();
                sw.Start();
                //Execute the demo case
                PerformDemoCase(log, demoCaseParams);
                sw.Stop();
                TimeSpan ts = sw.Elapsed;
                log.Write("Run time of demo case: " + String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10));
                log.Write(string.Empty);
                log.Write(string.Empty);
            }
            log.Write("State Machine demo finished");
            log.Write(string.Empty);
            return;
        }
コード例 #4
0
        /// <summary>
        /// Performs specified demo case.
        /// Loads and prepares sample data, trains State Machine and displayes results
        /// </summary>
        /// <param name="log">Into this interface are written output messages</param>
        /// <param name="demoCaseParams">An instance of DemoSettings.CaseSettings to be performed</param>
        public static void PerformDemoCase(IOutputLog log, DemoSettings.CaseSettings demoCaseParams)
        {
            //For demo purposes is allowed only the normalization range (-1, 1)
            Interval normRange = new Interval(-1, 1);

            log.Write("  Performing demo case " + demoCaseParams.Name, false);

            //Bundle normalizer object
            BundleNormalizer bundleNormalizer = null;

            //Prediction input vector (relevant only for time series prediction task)
            double[] predictionInputVector = null;

            //Instantiate an State Machine
            StateMachine stateMachine = new StateMachine(demoCaseParams.stateMachineCfg, normRange);

            //Prepare regression stage input object
            log.Write(" ", false);
            StateMachine.RegressionStageInput rsi = null;
            if (demoCaseParams.stateMachineCfg.TaskType == CommonEnums.TaskType.Prediction)
            {
                //Time series prediction task
                //Load data bundle from csv file
                TimeSeriesBundle data = TimeSeriesDataLoader.Load(demoCaseParams.FileName,
                                                                  demoCaseParams.stateMachineCfg.InputFieldNameCollection,
                                                                  demoCaseParams.stateMachineCfg.ReadoutLayerConfig.OutputFieldNameCollection,
                                                                  normRange,
                                                                  demoCaseParams.NormalizerReserveRatio,
                                                                  true,
                                                                  demoCaseParams.SingleNormalizer,
                                                                  out bundleNormalizer,
                                                                  out predictionInputVector
                                                                  );
                rsi = stateMachine.PrepareRegressionStageInput(data, demoCaseParams.NumOfBootSamples, PredictorsCollectionCallback, log);
            }
            else
            {
                //Classification or hybrid task
                //Load data bundle from csv file
                PatternBundle data = PatternDataLoader.Load(demoCaseParams.stateMachineCfg.TaskType == CommonEnums.TaskType.Classification,
                                                            demoCaseParams.FileName,
                                                            demoCaseParams.stateMachineCfg.InputFieldNameCollection,
                                                            demoCaseParams.stateMachineCfg.ReadoutLayerConfig.OutputFieldNameCollection,
                                                            normRange,
                                                            demoCaseParams.NormalizerReserveRatio,
                                                            true,
                                                            out bundleNormalizer
                                                            );
                rsi = stateMachine.PrepareRegressionStageInput(data, PredictorsCollectionCallback, log);
            }
            //Report reservoirs statistics
            ReportReservoirsStatistics(rsi.ReservoirStatCollection, log);

            //Regression stage
            log.Write("    Regression stage", false);
            //Training - State Machine regression stage
            ValidationBundle vb = stateMachine.RegressionStage(rsi, RegressionControl, log);

            //Perform prediction if the task type is Prediction
            double[] predictionOutputVector = null;
            if (demoCaseParams.stateMachineCfg.TaskType == CommonEnums.TaskType.Prediction)
            {
                predictionOutputVector = stateMachine.Compute(predictionInputVector);
                //Values are normalized so they have to be denormalized
                bundleNormalizer.NaturalizeOutputVector(predictionOutputVector);
            }

            //Display results
            //Report training (regression) results and prediction
            log.Write("    Results", false);
            List <ReadoutLayer.ClusterErrStatistics> clusterErrStatisticsCollection = stateMachine.ClusterErrStatisticsCollection;

            //Classification results
            for (int outputIdx = 0; outputIdx < demoCaseParams.stateMachineCfg.ReadoutLayerConfig.OutputFieldNameCollection.Count; outputIdx++)
            {
                ReadoutLayer.ClusterErrStatistics ces = clusterErrStatisticsCollection[outputIdx];
                if (demoCaseParams.stateMachineCfg.TaskType == CommonEnums.TaskType.Classification)
                {
                    //Classification task report
                    log.Write("            OutputField: " + demoCaseParams.stateMachineCfg.ReadoutLayerConfig.OutputFieldNameCollection[outputIdx], false);
                    log.Write("   Num of bin 0 samples: " + ces.BinaryErrStat.BinValErrStat[0].NumOfSamples.ToString(), false);
                    log.Write("     Bad bin 0 classif.: " + ces.BinaryErrStat.BinValErrStat[0].Sum.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("       Bin 0 error rate: " + ces.BinaryErrStat.BinValErrStat[0].ArithAvg.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("         Bin 0 accuracy: " + (1 - ces.BinaryErrStat.BinValErrStat[0].ArithAvg).ToString(CultureInfo.InvariantCulture), false);
                    log.Write("   Num of bin 1 samples: " + ces.BinaryErrStat.BinValErrStat[1].NumOfSamples.ToString(), false);
                    log.Write("     Bad bin 1 classif.: " + ces.BinaryErrStat.BinValErrStat[1].Sum.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("       Bin 1 error rate: " + ces.BinaryErrStat.BinValErrStat[1].ArithAvg.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("         Bin 1 accuracy: " + (1 - ces.BinaryErrStat.BinValErrStat[1].ArithAvg).ToString(CultureInfo.InvariantCulture), false);
                    log.Write("   Total num of samples: " + ces.BinaryErrStat.TotalErrStat.NumOfSamples.ToString(), false);
                    log.Write("     Total bad classif.: " + ces.BinaryErrStat.TotalErrStat.Sum.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("       Total error rate: " + ces.BinaryErrStat.TotalErrStat.ArithAvg.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("         Total accuracy: " + (1 - ces.BinaryErrStat.TotalErrStat.ArithAvg).ToString(CultureInfo.InvariantCulture), false);
                }
                else
                {
                    //Prediction task report
                    log.Write("            OutputField: " + demoCaseParams.stateMachineCfg.ReadoutLayerConfig.OutputFieldNameCollection[outputIdx], false);
                    log.Write("   Predicted next value: " + predictionOutputVector[outputIdx].ToString(CultureInfo.InvariantCulture), false);
                    log.Write("   Total num of samples: " + ces.PrecissionErrStat.NumOfSamples.ToString(), false);
                    log.Write("     Total Max Real Err: " + (bundleNormalizer.OutputFieldNormalizerRefCollection[outputIdx].ComputeNaturalSpan(ces.PrecissionErrStat.Max)).ToString(CultureInfo.InvariantCulture), false);
                    log.Write("     Total Avg Real Err: " + (bundleNormalizer.OutputFieldNormalizerRefCollection[outputIdx].ComputeNaturalSpan(ces.PrecissionErrStat.ArithAvg)).ToString(CultureInfo.InvariantCulture), false);
                }
                log.Write(" ", false);
            }
            log.Write(" ", false);
            return;
        }
コード例 #5
0
 /// <summary>
 /// Function simply displays important statistics of the State Machine's reservoirs.
 /// </summary>
 /// <param name="statisticsCollection">Collection of reservoir's statistics</param>
 /// <param name="log">Output log object</param>
 private static void ReportReservoirsStatistics(List <ReservoirStat> statisticsCollection, IOutputLog log)
 {
     log.Write("    Reservoir(s) info:", false);
     foreach (ReservoirStat resStat in statisticsCollection)
     {
         log.Write($"      Statistics of reservoir instance: {resStat.ReservoirInstanceName} ({resStat.ReservoirSettingsName})", false);
         foreach (ReservoirStat.PoolStat poolStat in resStat.PoolStatCollection)
         {
             log.Write($"        Statistics of pool: {poolStat.PoolName}", false);
             foreach (ReservoirStat.PoolStat.NeuronGroupStat groupStat in poolStat.NeuronGroupStatCollection)
             {
                 log.Write($"          Statistics of group: {groupStat.GroupName}", false);
                 log.Write($"            Neurons stimulation (all components)", false);
                 log.Write("              AVG Avg, Max, Min, SDdev: " + groupStat.AvgTStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgTStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgTStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgTStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MAX Avg, Max, Min, SDdev: " + groupStat.MaxTStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxTStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxTStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxTStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MIN Avg, Max, Min, SDdev: " + groupStat.MinTStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinTStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinTStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinTStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("             SPAN Avg, Max, Min, SDdev: " + groupStat.TStimuliSpansStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.TStimuliSpansStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.TStimuliSpansStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.TStimuliSpansStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write($"            Neurons stimulation (component coming from connected reservoir's neurons)", false);
                 log.Write("              AVG Avg, Max, Min, SDdev: " + groupStat.AvgRStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgRStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgRStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgRStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MAX Avg, Max, Min, SDdev: " + groupStat.MaxRStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxRStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxRStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxRStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MIN Avg, Max, Min, SDdev: " + groupStat.MinRStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinRStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinRStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinRStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("             SPAN Avg, Max, Min, SDdev: " + groupStat.RStimuliSpansStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.RStimuliSpansStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.RStimuliSpansStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.RStimuliSpansStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write($"            Synapses efficacy", false);
                 log.Write("              AVG Avg, Max, Min, SDdev: " + groupStat.AvgSynEfficacyStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgSynEfficacyStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgSynEfficacyStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgSynEfficacyStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MAX Avg, Max, Min, SDdev: " + groupStat.MaxSynEfficacyStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxSynEfficacyStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxSynEfficacyStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxSynEfficacyStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MIN Avg, Max, Min, SDdev: " + groupStat.MinSynEfficacyStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinSynEfficacyStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinSynEfficacyStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinSynEfficacyStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("             SPAN Avg, Max, Min, SDdev: " + groupStat.SynEfficacySpansStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.SynEfficacySpansStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.SynEfficacySpansStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.SynEfficacySpansStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write($"            Activations state", false);
                 log.Write("              AVG Avg, Max, Min, SDdev: " + groupStat.AvgActivationStatesStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgActivationStatesStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgActivationStatesStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgActivationStatesStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MAX Avg, Max, Min, SDdev: " + groupStat.MaxActivationStatesStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxActivationStatesStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxActivationStatesStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxActivationStatesStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("             SPAN Avg, Max, Min, SDdev: " + groupStat.ActivationStateSpansStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.ActivationStateSpansStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.ActivationStateSpansStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.ActivationStateSpansStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write($"            Neurons output signal", false);
                 log.Write("              AVG Avg, Max, Min, SDdev: " + groupStat.AvgOutputSignalStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgOutputSignalStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgOutputSignalStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.AvgOutputSignalStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MAX Avg, Max, Min, SDdev: " + groupStat.MaxOutputSignalStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxOutputSignalStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxOutputSignalStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MaxOutputSignalStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
                 log.Write("              MIN Avg, Max, Min, SDdev: " + groupStat.MinOutputSignalStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinOutputSignalStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinOutputSignalStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                           + groupStat.MinOutputSignalStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             }
             log.Write($"          Weights statistics", false);
             log.Write("            Input Avg, Max, Min, SDdev: " + poolStat.InputWeightsStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InputWeightsStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InputWeightsStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InputWeightsStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("         Internal Avg, Max, Min, SDdev: " + poolStat.InternalWeightsStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InternalWeightsStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InternalWeightsStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InternalWeightsStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
         }
     }
     log.Write(" ", false);
     //Console.ReadLine();
     return;
 }
コード例 #6
0
        /// <summary>
        /// Performs one demo case.
        /// Loads and prepares sample data, trains State Machine and displayes results
        /// </summary>
        /// <param name="log">Into this interface are written output messages</param>
        /// <param name="demoCaseParams">An instance of DemoSettings.CaseSettings to be performed</param>
        public static void PerformDemoCase(IOutputLog log, DemoSettings.CaseSettings demoCaseParams)
        {
            log.Write("  Performing demo case " + demoCaseParams.Name, false);
            //Bundle normalizer object
            BundleNormalizer bundleNormalizer = null;

            //Prediction input vector (relevant only for input continuous feeding)
            double[] predictionInputVector = null;
            //Instantiate the State Machine
            StateMachine stateMachine = new StateMachine(demoCaseParams.StateMachineCfg);

            //Prepare input object for regression stage
            log.Write(" ", false);
            StateMachine.RegressionStageInput rsi   = null;
            List <string> outputFieldNameCollection = (from rus in demoCaseParams.StateMachineCfg.ReadoutLayerConfig.ReadoutUnitCfgCollection select rus.Name).ToList();
            List <CommonEnums.TaskType> outputFieldTaskCollection = (from rus in demoCaseParams.StateMachineCfg.ReadoutLayerConfig.ReadoutUnitCfgCollection select rus.TaskType).ToList();

            if (demoCaseParams.StateMachineCfg.InputConfig.FeedingType == CommonEnums.InputFeedingType.Continuous)
            {
                //Continuous input feeding
                //Load data bundle from csv file
                TimeSeriesBundle data = TimeSeriesBundle.LoadFromCsv(demoCaseParams.FileName,
                                                                     demoCaseParams.StateMachineCfg.InputConfig.ExternalFieldNameCollection(),
                                                                     outputFieldNameCollection,
                                                                     outputFieldTaskCollection,
                                                                     StateMachine.DataRange,
                                                                     demoCaseParams.NormalizerReserveRatio,
                                                                     true,
                                                                     out bundleNormalizer,
                                                                     out predictionInputVector
                                                                     );
                rsi = stateMachine.PrepareRegressionStageInput(data, PredictorsCollectionCallback, log);
            }
            else
            {
                //Patterned input feeding
                //Load data bundle from csv file
                PatternBundle data = PatternBundle.LoadFromCsv(demoCaseParams.FileName,
                                                               demoCaseParams.StateMachineCfg.InputConfig.ExternalFieldNameCollection(),
                                                               outputFieldNameCollection,
                                                               outputFieldTaskCollection,
                                                               StateMachine.DataRange,
                                                               demoCaseParams.NormalizerReserveRatio,
                                                               true,
                                                               out bundleNormalizer
                                                               );
                rsi = stateMachine.PrepareRegressionStageInput(data, PredictorsCollectionCallback, log);
            }
            //Report statistics of the State Machine's reservoirs
            ReportReservoirsStatistics(rsi.ReservoirStatCollection, log);

            //Regression stage
            log.Write("    Regression stage", false);
            //Perform the regression
            ValidationBundle vb = stateMachine.RegressionStage(rsi, RegressionControl, log);

            //Perform prediction if the input feeding is continuous (we know the input but we don't know the ideal output)
            double[] predictionOutputVector = null;
            if (demoCaseParams.StateMachineCfg.InputConfig.FeedingType == CommonEnums.InputFeedingType.Continuous)
            {
                predictionOutputVector = stateMachine.Compute(predictionInputVector);
                //Values are normalized so they have to be denormalized
                bundleNormalizer.NaturalizeOutputVector(predictionOutputVector);
            }

            //Display results
            //Report training (regression) results and prediction
            log.Write("    Results", false);
            List <ReadoutLayer.ClusterErrStatistics> clusterErrStatisticsCollection = stateMachine.ClusterErrStatisticsCollection;

            //Results
            for (int outputIdx = 0; outputIdx < demoCaseParams.StateMachineCfg.ReadoutLayerConfig.ReadoutUnitCfgCollection.Count; outputIdx++)
            {
                ReadoutLayer.ClusterErrStatistics ces = clusterErrStatisticsCollection[outputIdx];
                if (demoCaseParams.StateMachineCfg.ReadoutLayerConfig.ReadoutUnitCfgCollection[outputIdx].TaskType == CommonEnums.TaskType.Classification)
                {
                    //Classification task report
                    log.Write("            OutputField: " + demoCaseParams.StateMachineCfg.ReadoutLayerConfig.ReadoutUnitCfgCollection[outputIdx].Name, false);
                    log.Write("   Num of bin 0 samples: " + ces.BinaryErrStat.BinValErrStat[0].NumOfSamples.ToString(), false);
                    log.Write("     Bad bin 0 classif.: " + ces.BinaryErrStat.BinValErrStat[0].Sum.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("       Bin 0 error rate: " + ces.BinaryErrStat.BinValErrStat[0].ArithAvg.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("         Bin 0 accuracy: " + (1 - ces.BinaryErrStat.BinValErrStat[0].ArithAvg).ToString(CultureInfo.InvariantCulture), false);
                    log.Write("   Num of bin 1 samples: " + ces.BinaryErrStat.BinValErrStat[1].NumOfSamples.ToString(), false);
                    log.Write("     Bad bin 1 classif.: " + ces.BinaryErrStat.BinValErrStat[1].Sum.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("       Bin 1 error rate: " + ces.BinaryErrStat.BinValErrStat[1].ArithAvg.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("         Bin 1 accuracy: " + (1 - ces.BinaryErrStat.BinValErrStat[1].ArithAvg).ToString(CultureInfo.InvariantCulture), false);
                    log.Write("   Total num of samples: " + ces.BinaryErrStat.TotalErrStat.NumOfSamples.ToString(), false);
                    log.Write("     Total bad classif.: " + ces.BinaryErrStat.TotalErrStat.Sum.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("       Total error rate: " + ces.BinaryErrStat.TotalErrStat.ArithAvg.ToString(CultureInfo.InvariantCulture), false);
                    log.Write("         Total accuracy: " + (1 - ces.BinaryErrStat.TotalErrStat.ArithAvg).ToString(CultureInfo.InvariantCulture), false);
                }
                else
                {
                    //Forecast task report
                    log.Write("            OutputField: " + demoCaseParams.StateMachineCfg.ReadoutLayerConfig.ReadoutUnitCfgCollection[outputIdx].Name, false);
                    log.Write("   Predicted next value: " + predictionOutputVector[outputIdx].ToString(CultureInfo.InvariantCulture), false);
                    log.Write("   Total num of samples: " + ces.PrecissionErrStat.NumOfSamples.ToString(), false);
                    log.Write("     Total Max Real Err: " + (bundleNormalizer.OutputFieldNormalizerRefCollection[outputIdx].ComputeNaturalSpan(ces.PrecissionErrStat.Max)).ToString(CultureInfo.InvariantCulture), false);
                    log.Write("     Total Avg Real Err: " + (bundleNormalizer.OutputFieldNormalizerRefCollection[outputIdx].ComputeNaturalSpan(ces.PrecissionErrStat.ArithAvg)).ToString(CultureInfo.InvariantCulture), false);
                }
                log.Write(" ", false);
            }
            log.Write(" ", false);
            return;
        }
コード例 #7
0
 public Monitor(IConfigProvider configProvider, IOutputLog outputLog)
 {
     _configProvider = configProvider;
     _outputLog      = outputLog;
 }
コード例 #8
0
 //Constructor
 protected ExampleBase()
 {
     _log = new ConsoleLog();
     return;
 }
コード例 #9
0
ファイル: SMDemo.cs プロジェクト: HDUfang/NET
        /// <summary>
        /// Performs one demo case.
        /// Loads and prepares sample data, trains State Machine and displayes results
        /// </summary>
        /// <param name="log">Into this interface are written output messages</param>
        /// <param name="demoCaseParams">An instance of DemoSettings.CaseSettings to be performed</param>
        public static void PerformDemoCase(IOutputLog log, DemoSettings.CaseSettings demoCaseParams)
        {
            log.Write("  Performing demo case " + demoCaseParams.Name, false);
            log.Write(" ", false);
            //Instantiate the State Machine
            StateMachine stateMachine = new StateMachine(demoCaseParams.StateMachineCfg);

            //Prepare input object for regression stage
            StateMachine.RegressionInput rsi = null;
            //Prediction input vector (relevant only for input continuous feeding)
            double[] predictionInputVector = null;
            if (demoCaseParams.StateMachineCfg.NeuralPreprocessorConfig.InputConfig.FeedingType == NeuralPreprocessor.InputFeedingType.Continuous)
            {
                //Continuous input feeding
                //Load data bundle from csv file
                VectorBundle data = VectorBundle.LoadFromCsv(demoCaseParams.FileName,
                                                             demoCaseParams.StateMachineCfg.NeuralPreprocessorConfig.InputConfig.ExternalFieldNameCollection(),
                                                             demoCaseParams.StateMachineCfg.ReadoutLayerConfig.OutputFieldNameCollection,
                                                             out predictionInputVector
                                                             );
                rsi = stateMachine.PrepareRegressionData(data, PredictorsCollectionCallback, log);
            }
            else
            {
                //Patterned input feeding
                //Load data bundle from csv file
                PatternBundle data = PatternBundle.LoadFromCsv(demoCaseParams.FileName,
                                                               demoCaseParams.StateMachineCfg.NeuralPreprocessorConfig.InputConfig.ExternalFieldNameCollection(),
                                                               demoCaseParams.StateMachineCfg.ReadoutLayerConfig.OutputFieldNameCollection
                                                               );
                rsi = stateMachine.PrepareRegressionData(data, PredictorsCollectionCallback, log);
            }
            //Report key statistics of the State Machine's reservoirs
            string statisticsReport = rsi.CreateReport(4);

            log.Write(statisticsReport);
            log.Write(string.Empty);

            //Regression stage - building of trained readout layer
            log.Write("    Regression stage (training of readout layer)", false);
            //Perform the regression
            ResultBundle rcb = stateMachine.BuildReadoutLayer(rsi, RegressionControl, log);

            log.Write(string.Empty);

            //Report training (regression) results
            log.Write("    Training results", false);
            string trainingReport = stateMachine.RL.GetTrainingResultsReport(6);

            log.Write(trainingReport);
            log.Write(string.Empty);

            //Perform prediction if the input feeding is continuous (we know the input but we don't know the ideal output)
            if (demoCaseParams.StateMachineCfg.NeuralPreprocessorConfig.InputConfig.FeedingType == NeuralPreprocessor.InputFeedingType.Continuous)
            {
                double[] predictionOutputVector = stateMachine.Compute(predictionInputVector);
                string   predictionReport       = stateMachine.RL.GetForecastReport(predictionOutputVector, 6);
                log.Write("    Forecasts", false);
                log.Write(predictionReport);
                log.Write(string.Empty);
            }
            return;
        }
コード例 #10
0
ファイル: SMDemo.cs プロジェクト: thild/NET
 //Constructor
 public SMDemo(IOutputLog log)
 {
     _log = log;
     return;
 }
コード例 #11
0
 void CmdUnlock(string command, ITMGame game, ITMPlayer caller, ITMPlayer player, IOutputLog log)
 {
     OnLockpickSwing(Items.Lockpick, player.RightHand);
 }
コード例 #12
0
 public Sensor(IMetricsProvider metricPovider, ITCPSender client, IOutputLog outputLog)
 {
     _client        = client;
     _metricPovider = metricPovider;
     _outputLog     = outputLog;
 }
コード例 #13
0
        private void ConsoleCommand(string str, ITMGame game, ITMPlayer player1, ITMPlayer player2, IOutputLog log)
        {
            str = str.ToLower();
            string[] commands = str.Split(' ');

            if (commands.Length > 1)
            {
                switch (commands[1])
                {
                case "help": log.WriteLine(QuickGatherHelp(commands)); break;

                case "toggleveinmine": log.WriteLine(ToggleVeinMining()); break;

                case "togglelumberjack": log.WriteLine(ToggleLumberJack()); break;

                case "toggleharvest": log.WriteLine(ToggleHarvesting()); break;

                case "saveconfig": log.WriteLine(SaveConfigs()); break;

                case "ver": log.WriteLine(GetVersion()); break;

                case "version": log.WriteLine(GetVersion()); break;

                default: log.WriteLine("Unknown Command use 'qg help' for more info"); break;
                }
            }
            else
            {
                log.WriteLine("Unknown Command use 'qg help' for help");
            }
        }
コード例 #14
0
 public TcpClientWrap(TcpClient client, IOutputLog output)
 {
     _client = client;
     _stream = _client.GetStream();
     _output = output;
 }
コード例 #15
0
 public TCPSender(TcpClient client, IOutputLog output)
     : base(client, output)
 {
     _output = output;
 }
コード例 #16
0
 /// <summary>
 /// Function displays reservoirs statistics.
 /// </summary>
 /// <param name="statisticsCollection">Collection of reservoir statistics</param>
 /// <param name="log">Output log object</param>
 private static void ReportReservoirsStatistics(List <ReservoirStat> statisticsCollection, IOutputLog log)
 {
     log.Write("    Reservoir(s) info:", false);
     foreach (ReservoirStat resStat in statisticsCollection)
     {
         log.Write($"      Statistics of reservoir instance: {resStat.ReservoirInstanceName} ({resStat.ReservoirSettingsName})", false);
         foreach (ReservoirStat.PoolStat poolStat in resStat.PoolStatCollection)
         {
             log.Write($"        Statistics of pool instance: {poolStat.PoolInstanceName}", false);
             log.Write($"          Neurons states", false);
             log.Write("                  AVG Avg, Max, Min, SDdev: " + poolStat.NeuronsAvgStatesStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgStatesStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgStatesStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgStatesStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("                  MAX Avg, Max, Min, SDdev: " + poolStat.NeuronsMaxStatesStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxStatesStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxStatesStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxStatesStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("                 SPAN Avg, Max, Min, SDdev: " + poolStat.NeuronsStateSpansStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsStateSpansStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsStateSpansStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsStateSpansStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write($"          Neurons stimuli", false);
             log.Write("                  AVG Avg, Max, Min, SDdev: " + poolStat.NeuronsAvgStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("                  MAX Avg, Max, Min, SDdev: " + poolStat.NeuronsMaxStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("                  MIN Avg, Max, Min, SDdev: " + poolStat.NeuronsMinStimuliStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMinStimuliStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMinStimuliStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMinStimuliStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("                 SPAN Avg, Max, Min, SDdev: " + poolStat.NeuronsStimuliSpansStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsStimuliSpansStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsStimuliSpansStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsStimuliSpansStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write($"          Neurons transmission signals", false);
             log.Write("                  AVG Avg, Max, Min, SDdev: " + poolStat.NeuronsAvgTransmissionSignalStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgTransmissionSignalStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgTransmissionSignalStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgTransmissionSignalStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("                  MAX Avg, Max, Min, SDdev: " + poolStat.NeuronsMaxTransmissionSignalStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxTransmissionSignalStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxTransmissionSignalStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMaxTransmissionSignalStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("                  MIN Avg, Max, Min, SDdev: " + poolStat.NeuronsMinTransmissionSignalStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMinTransmissionSignalStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMinTransmissionSignalStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsMinTransmissionSignalStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write($"          Neurons transmission frequencies", false);
             log.Write("                  AVG Avg, Max, Min, SDdev: " + poolStat.NeuronsAvgTransmissionFreqStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgTransmissionFreqStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgTransmissionFreqStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.NeuronsAvgTransmissionFreqStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write($"          Weights statistics", false);
             log.Write("                Input Avg, Max, Min, SDdev: " + poolStat.InputWeightsStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InputWeightsStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InputWeightsStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InputWeightsStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
             log.Write("             Internal Avg, Max, Min, SDdev: " + poolStat.InternalWeightsStat.ArithAvg.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InternalWeightsStat.Max.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InternalWeightsStat.Min.ToString("N4", CultureInfo.InvariantCulture) + ", "
                       + poolStat.InternalWeightsStat.StdDev.ToString("N4", CultureInfo.InvariantCulture), false);
         }
     }
     log.Write(" ", false);
     //Console.ReadLine();
     return;
 }
コード例 #17
0
 public TCPReciever(TcpClient client, IOutputLog output)
     : base(client, output)
 {
     _output = output;
 }
コード例 #18
0
 public OSAPI(IOutputLog log)
 {
     this.log = log;
 }