debug : nan, it's the learning rate too high,s try to find optimum: 0.001

deepQlearn_0/src/deepQlearning/learn_to_drive.c

@@ -2,17 +2,26 @@
 
 char *action_name[8] = {"LEFT", "CENTER", "RIGHT"};
 
-#define THRESHOLD_UP 10
+#define UPPER_THRESHOLD 10
+#define DIVIDER__  1
+#define USE_THRESHOLD 0
 
 float reLU(float x){
-  if(x>THRESHOLD_UP) return THRESHOLD_UP;
+  if(x!=x){// nan
-  if(x>0) return x;
+    printf("nan relu ");
+  }
+#if USE_THRESHOLD
+  if(x>UPPER_THRESHOLD) return UPPER_THRESHOLD;
+#endif
+  if(x>0) return x/DIVIDER__;
   return 0;
 }
 
 float d_reLU(float x){
-  if (x>THRESHOLD_UP) return 0;
+#if USE_THRESHOLD
-  if (x>0) return 1;
+  if (x>UPPER_THRESHOLD) return 0;
+#endif
+  if (x>0) return 1/DIVIDER__;
   return 0;
 }
 
@@ -37,7 +46,16 @@ float id(float x){ return x;}
 
 float constOne(float x){return 1;}
 
-struct networks_qlearning * create_nework_qlearning(
+void tensorProdTHR_TYPE_FLOAT(tensor_TYPE_FLOAT **MM, tensor_TYPE_FLOAT *M0, tensor_TYPE_FLOAT *M1, size_t nbthread){
+  return tensorProd_TYPE_FLOAT(MM,M0,M1);
+}
+
+
+void tensorContractnProdTHR_TYPE_FLOAT(tensor_TYPE_FLOAT **MM, tensor_TYPE_FLOAT *M0, tensor_TYPE_FLOAT *M1, size_t contractionNumber, size_t nbthread) {
+  return tensorContractnProd_TYPE_FLOAT(MM,M0,M1,contractionNumber);
+}
+
+struct networks_qlearning * create_network_qlearning(
   struct config_layers * config,
   bool randomize, float minR, float maxR,  int randomRange,
   size_t nb_prod_thread,
@@ -55,10 +73,13 @@ struct networks_qlearning * create_nework_qlearning(
   copy_weight_in_networks_from_main_to_best(qnets);
 
   setup_all_layers_functions_TYPE_FLOAT(qnets->main_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
+  //setup_all_layers_functions_TYPE_FLOAT(qnets->main_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   setup_all_layers_params_TYPE_FLOAT(qnets->main_net, nb_prod_thread, nb_calc_thread, learning_rate);
   setup_all_layers_functions_TYPE_FLOAT(qnets->target_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
+  //setup_all_layers_functions_TYPE_FLOAT(qnets->target_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   setup_all_layers_params_TYPE_FLOAT(qnets->target_net, nb_prod_thread, nb_calc_thread, learning_rate);
   setup_all_layers_functions_TYPE_FLOAT(qnets->best_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
+  //setup_all_layers_functions_TYPE_FLOAT(qnets->best_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
   setup_all_layers_params_TYPE_FLOAT(qnets->best_net, nb_prod_thread, nb_calc_thread, learning_rate);
 
 // ne pas mettre fonction d'activation à la sortie , i.e: fonction identité : f(x) = x:
@@ -67,12 +88,12 @@ struct networks_qlearning * create_nework_qlearning(
   neurons_TYPE_FLOAT *tmpBest = qnets->best_net;
   while(tmpMain){
     if(tmpMain->next_layer == NULL){
-      tmpMain->f_act = id;
+      tmpMain->f_act = id_TYPE_FLOAT;//id;
-      tmpMain->d_f_act = constOne;
+      tmpMain->d_f_act = d_id_TYPE_FLOAT; //constOne;
-      tmpTarget->f_act = id;
+      tmpTarget->f_act = id_TYPE_FLOAT;//id;
-      tmpTarget->d_f_act = constOne;
+      tmpTarget->d_f_act = d_id_TYPE_FLOAT;//constOne;
-      tmpBest->f_act = id;
+      tmpBest->f_act = id_TYPE_FLOAT;//id;
-      tmpBest->d_f_act = constOne;
+      tmpBest->d_f_act = d_id_TYPE_FLOAT;// constOne;
     }
     tmpMain = tmpMain->next_layer;
     tmpTarget= tmpTarget->next_layer;
@@ -156,18 +177,18 @@ struct qlearning_params * create_qlearning_params  (
 ){
   struct qlearning_params * qparams = malloc(sizeof(struct qlearning_params));
 
-  qparams->gamma = gamma;
+  qparams->gamma = gamma; /* taux d'actualisation (discount rate): default : 0.95  */
-  qparams->learning_rate = learning_rate ;
+  qparams->learning_rate = learning_rate ; /* default : 0.001 */
-  qparams->discount_factor = discount_factor ;
+  qparams->discount_factor = discount_factor ; /* */
   qparams->exploration_factor = exploration_factor ;
   
   qparams->nb_training_before_update_weight_in_target = nb_training_before_update_weight_in_target;
   qparams->number_episodes = number_episodes;
 
   qparams->factor_update_learning_rate = 0.995;
-  qparams->minimum_threshold_learning_rate = 0.0001 ;
+  qparams->minimum_threshold_learning_rate = 0.00001 ;
-  qparams->factor_update_exploration_factor = 0.9995 /*0.995*/;
+  qparams->factor_update_exploration_factor = 0.995 /*0.995*/;
-  qparams->minimum_threshold_exploration_factor = 0.01;
+  qparams->minimum_threshold_exploration_factor = 0.0001;
 
 //  qparams->threshold_number_same_action = 500;
 
@@ -250,6 +271,9 @@ void free_RL_agent(struct RL_agent *rlAgent){
 
 #define ACCEPTABLE_REWARD 1000
 
+#define UPDATE_PARAMS 1
+#define UPDATE_EXPLOR_FAC 1
+
 void train_qlearning(struct RL_agent * rlAgent, 
   int action  //, long reward
   ){
@@ -263,8 +287,11 @@ void train_qlearning(struct RL_agent * rlAgent,
   calculate_output_by_network_neurons_TYPE_FLOAT(net_target, new_state, &next_action_value);
   tensor_TYPE_FLOAT * experimental_values = CREATE_TENSOR_FROM_CPY_DIM_TYPE_FLOAT(action_value->dim);
   
+     // print_neurons_msg_TYPE_FLOAT(net_main, " net_main "); getchar();
   struct game_status * car_status = rlAgent->car->status;
+#if UPDATE_PARAMS
   struct qlearning_params * qlParams = rlAgent->qlearnParams;
+#endif
   copy_tensor_TYPE_FLOAT(experimental_values, action_value) ;
   //copy_tensor_TYPE_FLOAT(experimental_values, next_action_value) ;
   // experimental_values === Q-tab learning
@@ -277,23 +304,33 @@ void train_qlearning(struct RL_agent * rlAgent,
       copy_tensor_TYPE_FLOAT(ttmp->target, experimental_values);
       while(ttmp != net_main){
         calc_delta_neurons_TYPE_FLOAT(ttmp);
-        update_weight_neurons_TYPE_FLOAT(ttmp);
+        //update_weight_neurons_TYPE_FLOAT(ttmp);
         ttmp = ttmp->prev_layer;
       }
-
+      ttmp=net_main->next_layer; 
+      while(ttmp){
+        update_weight_neurons_TYPE_FLOAT(ttmp);
+        ttmp = ttmp->next_layer;
+      }
 // ***
-	if(car_status->cumulative_reward > ACCEPTABLE_REWARD){ 
+#if UPDATE_PARAMS
+	if((car_status->cumulative_reward > ACCEPTABLE_REWARD) || (rlAgent->status->nb_episodes % 100 == 0) ){ 
   	float new_value = ( (net_main->learning_rate < qlParams->minimum_threshold_learning_rate /*0.0001*/) ? net_main->learning_rate :(net_main->learning_rate ) * qlParams->factor_update_learning_rate   /*0.995*/ );
   	UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, net_main, learning_rate, new_value);
-
+    qlParams->learning_rate = new_value;
+#if UPDATE_EXPLOR_FAC
   	qlParams->exploration_factor = (qlParams->exploration_factor < qlParams->minimum_threshold_exploration_factor) ? qlParams->exploration_factor : qlParams->exploration_factor * qlParams->factor_update_exploration_factor ;
+#endif
 	}
+#endif
 //  free_tensor_TYPE_FLOAT(action_value);
 //  free_tensor_TYPE_FLOAT(next_action_value);
   free_tensor_TYPE_FLOAT(experimental_values);
 
 }
-#define MAX_SUCCESSIVE_ACTION 200
+#define SUCCESSIVE_ACTION_CHECK 1
+
+#define MAX_SUCCESSIVE_ACTION 1000
 int select_action(struct RL_agent * rlAgent){
   //static size_t explore = 0;
   int action;
@@ -313,6 +350,7 @@ int select_action(struct RL_agent * rlAgent){
   if(proba_explor > rlAgent->qlearnParams->exploration_factor ){
     action = ARG_MAX_ARRAY_TYPE_FLOAT( action_value->x, action_value->dim->rank  );
     //printf(" STRATEGY : action : %d , factor : %f nb_episodes : %ld \n",action,rlAgent->qlearnParams->exploration_factor, rlAgent->status->nb_episodes);
+#if SUCCESSIVE_ACTION_CHECK
   if(rlAgent->networks->nb_successive_action[action]>MAX_SUCCESSIVE_ACTION){
 			rlAgent->networks->nb_successive_action[action]=0;
 			int recAction=action;
@@ -320,8 +358,11 @@ int select_action(struct RL_agent * rlAgent){
     		action = xrand() % action_value->dim->rank ; 
 				//printf("debug: action=%d recAction=%d\n",action, recAction);
 			}
+      struct qlearning_params * qlParams = rlAgent->qlearnParams;
 		  write(1,"#",1);
+      qlParams->exploration_factor = (qlParams->exploration_factor < 1 ) ? qlParams->exploration_factor / qlParams->factor_update_exploration_factor :  qlParams->exploration_factor  ;
 		}
+#endif
 		////else write(1,".",1);
     //if(action == ARG_MIN_ARRAY_TYPE_FLOAT( action_value->x, action_value->dim->rank  )) 
       //action = xrand() % action_value->dim->rank ; 
@@ -333,12 +374,13 @@ int select_action(struct RL_agent * rlAgent){
     //printf(" EXPLORE : action : %d , factor : %f nb_episodes : %ld \n",action,rlAgent->qlearnParams->exploration_factor, rlAgent->status->nb_episodes);
 		////write(1,"*",1);
   }
+#if SUCCESSIVE_ACTION_CHECK
 	for(int a=0;a<COUNT_ACTION;++a){
 		if(a!=action)
 			rlAgent->networks->nb_successive_action[a]=0;
 	}
 	(rlAgent->networks->nb_successive_action[action])++;
-
+#endif 
   /*
     if(rlAgent->status->last_action == action){
       ++(rlAgent->status->count_last_action);
@@ -450,7 +492,12 @@ void* learn_to_drive(void * lrnarg){
   ////pthread_create(&threadPrint, NULL, runPrint, (void*)rlAgent);
   
  // while(true){
-    for(size_t index_episode = 0; (!is_ending(qlStatus)) && (index_episode < qlParams->number_episodes) ; ++index_episode){
+    for(size_t index_episode = 0; 
+      (!is_ending(qlStatus)) 
+      //|| (car_status->cumulative_reward > 2 * ACCEPTABLE_REWARD) 
+      //|| (index_episode < qlParams->number_episodes) 
+      ; 
+      ++index_episode){
       reset(car);
       qlStatus->nb_training_after_updated_weight_in_target = 0;
       qlStatus->index_episode = index_episode;

deepQlearn_0/src/deepQlearning/learn_to_drive.h

@@ -99,7 +99,7 @@ struct RL_agent {
 
 };
 
-struct networks_qlearning * create_nework_qlearning(
+struct networks_qlearning * create_network_qlearning(
   struct config_layers * config,
   bool randomize, float minR, float maxR,  int randomRange,
   size_t nb_prod_thread,

deepQlearn_0/src/deepQlearning/vehicle.c

@@ -7,7 +7,11 @@
 //#define CENTER 1
 //#define RIGHT 2
 
-#define LIMIT_DISTANCE ((float)((SUBDIVISION-1)/10))/SUBDIVISION
+#define MAXDISTANCE 49
+#define DIVISER     10
+
+//#define LIMIT_DISTANCE ((float)((SUBDIVISION-1)/10))/SUBDIVISION
+#define LIMIT_DISTANCE ((float)((int)(SUBDIVISION/10)-1)/SUBDIVISION)
 
 #define REWARD_STOP -1000
 #define REWARD_CONTINUE 100
@@ -420,9 +424,12 @@ float distance2_coordinate(coordinate *c0, coordinate *c1){
     diStep_sensor->x[0] += step_sensor * cos(direction_radian);\
     diStep_sensor->x[1] -= step_sensor * sin(direction_radian);\
   }\
-  dist = (distance2_coordinate(diStep_sensor, v->coord)/10/*5*/);\
+  /*dist = (distance2_coordinate(diStep_sensor, v->coord)/10)*/;\
+  dist = (distance2_coordinate(diStep_sensor, v->coord)/DIVISER);\
   /*printf("| dist :%f | ",dist);*/\
-  v->sensor->x[position] = (float)(MIN((SUBDIVISION-1),dist))/SUBDIVISION ;\
+  /*v->sensor->x[position] = (float)(MIN((SUBDIVISION-1),dist))/SUBDIVISION ;*/\
+  if(dist>=0) v->sensor->x[position] = (float)(MIN(MAXDISTANCE,dist))/SUBDIVISION;\
+  else v->sensor->x[position] = 0;\
   
   
  #if 0 
@@ -581,7 +588,7 @@ void step_vehicle(struct vehicle *v, int action){
   }
 }
 
-#define RANDOM 0
+#define RANDOM 1
 
 void reset(struct vehicle *v){
   //static bool init = true;
@@ -615,11 +622,11 @@ void reset(struct vehicle *v){
   #endif
   #if RANDOM
   random = xrand() % 50;
-    v->direction = 80 - random ;
+    //v->direction = 80 - random ;
     //v->direction = 115 - random ;
-   // v->direction = random - 25  ;
+    v->direction = random - 25  ;
   #else
-    v->direction = 70; //-90;
+    v->direction = 80; //-90;
   #endif
   v->speed = SPEED;
   read_sensor(v);

deepQlearn_0/test/is_good.c

@@ -458,7 +458,7 @@ TEST(first_learn_vehicle_rev50_8){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.001; // 0.00001 /*0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -622,7 +622,7 @@ TEST(first_learn_vehicle_50__9){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.00001 /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -792,7 +792,7 @@ TEST(first_learn_vehicle_50__10){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.00001 /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -964,7 +964,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0; /* 0.000001*/ /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -1143,7 +1143,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.0000001 /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -1265,7 +1265,7 @@ TEST(first_learn_vehicle13){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -1375,7 +1375,7 @@ TEST(first_learn_vehicle){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -1486,7 +1486,7 @@ TEST(first_learn_vehicle){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,

neuron_t/src/neuron_t/neuron_t.c

@@ -57,7 +57,8 @@ type power_##type(type b, size_t p){\
 void step_based_update_learning_rate_##type(neurons_##type *nr){\
   nr->learning_rate=(nr->initial_learning_rate)*power_##type((nr->decay_rate),(1+(nr->iteration_step))/(nr->drop_rate));\
 }\
-\
+type id_##type(type x){ return x;}\
+type d_id_##type(type x){ return 1;}\
 void setup_learning_rate_params_neurons_##type(neurons_##type *base,type initial_learning_rate, type decay_rate, size_t drop_rate, void (*update_learning_rate)(neurons_##type *)){\
   while(base){\
     base->initial_learning_rate = initial_learning_rate;\
@@ -123,10 +124,13 @@ void calc_delta_neurons_##type(neurons_##type *nr){\
     /*decrement_dim_var(temp_w_d->dim);*/\
     \
     if(nr->nb_calc_thread < 2){\
-      for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\
+      for(size_t i = 0; i<(nr->net)->dim->rank; ++i){\
+        if(temp_w_d->x[i]!=temp_w_d->x[i]) printf("debug: temp_w_d[%ld]=nan ",i);\
+        if((nr->net)->x[i] != (nr->net)->x[i]) printf("debug : (nr->net)->x[%ld] = nan ",i) ;\
         (nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i]) * temp_w_d->x[i] ;\
+        if((nr->delta_out)->x[i] != (nr->delta_out)->x[i] ) printf("debug: (nr->delta_out)->x[%ld]=nan ",i);\
       /*print_tensor_msg_##type(nr->delta_out," nr delta_out calc 1 core hidden delta_out");\
-     */\
+     */}\
     }else{\
       update_4tensor_func_##type(nr->delta_out, nr->net, temp_w_d,\
         funcalc_delta_hidden_out_##type , \
@@ -140,6 +144,8 @@ void calc_delta_neurons_##type(neurons_##type *nr){\
 }\
 \
 type  func_only_weight_in_##type(type w0, type w1, type scalar){\
+  if(w0 != w0) printf("debug: w0=nan ");\
+  if(w1 != w1) printf("debug: w1=nan ");\
   return w0 - scalar * w1;\
 }\
 void only_update_weight_neurons_##type(neurons_##type *nr){\
@@ -703,6 +709,7 @@ void print_data_set_msg_##type(data_set_##type *ds, char *msg){\
 size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dataset, bool (*condition)(type,size_t)){\
   neurons_##type *tmp=NULL, *ttmp;\
   size_t nbreps=0;\
+  /*char strNbreps[128];*/\
   do{\
     for(size_t i=0; i<dataset->size; ++i){\
       init_copy_in_out_networks_from_tensors_##type(base, dataset->input[i],dataset->target[i]);\
@@ -714,11 +721,18 @@ size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dat
       }\
       while(ttmp != base){\
         calc_delta_neurons_##type(ttmp);\
-        update_weight_neurons_##type(ttmp);\
+        /*update_weight_neurons_##type(ttmp);*/\
         ttmp = ttmp->prev_layer;\
       }\
+      ttmp = base->next_layer;\
+      while(ttmp){\
+        update_weight_neurons_##type(ttmp);\
+        ttmp = ttmp->next_layer;\
+      }\
     }\
     nbreps += (dataset->size);\
+    /*sprintf(strNbreps, " base %ld ",nbreps);\
+    print_neurons_msg_##type(base, strNbreps ); getchar();*/\
   }while(!condition(error_out_##type(base), nbreps));\
     \
   \
@@ -730,8 +744,9 @@ size_t learning_online2_neurons_##type(neurons_##type *base, data_set_##type *da
   size_t nbreps=0;\
   type err=0;\
   bool ending=false;\
+  /*char strNbreps[128];*/\
   do{\
-    for(size_t i=0; i<dataset->size && !ending; ++i){\
+    for(size_t i=0; i<dataset->size /*&& !ending*/; ++i){\
       init_copy_in_out_networks_from_tensors_##type(base, dataset->input[i],dataset->target[i]);\
       tmp=base->next_layer;\
       while(tmp){\
@@ -744,20 +759,23 @@ size_t learning_online2_neurons_##type(neurons_##type *base, data_set_##type *da
         /*update_weight_neurons_##type(ttmp);\
         */ttmp = ttmp->prev_layer;\
       }\
-        tmp = ttmp->next_layer;\
+        tmp = base/*ttmp*/->next_layer;\
       while(tmp){\
         update_weight_neurons_##type(tmp);\
         tmp = tmp->next_layer;\
       }\
-      err = ABSMAX(err,error_out_##type(base));\
+      /*if(i%20==0){err = error_out_##type(base);} else err = ABSMAX(err,error_out_##type(base));\
+      */err = error_out_##type(base);\
       ending = condition(err, ++nbreps);\
+    /*sprintf(strNbreps, " base %ld  ",nbreps );\
+    print_neurons_msg_##type(base, strNbreps ); getchar();*/\
     }\
 \
   }while(!ending);\
     \
   \
-  printf(" ### reps : %ld, err:%f \n",nbreps,err);\
+  /*printf(" ### reps : %ld, err:%f \n",nbreps,err);\
-  return nbreps;\
+  */return nbreps;\
 }\
 \
 neurons_##type * calculate_output_by_network_neurons_##type(neurons_##type *base, tensor_##type *input, tensor_##type **output_link){\
@@ -804,8 +822,8 @@ void print_predict_by_network_with_error_neurons_##type(neurons_##type *base, te
       }\
 \
 \
-  printf(" error : %f\n", error_out_##type(base));\
+  /*printf(" error : %f\n", error_out_##type(base));\
-  print_tensor_msg_##type(input,"from input:");\
+  */print_tensor_msg_##type(input,"from input:");\
   \
 }\
 \
@@ -1021,3 +1039,4 @@ size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##typ
   
 GEN_NEURONS_F_(TYPE_FLOAT)
 GEN_NEURONS_F_(TYPE_DOUBLE)
+GEN_NEURONS_F_(TYPE_L_DOUBLE)

neuron_t/src/neuron_t/neuron_t.h

@@ -60,6 +60,8 @@ struct func_act_##type {\
 void do_not_update_learnig_rate_##type(neurons_##type *N);\
 void time_based_update_learning_rate_##type(neurons_##type *nr);\
 void step_based_update_learning_rate_##type(neurons_##type *nr);\
+type id_##type(type x);\
+type d_id_##type(type x);\
 void setup_learning_rate_params_neurons_##type(neurons_##type *base,type initial_learning_rate, type decay_rate, size_t drop_rate, void (*update_learning_rate)(neurons_##type *));\
 /*void calc_net_neurons_##type(neurons_##type *nr);*/\
 void calc_out_neurons_##type(neurons_##type *nr);\
@@ -125,6 +127,7 @@ size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##typ
 
 GEN_NEURON_(TYPE_FLOAT)
 GEN_NEURON_(TYPE_DOUBLE)
+GEN_NEURON_(TYPE_L_DOUBLE)
 
 
 #define UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(type, neuronVar, attribute, value) \
@@ -164,21 +167,24 @@ GEN_NEURON_(TYPE_DOUBLE)
     free(vmsg);\
   }while(0);\
 
-#define BASH_PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(type, bash_arg, neuronVar, attribute, msg)\
+#define BASH_PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(type, bash_arg, neuronVar, attribute, msg, putIndexTens)\
   do{\
     neurons_##type *tmpn = neuronVar;\
     char *vmsg=malloc(strlen(msg)+70);\
-    size_t i=0;\
+    /*size_t i=0;\
-    size_t lenVMG=0;\
+    size_t lenVMG=0;*/\
     size_t lenBSH_T=0;\
     while(tmpn){\
-      lenVMG = sprintf(vmsg,"%s layer %ld",msg,i++);\
+      /*lenVMG = sprintf(vmsg,"%s layer %ld",msg,i++);\
-      BASH_WRITE_IF_EXIST(bash_arg,vmsg,lenVMG);\
+      BASH_WRITE_IF_EXIST(bash_arg,vmsg,lenVMG);*/\
       if(tmpn->attribute){\
         char *bashSTR=NULL;\
-        lenBSH_T=sprint_tensor_##type(&bashSTR, tmpn->attribute, true);\
+        lenBSH_T=sprint_tensor_##type(&bashSTR, tmpn->attribute, putIndexTens);\
+        if(tmpn/*->next_layer==NULL*/){\
           BASH_WRITE_IF_EXIST(bash_arg,bashSTR,lenBSH_T);\
+        }\
         if(bashSTR) free(bashSTR);\
+        /*if(lenBSH_T==0) getchar();*/\
       }\
       tmpn = tmpn->next_layer;\
     }\

neuron_t/test/is_good.c

@@ -38,6 +38,12 @@ float df(float x){
   return exp(-x)/ ((1+exp(-x)) * (1+exp(-x)));
 }
 
+float __id_(float x){
+  return x;
+}
+float d__id_(float x){
+  return 1;
+}
 
 TEST(init_One){
   //endian=false;
@@ -94,7 +100,7 @@ TEST(data_set_from_file){
 #define epsilon 0.0001
 
 bool cond(float e, size_t nbreps){
-  if (nbreps > 20000) return true;
+  if (nbreps > 2000) return true;
   if ((e<epsilon) && (e>-epsilon)) return true;
   return false;
 }
@@ -106,6 +112,7 @@ TEST(learning_first){
   print_data_set_msg_TYPE_FLOAT(ds,"data");
   neurons_TYPE_FLOAT *bn=NULL, *tmp ;
   setup_networks_OneD_TYPE_FLOAT(&bn, (size_t[]){2,4,1},3,false,0,1,5000); /* 2 input , 1 target; 1 hidden layer with 5 neurons */
+  //setup_networks_OneD_TYPE_FLOAT(&bn, (size_t[]){2,4,1},3,true,0,1,5000); /* 2 input , 1 target; 1 hidden layer with 5 neurons */
 
   setup_all_layers_functions_TYPE_FLOAT(bn,
     tensorContractnProdThread_TYPE_FLOAT,
@@ -115,11 +122,23 @@ TEST(learning_first){
     f,
     df);
 
-  setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.1);
+  setup_all_layers_params_TYPE_FLOAT(bn, 5/*5*/, 3/*1*/ ,  0.5);
 
+  neurons_TYPE_FLOAT *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=__id_;
+      ttmp->d_f_act=d__id_;
+    }
+    ttmp=ttmp->next_layer;
+  }
+
+  LOG("%s","setup done\n");
+  print_neurons_msg_TYPE_FLOAT(bn,"bn before ");
 
   size_t reps = learning_online_neurons_TYPE_FLOAT(bn,ds,cond);
   
+  print_neurons_msg_TYPE_FLOAT(bn,"bn after ");
  
   //char msg[256];
   for(size_t i=0; i<ds->size; ++i){
@@ -136,16 +155,16 @@ TEST(learning_first){
     */
   }
   
+  LOG("reps = %ld error=%f\n",reps, error_out_TYPE_FLOAT(bn));
   free_data_set_TYPE_FLOAT(ds);
   free_neurons_TYPE_FLOAT(bn); 
 
-  LOG("reps = %ld\n",reps);
   randomizeInitWeight = rec_randomizeInitWeight;
 }
 
 
 
-TEST(learning_second_PRINT){
+TEST(learning_second_PRINT){ endian=false;
    bool rec_randomizeInitWeight = randomizeInitWeight;
    randomizeInitWeight =false;
   
@@ -162,8 +181,15 @@ TEST(learning_second_PRINT){
     f,
     df);
 
-  setup_all_layers_params_TYPE_FLOAT(bn, 5, 3 ,  0.1);
+  setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.4);
-
+  neurons_TYPE_FLOAT *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=__id_;
+      ttmp->d_f_act=d__id_;
+    }
+    ttmp=ttmp->next_layer;
+  }
 
   size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
   
@@ -214,8 +240,16 @@ TEST(learning_withconfig2){
     f,
     df);
 
-  setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.1);
+  setup_all_layers_params_TYPE_FLOAT(bn, 1, 1 ,  0.5);
   
+  neurons_TYPE_FLOAT *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=__id_;
+      ttmp->d_f_act=d__id_;
+    }
+    ttmp=ttmp->next_layer;
+  }
 
   size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
   
@@ -231,6 +265,8 @@ TEST(learning_withconfig2){
   free_data_set_TYPE_FLOAT(ds);
   free_neurons_TYPE_FLOAT(bn); 
   
+  free_config_layers(pconf);
+
   LOG("reps = %ld\n",reps);
   randomizeInitWeight = rec_randomizeInitWeight;
 }
@@ -255,8 +291,15 @@ TEST(learning_cloneuroneset){
     f,
     df);
 
-  setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.1);
+  setup_all_layers_params_TYPE_FLOAT(bn, 1, 1 ,  0.5);
-
+  neurons_TYPE_FLOAT *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=__id_;
+      ttmp->d_f_act=d__id_;
+    }
+    ttmp=ttmp->next_layer;
+  }
   //print_neurons_msg_TYPE_FLOAT(bn,"before create clones");
 
   cloneuronset_TYPE_FLOAT *clnrnst = create_cloneuronset_from_base_conf_TYPE_FLOAT(bn, pconf, 3);
@@ -308,7 +351,14 @@ TEST(learning_cloneuroneset_LEARN_RATE){
   size_t dropRate = 100;
 //  setup_learning_rate_params_neurons_TYPE_FLOAT(bn, initRate, decayRate, dropRate, time_based_update_learning_rate_TYPE_FLOAT);
   setup_learning_rate_params_neurons_TYPE_FLOAT(bn, initRate, decayRate, dropRate, step_based_update_learning_rate_TYPE_FLOAT);
-
+  neurons_TYPE_FLOAT *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=__id_;
+      ttmp->d_f_act=d__id_;
+    }
+    ttmp=ttmp->next_layer;
+  }
   //print_neurons_msg_TYPE_FLOAT(bn,"before create clones");
 
   cloneuronset_TYPE_FLOAT *clnrnst = create_cloneuronset_from_base_conf_TYPE_FLOAT(bn, pconf, 3);
@@ -331,7 +381,6 @@ TEST(learning_cloneuroneset_LEARN_RATE){
 
   LOG("reps = %ld\n",reps);
   randomizeInitWeight = rec_randomizeInitWeight;
-
 }
 
 TEST(copy_weight_in_neurons){
@@ -356,7 +405,14 @@ TEST(copy_weight_in_neurons){
     df);
 
   setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.1);
-
+  neurons_TYPE_FLOAT *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=__id_;
+      ttmp->d_f_act=d__id_;
+    }
+    ttmp=ttmp->next_layer;
+  }
 
   size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
   
@@ -396,6 +452,7 @@ TEST(copy_weight_in_neurons){
 
   LOG("reps = %ld\n",reps);
   randomizeInitWeight = rec_randomizeInitWeight;
+  free_config_layers(pconf);
 }
 
 
@@ -435,7 +492,14 @@ TEST(Extract_weight_in_neurons){
     df);
 
   setup_all_layers_params_TYPE_FLOAT(cpyn, 5, 1 ,  0.1);
-
+  neurons_TYPE_FLOAT *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=__id_;
+      ttmp->d_f_act=d__id_;
+    }
+    ttmp=ttmp->next_layer;
+  }
   EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, cpyn, weight_in, ".ff_bn_weight_in__toExtract.txt")
 //  copy_weight_in_neurons_TYPE_FLOAT(cpyn, bn);
   EXPORT_TO_FILE_TENSOR_ATTRIBUTE_IN_NNEURONS(TYPE_FLOAT, bn, weight_in, ".ff_bn_weight_in__toExtract___exp.txt")
@@ -463,6 +527,8 @@ TEST(Extract_weight_in_neurons){
 
   LOG("reps = %ld\n",reps);
   randomizeInitWeight = rec_randomizeInitWeight;
+
+  free_config_layers(pconf);
 }
 
 
@@ -492,7 +558,14 @@ TEST(Extract_EXPORT_weight_in_neurons){
     df);
 
   setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.1);
-
+  neurons_TYPE_FLOAT *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=__id_;
+      ttmp->d_f_act=d__id_;
+    }
+    ttmp=ttmp->next_layer;
+  }
 
   size_t reps = 1;// learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
   EXPORT_TO_FILE_TENSOR_ATTRIBUTE_IN_NNEURONS(TYPE_FLOAT, bn, weight_in, ".ff_bn_weight_in__toCMP__.txt")
@@ -534,6 +607,8 @@ TEST(Extract_EXPORT_weight_in_neurons){
 
   LOG("reps = %ld\n",reps);
   randomizeInitWeight = rec_randomizeInitWeight;
+
+  free_config_layers(pconf);
 }
 
 
@@ -596,7 +671,14 @@ TEST(Extract_EXPORT_weight_in_neurons_double){
     doubledf);
 
   setup_all_layers_params_TYPE_DOUBLE(cpyn, 5, 1 ,  0.1);
-
+  neurons_TYPE_DOUBLE *ttmp=bn;
+  while(ttmp){
+    if(ttmp->next_layer == NULL){
+      ttmp->f_act=id_TYPE_DOUBLE;
+      ttmp->d_f_act=d_id_TYPE_DOUBLE;
+    }
+    ttmp=ttmp->next_layer;
+  }
 //  EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_DOUBLE, cpyn, weight_in, ".ff_bn_weight_in__toExtract.txt")
 //  copy_weight_in_neurons_TYPE_DOUBLE(cpyn, bn);
  
@@ -623,6 +705,7 @@ TEST(Extract_EXPORT_weight_in_neurons_double){
 
   LOG("reps = %ld\n",reps);
   randomizeInitWeight = rec_randomizeInitWeight;
+  free_config_layers(pconf);
 }
 
 

tensor_t/src/tensor_t/tensor_t.c

@@ -23,6 +23,21 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
   printf("\n");
 }
 
+int checkContractProdTensorDim(dimension *d0, dimension *d1, ssize_t contractionNumber){
+  if((d0->size-contractionNumber <0)||(d1->size-contractionNumber <0)) return 0;
+  if(endian){
+    ssize_t beginCommonM0=d0->size-contractionNumber;
+    for(ssize_t i=0; i<contractionNumber; ++i){
+      if(d0->perm[beginCommonM0+i] != d1->perm[i]) return 0;
+    }
+  }else{
+    ssize_t beginCommonM1=d1->size-contractionNumber;
+    for(ssize_t i=0; i<contractionNumber; ++i){
+      if(d0->perm[i] != d1->perm[beginCommonM1+i]) return 0;
+    }
+   }
+  return 1;
+}
 /*
 bool isLessEqThan(long int a, long int b) { return a <= b; }
 bool isLessThan(long int a, long int b) { return a < b; }
@@ -399,11 +414,11 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
     printf(" |#%ld]: %s, ",i,val);\
     /*printf(" %s, ",val);*/\
     free(val); val=NULL;\
-    if(T->x[i] != T->x[i]){\
+    /*if(T->x[i] != T->x[i]){\
       printf("\nALERT NAN\n");\
       char c;\
       scanf("%c",&c);\
-    }\
+    }*/\
     if(coord[begin]==(T->dim)->perm[begin]-1){\
       size_t count=0;\
       for(long int j=begin; cond(j,end); j = iter(j)){\
@@ -456,7 +471,12 @@ void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
         else break;\
       }\
     }\
-    /*fprintf(fileWrite," [");\
+    if(T->x[i] != T->x[i]){\
+      printf("\nALERT NAN\n");\
+      ;\
+      return;\
+    }\
+/*fprintf(fileWrite," [");\
     for(size_t k=0; k<(T->dim)->size;++k) fprintf(fileWrite," %ld,",coord[k]);\
     */val=type##_TO_STR(T->x[i]);\
     fprintf(fileWrite," %s, ",val);\
@@ -539,6 +559,14 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
     free(val); val = NULL;\
     (*tensorContent)[cur++]=']';\
     (*tensorContent)[cur++]=' ';\
+  }\
+     if(T->x[i] != T->x[i]){\
+      /*char *nanStr="ALERT NAN";\
+      for(size_t c=0;c<strlen(nanStr);++c)\
+        (*tensorContent)[cur++]=nanStr[c];*/\
+      printf(" ALERT NAN ");\
+      ;\
+      /*return strlen(nanStr)*/;\
     }\
     val=type##_TO_STR(T->x[i]);\
     /*printf(" {%ld} %s [",i,val);*/\
@@ -639,6 +667,12 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
    /* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\
         prsize_tf("Deep = %d\n", contractionNumber);\
     }*/\
+    if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
+      printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
+        printDebug_dimension(M0->dim, "M0 dim");\
+        printDebug_dimension(M1->dim, "M1 dim");\
+        getchar();\
+    }\
 \
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
@@ -727,6 +761,7 @@ void* runProd_thread_##type(void *arg){\
   return 0;\
 }\
 \
+\
 void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
@@ -863,8 +898,14 @@ void* runProdContract_thread_##type(void *arg){\
  M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
 M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
 \
-void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
 \
+void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
+    if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
+      printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
+        printDebug_dimension(M0->dim, "M0 dim");\
+        printDebug_dimension(M1->dim, "M1 dim");\
+        getchar();\
+    }\
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
 \
@@ -962,6 +1003,15 @@ void* runPro2dContract_thread_##type(void *arg){\
 M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
 \
 void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
+    /*if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
+      printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
+    }*/\
+    if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
+      printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
+        printDebug_dimension(M0->dim, "M0 dim");\
+        printDebug_dimension(M1->dim, "M1 dim");\
+        getchar();\
+    }\
 \
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
@@ -1015,10 +1065,12 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
   FREE_dM_S_ ; \
 }\
 void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
-   /* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\
+    if (!checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)) {\
-        prsize_tf("Deep = %d\n", contractionNumber);\
+        printf("error Deep = %ld\n", contractionNumber);\
-    }*/\
+        printDebug_dimension(M0->dim, "M0 dim");\
-\
+        printDebug_dimension(M1->dim, "M1 dim");\
+        getchar();\
+    }\
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
 \
@@ -1259,8 +1311,8 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
         if(!filled1){\
           ++i1;\
           (*Tpart1)->x[i++] = x;\
-          printf("++ x: %f, i1:%ld , rkn1: %ld\n",x,i1,ddim1->rank);\
+          /*printf("++ x: %f, i1:%ld , rkn1: %ld\n",x,i1,ddim1->rank);\
-          if(i1 == ddim1->rank){\
+          */if(i1 == ddim1->rank){\
             filled1=true;\
             i1=0;\
             filled2=false;\
@@ -1269,8 +1321,8 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
           if(!filled2){\
             ++i2;\
             (*Tpart2)->x[j++] = x;\
-            printf("-----++ x: %f, i2:%ld , rknr: %ld\n",x,i2,ddim2->rank);\
+            /*printf("-----++ x: %f, i2:%ld , rknr: %ld\n",x,i2,ddim2->rank);\
-            if(i2 == ddim2->rank){\
+            */if(i2 == ddim2->rank){\
               filled2=true;\
               i2=0;\
               filled1=false;\
@@ -1942,3 +1994,4 @@ void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
 
 GEN_FUNC_TENSOR(TYPE_FLOAT);
 GEN_FUNC_TENSOR(TYPE_DOUBLE);
+GEN_FUNC_TENSOR(TYPE_L_DOUBLE);

tensor_t/src/tensor_t/tensor_t.h

@@ -83,6 +83,7 @@ void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1,  \
 
 GENERATE_TENSOR_TYPE(TYPE_FLOAT);
 GENERATE_TENSOR_TYPE(TYPE_DOUBLE);
+GENERATE_TENSOR_TYPE(TYPE_L_DOUBLE);
 
 
 #endif /* __TENSOR_T__H__ */

tensor_t/test/is_good.c

@@ -510,6 +510,106 @@ TEST(SplitOne_randomInit){
 }
 #endif
 
+TEST(tensorProdNoOpt){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(2);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+
+#else
+
+
+  d0->perm[0]=5;
+  d0->perm[1]=7; //3;
+  d0->perm[2]=12;
+
+  d1->perm[0]=2;
+  d1->perm[1]=13;//3;
+#endif
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+
+  tensor_TYPE_FLOAT *M=NULL; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
+  
+  tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  
+  float MMM0[d0->perm[0]][d0->perm[1]][d0->perm[2]];
+  long int coord3[3];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int i1=0;i1<d0->perm[1];++i1){
+  for(long int i2=0;i2<d0->perm[2];++i2){
+    coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
+    MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+  }
+  }
+  }
+
+  float MMM1[d1->perm[0]][d1->perm[1]];
+  long int coord2[2];
+  for(long int j0=0;j0<d1->perm[0];++j0){
+  for(long int j1=0;j1<d1->perm[1];++j1){
+    coord2[0]=j0; coord2[1]=j1;
+    MMM1[j0][j1]=M1->x[signedLineFromCoord(coord2, d1)];
+  }
+  }
+  //tensorProd_TYPE_FLOAT(&M,M0,M1);
+  float MMMm[d0->perm[0]][d0->perm[1]][d0->perm[2]][d1->perm[0]][d1->perm[1]];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int i1=0;i1<d0->perm[1];++i1){
+  for(long int i2=0;i2<d0->perm[2];++i2){
+  for(long int j0=0;j0<d1->perm[0];++j0){
+  for(long int j1=0;j1<d1->perm[1];++j1){
+    MMMm[i0][i1][i2][j0][j1]=MMM0[i0][i1][i2] * MMM1[j0][j1];
+    //printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
+  }
+  }
+  }
+  }
+  }
+  //LOG("M->dim->rank = %ld\n",M->dim->rank);
+
+  //print_tensor_float(M,"M");
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
+  long int coord5[5];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int i1=0;i1<d0->perm[1];++i1){
+  for(long int i2=0;i2<d0->perm[2];++i2){
+  for(long int j0=0;j0<d1->perm[0];++j0){
+  for(long int j1=0;j1<d1->perm[1];++j1){
+    coord5[0]=i0; coord5[1]=i1;coord5[2]=i2;
+    coord5[3]=j0; coord5[4]=j1;
+    EXPECT_EQ_TYPE_FLOAT(MMMm[i0][i1][i2][j0][j1], Mn->x[signedLineFromCoord(coord5, Mn->dim)] );
+  }
+  }
+  }
+  }
+  }
+
+  print_tensor_float(Mn,"Mn");
+  
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+  //free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+}
 TEST(tensorProd ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(2);
@@ -563,6 +663,364 @@ TEST(tensorProd ){
   free_tensor_TYPE_FLOAT(Mn);
 }
 
+TEST(tensorContractnProd_TYPE_FLOATNoOpt ){ 
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=3;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
+
+  d0->perm[0]=15;
+  d0->perm[1]=12; //3;
+  d0->perm[2]=13;
+
+  d1->perm[0]=13;
+  d1->perm[1]=15;//3;
+  d1->perm[2]=14;
+#endif
+
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+  tensorContractnProd_TYPE_FLOAT(&MnO, M0,M1,1);
+  //tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,1);
+printDebug_dimension(MnO->dim, "dim Contr 1");
+  float MMM0[d0->perm[0]][d0->perm[1]][d0->perm[2]];
+  long int coord3[3];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int i1=0;i1<d0->perm[1];++i1){
+  for(long int i2=0;i2<d0->perm[2];++i2){
+    coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
+    MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+  }
+  }
+  }
+
+  float MMM1[d1->perm[0]][d1->perm[1]][d1->perm[2]];
+  long int coord23[3];
+  for(long int j0=0;j0<d1->perm[0];++j0){
+  for(long int j1=0;j1<d1->perm[1];++j1){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
+    MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
+  }
+  }
+  }
+  //tensorProd_TYPE_FLOAT(&M,M0,M1);
+  float MMMm[d0->perm[0]][d0->perm[1]][d1->perm[1]][d1->perm[2]];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int i1=0;i1<d0->perm[1];++i1){
+  for(long int j1=0;j1<d1->perm[1];++j1){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    MMMm[i0][i1][j1][j2]=0;
+      for(long int i2=0;i2<d0->perm[2];++i2){
+        MMMm[i0][i1][j1][j2] += MMM0[i0][i1][i2] * MMM1[i2][j1][j2];
+    //printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
+      }
+  }
+  }
+  }
+  }
+  //LOG("M->dim->rank = %ld\n",M->dim->rank);
+
+  //print_tensor_float(M,"M");
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
+  long int coord4[4];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int i1=0;i1<d0->perm[1];++i1){
+  for(long int j1=0;j1<d1->perm[1];++j1){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    coord4[0]=i0; coord4[1]=i1; coord4[2]=j1; coord4[3]=j2;
+    //EXPECT_EQ_TYPE_FLOAT(MMMm[i0][i1][j1][j2], MnO->x[signedLineFromCoord(coord4, MnO->dim)] );
+   
+   if(expected_EQ_TYPE_FLOAT(MMMm[i0][i1][j1][j2], MnO->x[signedLineFromCoord(coord4, MnO->dim)] ) == false){
+      LOG("[ %ld, %ld, %ld, %ld ] [%ld]\n",i0,i1,j1,j2,
+      signedLineFromCoord(coord4, MnO->dim)
+      );
+
+   }
+   
+  }
+  }
+  }
+  }
+
+  //print_tensor_float(M,"M");
+  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //  EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  //free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+TEST(tensorContractnProd_TYPE_FLOATNoOpt2 ){
+  endian=true; //
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
+
+  d0->perm[0]=35;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=23;
+
+  d1->perm[0]=32;
+  d1->perm[1]=23;//3;
+  d1->perm[2]=44;
+#endif
+
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+  float MMM0[d0->perm[0]][d0->perm[1]][d0->perm[2]];
+  long int coord3[3];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int i1=0;i1<d0->perm[1];++i1){
+  for(long int i2=0;i2<d0->perm[2];++i2){
+    coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
+    MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+  }
+  }
+  }
+
+  float MMM1[d1->perm[0]][d1->perm[1]][d1->perm[2]];
+  long int coord23[3];
+  for(long int j0=0;j0<d1->perm[0];++j0){
+  for(long int j1=0;j1<d1->perm[1];++j1){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
+    MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
+  }
+  }
+  }
+  //tensorProd_TYPE_FLOAT(&M,M0,M1);
+  float MMMm[d0->perm[0]][d1->perm[2]];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    MMMm[i0][j2]=0;
+    for(long int i1=0;i1<d0->perm[1];++i1){
+      for(long int i2=0;i2<d0->perm[2];++i2){
+        MMMm[i0][j2] += MMM0[i0][i1][i2] * MMM1[i1][i2][j2];
+    //printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
+      }
+    }
+  }
+  }
+  //LOG("M->dim->rank = %ld\n",M->dim->rank);
+
+  //print_tensor_float(M,"M");
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
+  long int coord52[2];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    coord52[0]=i0; coord52[1]=j2;
+    EXPECT_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] );
+  
+   if(expected_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] ) == false){
+      LOG("[ %ld, %ld] [%ld]\n",i0,j2,
+      signedLineFromCoord(coord52, MnO->dim)
+      );
+
+   }
+  }
+  }
+
+  //print_tensor_float(M,"M");
+  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //  EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  //free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+TEST(tensorContractnProd_TYPE_FLOATNoOpt3endianFalse ){
+  endian=false;
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=4;
+  d1->perm[1]=2;//3;
+  d1->perm[2]=5;
+
+#else
+
+
+  d0->perm[0]=13;
+  d0->perm[1]=12; //3;
+  d0->perm[2]=35;
+
+  d1->perm[0]=32;
+  d1->perm[1]=12;//3;
+  d1->perm[2]=13;
+#endif
+
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+  float MMM0[d0->perm[0]][d0->perm[1]][d0->perm[2]];
+  long int coord3[3];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int i1=0;i1<d0->perm[1];++i1){
+  for(long int i2=0;i2<d0->perm[2];++i2){
+    coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
+    MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+  }
+  }
+  }
+
+  float MMM1[d1->perm[0]][d1->perm[1]][d1->perm[2]];
+  long int coord23[3];
+  for(long int j0=0;j0<d1->perm[0];++j0){
+  for(long int j1=0;j1<d1->perm[1];++j1){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
+    MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
+  }
+  }
+  }
+  //tensorProd_TYPE_FLOAT(&M,M0,M1);
+  float MMMm[d0->perm[0]][d1->perm[2]];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    MMMm[i0][j2]=0;
+    for(long int i1=0;i1<d0->perm[1];++i1){
+      for(long int i2=0;i2<d0->perm[2];++i2){
+        MMMm[i0][j2] += MMM0[i0][i1][i2] * MMM1[i1][i2][j2];
+    //printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
+      }
+    }
+  }
+  }
+  //LOG("M->dim->rank = %ld\n",M->dim->rank);
+
+  //print_tensor_float(M,"M");
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
+  long int coord52[2];
+  for(long int i0=0;i0<d0->perm[0];++i0){
+  for(long int j2=0;j2<d1->perm[2];++j2){
+    coord52[0]=i0; coord52[1]=j2;
+    EXPECT_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] );
+  
+   if(expected_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] ) == false){
+      LOG("[ %ld, %ld] [%ld]\n",i0,j2,
+      signedLineFromCoord(coord52, MnO->dim)
+      );
+
+   }
+  }
+  }
+
+  //print_tensor_float(M,"M");
+  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //  EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  //free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+
+
 TEST(tensorContractnProd_TYPE_FLOAT ){ 
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);

y_network_neural_network_/include/y_net_neur_net/y_nnn_screen_manager.h

@@ -61,6 +61,7 @@ struct arg_bash{
   pthread_mutex_t *mut_bash_var;
   pthread_cond_t *cond_bash_var;
   int go_on;
+  int weight_net_print;
 };
 
 struct arg_bash *create_arg_bash();

y_network_neural_network_/src/y_net_neur_net/y_nnn_manager.c

@@ -129,10 +129,11 @@ void* runBashPrint(void *arg){
   while( check_go_on_bash(bash_arg) && (new_bash_exist(bash_arg)) && check_go_on_print_params(pprint) && !is_ending(qlStatus)){
     if(/*(qlStatus->nb_episodes %125 == 0)  &&*/  pprint->printed){
           //pthread_mutex_lock(&(pprint->mut_printed));
+          if(bash_arg->weight_net_print == 0){
             pthread_mutex_lock(&(car->mut_coord));
             bash_print_vehicle_n_path(car, pprint->scale_x, pprint->scale_y,bash_arg);
             pthread_mutex_unlock(&(car->mut_coord));
-
+          }
           //pthread_mutex_unlock(&(pprint->mut_printed));
           ////printf("%s ",pprint->string_space);
           len_buf=sprintf(buf,"%s ",pprint->string_space);
@@ -150,7 +151,7 @@ void* runBashPrint(void *arg){
 
           }
           ////printf("\n< %5.2f > ( %s  ) \n", car->direction, action_name[qlStatus->action % COUNT_ACTION]);
-          len_buf=sprintf(buf,"\n< %5.2f > ( %s  ) \n", car->direction, action_name[qlStatus->action % COUNT_ACTION]);
+          len_buf=sprintf(buf,"\n< %5.2f ( %s  ) \n", car->direction, action_name[qlStatus->action % COUNT_ACTION]);
           BASH_WRITE_IF_EXIST(bash_arg, buf, len_buf)
           //print_weight_in_neurons_TYPE_FLOAT(net_main, "net_main_wei");
           //PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, net_main, weight_in, "net_main_we_in");
@@ -158,9 +159,15 @@ void* runBashPrint(void *arg){
           //PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, net_target, output, "net_target_out");
           //PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, net_main, input, "net_main_input");
           ////printf(" action : %d , factor : %f nb_episodes : %ld \n",qlStatus->action,rlAgent->qlearnParams->exploration_factor, rlAgent->status->nb_episodes);
-          BASH_PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, bash_arg, net_main, weight_in, "net_main_we_in");
          
-          len_buf=sprintf(buf," action : %d , factor : %f nb_episodes : %ld \n",qlStatus->action,rlAgent->qlearnParams->exploration_factor, rlAgent->status->nb_episodes);
+          if(bash_arg->weight_net_print){
+            BASH_PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, bash_arg, net_target, weight_in, "net_main_we_in", false);
+          }
+          len_buf=sprintf(buf," action : %d , learning_rate: %f, factor : %f nb_episodes : %ld \n",
+            qlStatus->action,
+            rlAgent->qlearnParams->learning_rate, 
+            rlAgent->qlearnParams->exploration_factor, 
+            rlAgent->status->nb_episodes);
           BASH_WRITE_IF_EXIST(bash_arg, buf, len_buf)
 
           FOR_LIST_FORM_BEGIN(TYPE_L_INT, qlStatus->progress_best_cumul){

y_network_neural_network_/src/y_net_neur_net/y_nnn_screen_manager.c

@@ -116,6 +116,7 @@ struct arg_bash *create_arg_bash(){
   pthread_cond_init(b_arg->cond_bash_var,NULL);
   
   b_arg->go_on=1;
+  b_arg->weight_net_print=0;
   b_arg->thread_launch=NULL;
 
 	b_arg->thread_run_newbash=NULL;

y_network_neural_network_/test/is_good.c

@@ -336,7 +336,7 @@ HIDE_TEST(_first_learn_vehicle_50__9){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.001 /*0.01*/ /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -364,12 +364,12 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
     20/*long int nb_training_before_update_weight_in_target*/,
     10000/*size_t number_episodes*/
   );
-   
+#if 0
  	 UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, d_f_act , df );
    UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, f_act, f );
    UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, d_f_act , df );
    UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, f_act , f );
-
+#endif
   struct print_params *pprint = create_print_params(
     12/*float scale_x*/,12 /*float scale_y*/,  
     dly/*struct delay_params * dly_p*/
@@ -529,7 +529,7 @@ HIDE_TEST(_first_learn_vehicle_50__10){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.00001 /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -614,33 +614,13 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
 }
 #endif
 
-TEST(_first_learn_vehicle_50__11_9){
+HIDE_TEST(_first_learn_vehicle_50__11_9){
   size_t nb_block = 7;
   size_t dim= 2;
   struct blocks * path = create_blocks(nb_block, dim);
 
 #if 1
 
-
-  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
-  copy_coordinate(path->upper_bound_block[0], (float[]){100,250});
-  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
-  copy_coordinate(path->upper_bound_block[1], (float[]){250,80});
-  copy_coordinate(path->lower_bound_block[2], (float[]){250,0});
-  copy_coordinate(path->upper_bound_block[2], (float[]){360,140});
-  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
-  copy_coordinate(path->upper_bound_block[3], (float[]){600,140});
-  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
-  copy_coordinate(path->upper_bound_block[4], (float[]){720,300});
-  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
-  copy_coordinate(path->upper_bound_block[5], (float[]){720,350});
-  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
-  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
- 
-
-
-#else 
-
     copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   copy_coordinate(path->upper_bound_block[0], (float[]){150,250});
   copy_coordinate(path->lower_bound_block[1], (float[]){150,0});
@@ -657,9 +637,30 @@ TEST(_first_learn_vehicle_50__11_9){
   copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
 
 
+
+
+
+#else 
+
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){100,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,80});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,0});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,140});
+  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[3], (float[]){600,140});
+  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[4], (float[]){720,300});
+  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
+  copy_coordinate(path->upper_bound_block[5], (float[]){720,350});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
+ 
 ///////////////////////////////////////
 
-
+#if 0
   copy_coordinate(path->lower_bound_block[0], (float[]){0,3});
   copy_coordinate(path->upper_bound_block[0], (float[]){4,7});
   copy_coordinate(path->lower_bound_block[1], (float[]){1,0});
@@ -675,6 +676,7 @@ TEST(_first_learn_vehicle_50__11_9){
   copy_coordinate(path->lower_bound_block[6], (float[]){1,7});
   copy_coordinate(path->upper_bound_block[6], (float[]){8,9.75});
  
+#endif
  
 #endif
 
@@ -683,15 +685,15 @@ TEST(_first_learn_vehicle_50__11_9){
   struct vehicle *car = create_vehicle(path);
 
   config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,24,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
-  //config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,14,14,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
+  //config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,4,4,3}); /* 3 input , 3 target; 2 hidden layer with 14 neurons each */
   
   bool randomize=true; 
   float minR = -0.5, maxR = 0.5;  
   int randomRange = 500;
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
-  float learning_rate = 0.001; /* 0.00001*/ /* 0.001*/;  
+  float learning_rate = 0.01; /* 0.00001*/ /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -771,7 +773,7 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
 }
 
 #if 1
-HIDE_TEST(_first_learn_vehicle_50__11){
+TEST(_first_learn_vehicle_50__11){
   size_t nb_block = 7;
   size_t dim= 2;
   struct blocks * path = create_blocks(nb_block, dim);
@@ -873,15 +875,16 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   struct vehicle *car = create_vehicle(path);
 
   config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,24,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
-  //config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,14,14,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
+  //config_layers *pconf = create_config_layers_from_OneD(3,(size_t[]){3,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
   
   bool randomize=true; 
   float minR = -0.5, maxR = 0.5;  
+  //float minR = 0, maxR = 1;  
   int randomRange = 500;
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
-  float learning_rate = 0; /* 0.000001*/ /* 0.001*/;  
+  float learning_rate = 0.0007 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -894,8 +897,8 @@ EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, wei
 
 //EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20250508_17h50m56s_26300.txt");
 //EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_17h50m56s_26300.txt");
-EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_.symlink");
+///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_.symlink");
-EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_.symlink");
+///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_.symlink");
 /*
 EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20250508_23h02m40s_29000.txt");
 EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_23h02m40s_29000.txt");
@@ -910,7 +913,7 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
     0.95/*float gamma*/,
     learning_rate,
     0 /* (not used!)float discount_factor*/,
-    0.0001/*0.99*/  /*float exploration_factor*/,
+    1.0/*0.99*//*0.0001*//*0.99*/  /*float exploration_factor*/,
     20/*long int nb_training_before_update_weight_in_target*/,
     10000/*size_t number_episodes*/
   );
@@ -1086,7 +1089,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.0000001 /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -1233,7 +1236,7 @@ HIDE_TEST(__first_learn_vehicle13){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -1371,7 +1374,7 @@ HIDE_TEST(first_learn_vehicle){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -1482,7 +1485,7 @@ HIDE_TEST(first_learn_vehicle){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -2006,7 +2009,7 @@ HIDE_TEST(first_learn_vehicle_rev50_8){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.001; // 0.00001 /*0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -2170,7 +2173,7 @@ HIDE_TEST(first_learn_vehicle_50__9){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.00001 /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -2340,7 +2343,7 @@ HIDE_TEST(first_learn_vehicle_50__10){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.00001 /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -2512,7 +2515,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0; /* 0.000001*/ /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -2691,7 +2694,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.0000001 /* 0.001*/;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -2813,7 +2816,7 @@ HIDE_TEST(_first_learn_vehicle13){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -2951,7 +2954,7 @@ HIDE_TEST(first_learn_vehicle){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,
@@ -3062,7 +3065,7 @@ HIDE_TEST(first_learn_vehicle){
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
   float learning_rate = 0.1;  
-  struct networks_qlearning *nnetworks = create_nework_qlearning(
+  struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
     nb_prod_thread, nb_calc_thread,