neat fixes

Author: VivianoRiccardo

src/fully_connected_layers.c

@@ -1614,7 +1614,7 @@ uint64_t get_array_size_params(fcl* f){
  *                 @ flc* f:= the fully-connected layer
  * */
 uint64_t get_array_size_scores_fcl(fcl* f){
-    if(f == NULL || !exists_edge_popup_stuff_fcl(f))
+    if(f == NULL || !exists_edge_popup_stuff_fcl(f) || f->feed_forward_flag == ONLY_DROPOUT)
         return 0;
     return (uint64_t)f->input*f->output;
 }
@@ -1628,7 +1628,7 @@ uint64_t get_array_size_scores_fcl(fcl* f){
  *                 @ flc* f:= the fully-connected layer
  * */
 uint64_t get_array_size_weights(fcl* f){
-    if(f == NULL || !exists_params_fcl(f))
+    if(f == NULL || !exists_params_fcl(f) || f->feed_forward_flag == ONLY_DROPOUT)
         return 0;
     uint64_t sum = 0;
     if(f->normalization_flag == LAYER_NORMALIZATION){
@@ -1665,7 +1665,7 @@ void memcopy_vector_to_params(fcl* f, float* vector){
  *                 @ float* vector:= the vector where is copyed everything
  * */
 void memcopy_vector_to_scores(fcl* f, float* vector){
-    if(f == NULL || vector == NULL || !exists_edge_popup_stuff_fcl(f))
+    if(f == NULL || vector == NULL || !exists_edge_popup_stuff_fcl(f) || f->feed_forward_flag == ONLY_DROPOUT)
         return;
     memcpy(f->scores,vector,f->input*f->output*sizeof(float));
 }
@@ -1698,7 +1698,7 @@ void memcopy_params_to_vector(fcl* f, float* vector){
  *                 @ float* vector:= the vector where is copyed everything
  * */
 void memcopy_weights_to_vector(fcl* f, float* vector){
-    if(f == NULL || !exists_params_fcl(f) || vector == NULL)
+    if(f == NULL || !exists_params_fcl(f) || vector == NULL || f->feed_forward_flag == ONLY_DROPOUT)
         return;
     memcpy(vector,f->weights,f->input*f->output*sizeof(float));
     if(f->normalization_flag == LAYER_NORMALIZATION){
@@ -1716,7 +1716,7 @@ void memcopy_weights_to_vector(fcl* f, float* vector){
  *                 @ float* vector:= the vector where is copyed everything
  * */
 void memcopy_vector_to_weights(fcl* f, float* vector){
-    if(f == NULL || !exists_params_fcl(f) || vector == NULL)
+    if(f == NULL || !exists_params_fcl(f) || vector == NULL || f->feed_forward_flag == ONLY_DROPOUT)
         return;
     memcpy(f->weights,vector,f->input*f->output*sizeof(float));
     if(f->normalization_flag == LAYER_NORMALIZATION){
@@ -1734,7 +1734,7 @@ void memcopy_vector_to_weights(fcl* f, float* vector){
  *                 @ float* vector:= the vector where is copyed everything
  * */
 void memcopy_scores_to_vector(fcl* f, float* vector){
-    if(f == NULL || vector == NULL || !exists_edge_popup_stuff_fcl(f))
+    if(f == NULL || vector == NULL || !exists_edge_popup_stuff_fcl(f) || f->feed_forward_flag == ONLY_DROPOUT)
         return;
     memcpy(vector,f->scores,f->input*f->output*sizeof(float));
 }

src/genome.h

@@ -45,6 +45,7 @@ typedef struct connection{
 typedef struct genome{
     struct node** all_nodes; /*the first nodes are inputs and outputs*/ 
     int number_input,number_output, number_total_nodes,specie_rip;
+    int global_inn_numb_connections, global_inn_numb_nodes;
     float fitness;
 }genome;
 

src/model.c

@@ -1318,7 +1318,7 @@ void ff_fcl_fcl(fcl* f1, fcl* f2){
 }
 
 int ff_fcl_fcl_without_arrays(fcl* f1, fcl* f2){
-    if(f1->output != f2->input){
+    if(f1->output != f2->input || f2->feed_forward_flag == ONLY_DROPOUT){
         return 0;
     }
     return 1;

src/neat.c

@@ -221,7 +221,7 @@ void neat_generation_run(neat* nes){
 
     //save best genome of the generation in a file
     if(nes->k%nes->saving == 0 || nes->k == nes->generations)
-        save_genome(gg[nes->j],nes->global_inn_numb_connections,nes->k+1);
+        save_genome_complete(gg[nes->j],nes->global_inn_numb_connections,nes->global_inn_numb_nodes, nes->k+1);
 
     // if we have reached the number of generations then just end
     if(nes->k == nes->generations)

src/neat_functions.h

@@ -42,7 +42,11 @@ float random_float_number(float a);
 int shuffle_connection_set(connection** m,int n);
 int shuffle_genome_set(genome** m,int n);
 int save_genome(genome* g, int global_inn_numb_connections, int numb);
+int save_genome_complete(genome* g, int global_inn_numb_connections, int global_inn_numb_nodes, int numb);
 genome* load_genome(int global_inn_numb_connections, char* filename);
+genome* load_genome_complete(char* filename);
+int get_global_innovation_number_connections_from_genome(genome* g);
+int get_global_innovation_number_nodes_from_genome(genome* g);
 int round_up(float num);
 char* get_genome_array(genome* g, int global_inn_numb_connections);
 genome* init_genome_from_array(int global_inn_numb_connections, char* g_array);

src/neat_utils.c

@@ -101,6 +101,80 @@ int save_genome(genome* g, int global_inn_numb_connections, int numb){
 
 }
 
+int save_genome_complete(genome* g, int global_inn_numb_connections, int global_inn_numb_nodes, int numb){
+    
+    int i,n;
+    connection** c = get_connections(g,global_inn_numb_connections);
+    n = get_numb_connections(g,global_inn_numb_connections);
+    char string[20];
+    char *s = ".bin";
+    FILE *write_ptr;
+    
+    itoa(numb, string);
+    
+    strcat(string,s);
+    
+    write_ptr = fopen(string,"wb");
+    convert_data(&global_inn_numb_connections,sizeof(int),1);
+    fwrite(&global_inn_numb_connections,sizeof(int),1,write_ptr);
+    convert_data(&global_inn_numb_connections,sizeof(int),1);
+    convert_data(&global_inn_numb_nodes,sizeof(int),1);
+    fwrite(&global_inn_numb_nodes,sizeof(int),1,write_ptr);
+    convert_data(&global_inn_numb_nodes,sizeof(int),1);
+    
+    convert_data(&g->number_input,sizeof(int),1);
+    fwrite(&g->number_input,sizeof(int),1,write_ptr);
+    convert_data(&g->number_input,sizeof(int),1);
+    convert_data(&g->number_output,sizeof(int),1);
+    fwrite(&g->number_output,sizeof(int),1,write_ptr);
+    convert_data(&g->number_output,sizeof(int),1);
+    convert_data(&g->number_total_nodes,sizeof(int),1);
+    fwrite(&g->number_total_nodes,sizeof(int),1,write_ptr);
+    convert_data(&g->number_total_nodes,sizeof(int),1);
+    convert_data(&g->fitness,sizeof(float),1);
+    fwrite(&g->fitness,sizeof(float),1,write_ptr);
+    convert_data(&g->fitness,sizeof(float),1);
+    
+    for(i = 0; i < g->number_total_nodes; i++){
+        convert_data(&g->all_nodes[i]->in_conn_size,sizeof(int),1);
+        fwrite(&g->all_nodes[i]->in_conn_size,sizeof(int),1,write_ptr);
+        convert_data(&g->all_nodes[i]->in_conn_size,sizeof(int),1);
+        convert_data(&g->all_nodes[i]->out_conn_size,sizeof(int),1);
+        fwrite(&g->all_nodes[i]->out_conn_size,sizeof(int),1,write_ptr);
+        convert_data(&g->all_nodes[i]->out_conn_size,sizeof(int),1);
+        convert_data(&g->all_nodes[i]->innovation_number,sizeof(int),1);
+        fwrite(&g->all_nodes[i]->innovation_number,sizeof(int),1,write_ptr);
+        convert_data(&g->all_nodes[i]->innovation_number,sizeof(int),1);
+    }
+    convert_data(&n,sizeof(int),1);
+    fwrite(&n,sizeof(int),1,write_ptr);
+    convert_data(&n,sizeof(int),1);
+    
+    for(i = 0; i < n; i++){
+        convert_data(&c[i]->innovation_number,sizeof(int),1);
+        fwrite(&c[i]->innovation_number,sizeof(int),1,write_ptr);
+        convert_data(&c[i]->innovation_number,sizeof(int),1);
+        convert_data(&c[i]->in_node->innovation_number,sizeof(int),1);
+        fwrite(&c[i]->in_node->innovation_number,sizeof(int),1,write_ptr);
+        convert_data(&c[i]->in_node->innovation_number,sizeof(int),1);
+        convert_data(&c[i]->out_node->innovation_number,sizeof(int),1);
+        fwrite(&c[i]->out_node->innovation_number,sizeof(int),1,write_ptr);
+        convert_data(&c[i]->out_node->innovation_number,sizeof(int),1);
+        convert_data(&c[i]->weight,sizeof(float),1);
+        fwrite(&c[i]->weight,sizeof(float),1,write_ptr);
+        convert_data(&c[i]->weight,sizeof(float),1);
+        convert_data(&c[i]->flag,sizeof(int),1);
+        fwrite(&c[i]->flag,sizeof(int),1,write_ptr);
+        convert_data(&c[i]->flag,sizeof(int),1);
+    }
+    
+    free(c);
+    i = fclose(write_ptr);
+    
+    return i;
+    
+}
+
 char* get_genome_array(genome* g, int global_inn_numb_connections){
     int i,n, sum=0;
     connection** cc = get_connections(g,global_inn_numb_connections);
@@ -396,6 +470,132 @@ genome* load_genome(int global_inn_numb_connections, char* filename){
     return g;
 
 
+}
+
+int get_global_innovation_number_connections_from_genome(genome* g){
+	return g->global_inn_numb_connections;
+}
+int get_global_innovation_number_nodes_from_genome(genome* g){
+	return g->global_inn_numb_nodes;
+}
+
+genome* load_genome_complete(char* filename){
+    int i,j,n,inn,inn2,k;
+    char input[256];
+    FILE *read_ptr = fopen(filename,"r");
+    if(read_ptr == NULL){
+        fprintf(stderr,"Error no such a file\n");
+        exit(1);
+    }
+    
+    int global_inn_numb_connections,global_inn_numb_nodes;
+    k = fread(&global_inn_numb_connections,sizeof(int),1,read_ptr);
+    convert_data(&global_inn_numb_connections,sizeof(int),1);
+    k = fread(&global_inn_numb_nodes,sizeof(int),1,read_ptr);
+    convert_data(&global_inn_numb_nodes,sizeof(int),1);
+    
+    
+    connection** c = (connection**)malloc(sizeof(connection*)*global_inn_numb_connections);
+    for(i = 0; i < global_inn_numb_connections; i++){
+        c[i] = NULL;
+    }
+    genome* g = (genome*)malloc(sizeof(genome));
+    
+    k = fread(&g->number_input,sizeof(int),1,read_ptr);
+    convert_data(&g->number_input,sizeof(int),1);
+    k = fread(&g->number_output,sizeof(int),1,read_ptr);
+    convert_data(&g->number_output,sizeof(int),1);
+    k = fread(&g->number_total_nodes,sizeof(int),1,read_ptr);
+    convert_data(&g->number_total_nodes,sizeof(int),1);
+    k = fread(&g->fitness,sizeof(float),1,read_ptr);
+    convert_data(&g->fitness,sizeof(float),1);
+    g->all_nodes = (node**)malloc(sizeof(node*)*g->number_total_nodes);
+    
+    for(i = 0; i < g->number_total_nodes; i++){
+        g->all_nodes[i] = (node*)malloc(sizeof(node));
+        k = fread(&g->all_nodes[i]->in_conn_size,sizeof(int),1,read_ptr);
+        convert_data(&g->all_nodes[i]->in_conn_size,sizeof(int),1);
+        k = fread(&g->all_nodes[i]->out_conn_size,sizeof(int),1,read_ptr);
+        convert_data(&g->all_nodes[i]->out_conn_size,sizeof(int),1);
+        k = fread(&g->all_nodes[i]->innovation_number,sizeof(int),1,read_ptr);
+        convert_data(&g->all_nodes[i]->innovation_number,sizeof(int),1);
+        g->all_nodes[i]->actual_value = 0;
+        g->all_nodes[i]->stored_value = 0;
+        g->all_nodes[i]->in_connections = (connection**)malloc(sizeof(connection*)*g->all_nodes[i]->in_conn_size);
+        g->all_nodes[i]->out_connections = (connection**)malloc(sizeof(connection*)*g->all_nodes[i]->out_conn_size);
+    }
+    
+    k = fread(&n,sizeof(int),1,read_ptr);
+    convert_data(&n,sizeof(int),1);
+    for(i = 0; i < n; i++){
+        k = fread(&inn,sizeof(int),1,read_ptr);
+        convert_data(&inn,sizeof(int),1);
+        free(c[inn-1]);
+        c[inn-1] = (connection*)malloc(sizeof(connection));
+        c[inn-1]->innovation_number = inn;
+        k = fread(&inn2,sizeof(int),1,read_ptr);
+        convert_data(&inn2,sizeof(int),1);
+        for(j = 0; j < g->number_total_nodes; j++){
+            if(g->all_nodes[j]->innovation_number == inn2){
+                c[inn-1]->in_node = g->all_nodes[j];
+                break;
+            }
+        }
+        k = fread(&inn2,sizeof(int),1,read_ptr);
+        convert_data(&inn2,sizeof(int),1);
+        for(j = 0; j < g->number_total_nodes; j++){
+            if(g->all_nodes[j]->innovation_number == inn2){
+                c[inn-1]->out_node = g->all_nodes[j];
+                break;
+            }
+        }
+        
+        k = fread(&c[inn-1]->weight,sizeof(float),1,read_ptr);
+        convert_data(&c[inn-1]->weight,sizeof(float),1);
+        k = fread(&c[inn-1]->flag,sizeof(int),1,read_ptr);
+        convert_data(&c[inn-1]->flag,sizeof(int),1);
+    }
+    
+    for(i = 0; i < g->number_total_nodes; i++){
+        inn = 0;
+        inn2 = 0;
+        for(j = 0; j < global_inn_numb_connections; j++){
+            if(c[j]!=NULL){
+                if(c[j]->in_node->innovation_number == g->all_nodes[i]->innovation_number){
+                    g->all_nodes[i]->out_connections[inn] = c[j];
+                    inn++;
+                }
+                if(c[j]->out_node->innovation_number == g->all_nodes[i]->innovation_number){
+
+                    g->all_nodes[i]->in_connections[inn2] = c[j];
+                    inn2++;
+                }
+                
+            }
+        }
+            
+        
+    }
+    
+    for(j = 0; j < global_inn_numb_connections; j++){
+        if(c[j] == NULL)
+            free(c[j]);
+    }
+    
+    free(c);
+    
+    i = fclose(read_ptr);
+    
+    
+    if(i == EOF){
+        printf("error closing the file, the process will end\n");
+        exit(1);
+    }
+    g->global_inn_numb_connections = global_inn_numb_connections;
+    g->global_inn_numb_nodes = global_inn_numb_nodes;
+    return g;
+    
+    
 }
 
 float random_float_number(float a){