update: [tensor] add transpose optimized function and tests

tranfert learning find quickly a path (less crash) but from scratch learning find optimal path (shorter and faster)

deepQlearn_0/src/deepQlearning/learn_to_drive.c

@@ -74,13 +74,14 @@ struct networks_qlearning * create_network_qlearning(
   setup_networks_alloutputs_config_TYPE_FLOAT(&(qnets->best_net), config, false, minR, maxR, randomRange);  
   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, tensorContractnProdThreadOpt0_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
+  //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, tensorContractnProdThreadOpt0_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, tensorContractnProdThreadOpt0_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);
 
@@ -276,6 +277,7 @@ void free_RL_agent(struct RL_agent *rlAgent){
 }
 
 #define ACCEPTABLE_REWARD 1000
+#define VERY_GOOD_REWARD 10000
 
 #define UPDATE_PARAMS 1
 #define UPDATE_EXPLOR_FAC 1
@@ -322,7 +324,8 @@ void train_qlearning(struct RL_agent * rlAgent,
 #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);
+	  if(car_status->cumulative_reward > VERY_GOOD_REWARD) new_value = (net_main->learning_rate ) * qlParams->factor_update_learning_rate ;
+    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 ;

tensor_t/src/tensor_t/tensor_t.c

@@ -671,7 +671,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
 \
     size_t len0 = M0->dim->size - contractionNumber;\
@@ -749,7 +749,7 @@ void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tenso
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
 \
     size_t len0 = M0->dim->size - contractionNumber;\
@@ -992,7 +992,7 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
@@ -1089,7 +1089,7 @@ void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0,
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
@@ -1196,7 +1196,7 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
 \
     size_t len0 = M0->dim->size - contractionNumber;\
@@ -1296,7 +1296,7 @@ void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
 \
     size_t len0 = M0->dim->size - contractionNumber;\
@@ -1355,7 +1355,7 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
         printf("error Deep = %ld\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
-        getchar();\
+        /*getchar();*/\
     }\
     size_t len0 = M0->dim->size - contractionNumber;\
     size_t len1 = M1->dim->size - contractionNumber;\
@@ -1977,6 +1977,40 @@ tensor_##type * transpose_notOpt_tensor_##type(tensor_##type *org){\
   return tens_tr;\
 }\
 \
+tensor_##type * transpose_Opt0_tensor_##type(tensor_##type *org){\
+  size_t dimsz = (org->dim)->size; \
+  dimension *dim_tr=create_dim(dimsz);\
+  for(size_t i=0; i<dimsz; ++i) dim_tr->perm[i]=(org->dim)->perm[(dimsz-1)-i];\
+  updateRankDim(dim_tr);\
+  printDebug_dimension(dim_tr,"dim_trOpt");\
+  tensor_##type *tens_tr = CREATE_TENSOR_##type(dim_tr);\
+  long int base_i[dimsz+1];/* = (org->dim)->size;*/ \
+	base_i[dimsz]=1;/*(org->dim)->perm[dimsz-1];*/\
+	/*printf("DEBUG: base_i[%ld]=%ld\n",dimsz,base_i[dimsz]);*/\
+  for(long int j=dimsz-1; j>=0; --j) { \
+		base_i[j] =base_i[j+1]*(org->dim)->perm[j];\
+		/*printf("DEBUG: base_i[%ld]=%ld\n",j,base_i[j]);*/\
+	}\
+	long int cur_tr=0, add_tr=0, minus_tr=0;\
+	tens_tr->x[cur_tr] = org->x[cur_tr];\
+  for(size_t i=1; i<dim_tr->rank; ++i){\
+		minus_tr =0;\
+		/*printf("DEBUG: cur_tr=%ld\n",cur_tr);*/\
+		for(size_t l=0; l<dimsz; ++l){			\
+			add_tr = minus_tr + base_i[l+1];\
+			if(cur_tr + add_tr < base_i[l]){\
+				cur_tr += add_tr;\
+				/*tens_tr->x[cur_tr] = org->x[i]*/;\
+				tens_tr->x[i] = org->x[cur_tr];\
+				break;\
+			}\
+			minus_tr -= (base_i[l]-base_i[l+1]);\
+		}\
+		/*printf("DEBUG: after cur_tr=%ld\n",cur_tr);*/\
+  }\
+  return tens_tr;\
+}\
+\
 tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dperm){\
   size_t dimsz = (org->dim)->size; \
   dimension *dim_tr=create_dim(dimsz);\

tensor_t/src/tensor_t/tensor_t.h

@@ -62,6 +62,7 @@ void append_array_chainlist_##type(array_chainlist_##type **list_a, type x);\
 tensor_##type * create_tensor_from_list_array_##type( array_chainlist_##type *l_a, dimension *part_dim);\
 void free_array_chainlist_##type(array_chainlist_##type *l_a);\
 tensor_##type * transpose_notOpt_tensor_##type(tensor_##type *org);\
+tensor_##type * transpose_Opt0_tensor_##type(tensor_##type *org);\
 tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dperm);\
 void update_1tensor_func_##type(tensor_##type *M0, \
     type (*func)(type), size_t nbthread);\

tensor_t/test/is_good.c

@@ -17,7 +17,7 @@
 //#include "permutation_t/permutation_t.h"
 #include "tensor_t/tensor_t.h"
 
-#define VALGRIND_ 0
+#define VALGRIND_ 1
 
 TEST(rank){
   endian =true;
@@ -911,7 +911,7 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3endianFalse ){
   d0->perm[1]=2; //3;
   d0->perm[2]=3;
 
-  d1->perm[0]=4;
+  d1->perm[0]=3;
   d1->perm[1]=2;//3;
   d1->perm[2]=5;
 
@@ -922,7 +922,7 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3endianFalse ){
   d0->perm[1]=12; //3;
   d0->perm[2]=35;
 
-  d1->perm[0]=32;
+  d1->perm[0]=35;
   d1->perm[1]=12;//3;
   d1->perm[2]=13;
 #endif
@@ -2168,6 +2168,67 @@ TEST(transpose_parseInput_unknownpart_to_tensor){
   free_tensor_TYPE_FLOAT(t);
   free_tensor_TYPE_FLOAT(transpose);
 }
+TEST(transpose_input_to_OpT_Ranspose){
+  endian=true;
+  char *input="[*,3]"\
+               "((1.1,1.2,1.3)"\
+               "((2.1,2.2,2.3)"\
+               "((3.1,3.2,3.3)"\
+               "((4.1,4.2,4.3)"\
+               "((5.1,5.2,5.3)"\
+               "((6.1,6.2,6.3)"\
+               "(7.1,7.2,7.3)) ";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+
+  tensor_TYPE_FLOAT *transpose = transpose_notOpt_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose," transpose from input" );
+  tensor_TYPE_FLOAT *transpose_Opt0 = transpose_Opt0_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose_Opt0," transpose_Opt0 from input" );
+
+	EXPECT_ARRAY_EQ_TYPE_FLOAT(transpose->x,transpose->dim->rank ,transpose_Opt0->x,transpose_Opt0->dim->rank);
+
+  free_tensor_TYPE_FLOAT(t);
+  free_tensor_TYPE_FLOAT(transpose);
+  free_tensor_TYPE_FLOAT(transpose_Opt0);
+}
+
+TEST(transpose_input_to_OpT_Ranspose2){
+  endian=true;
+  char *input="[*,4,3]"\
+               "(((1.11,1.12,1.13),(1.21,1.22,1.23),(1.31,1.32,1.33),(1.41,1.42,1.43)),"\
+               "((2.11,2.12,2.13),(2.21,2.22,2.23),(2.31,2.32,2.33),(2.41,2.42,2.43)),"\
+               "((3.11,3.12,3.13),(3.21,3.22,3.23),(3.31,3.32,3.33),(3.41,3.42,3.43)),"\
+               "((4.11,4.12,4.13),(4.21,4.22,4.23),(4.31,4.32,4.33),(4.41,4.42,4.43)),"\
+               "((5.11,5.12,5.13),(5.21,5.22,5.23),(5.31,5.32,5.33),(5.41,5.42,5.43)),"\
+               "((6.11,6.12,6.13),(6.21,6.22,6.23),(6.31,6.32,6.33),(6.41,6.42,6.43)),"\
+               "((7.11,7.12,7.13),(7.21,7.22,7.23),(7.31,7.32,7.33),(7.41,7.42,7.43)),"\
+               "((8.11,8.12,8.13),(8.21,8.22,8.23),(8.31,8.32,8.33),(8.41,8.42,8.43)),"\
+               "((9.11,9.12,9.13),(9.21,9.22,9.23),(9.31,9.32,9.33),(9.41,9.42,9.43)),"\
+               "((10.11,10.12,10.13),(10.21,10.22,10.23),(10.31,10.32,10.33),(10.41,10.42,10.43)),"\
+               "((11.11,11.12,11.13),(11.21,11.22,11.23),(11.31,11.32,11.33),(11.41,11.42,11.43)),"\
+               "((12.11,12.12,12.13),(12.21,12.22,12.23),(12.31,12.32,12.33),(12.41,12.42,12.43)),"\
+               "((13.11,13.12,13.13),(13.21,13.22,13.23),(13.31,13.32,13.33),(13.41,13.42,13.43)))";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+
+  tensor_TYPE_FLOAT *transpose = transpose_notOpt_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose," transpose from input" );
+  tensor_TYPE_FLOAT *transpose_Opt0 = transpose_Opt0_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose_Opt0," transpose_Opt0 from input" );
+
+	EXPECT_ARRAY_EQ_TYPE_FLOAT(transpose->x,transpose->dim->rank ,transpose_Opt0->x,transpose_Opt0->dim->rank);
+
+  free_tensor_TYPE_FLOAT(t);
+  free_tensor_TYPE_FLOAT(transpose);
+  free_tensor_TYPE_FLOAT(transpose_Opt0);
+}
 TEST(permute_parseInput_unknownpart_to_tensor){
   endian=true;
   char *input="[*,3]"\

y_network_neural_network_/test/is_good.c

@@ -773,14 +773,14 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
 
 }
 
-HIDE_TEST(extract_with_pconf){
+TEST(extract_with_pconf){
   size_t nb_block = 7;
   size_t dim= 2;
   struct blocks * path = create_blocks(nb_block, dim);
 
   LOG("debug: f_name = %s\n", __func__);
 
-#if 1
+#if 0
 
   copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   copy_coordinate(path->upper_bound_block[0], (float[]){100,250});
@@ -798,8 +798,9 @@ HIDE_TEST(extract_with_pconf){
   copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
  
 
+#else 
+#if 0
 
-/*
 
   copy_coordinate(path->lower_bound_block[4], (float[]){0,0});
   copy_coordinate(path->upper_bound_block[4], (float[]){150,250});
@@ -816,10 +817,10 @@ HIDE_TEST(extract_with_pconf){
   copy_coordinate(path->lower_bound_block[5], (float[]){0,250});
   copy_coordinate(path->upper_bound_block[5], (float[]){410,300});
 
+#else
+#if 0
 
-
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
-
-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});
   copy_coordinate(path->upper_bound_block[1], (float[]){250,150});
@@ -834,7 +835,28 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
   copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
 
+#else
+#if 1
 
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){60,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){60,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,50});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,20});
+  copy_coordinate(path->upper_bound_block[2], (float[]){310,80});
+  copy_coordinate(path->lower_bound_block[3], (float[]){310,40});
+  copy_coordinate(path->upper_bound_block[3], (float[]){450,90});
+  copy_coordinate(path->lower_bound_block[4], (float[]){450,60});
+  copy_coordinate(path->upper_bound_block[4], (float[]){560,220});
+  copy_coordinate(path->lower_bound_block[5], (float[]){430,220});
+  copy_coordinate(path->upper_bound_block[5], (float[]){560,280});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){430,300});
+
+
+
+#else
+#if 0
 
   copy_coordinate(path->lower_bound_block[0], (float[]){0,300});
   copy_coordinate(path->upper_bound_block[0], (float[]){400,700});
@@ -850,7 +872,6 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   copy_coordinate(path->upper_bound_block[5], (float[]){1100,975});
   copy_coordinate(path->lower_bound_block[6], (float[]){100,700});
   copy_coordinate(path->upper_bound_block[6], (float[]){800,975});
- */
 
 #else
 
@@ -870,6 +891,10 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   copy_coordinate(path->upper_bound_block[6], (float[]){8,9.75});
  
  
+#endif
+#endif
+#endif
+#endif
 #endif
 
   update_bounds_limits_blocks(path);
@@ -885,7 +910,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   int randomRange = 500;
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
-  float learning_rate = 0.0007 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
+  float learning_rate = 0.007 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
   struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
@@ -979,7 +1004,7 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
   struct arg_run_qlearn_bprint *argQL_BP =   create_arg_run_qlearn_bprint(bash_arg, rlAgent);
 
   struct arg_var_ * var = create_arg_var_(y_nnn_manager_handle_input, argQL_BP);
-  struct y_socket_t *argS = y_socket_create("1600", 2, 3, var);
+  struct y_socket_t *argS = y_socket_create("1609", 2, 3, var);
  
 
   pthread_t pollTh;
@@ -1006,7 +1031,7 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
 
 
 
-TEST(Transfert_learn_mini_learn){
+HIDE_TEST(Transfert_learn_mini_learn){
   size_t nb_block = 7;
   size_t dim= 2;
   struct blocks * path = create_blocks(nb_block, dim);
@@ -1031,7 +1056,7 @@ TEST(Transfert_learn_mini_learn){
   copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
  
 #else
-#if 1
+#if 0
 
 
   copy_coordinate(path->lower_bound_block[4], (float[]){0,0});
@@ -1051,7 +1076,7 @@ TEST(Transfert_learn_mini_learn){
 
 
 #else
-#if 0
+#if 1
 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});
@@ -1122,7 +1147,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
   int randomRange = 500;
   size_t nb_prod_thread = 2;
   size_t nb_calc_thread = 4;
-  float learning_rate = 0.000001 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
+  float learning_rate = 0.00001 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
   struct networks_qlearning *nnetworks = create_network_qlearning(
     pconf,
     randomize, minR, maxR,  randomRange,
@@ -1136,8 +1161,8 @@ EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, wei
   struct main_list_ptr_DIMENSION *m_l_dim=create_var_list_ptr_DIMENSION();
   //struct main_list_dimension *m_l_dim=create_var_list_dimension();
 
-EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_TEST_extract_with_pconf____9.symlink",m_l_dim);
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_learnDir/.ff_main_TEST_extract_with_pconf____9;1770646800;2400;",m_l_dim);
-EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_TEST_extract_with_pconf____9.symlink",m_l_dim);
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_learnDir/.ff_target_TEST_extract_with_pconf____9;1770646800;2400;",m_l_dim);
  
  for(struct list_ptr_DIMENSION *local_l_dim=m_l_dim->begin_list; local_l_dim; local_l_dim=local_l_dim->next){
    size_t i=local_l_dim->index;
@@ -1182,7 +1207,7 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
     0.95/*float gamma*/,
     learning_rate,
     0 /* (not used!)float discount_factor*/,
-    0.000001/*1.0*//*0.99*//*0.0001*//*0.99*/  /*float exploration_factor*/,
+    0.0001/*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*/
   );
@@ -1217,7 +1242,269 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
   struct arg_run_qlearn_bprint *argQL_BP =   create_arg_run_qlearn_bprint(bash_arg, rlAgent);
 
   struct arg_var_ * var = create_arg_var_(y_nnn_manager_handle_input, argQL_BP);
-  struct y_socket_t *argS = y_socket_create("1600", 2, 3, var);
+  struct y_socket_t *argS = y_socket_create("1613", 2, 3, var);
+ 
+
+  pthread_t pollTh;
+  pthread_create(&pollTh, NULL, y_socket_poll_fds, (void*)argS);
+
+
+
+
+
+
+
+  pthread_join(pollTh, NULL);
+	//pthread_join(thread_learn, NULL);
+  
+  y_socket_free(argS);
+  free_arg_var_(var);
+  free_arg_run_qlearn_bprint(argQL_BP);
+  //free_RL_agent(rlAgent);
+
+
+
+
+}
+
+
+
+TEST(transfertlearning_extract_with_pconf){
+  size_t nb_block = 7;
+  size_t dim= 2;
+  struct blocks * path = create_blocks(nb_block, dim);
+
+  LOG("debug: f_name = %s\n", __func__);
+
+#if 0
+
+  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 
+#if 0
+
+
+  copy_coordinate(path->lower_bound_block[4], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[4], (float[]){150,250});
+  copy_coordinate(path->lower_bound_block[3], (float[]){150,40});
+  copy_coordinate(path->upper_bound_block[3], (float[]){250,150});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,80});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,200});
+  copy_coordinate(path->lower_bound_block[1], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[1], (float[]){600,150});
+  copy_coordinate(path->lower_bound_block[0], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[0], (float[]){760,300});
+  copy_coordinate(path->lower_bound_block[6], (float[]){260,300});
+  copy_coordinate(path->upper_bound_block[6], (float[]){760,360});
+  copy_coordinate(path->lower_bound_block[5], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[5], (float[]){410,300});
+
+#else
+#if 0
+
+  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});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,150});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,80});
+  copy_coordinate(path->upper_bound_block[2], (float[]){360,200});
+  copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
+  copy_coordinate(path->upper_bound_block[3], (float[]){600,170});
+  copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
+  copy_coordinate(path->upper_bound_block[4], (float[]){760,300});
+  copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
+  copy_coordinate(path->upper_bound_block[5], (float[]){760,350});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
+
+#else
+#if 1
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
+  copy_coordinate(path->upper_bound_block[0], (float[]){60,250});
+  copy_coordinate(path->lower_bound_block[1], (float[]){60,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){250,50});
+  copy_coordinate(path->lower_bound_block[2], (float[]){250,20});
+  copy_coordinate(path->upper_bound_block[2], (float[]){310,80});
+  copy_coordinate(path->lower_bound_block[3], (float[]){310,40});
+  copy_coordinate(path->upper_bound_block[3], (float[]){450,90});
+  copy_coordinate(path->lower_bound_block[4], (float[]){450,60});
+  copy_coordinate(path->upper_bound_block[4], (float[]){560,220});
+  copy_coordinate(path->lower_bound_block[5], (float[]){430,220});
+  copy_coordinate(path->upper_bound_block[5], (float[]){560,280});
+  copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
+  copy_coordinate(path->upper_bound_block[6], (float[]){430,300});
+
+
+
+
+#else
+#if 1
+
+  copy_coordinate(path->lower_bound_block[0], (float[]){0,300});
+  copy_coordinate(path->upper_bound_block[0], (float[]){400,700});
+  copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
+  copy_coordinate(path->upper_bound_block[1], (float[]){1000,300});
+  copy_coordinate(path->lower_bound_block[2], (float[]){1000,50});
+  copy_coordinate(path->upper_bound_block[2], (float[]){1400,500});
+  copy_coordinate(path->lower_bound_block[3], (float[]){1400,200});
+  copy_coordinate(path->upper_bound_block[3], (float[]){1800,700});
+  copy_coordinate(path->lower_bound_block[4], (float[]){1100,700});
+  copy_coordinate(path->upper_bound_block[4], (float[]){1700,1000});
+  copy_coordinate(path->lower_bound_block[5], (float[]){800,600});
+  copy_coordinate(path->upper_bound_block[5], (float[]){1100,975});
+  copy_coordinate(path->lower_bound_block[6], (float[]){100,700});
+  copy_coordinate(path->upper_bound_block[6], (float[]){800,975});
+
+#else
+
+  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});
+  copy_coordinate(path->upper_bound_block[1], (float[]){10,3});
+  copy_coordinate(path->lower_bound_block[2], (float[]){10,0.5});
+  copy_coordinate(path->upper_bound_block[2], (float[]){14,5});
+  copy_coordinate(path->lower_bound_block[3], (float[]){14,2});
+  copy_coordinate(path->upper_bound_block[3], (float[]){18,7});
+  copy_coordinate(path->lower_bound_block[4], (float[]){11,7});
+  copy_coordinate(path->upper_bound_block[4], (float[]){17,10});
+  copy_coordinate(path->lower_bound_block[5], (float[]){8,6});
+  copy_coordinate(path->upper_bound_block[5], (float[]){11,9.75});
+  copy_coordinate(path->lower_bound_block[6], (float[]){1,7});
+  copy_coordinate(path->upper_bound_block[6], (float[]){8,9.75});
+ 
+ 
+#endif
+#endif
+#endif
+#endif
+#endif
+
+  update_bounds_limits_blocks(path);
+
+  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(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.0001;  // 0.0007 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;  
+  struct networks_qlearning *nnetworks = create_network_qlearning(
+    pconf,
+    randomize, minR, maxR,  randomRange,
+    nb_prod_thread, nb_calc_thread,
+    learning_rate
+  );
+/*
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20240717_01h42m16s_5300.txt");
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20240717_01h42m16s_5300.txt");
+*/
+  struct main_list_ptr_DIMENSION *m_l_dim=create_var_list_ptr_DIMENSION();
+  //struct main_list_dimension *m_l_dim=create_var_list_dimension();
+
+//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_learnDir/.ff_main_TEST_extract_with_pconf____9;1770646800;2400;",m_l_dim);
+//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_learnDir/.ff_target_TEST_extract_with_pconf____9;1770646800;2400;",m_l_dim);
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_learnDir/.ff_main_TEST_extract_with_pconf____9;1770675296;1044700;",m_l_dim);
+EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS_PCONF(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_learnDir/.ff_target_TEST_extract_with_pconf____9;1770675296;1044700;",m_l_dim);
+ 
+ for(struct list_ptr_DIMENSION *local_l_dim=m_l_dim->begin_list; local_l_dim; local_l_dim=local_l_dim->next){
+   size_t i=local_l_dim->index;
+   char msg[50]; sprintf(msg, " DIM[%ld] ",i);
+   printDebug_dimension((local_l_dim->value), msg);
+ }
+ LOG("%s","=========================================="); 
+  config_layers *base_conf=create_config_layers_from_weight_in_neurons_TYPE_FLOAT(nnetworks->main_net);
+  config_layers *p_conf=create_config_layers_from_m_list_ptr_DIMENSION(m_l_dim);
+  //config_layers *p_conf=create_config_layers_from_m_list_dimension(m_l_dim);
+
+  if(cmp_config_layers(p_conf, base_conf)==0){
+    LOG("base_conf == %s\n","p_conf");
+    
+  }else{
+    LOG("base_conf != %s\n","p_conf");
+
+  }
+LOG("%s ", "base_conf"); print_config_layers(base_conf);
+LOG("%s ", "p_conf"); print_config_layers(p_conf);
+free_config_layers(base_conf);
+free_config_layers(p_conf);
+//free_all_var_list_dimension(m_l_dim);
+///free_all_var_list_ptr_DIMENSION(m_l_dim);
+//remove_all_ptr_type_list_ptr_DIMENSION(m_l_dim);
+purge_ptr_type_list_ptr_DIMENSION(m_l_dim);
+
+//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->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");
+*/
+struct status_qlearning *qlstatus = create_status_qlearning ();
+  struct delay_params *dly = create_delay_params (
+    500/*size_t delay_between_episodes*/,
+    50/*size_t delay_between_games*/
+  );
+  
+  struct qlearning_params *qlparams = create_qlearning_params (
+    0.95/*float gamma*/,
+    learning_rate,
+    0 /* (not used!)float discount_factor*/,
+    0.01/*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*/
+  );
+/*   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 );
+*/
+  qlparams->caller_func_name=malloc(strlen(__func__)+1);
+  strcpy(qlparams->caller_func_name, __func__);
+
+
+  struct print_params *pprint = create_print_params(
+    12/*float scale_x*/,12 /*float scale_y*/,  
+    dly/*struct delay_params * dly_p*/
+  );
+
+  struct RL_agent *rlAgent = create_RL_agent (
+    nnetworks /*struct networks_qlearning * networks*/,
+    car /*struct vehicle *  car*/,
+    qlstatus /*struct status_qlearning * status*/,
+    pprint /*struct print_params * pprint*/,
+    qlparams/*struct qlearning_params *qlearnParams*/
+  );
+
+
+  //learn_to_drive(rlAgent);
+ 	//learn_to_drive(rlAgent);
+  
+	struct arg_bash *bash_arg= create_arg_bash();
+
+  struct arg_run_qlearn_bprint *argQL_BP =   create_arg_run_qlearn_bprint(bash_arg, rlAgent);
+
+  struct arg_var_ * var = create_arg_var_(y_nnn_manager_handle_input, argQL_BP);
+  struct y_socket_t *argS = y_socket_create("1621", 2, 3, var);
  
 
   pthread_t pollTh;

y_socket_t/src/y_socket_t/y_list_var_tool.c

@@ -193,6 +193,6 @@ void usage_cmdl(){
   "\t\t\tNeed to add \"seq\" and \"tm\" keys to have good handling, the payload is after the header {}\n"
   "\t\t\tSee y_socket_send_file_for_node function.\n"
   "\t\tpost ok [filenameid]: to acknowledge receipt [filename].\n"
-  "\t\t\t[filenameid] is to precise witch [filename] (file name from whom and when)\n"
+  "\t\t\t[filenameid] is to precise wich [filename] (file name from whom and when)\n"
   );
 }