/// <summary> /// Generate the input to the neural network to predict. It will look at the current /// date as well as the number of days leading up to it specified by EvalWindow. /// This method is used both internally and externally. /// </summary> /// <param name="marketData">The market data to use.</param> /// <param name="marketDataIndex">The point that we want to predict from.</param> /// <returns></returns> public INeuralData CreateData( List<LoadedMarketData> marketData, int marketDataIndex) { INeuralData neuralData = new BasicNeuralData(14); int totalPatterns = 0; var patternCount = new int[14]; for (var i = 0; i < EvalWindow; i++) { var data = marketData[(marketDataIndex-EvalWindow) + i]; var candle = new IdentifyCandleStick(); candle.SetStats(data); var pattern = candle.DeterminePattern(); if (pattern == IdentifyCandleStick.UNKNOWN) continue; totalPatterns++; patternCount[pattern]++; } if (totalPatterns == 0) return null; for (var i = 0; i < 14; i++) { neuralData[i] = patternCount[i] / ((double)totalPatterns); } return neuralData; }
/// <summary> /// Construct a data set from an input and idea array. /// </summary> /// <param name="input">The input into the neural network for training.</param> /// <param name="ideal">The idea into the neural network for training.</param> public BasicNeuralDataSet(double[][] input, double[][] ideal) { for (int i = 0; i < input.Length; i++) { double[] tempInput = new double[input[0].Length]; double[] tempIdeal = null; for (int j = 0; j < tempInput.Length; j++) { tempInput[j] = input[i][j]; } BasicNeuralData idealData = null; if (ideal != null) { tempIdeal = new double[ideal[0].Length]; for (int j = 0; j < tempIdeal.Length; j++) { tempIdeal[j] = ideal[i][j]; } idealData = new BasicNeuralData(tempIdeal); } BasicNeuralData inputData = new BasicNeuralData(tempInput); this.Add(inputData, idealData); } }
/// <summary> /// Generate a random training set. /// </summary> /// <param name="seed">The seed value to use, the same seed value will always produce /// the same results.</param> /// <param name="count">How many training items to generate.</param> /// <param name="inputCount">How many input numbers.</param> /// <param name="idealCount">How many ideal numbers.</param> /// <param name="min">The minimum random number.</param> /// <param name="max">The maximum random number.</param> /// <returns>The random training set.</returns> public static BasicNeuralDataSet Generate(long seed, int count, int inputCount, int idealCount, double min, double max) { LinearCongruentialGenerator rand = new LinearCongruentialGenerator(seed); BasicNeuralDataSet result = new BasicNeuralDataSet(); for (int i = 0; i < count; i++) { INeuralData inputData = new BasicNeuralData(inputCount); for (int j = 0; j < inputCount; j++) { inputData.Data[j] = rand.Range(min, max); } INeuralData idealData = new BasicNeuralData(idealCount); for (int j = 0; j < idealCount; j++) { idealData[j] = rand.Range(min, max); } BasicNeuralDataPair pair = new BasicNeuralDataPair(inputData, idealData); result.Add(pair); } return result; }
/// <summary> /// Handle reading an item tag. /// </summary> /// <param name="xmlIn">The XML reader.</param> private void HandleItem(ReadXML xmlIn) { IDictionary<String, String> properties = xmlIn.ReadPropertyBlock(); INeuralDataPair pair = null; INeuralData input = new BasicNeuralData(NumberList .FromList(CSVFormat.EG_FORMAT, properties [BasicNeuralDataSetPersistor.TAG_INPUT])); if (properties.ContainsKey(BasicNeuralDataSetPersistor.TAG_IDEAL)) { // supervised INeuralData ideal = new BasicNeuralData(NumberList .FromList(CSVFormat.EG_FORMAT, properties [BasicNeuralDataSetPersistor.TAG_IDEAL])); pair = new BasicNeuralDataPair(input, ideal); } else { // unsupervised pair = new BasicNeuralDataPair(input); } this.currentDataSet.Add(pair); }
/// <inheritdoc/> public void Compute(double[] input, double[] output) { BasicNeuralData input2 = new BasicNeuralData(input); INeuralData output2 = this.Compute(input2); EngineArray.ArrayCopy(output2.Data, output); }
/// <summary> /// Compute the output for the given input. /// </summary> /// <param name="input">The input to the SVM.</param> /// <returns>The results from the SVM.</returns> public override INeuralData Compute(INeuralData input) { INeuralData result = new BasicNeuralData(this.outputCount); svm_node[] formattedInput = MakeSparse(input); for (int i = 0; i < this.outputCount; i++) { double d = svm.svm_predict(this.models[i], formattedInput); result[i] = d; } return result; }
public virtual BasicNeuralData GenerateInputNeuralData(int index) { BasicNeuralData data; int num; int num2; if ((index + this._xc278386c02fd6e51) <= this._x6fa2570084b2ad39.Count) { data = new BasicNeuralData(this._x57202a8751db8895); num = 0; num2 = 0; goto Label_007B; } if ((((uint) index) & 0) == 0) { if ((((uint) num) & 0) == 0) { throw new TemporalError("Can't generate input temporal data beyond the end of provided data."); } goto Label_0077; } Label_002C: foreach (TemporalDataDescription description in this._x6849a3dfb0329317) { if (description.IsInput) { data[num++] = this.x8c7fc30b887213d1(description, index + num2); } } Label_0077: num2++; Label_007B: if (num2 < this._xc278386c02fd6e51) { goto Label_002C; } return data; }
/// <summary> /// Mencari solusi model neural network /// </summary> private void searchSolution() { // Normalize Data switch (this.selectedActivationFunction) { case ActivationFunctionEnumeration.SemiLinearFunction: this.activationFunction = new SemiLinearFunction(); this.normalizeData(0.1, 0.9); break; case ActivationFunctionEnumeration.SigmoidFunction: this.activationFunction = new SigmoidFunction(); this.normalizeData(0.1, 0.9); break; case ActivationFunctionEnumeration.BipolarSigmoidFunction: this.activationFunction = new BipolarSigmoidFunction(); this.normalizeData(-0.9, 0.9); break; case ActivationFunctionEnumeration.HyperbolicTangentFunction: this.activationFunction = new HyperbolicTangentFunction(); this.normalizeData(-0.9, 0.9); break; default: this.activationFunction = new BipolarSigmoidFunction(); this.normalizeData(-0.9, 0.9); break; } //create network this.network = new BasicNetwork(); this.network.AddLayer(new FeedforwardLayer(this.activationFunction, this.inputLayerNeurons)); this.network.AddLayer(new FeedforwardLayer(this.activationFunction, this.hiddenLayerNeurons)); this.network.AddLayer(new FeedforwardLayer(this.activationFunction, this.outputLayerNeurons)); this.network.Reset(); //variable for looping //needToStop = false; double mse = 0.0, error = 0.0, mae=0.0; int iteration = 1; // parameters double msle = 0.0, mspe = 0.0, generalizationLoss = 0.0, pq = 0.0; double[] trainingErrors = new double[this.strip]; for (int i = 0; i < this.strip; i++) trainingErrors[i] = double.MaxValue / strip; double lastMSE = double.MaxValue; // advanced early stopping int n = this.data.Length - this.network.InputLayer.NeuronCount; int validationSet = (int)Math.Round(this.validationSetRatio * n); int trainingSet = n - validationSet; double[][] networkTrainingInput = new double[trainingSet][]; double[][] networkTrainingOutput = new double[trainingSet][]; for (int i = 0; i < trainingSet; i++) { networkTrainingInput[i] = new double[this.network.InputLayer.NeuronCount]; networkTrainingOutput[i] = new double[1]; } for (int i = 0; i < trainingSet; i++) { for (int j = 0; j < this.network.InputLayer.NeuronCount; j++) { networkTrainingInput[i][j] = this.networkInput[i][j]; } networkTrainingOutput[i][0] = this.networkOutput[i][0]; } // validation set double[] solutionValidation = new double[validationSet]; double[] inputForValidation = new double[this.network.InputLayer.NeuronCount]; double[] inputForValidationNetwork = new double[this.network.InputLayer.NeuronCount]; // array for saving neural weights and parameters this.bestValidationError = double.MaxValue; this.bestWeightMatrix = new double[this.network.Layers.Count -1][,]; this.bestSolution = new double[n]; for (int i = 0; i < this.network.Layers.Count - 1; i++) { this.bestWeightMatrix[i] = new double[this.network.Layers[i].WeightMatrix.Rows, this.network.Layers[i].WeightMatrix.Cols]; } //best network criterion double bestNetworkError = double.MaxValue, bestNetworkMSE = double.MaxValue, bestNetworkMAE = double.MaxValue; // build array for graph this.solutionData = new double[n]; this.predictedPoint = new cPoint[n]; this.validationPoint = new cPoint[validationSet]; //initialize point for graph predictedDS.Samples = predictedPoint; validationDS.Samples = validationPoint; this.predictedDS.Active = true; // prepare training data INeuralDataSet dataset; if (this.useAdvanceEarlyStopping) dataset = new BasicNeuralDataSet(networkTrainingInput, networkTrainingOutput); else dataset = new BasicNeuralDataSet(this.networkInput, this.networkOutput); // initialize trainer this.learning = new Backpropagation(this.network, dataset, this.learningRate, this.momentum); //training while (!needToStop) { double sse = 0.0; double sae = 0.0; double ssle = 0.0; double sspe = 0.0; this.learning.Iteration(); error = learning.Error; if (this.useAdvanceEarlyStopping) { this.validationDS.Active = true; } else { this.validationDS.Active = false; } for (int i = 0; i < n; i++) { INeuralData neuraldata = new BasicNeuralData(this.networkInput[i]); this.solutionData[i] = (this.network.Compute(neuraldata)[0] - this.minNormalizedData) / this.factor + this.minData; this.predictedPoint[i].x = i + this.network.InputLayer.NeuronCount; this.predictedPoint[i].y = (float)this.solutionData[i]; sse += Math.Pow(this.solutionData[i] - this.data[i + this.network.InputLayer.NeuronCount], 2); sae += Math.Abs(this.solutionData[i] - this.data[i + this.network.InputLayer.NeuronCount]); //calculate advance early stopping if (this.useAdvanceEarlyStopping) { if (i < n - validationSet) { ssle += Math.Pow(this.solutionData[i] - this.data[i + this.network.InputLayer.NeuronCount], 2); } else { // initialize the first validation set input if (i == n - validationSet) { for (int j = 0; j < this.network.InputLayer.NeuronCount; j++) { inputForValidation[this.network.InputLayer.NeuronCount - 1 - j] = this.data[this.data.Length - (n - i) - 1 - j]; } } for (int j = 0; j < this.network.InputLayer.NeuronCount; j++) { inputForValidationNetwork[j] = (inputForValidation[j] - this.minData) * this.factor + this.minNormalizedData; } INeuralData neuraldataval = new BasicNeuralData(inputForValidationNetwork); solutionValidation[i - n + validationSet] = (this.network.Compute(neuraldataval)[0] - this.minNormalizedData) / this.factor + this.minData; this.validationPoint[i - n + validationSet].x = i + this.network.InputLayer.NeuronCount; this.validationPoint[i - n + validationSet].y = (float)solutionValidation[i - n + validationSet]; sspe += Math.Pow(this.data[i + this.network.InputLayer.NeuronCount] - solutionValidation[i - n + validationSet], 2); // initialize the next validation set input from the current validation set input for (int j = 0; j < this.network.InputLayer.NeuronCount - 1; j++) { inputForValidation[j] = inputForValidation[j + 1]; } inputForValidation[this.network.InputLayer.NeuronCount - 1] = solutionValidation[i - n + validationSet]; } } } mse = sse / this.solutionData.Length; mae = sae / this.solutionData.Length; //Console.WriteLine(error.ToString()); //Display it this.iterationBox.Text = iteration.ToString(); this.maeBox.Text = mae.ToString("F5"); this.mseBox.Text = mse.ToString("F5"); this.errorBox.Text = error.ToString("F5"); seriesGraph.Refresh(); if (this.useAdvanceEarlyStopping) { //calculate advance early stopping 2 mspe = sspe / validationSet; msle = ssle / (this.solutionData.Length - validationSet); //save best weight if (this.bestValidationError > mspe) { this.bestValidationError = mspe; this.bestSolution = this.solutionData; // weight matrix for (int i = 0; i < this.network.Layers.Count - 1; i++) for (int j = 0; j < this.network.Layers[i].WeightMatrix.Rows; j++) for (int k = 0; k < this.network.Layers[i].WeightMatrix.Cols; k++) this.bestWeightMatrix[i][j,k] = this.network.Layers[i].WeightMatrix[j, k]; bestNetworkError = error; bestNetworkMAE = mae; bestNetworkMSE = mse; } //calculate generalization loss &pq generalizationLoss = 100 * (mspe / this.bestValidationError - 1); trainingErrors[(iteration - 1) % this.strip] = msle; double minStripTrainingError = double.MaxValue, sumStripTrainingError = 0.0; for (int i = 0; i < this.strip; i++) { sumStripTrainingError += trainingErrors[i]; if (trainingErrors[i] < minStripTrainingError) minStripTrainingError = trainingErrors[i]; } double trainingProgress = 1000 * ((sumStripTrainingError / (this.strip * minStripTrainingError)) - 1); pq = generalizationLoss / trainingProgress; //display advance early stopping this.learningErrorBox.Text = msle.ToString("F5"); this.validationErrorBox.Text = mspe.ToString("F5"); this.generalizationLossBox.Text = generalizationLoss.ToString("F5"); this.pqBox.Text = pq.ToString("F5"); this.seriesGraph.Refresh(); //stopping switch (this.advanceStoppingMethod) { case AdvanceStoppingMethodEnumeration.GeneralizationLoss: if (generalizationLoss > this.generalizationLossTreshold) needToStop = true; break; case AdvanceStoppingMethodEnumeration.ProgressQuotient: if (pq > this.pqTreshold) needToStop = true; break; } } if (this.withCheckingCycle && iteration % this.checkingCycle == 0) { switch (this.checkingMethod) { case CheckingMethodEnumeration.byMSEValue: if (mse <= this.byMSEValueStopping) needToStop = true; break; case CheckingMethodEnumeration.byMSEChange: if (lastMSE - mse <= this.byMSEChangeStopping) needToStop = true; break; } lastMSE = mse; } if (iteration >= this.maxIteration) { needToStop = true; } iteration++; } //restore weight if (this.useAdvanceEarlyStopping) { this.solutionData = this.bestSolution; // weight matrix for (int i = 0; i < this.network.Layers.Count - 1; i++) for (int j = 0; j < this.network.Layers[i].WeightMatrix.Rows; j++) for (int k = 0; k < this.network.Layers[i].WeightMatrix.Cols; k++) this.network.Layers[i].WeightMatrix[j, k] = this.bestWeightMatrix[i][j, k]; //best network criterion this.error = bestNetworkError; this.mse = bestNetworkMSE; this.mae = bestNetworkMAE; } else { this.error = error; this.mse = mse; this.mae = mae; } this.enableControls(true); }
/// <summary> /// Construct the chain rule calculation. /// </summary> /// <param name="network">The network to use.</param> /// <param name="indexableTraining">The training set to use.</param> public JacobianChainRule(BasicNetwork network, IIndexable indexableTraining) { this.indexableTraining = indexableTraining; this.network = network; this.parameterSize = network.Structure.CalculateSize(); this.inputLength = (int)this.indexableTraining.Count; this.jacobian = EngineArray.AllocateDouble2D(this.inputLength, this.parameterSize); this.rowErrors = new double[this.inputLength]; BasicNeuralData input = new BasicNeuralData( this.indexableTraining.InputSize); BasicNeuralData ideal = new BasicNeuralData( this.indexableTraining.IdealSize); this.pair = new BasicNeuralDataPair(input, ideal); }
/// <summary> /// Generate neural ideal data for the specified index. /// </summary> /// <param name="index">The index to generate for.</param> /// <returns>The neural data generated.</returns> public virtual BasicNeuralData GenerateOutputNeuralData(int index) { if (index + _predictWindowSize > _points.Count) { throw new TemporalError("Can't generate prediction temporal data " + "beyond the end of provided data."); } var result = new BasicNeuralData(_outputNeuronCount); int resultIndex = 0; for (int i = 0; i < _predictWindowSize; i++) { foreach (TemporalDataDescription desc in _descriptions) { if (desc.IsPredict) { result[resultIndex++] = FormatData(desc, index + i); } } } return result; }
/// <summary> /// Write an array. /// </summary> /// <param name="data">The data to write.</param> /// <param name="inputCount">How much of the data is input.</param> public void Write(double[] data, int inputCount) { if (this.idealCount == 0) { BasicNeuralData inputData = new BasicNeuralData(data); this.dataset.Add(inputData); } else { BasicNeuralData inputData = new BasicNeuralData( this.inputCount); BasicNeuralData idealData = new BasicNeuralData( this.idealCount); int index = 0; for (int i = 0; i < this.inputCount; i++) { inputData[i] = data[index++]; } for (int i = 0; i < this.idealCount; i++) { idealData[i] = data[index++]; } this.dataset.Add(inputData, idealData); } }
/// <summary> /// Generate random training into a training set. /// </summary> /// <param name="training">The training set to generate into.</param> /// <param name="seed">The seed to use.</param> /// <param name="count">How much data to generate.</param> /// <param name="min">The low random value.</param> /// <param name="max">The high random value.</param> public static void Generate(INeuralDataSet training, long seed, int count, double min, double max) { LinearCongruentialGenerator rand = new LinearCongruentialGenerator(seed); int inputCount = training.InputSize; int idealCount = training.IdealSize; for (int i = 0; i < count; i++) { INeuralData inputData = new BasicNeuralData(inputCount); for (int j = 0; j < inputCount; j++) { inputData[j] = rand.Range(min, max); } INeuralData idealData = new BasicNeuralData(idealCount); for (int j = 0; j < idealCount; j++) { idealData[j] = rand.Range(min, max); } BasicNeuralDataPair pair = new BasicNeuralDataPair(inputData, idealData); training.Add(pair); } }
public IMLData BuildForNetworkInput(double[] data) { int num2; int num5; int num = 0; goto Label_0148; Label_00A8: this.InitForOutput(); IMLData data2 = new BasicNeuralData(num2); int num4 = 0; using (IEnumerator<IOutputField> enumerator3 = this._outputFields.GetEnumerator()) { IOutputField field3; goto Label_00F6; Label_00C8: num5 = 0; while (num5 < field3.SubfieldCount) { data2.Data[num4++] = field3.Calculate(num5); num5++; } Label_00F6: if (enumerator3.MoveNext()) { goto Label_0119; } return data2; Label_0101: if ((((uint) num) & 0) != 0) { goto Label_0122; } goto Label_00C8; Label_0119: field3 = enumerator3.Current; Label_0122: if (field3.Ideal) { goto Label_00F6; } goto Label_0101; } if (2 != 0) { return data2; } Label_0148: using (IEnumerator<IInputField> enumerator = this._inputFields.GetEnumerator()) { IInputField field; Label_0157: if (enumerator.MoveNext()) { goto Label_01D2; } goto Label_01EF; Label_0168: if (!field.UsedForNetworkInput) { goto Label_0157; if (((uint) num) >= 0) { goto Label_01A2; } } if (num >= data.Length) { throw new NormalizationError("Can't build data, input fields used for neural input, must match provided data(" + data.Length + ")."); } if ((((uint) num4) - ((uint) num2)) < 0) { goto Label_0157; } Label_01A2: field.CurrentValue = data[num++]; goto Label_0157; Label_01D2: field = enumerator.Current; goto Label_0168; } Label_01EF: num2 = 0; if ((((uint) num5) - ((uint) num)) <= uint.MaxValue) { using (IEnumerator<IOutputField> enumerator2 = this._outputFields.GetEnumerator()) { IOutputField field2; Label_0031: if (enumerator2.MoveNext()) { goto Label_0077; } goto Label_00A8; Label_003E: while (field2.Ideal) { if (((uint) num2) <= uint.MaxValue) { goto Label_0031; } } int num3 = 0; while (num3 < field2.SubfieldCount) { num2++; num3++; } goto Label_0031; Label_0077: field2 = enumerator2.Current; if ((((uint) num3) & 0) == 0) { } goto Label_003E; } } goto Label_00A8; }
/// <summary> /// Construct the LMA object. /// </summary> /// <param name="network">The network to train. Must have a single output neuron.</param> /// <param name="training">The training data to use. Must be indexable.</param> public SVDTraining(BasicNetwork network, INeuralDataSet training) { ILayer outputLayer = network.GetLayer(BasicNetwork.TAG_OUTPUT); if (outputLayer == null) { throw new TrainingError("SVD requires an output layer."); } if (outputLayer.NeuronCount != 1) { throw new TrainingError("SVD requires an output layer with a single neuron."); } if (network.GetLayer(RadialBasisPattern.RBF_LAYER) == null) throw new TrainingError("SVD is only tested to work on radial basis function networks."); rbfLayer = (RadialBasisFunctionLayer)network.GetLayer(RadialBasisPattern.RBF_LAYER); this.Training = training; this.network = network; this.trainingLength = (int)this.Training.InputSize; BasicNeuralData input = new BasicNeuralData(this.Training.InputSize); BasicNeuralData ideal = new BasicNeuralData(this.Training.IdealSize); this.pair = new BasicNeuralDataPair(input, ideal); }
public virtual BasicNeuralData GenerateOutputNeuralData(int index) { if ((index + this._xcfe8f2ba20a6a8e4) <= this._x6fa2570084b2ad39.Count) { BasicNeuralData data = new BasicNeuralData(this._x0c37ff3adde9bc44); int num = 0; int num2 = 0; while (num2 < this._xcfe8f2ba20a6a8e4) { using (IEnumerator<TemporalDataDescription> enumerator = this._x6849a3dfb0329317.GetEnumerator()) { TemporalDataDescription current; goto Label_005F; Label_002C: data[num++] = this.x8c7fc30b887213d1(current, index + num2); if ((((uint) num) & 0) == 0) { } goto Label_005F; Label_0057: if (current.IsPredict) { goto Label_002C; } Label_005F: if (enumerator.MoveNext()) { current = enumerator.Current; goto Label_0057; } } num2++; } if ((((uint) num) - ((uint) num2)) >= 0) { return data; } } throw new TemporalError("Can't generate prediction temporal data beyond the end of provided data."); }
/// <summary> /// Generate input neural data for the specified index. /// </summary> /// <param name="index">The index to generate neural data for.</param> /// <returns>The input neural data generated.</returns> public virtual BasicNeuralData GenerateInputNeuralData(int index) { if (index + this.inputWindowSize > this.points.Count) { throw new TemporalError("Can't generate input temporal data " + "beyond the end of provided data."); } BasicNeuralData result = new BasicNeuralData(this.inputNeuronCount); int resultIndex = 0; for (int i = 0; i < this.inputWindowSize; i++) { int descriptionIndex = 0; foreach (TemporalDataDescription desc in this.descriptions) { if (desc.IsInput) { result[resultIndex++] = this.FormatData(desc, index + i); } descriptionIndex++; } } return result; }
/// <summary> /// Compute the values before sending output to the next layer. /// This function allows the activation functions to be called. /// </summary> /// <param name="pattern">The incoming Project.</param> /// <returns>The output from this layer.</returns> public override INeuralData Compute(INeuralData pattern) { INeuralData result = new BasicNeuralData(NeuronCount); for (int i = 0; i < NeuronCount; i++) { if (this.radialBasisFunction[i] == null) { String str = "Error, must define radial functions for each neuron"; #if logging if (RadialBasisFunctionLayer.logger.IsErrorEnabled) { RadialBasisFunctionLayer.logger.Error(str); } #endif throw new NeuralNetworkError(str); } IRadialBasisFunction f = this.radialBasisFunction[i]; if (pattern.Data.Length != f.Dimensions) throw new Exception("Inputs must equal the number of dimensions."); result[i] = f.Calculate(pattern.Data); } return result; }
/// <summary> /// Clone this object. /// </summary> /// <returns>A clone of this object.</returns> public object Clone() { BasicNeuralData result = new BasicNeuralData(this.data); return(result); }
/// <summary> /// Compute the weighted output from this synapse. Each neuron /// in the from layer has a weighted connection to each of the /// neurons in the next layer. /// </summary> /// <param name="input">The input from the synapse.</param> /// <returns>The output from this synapse.</returns> public override INeuralData Compute(INeuralData input) { INeuralData result = new BasicNeuralData(this.ToNeuronCount); double[] inputArray = input.Data; double[][] matrixArray = this.WeightMatrix.Data; double[] resultArray = result.Data; for (int i = 0; i < this.ToNeuronCount; i++) { double sum = 0; for(int j = 0;j<inputArray.Length;j++ ) { sum+=inputArray[j]*matrixArray[j][i]; } resultArray[i] = sum; } return result; }
/// <summary> /// Clone this object. /// </summary> /// <returns>A clone of this object.</returns> public object Clone() { BasicNeuralData result = new BasicNeuralData(this.data); return result; }
/// <summary> /// Build "input data for a neural network" based on the input values /// provided. This allows input for a neural network to be normalized. /// This is typically used when data is to be presented to a trained /// neural network. /// </summary> /// <param name="data">The input values to be normalized.</param> /// <returns>The data to be sent to the neural network.</returns> public IMLData BuildForNetworkInput(double[] data) { // feed the input fields int index = 0; foreach (IInputField field in _inputFields) { if (field.UsedForNetworkInput) { if (index >= data.Length) { throw new NormalizationError( "Can't build data, input fields used for neural input, must match provided data(" + data.Length + ")."); } field.CurrentValue = data[index++]; } } // count the output fields int outputCount = 0; foreach (IOutputField ofield in _outputFields) { if (!ofield.Ideal) { for (int sub = 0; sub < ofield.SubfieldCount; sub++) { outputCount++; } } } // process the output fields InitForOutput(); var result = new BasicNeuralData(outputCount); // write the value int outputIndex = 0; foreach (IOutputField ofield in _outputFields) { if (!ofield.Ideal) { for (int sub = 0; sub < ofield.SubfieldCount; sub++) { result[outputIndex++] = ofield.Calculate(sub); } } } return result; }
/// <summary> /// Create one training pair, either good or bad. /// </summary> /// <param name="data">The data to create from.</param> /// <param name="index">The index into the data to create from.</param> /// <param name="good">True if this was a good(bearish) period.</param> /// <returns></returns> public IMLDataPair CreateData(List<LoadedMarketData> data, int index, bool good) { BasicNeuralData ideal = new BasicNeuralData(1); INeuralData input = CreateData(data, index); if (input == null) return null; // ideal if (good) ideal[0] = 0.9; else ideal[0] = 0.1; return new BasicMLDataPair(input, ideal); }
/// <summary> /// Meramalkan data /// </summary> /// <param name="step">step peramalan</param> /// <returns>hasil peramalan</returns> public double[] Forecast(int step) { if (step < 1) step = 1; int inputsCount = this.network.InputLayer.NeuronCount; double[] result = new double[step]; double[] inputForOut = new double[inputsCount]; double[] inputForOutNetwork = new double[inputsCount]; //input for forecasting for (int j = 0; j < inputsCount; j++) { inputForOut[inputsCount - 1 - j] = this.data[this.data.Length - 1 - j]; } //forecast for (int i = 0; i < step; i++) { for (int j = 0; j < inputsCount; j++) { inputForOutNetwork[j] = (inputForOut[j] - this.minData) * this.factor + this.minNormalizedData; } INeuralData neuraldata = new BasicNeuralData(inputForOutNetwork); // evalue the function result[i] = (this.network.Compute(neuraldata)[0] - this.minNormalizedData) / this.factor + this.minData; for (int j = 0; j < inputsCount - 1; j++) { inputForOut[j] = inputForOut[j + 1]; } inputForOut[inputsCount - 1] = result[i]; } return result; }
/// <summary> /// Compute the output from this synapse. /// </summary> /// <param name="input">The input to this synapse.</param> /// <returns>The output from this synapse.</returns> public INeuralData Compute(INeuralData input) { INeuralData result = new BasicNeuralData(ToNeuronCount); if (this.neurons.Count == 0) { throw new NeuralNetworkError("This network has not been evolved yet, it has no neurons in the NEAT synapse."); } int flushCount = 1; if (snapshot) { flushCount = networkDepth; } // iterate through the network FlushCount times for (int i = 0; i < flushCount; ++i) { int outputIndex = 0; int index = 0; result.Clear(); // populate the input neurons while (neurons[index].NeuronType == NEATNeuronType.Input) { neurons[index].Output = input[index]; index++; } // set the bias neuron neurons[index++].Output = 1; while (index < neurons.Count) { NEATNeuron currentNeuron = neurons[index]; double sum = 0; foreach (NEATLink link in currentNeuron.InboundLinks) { double weight = link.Weight; double neuronOutput = link.FromNeuron.Output; sum += weight * neuronOutput; } double[] d = new double[1]; d[0] = sum / currentNeuron.ActivationResponse; activationFunction.ActivationFunction(d,0,1); neurons[index].Output = d[0]; if (currentNeuron.NeuronType == NEATNeuronType.Output) { result.Data[outputIndex++] = currentNeuron.Output; } index++; } } return result; }
/// <summary> /// Compute the output for a given input to the neural network. This method /// provides a parameter to specify an output holder to use. This holder /// allows propagation training to track the output from each layer. /// If you do not need this holder pass null, or use the other /// compare method. /// </summary> /// <param name="input">The input provide to the neural network.</param> /// <param name="useHolder">Allows a holder to be specified, this allows /// propagation training to check the output of each layer.</param> /// <returns>The results from the output neurons.</returns> public virtual INeuralData Compute(INeuralData input, NeuralOutputHolder useHolder) { NeuralOutputHolder holder; ILayer inputLayer = this.network.GetLayer(BasicNetwork.TAG_INPUT); #if logging if (FeedforwardLogic.logger.IsDebugEnabled) { FeedforwardLogic.logger.Debug("Pattern " + input.ToString() + " presented to neural network"); } #endif if (useHolder == null && this.network.Structure.Flat != null) { this.network.Structure.UpdateFlatNetwork(); INeuralData result = new BasicNeuralData(this.network.Structure.Flat.OutputCount); this.network.Structure.Flat.Compute(input.Data, result.Data); return result; } if (useHolder == null) { holder = new NeuralOutputHolder(); } else { holder = useHolder; } Compute(holder, inputLayer, input, null); return holder.Output; }
/// <summary> /// Compute the weightless output from this synapse. Each neuron /// in the from layer has a weightless connection to each of the /// neurons in the next layer. /// </summary> /// <param name="input">The input from the synapse.</param> /// <returns>The output from this synapse.</returns> public override INeuralData Compute(INeuralData input) { INeuralData result = new BasicNeuralData(this.ToNeuronCount); // just sum the input double sum = 0; for (int i = 0; i < input.Count; i++) { sum += input[i]; } for (int i = 0; i < this.ToNeuronCount; i++) { result[i] = sum; } return result; }