Beispiel #1
0
        static void Main(string[] args)
        {
            IActivationFunction activationFunction = new TanH();

            for (float x = -2; x < 2; x += 0.1f)
            {
                Debug.Write($"{activationFunction.ActivationDerivative((float)Math.Tanh(x))},");
                //Debug.Write($"{Math.Tanh(x)},");
            }

            // Create the random object.
            Random random = new Random();

            // Load the data set.
            DigitDataSet digitDataSet = DigitDataSet.LoadFromFile("Files/labels.idx1-ubyte", "Files/images.idx3-ubyte");
            DigitDataSet testSet      = DigitDataSet.LoadFromFile("Files/t10k-labels.idx1-ubyte", "Files/t10k-images.idx3-ubyte");

            // Take input.
            Console.WriteLine("Choose the size of a batch.");
            int batchSize = int.Parse(Console.ReadLine());

            Console.WriteLine("Choose number of epochs.");
            int epochs = int.Parse(Console.ReadLine());

            // Create the neural network.
            NeuralNetwork neuralNetwork = new NeuralNetwork(random, new int[] { digitDataSet.ImageWidth *digitDataSet.ImageHeight, 30, 10 }, 3.0f);  //Network.NeuralNetwork.Load(new XmlNetworkLoader("DigitRecognition.xml"));

            neuralNetwork.LearnOverData(random, digitDataSet, epochs, batchSize, new NetworkConsoleLogger(OutputOptions.All ^ OutputOptions.CurrentData), testSet);
            //neuralNetwork.LearnOverData(random, digitDataSet, epochs, batchSize, new NetworkConsoleLogger(OutputOptions.None ^ OutputOptions.WhenFinished), testSet);

            neuralNetwork.Save(new XmlNetworkSaver("DigitRecognition.xml", true));

            Console.ReadKey();
        }
Beispiel #2
0
        public void CalculateTest(double firstValue, double expected)
        {
            var calculator   = new TanH();
            var actualResult = calculator.Calculate(firstValue);

            Assert.AreEqual(expected, actualResult, 0.0001);
        }
        private void btn_createNetwork_Click(object sender, RoutedEventArgs e)
        {
            int[] layers = new int[this.wp_layers.Items.Count + 2];
            layers[0] = Convert.ToInt32((this.ucInputLayer.Content as NetwokLayerSizeControl).GetLayerSize());

            for (int i = 1; i < layers.Length - 1; i++)
            {
                layers[i] = Convert.ToInt32((this.wp_layers.Items[i - 1] as NetwokLayerSizeControl).GetLayerSize());
            }

            layers[layers.Length - 1] = Convert.ToInt32((this.ucOutputLayer.Content as NetwokLayerSizeControl).GetLayerSize());

            ActivationStrategy acti = new Sigmoid();

            if (this.cb_activationFunctions.SelectedIndex == 0)
            {
                acti = new Sigmoid();
            }
            else if (this.cb_activationFunctions.SelectedIndex == 1)
            {
                acti = new TanH();
            }
            else if (this.cb_activationFunctions.SelectedIndex == 2)
            {
                acti = new ReLU();
            }

            NetworkHelper.SaveNetToFile(new NeuralNetwork(layers, acti), "neuralNetwork.txt");
            MessageBox.Show("Success!");
        }
Beispiel #4
0
        private List <IKernelDescriptor> ReadDescriptors(JObject model)
        {
            List <IKernelDescriptor> dscps = model.SelectToken("descriptors").Select(layer => {
                IKernelDescriptor descriptor = null;

                String layerName = (String)layer.SelectToken("layer");

                switch (layerName)
                {
                case "AvgPooling1D":
                    descriptor = new AvgPooling1D(
                        (int)layer.SelectToken("padding"),
                        (int)layer.SelectToken("stride"),
                        (int)layer.SelectToken("kernel_size"));
                    break;

                case "GlobalAveragePooling1D":
                    descriptor = new GlobalAvgPooling1D();
                    break;

                case "AvgPooling2D":
                    descriptor = new AvgPooling2D((int)layer.SelectToken("padding_vl"), (int)layer.SelectToken("padding_hz"),
                                                  (int)layer.SelectToken("stride_vl"), (int)layer.SelectToken("stride_hz"),
                                                  (int)layer.SelectToken("kernel_height"), (int)layer.SelectToken("kernel_width"));
                    break;

                case "GlobalAveragePooling2D":
                    descriptor = new GlobalAvgPooling2D();
                    break;

                case "BatchNormalization":
                    descriptor = new BatchNormalization(
                        (int)layer.SelectToken("epsilon"));
                    break;

                case "Cropping1D":
                    descriptor = new Cropping1D(
                        (int)layer.SelectToken("trimBegin"),
                        (int)layer.SelectToken("trimEnd"));
                    break;

                case "Cropping2D":
                    descriptor = new Cropping2D(
                        (int)layer.SelectToken("topTrim"),
                        (int)layer.SelectToken("bottomTrim"),
                        (int)layer.SelectToken("leftTrim"),
                        (int)layer.SelectToken("rightTrim"));
                    break;

                case "MaxPooling1D":
                    descriptor = new MaxPooling1D(
                        (int)layer.SelectToken("padding"),
                        (int)layer.SelectToken("stride"),
                        (int)layer.SelectToken("kernel_size"));
                    break;

                case "GlobalMaxPooling1D":
                    descriptor = new GlobalMaxPooling1D();
                    break;

                case "MaxPooling2D":
                    descriptor = new MaxPooling2D((int)layer.SelectToken("padding_vl"), (int)layer.SelectToken("padding_hz"),
                                                  (int)layer.SelectToken("stride_vl"), (int)layer.SelectToken("stride_hz"),
                                                  (int)layer.SelectToken("kernel_height"), (int)layer.SelectToken("kernel_width"));
                    break;

                case "GlobalMaxPooling2D":
                    descriptor = new GlobalMaxPooling2D();
                    break;

                case "Convolution1D":
                    descriptor = new Convolution1D(
                        (int)layer.SelectToken("padding"),
                        (int)layer.SelectToken("stride"),
                        (int)layer.SelectToken("kernel_size"),
                        (int)layer.SelectToken("kernel_num"));
                    break;

                case "Convolution2D":
                    descriptor = new Convolution2D((int)layer.SelectToken("padding_vl"), (int)layer.SelectToken("padding_hz"),
                                                   (int)layer.SelectToken("stride_vl"), (int)layer.SelectToken("stride_hz"),
                                                   (int)layer.SelectToken("kernel_height"), (int)layer.SelectToken("kernel_width"),
                                                   (int)layer.SelectToken("kernel_num"));
                    break;

                case "Dense2D":
                    descriptor = new Dense2D((int)layer.SelectToken("units"));
                    break;

                case "Input2D":
                    descriptor = new Input2D((int)layer.SelectToken("height"), (int)layer.SelectToken("width"),
                                             (int)layer.SelectToken("channel"), (int)layer.SelectToken("batch"));
                    break;

                case "Bias2D":
                    descriptor = new Bias2D();
                    break;

                case "Permute":
                    descriptor = new Permute(
                        (int)layer.SelectToken("dim1"),
                        (int)layer.SelectToken("dim2"),
                        (int)layer.SelectToken("dim3"));
                    break;

                case "Reshape":
                    descriptor = new Reshape2D(
                        (int)layer.SelectToken("height"),
                        (int)layer.SelectToken("width"),
                        (int)layer.SelectToken("channel"),
                        1);
                    break;

                case "RepeatVector":
                    descriptor = new RepeatVector(
                        (int)layer.SelectToken("num"));
                    break;

                case "SimpleRNN":
                    descriptor = new SimpleRNN(
                        (int)layer.SelectToken("units"),
                        (int)layer.SelectToken("input_dim"),
                        ANR((string)layer.SelectToken("activation")));
                    break;

                case "LSTM":
                    descriptor = new LSTM(
                        (int)layer.SelectToken("units"),
                        (int)layer.SelectToken("input_dim"),
                        ANR((string)layer.SelectToken("activation")),
                        ANR((string)layer.SelectToken("rec_act")));
                    break;

                case "GRU":
                    descriptor = new GRU(
                        (int)layer.SelectToken("units"),
                        (int)layer.SelectToken("input_dim"),
                        ANR((string)layer.SelectToken("activation")),
                        ANR((string)layer.SelectToken("rec_act")));
                    break;

                case "ELu":
                    descriptor = new ELu(1);
                    break;

                case "HardSigmoid":
                    descriptor = new HardSigmoid();
                    break;

                case "ReLu":
                    descriptor = new ReLu();
                    break;

                case "Sigmoid":
                    descriptor = new Sigmoid();
                    break;

                case "Flatten":
                    descriptor = new Flatten();
                    break;

                case "Softmax":
                    descriptor = new Softmax();
                    break;

                case "SoftPlus":
                    descriptor = new SoftPlus();
                    break;

                case "SoftSign":
                    descriptor = new Softsign();
                    break;

                case "TanH":
                    descriptor = new TanH();
                    break;

                default:
                    throw new Exception("Unknown layer type!");
                }

                return(descriptor);
            }).ToList();

            return(dscps);
        }