using System;

using System.IO;

​

namespace SimpleNeuralNetworkWithCSV

{

    class Program

    {

        static void Main(string[] args)

        {

            // Define the network structure

            int[] layers = new[] { 2, 2, 1 };

            NeuralNetwork nn = new NeuralNetwork(layers);

​

            // Load training data from CSV

            var (input, output) = LoadData("data.csv");

​

            // Train the network

            nn.Train(input, output, 10000);

​

            // Test the network

            foreach (var data in input)

            {

                var result = nn.Predict(data);

                Console.WriteLine($"Input: {string.Join(", ", data)} => Output: {result[0]}");

            }

        }

​

        static (double[][], double[][]) LoadData(string filePath)

        {

            var lines = File.ReadAllLines(filePath);

            double[][] inputs = new double[lines.Length][];

            double[][] outputs = new double[lines.Length][];

​

            for (int i = 0; i < lines.Length; i++)

            {

                var values = lines[i].Split(',');

                inputs[i] = new double[] { double.Parse(values[0]), double.Parse(values[1]) };

                outputs[i] = new double[] { double.Parse(values[2]) };

            }

​

            return (inputs, outputs);

        }

    }

​

    public class NeuralNetwork

    {

        private int[] layers;

        private double[][] neurons;

        private double[][][] weights;

        private Random random = new Random();

​

        public NeuralNetwork(int[] layers)

        {

            this.layers = layers;

            InitializeNeurons();

            InitializeWeights();

        }

​

        private void InitializeNeurons()

        {

            neurons = new double[layers.Length][];

            for (int i = 0; i < layers.Length; i++)

            {

                neurons[i] = new double[layers[i]];

            }

        }

​

        private void InitializeWeights()

        {

            weights = new double[layers.Length - 1][][];

            for (int i = 0; i < layers.Length - 1; i++)

            {

                weights[i] = new double[layers[i]][];

                for (int j = 0; j < layers[i]; j++)

                {

                    weights[i][j] = new double[layers[i + 1]];

                    for (int k = 0; k < layers[i + 1]; k++)

                    {

                        weights[i][j][k] = random.NextDouble() - 0.5;

                    }

                }

            }

        }

​

        public void Train(double[][] inputs, double[][] outputs, int iterations)

        {

            for (int i = 0; i < iterations; i++)

            {

                for (int j = 0; j < inputs.Length; j++)

                {

                    Forward(inputs[j]);

                    Backward(outputs[j]);

                }

            }

        }

​

        private void Forward(double[] input)

        {

            for (int i = 0; i < input.Length; i++)

            {

                neurons[0][i] = input[i];

            }

​

            for (int i = 1; i < layers.Length; i++)

            {

                for (int j = 0; j < layers[i]; j++)

                {

                    double value = 0;

                    for (int k = 0; k < layers[i - 1]; k++)

                    {

                        value += neurons[i - 1][k] * weights[i - 1][k][j];

                    }

                    neurons[i][j] = Sigmoid(value);

                }

            }

        }

​

        private void Backward(double[] output)

        {

            double[][] errors = new double[layers.Length][];

            for (int i = 0; i < layers.Length; i++)

            {

                errors[i] = new double[layers[i]];

            }

​

            for (int i = 0; i < output.Length; i++)

            {

                errors[layers.Length - 1][i] = neurons[layers.Length - 1][i] - output[i];

            }

​

            for (int i = layers.Length - 2; i >= 0; i--)

            {

                for (int j = 0; j < layers[i]; j++)

                {

                    double error = 0;

                    for (int k = 0; k < layers[i + 1]; k++)

                    {

                        error += errors[i + 1][k] * weights[i][j][k];

                    }

                    errors[i][j] = error * SigmoidDerivative(neurons[i][j]);

                }

            }

​

            for (int i = 0; i < layers.Length - 1; i++)

            {

                for (int j = 0; j < layers[i]; j++)

                {

                    for (int k = 0; k < layers[i + 1]; k++)

                    {

                        weights[i][j][k] -= errors[i + 1][k] * neurons[i][j];

                    }

                }

            }

        }

​

        private double Sigmoid(double x)

        {

            return 1.0 / (1.0 + Math.Exp(-x));

        }

​

        private double SigmoidDerivative(double x)

        {

            return x * (1.0 - x);

        }

​

        public double[] Predict(double[] input)

        {

            Forward(input);

            return neurons[layers.Length - 1];

        }

    }

}

​