Exemplo n.º 1
0
        public void NormalizeSunspots(double lo, double hi)
        {
            array= new NormalizeArray { NormalizedHigh = hi, NormalizedLow = lo };

            // create arrays to hold the normalized sunspots
            _normalizedSunspots = array.Process(Sunspots);
            _closedLoopSunspots = EngineArray.ArrayCopy(_normalizedSunspots);
        }
Exemplo n.º 2
0
 public Stage1NeuralNetwork(int windowSize, int iterations, double[] trainingData, double[] predictData)
 {
     WindowSize = windowSize;
     this.iterations = iterations;
     this.trainingData = trainingData;
     predictionData = predictData;
     normalizeArray = new NormalizeArray {NormalizedHigh = normalizeHi, NormalizedLow = normalizeLo};
 }
 public void TestNormalize()
 {
     var norm = new NormalizeArray();
     double[] input = {1, 5, 10};
     double[] output = norm.Process(input);
     Assert.AreEqual(3, output.Length);
     Assert.AreEqual(-1.0, output[0]);
     Assert.AreEqual(1.0, output[2]);
     Assert.AreEqual(1.0, norm.Stats.ActualLow);
     Assert.AreEqual(10.0, norm.Stats.ActualHigh);
 }
Exemplo n.º 4
0
 public Stage2NeuralNetwork(int inputs, int iterations, DenseMatrix trainingData, double[] predictData)
 {
     this.inputs = inputs;
     this.iterations = iterations;
     this.trainingData = trainingData;
     predictionData = predictData;
     normalizeArrayInput = new NormalizeArray[trainingData.RowCount];
     for (int i = 0; i < normalizeArrayInput.Length; i++)
         normalizeArrayInput[i] = new NormalizeArray {NormalizedHigh = normalizeHi, NormalizedLow = normalizeLo};
     normalizeArrayOutput = new NormalizeArray {NormalizedHigh = normalizeHi, NormalizedLow = normalizeLo};
 }
Exemplo n.º 5
0
        /// <summary>
        /// Send all the (unNormalized)inputs in the as the network was trained and this outputs a list of double ready for a network.compute(imldata result)).
        /// </summary>
        /// <param name="WindoSize"> Size of the windo. </param>
        /// <param name="pparamInputs"> A variable-length parameters list containing pparam inputs. </param>
        /// <returns>
        ///  The compute pair ready for network computes)
        /// </returns>
        public static Tuple<List<double>, NormalizeArray> GetReadiedComputePair(int WindoSize, params double[][] pparamInputs)
        {
            try
            {
                //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;
                NormalizeArray Normee = new NormalizeArray(-1, 1);
                // PredictionStats.NormalizationClass NormingClass = new PredictionStats.NormalizationClass();
                foreach (double[] doubleSeries in pparamInputs)
                {
                    inputsDics.Add(indexS++, Normee.Process(doubleSeries));
                }
                List<double> dtda = new List<double>();
                int listindex = 0;
                int currentindex = 0;
                //count the fields -1 ,as it starts from zero.
                int dicinputsCount = inputsDics.Keys.Count - 1;
                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)
                    {
                        return new Tuple<List<double>, NormalizeArray>(dtda, Normee);
                    }
                    //Lets increment the indexes..
                    listindex++;
                }
                return new Tuple<List<double>, NormalizeArray>(dtda, Normee);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Exemplo n.º 6
0
 /// <summary>
 ///     Normalizes an array using Normalize Array (and not DataNormalization way : Faster).
 ///     The high and low are the standard -1,1.
 /// </summary>
 /// <param name="arrays">The arrays.</param>
 /// <returns>returns a tuple with the array in item1 and the normalization in item 2.</returns>
 public static Tuple<double[], NormalizeArray> NormalizeArray(double[] arrays)
 {
     var norm = new NormalizeArray();
     return new Tuple<double[], NormalizeArray>(norm.Process(arrays), norm);
 }
Exemplo n.º 7
0
 /// <summary>
 ///     Normalizes an array using Normalize Array (and not DataNormalization way : Faster).
 /// </summary>
 /// <param name="lo">The lo.</param>
 /// <param name="hi">The hi.</param>
 /// <param name="arrays">The arrays.</param>
 /// <returns></returns>
 public static double[] NormalizeArray(double lo, double hi, double[] arrays)
 {
     var norm = new NormalizeArray {NormalizedHigh = hi, NormalizedLow = lo};
     return norm.Process(arrays);
 }
 public void NormalizeForexPair(double lo, double hi)
 {
     array= new NormalizeArray { NormalizedHigh = hi, NormalizedLow = lo };
     // create arrays to hold the normalized forex pair data
     _normalizedForexPair = array.Process(ForexPair);
     _closedLoopForexPair = EngineArray.ArrayCopy(_normalizedForexPair);
 }
            public static void normalizeSunspots(double lo, double hi)
            {
                NormalizeArray norm = new NormalizeArray();
                norm.NormalizedHigh=( hi);
                norm.NormalizedLow =  lo;

                // create arrays to hold the normalized sunspots
                normalizedSunspots = norm.Process(SUNSPOTS);
                closedLoopSunspots = EngineArray.ArrayCopy(normalizedSunspots);
            }
Exemplo n.º 10
0
        /// <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....");
            }
        }