/// <summary> /// Load a CSV file into a memory dataset. /// </summary> /// /// <param name="format">The CSV format to use.</param> /// <param name="filename">The filename to load.</param> /// <param name="headers">True if there is a header line.</param> /// <param name="inputSize">The input size. Input always comes first in a file.</param> /// <param name="idealSize">The ideal size, 0 for unsupervised.</param> /// <returns>A NeuralDataSet that holds the contents of the CSV file.</returns> public static IMLDataSet LoadCSVTOMemory(CSVFormat format, String filename, bool headers, int inputSize, int idealSize) { var result = new BasicMLDataSet(); var csv = new ReadCSV(filename, headers, format); while (csv.Next()) { BasicMLData ideal = null; int index = 0; var input = new BasicMLData(inputSize); for (int i = 0; i < inputSize; i++) { double d = csv.GetDouble(index++); input[i] = d; } if (idealSize > 0) { ideal = new BasicMLData(idealSize); for (int i = 0; i < idealSize; i++) { double d = csv.GetDouble(index++); ideal[i] = d; } } IMLDataPair pair = new BasicMLDataPair(input, ideal); result.Add(pair); } return result; }
/// <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 BasicMLDataSet Generate(long seed, int count, int inputCount, int idealCount, double min, double max) { var rand = new LinearCongruentialGenerator(seed); var result = new BasicMLDataSet(); for (int i = 0; i < count; i++) { IMLData inputData = new BasicMLData(inputCount); for (int j = 0; j < inputCount; j++) { inputData.Data[j] = rand.Range(min, max); } IMLData idealData = new BasicMLData(idealCount); for (int j = 0; j < idealCount; j++) { idealData[j] = rand.Range(min, max); } var pair = new BasicMLDataPair(inputData, idealData); result.Add(pair); } return result; }
/// <summary> /// Clone this object. /// </summary> /// <returns>A clone of this object.</returns> public object Clone() { Object result; if (Ideal == null) { result = new BasicMLDataPair((IMLData)_input.Clone()); } else { result = new BasicMLDataPair((IMLData)_input.Clone(), (IMLData)_ideal.Clone()); } return(result); }
/// <summary> /// Create a new neural data pair object of the correct size for the neural /// network that is being trained. This object will be passed to the getPair /// method to allow the neural data pair objects to be copied to it. /// </summary> /// <param name="inputSize">The size of the input data.</param> /// <param name="idealSize">The size of the ideal data.</param> /// <returns>A new neural data pair object.</returns> public static BasicMLDataPair CreatePair(int inputSize, int idealSize) { BasicMLDataPair result; if (idealSize > 0) { result = new BasicMLDataPair(new BasicMLData(inputSize), new BasicMLData(idealSize)); } else { result = new BasicMLDataPair(new BasicMLData(inputSize)); } return(result); }
public static IMLDataSet CreateNoisyXORDataSet(int count) { var result = new BasicMLDataSet(); for (int i = 0; i < count; i++) { for (int j = 0; j < 4; j++) { var inputData = new BasicMLData(XORInput[j]); var idealData = new BasicMLData(XORIdeal[j]); var pair = new BasicMLDataPair(inputData, idealData); inputData[0] = inputData[0] + RangeRandomizer.Randomize(-0.1, 0.1); inputData[1] = inputData[1] + RangeRandomizer.Randomize(-0.1, 0.1); result.Add(pair); } } return result; }
/// <summary> /// Construct the centroid. /// </summary> /// <param name="o"> The pair to base the centroid on.</param> public BasicMLDataPairCentroid(BasicMLDataPair o) { _value = (BasicMLData)o.Input.Clone(); _size = 1; }
/// <inheritdoc/> public IMLDataPair this[int x] { get { var input = new double[InputSize]; var ideal = new double[IdealSize]; _egb.SetLocation(x); _egb.Read(input); _egb.Read(ideal); var inputData = new BasicMLData(input, false); var idealData = new BasicMLData(ideal, false); var result = new BasicMLDataPair(inputData, idealData); result.Significance = _egb.Read(); return result; } }
/// <summary> /// Process the data array and returns an IMLdatapair. /// </summary> /// /// <param name="data">The array to process.</param> /// <returns>An IMLDatapair containing data.</returns> public IMLDataPair ProcessToPair(double[] data) { // not sure this method works right: it's only using the last pair? IMLDataPair pair = null; int totalWindowSize = _inputWindow + _predictWindow; int stopPoint = data.Length - totalWindowSize; for (int i = 0; i < stopPoint; i++) { var inputData = new BasicMLData(_inputWindow); var idealData = new BasicMLData(_predictWindow); int index = i; // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = data[index++]; } // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] = data[index++]; } pair = new BasicMLDataPair(inputData, idealData); } return pair; }
public static IMLDataSet LoadCSVTOMemory(CSVFormat format, string filename, bool headers, int inputSize, int idealSize) { ReadCSV dcsv; IMLData data; int num; IMLData data2; int num4; IMLDataSet set = new BasicMLDataSet(); goto Label_00FF; Label_000B: if (idealSize > 0) { data = new BasicMLData(idealSize); num4 = 0; while (num4 < idealSize) { double num5 = dcsv.GetDouble(num++); data[num4] = num5; num4++; } } IMLDataPair inputData = new BasicMLDataPair(data2, data); set.Add(inputData); Label_0022: if (!dcsv.Next()) { return set; } Label_00C4: data = null; num = 0; if (((uint) num4) < 0) { goto Label_0108; } data2 = new BasicMLData(inputSize); int num2 = 0; Label_006A: if (num2 < inputSize) { double num3 = dcsv.GetDouble(num++); if (-2147483648 != 0) { data2[num2] = num3; if ((((uint) idealSize) + ((uint) num)) >= 0) { num2++; } if ((((uint) num) - ((uint) idealSize)) >= 0) { goto Label_006A; } goto Label_0125; } } else { if (0 == 0) { goto Label_000B; } if (0 == 0) { goto Label_0125; } } goto Label_00C4; Label_00FF: dcsv = new ReadCSV(filename, headers, format); Label_0108: if ((((uint) num) + ((uint) num2)) < 0) { goto Label_00FF; } goto Label_0022; Label_0125: if (((uint) num4) >= 0) { goto Label_000B; } return set; }
/// <summary> /// Clone this object. /// </summary> /// <returns>A clone of this object.</returns> public object Clone() { Object result; if (Ideal == null) result = new BasicMLDataPair((IMLData) _input.Clone()); else result = new BasicMLDataPair((IMLData) _input.Clone(), (IMLData) _ideal.Clone()); return result; }
/// <summary> /// Read an object. /// </summary> public Object Read(Stream mask0) { var ins0 = new EncogReadHelper(mask0); EncogFileSection section; var samples = new BasicMLDataSet(); IDictionary<String, String> networkParams = null; PNNKernelType kernel = default(PNNKernelType) /* was: null */; PNNOutputMode outmodel = default(PNNOutputMode) /* was: null */; int inputCount = 0; int outputCount = 0; double error = 0; double[] sigma = null; while ((section = ins0.ReadNextSection()) != null) { if (section.SectionName.Equals("PNN") && section.SubSectionName.Equals("PARAMS")) { networkParams = section.ParseParams(); } if (section.SectionName.Equals("PNN") && section.SubSectionName.Equals("NETWORK")) { IDictionary<String, String> paras = section.ParseParams(); inputCount = EncogFileSection.ParseInt(paras, PersistConst.InputCount); outputCount = EncogFileSection.ParseInt(paras, PersistConst.OutputCount); kernel = StringToKernel(paras[PersistConst.Kernel]); outmodel = StringToOutputMode(paras[PropertyOutputMode]); error = EncogFileSection .ParseDouble(paras, PersistConst.Error); sigma = section.ParseDoubleArray(paras, PersistConst.Sigma); } if (section.SectionName.Equals("PNN") && section.SubSectionName.Equals("SAMPLES")) { foreach (String line in section.Lines) { IList<String> cols = EncogFileSection .SplitColumns(line); int index = 0; var inputData = new BasicMLData(inputCount); for (int i = 0; i < inputCount; i++) { inputData[i] = CSVFormat.EgFormat.Parse(cols[index++]); } var idealData = new BasicMLData(inputCount); idealData[0] = CSVFormat.EgFormat.Parse(cols[index++]); IMLDataPair pair = new BasicMLDataPair(inputData, idealData); samples.Add(pair); } } } var result = new BasicPNN(kernel, outmodel, inputCount, outputCount); if (networkParams != null) { EngineArray.PutAll(networkParams, result.Properties); } result.Samples = samples; result.Error = error; if (sigma != null) { EngineArray.ArrayCopy(sigma, result.Sigma); } return result; }
/// <summary> /// Process the data array and returns an IMLdatapair. /// </summary> /// /// <param name="data">The array to process.</param> /// <returns>An IMLDatapair containing data.</returns> public IMLDataPair ProcessToPair(double[] data) { IMLDataPair pair = null; int totalWindowSize = _inputWindow + _predictWindow; int stopPoint = data.Length - totalWindowSize; for (int i = 0; i < stopPoint; i++) { IMLData inputData = new BasicMLData(_inputWindow); IMLData idealData = new BasicMLData(_predictWindow); int index = i; // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = data[index++]; } // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] = data[index++]; } pair = new BasicMLDataPair(inputData, idealData); } return pair; }
public IMLDataSet External2Memory() { double[] numArray; double[] numArray2; int num; int num2; double num3; IMLData data; IMLData data2; IMLDataPair pair; this.x658c509a55e4e71a.Report(0, 0, "Importing to memory"); goto Label_0166; Label_0017: if (1 == 0) { goto Label_011C; } Label_0021: if (this._x75d376891c19d365.Read(numArray, numArray2, ref num3)) { data = null; data2 = new BasicMLData(numArray); goto Label_00FF; } this._x75d376891c19d365.Close(); this.x658c509a55e4e71a.Report(0, 0, "Done importing to memory"); return this.Result; Label_0065: this.x658c509a55e4e71a.Report(0, num, "Importing..."); goto Label_0017; Label_00B8: pair = new BasicMLDataPair(data2, data); pair.Significance = num3; if (0 != 0) { goto Label_0166; } this.Result.Add(pair); if ((((uint) num3) - ((uint) num2)) >= 0) { num++; if ((((uint) num) & 0) != 0) { goto Label_016E; } if ((((uint) num) + ((uint) num)) < 0) { goto Label_00B8; } } if (3 != 0) { num2++; if (num2 < 0x2710) { goto Label_0021; } num2 = 0; goto Label_0065; } goto Label_0017; Label_00FF: if (this._x75d376891c19d365.IdealSize <= 0) { goto Label_00B8; } Label_011C: data = new BasicMLData(numArray2); if (0x7fffffff == 0) { goto Label_00FF; } goto Label_00B8; Label_0166: if (this.Result == null) { this.Result = new BasicMLDataSet(); if (0 == 0) { if (((uint) num3) > uint.MaxValue) { goto Label_0065; } } else { goto Label_01A6; } } Label_016E: numArray = new double[this._x75d376891c19d365.InputSize]; numArray2 = new double[this._x75d376891c19d365.IdealSize]; this._x75d376891c19d365.PrepareRead(); num = 0; num2 = 0; num3 = 1.0; Label_01A6: if ((((uint) num2) + ((uint) num)) <= uint.MaxValue) { goto Label_0021; } goto Label_00B8; }
/// <summary> /// Processes the specified double serie into an IMLDataset. /// To use this method, you must provide a formated double array with the input data and the ideal data in another double array. /// The number of points in the input window makes the input array , and the predict window will create the array used in ideal. /// This method will use ALL the data inputs and ideals you have provided. /// </summary> /// <param name="datainput">The datainput.</param> /// <param name="ideals">The ideals.</param> /// <param name="_inputWindow">The _input window.</param> /// <param name="_predictWindow">The _predict window.</param> /// <returns></returns> public static IMLDataSet ProcessDoubleSerieIntoIMLDataset(List<double> datainput,List<double>ideals, int _inputWindow, int _predictWindow) { var result = new BasicMLDataSet(); //int count = 0; ////lets check if there is a modulo , if so we move forward in the List of doubles in inputs.This is just a check ////as the data of inputs should be able to fill without having . //while (datainput.Count % _inputWindow !=0) //{ // count++; //} var inputData = new BasicMLData(_inputWindow); var idealData = new BasicMLData(_predictWindow); foreach (double d in datainput) { // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = d; } } foreach (double ideal in ideals) { // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] =ideal; } } var pair = new BasicMLDataPair(inputData, idealData); result.Add(pair); return result; }
public static BasicMLDataSet Generate(long seed, int count, int inputCount, int idealCount, double min, double max) { IMLData data; int num2; IMLData data2; BasicMLDataPair pair; LinearCongruentialGenerator generator = new LinearCongruentialGenerator(seed); BasicMLDataSet set = new BasicMLDataSet(); int num = 0; goto Label_0018; Label_000C: set.Add(pair); Label_0014: num++; Label_0018: if (num < count) { data = new BasicMLData(inputCount); num2 = 0; while (num2 < inputCount) { data.Data[num2] = generator.Range(min, max); num2++; } data2 = new BasicMLData(idealCount); if (((uint) count) < 0) { goto Label_000C; } if ((((uint) idealCount) & 0) != 0) { goto Label_0014; } int num3 = 0; Label_002D: if (num3 < idealCount) { data2[num3] = generator.Range(min, max); if ((((uint) idealCount) - ((uint) max)) <= uint.MaxValue) { num3++; goto Label_002D; } } else { goto Label_0032; } goto Label_00C6; } if (0 == 0) { return set; } Label_0032: pair = new BasicMLDataPair(data, data2); Label_00C6: if ((((uint) num2) & 0) == 0) { goto Label_000C; } goto Label_0018; }
public static void Generate(IMLDataSet training, long seed, int count, double min, double max) { int num; int idealSize; int num3; IMLData data; int num4; IMLData data2; int num5; LinearCongruentialGenerator generator = new LinearCongruentialGenerator(seed); goto Label_0111; Label_0023: if (num3 < count) { data = new BasicMLData(num); num4 = 0; while (true) { if (num4 < num) { data[num4] = generator.Range(min, max); } else { data2 = new BasicMLData(idealSize); num5 = 0; goto Label_004D; } num4++; } } if ((((uint) num) - ((uint) num)) >= 0) { if ((((uint) num4) - ((uint) num3)) >= 0) { if ((((uint) seed) + ((uint) seed)) >= 0) { return; } goto Label_0111; } goto Label_00F5; } Label_0047: num5++; Label_004D: if (num5 >= idealSize) { if ((((uint) max) + ((uint) num3)) <= uint.MaxValue) { BasicMLDataPair inputData = new BasicMLDataPair(data, data2); training.Add(inputData); num3++; } } else { data2[num5] = generator.Range(min, max); if (((uint) num5) >= 0) { goto Label_0047; } } goto Label_0023; Label_00F5: num3 = 0; goto Label_0023; Label_0111: num = training.InputSize; idealSize = training.IdealSize; goto Label_00F5; }
public IMLDataSet Process(double[] data) { int num; int num2; int num3; IMLData data2; IMLData data3; int num4; int num6; IMLDataSet set = new BasicMLDataSet(); goto Label_00F0; Label_0017: if (num3 < num2) { int num5; data2 = new BasicMLData(this._xdf118c3be13cc35d); do { data3 = new BasicMLData(this._x819dc6aed7346fc6); if ((((uint) num3) | 3) == 0) { goto Label_004D; } num4 = num3; } while ((((uint) num3) - ((uint) num5)) < 0); num5 = 0; if ((((uint) num5) | 0xff) != 0) { Label_007A: if (num5 < this._xdf118c3be13cc35d) { data2[num5] = data[num4++]; if ((((uint) num3) + ((uint) num5)) <= uint.MaxValue) { num5++; goto Label_007A; } } num6 = 0; goto Label_0053; } goto Label_00F0; } return set; Label_004D: num6++; Label_0053: if (num6 < this._x819dc6aed7346fc6) { data3[num6] = data[num4++]; if ((((uint) num6) | 15) == 0) { return set; } goto Label_004D; } IMLDataPair inputData = new BasicMLDataPair(data2, data3); set.Add(inputData); num3++; goto Label_0017; Label_00F0: num = this._xdf118c3be13cc35d + this._x819dc6aed7346fc6; num2 = data.Length - num; num3 = 0; goto Label_0017; }
/// <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(IMLDataSetAddable training, long seed, int count, double min, double max) { var rand = new LinearCongruentialGenerator(seed); int inputCount = training.InputSize; int idealCount = training.IdealSize; for (int i = 0; i < count; i++) { var inputData = new BasicMLData(inputCount); for (int j = 0; j < inputCount; j++) { inputData[j] = rand.Range(min, max); } var idealData = new BasicMLData(idealCount); for (int j = 0; j < idealCount; j++) { idealData[j] = rand.Range(min, max); } var pair = new BasicMLDataPair(inputData, idealData); training.Add(pair); } }
/// <summary> /// Add the specified data to the set. Add unsupervised data. /// </summary> /// <param name="data1">The data to add to the set.</param> public virtual void Add(IMLData data1) { IMLDataPair pair = new BasicMLDataPair(data1, null); _data.Add(pair); }
/// <summary> /// Processes the specified double serie into an IMLDataset. /// To use this method, you must provide a formated double array. /// The number of points in the input window makes the input array , and the predict window will create the array used in ideal. /// Example you have an array with 1, 2, 3 , 4 , 5. /// You can use this method to make an IMLDataset 4 inputs and 1 ideal (5). /// </summary> /// <param name="data">The data.</param> /// <param name="_inputWindow">The _input window.</param> /// <param name="_predictWindow">The _predict window.</param> /// <returns></returns> public static IMLDataSet ProcessDoubleSerieIntoIMLDataset(double[] data, int _inputWindow, int _predictWindow) { var result = new BasicMLDataSet(); int totalWindowSize = _inputWindow + _predictWindow; int stopPoint = data.Length - totalWindowSize; for (int i = 0; i < stopPoint; i++) { var inputData = new BasicMLData(_inputWindow); var idealData = new BasicMLData(_predictWindow); int index = i; // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = data[index++]; } // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] = data[index++]; } var pair = new BasicMLDataPair(inputData, idealData); result.Add(pair); } return result; }
/// <summary> /// Loads variables inputs and one ideal double series into an imldataset. /// </summary> /// <param name="idealsinputs"></param> /// <param name="WindoSize"></param> /// <param name="pparamInputs"></param> /// <returns></returns> public static Tuple<IMLDataSet, NormalizeArray> Load(double[] idealsinputs, int WindoSize, params double[][] pparamInputs) { try { var finalSet = new BasicMLDataSet(); //We make a dic with the count of inputs being the number of double series we are sending in. Dictionary<int, double[]> inputsDics = new Dictionary<int, double[]>(pparamInputs.Length); int indexS = 0; //We make a normalizeArray which we will return as a tuple ready for denormalization. NormalizeArray Normer = new NormalizeArray(-1, 1); //Process each inputs. foreach (double[] doubleSeries in pparamInputs) { inputsDics.Add(indexS++, Normer.Process(doubleSeries)); } //Process the ideals. var idealNormed = Normer.Process(idealsinputs); //Make a list which will hold the inputs one after the others List<double> dtda = new List<double>(); int listindex = 0; int currentindex = 0; //starts from zero so count -1.. int dicinputsCount = inputsDics.Keys.Count - 1; //Process the input normed. foreach (double d in inputsDics[0]) { if (currentindex++ < WindoSize) { dtda.Add(d); //we put all the fields which are in the dic. while (dicinputsCount > 0) { dtda.Add(inputsDics[dicinputsCount--][listindex]); } //We reset the field count for a later pass. dicinputsCount = inputsDics.Keys.Count - 1; } if (currentindex == WindoSize) { //Make an imldata pair, and add it to the imldataset...reset the temp list of inputs... var pair = new BasicMLDataPair( new BasicMLData(dtda.ToArray()), new BasicMLData(new double[] { idealNormed[listindex] })); currentindex = 0; dtda.Clear(); finalSet.Add(pair); } //Lets increment the indexes.. listindex++; } //Return the dataset and the normalization array.. return new Tuple<IMLDataSet, NormalizeArray>(finalSet,Normer); } catch (Exception ex) { Console.WriteLine("Got an error : ", ex); throw new Exception("Error parsing points...."); } }
/// <summary> /// Processes a double array of data of input and a second array of data for ideals /// you must input the input and output size. /// this typically builds a supervised IMLDatapair, which you must add to a IMLDataset. /// </summary> /// <param name="data">The data.</param> /// <param name="ideal">The ideal.</param> /// <param name="_inputWindow">The _input window.</param> /// <param name="_predictWindow">The _predict window.</param> /// <returns></returns> public static IMLDataPair ProcessPairs(double[] data, double[] ideal, int _inputWindow, int _predictWindow) { var result = new BasicMLDataSet(); for (int i = 0; i < data.Length; i++) { var inputData = new BasicMLData(_inputWindow); var idealData = new BasicMLData(_predictWindow); int index = i; // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = data[index++]; } index = 0; // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] = ideal[index++]; } IMLDataPair pair = new BasicMLDataPair(inputData, idealData); return pair; } return null; }
/// <summary> /// Convert an external file format, such as CSV, to an Encog memory training set. /// </summary> public IMLDataSet External2Memory() { Status.Report(0, 0, "Importing to memory"); if (Result == null) { Result = new BasicMLDataSet(); } var input = new double[_codec.InputSize]; var ideal = new double[_codec.IdealSize]; _codec.PrepareRead(); int currentRecord = 0; int lastUpdate = 0; double significance = 1.0; while (_codec.Read(input, ideal, ref significance)) { IMLData b = null; IMLData a = new BasicMLData(input); if (_codec.IdealSize > 0) b = new BasicMLData(ideal); IMLDataPair pair = new BasicMLDataPair(a, b); pair.Significance = significance; Result.Add(pair); currentRecord++; lastUpdate++; if (lastUpdate >= 10000) { lastUpdate = 0; Status.Report(0, currentRecord, "Importing..."); } } _codec.Close(); Status.Report(0, 0, "Done importing to memory"); return Result; }
/// <inheritdoc/> public void Add(IMLData inputData, IMLData idealData) { IMLDataPair pair = new BasicMLDataPair(inputData, idealData); _currentSequence.Add(pair); }
/// <summary> /// Create a new neural data pair object of the correct size for the neural /// network that is being trained. This object will be passed to the getPair /// method to allow the neural data pair objects to be copied to it. /// </summary> /// <param name="inputSize">The size of the input data.</param> /// <param name="idealSize">The size of the ideal data.</param> /// <returns>A new neural data pair object.</returns> public static IMLDataPair CreatePair(int inputSize, int idealSize) { IMLDataPair result; if (idealSize > 0) { result = new BasicMLDataPair(new BasicMLData(inputSize), new BasicMLData(idealSize)); } else { result = new BasicMLDataPair(new BasicMLData(inputSize)); } return result; }
/// <summary> /// Add supervised data to the set. /// </summary> /// <param name="inputData">The input data.</param> /// <param name="idealData">The ideal data.</param> public virtual void Add(IMLData inputData, IMLData idealData) { IMLDataPair pair = new BasicMLDataPair(inputData, idealData); _data.Add(pair); }
public object Read(Stream mask0) { EncogFileSection section; double num3; double[] numArray; IDictionary<string, string> dictionary2; int num4; int num5; int num6; BasicPNN cpnn; EncogReadHelper helper = new EncogReadHelper(mask0); BasicMLDataSet set = new BasicMLDataSet(); IDictionary<string, string> source = null; PNNKernelType gaussian = PNNKernelType.Gaussian; PNNOutputMode unsupervised = PNNOutputMode.Unsupervised; int inputCount = 0; int outputCount = 0; goto Label_042A; Label_000C: cpnn.Error = num3; while (numArray != null) { EngineArray.ArrayCopy(numArray, cpnn.Sigma); return cpnn; } if ((((uint) num3) - ((uint) outputCount)) <= uint.MaxValue) { if ((((uint) num5) - ((uint) outputCount)) >= 0) { return cpnn; } if ((((uint) inputCount) - ((uint) inputCount)) >= 0) { goto Label_0319; } if (((uint) num4) >= 0) { goto Label_02F1; } goto Label_02BB; } goto Label_00D8; Label_0075: while (source != null) { EngineArray.PutAll<string, string>(source, cpnn.Properties); if ((((uint) outputCount) + ((uint) num3)) >= 0) { break; } } cpnn.Samples = set; goto Label_00A5; Label_0082: if ((section = helper.ReadNextSection()) != null) { if (section.SectionName.Equals("PNN") && (((((uint) num4) & 0) != 0) || section.SubSectionName.Equals("PARAMS"))) { source = section.ParseParams(); } if (section.SectionName.Equals("PNN") && section.SubSectionName.Equals("NETWORK")) { dictionary2 = section.ParseParams(); if ((((uint) outputCount) + ((uint) num6)) <= uint.MaxValue) { inputCount = EncogFileSection.ParseInt(dictionary2, "inputCount"); outputCount = EncogFileSection.ParseInt(dictionary2, "outputCount"); } gaussian = StringToKernel(dictionary2["kernel"]); if (0 != 0) { return cpnn; } unsupervised = StringToOutputMode(dictionary2["outputMode"]); goto Label_0319; } goto Label_02BB; } cpnn = new BasicPNN(gaussian, unsupervised, inputCount, outputCount); if (4 != 0) { goto Label_0075; } Label_00A5: if ((((uint) outputCount) | 15) != 0) { goto Label_000C; } goto Label_0082; Label_00D8: if (0 != 0) { goto Label_042A; } if ((((uint) num3) | 1) != 0) { goto Label_0082; } goto Label_000C; Label_02BB: if (section.SectionName.Equals("PNN")) { if (((uint) inputCount) > uint.MaxValue) { goto Label_0075; } if (section.SubSectionName.Equals("SAMPLES")) { using (IEnumerator<string> enumerator = section.Lines.GetEnumerator()) { string str; IList<string> list; IMLData data; IMLData data2; IMLDataPair pair; goto Label_0193; Label_0174: set.Add(pair); if ((((uint) num4) & 0) != 0) { goto Label_0206; } Label_0193: if (enumerator.MoveNext()) { goto Label_0255; } goto Label_0082; Label_01A1: data2[num6] = CSVFormat.EgFormat.Parse(list[num4++]); num6++; Label_01C8: if (num6 < outputCount) { goto Label_01A1; } pair = new BasicMLDataPair(data, data2); if (((uint) num3) >= 0) { goto Label_0174; } goto Label_0082; Label_01ED: if (((uint) num5) > uint.MaxValue) { goto Label_0238; } num6 = 0; goto Label_01C8; Label_0206: num5 = 0; while (num5 < inputCount) { data[num5] = CSVFormat.EgFormat.Parse(list[num4++]); num5++; } Label_0238: data2 = new BasicMLData(inputCount); goto Label_01ED; Label_0245: num4 = 0; data = new BasicMLData(inputCount); goto Label_0206; Label_0255: str = enumerator.Current; list = EncogFileSection.SplitColumns(str); if ((((uint) num6) + ((uint) num4)) <= uint.MaxValue) { goto Label_0245; } goto Label_0082; } if ((((uint) inputCount) + ((uint) num5)) <= uint.MaxValue) { if ((((uint) outputCount) + ((uint) num6)) <= uint.MaxValue) { goto Label_033B; } goto Label_0319; } goto Label_02F1; } } goto Label_0082; Label_02F1: numArray = EncogFileSection.ParseDoubleArray(dictionary2, "sigma"); goto Label_02BB; Label_0319: num3 = EncogFileSection.ParseDouble(dictionary2, "error"); if ((((uint) inputCount) & 0) == 0) { goto Label_02F1; } Label_033B: if ((((uint) inputCount) & 0) == 0) { goto Label_00D8; } return cpnn; Label_042A: num3 = 0.0; numArray = null; if ((((uint) num4) - ((uint) num6)) < 0) { goto Label_0075; } goto Label_0082; }