API tools faq
paste
Hexadroid

Untitled

Hexadroid
Feb 23rd, 2021
77
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 23.79 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <random>
  4. #include <algorithm>
  5. #include <iterator>
  6. #include <iostream>
  7. #include <windows.h>
  8.  
  9. const int nr_neurons_A = 4;
  10. const int nr_neurons_B = 4;
  11. const int nr_neurons_C = 4;
  12. const int nr_neurons_D = 4;
  13. const int nr_neurons_E = 4;
  14. const int nr_neurons_F = 4;
  15. const int nr_neurons_G = 4;
  16. int tota = nr_neurons_A + nr_neurons_B + nr_neurons_C + nr_neurons_D + nr_neurons_E + nr_neurons_F + nr_neurons_G;
  17.  
  18. int Z;
  19. int A, B, C, D, E, F, G;
  20. int loops = 1334000;
  21. int showtime = 0.50*loops;
  22. int zrows = 99;
  23. int temp, i1, i2, rows, shuffled;
  24. int i, j;
  25. int showoutputs;
  26.  
  27. double xDD, gDD, fDD, eDD, dDD, cDD, bDD, zDD;
  28. double bDD_xupd, bDD_xbupd;
  29. double cDD_wupd, cDD_bupd;
  30. double dDD_wupd, dDD_bupd;
  31. double eDD_wupd, eDD_bupd;
  32. double fDD_wupd, fDD_bupd;
  33. double gDD_wupd, gDD_bupd;
  34. double zDD_wupd, zDD_bupd;
  35.  
  36. double membDD_xupd[nr_neurons_A][nr_neurons_B];
  37. double memBWC_xupd[nr_neurons_B][nr_neurons_C];
  38. double memCWD_xupd[nr_neurons_C][nr_neurons_D];
  39. double memDWD_xupd[nr_neurons_D][nr_neurons_E];
  40. double memEWD_xupd[nr_neurons_E][nr_neurons_F];
  41. double memFWD_xupd[nr_neurons_F][nr_neurons_G];
  42. double memGWD_xupd[nr_neurons_G];
  43.  
  44. double sqcalc, gemiddelde;
  45. double TOTAL, TOTALcCoD, TOTALao, TOTALbo, TOTALco, TOTALdo, TOTALeo, TOTALfo;
  46. double learn = 0.0000000001;
  47. double xerr[nr_neurons_G], xerrtotal;
  48. double sqerrtot = 0;
  49.  
  50. double ato[5];
  51. double bto[5];
  52. double cto[5];
  53. double dto[5];
  54. double eto[5];
  55. double fto[5];
  56.  
  57. double atoTOTAL[5];
  58. double btoTOTAL[5];
  59. double ctoTOTAL[5];
  60. double dtoTOTAL[5];
  61. double etoTOTAL[5];
  62. double ftoTOTAL[5];
  63.  
  64.  
  65. bool training_mode = false;
  66.  
  67. double train_input[100][nr_neurons_A];
  68. double train_output[100][nr_neurons_G];
  69. double requested1[nr_neurons_A];
  70.  
  71. double gDD_times, fDD_times, eDD_times, dDD_times, cDD_times, bDD_times;
  72. double avgtot, aw, bw, cw, dw, ew, fw, gw;
  73. double tussen, row_0, row_1, row_2, row_3;
  74.  
  75. struct MiddleNode {
  76.  
  77.  std::vector<double> w = std::vector<double>(256, 0.00);
  78.  std::vector<double> o = std::vector<double>(256, 0.00);
  79.  std::vector<double> bw = std::vector<double>(256, 0.00);
  80.  std::vector<double> b = std::vector<double>(256, 0.00);
  81.  
  82. };
  83.  
  84. struct InputNode {
  85.  
  86.  std::vector<double> w = std::vector<double>(256, 0.00);
  87.  std::vector<double> o = std::vector<double>(256, 0.00);
  88.  std::vector<double> bw = std::vector<double>(256, 0.00);
  89.  std::vector<double> b = std::vector<double>(256, 0.00);
  90.  
  91. };
  92.  
  93. struct OutputNode {
  94.  
  95.  std::vector<double> w = std::vector<double>(256, 0.00);
  96.  std::vector<double> o = std::vector<double>(256, 0.00);
  97.  std::vector<double> bw = std::vector<double>(256, 0.00);
  98.  std::vector<double> b = std::vector<double>(256, 0.00);
  99.  
  100. };
  101.  
  102. double choose(int x, int aa) {
  103.  
  104.   if (training_mode) return train_input[x][aa];
  105.   else return requested1[aa];
  106.  
  107. }
  108.  
  109.  
  110. double initialize() {
  111.  
  112.   //return 0.50/exp(1.00);
  113.   return ((rand()%10000)/10000.00) + 0.01;
  114.  
  115. }
  116.  
  117. double fd(double x) {
  118.  
  119.   return (x >= 0) ? (1) : (0);
  120.  
  121. }
  122.  
  123. double fx(double x) {
  124.  
  125.   return (x >= 0) ? (x) : (0);
  126.  
  127. }
  128.  
  129. double undetail(double number)
  130. {
  131.     bool pec = false;
  132.     double hevel,f0,f1,f2,f3,f4,f5,f6,f7,f8,f9,f10;
  133.     double number_copy = number;
  134.     double outt;
  135.     int teller = 0;
  136.  
  137.     //if (!number) return 0.00;
  138.  
  139.     //if (i>1000) {
  140.  
  141.  
  142.  
  143.  
  144.     f0 = floor(number_copy / 1.0);
  145.      //printf("\n\nhet aantal helen %f", f0);
  146.      number_copy = number_copy - 1.0 * f0;
  147.  
  148.     f1 = floor(number_copy / 0.1);
  149.     // printf("\n\nhet aantal tienden %f", f1);
  150.      number_copy = number_copy - 0.1 * f1;
  151.      /*
  152.      f2 = floor(number_copy / 0.01);
  153.      if (f2>4) {
  154.                     if (f1!=9) {
  155.                                   f1=f1+1.0;;
  156.                                 }
  157.  
  158.                                 else { f2 = 9; pec = true; }
  159.  
  160.                  }
  161.  
  162.     f2 = floor(number_copy / 0.01);
  163.      //printf("\n\nhet aantal honderdsten %f", f2);
  164.      number_copy = number_copy - 0.01 * f2;
  165.  
  166.      hevel = 0.001;
  167.     f3 = floor(number_copy / hevel);
  168.      //printf("\n\nhet aantal duizendsten %f", f3);
  169.      number_copy = number_copy - hevel * f3;
  170.  
  171.     hevel = 0.0001;
  172.     f4 = floor(number_copy / hevel);
  173.      //printf("\n\nhet aantal tienduizendsten %f", f4);
  174.      number_copy = number_copy - hevel * f4;
  175.  
  176.          hevel = 0.00001;
  177.     f5 = floor(number_copy / hevel);
  178.      //printf("\n\nhet aantal honderdduizendsten %f", f5);
  179.      number_copy = number_copy - hevel * f5;
  180.  
  181.              hevel = 0.000001;
  182.     f6 = floor(number_copy / hevel);
  183.      //printf("\n\nhet aantal miljoensten %f", f6);
  184.      number_copy = number_copy - hevel * f6;
  185.  
  186.  
  187.                  hevel = 0.0000001;
  188.     f7 = floor(number_copy / hevel);
  189.      //printf("\n\nhet aantal tienmiljoensten %f", f7);
  190.      number_copy = number_copy - hevel * f7;
  191.  
  192.                      hevel = 0.00000001;
  193.     f8 = floor(number_copy / hevel);
  194.      //printf("\n\nhet aantal honderdmiljoensten %f", f8);
  195.      number_copy = number_copy - hevel * f8;
  196.  
  197.                      hevel = 0.000000001;
  198.     f9 = floor(number_copy / hevel);
  199.      //printf("\n\nhet aantal miljardsten %f", f9);
  200.      number_copy = number_copy - hevel * f9;
  201.  
  202.                          hevel = 0.0000000001;
  203.     f10 = floor(number_copy / hevel);
  204.      //printf("\n\nhet aantal tienmiljardsten %f", f10);
  205.      number_copy = number_copy - hevel * f10;
  206.      */
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.      outt = f0;
  224.  
  225.      if (f1)    {
  226.                     outt = outt + f1/10;
  227.                     teller ++;
  228.                 }
  229.  
  230.                  /*
  231.                 if (pec) { outt = outt + f2/100;
  232.  
  233.                 }
  234.  
  235.      if (f2 || teller)  {
  236.                     teller ++;
  237.                     outt = outt + f2/100;
  238.  
  239.                 }
  240.  
  241.      if (f3 || teller)  {
  242.                     teller ++;
  243.                     if (teller<3) outt = outt + f3/1000;
  244.                 }
  245.  
  246.  
  247.  
  248.      if (f4 || teller)  {
  249.                     teller ++;
  250.                     if (teller<3) outt = outt + f4/10000;
  251.                 }
  252.  
  253.  
  254.      if (f5 || teller)  {
  255.                     teller ++;
  256.                     if (teller<3) outt = outt + f5/100000;
  257.                 }
  258.  
  259.          if (f6 || teller)  {
  260.                     teller ++;
  261.                     if (teller<3) outt = outt + f6/1000000;
  262.                 }
  263.  
  264.              if (f7 || teller)  {
  265.                     teller ++;
  266.                     if (teller<3) outt = outt + f7/10000000;
  267.                 }
  268.  
  269.          if (f8 || teller)  {
  270.                     teller ++;
  271.                     if (teller<3) outt = outt + f8/100000000;
  272.                 }
  273.  
  274.          if (f9 || teller)  {
  275.                     teller ++;
  276.                     if (teller<3) outt = outt + f9/1000000000;
  277.                 }
  278.  
  279.          if (f10 || teller)     {
  280.                     teller ++;
  281.                     if (teller<3) outt = outt + f10/10000000000;
  282.                 }
  283.                 */
  284.                 //printf("\n\n changing %.10f to %.10f", number, outt);
  285.          //return outt;
  286.             // }
  287.  
  288.              return outt; //else return number;
  289.  
  290.  
  291. }
  292.  
  293.  
  294. int _tmain(int argc, _TCHAR * argv[]) {
  295.  
  296.   srand (time(NULL));
  297.  
  298.   std::random_device rd;
  299.   std::mt19937 gh(rd());
  300.  
  301.   learn = learn / tota;
  302.  
  303.  
  304.   InputNode a[nr_neurons_A];
  305.   MiddleNode b[nr_neurons_B];
  306.   MiddleNode c[nr_neurons_C];
  307.   MiddleNode d[nr_neurons_D];
  308.   MiddleNode e[nr_neurons_E];
  309.   MiddleNode f[nr_neurons_F];
  310.   OutputNode g[nr_neurons_G];
  311.  
  312.   for (i = 0; i < zrows; i++) {
  313.  
  314.     for (j = 0; j < nr_neurons_A; j++) {
  315.  
  316.       train_input[i][j] = (i + 1.00) / (j + 1);
  317.       train_output[i][j] = 2.33 * pow(train_input[i][j],1.22);
  318.  
  319.     }
  320.  
  321.   }
  322.  
  323.   for (j = 0; j < nr_neurons_A; j++) {
  324.  
  325.     requested1[j] = 1.50 / (j + 1.00);
  326.  
  327.   }
  328.  
  329.   double input = 0;
  330.  
  331.   int i1, i2;
  332.  
  333.   for (i1 = 0; i1 < nr_neurons_A; i1++)
  334.     for (i2 = 0; i2 < nr_neurons_B; i2++) {
  335.       a[i1].w[i2] = initialize();
  336.       a[i1].bw[i2] = initialize();
  337.       a[i1].b[i2] = initialize();
  338.     }
  339.  
  340.   for (i1 = 0; i1 < nr_neurons_B; i1++)
  341.     for (i2 = 0; i2 < nr_neurons_C; i2++) {
  342.       b[i1].w[i2] = initialize();
  343.       b[i1].bw[i2] = initialize();
  344.       b[i1].b[i2] = initialize();
  345.     }
  346.  
  347.   for (i1 = 0; i1 < nr_neurons_C; i1++)
  348.     for (i2 = 0; i2 < nr_neurons_D; i2++) {
  349.       c[i1].w[i2] = initialize();
  350.       c[i1].bw[i2] = initialize();
  351.       c[i1].b[i2] = initialize();
  352.     }
  353.  
  354.   for (i1 = 0; i1 < nr_neurons_D; i1++)
  355.     for (i2 = 0; i2 < nr_neurons_E; i2++) {
  356.       d[i1].w[i2] = initialize();
  357.       d[i1].bw[i2] = initialize();
  358.       d[i1].b[i2] = initialize();
  359.     }
  360.  
  361.   for (i1 = 0; i1 < nr_neurons_E; i1++)
  362.     for (i2 = 0; i2 < nr_neurons_F; i2++) {
  363.       e[i1].w[i2] = initialize();
  364.       e[i1].bw[i2] = initialize();
  365.       e[i1].b[i2] = initialize();
  366.     }
  367.  
  368.   for (i1 = 0; i1 < nr_neurons_F; i1++)
  369.     for (i2 = 0; i2 < nr_neurons_G; i2++) {
  370.       f[i1].w[i2] = initialize();
  371.       f[i1].bw[i2] = initialize();
  372.       f[i1].b[i2] = initialize();
  373.     }
  374.  
  375.   for (i1 = 0; i1 < nr_neurons_G; i1++) {
  376.     g[i1].w[0] = initialize();
  377.     g[i1].bw[0] = initialize();
  378.     g[i1].b[0] = initialize();
  379.   }
  380.  
  381.   sqcalc = 99999999.99;
  382.   for (temp = 0; temp < loops; temp++) {
  383.  
  384.             //std::fill(atoTOTAL, atoTOTAL+5, 0);
  385.             std::fill(btoTOTAL, btoTOTAL+5, 0);
  386.             std::fill(ctoTOTAL, ctoTOTAL+5, 0);
  387.             std::fill(dtoTOTAL, dtoTOTAL+5, 0);
  388.             std::fill(etoTOTAL, etoTOTAL+5, 0);
  389.             std::fill(ftoTOTAL, ftoTOTAL+5, 0);
  390.  
  391.             std::fill(ato, ato+5, 0);
  392.             //std::fill(bto, bto+5, 0);
  393.             //std::fill(cto, cto+5, 0);
  394.             //std::fill(dto, dto+5, 0);
  395.             //std::fill(eto, eto+5, 0);
  396.             //std::fill(fto, fto+5, 0);
  397.             //d::fill(ato, ato+5, 0);
  398.  
  399.     //for (rows = 0; rows < zrows+1; rows++)
  400.     rows = rand() % (zrows + 1); {
  401.  
  402.       shuffled = rows;
  403.  
  404.       if (shuffled == zrows) training_mode = false;
  405.       else training_mode = true;;
  406.  
  407.  
  408.  
  409.      // TOTALbo = 0; TOTALao = 0;
  410.       for (C = 0; C < nr_neurons_C; C++) {
  411.  
  412.         for (B = 0; B < nr_neurons_B; B++) {
  413.           TOTAL = 0;
  414.           for (A = 0; A < nr_neurons_A; A++) {
  415.  
  416.             if (C == 0) {
  417.               a[A].o[B] = undetail(fx(choose(shuffled, A) * a[A].w[B] /*+ a[A].bw[B] * a[A].b[B]*/ ));
  418.               ato[B] += undetail(a[A].o[B]);
  419.               //atoTOTAL[B] += undetail(a[A].o[B]) ;
  420.              }
  421.  
  422.             TOTAL += undetail(a[A].o[B] * b[B].w[C]);
  423.             btoTOTAL[C] += undetail(a[A].o[B] * b[B].w[C]);
  424.           }
  425.  
  426.           b[B].o[C] = undetail(fx(btoTOTAL[C] /*+ b[B].bw[C] * b[B].b[C]*/ ));
  427.           //bto[C] += undetail(b[B].o[C]);
  428.  
  429.         }
  430.  
  431.       }
  432.  
  433.      // TOTALdo = 0;
  434.      // TOTALco = 0;
  435.  
  436.       for (E = 0; E < nr_neurons_E; E++) {
  437.         for (D = 0; D < nr_neurons_D; D++) {
  438.           //TOTAL = 0;
  439.           for (C = 0; C < nr_neurons_C; C++) {
  440.  
  441.             if (E == 0) {
  442.  
  443.              // double TOTALcCoD = 0;
  444.               for (B = 0; B < nr_neurons_B; B++) {
  445.                 ctoTOTAL[D] += undetail(b[B].o[C] * c[C].w[D]);
  446.               }
  447.  
  448.               c[C].o[D] = undetail(fx(ctoTOTAL[D] /*+ c[C].bw[D] * c[C].b[D]*/ ));
  449.               //cto[D] += undetail(c[C].o[D]);
  450.  
  451.  
  452.             }
  453.  
  454.             //TOTAL += undetail(c[C].o[D] * d[D].w[E]);
  455.             dtoTOTAL[E] += undetail(c[C].o[D] * d[D].w[E]);
  456.           }
  457.  
  458.           d[D].o[E] = undetail(fx(dtoTOTAL[E] /*+ d[D].bw[E] * d[D].b[E]*/ ));
  459.           dto[E] += undetail(d[D].o[E]);
  460.  
  461.         }
  462.  
  463.       }
  464.  
  465.       //TOTALeo = 0;
  466.       for (F = 0; F < nr_neurons_F; F++) {
  467.         for (E = 0; E < nr_neurons_E; E++) {
  468.          // TOTAL = 0;
  469.           for (D = 0; D < nr_neurons_D; D++) {
  470.            //   TOTAL += undetail(d[D].o[E] * e[E].w[F]);
  471.             etoTOTAL[F] += undetail(d[D].o[E] * e[E].w[F]);
  472.           }
  473.           e[E].o[F] = undetail(fx(etoTOTAL[F]/*+ e[E].bw[F] * e[E].b[F]*/ ));
  474.           eto[F] += undetail(e[E].o[F]);
  475.  
  476.  
  477.         }
  478.  
  479.       }
  480.  
  481.       //TOTALfo = 0;
  482.       for (G = 0; G < nr_neurons_G; G++) {
  483.         for (F = 0; F < nr_neurons_F; F++) {
  484.           //TOTAL = 0;
  485.           for (E = 0; E < nr_neurons_E; E++) {
  486.             //TOTAL += undetail(e[E].o[F] * f[F].w[G]);
  487.             ftoTOTAL[G] += undetail(e[E].o[F] * f[F].w[G]);
  488.           }
  489.  
  490.           f[F].o[G] = undetail(fx(ftoTOTAL[G] /*+ f[F].bw[G] * f[F].b[G]*/ ));
  491.           fto[G] += undetail(f[F].o[G]);
  492.  
  493.  
  494.         }
  495.  
  496.       }
  497.  
  498.       for (G = 0; G < nr_neurons_G; G++) {
  499.        TOTAL = 0;
  500.         for (F = 0; F < nr_neurons_F; F++) {
  501.           TOTAL += undetail(f[F].o[G] * g[G].w[0]);
  502.         }
  503.  
  504.         g[G].o[0] = undetail(fx(TOTAL /*+ g[G].bw[0] * g[G].b[0]*/ ));
  505.  
  506.       }
  507.  
  508.       if (temp > showtime) {
  509.  
  510.         if (training_mode) {
  511.           printf("\n-");
  512.           for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  513.  
  514.             printf("\n input: %.2lf The current output_%d for training set[%d] is %.28lf of (%lf)", train_input[shuffled][showoutputs], showoutputs, shuffled, g[showoutputs].o[0], train_output[shuffled][showoutputs]);
  515.  
  516.           }
  517.         } else {
  518.  
  519.           for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  520.  
  521.             printf("\n(loop: % d) output_%d for requested data (%.28lf) is currently : %.8lf  (should be:%lf)", temp, showoutputs, requested1[showoutputs], g[showoutputs].o[0], 2.00 * pow(requested1[showoutputs],2) );
  522.  
  523.           }
  524.  
  525.         }
  526.  
  527.       }
  528.  
  529.  
  530.  
  531.  
  532.  
  533.  
  534.       xerrtotal = 0;
  535.       if (training_mode) {
  536.         for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  537.           xerr[showoutputs] = 2 * (g[showoutputs].o[0] - train_output[shuffled][showoutputs]);
  538.  
  539.           xerrtotal += (xerr[showoutputs]);
  540.         }
  541.  
  542.  sqerrtot = xerrtotal;
  543.  
  544.  
  545.  
  546.         xDD = learn * xerrtotal;
  547.         gDD_times = xDD;
  548.         avgtot = 0; aw = 0; bw = 0; cw = 0; dw = 0; ew = 0; fw = 0; gw = 0;
  549.  
  550.  
  551.  
  552.  
  553.  
  554.  
  555.         for (G = 0; G < nr_neurons_G; G++) gDD_times *= g[G].w[0];
  556.         fDD_times = gDD_times;
  557.         for (G = 0; G < nr_neurons_G; G++) { for (F = 0; F < nr_neurons_F; F++) fDD_times *= f[F].w[G]; }
  558.         eDD_times =  fDD_times;
  559.         for (F = 0; F < nr_neurons_F; F++) { for (E = 0; E < nr_neurons_E; E++) eDD_times *= e[E].w[F]; }
  560.         dDD_times = eDD_times;
  561.         for (E = 0; E < nr_neurons_E; E++) { for (D = 0; D < nr_neurons_D; D++) dDD_times *= d[D].w[E]; }
  562.         cDD_times = dDD_times;
  563.         for (D = 0; D < nr_neurons_D; D++) { for (C = 0; C < nr_neurons_C; C++) cDD_times *= c[C].w[D]; }
  564.         bDD_times = cDD_times;
  565.         for (C = 0; C < nr_neurons_C; C++) { for (B = 0; B < nr_neurons_B; B++) bDD_times *= b[B].w[C]; }
  566.  
  567.  
  568.  
  569.         for (G = 0; G < nr_neurons_G; G++) {
  570.  
  571.           zDD_wupd = ftoTOTAL[G] * learn * xerr[G];
  572.  
  573.           gDD = xDD * g[G].w[0];
  574.  
  575.           tussen = fd(g[G].o[0]) * zDD_wupd;
  576.            g[G].w[0] -= tussen;
  577.           gw += tussen;
  578.           avgtot += tussen;
  579.           if (G==0) row_0 += tussen;
  580.           if (G==1) row_1 += tussen;
  581.           if (G==2) row_2 += tussen;
  582.           if (G==3) row_3 += tussen;
  583.  
  584.  
  585.  
  586.  
  587.           for (F = 0; F < nr_neurons_F; F++) {
  588.             gDD_wupd = etoTOTAL[F] * gDD;
  589.  
  590.  
  591.             tussen = fd(f[F].o[G]) * gDD_wupd;
  592.              f[F].w[G] -= tussen;
  593.             //f[F].w[G] -= new_avgtot;
  594.             //f[F].w[G] -= new_fw;
  595.             fw += tussen;
  596.             avgtot += tussen;
  597.           if (F==0) row_0 += tussen;
  598.           if (F==1) row_1 += tussen;
  599.           if (F==2) row_2 += tussen;
  600.           if (F==3) row_3 += tussen;
  601.  
  602.             }
  603.         }
  604.  
  605.  
  606.  
  607.  
  608.          for (F = 0; F < nr_neurons_F; F++) {
  609.  
  610.  
  611.             for (E = 0; E < nr_neurons_E; E++) {
  612.               fDD_wupd = dtoTOTAL[E] * fDD_times;
  613.  
  614.  
  615.               tussen = fd(e[E].o[F]) * fDD_wupd;
  616.                e[E].w[F] -= tussen;
  617.               //e[E].w[F] -= new_avgtot;
  618.               //e[E].w[F] -= new_ew;
  619.               ew += tussen;
  620.               avgtot += tussen;
  621.                       if (E==0) row_0 += tussen;
  622.           if (E==1) row_1 += tussen;
  623.           if (E==2) row_2 += tussen;
  624.           if (E==3) row_3 += tussen;
  625.  
  626.               }
  627.          }
  628.  
  629.  
  630.  
  631.             for (E = 0; E < nr_neurons_E; E++) {
  632.  
  633.  
  634.               for (D = 0; D < nr_neurons_D; D++) {
  635.                 eDD_wupd = ctoTOTAL[D] * eDD_times;
  636.  
  637.  
  638.  
  639.                 tussen = fd(d[D].o[E]) * eDD_wupd;
  640.                 d[D].w[E] -= tussen;
  641.                 //d[D].w[E] -= new_avgtot;
  642.                 //d[D].w[E] -= new_dw;
  643.                 dw += tussen;
  644.                 avgtot += tussen;
  645.                           if (D==0) row_0 += tussen;
  646.           if (D==1) row_1 += tussen;
  647.           if (D==2) row_2 += tussen;
  648.           if (D==3) row_3 += tussen;
  649.  
  650.                 }
  651.             }
  652.  
  653.  
  654.           for (D = 0; D < nr_neurons_D; D++) {
  655.  
  656.  
  657.                 for (C = 0; C < nr_neurons_C; C++) {
  658.                   dDD_wupd = btoTOTAL[C] * dDD_times;
  659.  
  660.  
  661.                   tussen = fd(c[C].o[D]) * dDD_wupd;
  662.                    c[C].w[D] -= tussen;
  663.                   //c[C].w[D] -= new_avgtot;
  664.                   //c[C].w[D] -= new_cw;
  665.                   cw += tussen;
  666.                   avgtot += tussen;
  667.                           if (C==0) row_0 += tussen;
  668.           if (C==1) row_1 += tussen;
  669.           if (C==2) row_2 += tussen;
  670.           if (C==3) row_3 += tussen;
  671.  
  672.                   }
  673.           }
  674.  
  675.  
  676.            for (C = 0; C < nr_neurons_C; C++) {
  677.  
  678.  
  679.                   for (B = 0; B < nr_neurons_B; B++) {
  680.                     cDD_wupd =  ato[B] * cDD_times;   //was atotal[b]
  681.                     tussen = fd(b[B].o[C]) * cDD_wupd;
  682.                     b[B].w[C] -= tussen;
  683.                     //b[B].w[C] -= new_avgtot;
  684.                     //b[B].w[C] -= new_bw;
  685.                     bw += tussen;
  686.                     avgtot += tussen;
  687.                               if (B==0) row_0 += tussen;
  688.           if (B==1) row_1 += tussen;
  689.           if (B==2) row_2 += tussen;
  690.           if (B==3) row_3 += tussen;
  691.  
  692.                     }
  693.            }
  694.  
  695.  
  696.  
  697.  
  698.             for (B = 0; B < nr_neurons_B; B++) {
  699.  
  700.  
  701.                     for (A = 0; A < nr_neurons_A; A++) {
  702.  
  703.                       tussen = train_input[shuffled][A] * fd(a[A].o[B]) * bDD_times;
  704.                       a[A].w[B] -= tussen;
  705.                       //a[A].w[B] -= new_avgtot;
  706.                       //a[A].w[B] -= new_aw;
  707.                       aw += tussen;
  708.                       avgtot += tussen;
  709.                               if (A==0) row_0 += tussen;
  710.           if (A==1) row_1 += tussen;
  711.           if (A==2) row_2 += tussen;
  712.           if (A==3) row_3 += tussen;
  713.  
  714.                       }
  715.             }
  716.  
  717.  
  718.        //printf("\ntijdelijk %d",tijdelijk);
  719.  
  720.        avgtot = avgtot / 96;
  721.  
  722.        aw = aw / (nr_neurons_A*4);
  723.        bw = bw / (nr_neurons_B*4);
  724.        cw = cw / (nr_neurons_C*4);
  725.        dw = dw / (nr_neurons_D*4);
  726.        ew = ew / (nr_neurons_E*4);
  727.        fw = fw / (nr_neurons_F*4);
  728.        gw = gw / (nr_neurons_G);
  729.  
  730.         row_0 = row_0 / 25;
  731.         row_1 = row_1 / 25;
  732.         row_2 = row_2 / 25;
  733.         row_3 = row_3 / 25;
  734.  
  735.  
  736.  
  737.  
  738.              for (G = 0; G < nr_neurons_G; G++) {
  739.  
  740.                   g[G].w[0] -= avgtot;    //average change for all nodes
  741.                   g[G].w[0] -= gw;        //average change for this 'block'
  742.                           if (G==0) g[G].w[0] -= row_0;
  743.                             if (G==1) g[G].w[0] -= row_1;
  744.                                 if (G==2) g[G].w[0] -= row_2;
  745.                                    if (G==3) g[G].w[0] -= row_3;
  746.                                         //g[G].w[0] = undetail(g[G].w[0]);
  747.  
  748.  
  749.  
  750.           for (F = 0; F < nr_neurons_F; F++) {
  751.  
  752.             f[F].w[G] -= avgtot;
  753.             f[F].w[G] -= fw;
  754.              if (F==0) f[F].w[G] -= row_0;
  755.              if (F==1) f[F].w[G] -= row_1;
  756.              if (F==2) f[F].w[G] -= row_2;
  757.              if (F==3) f[F].w[G] -= row_3;
  758.                //   f[F].w[G] = undetail(f[F].w[G]);
  759.  
  760.             }
  761.         }
  762.  
  763.  
  764.  
  765.  
  766.          for (F = 0; F < nr_neurons_F; F++) {
  767.  
  768.  
  769.             for (E = 0; E < nr_neurons_E; E++) {
  770.  
  771.               e[E].w[F] -= avgtot;
  772.               e[E].w[F] -= ew;
  773.  
  774.              if (E==0) e[E].w[F] -= row_0;
  775.              if (E==1) e[E].w[F] -= row_1;
  776.             if (E==2) e[E].w[F] -= row_2;
  777.              if (E==3) e[E].w[F] -= row_3;
  778.                //e[E].w[F] = undetail(e[E].w[F]);
  779.  
  780.               }
  781.          }
  782.  
  783.  
  784.  
  785.             for (E = 0; E < nr_neurons_E; E++) {
  786.  
  787.  
  788.               for (D = 0; D < nr_neurons_D; D++) {
  789.  
  790.                d[D].w[E] -= avgtot;
  791.                 d[D].w[E] -= dw;
  792.  
  793.              if (D==0) d[D].w[E] -= row_0;
  794.              if (D==1) d[D].w[E] -= row_1;
  795.              if (D==2) d[D].w[E] -= row_2;
  796.              if (D==3) d[D].w[E] -= row_3;
  797.                 // d[D].w[E] = undetail(d[D].w[E]);
  798.                 }
  799.             }
  800.  
  801.  
  802.           for (D = 0; D < nr_neurons_D; D++) {
  803.  
  804.  
  805.                 for (C = 0; C < nr_neurons_C; C++) {
  806.  
  807.                   c[C].w[D] -= avgtot;
  808.                   c[C].w[D] -= cw;
  809.  
  810.              if (C==0) c[C].w[D] -= row_0;
  811.              if (C==1) c[C].w[D] -= row_1;
  812.              if (C==2) c[C].w[D] -= row_2;
  813.              if (C==3) c[C].w[D] -= row_3;
  814.                  // c[C].w[D] = undetail(c[C].w[D]);
  815.                   }
  816.           }
  817.  
  818.  
  819.            for (C = 0; C < nr_neurons_C; C++) {
  820.  
  821.  
  822.                   for (B = 0; B < nr_neurons_B; B++) {
  823.  
  824.                     b[B].w[C] -= avgtot;
  825.                     b[B].w[C] -= bw;
  826.  
  827.              if (B==0) b[B].w[C] -= row_0;
  828.              if (B==1) b[B].w[C] -= row_1;
  829.             if (B==2) b[B].w[C] -= row_2;
  830.             if (B==3) b[B].w[C] -= row_3;
  831.                    //    b[B].w[C]  = undetail(b[B].w[C]);
  832.                     }
  833.            }
  834.  
  835.  
  836.  
  837.  
  838.             for (B = 0; B < nr_neurons_B; B++) {
  839.  
  840.  
  841.                     for (A = 0; A < nr_neurons_A; A++) {
  842.  
  843.  
  844.                       a[A].w[B] -= avgtot;
  845.                       a[A].w[B] -= aw;
  846.  
  847.             if (A==0) a[A].w[B] -= row_0;
  848.             if (A==1) a[A].w[B] -= row_1;
  849.             if (A==2) a[A].w[B] -= row_2;
  850.             if (A==3) a[A].w[B] -= row_3;
  851.                     //  a[A].w[B] = undetail(a[A].w[B]);
  852.                       }
  853.             }
  854.  
  855.  
  856.  
  857.  
  858.  
  859.  
  860.  
  861.  
  862.  
  863.  
  864.  
  865.  
  866.  
  867.  
  868.  
  869.  
  870.  
  871.  
  872.  
  873.  
  874.  
  875.  
  876.  
  877.  
  878.  
  879.  
  880.  
  881.  
  882.  
  883.  
  884.  
  885.  
  886.  
  887.  
  888.  
  889.  
  890.  
  891.  
  892.  
  893.  
  894.  
  895.  
  896.  
  897.  
  898.        /*
  899.         for (G = 0; G < nr_neurons_G; G++) {
  900.  
  901.           zDD_wupd = TOTALfo * learn * xerr[G];
  902.  
  903.           gDD = xDD * g[G].w[0];
  904.           gDD_wupd = TOTALeo * gDD;
  905.           g[G].w[0] -= fd(g[G].o[0]) * zDD_wupd * nr_neurons_G;
  906.  
  907.  
  908.           for (F = 0; F < nr_neurons_F; F++) {
  909.             fDD = f[F].w[G] * gDD;
  910.             fDD_wupd = TOTALdo * fDD;
  911.             f[F].w[G] -= fd(f[F].o[G]) * gDD_wupd * nr_neurons_F / xerrtotal * xerr[G];
  912.  
  913.             }
  914.         }
  915.  
  916.  
  917.  
  918.  
  919.          for (F = 0; F < nr_neurons_F; F++) {
  920.  
  921.  
  922.             for (E = 0; E < nr_neurons_E; E++) {
  923.               eDD = e[E].w[F] * fDD;
  924.               eDD_wupd = TOTALco * eDD;
  925.               e[E].w[F] -= fd(e[E].o[F]) * fDD_wupd * nr_neurons_E;
  926.  
  927.               }
  928.          }
  929.  
  930.  
  931.  
  932.             for (E = 0; E < nr_neurons_E; E++) {
  933.  
  934.  
  935.               for (D = 0; D < nr_neurons_D; D++) {
  936.                 dDD = d[D].w[E] * eDD;
  937.                 dDD_wupd = TOTALbo * dDD;
  938.                 d[D].w[E] -= fd(d[D].o[E]) * eDD_wupd * nr_neurons_D;
  939.  
  940.                 }
  941.             }
  942.  
  943.  
  944.           for (D = 0; D < nr_neurons_D; D++) {
  945.  
  946.  
  947.                 for (C = 0; C < nr_neurons_C; C++) {
  948.                   cDD = c[C].w[D] * dDD;
  949.                   cDD_wupd = cDD * TOTALao;
  950.                   c[C].w[D] -= fd(c[C].o[D]) * dDD_wupd * nr_neurons_C;
  951.  
  952.                   }
  953.           }
  954.  
  955.  
  956.            for (C = 0; C < nr_neurons_C; C++) {
  957.  
  958.  
  959.                   for (B = 0; B < nr_neurons_B; B++) {
  960.                     bDD = b[B].w[C] * cDD;
  961.                     b[B].w[C] -= fd(b[B].o[C]) * cDD_wupd * nr_neurons_B;
  962.  
  963.                     }
  964.            }
  965.  
  966.  
  967.  
  968.  
  969.             for (B = 0; B < nr_neurons_B; B++) {
  970.  
  971.  
  972.                     for (A = 0; A < nr_neurons_A; A++) {
  973.  
  974.                       a[A].w[B] -= train_input[shuffled][A] * fd(a[A].o[B]) * bDD * nr_neurons_A;
  975.  
  976.                       }
  977.             }
  978.  
  979.  
  980.  
  981.               */
  982.  
  983.  
  984.  
  985.  
  986.  
  987.  
  988.  
  989.  
  990.  
  991.  
  992.  
  993.  
  994.  
  995.  
  996.  
  997.  
  998.  
  999.  
  1000.  
  1001.  
  1002.  
  1003.  
  1004.  
  1005.  
  1006.  
  1007.       }
  1008.  
  1009.  
  1010.     }
  1011.  
  1012.  
  1013.  
  1014.     if (!(temp % (showtime/100))) printf("\n %d %%",++Z);
  1015.  
  1016.     sqcalc += sqerrtot;
  1017.  
  1018.     if (temp % 1000 == 0) {
  1019.       gemiddelde = sqcalc / 1000;
  1020.       sqcalc = 0;
  1021.     }
  1022.  
  1023.     sqerrtot = 0;
  1024.  
  1025.   }
  1026.  
  1027.   printf("\nEnd.");
  1028.   scanf("%d", &Z);
  1029.  
  1030.   return 0;
  1031.  
  1032. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!