static void Main(string[] args)
{
int dimension = 2;
int numNeuronsPerDimension = 4;
double volumeNeuronWidth = 2.0 / numNeuronsPerDimension;;
bool includeEdgeRBFs = true;
RBFNetwork n = new RBFNetwork(dimension, numNeuronsPerDimension, 1, RBFEnum.Gaussian);
n.SetRBFCentersAndWidthsEqualSpacing(0, 1, RBFEnum.Gaussian, volumeNeuronWidth, includeEdgeRBFs);
INeuralDataSet trainingSet = new BasicNeuralDataSet(XORInput, XORIdeal);
SVDTraining train = new SVDTraining(n, trainingSet);
int epoch = 1;
do
{
train.Iteration();
Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error);
epoch++;
} while ((epoch < 1) && (train.Error > 0.001));
Console.WriteLine(@"Neural Network Results:");
foreach (IMLDataPair pair in trainingSet)
{
IMLData output = n.Compute(pair.Input);
Console.WriteLine(pair.Input[0] + @"," + pair.Input[1]
+ @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]);
}
Console.Read();
}
public TimeSeries Predict(RBFNetwork network, NormalizeArray norm, TimeSeries simulatedData)
{
double[] data = GenerateData(simulatedData);
int data_count = simulatedData.Count;
TimeSeries ts = new TimeSeries();
double input_val = 0;
for (int idx = 0; idx < data_count; ++idx)
{
var input = new BasicMLData(WindowSize);
for (var i = 0; i < WindowSize; i++)
{
int idx2 = (idx - WindowSize) + i;
if (idx2 < 0)
{
input_val = 0;
}
else
{
input_val = norm.Stats.Normalize(data[idx2]);
}
input[i] = input_val;
}
IMLData output = network.Compute(input);
double prediction = norm.Stats.DeNormalize(output[0]);
ts.Add(simulatedData.TimeStamp(idx), prediction, false);
}
return(ts);
}
public TimeSeries Forecast(RBFNetwork network, NormalizeArray norm, TimeSeries simulatedData, List <DateTime> futureTimes)
{
int data_count = simulatedData.Count;
int future_data_count = futureTimes.Count;
double[] data = new double[data_count + future_data_count];
for (int idx = 0; idx < data_count; ++idx)
{
data[idx] = simulatedData[idx];
}
for (int idx = 0; idx < future_data_count; ++idx)
{
data[data_count + idx] = 0;
}
TimeSeries ts = new TimeSeries();
double input_val = 0;
for (int idx = 0; idx < future_data_count; ++idx)
{
var input = new BasicMLData(WindowSize);
for (var i = 0; i < WindowSize; i++)
{
int idx2 = (data_count + idx - WindowSize) + i;
if (idx2 < 0)
{
input_val = 0;
}
else
{
input_val = norm.Stats.Normalize(data[idx2]);
}
input[i] = input_val;
}
IMLData output = network.Compute(input);
double prediction = norm.Stats.DeNormalize(output[0]);
data[data_count + idx] = prediction;
ts.Add(futureTimes[idx], prediction, false);
}
return(ts);
}
public override int Classify(double[] input)
{
double[,] sample = new double[1, input.Length];
#region convert to LDA format
for (int i = 0; i < input.Length; i++)
{
sample[0, i] = input[i];
}
#endregion
double[,] projectedSample = _lda.Transform(sample);
#region convert to NN format
double[] projectedSample2 = new double[projectedSample.GetLength(1)];
for (int i = 0; i < projectedSample.GetLength(1); i++)
{
projectedSample2[i] = projectedSample[0, i];
}
#endregion
IMLData set = new Encog.ML.Data.Basic.BasicMLData(projectedSample2);
IMLData result = method.Compute(set);
#region find winner node
int pos = -1;
double max = -1;
for (int i = 0; i < result.Count; i++)
{
if (result[i] > max)
{
pos = i;
max = result[i];
}
}
return(pos + 1);
#endregion
}