コード例 #1
0
        public static void Optimize(
            string inputFileName, string outputFileName,
            int[][] layers,
            double minThreshold, double maxThreshold, double thresholdStepSize,
            int minTrades,
            int iterations,
            int randomize,
            string[] validationFileNames)
        {
            FsdParser inputParser = FsdParser.FromFile(inputFileName);
            FsdParser[] validationParsers = new FsdParser[validationFileNames.Length];

            for (int valParIdx = 0; valParIdx < validationParsers.Length; valParIdx++)
            {
                validationParsers[valParIdx] =
                    FsdParser.FromFile(validationFileNames[valParIdx]);
            }

            Optimize(
                inputParser, outputFileName,
                layers,
                minThreshold, maxThreshold, thresholdStepSize,
                minTrades,
                iterations,
                randomize,
                validationParsers);
        }
コード例 #2
0
        public static void Optimize(
            FsdParser inputParser, string outputFileName,
            int[][] layers,
            double minThreshold, double maxThreshold, double thresholdStepSize,
            int minTrades,
            int iterations,
            int randomize,
            FsdParser[] validationParsers)
        {
            HashSet<int[]> layerCombinations;
            getLayerCombinations(layers, out layerCombinations);

            Network bestNetwork = null;
            double bestThreshold = double.NaN;
            double bestMinWinRate = double.NegativeInfinity;

            int cursorLeft = Console.CursorLeft;
            int cursorTop = Console.CursorTop;

            int numTotalIterations = (int)(layerCombinations.Count * ((maxThreshold - minThreshold) / thresholdStepSize + 1) * iterations);
            int numIterations = 0;

            foreach (int[] layerCombination in layerCombinations)
            {
                ActivationNetwork network = new ActivationNetwork(
                    new SigmoidFunction(),
                    inputParser.InputVectors[0].Length,
                    layerCombination);

                network.Randomize();

                ParallelResilientBackpropagationLearning teacher = new ParallelResilientBackpropagationLearning(network);

                for (double threshold = minThreshold; threshold <= maxThreshold; threshold += thresholdStepSize)
                {
                    for (int iteration = 1; iteration <= iterations; iteration++)
                    {
                        numIterations++;

                        Console.CursorLeft = cursorLeft;
                        Console.CursorTop = cursorTop;

                        Console.Write(new string(' ', Console.BufferWidth * 10));

                        Console.CursorLeft = cursorLeft;
                        Console.CursorTop = cursorTop;

                        Console.Write("layerCombination[]: { ");

                        for (int layerComponentIdx = 0; layerComponentIdx < layerCombination.Length; layerComponentIdx++)
                        {
                            Console.Write(layerCombination[layerComponentIdx]);
                            if (layerComponentIdx < layerCombination.Length - 1)
                                Console.Write(", ");
                        }

                        Console.WriteLine(" }");

                        Console.WriteLine("threshold: {0:0.00}", threshold);
                        Console.WriteLine("iteration: {0}", iteration);
                        Console.WriteLine("bestMinWinRate: {0:0.00}%", bestMinWinRate);
                        Console.WriteLine("");
                        Console.WriteLine("Progress: {0:0.00}%", (double)numIterations / numTotalIterations * 100.0);

                        if (randomize > 0 && (iteration - 1) % randomize == 0)
                            network.Randomize();

                        teacher.RunEpoch(inputParser.InputVectors, inputParser.OutputVectors);

                        bool validData = true;
                        double minWinRate = double.PositiveInfinity;

                        foreach (FsdParser validationParser in validationParsers)
                        {
                            int numTradesWon, numTradesLost;
                            double tradeWinRate;

                            getStatistics(network, validationParser, threshold, out numTradesWon, out numTradesLost, out tradeWinRate);

                            if (numTradesWon + numTradesLost < minTrades)
                            {
                                validData = false;
                                break;
                            }

                            minWinRate = Math.Min(minWinRate, tradeWinRate);

                            if (minWinRate < bestMinWinRate)
                            {
                                validData = false;
                                break;
                            }
                        }

                        if (validData)
                        {
                            bestNetwork = network;
                            bestThreshold = threshold;
                            bestMinWinRate = minWinRate;

                            network.Save(outputFileName);

                            // Konfigurationsinformationen speichern
                            string configuration = "";
                            configuration += "layerCombination[]: { ";

                            for (int layerComponentIdx = 0; layerComponentIdx < layerCombination.Length; layerComponentIdx++)
                            {
                                configuration += layerCombination[layerComponentIdx];
                                if (layerComponentIdx < layerCombination.Length - 1)
                                    configuration += ", ";
                            }

                            configuration += " }\r\n";

                            configuration += string.Format("threshold: {0:0.00}\r\n", threshold);
                            configuration += string.Format("iteration: {0}\r\n", iteration);
                            configuration += string.Format("bestMinWinRate: {0:0.00}%\r\n", bestMinWinRate);

                            File.WriteAllText(outputFileName + ".txt", configuration);
                        }
                    }
                }
            }
        }
コード例 #3
0
        private static void getStatistics(Network network, FsdParser parser, double threshold,
            out int numTradesWon, out int numTradesLost, out double tradeWinRate)
        {
            numTradesWon = 0;
            numTradesLost = 0;

            int numSamples = parser.InputVectors.Length;

            for (int sampleIdx = 0; sampleIdx < numSamples; sampleIdx++)
            {
                double[] computed = network.Compute(parser.InputVectors[sampleIdx]);

                if (computed[0] > threshold && computed[1] < threshold)
                {
                    // Netzwerk hat "Rise" errechnet
                    if (parser.OutputVectors[sampleIdx][0] == 1)
                    {
                        numTradesWon++;
                    }
                    else
                    {
                        numTradesLost++;
                    }
                }
                else if (computed[1] > threshold && computed[0] < threshold)
                {
                    // Netzwerk hat "Fall" errechnet
                    if (parser.OutputVectors[sampleIdx][1] == 1)
                    {
                        numTradesWon++;
                    }
                    else
                    {
                        numTradesLost++;
                    }
                }
            }

            tradeWinRate = (double)numTradesWon / (numTradesWon + numTradesLost);
        }