neural network feedforward backpropagation

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NeuronskeI
{
    public class BackPropagation
    {
        public static int MAXN = 8;
        public static int SLOJEVI = 3;
        public static int uzorciN = 256;
        public static int MAXITERACIJA = 1000;
        public static double MAXGRESKA = 0.001;
        public static int BROJPOKUSAJA = 42;

        public TSloj[] slojevi = new TSloj[SLOJEVI];
        public double[, ,] tezine = new double[SLOJEVI - 1, MAXN, MAXN];
        public double[, ,] tezineP = new double[SLOJEVI - 1, MAXN, MAXN];
        public double[, ,] obucavajuciSkup = new double[uzorciN, 2, MAXN];
        public double ni;
        public double beta;

        public BackPropagation()
        {
            inicijalizacija();
        }

        protected void inicijalizacija()
        {
            for (int i = 0; i < SLOJEVI; i++)
                slojevi[i] = new TSloj();
            ni = 0.05;
            beta = 0.9;

            // TODO 5: postaviti brojeve neurona za svaki sloj
            slojevi[0].n = 8;
            slojevi[1].n = 8;
            slojevi[2].n = 8;

            // TODO 6: napuniti obucavajuci skup

            int k = 0;

            for (int i = 0; i < 256; i++) {
                int[] x = int2bin8(i);
                int[] y = pomjeranje(x);

                obucavajuciSkup[k, 0, 0] = x[0];
                obucavajuciSkup[k, 0, 1] = x[1];
                obucavajuciSkup[k, 0, 2] = x[2];
                obucavajuciSkup[k, 0, 3] = x[3];
                obucavajuciSkup[k, 0, 4] = x[4];
                obucavajuciSkup[k, 0, 5] = x[5];
                obucavajuciSkup[k, 0, 6] = x[6];
                obucavajuciSkup[k, 0, 7] = x[7];
                obucavajuciSkup[k, 1, 0] = y[0];
                obucavajuciSkup[k, 1, 1] = y[1];
                obucavajuciSkup[k, 1, 2] = y[2];
                obucavajuciSkup[k, 1, 3] = y[3];
                obucavajuciSkup[k, 1, 4] = y[4];
                obucavajuciSkup[k, 1, 5] = y[5];
                obucavajuciSkup[k, 1, 6] = y[6];
                obucavajuciSkup[k, 1, 7] = y[7];

                k++;

            }

        }

        int[] pomjeranje(int [] niz){
            bool najveciBit = false;
            int[] ret= {0,0,0,0,0,0,0,0};
            if (niz[0] == 1)
            {
                ret[0] = 0;
                ret[7] = 1;
            }

            for (int i = 7; i > 0; i--) {
                if (niz[i] == 1) {
                    ret[i - 1] = 1;
                }
            }


            return ret;
        }

        int[] int2bin8(int b)
        {
            int[] retVal = new int[8];
            for (int i = 7; i >= 0; i--)
            {
                int o = (int)b % 2;
                b = b / 2;
                retVal[i] = o;
            }
            return retVal;
        }

        protected void inicijalizacijaTezina()
        {
            Random rnd = new Random();
            for (int s = 0; s < SLOJEVI - 1; s++)
                for (int u = 0; u < slojevi[s].n; u++)
                    for (int v = 0; v < slojevi[s + 1].n; v++)
                    {
                        tezine[s, u, v] = (float)(rnd.NextDouble() - 0.5) / 5;
                        tezineP[s, u, v] = 0;
                    }

            for (int s = 0; s < SLOJEVI; s++)
                for (int u = 0; u < MAXN; u++)
                {
                    slojevi[s].bias[u] = 0;
                    slojevi[s].biasp[u] = 0;
                }

            for (int s = 1; s < SLOJEVI - 1; s++)
                for (int u = 0; u < slojevi[s].n; u++)
                    slojevi[s].bias[u] = (float)rnd.NextDouble();

        }

        double sigmoid(double net)
        {
            return 1 / (1 + Math.Exp(-net));
        }

        public void izracunajIzlaz()
        {
            double net = 0.0;
            for (int s = 1; s < SLOJEVI; s++)
                for (int v = 0; v < slojevi[s].n; v++)
                {
                    net = slojevi[s].bias[v];
                    for (int u = 0; u < slojevi[s - 1].n; u++)
                        net += slojevi[s - 1].izlaz[u] * tezine[s - 1, u, v];
                    slojevi[s].izlaz[v] = sigmoid(net);
                }
        }

        void postaviUlaz(int uzorak)
        {
            for (int u = 0; u < slojevi[0].n; u++)
                slojevi[0].izlaz[u] = obucavajuciSkup[uzorak, 0, u];
        }

        double izracunajGreske(int uzorak)
        {
            double greska = 0.0;
            // greska u izlaznom sloju
            for (int v = 0; v < slojevi[SLOJEVI - 1].n; v++)
            {
                slojevi[SLOJEVI - 1].sigma[v] = obucavajuciSkup[uzorak, 1, v] - slojevi[SLOJEVI - 1].izlaz[v];
                greska += (slojevi[SLOJEVI - 1].sigma[v]) * (slojevi[SLOJEVI - 1].sigma[v]);
            }
            // greska u ostalim slojevima
            for (int s = SLOJEVI - 2; s >= 0; s--)
                for (int u = 0; u < slojevi[s].n; u++)
                {
                    double sigmaa = 0.0;
                    for (int v = 0; v < slojevi[s + 1].n; v++)
                        sigmaa += slojevi[s + 1].sigma[v] * tezine[s, u, v];
                    double f = slojevi[s].izlaz[u];
                    slojevi[s].sigma[u] = f * (1 - f) * sigmaa;
                }
            return greska;
        }

        void korigujTezine()
        {
            for (int s = 0; s < SLOJEVI - 1; s++)
                for (int v = 0; v < slojevi[s + 1].n; v++)
                {
                    for (int u = 0; u < slojevi[s].n; u++)
                    {
                        tezineP[s, u, v] = ni * slojevi[s + 1].sigma[v] * slojevi[s].izlaz[u] + beta * tezineP[s, u, v];
                        tezine[s, u, v] += tezineP[s, u, v];
                    }
                    slojevi[s + 1].biasp[v] = ni * slojevi[s + 1].sigma[v] +
                                            beta * slojevi[s + 1].biasp[v];
                    slojevi[s + 1].bias[v] += slojevi[s + 1].biasp[v];
                    // izracunavanje korigovane vrednosti izlaza u sloju
                    double net = slojevi[s + 1].bias[v];
                    for (int u = 0; u < slojevi[s].n; u++)
                        net += slojevi[s].izlaz[u] * tezine[s, u, v];
                    slojevi[s + 1].izlaz[v] = sigmoid(net);
                }
        }

        public double obucavanje()
        {
            double greska = 0;
            for (int iteracija = 0; iteracija < MAXITERACIJA; iteracija++)
            {
                greska = 0;
                for (int uzorak = 0; uzorak < uzorciN; uzorak++)
                {
                    postaviUlaz(uzorak);
                    izracunajIzlaz();
                    greska += 0.5 * izracunajGreske(uzorak);
                    korigujTezine();
                }
                Console.WriteLine("" + iteracija + " " + greska);
                if (greska < MAXGRESKA)
                    break;
            }
            return greska;
        }

        public double izlaz(double[] ulaz)
        {
            slojevi[0].izlaz[0] = ulaz[0];
            slojevi[0].izlaz[1] = ulaz[1];
            slojevi[0].izlaz[2] = ulaz[2];
            slojevi[0].izlaz[3] = ulaz[3];
            slojevi[0].izlaz[4] = ulaz[4];
            slojevi[0].izlaz[5] = ulaz[5];
            slojevi[0].izlaz[6] = ulaz[6];
            slojevi[0].izlaz[7] = ulaz[7];
            izracunajIzlaz();

            double ret = 0;
            int j = 0;
            for (int i = 7; i >= 0; i--)
            {
                ret += Math.Round(slojevi[SLOJEVI - 1].izlaz[i]) * Math.Pow(2, j);
                j++;
            }

            return ret;
        }

        public void obuci()
        {
            inicijalizacija();
            for (int pokusaj = 0; pokusaj < BROJPOKUSAJA; pokusaj++)
            {
                inicijalizacijaTezina();
                double greska = obucavanje();
                if (greska < MAXGRESKA)
                    break;
            }
        }
    }

    public class TSloj
    {

        public int n;
        public double[] izlaz = new double[BackPropagation.MAXN];
        public double[] sigma = new double[BackPropagation.MAXN];
        public double[] bias = new double[BackPropagation.MAXN];
        public double[] biasp = new double[BackPropagation.MAXN];

    }
}