add cloneuronset to parrallel learning in batch

neuron_t/src/neuron_t/neuron_t.c

@@ -1,8 +1,43 @@
 #include "neuron_t/neuron_t.h"
 
+#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
+
+#define ABSMAX(X, Y) ((((X) > (Y)) || ((-X) > (Y))  ) ? (X) : (Y))
 
 #define PR_LINE printf("===================================================== \n");
 
+config_layers *create_config_layers(size_t nb_layers, size_t *sz_layers, size_t **array_dim_in_layers){
+  config_layers *pconf=malloc(sizeof(config_layers));
+   pconf->nb_layers=nb_layers;
+   pconf->sz_layers=malloc(nb_layers * sizeof(size_t));
+   pconf->array_dim_in_layers=malloc(nb_layers*sizeof(size_t*));
+   for(size_t i=0; i<nb_layers; ++i){
+    pconf->sz_layers[i]=sz_layers[i];
+    pconf->array_dim_in_layers[i]=malloc(sz_layers[i]*sizeof(size_t));
+    for(size_t j=0; j<sz_layers[i];++j)
+      pconf->array_dim_in_layers[i][j]=array_dim_in_layers[i][j];
+   }
+   return pconf;
+}
+config_layers *create_config_layers_from_OneD(size_t nb_layers, size_t *array_dim_in_layers){
+   config_layers *pconf=malloc(sizeof(config_layers));
+   pconf->nb_layers=nb_layers;
+   pconf->sz_layers=malloc(nb_layers * sizeof(size_t));
+   pconf->array_dim_in_layers=malloc(nb_layers*sizeof(size_t*));
+   for(size_t i=0; i<nb_layers; ++i){
+    pconf->sz_layers[i]=1;
+    pconf->array_dim_in_layers[i]=malloc(sizeof(size_t));
+    pconf->array_dim_in_layers[i][0]=array_dim_in_layers[i];
+   }
+   return pconf;
+}
+
+void free_config_layers(config_layers *pconf){
+  for(size_t i=0; i<pconf->nb_layers;++i) free(pconf->array_dim_in_layers[i]);
+  free(pconf->array_dim_in_layers);
+  free(pconf->sz_layers);
+  free(pconf);
+} 
 
 #define GEN_NEURONS_F_(type)\
   \
@@ -73,17 +108,20 @@ void calc_delta_neurons_##type(neurons_##type *nr){\
   }\
 }\
 void update_weight_neurons_##type(neurons_##type *nr){\
-  tensor_##type *tmp_e_w=NULL;\
+  nr->TensorProduct(&(nr->weight_out), nr->input, nr->delta_out, nr->nb_prod_thread);\
+  /*tensor_##type *tmp_e_w=NULL;\
   nr->TensorProduct(&(tmp_e_w), nr->input, nr->delta_out, nr->nb_prod_thread);\
-  /*print_tensor_msg_##type(nr->input," nr input  update wei");*/\
+  *//*print_tensor_msg_##type(nr->input," nr input  update wei");*/\
   /*print_tensor_msg_##type(nr->delta_out," nr delta_out  update wei");*/\
   /*print_tensor_msg_##type(tmp_e_w," tmp_e_w  update wei");*/\
   \
   for(size_t i = 0; i<(nr->weight_in)->dim->rank; ++i){\
-    (nr->weight_in)->x[i]= (nr->weight_in)->x[i] - nr->learning_rate *tmp_e_w->x[i] ;\
+    /*(nr->weight_in)->x[i]= (nr->weight_in)->x[i] - nr->learning_rate *tmp_e_w->x[i] ;\
+    */(nr->weight_in)->x[i]= (nr->weight_in)->x[i] - nr->learning_rate * (nr->weight_out)->x[i] ;\
   }\
   /*print_tensor_msg_##type(nr->weight_in," weight_in  updated ");*/\
-  free_tensor_##type(tmp_e_w);\
+  /*free_tensor_##type(tmp_e_w);\
+  */\
 }\
 void init_in_out_all_networks_##type(neurons_##type *nr, tensor_##type *in, tensor_##type *out){\
   if(((nr->input)->dim)->rank == (in->dim)->rank)\
@@ -115,7 +153,6 @@ void link_layers_##type(neurons_##type *nPrev, neurons_##type *nNext ){\
 }\
 \
 \
-\
 void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers){\
   neurons_##type *tmp_l=NULL, *ttmp_l=NULL;\
   for(size_t l=0; l<nb_layers; ++l){\
@@ -154,7 +191,7 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_d
           dimension *d_w_in;  \
           add_dimension(&d_w_in, (ttmp_l->input)->dim, ((ttmp_l->output)->dim)); \
           ttmp_l->weight_in = CREATE_TENSOR_##type(d_w_in);\
-          for(size_t i=0;i<((ttmp_l->weight_in)->dim)->rank;++i) (ttmp_l->weight_in)->x[i]=0.01;\
+          for(size_t i=0;i<((ttmp_l->weight_in)->dim)->rank;++i) (ttmp_l->weight_in)->x[i]=0.5;\
           /*init_random_x_##type(ttmp_l->weight_in,0,1,5000);\
           */\
       }\
@@ -171,7 +208,7 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_d
         dimension *d_w_in;  \
         add_dimension(&d_w_in, (tmp_l->input)->dim, ((tmp_l->output)->dim)); \
         tmp_l->weight_in = CREATE_TENSOR_##type(d_w_in);\
-        for(size_t i=0;i<((tmp_l->weight_in)->dim)->rank;++i) (tmp_l->weight_in)->x[i]=0.01;\
+        for(size_t i=0;i<((tmp_l->weight_in)->dim)->rank;++i) (tmp_l->weight_in)->x[i]=0.5;\
         /*init_random_x_##type(tmp_l->weight_in,0,1,5000);\
         */\
       }\
@@ -185,6 +222,93 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_d
   }\
 }\
 \
+\
+void setup_networks_layers_without_weights_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers){\
+  neurons_##type *tmp_l=NULL, *ttmp_l=NULL;\
+  for(size_t l=0; l<nb_layers; ++l){\
+    tmp_l = malloc(sizeof(neurons_##type)); \
+    if(l==0){\
+      *base_nr = tmp_l ;\
+    }else{\
+      ttmp_l->next_layer = tmp_l ;\
+    }\
+    tmp_l->id_layer= l;\
+    tmp_l->input = NULL; \
+    tmp_l->net = NULL; \
+    tmp_l->output = NULL; \
+    tmp_l->target = NULL; \
+    tmp_l->weight_in = NULL; \
+    tmp_l->weight_out = NULL; \
+    tmp_l->delta_out = NULL; \
+    tmp_l->bias = NULL;  \
+    tmp_l->prev_layer = ttmp_l;\
+    tmp_l->next_layer = NULL;\
+    \
+    if(ttmp_l != NULL){\
+      dimension *dim=init_copy_dim(array_dim_in_layers[l-1],sz_layers[l-1]);\
+      increment_dim_var(dim);\
+      tmp_l->input = CREATE_TENSOR_##type(dim);\
+      for(size_t i=0;i<((tmp_l->input)->dim)->rank;++i) (tmp_l->input)->x[i]=(type)l;\
+      \
+      link_layers_##type(ttmp_l,tmp_l);\
+      if(l>1 ){\
+          dimension *dim_out = (ttmp_l->output)->dim;\
+          for(size_t i=0;i<dim_out->rank; ++i) (ttmp_l->output)->x[i]=(type)(l-1);\
+          ttmp_l->net = CREATE_TENSOR_FROM_CPY_DIM_##type(dim_out);\
+          for(size_t i=0;i<dim_out->rank; ++i) (ttmp_l->net)->x[i]=(type)(l-1);\
+          ttmp_l->delta_out = CREATE_TENSOR_FROM_CPY_DIM_##type(dim_out); \
+          for(size_t i=0;i< dim_out->rank; ++i) (ttmp_l->delta_out)->x[i]=(type)(l-1);\
+          /*dimension *d_w_in;  \
+          add_dimension(&d_w_in, (ttmp_l->input)->dim, ((ttmp_l->output)->dim)); \
+          ttmp_l->weight_in = CREATE_TENSOR_##type(d_w_in);\
+          for(size_t i=0;i<((ttmp_l->weight_in)->dim)->rank;++i) (ttmp_l->weight_in)->x[i]=0.01;\
+          *//*init_random_x_##type(ttmp_l->weight_in,0,1,5000);\
+          */\
+      }\
+      if(l==nb_layers-1) {\
+        dimension *dim_out=init_copy_dim(array_dim_in_layers[l],sz_layers[l]);\
+        tmp_l->output = CREATE_TENSOR_##type(dim_out);\
+        for(size_t i=0;i<((tmp_l->output)->dim)->rank;++i) (tmp_l->output)->x[i]=(type)l;\
+        tmp_l->target = CREATE_TENSOR_FROM_CPY_DIM_##type(dim_out);\
+        for(size_t i=0;i<((tmp_l->target)->dim)->rank;++i) (tmp_l->target)->x[i]=(type)(l);\
+        tmp_l->net = CREATE_TENSOR_FROM_CPY_DIM_##type(dim_out);\
+        for(size_t i=0;i<((tmp_l->net)->dim)->rank;++i) (tmp_l->net)->x[i]=(type)(l);\
+        tmp_l->delta_out = CREATE_TENSOR_FROM_CPY_DIM_##type(dim_out); \
+        for(size_t i=0;i<((tmp_l->delta_out)->dim)->rank;++i) (tmp_l->delta_out)->x[i]=(type)(l);\
+        /*dimension *d_w_in;  \
+        add_dimension(&d_w_in, (tmp_l->input)->dim, ((tmp_l->output)->dim)); \
+        tmp_l->weight_in = CREATE_TENSOR_##type(d_w_in);\
+        for(size_t i=0;i<((tmp_l->weight_in)->dim)->rank;++i) (tmp_l->weight_in)->x[i]=0.01;\
+        *//*init_random_x_##type(tmp_l->weight_in,0,1,5000);\
+        */\
+      }\
+     \
+    }\
+\
+    ttmp_l = tmp_l;\
+    \
+ \
+\
+  }\
+}\
+\
+\
+void setup_weights_neurons_##type(neurons_##type *base, bool randomize, type minR, type maxR,  int randomRange){\
+  neurons_##type *tmp_l=base->next_layer;\
+  while(tmp_l){\
+    dimension *d_w_in;  \
+    add_dimension(&d_w_in, (tmp_l->input)->dim, ((tmp_l->output)->dim)); \
+    tmp_l->weight_in = CREATE_TENSOR_##type(d_w_in);\
+    if(randomize){\
+        init_random_x_##type(tmp_l->weight_in,minR, maxR, randomRange);\
+    }else{\
+        for(size_t i=0;i<((tmp_l->weight_in)->dim)->rank;++i) (tmp_l->weight_in)->x[i]=maxR;\
+    }\
+    tmp_l = tmp_l->next_layer;\
+  }\
+  \
+}\
+\
 void setup_networks_alloutputs_config_##type(neurons_##type **base_nr, config_layers *lconf){\
   setup_networks_alloutputs_##type(base_nr, lconf->array_dim_in_layers, lconf->sz_layers, lconf->nb_layers);\
 }\
@@ -269,49 +393,74 @@ void init_copy_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##
 \
 void init_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type *input, tensor_##type *target, neurons_##type *base){\
   if(is_equal_dim((base->output)->dim , input->dim)){\
-    nr->output = input ;\
+    for(size_t i=0;i<(input->dim)->rank;++i) (nr->output)->x[i]=input->x[i];\
+    /*nr->output = input ;*/\
   }\
   neurons_##type *tmp=nr;\
   while(tmp->next_layer) tmp=tmp->next_layer;\
   \
-  if(is_equal_dim((base->target)->dim, target->dim)){\
+  if(is_equal_dim((tmp->target)->dim, target->dim)){\
-      tmp->target = target; \
+    for(size_t i=0; i< (target->dim)->rank; ++i) {\
+      (tmp->target)->x[i] = target->x[i]; \
+      /*tmp->target = target;*/ \
+    }\
   }\
 }\
-neurons_##type * clone_neurons_base_from_input_target_tensors_##type(neurons_##type *base_nr, tensor_##type *input, tensor_##type *target){\
+void setup_networks_layers_without_weights_from_config_##type(neurons_##type **base, config_layers *pconf){\
-  neurons_##type *nr = malloc(sizeof(neurons_##type));\
+  setup_networks_layers_without_weights_##type(base, pconf->array_dim_in_layers, pconf->sz_layers, pconf->nb_layers);\
-  neurons_##type *tmpnr = nr, *tmpbs=base_nr, *prevLayer = NULL;\
+}\
-  while(tmpbs){\
+void unlink_all_weigth_in_neurons_##type(neurons_##type *nr){\
-    tmpnr->id_layer = tmpbs->id_layer;\
+  while(nr){\
-    tmpnr->nb_prod_thread = tmpbs->nb_prod_thread;\
+    nr->weight_in=NULL;\
-    tmpnr->learning_rate = tmpbs->learning_rate;\
+    nr=nr->next_layer;\
-    tmpnr->input  = CLONE_TENSOR_##type(tmpbs->input); \
-    tmpnr->net  = CLONE_TENSOR_##type(tmpbs->net); \
-    tmpnr->weight_in  = CLONE_TENSOR_##type(tmpbs->weight_in); \
-    tmpnr->bias  = CLONE_TENSOR_##type(tmpbs->bias); \
-    tmpnr->weight_out  = CLONE_TENSOR_##type(tmpbs->weight_out); \
-    tmpnr->delta_out  = CLONE_TENSOR_##type(tmpbs->delta_out); \
-    tmpnr->prev_layer = prevLayer;\
-    if(prevLayer)  {\
-      prevLayer->next_layer = tmpnr;\
-      tmpnr->output  = CLONE_TENSOR_##type(tmpbs->output); \
-    }else{\
-      tmpnr->output = NULL;\
-    }\
-    tmpnr->target  = NULL;\
-    prevLayer = tmpnr;\
-    tmpnr->TensorContraction = tmpbs->TensorContraction;\
-    tmpnr->TensorProduct = tmpbs->TensorProduct;\
-    tmpnr->dL = tmpbs->dL;\
-    tmpnr->L = tmpbs->L;\
-    tmpnr->f_act = tmpbs->f_act;\
-    tmpnr->d_f_act = tmpbs->d_f_act;\
-    if(tmpbs->next_layer) tmpnr->next_layer = malloc(sizeof(neurons_##type));\
-    else tmpnr->next_layer =NULL;\
-    tmpbs=tmpbs->next_layer;\
-    tmpnr=tmpnr->next_layer;\
   }\
-  return nr;\
+}\
+void free_cloneuronset_##type(cloneuronset_##type *clnrnst){\
+  for(size_t i=0; i < clnrnst->nb_clone; ++i) {\
+    unlink_all_weigth_in_neurons_##type(clnrnst->cloneurons[i]);\
+    free_neurons_##type(clnrnst->cloneurons[i]);\
+  }\
+  free_config_layers(clnrnst->conf);\
+}\
+void link_cloneuronset_weight_in_funcs_params_from_base_##type(cloneuronset_##type *clnrnst){\
+  neurons_##type **tmp_c=malloc(clnrnst->nb_clone * sizeof(neurons_##type *));\
+  for(size_t c=0; c<clnrnst->nb_clone; ++c){\
+    tmp_c[c]=clnrnst->cloneurons[c];\
+  }\
+  neurons_##type *tmp_b=clnrnst->base;\
+  while(tmp_b){\
+    for(size_t c=0; c<clnrnst->nb_clone; ++c){\
+      tmp_c[c]->weight_in = tmp_b->weight_in;\
+      tmp_c[c]->L = tmp_b->L;\
+      tmp_c[c]->dL = tmp_b->dL;\
+      tmp_c[c]->f_act = tmp_b->f_act;\
+      tmp_c[c]->d_f_act = tmp_b->d_f_act;\
+      tmp_c[c]->TensorContraction = tmp_b->TensorContraction;\
+      tmp_c[c]->TensorProduct = tmp_b->TensorProduct;\
+      tmp_c[c]->learning_rate = tmp_b->learning_rate;\
+      tmp_c[c]->nb_prod_thread = tmp_b->nb_prod_thread;\
+      tmp_c[c]->nb_calc_thread = tmp_b->nb_calc_thread;\
+      tmp_c[c]->id_layer = tmp_b->id_layer;\
+    }\
+    for(size_t c=0; c<clnrnst->nb_clone; ++c){\
+      tmp_c[c]=tmp_c[c]->next_layer;\
+    }\
+    tmp_b=tmp_b->next_layer;\
+    \
+  }\
+  free(tmp_c);\
+}\
+cloneuronset_##type * create_cloneuronset_from_base_conf_##type(neurons_##type *base, config_layers *conf, size_t nb_clone){\
+  cloneuronset_##type *clnrnst = malloc(sizeof(cloneuronset_##type));\
+  clnrnst->nb_clone = nb_clone;\
+  clnrnst->conf=conf;\
+  clnrnst->base=base;\
+  clnrnst->cloneurons = malloc(nb_clone*sizeof(neurons_##type*));\
+  for(size_t c=0; c<nb_clone; ++c){\
+    setup_networks_layers_without_weights_from_config_##type(&(clnrnst->cloneurons[c]), conf);\
+  }\
+  link_cloneuronset_weight_in_funcs_params_from_base_##type(clnrnst);\
+  return clnrnst;\
 }\
 \
 void print_neurons_msg_##type(neurons_##type *nr, char *msg){\
@@ -427,14 +576,243 @@ size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dat
   printf(" ### reps : %ld \n",nbreps);\
   return nbreps;\
 }\
-size_t learning_set_cloneurons_##type(set_cloneurons_##type *clon, data_set_##type *dataset, neurons_##type *base, bool (*condition)(type, size_t)){\
+size_t learning_online2_neurons_##type(neurons_##type *base, data_set_##type *dataset, bool (*condition)(type,size_t)){\
+  neurons_##type *tmp=NULL, *ttmp;\
   size_t nbreps=0;\
   type err=0;\
+  bool ending=false;\
   do{\
+    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){\
+        calc_out_neurons_##type(tmp);\
+        ttmp = tmp;\
+        tmp = tmp->next_layer;\
+      }\
+      while(ttmp != base){\
+        calc_delta_neurons_##type(ttmp);\
+        update_weight_neurons_##type(ttmp);\
+        ttmp = ttmp->prev_layer;\
+      }\
+      err = ABSMAX(err,error_out_##type(base));\
+      ending = condition(err, nbreps++);\
+    }\
+\
+  }while(!ending);\
     \
-  }while(!condition(err,nbreps++));\
+  \
+  printf(" ### reps : %ld, err:%f \n",nbreps,err);\
   return nbreps;\
 }\
+\
+void print_predict_by_network_neurons_##type(neurons_##type *base, tensor_##type *input){\
+    for(size_t i=0; i<(input->dim)->rank; ++i) (base->output)->x[i]=input->x[i];\
+      neurons_##type * tmp=base->next_layer;\
+      while(tmp){\
+        calc_out_neurons_##type(tmp);\
+        if(tmp->next_layer==NULL){\
+          print_tensor_msg_##type(tmp->output,"retult");\
+          \
+        }\
+        tmp = tmp->next_layer;\
+      }\
+\
+  print_tensor_msg_##type(input,"from input:");\
+  \
+}\
+\
+void print_predict_by_network_with_error_neurons_##type(neurons_##type *base, tensor_##type *input, tensor_##type *target){\
+  init_copy_in_out_networks_from_tensors_##type(base, input, target);\
+      neurons_##type * tmp=base->next_layer;\
+      while(tmp){\
+        calc_out_neurons_##type(tmp);\
+        if(tmp->next_layer==NULL){\
+          print_tensor_msg_##type(tmp->output,"retult");\
+          \
+        }\
+        tmp = tmp->next_layer;\
+      }\
+\
+\
+  printf(" error : %f\n", error_out_##type(base));\
+  print_tensor_msg_##type(input,"from input:");\
+  \
+}\
+\
+void only_update_weight_neurons_##type(neurons_##type *nr){\
+  for(size_t i = 0; i<(nr->weight_in)->dim->rank; ++i){\
+    /*(nr->weight_in)->x[i]= (nr->weight_in)->x[i] - nr->learning_rate *tmp_e_w->x[i] ;\
+    */(nr->weight_in)->x[i]= (nr->weight_in)->x[i] - nr->learning_rate * (nr->weight_out)->x[i] ;\
+  }\
+}\
+\
+void update_cloneuronesets_weight_in_base_##type(cloneuronset_##type * clnrnst){\
+  type sumDw=0;\
+  size_t nb_clone=clnrnst->nb_clone;\
+  neurons_##type **tmp_c=malloc(nb_clone*sizeof(neurons_##type *));\
+  for(size_t c=0; c<nb_clone; ++c)\
+    tmp_c[c] = (clnrnst->cloneurons[c])->next_layer;\
+  neurons_##type *tmp=(clnrnst->base)->next_layer;\
+  while(tmp){\
+    for(size_t i=0; i<((tmp->weight_in)->dim)->rank; ++i){\
+      sumDw=0;\
+      for(size_t c=0; c<nb_clone; ++c){\
+        sumDw += ((tmp_c[c])->weight_out)->x[i];\
+      }\
+      (tmp->weight_in)->x[i] += ((-1) * (tmp->learning_rate) * sumDw) / nb_clone ;\
+    }\
+    for(size_t c=0; c<nb_clone; ++c){\
+      tmp_c[c]=(tmp_c[c])->next_layer;\
+    }\
+    tmp=tmp->next_layer;\
+  }\
+  free(tmp_c);\
+}\
+\
+type clon_error_batch_##type(cloneuronset_##type * clnrnst){\
+  \
+  type err=0;\
+  type sumErrP=0;\
+  size_t nb_clone=clnrnst->nb_clone;\
+  neurons_##type **tmp_c=malloc(nb_clone*sizeof(neurons_##type *));\
+  for(size_t c=0; c<nb_clone; ++c)\
+    tmp_c[c] = (clnrnst->cloneurons[c])->next_layer;\
+  neurons_##type *tmp=(clnrnst->base)->next_layer;\
+  while(tmp){\
+    if(tmp->next_layer==NULL){\
+      for(size_t i=0; i<((tmp->target)->dim)->rank; ++i){\
+        sumErrP=0;\
+        for(size_t c=0; c<nb_clone; ++c){\
+          sumErrP += (tmp_c[c])->L(((tmp_c[c])->target)->x[i],((tmp_c[c])->output)->x[i]);\
+        }\
+        err += sumErrP/nb_clone;\
+      }\
+      break;\
+    }\
+    for(size_t c=0; c<nb_clone; ++c){\
+      tmp_c[c]=(tmp_c[c])->next_layer;\
+    }\
+    tmp=tmp->next_layer;\
+  }\
+  free(tmp_c);\
+  \
+  return err / (((tmp->target)->dim)->rank);\
+}\
+\
+struct arg_learnCloneuronset_##type{\
+  size_t id_th;\
+  sem_t *semaphore_datas;\
+  sem_t *semaphore_learn;\
+  size_t *id_datas;\
+  bool *ending;\
+  neurons_##type *base_c;\
+  data_set_##type *dataset;\
+};\
+void* run_learnCloneuronset_thread_##type(void *arg){\
+  struct arg_learnCloneuronset_##type *arg_t = arg;\
+  size_t id_th = arg_t->id_th;\
+  sem_t *semaphore_datas = arg_t->semaphore_datas;\
+  sem_t *semaphore_learn = arg_t->semaphore_learn;\
+  size_t *id_datas = arg_t->id_datas;\
+  bool *ending = arg_t->ending;\
+  neurons_##type *base_c = arg_t->base_c;\
+  data_set_##type *dataset = arg_t->dataset;\
+  neurons_##type *tmp, *ttmp;\
+  while(!(*ending)){\
+    sem_wait(semaphore_datas);\
+    if(!(*ending)) break;\
+    init_copy_in_out_networks_from_tensors_##type(base_c, dataset->input[id_datas[id_th]],dataset->target[id_datas[id_th]]);\
+      tmp=base_c->next_layer;\
+      while(tmp){\
+        calc_out_neurons_##type(tmp);\
+        ttmp = tmp;\
+        tmp = tmp->next_layer;\
+      }\
+      while(ttmp != base_c){\
+        calc_delta_neurons_##type(ttmp);\
+        /*update_weight_neurons_##type(ttmp);\
+        */\
+        ttmp->TensorProduct(&(ttmp->weight_out), ttmp->input, ttmp->delta_out, ttmp->nb_prod_thread);\
+        ttmp = ttmp->prev_layer;\
+      }\
+    sem_post(semaphore_learn);\
+  }\
+  sem_post(semaphore_learn);\
+}\
+\
+size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##type *dataset, neurons_##type *base, bool (*condition)(type, size_t)){\
+  size_t nbreps=0;\
+  size_t curData=0;\
+  type err=0;\
+  bool *ending=malloc(sizeof(bool));\
+  *ending=false;\
+  size_t nb_clone = clnrnst->nb_clone;\
+  sem_t *semaphore_datas=malloc(sizeof(sem_t));\
+  sem_t *semaphore_learn=malloc(sizeof(sem_t));\
+  sem_init(semaphore_datas,0,0);\
+  sem_init(semaphore_learn,0,0);\
+  size_t *id_datas = malloc(nb_clone * sizeof(size_t));\
+    \
+  pthread_t *thrd = malloc(nb_clone * sizeof(pthread_t));\
+  struct arg_learnCloneuronset_##type **arg_th = malloc( nb_clone * sizeof(struct arg_learnCloneuronset_##type *));\
+\
+  for(size_t i = 0; i < nb_clone; ++i){\
+    arg_th[i]=malloc(sizeof(struct arg_learnCloneuronset_##type));\
+    arg_th[i]->id_th=i;\
+    arg_th[i]->semaphore_datas=semaphore_datas;\
+    arg_th[i]->semaphore_learn=semaphore_learn;\
+    arg_th[i]->ending=ending;\
+    arg_th[i]->base_c = clnrnst->cloneurons[i] ;\
+    arg_th[i]->dataset = dataset ;\
+    \
+    pthread_create(&thrd[i], NULL, run_learnCloneuronset_thread_##type, (void*)arg_th[i]);\
+  }\
+\
+  \
+  while(!(*ending)){\
+    for(size_t c=0; c<nb_clone; ++c){\
+      id_datas[c]=curData;\
+      curData = (curData + 1) % (dataset->size);\
+      \
+    }\
+    for(size_t c=0; c<nb_clone; ++c){\
+      sem_post(semaphore_datas);\
+    }\
+    /* ============ ============= ============ */\
+    \
+    for(size_t c=0; c<nb_clone; ++c){\
+      sem_wait(semaphore_learn);\
+    }\
+    \
+    update_cloneuronesets_weight_in_base_##type(clnrnst);\
+    err = clon_error_batch_##type(clnrnst);\
+    *ending = condition(err, nbreps++) ;\
+  }\
+  \
+  printf("reps batch learning : %ld\n",nbreps);\
+    for(size_t c=0; c<nb_clone; ++c){\
+      sem_post(semaphore_datas);\
+    }\
+  \
+  \
+  for(size_t i=0; i< nb_clone; ++i){\
+    pthread_join(thrd[i], NULL);\
+    free(arg_th[i]);\
+  }\
+\
+  free(thrd);\
+  free(arg_th);\
+  sem_destroy(semaphore_datas);\
+  sem_destroy(semaphore_learn);\
+  free(semaphore_datas);\
+  free(semaphore_learn);\
+  free(ending);\
+  free(id_datas);\
+  return err;\
+}  \
+\
+
  
   
   

neuron_t/src/neuron_t/neuron_t.h

@@ -3,6 +3,7 @@
 
 #include <stdlib.h>
 #include <pthread.h>
+#include <semaphore.h>
 
 //#include "tools_t/tools_t.h"
 #include "tensor_t/tensor_t.h"
@@ -13,6 +14,10 @@ struct config_layers{
    size_t **array_dim_in_layers;
 };
 typedef struct config_layers config_layers; 
+config_layers *create_config_layers(size_t nb_layers, size_t *sz_layers, size_t **array_dim_in_layers);
+config_layers *create_config_layers_from_OneD(size_t nb_layers, size_t *array_dim_in_layers);
+void free_config_layers(config_layers *pconf);
+
 
 #define GEN_NEURON_(type)\
 \
@@ -55,6 +60,8 @@ void init_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type
 void init_in_out_all_networks_##type(neurons_##type *nr, tensor_##type *in, tensor_##type *out);\
 void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers);\
 void setup_networks_alloutputs_config_##type(neurons_##type **base_nr, config_layers *lconf);\
+void setup_networks_layers_without_weights_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers);\
+void setup_networks_layers_without_weights_from_config_##type(neurons_##type **base, config_layers *pconf);\
 void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *array_dim_in_layers, size_t nb_layers);\
 void init_in_out_all_networks_OneD_##type(neurons_##type *nr, type *in, size_t sz_in, type *out, size_t sz_out);\
 void print_neurons_msg_##type(neurons_##type *nr, char * msg);\
@@ -85,15 +92,21 @@ data_set_##type*  fill_data_set_from_file_##type(char * file_input, size_t pivot
 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));\
+size_t learning_online2_neurons_##type(neurons_##type *base, data_set_##type *dataset, bool (*condition)(type, size_t));\
 \
-struct set_cloneurons_##type{\
+void print_predict_by_network_neurons_##type(neurons_##type *base, tensor_##type *input);\
+void print_predict_by_network_with_error_neurons_##type(neurons_##type *base, tensor_##type *input, tensor_##type *target);\
+\
+struct cloneuronset_##type{\
   size_t nb_clone;\
   config_layers *conf;\
   neurons_##type *base;\
   neurons_##type **cloneurons;\
 };\
-typedef struct set_cloneurons_##type set_cloneurons_##type;\
+typedef struct cloneuronset_##type cloneuronset_##type;\
-size_t learning_set_cloneurons_##type(set_cloneurons_##type *clon, data_set_##type *dataset, neurons_##type *base, bool (*condition)(type, size_t));\
+void free_cloneuronset_##type(cloneuronset_##type *clnrnst);\
+cloneuronset_##type * create_cloneuronset_from_base_conf_##type(neurons_##type *base, config_layers *conf, size_t nb_clone);\
+size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##type *dataset, neurons_##type *base, bool (*condition)(type, size_t));\
 
 GEN_NEURON_(TYPE_FLOAT)
 GEN_NEURON_(TYPE_DOUBLE)

neuron_t/test/is_good.c

@@ -78,6 +78,7 @@ TEST(init_One){
   free_neurons_TYPE_FLOAT(bn);
 }
 
+#if 0
 TEST(data_set_from_file){
   data_set_TYPE_FLOAT *ds= fill_data_set_from_file_TYPE_FLOAT("data.txt",1);
 
@@ -86,11 +87,12 @@ TEST(data_set_from_file){
   free_data_set_TYPE_FLOAT(ds);
 
 }
+#endif 
 
 #define epsilon 0.0001
 
 bool cond(float e, size_t nbreps){
-  //if (nbreps > 5) return true;
+  if (nbreps > 1) return true;
   if ((e<epsilon) && (e>-epsilon)) return true;
   return false;
 }
@@ -98,7 +100,7 @@ bool cond(float e, size_t nbreps){
 TEST(learning_first){
   
   data_set_TYPE_FLOAT *ds= fill_data_set_from_file_TYPE_FLOAT("xor.txt",1);
-//  print_data_set_msg_TYPE_FLOAT(ds,"data");
+  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); /* 2 input , 1 target; 1 hidden layer with 5 neurons */
 
@@ -116,9 +118,10 @@ TEST(learning_first){
   size_t reps = learning_online_neurons_TYPE_FLOAT(bn,ds,cond);
   
  
-  char msg[256];
+  //char msg[256];
   for(size_t i=0; i<ds->size; ++i){
-    sprintf(msg, "data set [%ld]",i);
+    print_predict_by_network_neurons_TYPE_FLOAT(bn,ds->input[i]);
+    /*sprintf(msg, "data set [%ld]",i);
     init_copy_in_out_networks_from_tensors_TYPE_FLOAT(bn, ds->input[i],ds->target[i]);\
       tmp=bn->next_layer;\
       while(tmp){\
@@ -126,7 +129,7 @@ TEST(learning_first){
         tmp = tmp->next_layer;\
       }
     print_neurons_msg_TYPE_FLOAT(bn, msg);
-  
+    */
   }
   
 
@@ -137,6 +140,89 @@ TEST(learning_first){
 }
 
 
+
+TEST(learning_second){
+  
+  data_set_TYPE_FLOAT *ds= fill_data_set_from_file_TYPE_FLOAT("xor.txt",1);
+//  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); /* 2 input , 1 target; 1 hidden layer with 5 neurons */
+
+  setup_all_layers_functions_TYPE_FLOAT(bn,
+    tensorContractnProdThread_TYPE_FLOAT,
+    tensorProdThread_TYPE_FLOAT,
+    DL,
+    L,
+    f,
+    df);
+
+  setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.5);
+
+
+  size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
+  
+ 
+  char msg[256];
+  for(size_t i=0; i<ds->size; ++i){
+    print_predict_by_network_neurons_TYPE_FLOAT(bn,ds->input[i]);
+    /*sprintf(msg, "data set [%ld]",i);
+    init_copy_in_out_networks_from_tensors_TYPE_FLOAT(bn, ds->input[i],ds->target[i]);\
+      tmp=bn->next_layer;\
+      while(tmp){\
+        calc_out_neurons_TYPE_FLOAT(tmp);\
+        tmp = tmp->next_layer;\
+      }
+    print_neurons_msg_TYPE_FLOAT(bn, msg);
+  */
+  }
+ 
+
+
+  free_data_set_TYPE_FLOAT(ds);
+  free_neurons_TYPE_FLOAT(bn); 
+
+  LOG("reps = %ld\n",reps);
+}
+
+TEST(learning_withconfig2){
+  
+  data_set_TYPE_FLOAT *ds= fill_data_set_from_file_TYPE_FLOAT("xor.txt",1);
+//  print_data_set_msg_TYPE_FLOAT(ds,"data");
+  config_layers *pconf = create_config_layers_from_OneD(3,(size_t[]){2,4,1}); /* 2 input , 1 target; 1 hidden layer with 5 neurons */
+  neurons_TYPE_FLOAT *bn=NULL, *tmp ;
+  setup_networks_alloutputs_config_TYPE_FLOAT(&bn,pconf);
+
+  setup_all_layers_functions_TYPE_FLOAT(bn,
+    tensorContractnProdThread_TYPE_FLOAT,
+    tensorProdThread_TYPE_FLOAT,
+    DL,
+    L,
+    f,
+    df);
+
+  setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 ,  0.5);
+
+
+  size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
+  
+ 
+  char msg[256];
+  for(size_t i=0; i<ds->size; ++i){
+    print_predict_by_network_with_error_neurons_TYPE_FLOAT(bn,ds->input[i],ds->target[i]);
+    
+  }
+ 
+
+
+  free_data_set_TYPE_FLOAT(ds);
+  free_neurons_TYPE_FLOAT(bn); 
+
+  LOG("reps = %ld\n",reps);
+}
+
+
+
+
 int main(int argc, char **argv){
   
 

neuron_t/test/xor.txt

@@ -1,5 +1,5 @@
 [*,2,1]
 ((1,0),1)
 ((1,1),0)
+((1,0),1)
 ((0,0),0)
-((0,1),1)

tensor_t/src/tensor_t/tensor_t.c

@@ -386,10 +386,14 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
     printf(" |#%ld]: %s, ",i,val);\
     free(val); val=NULL;\
     if(coord[begin]==(T->dim)->perm[begin]-1){\
+      size_t count=0;\
       for(long int j=begin; cond(j,end); j = iter(j)){\
-        if(coord[j]==(T->dim)->perm[j]-1) printf(")");\
+        if(coord[j]==(T->dim)->perm[j]-1) {\
+          printf(")"); ++count;\
+        }\
         else break;\
       }\
+      if(count == (T->dim)->size-1) printf("\n ");\
     }\
   }\
   \
@@ -468,10 +472,12 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
     free(val); val = NULL;\
     (*tensorContent)[cur++]=',';\
     if(coord[begin]==(T->dim)->perm[begin]-1){\
+      size_t count=0;\
       for(long int j=begin; cond(j,end); j = iter(j)){\
-        if(coord[j]==(T->dim)->perm[j]-1) /*printf(")"); */ (*tensorContent)[cur++]=')';\
+        if(coord[j]==(T->dim)->perm[j]-1) {/*printf(")"); */ (*tensorContent)[cur++]=')'; ++count;}\
         else break;\
       }\
+      if(count == (T->dim)->size-1) {(*tensorContent)[cur++]='\n'; (*tensorContent)[cur++]=' ';}\
     }\
   }\
   \
@@ -1238,9 +1244,10 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
 \
 /*format_file: [*,dim1,dim2]((x,x,a)(x,a))... | example:[2,(2,3),4](((a0,b0,c0,)((a1,b1,c1))((a2,b2,c2,d2))((e0,f0,g0)(e1,f1,g1)(e2,f2,g2,h2))) == with pivot 1 => [2,2,3][2,4]*/\
 void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *file_name_input, size_t pivotSplit){\
-  size_t block_size=4;\
+  size_t block_size=2;\
-  size_t block_count=2;\
+  size_t block_count=4;\
   char *input=malloc(block_size*block_count + 1);\
+  char *iinput=malloc(block_size*block_count + 256);\
   FILE *f_input;\
   f_input=fopen(file_name_input,"r");\
   if ( f_input == NULL ) {\
@@ -1248,15 +1255,28 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
     exit( -1 );\
   }\
   bool size_unknown=false, breaked=false; \
-  while((block_count == fread(input, block_size, block_count, f_input)) && !breaked){\
+  bool Done=false;\
-    input[block_count * block_size]='\0';\
+  int retfread = 0, curIn=0;\
-    size_t len = strlen(input);\
+  while(!Done){\
-    for(size_t i=0; i<len ; ++i){\
+    retfread = fread(input, block_size, block_count, f_input) ;\
-      if(input[i]==']') {breaked = true; break;}\
+    Done = (retfread != block_count);\
-      if((input[i]=='*') ||(input[i]=='_')){ \
+    /*input[retfread*block_size]='\0';\
-        breaked=true;  size_unknown =true;\
+    */for(curIn=0; curIn<retfread*block_size; ++curIn) iinput[curIn]=input[curIn];\
-        break;}\
+    while(!Done && ( ((iinput[curIn-1] >='0') && (iinput[curIn-1] <='9'))||(iinput[curIn-1] =='.')||(iinput[curIn-1] =='E')||(iinput[curIn-1] =='e'))){\
+      retfread = fread(input, 1, 1, f_input) ;\
+      Done = (retfread != 1);\
+      iinput[curIn++]=input[0];\
     }\
+    iinput[curIn]='\0';\
+    size_t len = strlen(iinput);\
+    for(size_t i=0; i<len ; ++i){\
+      if(iinput[i]==']') {breaked = true; break;}\
+      if((iinput[i]=='*') ||(iinput[i]=='_')){ \
+        breaked=true;  size_unknown =true;\
+        break;\
+      }\
+    }\
+    Done = breaked;\
   }\
   rewind(f_input);\
   list_perm_in_dim *l_p=NULL;\
@@ -1274,11 +1294,19 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
         dimension *ddim1=NULL;\
         dimension *ddim2=NULL;\
         dimension *dim2=NULL ;\
-  bool Done=false;\
+  Done=false;\
   while(!Done){\
-    Done =  (block_count != fread(input, block_size, block_count, f_input)); \
+    retfread = fread(input, block_size, block_count, f_input) ;\
-    input[block_size * block_count] = '\0';\
+    Done = (retfread != block_count);\
-    ttmp=input;\
+    /*input[retfread*block_size]='\0';\
+    */for(curIn=0; curIn<retfread*block_size; ++curIn) iinput[curIn]=input[curIn];\
+    while(!Done && (((iinput[curIn-1] >='0') && (iinput[curIn-1] <='9'))||(iinput[curIn-1] =='.')||(iinput[curIn-1] =='E')||(iinput[curIn-1] =='e'))){\
+      retfread = fread(input, 1, 1, f_input) ;\
+      Done = (retfread != 1);\
+      iinput[curIn++] = *input;\
+    }\
+    iinput[curIn]='\0';\
+    ttmp=iinput;\
     if( !bracketsDown){\
     while(strlen(ttmp) && strlen(ppEnd) && (*ppEnd !=']')  ){\
       ss = strtoul(ttmp, &ppEnd, 10);\
@@ -1290,7 +1318,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
         append_in_list_perm(&l_p,ss);\
       ttmp=ppEnd;\
     }\
-    if(*ppEnd ==']'){\
+    if( *ppEnd ==']'){\
       dim=create_dim_from_list_perm(l_p);\
       bracketsDown = true;\
       ttmp++; ppEnd++;\
@@ -1367,7 +1395,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
           updateRankDim(ddim2);\
           initDim=true;\
         }\
-        type x=0;\
+        type x= 0;\
         while(ttmp && strlen(ttmp) ){ \
           x = strto_##type(ttmp, &ppEnd);\
            while(ttmp == ppEnd && strlen(ttmp)){\
@@ -1414,6 +1442,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
     free_dimension(dim);\
     free_list_perm_in_dim(l_p);\
     free(input);\
+    free(iinput);\
     fclose(f_input);\
 }\
 \