/// <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>
/// 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>
/// Evaluate memory.
/// </summary>
private void EvalMemory()
{
BasicNeuralDataSet training = RandomTrainingFactory.Generate(
1000, 10000, 10, 10, -1, 1);
long stop = (10 * Evaluate.MILIS);
int record = 0;
INeuralDataPair pair = BasicNeuralDataPair.CreatePair(10, 10);
int iterations = 0;
Stopwatch watch = new Stopwatch();
watch.Start();
while (watch.ElapsedMilliseconds < stop)
{
iterations++;
training.GetRecord(record++, pair);
if (record >= training.Count)
{
record = 0;
}
}
iterations /= 100000;
this.report.Report(EncogBenchmark.STEPS, EncogBenchmark.STEP3,
"Memory dataset, result: " + Format.FormatInteger(iterations));
this.memoryScore = iterations;
}
/// <inheritdoc/>
public void Write(double[] input, double[] ideal)
{
INeuralDataPair pair = BasicNeuralDataPair.CreatePair(inputSize,
idealSize);
EngineArray.ArrayCopy(input, pair.Input.Data);
EngineArray.ArrayCopy(ideal, pair.Ideal.Data);
}
/// <summary>
/// Move to the next record.
/// </summary>
/// <returns>True, if we were able to move to the next record.</returns>
public bool MoveNext()
{
if (HasNext())
{
INeuralDataPair pair = BasicNeuralDataPair.CreatePair(
this.owner.InputSize, this.owner.IdealSize);
this.owner.GetRecord(this.currentIndex++, pair);
this.currentPair = pair;
return(true);
}
else
{
this.currentPair = null;
return(false);
}
}
/// <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>
/// Evaluate disk.
/// </summary>
private void EvalBinary()
{
String file = "temp.egb";
BasicNeuralDataSet training = RandomTrainingFactory.Generate(
1000, 10000, 10, 10, -1, 1);
// create the binary file
File.Delete(file);
BufferedNeuralDataSet training2 = new BufferedNeuralDataSet(file);
training2.Load(training);
long stop = (10 * Evaluate.MILIS);
int record = 0;
INeuralDataPair pair = BasicNeuralDataPair.CreatePair(10, 10);
Stopwatch watch = new Stopwatch();
watch.Start();
int iterations = 0;
while (watch.ElapsedMilliseconds < stop)
{
iterations++;
training2.GetRecord(record++, pair);
if (record >= training2.Count)
{
record = 0;
}
}
training2.Close();
iterations /= 100000;
this.report.Report(EncogBenchmark.STEPS, EncogBenchmark.STEP4,
"Disk(binary) dataset, result: "
+ Format.FormatInteger(iterations));
File.Delete(file);
this.binaryScore = iterations;
}
/// <summary>
/// Move to the next element.
/// </summary>
/// <returns>True if there are more elements to read.</returns>
public bool MoveNext()
{
try
{
if (this.current >= data.Count)
{
return(false);
}
this.currentRecord = BasicNeuralDataPair.CreatePair(this.data
.InputSize, this.data.IdealSize);
this.data.GetRecord(this.current++, this.currentRecord);
return(true);
}
catch (EndOfStreamException)
{
return(false);
}
}
/// <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);
}
