/// <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 + this.predictWindowSize > this.points.Count)
{
throw new TemporalError("Can't generate prediction temporal data "
+ "beyond the end of provided data.");
}
BasicNeuralData result = new BasicNeuralData(this.outputNeuronCount);
int resultIndex = 0;
for (int i = 0; i < this.predictWindowSize; i++)
{
int descriptionIndex = 0;
foreach (TemporalDataDescription desc in this.descriptions)
{
if (desc.IsPredict)
{
result[resultIndex++] = this.FormatData(desc, index
+ i);
}
descriptionIndex++;
}
}
return(result);
}
public PredicResults Predict()
{
double[] present = new double[INPUT_TUPLES * INDEXES_TO_CONSIDER];
double[] actualOutput = new double[OUTPUT_SIZE];
int index = 0;
index = _manager.Samples.Count;
var result = new PredicResults();
_manager.GetInputData(index - INPUT_TUPLES, present);
//_manager.GetOutputData(index - INPUT_TUPLES, actualOutput);
var data = new BasicNeuralData(present);
var predict = _network.Compute(data);
//result.ActualClose = actualOutput[0] * (_manager.GetMax((int)PredicInputIndexe.CloseIndex) - _manager.GetMin((int)PredicInputIndexe.CloseIndex)) + _manager.GetMin((int)PredicInputIndexe.CloseIndex);
result.PredictedClose = predict[0] * (_manager.GetMax((int)PredicInputIndexe.CloseIndex) - _manager.GetMin((int)PredicInputIndexe.CloseIndex)) + _manager.GetMin((int)PredicInputIndexe.CloseIndex);
//result.ActualPir = actualOutput[1] * (_manager.MaxPrimeRate - _manager.MinPrimeRate) + _manager.MinPrimeRate;
//result.PredictedPir = predict[1] * (_manager.MaxPrimeRate - _manager.MinPrimeRate) + _manager.MinPrimeRate;
//result.ActualDow = actualOutput[2] * (_manager.MaxDow - _manager.MinDow) + _manager.MinDow;
//result.PredictedDow = predict[2] * (_manager.MaxDow - _manager.MinDow) + _manager.MinDow;
//result.ActualNasdaq = actualOutput[3] * (_manager.MaxNasdaq - _manager.MinNasdaq) + _manager.MinNasdaq;
//result.PredictedNasdaq = predict[3] * (_manager.MaxNasdaq - _manager.MinNasdaq) + _manager.MinNasdaq;
result.Date = _manager.GetDateTime(index - 1).AddDays(3);
//ErrorCalculation error = new ErrorCalculation();
//error.UpdateError(actualOutput, predict);
//result.Error = error.CalculateRMS();
result.Error = 0;
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);
}
}
/// <inheritdoc/>
public void Compute(double[] input, double[] output)
{
BasicNeuralData input2 = new BasicNeuralData(input);
INeuralData output2 = this.Compute(input2);
EngineArray.ArrayCopy(output2.Data, output);
}
/// <summary>
/// Move to the next object.
/// </summary>
/// <returns>True if there is a next object.</returns>
public bool MoveNext()
{
if (!this.results.NextResult())
{
return(false);
}
INeuralData input = new BasicNeuralData(owner.inputSize);
INeuralData ideal = null;
for (int i = 1; i <= owner.inputSize; i++)
{
input[i - 1] = this.results.GetDouble(i);
}
if (owner.idealSize > 0)
{
ideal =
new BasicNeuralData(owner.idealSize);
for (int i = 1; i <= owner.idealSize; i++)
{
ideal[i - 1] =
this.results.GetDouble(i + owner.inputSize);
}
}
this.current = new BasicNeuralDataPair(input, ideal);
return(true);
}
/// <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);
}
}
/// <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>
/// 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>
/// 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 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);
}
public List <PredictionResults> Predict(DateTime predictFrom, DateTime predictTo)
{
List <PredictionResults> results = new List <PredictionResults>();
double[] present = new double[InputTuples * IndexesToConsider];
double[] actualOutput = new double[OutputSize];
int index = 0;
foreach (var sample in _manager.Samples)
{
if (sample.Date.CompareTo(predictFrom) > 0 && sample.Date.CompareTo(predictTo) < 0)
{
var result = new PredictionResults();
_manager.GetInputData(index - InputTuples, present);
_manager.GetOutputData(index - InputTuples, actualOutput);
var data = new BasicNeuralData(present);
var predict = _network.Compute(data);
result.ActualLotos = actualOutput[0] * (_manager.MaxLotos - _manager.MinLotos) + _manager.MinLotos;
result.PredictedLotos = predict[0] * (_manager.MaxLotos - _manager.MinLotos) + _manager.MinLotos;
result.ActualPir = actualOutput[1] * (_manager.MaxPrimeRate - _manager.MinPrimeRate) + _manager.MinPrimeRate;
result.PredictedPir = predict[1] * (_manager.MaxPrimeRate - _manager.MinPrimeRate) + _manager.MinPrimeRate;
result.ActualOrlen = actualOutput[2] * (_manager.MaxOrlen - _manager.MinOrlen) + _manager.MinOrlen;
result.PredictedOrlen = predict[2] * (_manager.MaxOrlen - _manager.MinOrlen) + _manager.MinOrlen;
result.Date = sample.Date;
var error = new ErrorCalculation();
error.UpdateError(actualOutput, predict.Data);
result.Error = error.CalculateRMS();
results.Add(result);
}
index++;
}
return(results);
}
/// <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);
}
/// <summary>
/// Internal function to obtain the next training set item.
/// </summary>
/// <returns>True if one was found.</returns>
private bool ObtainNext()
{
if (!this.reader.FindTag(this.owner.PairXML, true))
{
return(false);
}
INeuralData input = new BasicNeuralData(
this.owner.InputSize);
INeuralData ideal = new BasicNeuralData(
this.owner.IdealSize);
if (!this.reader.FindTag(owner.InputXML, true))
{
InvalidError();
}
for (int i = 0; i < owner.InputSize; i++)
{
if (!this.reader.FindTag(owner.ValueXML, true))
{
InvalidError();
}
String str = this.reader.ReadTextToTag();
input[i] = double.Parse(str);
}
if (owner.IdealSize > 0)
{
if (!this.reader.FindTag(owner.IdealXML, true))
{
InvalidError();
}
for (int i = 0; i < owner.IdealSize; i++)
{
if (!this.reader.FindTag(owner.ValueXML, true))
{
InvalidError();
}
String str = this.reader.ReadTextToTag();
ideal[i] = double.Parse(str);
}
}
if (ideal != null)
{
this.nextPair = new BasicNeuralDataPair(input, ideal);
}
else
{
this.nextPair = new BasicNeuralDataPair(input);
}
return(true);
}
/// <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);
}
public void testNetwork(double[][] networkOutputs)
{
for (int i = 0; i < networkOutputs.Length; i++)
{
//INeuralData data = new BasicNeuralData(networkInput[i]);
//networkOutputs[i] = (double[])network.Compute(data).Data.Clone();
BasicNeuralData inputs = new BasicNeuralData(networkInput[i]);
INeuralData output = network.Compute(inputs);
EngineArray.ArrayCopy(output.Data, networkOutputs[i]);
}
}
/// <summary>
/// Tests the network using defined inputs and ideal outputs. Returns a 2D matrix of the predicted
/// values, which can then somewhere else be compared against the idealoutputs.
/// </summary>
/// <returns></returns>
public double[][] testNetwork()
{
double[][] networkOutputs = new double[networkInput.Length][];
for (int i = 0; i < networkOutputs.Length; i++)
{
INeuralData data = new BasicNeuralData(networkInput[i]);
networkOutputs[i] = (double[])network.Compute(data).Data.Clone();
}
return networkOutputs;
}
/// <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);
}
private BasicNeuralData GenerateInputNeuralData(List <Quant> inputQuants)
{
var result = new BasicNeuralData(inputQuants.Count);
int resultIndex = 0;
for (int i = 0; i < inputQuants.Count; i++)
{
result[resultIndex++] = i == 0
? 0.0
: (inputQuants[i].Close - inputQuants[i - 1].Close) / inputQuants[i - 1].Close;
}
return(result);
}
/// <summary>
/// Generate the training sets.
/// </summary>
public virtual void Generate()
{
SortPoints();
int start = CalculateStartIndex() + 1;
int setSize = CalculateActualSetSize();
int range = start
+ (setSize - _predictWindowSize - _inputWindowSize);
for (int i = start; i < range; i++)
{
BasicNeuralData input = GenerateInputNeuralData(i);
BasicNeuralData ideal = GenerateOutputNeuralData(i + _inputWindowSize);
var pair = new BasicNeuralDataPair(input, ideal);
base.Add(pair);
}
}
/// <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>
/// 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);
}
/// <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 LevenbergMarquardtTraining(BasicNetwork network,
INeuralDataSet training)
{
if (!(training is IIndexable))
{
throw new TrainingError(
"Levenberg Marquardt requires an indexable training set.");
}
ILayer outputLayer = network.GetLayer(BasicNetwork.TAG_OUTPUT);
if (outputLayer == null)
{
throw new TrainingError(
"Levenberg Marquardt requires an output layer.");
}
if (outputLayer.NeuronCount != 1)
{
throw new TrainingError(
"Levenberg Marquardt requires an output layer with a single neuron.");
}
this.Training = training;
this.indexableTraining = (IIndexable)Training;
this.network = network;
this.trainingLength = (int)this.indexableTraining.Count;
this.parametersLength = this.network.Structure.CalculateSize();
this.hessianMatrix = new Matrix(this.parametersLength,
this.parametersLength);
this.hessian = this.hessianMatrix.Data;
this.alpha = 0.0;
this.beta = 1.0;
this.lambda = 0.1;
this.deltas = new double[this.parametersLength];
this.gradient = new double[this.parametersLength];
this.diagonal = new double[this.parametersLength];
BasicNeuralData input = new BasicNeuralData(
this.indexableTraining.InputSize);
BasicNeuralData ideal = new BasicNeuralData(
this.indexableTraining.IdealSize);
this.pair = new BasicNeuralDataPair(input, ideal);
}
/// <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>
/// 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>
/// Predict the results
/// </summary>
/// <returns>List with the prediction results</returns>
public List <PredicResults> Predict(DateTime predictFrom, DateTime predictTo)
{
var results = new List <PredicResults>();
double[] present = new double[INPUT_TUPLES * INDEXES_TO_CONSIDER];
double[] actualOutput = new double[OUTPUT_SIZE];
int index = 0;
foreach (var sample in _manager.Samples)
{
if (sample.Date.Date.CompareTo(predictFrom.Date) > 0 && sample.Date.Date.CompareTo(predictTo.Date) <= 0)
{
var result = new PredicResults();
_manager.GetInputData(index - INPUT_TUPLES, present);
// _manager.GetOutputData(index - INPUT_TUPLES, actualOutput);
var data = new BasicNeuralData(present);
var predict = _network.Compute(data);
//result.ActualClose = actualOutput[0] * (_manager.GetMax((int)PredicInputIndexe.CloseIndex) - _manager.GetMin((int)PredicInputIndexe.CloseIndex)) + _manager.GetMin((int)PredicInputIndexe.CloseIndex);
result.PredictedClose = predict[0] * (_manager.GetMax((int)PredicInputIndexe.CloseIndex) - _manager.GetMin((int)PredicInputIndexe.CloseIndex)) + _manager.GetMin((int)PredicInputIndexe.CloseIndex);
//result.ActualPir = actualOutput[1] * (_manager.MaxPrimeRate - _manager.MinPrimeRate) + _manager.MinPrimeRate;
//result.PredictedPir = predict[1] * (_manager.MaxPrimeRate - _manager.MinPrimeRate) + _manager.MinPrimeRate;
//result.ActualDow = actualOutput[2] * (_manager.MaxDow - _manager.MinDow) + _manager.MinDow;
//result.PredictedDow = predict[2] * (_manager.MaxDow - _manager.MinDow) + _manager.MinDow;
//result.ActualNasdaq = actualOutput[3] * (_manager.MaxNasdaq - _manager.MinNasdaq) + _manager.MinNasdaq;
//result.PredictedNasdaq = predict[3] * (_manager.MaxNasdaq - _manager.MinNasdaq) + _manager.MinNasdaq;
result.Date = sample.Date;
ErrorCalculation error = new ErrorCalculation();
//error.UpdateError(actualOutput, predict);
//result.Error = error.CalculateRMS();
//result.Error = result.ActualClose - result.PredictedClose;
result.Error = 0;
result.ActualClose = 0;
results.Add(result);
}
index++;
}
return(results);
}
/// <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(bullish) period.</param>
/// <returns></returns>
public IMLDataPair CreateData(List <LoadedMarketData> data, int index, bool good)
{
var 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>
/// 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 + _inputWindowSize > _points.Count)
{
throw new TemporalError("Can't generate input temporal data "
+ "beyond the end of provided data.");
}
var result = new BasicNeuralData(_inputNeuronCount);
int resultIndex = 0;
for (int i = 0; i < _inputWindowSize; i++)
{
foreach (TemporalDataDescription desc in _descriptions)
{
if (desc.IsInput)
{
result[resultIndex++] = FormatData(desc, index
+ i);
}
}
}
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);
}
public string Post(string symbol, double close, long time)
{
DateTime origin = new DateTime(1970, 1, 1, 0, 0, 0, 0);
var date = origin.AddSeconds(time);
var symb = _context.Symbols.SingleOrDefault(s => s.Name == symbol);
if (symb == null)
{
symb = new Symbol()
{
Name = symbol
};
_context.Symbols.Add(symb);
_context.SaveChanges();
}
var tick = new Tick()
{
Id = Guid.NewGuid(),
SymbolId = symb.Id,
Close = close,
Time = date
};
_context.Ticks.Add(tick);
_context.SaveChanges();
var quant = _context.Quants.Where(q => q.SymbolId == symb.Id).OrderByDescending(q => q.Ind).FirstOrDefault();
if (quant == null)
{
_context.Quants.Add(new Quant()
{
Id = Guid.NewGuid(),
SymbolId = symb.Id,
Close = close,
Recommendation = Recommendation.CloseAll,
Ind = 0,
TickId = tick.Id
});
return("ok");
}
var dif = Math.Abs(close - quant.Close);
if (dif > symb.QuantSize)
{
var network = _context.Networks.SingleOrDefault(n => n.SymbolId == symb.Id);
var sign = close < quant.Close ? -1 : 1;
var steps = (int)(dif / symb.QuantSize);
for (int i = 1; i <= steps; i++)
{
Recommendation recommendation = Recommendation.CloseAll;
var newQuantVal = quant.Close + symb.QuantSize * sign * i;
var newQuant = new Quant()
{
TickId = tick.Id,
Close = newQuantVal,
Ind = quant.Ind + i,
Recommendation = recommendation
};
if (network != null)
{
network.QuantsProcessed++;
if (i == steps)
{
var inputQuants = _context.Quants.Where(q => q.SymbolId == symb.Id).OrderByDescending(q => q.Ind).Take(24).Reverse().ToList();
inputQuants.Add(newQuant);
if (inputQuants.Count == 25)
{
var predictor = (BasicNetwork)EncogDirectoryPersistence.LoadObject(new FileInfo(network.FileName));
BasicNeuralData input = GenerateInputNeuralData(inputQuants);
var predictData = predictor.Compute(input)[0];
newQuant.Recommendation = predictData < 0 ? Recommendation.Sell : Recommendation.Buy;
}
if (network.QuantsProcessed > 200)
{
_context.NetworkCalculationTasks.Add(new NetworkCalculationTask()
{
ShouldStartAt = DateTime.Today.AddHours(18).AddMinutes(10),
Status = TaskStatus.New,
SymbolId = symb.Id
});
}
}
}
_context.Quants.Add(newQuant);
_context.SaveChanges();
}
}
return("ok");
}
/// <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);
}
