/// <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); }