public void LoadCSVFileTrainingClass() { var path = parameters.TrainFile; var csvRead = new ReadCSV(new FileStream(path, FileMode.Open), true, CSVFormat.DecimalPoint); var values = new List <double[]>(); var classes = new List <double[]>(); while (csvRead.Next()) { values.Add(new double[2] { csvRead.GetDouble(0), csvRead.GetDouble(1) }); classes.Add(new double[1] { csvRead.GetDouble(2) }); } csvRead.Close(); var min = parameters.FunctionType == FunctionTypeEnum.Unipolar ? 0d : -1d; ArgNormalize = new NormalizedField[2] { new NormalizedField(NormalizationAction.Normalize, "X", values.Max(v => v[0]), values.Min(v => v[0]), 1.0, min), new NormalizedField(NormalizationAction.Normalize, "Y", values.Max(v => v[1]), values.Min(v => v[1]), 1.0, min) }; for (int i = 0; i < values.Count; i++) { for (int argc = 0; argc < values[i].Length; argc++) { values[i][argc] = ArgNormalize[argc].Normalize(values[i][argc]); } } //Normalization(values); classCount = classes.Select(c => c[0]).Distinct().Count(); var normalizeClasses = new List <double[]>(); for (int i = 0; i < classes.Count; ++i) { var newClasses = new double[classCount]; for (int j = 0; j < newClasses.Length; j++) { newClasses[j] = min; } newClasses[(int)classes[i][0] - 1] = 1;// dodoac normalizacje na -1 normalizeClasses.Add(newClasses); } var trainSetCount = (int)((double)values.Count * ((100.0 - 15) / 100)); values.Shuffle(); normalizeClasses.Shuffle(); MyExtensions.ResetStableShuffle(); TrainSet = new BasicNeuralDataSet(values.Take(trainSetCount).ToArray(), normalizeClasses.Take(trainSetCount).ToArray()); ValidationSet = new BasicNeuralDataSet(values.Skip(trainSetCount).ToArray(), normalizeClasses.Skip(trainSetCount).ToArray()); }
public PlanogramSimulation(BasicNetwork network, Item[] items, SimulationSettings simSettings) { slotNormalizer = new NormalizedField(NormalizationAction.Normalize, "Slot", (simSettings.NumSlots * simSettings.NumShelves) - 1, 0, -1, 1); itemNormalizer = new NormalizedField(NormalizationAction.Normalize, "Item", items.Length - 1, 0, -1, 1); this.items = items; this.simSettings = simSettings; this.network = network; }
/// <summary> /// Construct the training generator. /// </summary> /// <param name="thePath">The path to use.</param> public GenerateTraining(string thePath) { _path = thePath; _trainingFile = FileUtil.CombinePath(new FileInfo(_path), Config.FilenameTrain); _fieldDifference = new NormalizedField(NormalizationAction.Normalize, "diff", Config.DiffRange, -Config.DiffRange, 1, -1); _fieldOutcome = new NormalizedField(NormalizationAction.Normalize, "out", Config.PipRange, -Config.PipRange, 1, -1); }
public NeuralPilot(BasicNetwork network, bool track) { _fuelStats = new NormalizedField(NormalizationAction.Normalize, "fuel", 200, 0, -0.9, 0.9); _altitudeStats = new NormalizedField(NormalizationAction.Normalize, "altitude", 10000, 0, -0.9, 0.9); _velocityStats = new NormalizedField(NormalizationAction.Normalize, "velocity", LanderSimulator.TerminalVelocity, -LanderSimulator.TerminalVelocity, -0.9, 0.9); _track = track; _network = network; }
public EncogMazeTraveler(BasicNetwork network, MazeInfo maze) { this.network = network; this.maze = maze; // set normalized fields xInput = new NormalizedField(NormalizationAction.Normalize, "X", maze.Width - 1, 0, -0.9, 0.9); yInput = new NormalizedField(NormalizationAction.Normalize, "Y", maze.Height - 1, 0, -0.9, 0.9); bumpedIntoWallInput = new NormalizedField(NormalizationAction.Normalize, "BumpedIntoWall", 1, 0, -0.9, 0.9); directionOutput = new NormalizedField(NormalizationAction.Normalize, "Direction", 3, 0, -0.9, 0.9); tmr.Elapsed += Tmr_Elapsed; }
/// <summary> /// Construct the indicator. /// </summary> /// <param name="theMethod">The machine learning method to use.</param> /// <param name="thePath">The path to use.</param> public MyInd(IMLRegression theMethod, string thePath) : base(theMethod != null) { _method = theMethod; _path = thePath; RequestData("CLOSE[1]"); RequestData("SMA(10)[" + Config.InputWindow + "]"); RequestData("SMA(25)[" + Config.InputWindow + "]"); _fieldDifference = new NormalizedField(NormalizationAction.Normalize, "diff", Config.DiffRange, -Config.DiffRange, 1, -1); _fieldOutcome = new NormalizedField(NormalizationAction.Normalize, "out", Config.PipRange, -Config.PipRange, 1, -1); }
public void Execute(IExampleInterface app) { // Normalize values with an actual range of (0 to 100) to (-1 to 1) var norm = new NormalizedField(NormalizationAction.Normalize, null, 100, 0, 1, -1); double x = 5; double y = norm.Normalize(x); Console.WriteLine(x + @" normalized is " + y); double z = norm.DeNormalize(y); Console.WriteLine(y + @" denormalized is " + z); }
static void Normalization() { //Single value var weightNorm = new NormalizedField(NormalizationAction.Normalize, "Weights", ahigh: 40.0, alow: 50.0, nhigh: -1.0, nlow: 1.0); double normalizedValue = weightNorm.Normalize(42.5); double denormalizedValue = weightNorm.DeNormalize(normalizedValue); //Array double[] weights = new double[] { 40.0, 42.5, 43.0, 49.0, 50.0 }; var weightNorm2 = new NormalizeArray(); weightNorm2.NormalizedHigh = 1.0; weightNorm2.NormalizedLow = -1.0; double[] normalizedWeights = weightNorm2.Process(weights); }
public void LoadCSVFileTrainingRegg() { var path = parameters.TrainFile; var csvRead = new ReadCSV(new FileStream(path, FileMode.Open), true, CSVFormat.DecimalPoint); var valuesX = new List <double[]>(); var valuesY = new List <double[]>(); while (csvRead.Next()) { valuesX.Add(new double[1] { csvRead.GetDouble(0) }); valuesY.Add(new double[1] { csvRead.GetDouble(1) }); } csvRead.Close(); var min = parameters.FunctionType == FunctionTypeEnum.Unipolar ? 0d : -1d; ArgNormalize = new NormalizedField[] { new NormalizedField(NormalizationAction.Normalize, "X", valuesX.Max(v => v[0]), valuesX.Min(v => v[0]), 1.0, min) }; YNormalize = new NormalizedField(NormalizationAction.Normalize, "Y", valuesY.Max(v => v[0]), valuesY.Min(v => v[0]), 1.0, min); for (int i = 0; i < valuesX.Count; i++) { valuesX[i][0] = ArgNormalize[0].Normalize(valuesX[i][0]); valuesY[i][0] = YNormalize.Normalize(valuesY[i][0]); } //if(parameters.FunctionType==FunctionTypeEnum.Bipolar) // ansMeans = means[0]; //ansfactor = factor[0]; //ansMIn = Min[0]; var trainSetCount = (int)((double)valuesX.Count * ((100.0 - 15) / 100)); valuesX.Shuffle(); valuesY.Shuffle(); MyExtensions.ResetStableShuffle(); TrainSet = new BasicNeuralDataSet(valuesX.Take(trainSetCount).ToArray(), valuesY.Take(trainSetCount).ToArray()); ValidationSet = new BasicNeuralDataSet(valuesX.Skip(trainSetCount).ToArray(), valuesY.Skip(trainSetCount).ToArray()); }
public static double[][] GetValues <T>(this IList <IParamDefinition <T> > @params, IList <T> dataSource) { double[][] input = new double[dataSource.Count][]; for (int col = 0; col < @params.Count; col++) { NormalizedField _normalizedParam = new NormalizedField(NormalizationAction.Normalize, "Weights", @params[col].MaxValue, @params[col].MinValue, 1.0, -1.0); for (int row = 0; row < dataSource.Count; row++) { if (col == 0) { input[row] = new double[@params.Count]; } input[row][col] = Normalization.Normalize(@params[col].GetValue(dataSource[row], dataSource), _normalizedParam); } } return(input); }
/// <summary> /// Normalize the array. Return the new normalized array. /// </summary> /// /// <param name="inputArray">The input array.</param> /// <returns>The normalized array.</returns> public double[] Process(double[] inputArray) { _stats = new NormalizedField(); _stats.NormalizedHigh = _normalizedHigh; _stats.NormalizedLow = _normalizedLow; foreach (double element in inputArray) { _stats.Analyze(element); } var result = new double[inputArray.Length]; for (int i = 0; i < inputArray.Length; i++) { result[i] = _stats.Normalize(inputArray[i]); } return(result); }
/// <summary> /// Normalize the array. Return the new normalized array. /// </summary> /// <param name="inputArray">The input array.</param> /// <param name="low">The low of the normalized array.</param> /// <param name="high">The high of the normalized array..</param> /// <returns> /// The normalized array. /// </returns> public double[] Process(double[] inputArray, int low, int high) { this.NormalizedHigh = high; this.NormalizedLow = low; _stats = new NormalizedField(); _stats.NormalizedHigh = high; _stats.NormalizedLow = low; foreach (double element in inputArray) { _stats.Analyze(element); } var result = new double[inputArray.Length]; for (int i = 0; i < inputArray.Length; i++) { result[i] = _stats.Normalize(inputArray[i]); } return result; }
public static void initalize() { location = new NormalizedField(NormalizationAction.Normalize, "Location", -800, 800, -0.9, 0.9); speed = new NormalizedField(NormalizationAction.Normalize, "Speed", -10, 10, -0.9, 0.9); }
static void Main(string[] args) { double error = 0.00001; double[][] XOR_Input = { new[] { 0.0, 0.0 }, new[] { 1.0, 0.0 }, new[] { 0.0, 1.0 }, new[] { 1.0, 1.0 } }; double[][] XOR_Ideal = { new[] { 0.0 }, new[] { 1.0 }, new[] { 1.0 }, new[] { 0.0 } }; var trainingSet = new BasicMLDataSet(XOR_Input, XOR_Ideal); BasicNetwork network = CreateNetwork(); //var train = new Backpropagation(network, trainingSet, 0.7, 0.2); //var train = new ManhattanPropagation(network, trainingSet, 0.001); // var train = new QuickPropagation(network, trainingSet, 2.0); //var train = new ResilientPropagation(network, trainingSet); //var train = new ScaledConjugateGradient(network, trainingSet); var train = new LevenbergMarquardtTraining(network, trainingSet); int epoch = 0; do { train.Iteration(); Console.WriteLine("Iteration No: {0}, Error: {1}", ++epoch, train.Error); }while (train.Error > error); foreach (var item in trainingSet) { var output = network.Compute(item.Input); Console.WriteLine("Input: {0}, {1} \tIdeal: {2} \t Actual: {3}", item.Input[0], item.Input[1], item.Ideal[0], output[0]); } Console.WriteLine("Training done."); Console.WriteLine("press any key to continue"); Console.ReadLine(); // normalized value var weightNorm = new NormalizedField(NormalizationAction.Normalize, "Weights", 50.0, 40.0, 1.0, -1.0); double normalizedValue = weightNorm.Normalize(42.5); double denormalizedValue = weightNorm.DeNormalize(normalizedValue); Console.WriteLine("Normalized value: {0}", normalizedValue.ToString()); Console.WriteLine("press any key to continue"); Console.ReadLine(); // normalized array double[] weights = new double[] { 40.0, 42.5, 43.0, 49.0, 50.0 }; var weightNormArray = new NormalizeArray(); weightNormArray.NormalizedHigh = 1.0; weightNormArray.NormalizedLow = -1.0; double[] normalizedWeights = weightNormArray.Process(weights); foreach (var item in normalizedWeights) { Console.WriteLine("Normalized value: {0}", item.ToString()); } Console.WriteLine("press any key to continue"); Console.ReadLine(); }
public static double Normalize(double value, NormalizedField field) { return(field.Normalize(value)); }
public SnakeGame() { location = new NormalizedField(NormalizationAction.Normalize, "Location", 600, 0, -0.9, 0.9); speed = new NormalizedField(NormalizationAction.Normalize, "Speed", 20, -20, -0.9, 0.9); }