Перцептрон

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            int Seed = Guid.NewGuid().GetHashCode();
            Random random = new Random(Seed);
            Console.WriteLine("Seed: " + Seed);
            Console.WriteLine();
 
            // Study data
            int[][] input_data = new int[][]{
                new int[] { 0, 0 },
                new int[] { 0, 1 },
                new int[] { 1, 0 },
                new int[] { 1, 1 },
            };
            int[][] output_data = new int[][]{
                new int[] { 0 },
                new int[] { 1 },
                new int[] { 1 },
                new int[] { 0 },
            };
 
            // Check
            if (input_data.Length != output_data.Length)
                throw new Exception("[ERROR] InputVector.Length != OutputVector.Length");
            for (int i = 1, j = input_data[0].Length; i < input_data.Length; i++)
                if (input_data[i].Length != j)
                    throw new Exception("[ERROR] (InputVector) Length [i - 1] != [i]");
            for (int i = 1, j = output_data[0].Length; i < output_data.Length; i++)
                if (output_data[i].Length != j)
                    throw new Exception("[ERROR] (OutputVector) Length [i - 1] != [i]");
 
            // Layers
            int[] S = new int[input_data[0].Length];
            (int, int)[] A = new(int, int)[3]; // Activate, Theta
            (int, int)[] R = new(int, int)[output_data[0].Length]; // Activate, Theta
 
            // Links
            List<(int, int, int)> SA_links = new List<(int, int, int)>();
            (int, int, int)[] AR_links = new(int, int, int)[A.Length * R.Length];
 
            // Create SA links
            for (int i = 0; i < A.Length; i++)
            {
                HashSet<int> used = new HashSet<int>();
 
                for (int j = 0, u = random.Next(1, S.Length + 1); j < u; j++)
                {
                    int num = int.MinValue;
 
                    do
                    {
                        num = random.Next(S.Length);
                    } while (!used.Add(num));
 
                    SA_links.Add((num, i, random.Next(2) == 0 ? -1 : 1));
                }
            }
 
            // Create AR links
            for (int i = 0; i < A.Length; i++)
                for (int j = 0; j < R.Length; j++)
                    AR_links[i * R.Length + j] = (i, j, 0);
 
            #region Functions
            Func<int[], int> SetS = delegate (int[] input)
            {
                if (input.Length != S.Length)
                    return 1;
 
                for (int i = 0; i < input.Length; i++)
                    S[i] = input[i];
 
                return 0;
            };
 
            Func<int> RecalcA = delegate () {
                for (int i = 0; i < A.Length; i++)
                {
                    A[i].Item1 = 0;
 
                    foreach (var link in SA_links.Where((v) => (v.Item2 == i)))
                    {
                        if (S[link.Item1] == 1)
                        {
                            A[i].Item1 += link.Item3;
                        }
                    }
 
                    A[i].Item1 = (A[i].Item1 > A[i].Item2) ? 1 : 0;
                }
 
                return 0;
            };
 
            Func<int> RecalcR = delegate ()
            {
                for (int i = 0; i < R.Length; i++)
                {
                    R[i].Item1 = 0;
                    foreach(var link in AR_links.Where((v) => (v.Item2 == i)))
                        R[i].Item1 += link.Item3 * A[link.Item1].Item1;
 
                    R[i].Item1 = (R[i].Item1 == 0) ? 0 : (R[i].Item1 < R[i].Item2 ? -1 : 1);
                }
 
                return 0;
            };
            #endregion Functions
 
            #region Study
            for (int step = 0; step < 1e4; step++)
            {
                int sampleInd = random.Next(input_data.Length);
                SetS(input_data[sampleInd]);
                RecalcA();
 
                for (int i = 0; i < A.Length; i++)
                {
                    if (A[i].Item1 == 1)
                    {
                        for (int j = 0; j < AR_links.Length; j++)
                        {
                            if (AR_links[j].Item1 == i)
                            {
                                for (int f = 0; f < R.Length; f++)
                                {
                                    if (AR_links[j].Item2 == f)
                                    {
                                        AR_links[j].Item3 += (output_data[sampleInd][f] == 1 ? 1 : -1);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            #endregion Study
 
            #region DebugOutput
            for (int i = 0; i < input_data.Length; i++)
            {
                Console.Write("{");
                for (int u = 0; u < input_data[i].Length; u++)
                    Console.Write(input_data[i][u] + (u < input_data[i].Length - 1 ? ", " : ""));
                Console.Write("} -> {");
 
                SetS(input_data[i]);
                RecalcA();
                RecalcR();
 
                for (int j = 0; j < R.Length; j++)
                    Console.Write(R[j].Item1 + (j < R.Length - 1 ? ", " : ""));
                Console.WriteLine("}");
            }
            #endregion DebugOutput
 
            Console.ReadLine();
        }
    }
}

/// <summary>
    /// 
    /// </summary>
    public static class Gaussian
    {
        private static Random random = new Random();
 
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public static double GetRandomGaussian()
        {
            return GetRandomGaussian(0.0, 1.0);
        }
 
        /// <summary>
        /// 
        /// </summary>
        /// <param name="mean"></param>
        /// <param name="stddev"></param>
        /// <returns></returns>
        public static double GetRandomGaussian(double mean, double stddev)
        {
            double rVal1, rVal2;
 
            GetRandomGaussian(mean, stddev, out rVal1, out rVal2);
 
            return rVal1;
        }
 
        /// <summary>
        /// 
        /// </summary>
        /// <param name="mean"></param>
        /// <param name="stddev"></param>
        /// <param name="val1"></param>
        /// <param name="val2"></param>
        public static void GetRandomGaussian(double mean, double stddev, out double val1, out double val2)
        {
            double u, v, s, t;
 
            do
            {
                u = 2 * random.NextDouble() - 1;
                v = 2 * random.NextDouble() - 1;
            }
            while (u * u + v * v > 1 || (u == 0 && v == 0));
 
            s = u * u + v * v;
            t = Math.Sqrt((-0.2 * Math.Log(s)) / s);
 
            val1 = stddev * u * t + mean;
            val2 = stddev * v * t + mean;
        }
    }