API tools faq
paste
Hexadroid

undetail

Hexadroid
Feb 27th, 2021
70
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 19.54 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. double pseudorandteller = 1;
  10.  
  11. const int nr_neurons_A = 4;
  12. const int nr_neurons_B = 4;
  13. const int nr_neurons_C = 4;
  14. const int nr_neurons_D = 4;
  15. const int nr_neurons_E = 4;
  16. const int nr_neurons_F = 4;
  17. const int nr_neurons_G = 4;
  18. int tota = nr_neurons_A + nr_neurons_B + nr_neurons_C + nr_neurons_D + nr_neurons_E + nr_neurons_F + nr_neurons_G;
  19.  
  20. int Z;
  21. int A, B, C, D, E, F, G;
  22. int loops = 1000000;
  23. int showtime = 0.99*loops;
  24. int zrows = 99;
  25. int temp, i1, i2, rows, shuffled;
  26. int i, j;
  27. int showoutputs;
  28.  
  29. double diff;
  30. double xDD, gDD, fDD, eDD, dDD, cDD, bDD, zDD;
  31. double bDD_xupd, bDD_xbupd;
  32. double cDD_wupd, cDD_bupd;
  33. double dDD_wupd, dDD_bupd;
  34. double eDD_wupd, eDD_bupd;
  35. double fDD_wupd, fDD_bupd;
  36. double gDD_wupd, gDD_bupd;
  37. double zDD_wupd, zDD_bupd;
  38.  
  39. double membDD_xupd[nr_neurons_A][nr_neurons_B];
  40. double memBWC_xupd[nr_neurons_B][nr_neurons_C];
  41. double memCWD_xupd[nr_neurons_C][nr_neurons_D];
  42. double memDWD_xupd[nr_neurons_D][nr_neurons_E];
  43. double memEWD_xupd[nr_neurons_E][nr_neurons_F];
  44. double memFWD_xupd[nr_neurons_F][nr_neurons_G];
  45. double memGWD_xupd[nr_neurons_G];
  46.  
  47. double sqcalc, gemiddelde;
  48. double TOTAL, TOTALcCoD, TOTALao, TOTALbo, TOTALco, TOTALdo, TOTALeo, TOTALfo;
  49. double learn = 0.000001;     //plus:0.0000000001;
  50. double xerr[nr_neurons_G], xerrtotal;
  51. double sqerrtot = 0;
  52.  
  53. double ato[5];
  54. double bto[5];
  55. double cto[5];
  56. double dto[5];
  57. double eto[5];
  58. double fto[5];
  59.  
  60. double atoTOTAL[5];
  61. double btoTOTAL[5];
  62. double ctoTOTAL[5];
  63. double dtoTOTAL[5];
  64. double etoTOTAL[5];
  65. double ftoTOTAL[5];
  66.  
  67.  
  68. bool training_mode = false;
  69.  
  70. double train_input[100][nr_neurons_A];
  71. double train_output[100][nr_neurons_G];
  72. double requested1[nr_neurons_A];
  73.  
  74. double gDD_times, fDD_times, eDD_times, dDD_times, cDD_times, bDD_times;
  75. double avgtot, aw, bw, cw, dw, ew, fw, gw;
  76. double tussen, row_0, row_1, row_2, row_3;
  77.  
  78. struct MiddleNode {
  79.  
  80.  std::vector<double> w = std::vector<double>(256, 0.00);
  81.  std::vector<double> o = std::vector<double>(256, 0.00);
  82.  std::vector<double> bw = std::vector<double>(256, 0.00);
  83.  std::vector<double> b = std::vector<double>(256, 0.00);
  84.  
  85. };
  86.  
  87. struct InputNode {
  88.  
  89.  std::vector<double> w = std::vector<double>(256, 0.00);
  90.  std::vector<double> o = std::vector<double>(256, 0.00);
  91.  std::vector<double> bw = std::vector<double>(256, 0.00);
  92.  std::vector<double> b = std::vector<double>(256, 0.00);
  93.  
  94. };
  95.  
  96. struct OutputNode {
  97.  
  98.  std::vector<double> w = std::vector<double>(256, 0.00);
  99.  std::vector<double> o = std::vector<double>(256, 0.00);
  100.  std::vector<double> bw = std::vector<double>(256, 0.00);
  101.  std::vector<double> b = std::vector<double>(256, 0.00);
  102.  
  103. };
  104.  
  105. double choose(int x, int aa) {
  106.  
  107.   if (training_mode) return train_input[x][aa];
  108.   else return requested1[aa];
  109.  
  110. }
  111.  
  112.  
  113. double initialize() {
  114.  
  115.     pseudorandteller++;  printf("\naa %lf", pseudorandteller); //fake pseudo init, for testing only
  116.     return 0.00123456789 * pseudorandteller;
  117.  
  118.  
  119.   //return ((rand()%10000)/10000.00) + 0.01;
  120.  
  121. }
  122.  
  123. double fd(double x) {
  124.  
  125.   return (x >= 0) ? (1) : (0);
  126.  
  127. }
  128.  
  129. double fx(double x) {
  130.  
  131.   return (x >= 0) ? (x) : (0);
  132.  
  133. }
  134.  
  135. double undetail(double number, double option)
  136. {
  137.     double hevel,f0,f1,f2,f3,f4,f5,f6,f7,f8,f9,f10;
  138.     double number_copy = number;
  139.     double outt;
  140.  
  141.         //return number; //DISABLE THIS FUNCTION
  142.  
  143.  
  144.    f0 = floor(number_copy);
  145.  
  146.  
  147.  
  148.       if (option) {
  149.  
  150.  
  151.     f1 = floor(number_copy / 0.1);
  152.     // printf("\n\nhet aantal tienden %f", f1);
  153.      number_copy = number_copy - 0.1 * f1;
  154.            }
  155.  
  156.            if (option>1) {
  157.  
  158.  
  159.  
  160.     f2 = floor(number_copy / 0.01);
  161.      //printf("\n\nhet aantal honderdsten %f", f2);
  162.      number_copy = number_copy - 0.01 * f2;
  163.             }
  164.  
  165.  
  166.  
  167.  
  168.                        if (option>2) {
  169.  
  170.  
  171.  
  172.     f3 = floor(number_copy / 0.001);
  173.      //printf("\n\nhet aantal honderdsten %f", f2);
  174.      number_copy = number_copy - 0.001 * f3;
  175.             }
  176.  
  177.  
  178.  
  179.      outt = f0;
  180.  
  181.  
  182.  
  183.      if (f1 && option)    {
  184.                     f1 = f1 / 10.00;
  185.                     outt = outt + f1;
  186.                 }
  187.  
  188.  
  189.      if (f2 && option==2)  {
  190.                       outt = outt + f2/100.00;
  191.  
  192.                 }
  193.  
  194.  
  195.      if (f3)  {
  196.                 outt = outt + f3/1000.00;
  197.                 }
  198.  
  199.  
  200.  
  201.              return outt; //else return number;
  202.  
  203.  
  204. }
  205.  
  206.  
  207. int _tmain(int argc, _TCHAR * argv[]) {
  208.  
  209.   srand (time(NULL));
  210.  
  211.   std::random_device rd;
  212.   std::mt19937 gh(rd());
  213.  
  214.   learn = learn / tota;
  215.  
  216.  
  217.   InputNode a[nr_neurons_A];
  218.   MiddleNode b[nr_neurons_B];
  219.   MiddleNode c[nr_neurons_C];
  220.   MiddleNode d[nr_neurons_D];
  221.   MiddleNode e[nr_neurons_E];
  222.   MiddleNode f[nr_neurons_F];
  223.   OutputNode g[nr_neurons_G];
  224.  
  225.   for (i = 0; i < zrows; i++) {
  226.  
  227.     for (j = 0; j < nr_neurons_A; j++) {
  228.  
  229.       train_input[i][j] = (i + 1.00) / (j + 1);
  230.       train_output[i][j] = 2.33 * pow(train_input[i][j],1.22);
  231.  
  232.     }
  233.  
  234.   }
  235.  
  236.   for (j = 0; j < nr_neurons_A; j++) {
  237.  
  238.     requested1[j] = 1.50 / (j + 1.00);
  239.  
  240.   }
  241.  
  242.   double input = 0;
  243.  
  244.   int i1, i2;
  245.  
  246.   for (i1 = 0; i1 < nr_neurons_A; i1++)
  247.     for (i2 = 0; i2 < nr_neurons_B; i2++) {
  248.       a[i1].w[i2] = initialize();
  249.       a[i1].bw[i2] = initialize();
  250.       a[i1].b[i2] = initialize();
  251.     }
  252.  
  253.   for (i1 = 0; i1 < nr_neurons_B; i1++)
  254.     for (i2 = 0; i2 < nr_neurons_C; i2++) {
  255.       b[i1].w[i2] = initialize();
  256.       b[i1].bw[i2] = initialize();
  257.       b[i1].b[i2] = initialize();
  258.     }
  259.  
  260.   for (i1 = 0; i1 < nr_neurons_C; i1++)
  261.     for (i2 = 0; i2 < nr_neurons_D; i2++) {
  262.       c[i1].w[i2] = initialize();
  263.       c[i1].bw[i2] = initialize();
  264.       c[i1].b[i2] = initialize();
  265.     }
  266.  
  267.   for (i1 = 0; i1 < nr_neurons_D; i1++)
  268.     for (i2 = 0; i2 < nr_neurons_E; i2++) {
  269.       d[i1].w[i2] = initialize();
  270.       d[i1].bw[i2] = initialize();
  271.       d[i1].b[i2] = initialize();
  272.     }
  273.  
  274.   for (i1 = 0; i1 < nr_neurons_E; i1++)
  275.     for (i2 = 0; i2 < nr_neurons_F; i2++) {
  276.       e[i1].w[i2] = initialize();
  277.       e[i1].bw[i2] = initialize();
  278.       e[i1].b[i2] = initialize();
  279.     }
  280.  
  281.   for (i1 = 0; i1 < nr_neurons_F; i1++)
  282.     for (i2 = 0; i2 < nr_neurons_G; i2++) {
  283.       f[i1].w[i2] = initialize();
  284.       f[i1].bw[i2] = initialize();
  285.       f[i1].b[i2] = initialize();
  286.     }
  287.  
  288.   for (i1 = 0; i1 < nr_neurons_G; i1++) {
  289.     g[i1].w[0] = initialize();
  290.     g[i1].bw[0] = initialize();
  291.     g[i1].b[0] = initialize();
  292.   }
  293.  
  294.   sqcalc = 99999999.99;
  295.   for (temp = 0; temp < loops; temp++) {
  296.  
  297.  
  298.             std::fill(btoTOTAL, btoTOTAL+5, 0);
  299.             std::fill(ctoTOTAL, ctoTOTAL+5, 0);
  300.             std::fill(dtoTOTAL, dtoTOTAL+5, 0);
  301.             std::fill(etoTOTAL, etoTOTAL+5, 0);
  302.             std::fill(ftoTOTAL, ftoTOTAL+5, 0);
  303.  
  304.             std::fill(ato, ato+5, 0);
  305.        
  306.     int rowsteller;
  307.     //for (rows = 0; rows < zrows+1; rows++)
  308.     rowsteller++; {
  309.         rows = rowsteller % (zrows + 1);
  310.       shuffled = rows;
  311.  
  312.       if (shuffled == zrows) training_mode = false;
  313.       else training_mode = true;;
  314.  
  315.  
  316.  
  317.  
  318.       for (C = 0; C < nr_neurons_C; C++) {
  319.  
  320.         for (B = 0; B < nr_neurons_B; B++) {
  321.           TOTAL = 0;
  322.           for (A = 0; A < nr_neurons_A; A++) {
  323.  
  324.             if (C == 0) {
  325.               a[A].o[B] = fx(choose(shuffled, A) * a[A].w[B] /*+ a[A].bw[B] * a[A].b[B]*/ );
  326.               ato[B] += a[A].o[B];
  327.  
  328.              }
  329.  
  330.             TOTAL += a[A].o[B] * b[B].w[C];
  331.             btoTOTAL[C] += a[A].o[B] * b[B].w[C];
  332.           }
  333.  
  334.           b[B].o[C] = fx(btoTOTAL[C] /*+ b[B].bw[C] * b[B].b[C]*/ );
  335.  
  336.  
  337.         }
  338.  
  339.       }
  340.  
  341.  
  342.  
  343.       for (E = 0; E < nr_neurons_E; E++) {
  344.         for (D = 0; D < nr_neurons_D; D++) {
  345.  
  346.           for (C = 0; C < nr_neurons_C; C++) {
  347.  
  348.             if (E == 0) {
  349.  
  350.  
  351.               for (B = 0; B < nr_neurons_B; B++) {
  352.                 ctoTOTAL[D] += b[B].o[C] * c[C].w[D];
  353.               }
  354.  
  355.               c[C].o[D] = undetail(fx(ctoTOTAL[D] /*+ c[C].bw[D] * c[C].b[D]*/ ),0);
  356.  
  357.  
  358.  
  359.             }
  360.  
  361.  
  362.             dtoTOTAL[E] += c[C].o[D] * d[D].w[E];
  363.           }
  364.  
  365.           d[D].o[E] = undetail(fx(dtoTOTAL[E] /*+ d[D].bw[E] * d[D].b[E]*/ ),0);
  366.           dto[E] += d[D].o[E];
  367.  
  368.         }
  369.  
  370.       }
  371.  
  372.  
  373.       for (F = 0; F < nr_neurons_F; F++) {
  374.         for (E = 0; E < nr_neurons_E; E++) {
  375.  
  376.           for (D = 0; D < nr_neurons_D; D++) {
  377.  
  378.             etoTOTAL[F] += d[D].o[E] * e[E].w[F];
  379.           }
  380.           e[E].o[F] = undetail(fx(etoTOTAL[F]/*+ e[E].bw[F] * e[E].b[F]*/ ),0); //hier undetail ?
  381.           eto[F] += e[E].o[F];
  382.  
  383.  
  384.         }
  385.  
  386.       }
  387.  
  388.  
  389.       for (G = 0; G < nr_neurons_G; G++) {
  390.         for (F = 0; F < nr_neurons_F; F++) {
  391.  
  392.           for (E = 0; E < nr_neurons_E; E++) {
  393.  
  394.             ftoTOTAL[G] += e[E].o[F] * f[F].w[G];
  395.           }
  396.  
  397.           f[F].o[G] = undetail(fx(ftoTOTAL[G] /*+ f[F].bw[G] * f[F].b[G]*/),0 );
  398.           fto[G] += f[F].o[G];
  399.  
  400.  
  401.         }
  402.  
  403.       }
  404.  
  405.       for (G = 0; G < nr_neurons_G; G++) {
  406.        TOTAL = 0;
  407.         for (F = 0; F < nr_neurons_F; F++) {
  408.           TOTAL += f[F].o[G] * g[G].w[0];
  409.         }
  410.  
  411.         g[G].o[0] = undetail(fx(TOTAL /*+ g[G].bw[0] * g[G].b[0]*/ ),0);
  412.  
  413.       }
  414.  
  415.       if (temp > showtime) {
  416.  
  417.         if (training_mode) {
  418.           printf("\n-");
  419.           for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  420.  
  421.             diff += abs(g[showoutputs].o[0] - train_output[shuffled][showoutputs]);
  422.             printf("\n input: %.2lf The current output_%d for training set[%d] is %.28lf of (%lf),, diff:%lf", train_input[shuffled][showoutputs], showoutputs, shuffled, g[showoutputs].o[0], train_output[shuffled][showoutputs], diff);
  423.  
  424.           }
  425.         } else {
  426.  
  427.           for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  428.  
  429.             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) );
  430.  
  431.           }
  432.  
  433.         }
  434.  
  435.       }
  436.  
  437.  
  438.  
  439.  
  440.  
  441.  
  442.       xerrtotal = 0;
  443.       if (training_mode) {
  444.         for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  445.           xerr[showoutputs] = 2 * (g[showoutputs].o[0] - train_output[shuffled][showoutputs]);
  446.  
  447.           xerrtotal += (xerr[showoutputs]);
  448.         }
  449.  
  450.  sqerrtot = xerrtotal;
  451.  
  452.  
  453.  
  454.         xDD = learn * xerrtotal;
  455.         gDD_times = xDD;
  456.         avgtot = 0; aw = 0; bw = 0; cw = 0; dw = 0; ew = 0; fw = 0; gw = 0;
  457.  
  458.  
  459.  
  460.  
  461.  
  462.  
  463.              for (G = 0; G < nr_neurons_G; G++) gDD_times += g[G].w[0];
  464.         gDD_times *= xDD;
  465.  
  466.         /*
  467.         for (G = 0; G < nr_neurons_G; G++) { for (F = 0; F < nr_neurons_F; F++) fDD_times += f[F].w[G]; }
  468.         fDD_times *= gDD_times;
  469.  
  470.         for (F = 0; F < nr_neurons_F; F++) { for (E = 0; E < nr_neurons_E; E++) eDD_times += e[E].w[F]; }
  471.         eDD_times *= fDD_times;
  472.  
  473.         for (E = 0; E < nr_neurons_E; E++) { for (D = 0; D < nr_neurons_D; D++) dDD_times += d[D].w[E]; }
  474.         dDD_times *= eDD_times;
  475.  
  476.         for (D = 0; D < nr_neurons_D; D++) { for (C = 0; C < nr_neurons_C; C++) cDD_times += c[C].w[D]; }
  477.         cDD_times *= dDD_times;
  478.  
  479.         for (C = 0; C < nr_neurons_C; C++) { for (B = 0; B < nr_neurons_B; B++) bDD_times += b[B].w[C]; }
  480.         bDD_times *= cDD_times;
  481.         */
  482.         for (G = 0; G < nr_neurons_G; G++) gDD_times *= g[G].w[0];
  483.         fDD_times = gDD_times;
  484.         for (G = 0; G < nr_neurons_G; G++) { for (F = 0; F < nr_neurons_F; F++) fDD_times *= f[F].w[G]; }
  485.         eDD_times =  fDD_times;
  486.         for (F = 0; F < nr_neurons_F; F++) { for (E = 0; E < nr_neurons_E; E++) eDD_times *= e[E].w[F]; }
  487.         dDD_times = eDD_times;
  488.         for (E = 0; E < nr_neurons_E; E++) { for (D = 0; D < nr_neurons_D; D++) dDD_times *= d[D].w[E]; }
  489.         cDD_times = dDD_times;
  490.         for (D = 0; D < nr_neurons_D; D++) { for (C = 0; C < nr_neurons_C; C++) cDD_times *= c[C].w[D]; }
  491.         bDD_times = cDD_times;
  492.         for (C = 0; C < nr_neurons_C; C++) { for (B = 0; B < nr_neurons_B; B++) bDD_times *= b[B].w[C]; }
  493.  
  494.  
  495.         for (G = 0; G < nr_neurons_G; G++) {
  496.  
  497.           zDD_wupd = ftoTOTAL[G] * learn * xerr[G];
  498.  
  499.           gDD = xDD * g[G].w[0];
  500.  
  501.           tussen = fd(g[G].o[0]) * zDD_wupd;
  502.            g[G].w[0] -= tussen;
  503.           gw += tussen;
  504.           avgtot += tussen;
  505.           if (G==0) row_0 += tussen;
  506.           if (G==1) row_1 += tussen;
  507.           if (G==2) row_2 += tussen;
  508.           if (G==3) row_3 += tussen;
  509.  
  510.  
  511.  
  512.  
  513.           for (F = 0; F < nr_neurons_F; F++) {
  514.             gDD_wupd = etoTOTAL[F] * gDD;
  515.  
  516.  
  517.             tussen = fd(f[F].o[G]) * gDD_wupd;
  518.              f[F].w[G] -= tussen;
  519.             //f[F].w[G] -= new_avgtot;
  520.             //f[F].w[G] -= new_fw;
  521.             fw += tussen;
  522.             avgtot += tussen;
  523.           if (F==0) row_0 += tussen;
  524.           if (F==1) row_1 += tussen;
  525.           if (F==2) row_2 += tussen;
  526.           if (F==3) row_3 += tussen;
  527.  
  528.             }
  529.         }
  530.  
  531.  
  532.  
  533.  
  534.          for (F = 0; F < nr_neurons_F; F++) {
  535.  
  536.  
  537.             for (E = 0; E < nr_neurons_E; E++) {
  538.               fDD_wupd = dtoTOTAL[E] * fDD_times;
  539.  
  540.  
  541.               tussen = fd(e[E].o[F]) * fDD_wupd;
  542.                e[E].w[F] -= tussen;
  543.               //e[E].w[F] -= new_avgtot;
  544.               //e[E].w[F] -= new_ew;
  545.               ew += tussen;
  546.               avgtot += tussen;
  547.                       if (E==0) row_0 += tussen;
  548.           if (E==1) row_1 += tussen;
  549.           if (E==2) row_2 += tussen;
  550.           if (E==3) row_3 += tussen;
  551.  
  552.               }
  553.          }
  554.  
  555.  
  556.  
  557.             for (E = 0; E < nr_neurons_E; E++) {
  558.  
  559.  
  560.               for (D = 0; D < nr_neurons_D; D++) {
  561.                 eDD_wupd = ctoTOTAL[D] * eDD_times;
  562.  
  563.  
  564.  
  565.                 tussen = fd(d[D].o[E]) * eDD_wupd;
  566.                 d[D].w[E] -= tussen;
  567.                 //d[D].w[E] -= new_avgtot;
  568.                 //d[D].w[E] -= new_dw;
  569.                 dw += tussen;
  570.                 avgtot += tussen;
  571.                           if (D==0) row_0 += tussen;
  572.           if (D==1) row_1 += tussen;
  573.           if (D==2) row_2 += tussen;
  574.           if (D==3) row_3 += tussen;
  575.  
  576.                 }
  577.             }
  578.  
  579.  
  580.           for (D = 0; D < nr_neurons_D; D++) {
  581.  
  582.  
  583.                 for (C = 0; C < nr_neurons_C; C++) {
  584.                   dDD_wupd = btoTOTAL[C] * dDD_times;
  585.  
  586.  
  587.                   tussen = fd(c[C].o[D]) * dDD_wupd;
  588.                    c[C].w[D] -= tussen;
  589.                   //c[C].w[D] -= new_avgtot;
  590.                   //c[C].w[D] -= new_cw;
  591.                   cw += tussen;
  592.                   avgtot += tussen;
  593.                           if (C==0) row_0 += tussen;
  594.           if (C==1) row_1 += tussen;
  595.           if (C==2) row_2 += tussen;
  596.           if (C==3) row_3 += tussen;
  597.  
  598.                   }
  599.           }
  600.  
  601.  
  602.            for (C = 0; C < nr_neurons_C; C++) {
  603.  
  604.  
  605.                   for (B = 0; B < nr_neurons_B; B++) {
  606.                     cDD_wupd =  ato[B] * cDD_times;   //was atotal[b]
  607.                     tussen = fd(b[B].o[C]) * cDD_wupd;
  608.                     b[B].w[C] -= tussen;
  609.                     //b[B].w[C] -= new_avgtot;
  610.                     //b[B].w[C] -= new_bw;
  611.                     bw += tussen;
  612.                     avgtot += tussen;
  613.                               if (B==0) row_0 += tussen;
  614.           if (B==1) row_1 += tussen;
  615.           if (B==2) row_2 += tussen;
  616.           if (B==3) row_3 += tussen;
  617.  
  618.                     }
  619.            }
  620.  
  621.  
  622.  
  623.  
  624.             for (B = 0; B < nr_neurons_B; B++) {
  625.  
  626.  
  627.                     for (A = 0; A < nr_neurons_A; A++) {
  628.  
  629.                       tussen = train_input[shuffled][A] * fd(a[A].o[B]) * bDD_times;
  630.                       a[A].w[B] -= tussen;
  631.                       //a[A].w[B] -= new_avgtot;
  632.                       //a[A].w[B] -= new_aw;
  633.                       aw += tussen;
  634.                       avgtot += tussen;
  635.                               if (A==0) row_0 += tussen;
  636.           if (A==1) row_1 += tussen;
  637.           if (A==2) row_2 += tussen;
  638.           if (A==3) row_3 += tussen;
  639.  
  640.                       }
  641.             }
  642.  
  643.  
  644.        //printf("\ntijdelijk %d",tijdelijk);
  645.  
  646.        avgtot = avgtot / 96;
  647.  
  648.        aw = aw / (nr_neurons_A*4);
  649.        bw = bw / (nr_neurons_B*4);
  650.        cw = cw / (nr_neurons_C*4);
  651.        dw = dw / (nr_neurons_D*4);
  652.        ew = ew / (nr_neurons_E*4);
  653.        fw = fw / (nr_neurons_F*4);
  654.        gw = gw / (nr_neurons_G);
  655.  
  656.         row_0 = row_0 / 25;
  657.         row_1 = row_1 / 25;
  658.         row_2 = row_2 / 25;
  659.         row_3 = row_3 / 25;
  660.  
  661.              double tempi = 0.1;
  662.  
  663.  
  664.              for (G = 0; G < nr_neurons_G; G++) {
  665.  
  666.                   g[G].w[0] -= avgtot;    //average change for all nodes
  667.                   g[G].w[0] -= gw;        //average change for this 'block'
  668.                           if (G==0) g[G].w[0] -= row_0;
  669.                             if (G==1) g[G].w[0] -= row_1;
  670.                                 if (G==2) g[G].w[0] -= row_2;
  671.                                    if (G==3) g[G].w[0] -= row_3;
  672.                                   if (g[G].w[0]>tempi) g[G].w[0] = undetail(g[G].w[0],2);
  673.  
  674.  
  675.           for (F = 0; F < nr_neurons_F; F++) {
  676.  
  677.             f[F].w[G] -= avgtot;
  678.             f[F].w[G] -= fw;
  679.              if (F==0) f[F].w[G] -= row_0;
  680.              if (F==1) f[F].w[G] -= row_1;
  681.              if (F==2) f[F].w[G] -= row_2;
  682.              if (F==3) f[F].w[G] -= row_3;
  683.               //if (f[F].w[G]>tempi) f[F].w[G] = undetail(f[F].w[G],3);
  684.  
  685.  
  686.             }
  687.         }
  688.  
  689.  
  690.  
  691.  
  692.          for (F = 0; F < nr_neurons_F; F++) {
  693.  
  694.  
  695.             for (E = 0; E < nr_neurons_E; E++) {
  696.  
  697.               e[E].w[F] -= avgtot;
  698.               e[E].w[F] -= ew;
  699.  
  700.              if (E==0) e[E].w[F] -= row_0;
  701.              if (E==1) e[E].w[F] -= row_1;
  702.             if (E==2) e[E].w[F] -= row_2;
  703.              if (E==3) e[E].w[F] -= row_3;
  704.                //e[E].w[F] = undetail(e[E].w[F]);
  705.               //if (e[E].w[F]>tempi) e[E].w[F] = undetail(e[E].w[F],0);   //0.5
  706.               }
  707.          }
  708.  
  709.  
  710.  
  711.             for (E = 0; E < nr_neurons_E; E++) {
  712.  
  713.  
  714.               for (D = 0; D < nr_neurons_D; D++) {
  715.  
  716.                d[D].w[E] -= avgtot;
  717.                 d[D].w[E] -= dw;
  718.  
  719.              if (D==0) d[D].w[E] -= row_0;
  720.              if (D==1) d[D].w[E] -= row_1;
  721.              if (D==2) d[D].w[E] -= row_2;
  722.              if (D==3) d[D].w[E] -= row_3;
  723.                 // d[D].w[E] = undetail(d[D].w[E]);
  724.               //if (d[D].w[E]>tempi) d[D].w[E] = undetail(d[D].w[E],3);
  725.                 }
  726.             }
  727.  
  728.  
  729.           for (D = 0; D < nr_neurons_D; D++) {
  730.  
  731.  
  732.                 for (C = 0; C < nr_neurons_C; C++) {
  733.  
  734.                   c[C].w[D] -= avgtot;
  735.                   c[C].w[D] -= cw;
  736.  
  737.              if (C==0) c[C].w[D] -= row_0;
  738.              if (C==1) c[C].w[D] -= row_1;
  739.              if (C==2) c[C].w[D] -= row_2;
  740.              if (C==3) c[C].w[D] -= row_3;
  741.                  // c[C].w[D] = undetail(c[C].w[D]);
  742.              //  if (c[C].w[D]>3.0) c[C].w[D] = undetail(c[C].w[D],0);
  743.                   }
  744.           }
  745.  
  746.  
  747.            for (C = 0; C < nr_neurons_C; C++) {
  748.  
  749.  
  750.                   for (B = 0; B < nr_neurons_B; B++) {
  751.  
  752.                     b[B].w[C] -= avgtot;
  753.                     b[B].w[C] -= bw;
  754.  
  755.              if (B==0) b[B].w[C] -= row_0;
  756.              if (B==1) b[B].w[C] -= row_1;
  757.             if (B==2) b[B].w[C] -= row_2;
  758.             if (B==3) b[B].w[C] -= row_3;
  759.                    //    b[B].w[C]  = undetail(b[B].w[C]);
  760.                    //if (b[B].w[C]>tempi) b[B].w[C] = undetail(b[B].w[C],1);
  761.                     }
  762.            }
  763.  
  764.  
  765.  
  766.  
  767.             for (B = 0; B < nr_neurons_B; B++) {
  768.  
  769.  
  770.                     for (A = 0; A < nr_neurons_A; A++) {
  771.  
  772.  
  773.                       a[A].w[B] -= avgtot;
  774.                       a[A].w[B] -= aw;
  775.  
  776.             if (A==0) a[A].w[B] -= row_0;
  777.             if (A==1) a[A].w[B] -= row_1;
  778.             if (A==2) a[A].w[B] -= row_2;
  779.             if (A==3) a[A].w[B] -= row_3;
  780.                     //  a[A].w[B] = undetail(a[A].w[B]);
  781.                     if (a[A].w[B]>tempi) a[A].w[B] = undetail(a[A].w[B],0);
  782.                       }
  783.             }
  784.  
  785.  
  786.  
  787.  
  788.  
  789.  
  790.  
  791.  
  792.  
  793.  
  794.  
  795.       }
  796.  
  797.  
  798.     }
  799.  
  800.  
  801.  
  802.     if (!(temp % (showtime/100))) printf("\n %d %%",++Z);
  803.  
  804.     sqcalc += sqerrtot;
  805.  
  806.     if (temp % 1000 == 0) {
  807.       gemiddelde = sqcalc / 1000;
  808.       sqcalc = 0;
  809.     }
  810.  
  811.     sqerrtot = 0;
  812.  
  813.   }
  814.  
  815.   printf("\nEnd.");
  816.   scanf("%d", &Z);
  817.  
  818.   return 0;
  819.  
  820. }
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!