Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Programma rimane fermo-non so capire che problema sia
Forum - C/C++ - Programma rimane fermo-non so capire che problema sia

Avatar
web_pirate (Normal User)
Rookie


Messaggi: 51
Iscritto: 27/12/2011

Segnala al moderatore
Postato alle 14:14
Lunedì, 09/07/2012
Salve a tutti. Ecco il codice che mi sta facendo uscire pazzo.
Se lo eseguo così per com'è scritto di seguito, tutto funziona. Ma se elimino il printf alla linea 90 il programma arriva ad un certo punto e poi si ferma e devo chiuderlo dal task manager. Non ci capisco niente.

Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5.  
  6. #define SET_FILE "training_set.txt"
  7.  
  8. //Numero elementi
  9. int N_IN=2;
  10. int N_H=2;
  11. int N_O=1;
  12. int N_ES=4;
  13. int EPOCH;
  14.  
  15. //Elementi
  16. float *neur_in;
  17. float *w_in_hid;
  18. float *neur_hid;
  19. float *w_hid_out;
  20. float *neur_out;
  21. float var_w;
  22.  
  23. //Esempi
  24. float *es_in;
  25. float *es_out;
  26.  
  27. float sig(float x){
  28.         return 1/(1+pow(M_E,-x));
  29. }
  30.  
  31. void alloca_obj(){
  32.         neur_in=malloc(N_IN*sizeof(float));
  33.         w_in_hid=malloc(N_IN*N_H*sizeof(float));
  34.         neur_hid=malloc(N_IN*sizeof(float));
  35.         w_hid_out=malloc(N_IN*N_O*sizeof(float));
  36.         neur_out=malloc(N_IN*sizeof(float));
  37.         es_in=malloc(N_ES*N_IN*sizeof(float));
  38.         es_out=malloc(N_ES*N_O*sizeof(float));
  39. }
  40.  
  41. void att_to_zero(){
  42. int i;
  43.  
  44.         for(i=0;i<N_H;i++){
  45.                 neur_hid[i]=0;
  46.                 }
  47.         for(i=0;i<N_O;i++){
  48.                 neur_out[i]=0;
  49.                 }
  50. }
  51.  
  52. void output(){
  53. int i, j;
  54.        
  55.         att_to_zero();
  56.        
  57.         for(i=0;i<N_IN;i++){
  58.                 for(j=0;j<N_H;j++){
  59.                         neur_hid[j]+=neur_in[i]*w_in_hid[N_H*i+j];
  60.                 }
  61.         }
  62.        
  63.         for(i=0;i<N_H;i++){
  64.                 for(j=0;j<N_O;j++){
  65.                         neur_out[j]+=neur_hid[i]*w_hid_out[N_O*i+j];
  66.                 }
  67.         }
  68. }
  69.  
  70. void w_rand(){
  71. int i;
  72.         for(i=0;i<N_IN*N_H;i++){
  73.                 w_in_hid[i]=1;
  74.         }
  75.         for(i=0;i<N_H*N_O;i++){
  76.                 w_hid_out[i]=1;
  77.         }
  78. }
  79.  
  80. void read_training_set(FILE *fp){
  81. int i, j;
  82.  
  83.         for(i=0;i<N_ES;i++){
  84.                 for(j=0;j<N_IN;j++){
  85.                         fscanf(fp, "%f\t", &es_in[N_IN*i+j]);
  86.                         printf("\n%f", es_in[N_IN*i+j]);
  87.                 }
  88.                 for(j=0;j<N_O;j++){
  89.                         fscanf(fp, "%f\t", &es_out[N_IN*i+j]);
  90.                         printf("\n%f", es_out[N_IN*i+j]);
  91.                 }
  92.         }
  93. }
  94.  
  95. void clean(){
  96. int i;
  97.         for(i=0;i<N_IN;i++){
  98.                 neur_in[i]=0;
  99.         }
  100. }
  101.  
  102. void training(){
  103. int i, j;
  104.  
  105.         for(i=0;i<N_ES;i++){
  106.                 clean();
  107.                 for(j=0;j<N_IN;j++){
  108.                         neur_in[j]=es_in[N_IN*i+j];
  109.                         printf("\n%f", neur_in[j]);
  110.                 }
  111.         }
  112. }
  113.  
  114. int main(){
  115. int i, j;
  116. FILE *fp;
  117.  
  118. printf("Epoche: ");
  119. scanf("%d", &EPOCH);
  120. printf("\n");
  121.  
  122. fp=fopen(SET_FILE, "r");
  123.  
  124.         alloca_obj();
  125.        
  126.         read_training_set(fp);
  127.        
  128.         fclose(fp);
  129.        
  130.         w_rand();
  131.        
  132.         training();
  133.        
  134.         output();
  135.        
  136. return 0;
  137. }



il file training_set.txt è questo:

Codice sorgente - presumibilmente Plain Text

  1. 1       2
  2. 3
  3. 4       5
  4. 9
  5. 12      1
  6. 13
  7. 9       83
  8. 92


Ultima modifica effettuata da web_pirate il 09/07/2012 alle 14:17
PM Quote
Avatar
pnb2frank (Member)
Newbie


Messaggi: 1
Iscritto: 22/04/2012

Segnala al moderatore
Postato alle 12:15
Giovedì, 12/07/2012
anche tu con le reti neurali eh :k:
da me il tuo programma viene eseguito normalmente anche cancellando il printf alla riga 90.. :-?:-?:-?

PM Quote
Avatar
web_pirate (Normal User)
Rookie


Messaggi: 51
Iscritto: 27/12/2011

Segnala al moderatore
Postato alle 1:20
Sabato, 21/07/2012
Si ho risolto. Ma ancora adesso non ho capito qual'era il problema.. XD
Comunque adesso il problema è un altro, e non meno curioso. Ecco il nuovo codice che adesso mi da problemi:
Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5.  
  6. #define SET_FILE "training_set.txt"
  7.  
  8. //Numero elementi
  9. int N_IN;
  10. int N_H;
  11. int N_O;
  12. int N_ES=2;
  13. int EPOCH;
  14.  
  15. //Elementi
  16. float *neur_in;
  17. float *w_in_hid;
  18. float *neur_hid;
  19. float *w_hid_out;
  20. float *neur_out;
  21. float *err_out;
  22. float *err_hid;
  23. float *delta_out;
  24. float *delta_hid;
  25. float var_w;
  26. float rate;
  27. float bias_hid=0.5, bias_out=0.5;
  28. float max=0;
  29.  
  30. //Esempi
  31. float *es_in;
  32. float *es_out;
  33.  
  34. float sig(float x){
  35.         return 1/(1+pow(M_E,-x));
  36. }
  37.  
  38. void alloca_obj(){
  39.         neur_in=malloc(N_IN*sizeof(float));
  40.         w_in_hid=malloc(N_IN*N_H*sizeof(float));
  41.         neur_hid=malloc(N_IN*sizeof(float));
  42.         w_hid_out=malloc(N_IN*N_O*sizeof(float));
  43.         neur_out=malloc(N_IN*sizeof(float));
  44.         es_in=malloc(N_ES*N_IN*sizeof(float));
  45.         es_out=malloc(N_ES*N_O*sizeof(float));
  46.         err_out=malloc(N_O*sizeof(float));
  47.         err_hid=malloc(N_H*sizeof(float));
  48.         delta_out=malloc(N_O*sizeof(float));
  49.         delta_hid=malloc(N_H*sizeof(float));
  50. }
  51.  
  52. void max_in(){
  53. int i;
  54.         for(i=0;i<N_ES*N_IN;i++){
  55.                 if(es_in[i]>max){
  56.                         max=es_in[i];
  57.                 }
  58.         }
  59.         for(i=0;i<N_ES*N_O;i++){
  60.                 if(es_out[i]>max){
  61.                         max=es_out[i];
  62.                 }
  63.         }
  64. }
  65.  
  66. void att_to_zero(){
  67. int i;
  68.  
  69.         for(i=0;i<N_H;i++){
  70.                 neur_hid[i]=0;
  71.                 }
  72.         for(i=0;i<N_O;i++){
  73.                 neur_out[i]=0;
  74.                 }
  75. }
  76.  
  77. void output(){
  78. int i, j;
  79.        
  80.         att_to_zero();
  81.        
  82.         for(i=0;i<N_IN;i++){
  83.                 for(j=0;j<N_H;j++){
  84.                         neur_hid[j]+=neur_in[i]*w_in_hid[N_H*i+j]+bias_hid;
  85.                 }
  86.         }
  87.         for(i=0;i<N_H;i++){
  88.                 neur_hid[i]=sig(neur_hid[i]);
  89.         }
  90.        
  91.         for(i=0;i<N_H;i++){
  92.                 for(j=0;j<N_O;j++){
  93.                         neur_out[j]+=neur_hid[i]*w_hid_out[N_O*i+j]+bias_out;
  94.                 }
  95.         }
  96.         for(i=0;i<N_O;i++){
  97.                 neur_out[i]=sig(neur_out[i]);
  98.         }
  99. }
  100.  
  101. void w_rand(){
  102. int i;
  103.         for(i=0;i<N_IN*N_H;i++){
  104.                 w_in_hid[i]=0.5;
  105.         }
  106.         for(i=0;i<N_H*N_O;i++){
  107.                 w_hid_out[i]=0.5;
  108.         }
  109. }
  110.  
  111. void read_training_set(FILE *fp){
  112. int i, j;
  113. char ch;
  114.         for(i=0;i<N_ES;i++){
  115.                 for(j=0;j<N_IN;j++){
  116.                         fscanf(fp, "%f\t", &es_in[N_IN*i+j]);
  117.                 }
  118.                 for(j=0;j<N_O;j++){
  119.                         fscanf(fp, "%f\t", &es_out[N_O*i+j]);
  120.                 }
  121.         }
  122. }
  123.  
  124. void training(){
  125. int i, j, y, ep;
  126.         for(ep=0;ep<EPOCH;ep++){
  127.                 printf("\nEPOCA N.%d _____________________________________________________\n", ep+1);
  128.                 for(i=0;i<N_ES;i++){
  129.                         for(j=0;j<N_IN;j++){
  130.                                 neur_in[j]=es_in[N_IN*i+j]/max;
  131.                         }
  132.                
  133.                         output();
  134.                        
  135.                         for(j=0;j<N_IN;j++){
  136.                                 neur_in[j]=es_in[N_IN*i+j]*max;
  137.                         }
  138.                        
  139.                         for(j=0;j<N_O;j++){
  140.                                 err_out[j]=es_out[N_O*i+j]-neur_out[j]*max;
  141.                         }
  142.                        
  143.                         for(y=0;y<N_O;y++){
  144.                                 delta_out[y]=err_out[y]*(neur_out[y]*(1-neur_out[y]));
  145.                         }
  146.                        
  147.                         for(j=0;j<N_H;j++){
  148.                                 err_hid[j]=0;
  149.                                 for(y=0;y<N_O;y++){
  150.                                         err_hid[j]+=delta_out[y]*w_hid_out[N_O*j+y];
  151.                                 }
  152.                         }
  153.                         for(j=0;j<N_H;j++){
  154.                                 delta_hid[j]=err_hid[j]*(neur_hid[j]*(1-neur_hid[j]));
  155.                         }
  156.                        
  157.                         for(j=0;j<N_H;j++){
  158.                                 for(y=0;y<N_O;y++){
  159.                                         w_hid_out[N_O*j+y]+=rate*delta_out[y]*neur_hid[j];
  160.                                         bias_out+=rate*delta_out[y];
  161.                                 }
  162.                         }
  163.                         for(j=0;j<N_IN;j++){
  164.                                 for(y=0;y<N_H;y++){
  165.                                         w_in_hid[N_H*j+y]+=rate*delta_hid[y]*neur_in[j];
  166.                                         bias_hid+=rate*delta_hid[y];
  167.                                 }
  168.                         }
  169.                        
  170.                         printf("\n-------------------\n");
  171.                         for(y=0;y<N_O;y++){
  172.                                 printf("%f      ->      ", neur_out[y]*max);
  173.                                 printf("%f      ", es_out[N_O*i+y]);
  174.                         }
  175.                         printf("\n-------------------\n");
  176.                         for(j=0;j<N_O;j++){
  177.                                 printf("Errore: %f\n", err_out[j]);
  178.                         }
  179.                 }
  180.         }
  181. }
  182.  
  183. int main(){
  184. int i, j;
  185. FILE *fp;
  186.  
  187. printf("\nStabilire learning rate: ");
  188. scanf("%f", &rate);
  189.  
  190. //printf("\nNumero esempi: ");
  191. //scanf("%d", &N_ES);
  192.  
  193. printf("\nNeuroni in strato di input - in riferimento al file training_set.txt -: ");
  194. scanf("%d", &N_IN);
  195.  
  196. printf("\nNeuroni in strato nascosto: ");
  197. scanf("%d", &N_H);
  198.  
  199. printf("\nNeuroni in strato di output - in riferimento al file training_set.txt -: ");
  200. scanf("%d", &N_O);
  201.  
  202. printf("\nStabilire numero di epoche di apprendimento: ");
  203. scanf("%d", &EPOCH);
  204.  
  205. fp=fopen(SET_FILE, "r");
  206.  
  207.         alloca_obj();
  208.        
  209.         read_training_set(fp);
  210.        
  211.         fclose(fp);
  212.        
  213.         w_rand();
  214.        
  215.         max_in();
  216.        
  217.         training();
  218.        
  219.         printf("\nRete addestrata! Inserire nuovi inputs: \n");
  220.         for(i=0;i<N_IN;i++){
  221.                 printf("Input n.%d: ", i+1);
  222.                 scanf("%f", &neur_in[i]);
  223.                 neur_in[i]/=max;
  224.         }
  225.        
  226.         output();
  227.        
  228.         printf("\n");
  229.         for(i=0;i<N_O;i++){
  230.                 printf("%f      ", neur_out[i]*max);
  231.         }
  232.        
  233. return 0;
  234. }


Allora, il file training_set.txt è sempre strutturato allo stesso modo, ma ora il problema è diverso.
Alla linea 12 c'è la dichiarazione del numero di esempi da sottoporre alla rete. Se il numero è < 3 allora la rete funziona perfettamente, e con un learning rate di 0.1 e 1000 epoche di apprendimento l'errore è < 0.04, ma se la variabile N_ES è > 2 allora tutti i risultati della rete tendono allo stesso numero, circa 100. Non capisco dove possa essere il problema. Gli esempi vengono sottoposti alla rete con dei cicli for(), quindi non capisco per quale motivo con 2 debba funzionare e con più di 2 no.

PM Quote