#include <iostream>
#include <vector>
#include <fstream>
using std::ofstream;
#include <cmath>
using namespace std;
vector<vector<double>> arr;
vector<double> label;
vector<vector<int>> target;
int number_of_images = 0;
int ReverseIntData(int i)
{
    unsigned char ch1, ch2, ch3, ch4;
    ch1 = i & 255;
    ch2 = (i >> 8) & 255;
    ch3 = (i >> 16) & 255;
    ch4 = (i >> 24) & 255;
    return((int)ch1 << 24) + ((int)ch2 << 16) + ((int)ch3 << 8) + ch4;
}
void ReadMNISTData() {
    ifstream filetrain, filelabel;
    filetrain.open("C:\\t10k-images-idx3-ubyte\\t10k-images.idx3-ubyte", ios::binary);
    filelabel.open("C:\\Users\\Tasmin\\Downloads\\t10k-labels-idx1-ubyte\\t10k-labels.idx1-ubyte", ios::binary);
    if (filetrain.is_open()) {

        int magic_number = 0, n_rows = 0, n_cols = 0;
        // Reading from file magic number, #of images, #of rows and #of columns
        filetrain.read((char *)&magic_number, sizeof(magic_number));
        magic_number = ReverseIntData(magic_number);
        filetrain.read((char *)&number_of_images, sizeof(number_of_images));
        number_of_images = ReverseIntData(number_of_images);
        filetrain.read((char *)&n_rows, sizeof(n_rows));
        n_rows = ReverseIntData(n_rows);
        filetrain.read((char *)&n_cols, sizeof(n_cols));
        n_cols = ReverseIntData(n_cols);
        arr.resize(number_of_images, vector<double>(784));
        int x;
        for (int i = 0; i < number_of_images; ++i) {
            for (int j = 0; j < 784; ++j) {
                unsigned char flag = 0;
                filetrain.read((char *)&flag, sizeof(flag));
                arr[i][j] = (double)flag;
                //cout << arr[i][j];
            }
            //cout << endl;

        }
    }
    else {
        cout << "cant open the file";
    }
    if (filelabel.is_open()) {

        int magic_number = 0, number_of_items = 0;
        unsigned char flag = 0;
        filelabel.read((char *)&magic_number, sizeof(magic_number));
        magic_number = ReverseIntData(magic_number);
        //cout << magic_number;
        filelabel.read((char *)&number_of_items, sizeof(number_of_items));
        number_of_items = ReverseIntData(number_of_items);
        //cout << number_of_items;
        label.resize(number_of_items);
        target.resize(number_of_items, vector<int>(10));
        for (int i = 0; i < number_of_items; ++i) {
            for (int j = 0; j < 10; ++j) {
                target[i][j] = 0;
            }
        }
        for (int i = 0; i < number_of_items; ++i) {
            filelabel.read((char *)&flag, sizeof(flag));
            //flag = ReverseIntData(flag);
            label[i] = (double)flag;
            target[i][label[i]] = 1;
            //cout << label[i] <<" ";
        }
        /*for (int i = 0; i < number_of_items; ++i) {
        for (int j = 0; j < 10; ++j) {
        cout << target[i][j] << " ";
        }
        cout << endl;
        }*/


    }
    else {
        cout << "cant open the file";
    }
}
int main()
{
    ofstream outfile("file2.txt");
    ReadMNISTData();
    number_of_images =20;
    vector<vector<double>> W;
    W.resize(784, vector<double>(30));
    vector<vector<double>> U;
    U.resize(30, vector<double>(10));
    vector<double> B;
    B.resize(30);
    vector<double> C;
    C.resize(10);
    vector<double> Y;
    Y.resize(30);
    vector<double> Z;
    Z.resize(10);
    vector<double> SB;
    SB.resize(30);
    vector<double> RC;
    RC.resize(10);
    float S = 0, R = 0;
    double e = 0.2;
    //initialize W
    for (int i = 0; i < 784; ++i) {//W transpose
        for (int j = 0; j < 30; ++j) {
            W[i][j] = float(rand()) / float(RAND_MAX) - 0.5;
        }

    }
    //initialize B
    for (int i = 0; i < 30; ++i) {
        B[i] = float(rand()) / float(RAND_MAX) - 0.5;
    }

    //initialize U
    for (int i = 0; i < 30; ++i) {
        for (int j = 0; j < 10; ++j) {
            U[i][j] = float(rand()) / float(RAND_MAX) - 0.5;
        }

    }
    //initialize C
    for (int i = 0; i < 10; ++i) {
        C[i] = float(rand()) / float(RAND_MAX) - 0.5;
    }
    //initial Training
    for (int o = 0; o < number_of_images; ++o) {

        //Calculate Y
        for (int i = 0; i < 30; ++i) {//transoise of w
            for (int j = 0; j < 784; ++j) {
                S = S + W[j][i] * arr[o][j];
            }
            SB[i] = S + B[i];
            Y[i] = 1.0 / (1.0 + exp(-(SB[i])));
            S = 0;
        }
        /*for (int i = 0; i < 10; ++i) {
        cout<<Y[i]<<" ";

        }*/
        //Calculate Z
        for (int i = 0; i < 10; ++i) {//transpose of U
            for (int j = 0; j < 30; ++j) {
                R = R + U[j][i] * Y[j];

            }
            RC[i] = R + C[i];
            Z[i] = 1.0 / (1.0 + exp(-(RC[i])));
            R = 0;
        }

        for (int i = 0; i < 10; ++i) {
            outfile << Z[i] << " ";

        }
        outfile << endl;
        for (int i = 0; i < 10; ++i) {
            outfile << target[o][i] << " ";

        }
        outfile << endl;
        //Backpropagation starts
        //Update U
        for (int i = 0; i < 30; ++i) {
            for (int j = 0; j < 10; ++j) {
                U[i][j] = U[i][j] + e * Z[j] * (Z[j] - target[o][j])*(Z[j] - 1)*Y[i];
                //cout << U[i][j]<<" ";
            }
            //cout << endl;
        }
        //Update W
        double w_Sum = 0.0;
        for (int n = 0; n < 30; ++n) {// for 30 neuron
            for (int k = 0; k < 784; ++k) {
                for (int i = 0; i < 10; ++i) {//10ta sum
                    w_Sum = w_Sum + (1.0 - Z[i])*(Z[i] - target[o][i])*Z[i] * U[n][i] * (1.0 - Y[n])*Y[n] * arr[o][k];

                }
                W[k][n] = W[k][n] - e * w_Sum;
                w_Sum = 0.0;
            }
        }
        //Update C
        for (int i = 0; i < 10; ++i) {
            C[i] = C[i] - e * (Z[i] - target[o][i])*(1 - Z[i])*Z[i];
        }
        //Uppdate B
        double b_Sum = 0.0;
        for (int i = 0; i < 30; ++i) {
            for (int j = 0; j < 10; ++j) {
                b_Sum = b_Sum + (Z[j] - target[o][j])*(1 - Z[j])*Z[j] * U[i][j] * Y[i] * (1 - Y[i]);
            }
            b_Sum = b_Sum * Y[i] * (1.0 - Y[i]);
            B[i] = B[i] - e * b_Sum;
        }

    }
    //epoch
    for (int j = 0; j < 10; j++) {
        cout << "BEGINING OF EPOCH " << j + 2 << endl;
        for (int o = 0; o < number_of_images; ++o) {

            //Calculate Y
            for (int i = 0; i < 30; ++i) {//transoise of w
                for (int j = 0; j < 784; ++j) {
                    S = S + W[j][i] * arr[o][j];
                }
                SB[i] = S + B[i];
                Y[i] = 1.0 / (1.0 + exp(-(SB[i])));
                S = 0;
            }
            /*for (int i = 0; i < 10; ++i) {
            cout<<Y[i]<<" ";

            }*/
            //Calculate Z
            for (int i = 0; i < 10; ++i) {//transpose of U
                for (int j = 0; j < 30; ++j) {
                    R = R + U[j][i] * Y[j];

                }
                RC[i] = R + C[i];
                Z[i] = 1.0 / (1.0 + exp(-(RC[i])));
                R = 0;
            }

            for (int i = 0; i < 10; ++i) {
                outfile << Z[i] << " ";

            }
            outfile << endl;
            for (int i = 0; i < 10; ++i) {
                outfile << target[o][i] << " ";

            }
            outfile << endl;
            //Backpropagation starts
            //Update U
            for (int i = 0; i < 30; ++i) {
                for (int j = 0; j < 10; ++j) {
                    U[i][j] = U[i][j] + e * Z[j] * (Z[j] - target[o][j]) * (Z[j] - 1) * Y[i];
                    //cout << U[i][j]<<" ";
                }
                //cout << endl;
            }
            //Update W
            double w_Sum = 0.0;
            for (int n = 0; n < 30; ++n) {// for 30 neuron
                for (int k = 0; k < 784; ++k) {
                    for (int i = 0; i < 10; ++i) {//10ta sum
                        w_Sum = w_Sum +
                            (1.0 - Z[i]) * (Z[i] - target[o][i]) * Z[i] * U[n][i] * (1.0 - Y[n]) * Y[n] * arr[o][k];

                    }
                    W[k][n] = W[k][n] - e * w_Sum;
                    w_Sum = 0.0;
                }
            }
            //Update C
            for (int i = 0; i < 10; ++i) {
                C[i] = C[i] - e * (Z[i] - target[o][i]) * (1 - Z[i]) * Z[i];
            }
            //Uppdate B
            double b_Sum = 0.0;
            for (int i = 0; i < 30; ++i) {
                for (int j = 0; j < 10; ++j) {
                    b_Sum = b_Sum + (Z[j] - target[o][j]) * (1 - Z[j]) * Z[j] * U[i][j] * Y[i] * (1 - Y[i]);
                }
                b_Sum = b_Sum * Y[i] * (1.0 - Y[i]);
                B[i] = B[i] - e * b_Sum;
            }

        }
    }
    cout << "finished";
    outfile << "finished";

    getchar();
    return 0;
}