Neuronetwoooork

#include <QApplication>
#include <iostream>
#include <math.h>
#include <QMap>
#include <QVector>
#include <QDebug>
#include <random>
#include <QGenericMatrix>
#include <Eigen/Geometry>
#include <Eigen/Dense>
 
using namespace Eigen;
 
                                                                // VARIABLE-s
//Create items-data for input
 QMap<QString, int> train_data;
 QMap<QString, int> test_data;
 QStringList(vocab);
 QMap<QString, int> word_to_idx;
 QMap<int, QString> idx_to_word;
 QStringList(items);
//Create size for layers waves
 int const hiden_size=64;
 int const input_size = 18;
 int const output_size = 2;
//Create matrix waves
 
//Create matrix layer
MatrixXd inputs;
int target;
MatrixXd last_inputs;
MatrixXd last_hs;
MatrixXd h;
MatrixXd out;
 
//create variable for backprop
MatrixXd probs;
MatrixXd d_L_d_y;
 
 
class Waves{
public:
    MatrixXd Wxh=MatrixXd::Random(hiden_size,input_size)/1000;
    MatrixXd Whh=MatrixXd::Random(hiden_size,hiden_size)/1000;
    MatrixXd Why=MatrixXd::Random(output_size,hiden_size)/1000;
 
    Matrix<double, hiden_size, 1> bh;
    Matrix<double, output_size, 1> by;
 
 
    //Func for create and return after h layer and y(output) layer
   void forward(MatrixXd how_inputs,MatrixXd& y,MatrixXd& h){
   //Create hiden layer and get zero data in firast "h"
    int n=hiden_size, m=how_inputs.cols();
 
    MatrixXd pre_h(n,1);
    for (int i=0; i<n; i++)
    for (int j=0; j<1; j++)
       pre_h(i,j)=0;
 
    MatrixXd pre_last_inputs=how_inputs;//save last inputs
 
    MatrixXd pre_last_hs(n,m+1);
    for (int i=0; i<n; i++)
    for (int j=0; j<m; j++)
        pre_last_hs(i,j)=0;
 
       for (int j=0; j<m; j++)
       for (int z=0; z<vocab.size(); z++)
       for (int i=0; i<n; i++)
           pre_h(i,0) =  tanh(Wxh(i,j)*how_inputs(z,j) + Whh(i,j)*pre_h(i,0) + bh(i,0));
 
       for (int j=0; j<m; j++)
       for (int z=0; z<vocab.size(); z++)
       for (int i=0; i<n; i++)
           pre_last_hs(i,j+1)= tanh(Wxh(i,j)*how_inputs(z,j) + Whh(i,j)*pre_last_hs(i,j+1) + bh(i,0)); //last vector-col in pre_last_hs==h;
 
     MatrixXd pre_y(output_size,1);
 
 
         pre_y.row(0)=Why.row(0)*pre_h+by.row(0);
         pre_y.row(1)=Why.row(1)*pre_h+by.row(1);
 
       //from local var in global;
       last_hs=pre_last_hs;
       last_inputs=pre_last_inputs;
       y=pre_y;
       h=pre_h;
   }
 
   //Func for backprop
  void backprop(MatrixXd d_y,double learn_rate=2e-2){
 
     int nn=last_inputs.cols()-1; // how much inputs ?
     MatrixXd d_Why= d_y*last_hs.col(nn).transpose();
 
     MatrixXd d_by = d_y;
 
   //All backprob wave set on "0"
     MatrixXd d_Whh=MatrixXd(hiden_size,hiden_size).setZero();
     MatrixXd d_Wxh=MatrixXd(hiden_size,input_size).setZero();
     MatrixXd d_bh=MatrixXd(hiden_size,1).setZero();
 
 
     MatrixXd d_h = Why.transpose()*d_y;
   //create backprob waves which loop(for each last H and Input
     for(int t=nn;t!=-1;t--){
         int n=hiden_size, m=1;
         MatrixXd temp(n,m);
         temp.setZero();
         for (int i=0; i<n; i++)
         for (int j=0; j<m; j++)
         temp(i,j) = (1-pow(last_hs(i,t+1),2))*d_h(i,j);
 
 
 
          d_bh+=temp;
          d_Whh+=temp*last_hs.col(t).transpose();
          d_Wxh += temp*last_inputs.col(t).transpose();
          d_h = Whh * temp;
     }
 
     //cliping
     d_Wxh = (d_Wxh.array() > 1).select(1,d_Wxh);
     d_Wxh = (d_Wxh.array() < -1).select(-1,d_Wxh);
     d_Whh = (d_Whh.array() > 1).select(1,d_Whh);
     d_Whh = (d_Whh.array() < -1).select(-1,d_Whh);
     d_Why = (d_Why.array() > 1).select(1,d_Why);
     d_Why = (d_Why.array() < -1).select(-1,d_Why);
     d_bh = (d_bh.array() > 1).select(1,d_bh);
     d_bh = (d_bh.array() < -1).select(-1,d_bh);
     d_by = (d_by.array() > 1).select(1,d_by);
     d_by = (d_by.array() < -1).select(-1,d_by);
 
    //updating
 
     Wxh -= learn_rate*d_Wxh;
     Whh -= learn_rate*d_Whh;
     Why -= learn_rate*d_Why;
     bh -= learn_rate*d_bh;
     by -= learn_rate*d_by;
  }
 
 };
 
 Waves wv;                                                                  // FUNCTION-s and structurs
 
//Func for data massive
 void create_TrainData_TestData(){
     train_data["good"]= 1;
     train_data["bad"]= 0;
     train_data["happy"]= 1;
     train_data["sad"]= 0;
     train_data["not good"]= 0;
     train_data["not bad"]= 1;
     train_data["not happy"]= 0;
     train_data["not sad"]= 1;
     train_data["very good"]= 1;
     train_data["very bad"]= 0;
     train_data["very happy"]= 1;
     train_data["very sad"]= 0;
     train_data["i am happy"]= 1;
     train_data["this is good"]= 1;
     train_data["i am bad"]= 0;
     train_data["this is bad"]= 0;
     train_data["i am sad"]= 0;
     train_data["this is sad"]= 0;
     train_data["i am not happy"]= 0;
     train_data["this is not good"]= 0;
     train_data["i am not bad"]= 1;
     train_data["this is not sad"]= 1;
     train_data["i am very happy"]= 1;
     train_data["this is very good"]= 1;
     train_data["i am very bad"]= 0;
     train_data["this is very sad"]= 0;
     train_data["this is very happy"]= 1;
     train_data["i am good not bad"]= 1;
     train_data["this is good not bad"]= 1;
     train_data["i am bad not good"]= 0;
     train_data["i am good and happy"]= 1;
     train_data["this is not good and not happy"]= 0;
     train_data["i am not at all good"]= 0;
     train_data["i am not at all bad"]= 1;
     train_data["i am not at all happy"]= 0;
     train_data["this is not at all sad"]= 1;
     train_data["this is not at all happy"]= 0;
     train_data["i am good right now"]= 1;
     train_data["i am bad right now"]= 0;
     train_data["this is bad right now"]= 0;
     train_data["i am sad right now"]= 0;
     train_data["i was good earlier"]= 1;
     train_data["i was happy earlier"]= 1;
     train_data["i was bad earlier"]= 0;
     train_data["i was sad earlier"]= 0;
     train_data["i am very bad right now"]= 0;
     train_data["this is very good right now"]= 1;
     train_data["this is very sad right now"]= 0;
     train_data["this was bad earlier"]= 0;
     train_data["this was very good earlier"]= 1;
     train_data["this was very bad earlier"]= 0;
     train_data["this was very happy earlier"]= 1;
     train_data["this was very sad earlier"]= 0;
     train_data["i was good and not bad earlier"]= 1;
     train_data["i was not good and not happy earlier"]= 0;
     train_data["i am not at all bad or sad right now"]= 1;
     train_data["i am not at all good or happy right now"]= 0;
     train_data["this was not happy and not good earlier"]= 0;
 
     test_data["this is happy"] =1;
     test_data["i am good"] =1;
     test_data["this is not happy"] =0;
     test_data["i am not good"] =0;
     test_data["this is not bad"] =1;
     test_data["i am not sad"] =1;
     test_data["i am very good"] =1;
     test_data["this is very bad"] =0;
     test_data["i am very sad"] =0;
     test_data["this is bad not good"] =0;
     test_data["this is good and happy"] =1;
     test_data["i am not good and not happy"] =0;
     test_data["i am not at all sad"] =1;
     test_data["this is not at all good"] =0;
     test_data["this is not at all bad"] =1;
     test_data["this is good right now"] =1;
     test_data["this is sad right now"] =0;
     test_data["this is very bad right now"] =0;
     test_data["this was good earlier"] =1;
     test_data["i was not happy and not good earlier"] =0;
     test_data["happy"] =1;
     test_data["good"] =1;
     test_data["not happy"] =0;
     test_data["not good"] =0;
     test_data["not bad"] =1;
     test_data["sad"] =1;
     test_data["very good"] =1;
     test_data["very bad"] =0;
     test_data["very sad"] =0;
     test_data["good and happy"] =1;
     test_data["not good and not happy"] =0;
     test_data["not at all good"] =0;
     test_data["not at all bad"] =1;
     test_data["good right now"] =1;
     test_data["sad right now"] =0;
     test_data["very bad right now"] =0;
     test_data["was good earlier"] =1;
     test_data["not happy and not good earlier"] =0;
 }
 //Func for creating data fo Training and Test
 void data_forTrain(){
//     vocab.clear();
     word_to_idx.clear();
     idx_to_word.clear();
     //Create map for key in train_data
     QStringList(vocabpre);
     QMap<QString,int>::iterator it;
     for (it = train_data.begin(); it != train_data.end(); ++it) {
         // Format output here.
         vocabpre += QString("%1").arg(it.key());        // How mych "text" data in train data
     }
     for(int i=0;i<vocabpre.size();i++){
         vocab += vocabpre[i].split(' ');
     }
     std:: sort(vocab.begin(),vocab.end());
     vocab.erase(std::unique(vocab.begin(),vocab.end()),vocab.end());
 
     for(int i=0;i<vocab.size();i++)// !!!!!!!!!!!!!!!!
          word_to_idx[QString("%1").arg(vocab[i])]=i;
     for(int i=0;i<vocab.size();i++)
         idx_to_word[i]=vocab[i];
 }
 void data_forTest(){
     vocab.clear();
     word_to_idx.clear();
     idx_to_word.clear();
     //Create map for key in train_data
     QStringList(vocabpre);
     QMap<QString,int>::iterator its;
     for (its = test_data.begin(); its != test_data.end(); ++its) {
         // Format output here.
         vocabpre += QString("%1").arg(its.key());        // How mych "text" data in train data
     }
     for(int i=0;i<vocabpre.size();i++){
         vocab += vocabpre[i].split(' ');
     }
     std:: sort(vocab.begin(),vocab.end());
     vocab.erase(std::unique(vocab.begin(),vocab.end()),vocab.end());
 
     for(int i=0;i<vocab.size();i++)// !!!!!!!!!!!!!!!!
          word_to_idx[QString("%1").arg(vocab[i])]=i;
     for(int i=0;i<vocab.size();i++)
         idx_to_word[i]=vocab[i];
 }
 //Func for create input and return matrix "input" for each word
 void create_InputsTarget(QString text, int targ,MatrixXd& input,int& pre_targ){
     QStringList(e) = text.split(' ');
     qDebug() << text;
     int n=vocab.size(),m=e.size();
     MatrixXd pre_input(n,m);
     for (int i=0; i<n; i++)
     for (int j=0; j<m; j++)
         pre_input(i,j)=0;
 
     for(int i=0;i<e.size();i++)
         pre_input(word_to_idx[e[i]],i)=1;
 
     input=pre_input;
     pre_targ=targ;
 }
 //Func for waves*layer
MatrixXd softmax(MatrixXd which_out){
    probs.setZero();
 
    MatrixXd exps(output_size,1);
    exps.setZero();
    exps(0,0)=exp(which_out.row(0).maxCoeff());
    exps(1,0)=exp(which_out.row(1).maxCoeff());
 
 
    MatrixXd pre_softmax(output_size,1);
    pre_softmax.setZero();
    pre_softmax(0,0)=exps(0,0)/exps.sum();
    pre_softmax(1,0)=exps(1,0)/exps.sum();
 
 
    return pre_softmax;
}
 
 //Func for neuro learning
void processData(QMap<QString, int> pre_data,bool backprob,int show){
 
    if(backprob==1)
        data_forTrain();
    else
        data_forTest();
 
    //Create list of items and target
    items.clear();
    QMap<QString,int>::iterator it;
    for (it = pre_data.begin(); it !=pre_data.end(); ++it) {
       items+=(it.key()+":"+QString("%1").arg(it.value()));
    }
 
    double loss=0;
    double num_correct=0;
 
    //Create process for each items in List "items"
    int itet=0;
    while(itet < items.size()){
 
 
           int r =rand()%((items.size()-1)-0 + 1) + 0;
            create_InputsTarget(items[r].split(":")[0],items[r].split(":")[1].toInt(),inputs,target);
            wv.forward(inputs,out,h);
            probs = softmax(out);
           
            loss -= log(probs(target,0));
            if(probs.maxCoeff() == probs(target,0))
                num_correct+=1;
            else
                num_correct+=0;
             if (backprob==1)
                 d_L_d_y =probs;
             if (backprob==1)
                 d_L_d_y(target,0)-=1;
            if (backprob==1)
                wv.backprop(d_L_d_y);
            itet+=1;
    }
    if(show%100==99)
        qDebug() << "Loss: "<<loss/pre_data.size()<<"|"<<"Accurancy: " << num_correct/pre_data.size() ;
}
 
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    create_TrainData_TestData();
 
    for(int i =0; i!=1000;i++){
        processData(train_data,1,i);
        if(i%100=99)
            processData(test_data,0,i);
    }
 
    return a.exec();
}