public ResultOfTraining GetResultOfTraining(ref float[][] dataSet)
        {
            var xResult =
                GetWeight(ref dataSet, RungeKuttaService.ValuesEnum.X);
            var yResult =
                GetWeight(ref dataSet, RungeKuttaService.ValuesEnum.Y);
            var zResult =
                GetWeight(ref dataSet, RungeKuttaService.ValuesEnum.Z);

            var resultGroup =
                new ResultOfTraining
            {
                XResult = xResult,
                YResult = yResult,
                ZResult = zResult
            };

            return(resultGroup);
        }
示例#2
0
        private void learnButton_Click(object sender, EventArgs e)
        {
            int sampleCount = _pointsDataAccess.GetDataSetSize();

            float[][] dataSet = new float[sampleCount][];
            Array.Copy(Points.ToArray(), dataSet, sampleCount);

            ResultOfTraining resultOfTraining = _singlePerceptronService.GetResultOfTraining(ref dataSet);

            PointsAfterTraining.Add(new [] { dataSet[0][0], dataSet[0][1], dataSet[0][2] });

            for (int i = 0; i < 1500; i++)
            {
                float generatedValueForX = PointsAfterTraining[i][0] * resultOfTraining.XResult.Weight1 +
                                           PointsAfterTraining[i][1] * resultOfTraining.XResult.Weight2 +
                                           PointsAfterTraining[i][2] * resultOfTraining.XResult.Weight3 -
                                           resultOfTraining.XResult.Threshold;

                float generatedValueForY = PointsAfterTraining[i][0] * resultOfTraining.YResult.Weight1 +
                                           PointsAfterTraining[i][1] * resultOfTraining.YResult.Weight2 +
                                           PointsAfterTraining[i][2] * resultOfTraining.YResult.Weight3 -
                                           resultOfTraining.YResult.Threshold;

                float generatedValueForZ = PointsAfterTraining[i][0] * resultOfTraining.ZResult.Weight1 +
                                           PointsAfterTraining[i][1] * resultOfTraining.ZResult.Weight2 +
                                           PointsAfterTraining[i][2] * resultOfTraining.ZResult.Weight3 -
                                           resultOfTraining.ZResult.Threshold;

                PointsAfterTraining.Add(new[]
                {
                    generatedValueForX,
                    generatedValueForY,
                    generatedValueForZ
                });
            }

            AddOutputValuesToListBoxes();
            trainingPointsOneDimensionForX = _rungeKuttaService.GenerateOneDimension(PointsAfterTraining.ToArray(), RungeKuttaService.ValuesEnum.X);
            trainingPointsOneDimensionForY = _rungeKuttaService.GenerateOneDimension(PointsAfterTraining.ToArray(), RungeKuttaService.ValuesEnum.Y);
            trainingPointsOneDimensionForZ = _rungeKuttaService.GenerateOneDimension(PointsAfterTraining.ToArray(), RungeKuttaService.ValuesEnum.Z);
        }