API tools faq
paste
Hexadroid

giraffe

Hexadroid
Dec 26th, 2020
896
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 19.37 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 = 40000000;
  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.00000000001;
  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 ((rand()%10000)/10000.00);
  113.  
  114. }
  115.  
  116. double fd(double x) {
  117.  
  118.   return (x >= 0) ? (1) : (0);
  119.  
  120. }
  121.  
  122. double fx(double x) {
  123.  
  124.   return (x >= 0) ? (x) : (0);
  125.  
  126. }
  127.  
  128. int _tmain(int argc, _TCHAR * argv[]) {
  129.  
  130.   srand (time(NULL));
  131.  
  132.   std::random_device rd;
  133.   std::mt19937 gh(rd());
  134.  
  135.   learn = learn / tota;
  136.  
  137.  
  138.   InputNode a[nr_neurons_A];
  139.   MiddleNode b[nr_neurons_B];
  140.   MiddleNode c[nr_neurons_C];
  141.   MiddleNode d[nr_neurons_D];
  142.   MiddleNode e[nr_neurons_E];
  143.   MiddleNode f[nr_neurons_F];
  144.   OutputNode g[nr_neurons_G];
  145.  
  146.   for (i = 0; i < zrows; i++) {
  147.  
  148.     for (j = 0; j < nr_neurons_A; j++) {
  149.  
  150.       train_input[i][j] = (i + 1.00) / (j + 1);
  151.       train_output[i][j] = 2.33 * pow(train_input[i][j],1.22);
  152.  
  153.     }
  154.  
  155.   }
  156.  
  157.   for (j = 0; j < nr_neurons_A; j++) {
  158.  
  159.     requested1[j] = 1.50 / (j + 1.00);
  160.  
  161.   }
  162.  
  163.   double input = 0;
  164.  
  165.   int i1, i2;
  166.  
  167.   for (i1 = 0; i1 < nr_neurons_A; i1++)
  168.     for (i2 = 0; i2 < nr_neurons_B; i2++) {
  169.       a[i1].w[i2] = initialize();
  170.       a[i1].bw[i2] = initialize();
  171.       a[i1].b[i2] = initialize();
  172.     }
  173.  
  174.   for (i1 = 0; i1 < nr_neurons_B; i1++)
  175.     for (i2 = 0; i2 < nr_neurons_C; i2++) {
  176.       b[i1].w[i2] = initialize();
  177.       b[i1].bw[i2] = initialize();
  178.       b[i1].b[i2] = initialize();
  179.     }
  180.  
  181.   for (i1 = 0; i1 < nr_neurons_C; i1++)
  182.     for (i2 = 0; i2 < nr_neurons_D; i2++) {
  183.       c[i1].w[i2] = initialize();
  184.       c[i1].bw[i2] = initialize();
  185.       c[i1].b[i2] = initialize();
  186.     }
  187.  
  188.   for (i1 = 0; i1 < nr_neurons_D; i1++)
  189.     for (i2 = 0; i2 < nr_neurons_E; i2++) {
  190.       d[i1].w[i2] = initialize();
  191.       d[i1].bw[i2] = initialize();
  192.       d[i1].b[i2] = initialize();
  193.     }
  194.  
  195.   for (i1 = 0; i1 < nr_neurons_E; i1++)
  196.     for (i2 = 0; i2 < nr_neurons_F; i2++) {
  197.       e[i1].w[i2] = initialize();
  198.       e[i1].bw[i2] = initialize();
  199.       e[i1].b[i2] = initialize();
  200.     }
  201.  
  202.   for (i1 = 0; i1 < nr_neurons_F; i1++)
  203.     for (i2 = 0; i2 < nr_neurons_G; i2++) {
  204.       f[i1].w[i2] = initialize();
  205.       f[i1].bw[i2] = initialize();
  206.       f[i1].b[i2] = initialize();
  207.     }
  208.  
  209.   for (i1 = 0; i1 < nr_neurons_G; i1++) {
  210.     g[i1].w[0] = initialize();
  211.     g[i1].bw[0] = initialize();
  212.     g[i1].b[0] = initialize();
  213.   }
  214.  
  215.   sqcalc = 99999999.99;
  216.   for (temp = 0; temp < loops; temp++) {
  217.  
  218.             std::fill(atoTOTAL, atoTOTAL+5, 0);
  219.             std::fill(btoTOTAL, btoTOTAL+5, 0);
  220.             std::fill(ctoTOTAL, ctoTOTAL+5, 0);
  221.             std::fill(dtoTOTAL, dtoTOTAL+5, 0);
  222.             std::fill(etoTOTAL, etoTOTAL+5, 0);
  223.             std::fill(ftoTOTAL, ftoTOTAL+5, 0);
  224.  
  225.             std::fill(ato, ato+5, 0);
  226.             std::fill(bto, bto+5, 0);
  227.             std::fill(cto, cto+5, 0);
  228.             std::fill(dto, dto+5, 0);
  229.             std::fill(eto, eto+5, 0);
  230.             std::fill(fto, fto+5, 0);
  231.             //d::fill(ato, ato+5, 0);
  232.  
  233.     //for (rows = 0; rows < zrows+1; rows++)
  234.     rows = rand() % (zrows + 1); {
  235.  
  236.       shuffled = rows;
  237.  
  238.       if (shuffled == zrows) training_mode = false;
  239.       else training_mode = true;;
  240.  
  241.  
  242.  
  243.       TOTALbo = 0; TOTALao = 0;
  244.       for (C = 0; C < nr_neurons_C; C++) {
  245.  
  246.         for (B = 0; B < nr_neurons_B; B++) {
  247.           TOTAL = 0;
  248.           for (A = 0; A < nr_neurons_A; A++) {
  249.  
  250.             if (C == 0) {
  251.               a[A].o[B] = fx(choose(shuffled, A) * a[A].w[B] /*+ a[A].bw[B] * a[A].b[B]*/ );
  252.               ato[B] += a[A].o[B];
  253.               atoTOTAL[B] += a[A].o[B] ;
  254.              }
  255.  
  256.             TOTAL += a[A].o[B] * b[B].w[C];
  257.             btoTOTAL[C] += a[A].o[B] * b[B].w[C];
  258.           }
  259.  
  260.           b[B].o[C] = fx(btoTOTAL[C] /*+ b[B].bw[C] * b[B].b[C]*/ );
  261.           bto[C] += b[B].o[C];
  262.  
  263.         }
  264.  
  265.       }
  266.  
  267.       TOTALdo = 0;
  268.       TOTALco = 0;
  269.  
  270.       for (E = 0; E < nr_neurons_E; E++) {
  271.         for (D = 0; D < nr_neurons_D; D++) {
  272.           TOTAL = 0;
  273.           for (C = 0; C < nr_neurons_C; C++) {
  274.  
  275.             if (E == 0) {
  276.  
  277.               double TOTALcCoD = 0;
  278.               for (B = 0; B < nr_neurons_B; B++) {
  279.                 ctoTOTAL[D] += b[B].o[C] * c[C].w[D];
  280.               }
  281.  
  282.               c[C].o[D] = fx(ctoTOTAL[D] /*+ c[C].bw[D] * c[C].b[D]*/ );
  283.               cto[D] += c[C].o[D];
  284.  
  285.  
  286.             }
  287.  
  288.             TOTAL += c[C].o[D] * d[D].w[E];
  289.             dtoTOTAL[E] += c[C].o[D] * d[D].w[E];
  290.           }
  291.  
  292.           TOTALdo += (d[D].o[E] = fx(dtoTOTAL[E] /*+ d[D].bw[E] * d[D].b[E]*/ ));
  293.           dto[E] += d[D].o[E];
  294.  
  295.         }
  296.  
  297.       }
  298.  
  299.       TOTALeo = 0;
  300.       for (F = 0; F < nr_neurons_F; F++) {
  301.         for (E = 0; E < nr_neurons_E; E++) {
  302.           TOTAL = 0;
  303.           for (D = 0; D < nr_neurons_D; D++) {
  304.             TOTAL += d[D].o[E] * e[E].w[F];
  305.             etoTOTAL[F] += d[D].o[E] * e[E].w[F];
  306.           }
  307.           TOTALeo += (e[E].o[F] = fx(etoTOTAL[F]/*+ e[E].bw[F] * e[E].b[F]*/ ));
  308.           eto[F] += e[E].o[F];
  309.  
  310.  
  311.         }
  312.  
  313.       }
  314.  
  315.       TOTALfo = 0;
  316.       for (G = 0; G < nr_neurons_G; G++) {
  317.         for (F = 0; F < nr_neurons_F; F++) {
  318.           TOTAL = 0;
  319.           for (E = 0; E < nr_neurons_E; E++) {
  320.             TOTAL += e[E].o[F] * f[F].w[G];
  321.             ftoTOTAL[G] += e[E].o[F] * f[F].w[G];
  322.           }
  323.  
  324.           TOTALfo += (f[F].o[G] = fx(ftoTOTAL[G] /*+ f[F].bw[G] * f[F].b[G]*/ ));
  325.           fto[G] += f[F].o[G];
  326.  
  327.  
  328.         }
  329.  
  330.       }
  331.  
  332.       for (G = 0; G < nr_neurons_G; G++) {
  333.         TOTAL = 0;
  334.         for (F = 0; F < nr_neurons_F; F++) {
  335.           TOTAL += f[F].o[G] * g[G].w[0];
  336.         }
  337.  
  338.         g[G].o[0] = fx(TOTAL /*+ g[G].bw[0] * g[G].b[0]*/ );
  339.  
  340.       }
  341.  
  342.       if (temp > showtime) {
  343.  
  344.         if (training_mode) {
  345.           printf("\n-");
  346.           for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  347.  
  348.             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]);
  349.  
  350.           }
  351.         } else {
  352.  
  353.           for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  354.  
  355.             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) );
  356.  
  357.           }
  358.  
  359.         }
  360.  
  361.       }
  362.  
  363.  
  364.  
  365.  
  366.  
  367.  
  368.       xerrtotal = 0;
  369.       if (training_mode) {
  370.         for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  371.           xerr[showoutputs] = 2 * (g[showoutputs].o[0] - train_output[shuffled][showoutputs]);
  372.  
  373.           xerrtotal += (xerr[showoutputs]);
  374.         }
  375.  
  376.  sqerrtot = xerrtotal;
  377.  
  378.  
  379.  
  380.         xDD = learn * xerrtotal;
  381.         gDD_times = xDD;
  382.         avgtot = 0; aw = 0; bw = 0; cw = 0; dw = 0; ew = 0; fw = 0; gw = 0;
  383.  
  384.  
  385.  
  386.  
  387.  
  388.  
  389.         for (G = 0; G < nr_neurons_G; G++) gDD_times *= g[G].w[0];
  390.         fDD_times = gDD_times;
  391.         for (G = 0; G < nr_neurons_G; G++) { for (F = 0; F < nr_neurons_F; F++) fDD_times *= f[F].w[G]; }
  392.         eDD_times =  fDD_times;
  393.         for (F = 0; F < nr_neurons_F; F++) { for (E = 0; E < nr_neurons_E; E++) eDD_times *= e[E].w[F]; }
  394.         dDD_times = eDD_times;
  395.         for (E = 0; E < nr_neurons_E; E++) { for (D = 0; D < nr_neurons_D; D++) dDD_times *= d[D].w[E]; }
  396.         cDD_times = dDD_times;
  397.         for (D = 0; D < nr_neurons_D; D++) { for (C = 0; C < nr_neurons_C; C++) cDD_times *= c[C].w[D]; }
  398.         bDD_times = cDD_times;
  399.         for (C = 0; C < nr_neurons_C; C++) { for (B = 0; B < nr_neurons_B; B++) bDD_times *= b[B].w[C]; }
  400.  
  401.  
  402.  
  403.         for (G = 0; G < nr_neurons_G; G++) {
  404.  
  405.           zDD_wupd = ftoTOTAL[G] * learn * xerr[G];
  406.  
  407.           gDD = xDD * g[G].w[0];
  408.  
  409.           tussen = fd(g[G].o[0]) * zDD_wupd;
  410.            g[G].w[0] -= tussen;
  411.           gw += tussen;
  412.           avgtot += tussen;
  413.           if (G==0) row_0 += tussen;
  414.           if (G==1) row_1 += tussen;
  415.           if (G==2) row_2 += tussen;
  416.           if (G==3) row_3 += tussen;
  417.  
  418.  
  419.  
  420.  
  421.           for (F = 0; F < nr_neurons_F; F++) {
  422.             gDD_wupd = etoTOTAL[F] * gDD;
  423.  
  424.  
  425.             tussen = fd(f[F].o[G]) * gDD_wupd;
  426.              f[F].w[G] -= tussen;
  427.             //f[F].w[G] -= new_avgtot;
  428.             //f[F].w[G] -= new_fw;
  429.             fw += tussen;
  430.             avgtot += tussen;
  431.           if (F==0) row_0 += tussen;
  432.           if (F==1) row_1 += tussen;
  433.           if (F==2) row_2 += tussen;
  434.           if (F==3) row_3 += tussen;
  435.  
  436.             }
  437.         }
  438.  
  439.  
  440.  
  441.  
  442.          for (F = 0; F < nr_neurons_F; F++) {
  443.  
  444.  
  445.             for (E = 0; E < nr_neurons_E; E++) {
  446.               fDD_wupd = dtoTOTAL[E] * fDD_times;
  447.  
  448.  
  449.               tussen = fd(e[E].o[F]) * fDD_wupd;
  450.                e[E].w[F] -= tussen;
  451.               //e[E].w[F] -= new_avgtot;
  452.               //e[E].w[F] -= new_ew;
  453.               ew += tussen;
  454.               avgtot += tussen;
  455.                       if (E==0) row_0 += tussen;
  456.           if (E==1) row_1 += tussen;
  457.           if (E==2) row_2 += tussen;
  458.           if (E==3) row_3 += tussen;
  459.  
  460.               }
  461.          }
  462.  
  463.  
  464.  
  465.             for (E = 0; E < nr_neurons_E; E++) {
  466.  
  467.  
  468.               for (D = 0; D < nr_neurons_D; D++) {
  469.                 eDD_wupd = ctoTOTAL[D] * eDD_times;
  470.  
  471.  
  472.  
  473.                 tussen = fd(d[D].o[E]) * eDD_wupd;
  474.                 d[D].w[E] -= tussen;
  475.                 //d[D].w[E] -= new_avgtot;
  476.                 //d[D].w[E] -= new_dw;
  477.                 dw += tussen;
  478.                 avgtot += tussen;
  479.                           if (D==0) row_0 += tussen;
  480.           if (D==1) row_1 += tussen;
  481.           if (D==2) row_2 += tussen;
  482.           if (D==3) row_3 += tussen;
  483.  
  484.                 }
  485.             }
  486.  
  487.  
  488.           for (D = 0; D < nr_neurons_D; D++) {
  489.  
  490.  
  491.                 for (C = 0; C < nr_neurons_C; C++) {
  492.                   dDD_wupd = btoTOTAL[C] * dDD_times;
  493.  
  494.  
  495.                   tussen = fd(c[C].o[D]) * dDD_wupd;
  496.                    c[C].w[D] -= tussen;
  497.                   //c[C].w[D] -= new_avgtot;
  498.                   //c[C].w[D] -= new_cw;
  499.                   cw += tussen;
  500.                   avgtot += tussen;
  501.                           if (C==0) row_0 += tussen;
  502.           if (C==1) row_1 += tussen;
  503.           if (C==2) row_2 += tussen;
  504.           if (C==3) row_3 += tussen;
  505.  
  506.                   }
  507.           }
  508.  
  509.  
  510.            for (C = 0; C < nr_neurons_C; C++) {
  511.  
  512.  
  513.                   for (B = 0; B < nr_neurons_B; B++) {
  514.                     cDD_wupd =  ato[B] * cDD_times;   //was atotal[b]
  515.                     tussen = fd(b[B].o[C]) * cDD_wupd;
  516.                     b[B].w[C] -= tussen;
  517.                     //b[B].w[C] -= new_avgtot;
  518.                     //b[B].w[C] -= new_bw;
  519.                     bw += tussen;
  520.                     avgtot += tussen;
  521.                               if (B==0) row_0 += tussen;
  522.           if (B==1) row_1 += tussen;
  523.           if (B==2) row_2 += tussen;
  524.           if (B==3) row_3 += tussen;
  525.  
  526.                     }
  527.            }
  528.  
  529.  
  530.  
  531.  
  532.             for (B = 0; B < nr_neurons_B; B++) {
  533.  
  534.  
  535.                     for (A = 0; A < nr_neurons_A; A++) {
  536.  
  537.                       tussen = train_input[shuffled][A] * fd(a[A].o[B]) * bDD_times;
  538.                       a[A].w[B] -= tussen;
  539.                       //a[A].w[B] -= new_avgtot;
  540.                       //a[A].w[B] -= new_aw;
  541.                       aw += tussen;
  542.                       avgtot += tussen;
  543.                               if (A==0) row_0 += tussen;
  544.           if (A==1) row_1 += tussen;
  545.           if (A==2) row_2 += tussen;
  546.           if (A==3) row_3 += tussen;
  547.  
  548.                       }
  549.             }
  550.  
  551.  
  552.        //printf("\ntijdelijk %d",tijdelijk);
  553.  
  554.        avgtot = avgtot / 96;
  555.  
  556.        aw = aw / (nr_neurons_A*4);
  557.        bw = bw / (nr_neurons_B*4);
  558.        cw = cw / (nr_neurons_C*4);
  559.        dw = dw / (nr_neurons_D*4);
  560.        ew = ew / (nr_neurons_E*4);
  561.        fw = fw / (nr_neurons_F*4);
  562.        gw = gw / (nr_neurons_G);
  563.  
  564.         row_0 = row_0 / 25;
  565.         row_1 = row_1 / 25;
  566.         row_2 = row_2 / 25;
  567.         row_3 = row_3 / 25;
  568.  
  569.  
  570.  
  571.  
  572.              for (G = 0; G < nr_neurons_G; G++) {
  573.  
  574.                   g[G].w[0] -= avgtot;    //average change for all nodes
  575.                   g[G].w[0] -= gw;        //average change for this 'block'
  576.                           if (G==0) g[G].w[0] -= row_0;
  577.                             if (G==1) g[G].w[0] -= row_1;
  578.                                 if (G==2) g[G].w[0] -= row_2;
  579.                                    if (G==3) g[G].w[0] -= row_3;
  580.  
  581.  
  582.  
  583.  
  584.           for (F = 0; F < nr_neurons_F; F++) {
  585.  
  586.             f[F].w[G] -= avgtot;
  587.             f[F].w[G] -= fw;
  588.              if (F==0) f[F].w[G] -= row_0;
  589.              if (F==1) f[F].w[G] -= row_1;
  590.              if (F==2) f[F].w[G] -= row_2;
  591.              if (F==3) f[F].w[G] -= row_3;
  592.  
  593.  
  594.             }
  595.         }
  596.  
  597.  
  598.  
  599.  
  600.          for (F = 0; F < nr_neurons_F; F++) {
  601.  
  602.  
  603.             for (E = 0; E < nr_neurons_E; E++) {
  604.  
  605.               e[E].w[F] -= avgtot;
  606.               e[E].w[F] -= ew;
  607.  
  608.              if (E==0) e[E].w[F] -= row_0;
  609.              if (E==1) e[E].w[F] -= row_1;
  610.             if (E==2) e[E].w[F] -= row_2;
  611.              if (E==3) e[E].w[F] -= row_3;
  612.  
  613.  
  614.               }
  615.          }
  616.  
  617.  
  618.  
  619.             for (E = 0; E < nr_neurons_E; E++) {
  620.  
  621.  
  622.               for (D = 0; D < nr_neurons_D; D++) {
  623.  
  624.                d[D].w[E] -= avgtot;
  625.                 d[D].w[E] -= dw;
  626.  
  627.              if (D==0) d[D].w[E] -= row_0;
  628.              if (D==1) d[D].w[E] -= row_1;
  629.              if (D==2) d[D].w[E] -= row_2;
  630.              if (D==3) d[D].w[E] -= row_3;
  631.  
  632.                 }
  633.             }
  634.  
  635.  
  636.           for (D = 0; D < nr_neurons_D; D++) {
  637.  
  638.  
  639.                 for (C = 0; C < nr_neurons_C; C++) {
  640.  
  641.                   c[C].w[D] -= avgtot;
  642.                   c[C].w[D] -= cw;
  643.  
  644.              if (C==0) c[C].w[D] -= row_0;
  645.              if (C==1) c[C].w[D] -= row_1;
  646.              if (C==2) c[C].w[D] -= row_2;
  647.              if (C==3) c[C].w[D] -= row_3;
  648.  
  649.                   }
  650.           }
  651.  
  652.  
  653.            for (C = 0; C < nr_neurons_C; C++) {
  654.  
  655.  
  656.                   for (B = 0; B < nr_neurons_B; B++) {
  657.  
  658.                     b[B].w[C] -= avgtot;
  659.                     b[B].w[C] -= bw;
  660.  
  661.              if (B==0) b[B].w[C] -= row_0;
  662.              if (B==1) b[B].w[C] -= row_1;
  663.             if (B==2) b[B].w[C] -= row_2;
  664.             if (B==3) b[B].w[C] -= row_3;
  665.  
  666.                     }
  667.            }
  668.  
  669.  
  670.  
  671.  
  672.             for (B = 0; B < nr_neurons_B; B++) {
  673.  
  674.  
  675.                     for (A = 0; A < nr_neurons_A; A++) {
  676.  
  677.  
  678.                       a[A].w[B] -= avgtot;
  679.                       a[A].w[B] -= aw;
  680.  
  681.             if (A==0) a[A].w[B] -= row_0;
  682.             if (A==1) a[A].w[B] -= row_1;
  683.             if (A==2) a[A].w[B] -= row_2;
  684.             if (A==3) a[A].w[B] -= row_3;
  685.  
  686.                       }
  687.             }
  688.  
  689.  
  690.  
  691.  
  692.  
  693.  
  694.  
  695.  
  696.  
  697.  
  698.  
  699.  
  700.  
  701.  
  702.  
  703.  
  704.  
  705.  
  706.  
  707.  
  708.  
  709.  
  710.  
  711.  
  712.  
  713.  
  714.  
  715.  
  716.  
  717.  
  718.  
  719.  
  720.  
  721.  
  722.  
  723.  
  724.  
  725.  
  726.  
  727.  
  728.  
  729.  
  730.  
  731.  
  732.        /*
  733.         for (G = 0; G < nr_neurons_G; G++) {
  734.  
  735.           zDD_wupd = TOTALfo * learn * xerr[G];
  736.  
  737.           gDD = xDD * g[G].w[0];
  738.           gDD_wupd = TOTALeo * gDD;
  739.           g[G].w[0] -= fd(g[G].o[0]) * zDD_wupd * nr_neurons_G;
  740.  
  741.  
  742.           for (F = 0; F < nr_neurons_F; F++) {
  743.             fDD = f[F].w[G] * gDD;
  744.             fDD_wupd = TOTALdo * fDD;
  745.             f[F].w[G] -= fd(f[F].o[G]) * gDD_wupd * nr_neurons_F / xerrtotal * xerr[G];
  746.  
  747.             }
  748.         }
  749.  
  750.  
  751.  
  752.  
  753.          for (F = 0; F < nr_neurons_F; F++) {
  754.  
  755.  
  756.             for (E = 0; E < nr_neurons_E; E++) {
  757.               eDD = e[E].w[F] * fDD;
  758.               eDD_wupd = TOTALco * eDD;
  759.               e[E].w[F] -= fd(e[E].o[F]) * fDD_wupd * nr_neurons_E;
  760.  
  761.               }
  762.          }
  763.  
  764.  
  765.  
  766.             for (E = 0; E < nr_neurons_E; E++) {
  767.  
  768.  
  769.               for (D = 0; D < nr_neurons_D; D++) {
  770.                 dDD = d[D].w[E] * eDD;
  771.                 dDD_wupd = TOTALbo * dDD;
  772.                 d[D].w[E] -= fd(d[D].o[E]) * eDD_wupd * nr_neurons_D;
  773.  
  774.                 }
  775.             }
  776.  
  777.  
  778.           for (D = 0; D < nr_neurons_D; D++) {
  779.  
  780.  
  781.                 for (C = 0; C < nr_neurons_C; C++) {
  782.                   cDD = c[C].w[D] * dDD;
  783.                   cDD_wupd = cDD * TOTALao;
  784.                   c[C].w[D] -= fd(c[C].o[D]) * dDD_wupd * nr_neurons_C;
  785.  
  786.                   }
  787.           }
  788.  
  789.  
  790.            for (C = 0; C < nr_neurons_C; C++) {
  791.  
  792.  
  793.                   for (B = 0; B < nr_neurons_B; B++) {
  794.                     bDD = b[B].w[C] * cDD;
  795.                     b[B].w[C] -= fd(b[B].o[C]) * cDD_wupd * nr_neurons_B;
  796.  
  797.                     }
  798.            }
  799.  
  800.  
  801.  
  802.  
  803.             for (B = 0; B < nr_neurons_B; B++) {
  804.  
  805.  
  806.                     for (A = 0; A < nr_neurons_A; A++) {
  807.  
  808.                       a[A].w[B] -= train_input[shuffled][A] * fd(a[A].o[B]) * bDD * nr_neurons_A;
  809.  
  810.                       }
  811.             }
  812.  
  813.  
  814.  
  815.               */
  816.  
  817.  
  818.  
  819.  
  820.  
  821.  
  822.  
  823.  
  824.  
  825.  
  826.  
  827.  
  828.  
  829.  
  830.  
  831.  
  832.  
  833.  
  834.  
  835.  
  836.  
  837.  
  838.  
  839.  
  840.  
  841.       }
  842.  
  843.  
  844.     }
  845.  
  846.  
  847.  
  848.     if (!(temp % (showtime/100))) printf("\n %d %%",++Z);
  849.  
  850.     sqcalc += sqerrtot;
  851.  
  852.     if (temp % 1000 == 0) {
  853.       gemiddelde = sqcalc / 1000;
  854.       sqcalc = 0;
  855.     }
  856.  
  857.     sqerrtot = 0;
  858.  
  859.   }
  860.  
  861.   printf("\nEnd.");
  862.   scanf("%d", &Z);
  863.  
  864.   return 0;
  865.  
  866. }
Advertisement
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!