From 3911456abc5221ef852b9061b3f14b21df03254d Mon Sep 17 00:00:00 2001 From: fanasina Date: Fri, 22 Mar 2024 10:15:21 +0100 Subject: [PATCH] change setup neurons and add update learning rates --- neuron_t/src/neuron_t/neuron_t.c | 270 +++++++++++++++++++++++++------ neuron_t/src/neuron_t/neuron_t.h | 20 ++- neuron_t/test/is_good.c | 133 +++++++++++++-- neuron_t/test/xor.txt | 2 +- tensor_t/src/tensor_t/tensor_t.c | 109 ++++++++++++- tensor_t/src/tensor_t/tensor_t.h | 6 +- tensor_t/test/is_good.c | 30 +++- 7 files changed, 498 insertions(+), 72 deletions(-) diff --git a/neuron_t/src/neuron_t/neuron_t.c b/neuron_t/src/neuron_t/neuron_t.c index a30e6c4..57d6913 100644 --- a/neuron_t/src/neuron_t/neuron_t.c +++ b/neuron_t/src/neuron_t/neuron_t.c @@ -39,8 +39,36 @@ void free_config_layers(config_layers *pconf){ free(pconf); } +bool randomizeInitWeight=true; + #define GEN_NEURONS_F_(type)\ \ +void do_not_update_learnig_rate_##type(neurons_##type *N){}\ +\ +void time_based_update_learning_rate_##type(neurons_##type *nr){\ + nr->learning_rate=(nr->learning_rate)/(1+(nr->decay_rate)*(nr->iteration_step));\ +}\ +\ +type power_##type(type b, size_t p){\ + type ret_pow=1;\ + for(size_t i=0;ilearning_rate=(nr->initial_learning_rate)*power_##type((nr->decay_rate),(1+(nr->iteration_step))/(nr->drop_rate));\ +}\ +\ +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;\ + base->learning_rate = initial_learning_rate;\ + base->decay_rate = decay_rate;\ + base->drop_rate = drop_rate;\ + base->update_learning_rate = update_learning_rate;\ + base = base->next_layer;\ + }\ +}\ + \ void calc_net_neurons_##type(neurons_##type *nr){\ size_t contractNB= ((nr->weight_in)->dim)->size - ((nr->input)->dim)->size ;\ /*print_tensor_msg_##type((nr->weight_in)," weight_in calc");*/\ @@ -66,6 +94,9 @@ type funcalc_delta_hidden_out_##type (type net, type temp, type(*df_act)(type)){ return df_act(net)* temp;\ }\ void calc_delta_neurons_##type(neurons_##type *nr){\ + (nr->update_learning_rate)(nr);\ + /*printf("leraning rt :%f , step : %ld\n",nr->learning_rate,nr->iteration_step);\ + */++(nr->iteration_step);\ if(nr->next_layer == NULL){\ if(nr->nb_calc_thread < 2){\ for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\ @@ -107,6 +138,24 @@ void calc_delta_neurons_##type(neurons_##type *nr){\ free_tensor_##type(temp_w_d);\ }\ }\ +\ +type func_only_weight_in_##type(type w0, type w1, type scalar){\ + return w0 - scalar * w1;\ +}\ +void only_update_weight_neurons_##type(neurons_##type *nr){\ + if(nr->nb_calc_thread < 2){\ + 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] ;\ + }\ + }else{\ + update_6tensor_func_##type(nr->weight_in, nr->weight_out, \ + func_only_weight_in_##type,\ + nr->learning_rate,\ + nr->nb_calc_thread);\ + }\ +}\ +\ void update_weight_neurons_##type(neurons_##type *nr){\ nr->TensorProduct(&(nr->weight_out), nr->input, nr->delta_out, nr->nb_prod_thread);\ /*tensor_##type *tmp_e_w=NULL;\ @@ -115,11 +164,13 @@ void update_weight_neurons_##type(neurons_##type *nr){\ /*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 * (nr->weight_out)->x[i] ;\ + only_update_weight_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] ;\ }\ - /*print_tensor_msg_##type(nr->weight_in," weight_in updated ");*/\ + *//*print_tensor_msg_##type(nr->weight_in," weight_in updated ");*/\ /*free_tensor_##type(tmp_e_w);\ */\ }\ @@ -153,7 +204,7 @@ 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){\ +void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers, bool randomize, type minR, type maxR, int randomRange){\ neurons_##type *tmp_l=NULL, *ttmp_l=NULL;\ for(size_t l=0; lnext_layer = tmp_l ;\ }\ tmp_l->id_layer= l;\ + tmp_l->iteration_step= 0;\ tmp_l->input = NULL; \ tmp_l->net = NULL; \ tmp_l->output = NULL; \ @@ -171,6 +223,7 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_d tmp_l->weight_out = NULL; \ tmp_l->delta_out = NULL; \ tmp_l->bias = NULL; \ + tmp_l->update_learning_rate = do_not_update_learnig_rate_##type; \ tmp_l->prev_layer = ttmp_l;\ tmp_l->next_layer = NULL;\ \ @@ -191,9 +244,9 @@ 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.5;\ - /*init_random_x_##type(ttmp_l->weight_in,0,1,5000);\ - */\ + if(randomize) init_random_x_##type(ttmp_l->weight_in,minR,maxR,randomRange);\ + else\ + for(size_t i=0;i<((ttmp_l->weight_in)->dim)->rank;++i) (ttmp_l->weight_in)->x[i]=(minR+maxR)/2;\ }\ if(l==nb_layers-1) {\ dimension *dim_out=init_copy_dim(array_dim_in_layers[l],sz_layers[l]);\ @@ -208,9 +261,81 @@ 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);\ + 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]=(minR+maxR)/2;\ + }\ + \ + }\ +\ + ttmp_l = tmp_l;\ + \ + \ +\ + }\ +}\ +\ +\ +void setup_networks_alloutputs_GLOBAL_rdm01_##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; lnext_layer = tmp_l ;\ + }\ + tmp_l->id_layer= l;\ + tmp_l->iteration_step= 0;\ + 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->update_learning_rate = do_not_update_learnig_rate_##type; \ + 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;irank; ++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;irank; ++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);\ + if(randomizeInitWeight) init_random_x_##type(ttmp_l->weight_in,0,1,5000);\ + else\ + for(size_t i=0;i<((ttmp_l->weight_in)->dim)->rank;++i) (ttmp_l->weight_in)->x[i]=0.5;\ + }\ + 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);\ + if(randomizeInitWeight) init_random_x_##type(tmp_l->weight_in,0,1,5000);\ + else\ 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);\ - */\ }\ \ }\ @@ -233,6 +358,7 @@ void setup_networks_layers_without_weights_##type(neurons_##type **base_nr, size ttmp_l->next_layer = tmp_l ;\ }\ tmp_l->id_layer= l;\ + tmp_l->iteration_step= 0;\ tmp_l->input = NULL; \ tmp_l->net = NULL; \ tmp_l->output = NULL; \ @@ -241,6 +367,7 @@ void setup_networks_layers_without_weights_##type(neurons_##type **base_nr, size tmp_l->weight_out = NULL; \ tmp_l->delta_out = NULL; \ tmp_l->bias = NULL; \ + tmp_l->update_learning_rate = do_not_update_learnig_rate_##type; \ tmp_l->prev_layer = ttmp_l;\ tmp_l->next_layer = NULL;\ \ @@ -309,8 +436,8 @@ void setup_weights_neurons_##type(neurons_##type *base, bool randomize, type min \ }\ \ -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);\ +void setup_networks_alloutputs_config_##type(neurons_##type **base_nr, config_layers *lconf, bool randomize, type minR, type maxR, int randomRange){\ + setup_networks_alloutputs_##type(base_nr, lconf->array_dim_in_layers, lconf->sz_layers, lconf->nb_layers, randomize, minR, maxR, randomRange);\ }\ \ void setup_all_layers_functions_##type(neurons_##type *base, \ @@ -342,13 +469,14 @@ void setup_all_layers_params_##type(neurons_##type *base,\ while(temp){\ temp->nb_prod_thread=nb_prod_thread;\ temp->nb_calc_thread=nb_calc_thread;\ + temp->initial_learning_rate=learning_rate;\ temp->learning_rate=learning_rate;\ temp=temp->next_layer;\ }\ }\ \ \ -void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *array_dim_in_layers, size_t nb_layers){\ +void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *array_dim_in_layers, size_t nb_layers, bool randomize, type minR, type maxR, int randomRange){\ size_t *sz_layers=malloc(nb_layers*sizeof(size_t));\ for(size_t i=0; icloneurons[i]);\ free_neurons_##type(clnrnst->cloneurons[i]);\ }\ + free(clnrnst->cloneurons);\ free_config_layers(clnrnst->conf);\ + free(clnrnst);\ }\ void link_cloneuronset_weight_in_funcs_params_from_base_##type(cloneuronset_##type *clnrnst){\ neurons_##type **tmp_c=malloc(clnrnst->nb_clone * sizeof(neurons_##type *));\ @@ -437,7 +567,11 @@ void link_cloneuronset_weight_in_funcs_params_from_base_##type(cloneuronset_##ty 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]->initial_learning_rate = tmp_b->initial_learning_rate;\ tmp_c[c]->learning_rate = tmp_b->learning_rate;\ + tmp_c[c]->decay_rate= tmp_b->decay_rate;\ + tmp_c[c]->drop_rate= tmp_b->drop_rate;\ + tmp_c[c]->update_learning_rate = tmp_b->update_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;\ @@ -486,6 +620,8 @@ void print_neurons_msg_##type(neurons_##type *nr, char *msg){\ PR_LINE;\ if(nr->target) print_tensor_msg_##type(nr->target," target "); else printf(" target NULL\n");\ PR_LINE;\ + if(nr->next_layer == NULL) printf("next layer of %s = NULL\n",msg);\ + PR_LINE;\ \ nr=nr->next_layer;\ }\ @@ -569,8 +705,8 @@ size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dat ttmp = ttmp->prev_layer;\ }\ }\ -\ - }while(!condition(error_out_##type(base), nbreps++));\ + nbreps += (dataset->size);\ + }while(!condition(error_out_##type(base), nbreps));\ \ \ printf(" ### reps : %ld \n",nbreps);\ @@ -592,11 +728,16 @@ size_t learning_online2_neurons_##type(neurons_##type *base, data_set_##type *da }\ while(ttmp != base){\ calc_delta_neurons_##type(ttmp);\ - update_weight_neurons_##type(ttmp);\ - ttmp = ttmp->prev_layer;\ + /*update_weight_neurons_##type(ttmp);\ + */ttmp = ttmp->prev_layer;\ + }\ + tmp = ttmp->next_layer;\ + while(tmp){\ + update_weight_neurons_##type(tmp);\ + tmp = tmp->next_layer;\ }\ err = ABSMAX(err,error_out_##type(base));\ - ending = condition(err, nbreps++);\ + ending = condition(err, ++nbreps);\ }\ \ }while(!ending);\ @@ -640,13 +781,6 @@ void print_predict_by_network_with_error_neurons_##type(neurons_##type *base, te \ }\ \ -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;\ @@ -659,45 +793,63 @@ void update_cloneuronesets_weight_in_base_##type(cloneuronset_##type * clnrnst){ sumDw=0;\ for(size_t c=0; cweight_out)->x[i];\ + \ + \ }\ - (tmp->weight_in)->x[i] += ((-1) * (tmp->learning_rate) * sumDw) / nb_clone ;\ + (tmp->weight_in)->x[i] = (tmp->weight_in)->x[i] - ( (tmp->learning_rate) * sumDw) / nb_clone ;\ }\ for(size_t c=0; cnext_layer;\ }\ tmp=tmp->next_layer;\ }\ + /*while(tmp->next_layer){\ + for(size_t c=0; cnext_layer;\ + }\ + tmp=tmp->next_layer;\ + }\ + while(tmp != clnrnst->base){\ + for(size_t i=0; i<((tmp->weight_in)->dim)->rank; ++i){\ + sumDw=0;\ + for(size_t c=0; cTensorProduct(&((tmp_c[c])->weight_out), (tmp_c[c])->input, (tmp_c[c])->delta_out, (tmp_c[c])->nb_prod_thread);\ + sumDw += ((tmp_c[c])->weight_out)->x[i];\ + \ + \ + }\ + (tmp->weight_in)->x[i] = (tmp->weight_in)->x[i] - ( (tmp->learning_rate) * sumDw) / nb_clone ;\ + }\ + for(size_t c=0; cprev_layer;\ + }\ + tmp=tmp->prev_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; ccloneurons[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; cL(((tmp_c[c])->target)->x[i],((tmp_c[c])->output)->x[i]);\ - }\ - err += sumErrP/nb_clone;\ - }\ - break;\ - }\ - for(size_t c=0; ccloneurons[c]);\ + neurons_##type *tmp=(clnrnst->base);\ + while(tmp->next_layer){\ + for(size_t c=0; cnext_layer;\ - }\ tmp=tmp->next_layer;\ }\ + err=0;\ + for(size_t i=0; i<((tmp->target)->dim)->rank; ++i){\ + for(size_t c=0; cL(((tmp_c[c])->target)->x[i],((tmp_c[c])->output)->x[i]);\ + }\ + }\ free(tmp_c);\ \ - return err / (((tmp->target)->dim)->rank);\ + return err / (nb_clone * ((tmp->target)->dim)->rank);\ }\ \ struct arg_learnCloneuronset_##type{\ @@ -721,9 +873,10 @@ void* run_learnCloneuronset_thread_##type(void *arg){\ 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;\ + /*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]]);\ + /*printf(" id_datas [%ld] = %ld\n",id_th,id_datas[id_th]);\ + */tmp=base_c->next_layer;\ while(tmp){\ calc_out_neurons_##type(tmp);\ ttmp = tmp;\ @@ -731,9 +884,10 @@ void* run_learnCloneuronset_thread_##type(void *arg){\ }\ 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);\ + /*only_update_weight_neurons_##type(ttmp);\ + *//*update_weight_neurons_##type(ttmp);\ + */\ ttmp = ttmp->prev_layer;\ }\ sem_post(semaphore_learn);\ @@ -741,7 +895,7 @@ void* run_learnCloneuronset_thread_##type(void *arg){\ 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 learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##type *dataset, bool (*condition)(type, size_t)){\ size_t nbreps=0;\ size_t curData=0;\ type err=0;\ @@ -765,8 +919,10 @@ size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##typ arg_th[i]->ending=ending;\ arg_th[i]->base_c = clnrnst->cloneurons[i] ;\ arg_th[i]->dataset = dataset ;\ + arg_th[i]->id_datas= id_datas ;\ \ pthread_create(&thrd[i], NULL, run_learnCloneuronset_thread_##type, (void*)arg_th[i]);\ + \ }\ \ \ @@ -785,9 +941,17 @@ size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##typ sem_wait(semaphore_learn);\ }\ \ + /*neurons_##type *tmp = (clnrnst->cloneurons[0])->next_layer;\ + while(tmp){\ + only_update_weight_neurons_##type(tmp);\ + tmp=tmp->next_layer;\ + }*/\ update_cloneuronesets_weight_in_base_##type(clnrnst);\ - err = clon_error_batch_##type(clnrnst);\ - *ending = condition(err, nbreps++) ;\ + err = ABSMAX(err,clon_error_batch_##type(clnrnst));\ + \ + /*err = ABSMAX(err,error_out_##type(clnrnst->cloneurons[0]));\ + */nbreps += nb_clone;\ + *ending = condition(err, nbreps) ;\ }\ \ printf("reps batch learning : %ld\n",nbreps);\ @@ -809,7 +973,7 @@ size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##typ free(semaphore_learn);\ free(ending);\ free(id_datas);\ - return err;\ + return nbreps;\ } \ \ diff --git a/neuron_t/src/neuron_t/neuron_t.h b/neuron_t/src/neuron_t/neuron_t.h index 9b77987..020f05c 100644 --- a/neuron_t/src/neuron_t/neuron_t.h +++ b/neuron_t/src/neuron_t/neuron_t.h @@ -8,6 +8,8 @@ //#include "tools_t/tools_t.h" #include "tensor_t/tensor_t.h" +extern bool randomizeInitWeight; + struct config_layers{ size_t nb_layers; size_t *sz_layers; @@ -23,9 +25,14 @@ void free_config_layers(config_layers *pconf); \ struct neurons_##type {/* layer */\ size_t id_layer;\ + size_t iteration_step;\ size_t nb_prod_thread;\ size_t nb_calc_thread;\ + type initial_learning_rate;\ type learning_rate;\ + type decay_rate;\ + size_t drop_rate;\ + void (*update_learning_rate)(struct neurons_##type *N); \ tensor_##type *input; \ tensor_##type *net; /* output tensor_prodContract */\ tensor_##type *output; \ @@ -50,6 +57,10 @@ struct func_act_##type {\ type (*deriv_func_act)(type x); /* derivate func act */\ };\ \ +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);\ +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);\ void calc_delta_neurons_##type(neurons_##type *nr);\ @@ -58,11 +69,12 @@ void update_weight_neurons_##type(neurons_##type *nr);\ void init_copy_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type *input, tensor_##type *target);\ void init_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type *input, tensor_##type *target, neurons_##type *base);\ 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_alloutputs_GLOBAL_rdm01_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers);\ +void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *sz_layers, size_t nb_layers, bool randomize, type minR, type maxR, int randomRange);\ +void setup_networks_alloutputs_config_##type(neurons_##type **base_nr, config_layers *lconf, bool randomize, type minR, type maxR, int randomRange);\ 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 setup_networks_OneD_##type(neurons_##type **base_nr, size_t *array_dim_in_layers, size_t nb_layers, bool randomize, type minR, type maxR, int randomRange);\ 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);\ \ @@ -106,7 +118,7 @@ struct cloneuronset_##type{\ typedef struct cloneuronset_##type cloneuronset_##type;\ 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));\ +size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##type *dataset, bool (*condition)(type, size_t));\ GEN_NEURON_(TYPE_FLOAT) GEN_NEURON_(TYPE_DOUBLE) diff --git a/neuron_t/test/is_good.c b/neuron_t/test/is_good.c index 90e43db..23b8386 100644 --- a/neuron_t/test/is_good.c +++ b/neuron_t/test/is_good.c @@ -40,7 +40,7 @@ float df(float x){ TEST(init_One){ //endian=false; neurons_TYPE_FLOAT *bn=NULL, *tmp=NULL, *ttmp=NULL; - setup_networks_OneD_TYPE_FLOAT(&bn, (size_t[]){3,5,2},3); + setup_networks_OneD_TYPE_FLOAT(&bn, (size_t[]){3,5,2},3,false,0,1,5000); init_in_out_all_networks_OneD_TYPE_FLOAT(bn,(float[]){1.2,0.5,1.3},3,(float[]){0.1,0.8},2); @@ -92,17 +92,18 @@ TEST(data_set_from_file){ #define epsilon 0.0001 bool cond(float e, size_t nbreps){ - if (nbreps > 1) return true; + if (nbreps > 20000) return true; if ((e-epsilon)) return true; return false; } TEST(learning_first){ - + bool rec_randomizeInitWeight = randomizeInitWeight; + randomizeInitWeight =false; 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_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_all_layers_functions_TYPE_FLOAT(bn, tensorContractnProdThread_TYPE_FLOAT, @@ -112,7 +113,7 @@ TEST(learning_first){ f, df); - setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.5); + setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.1); size_t reps = learning_online_neurons_TYPE_FLOAT(bn,ds,cond); @@ -120,7 +121,8 @@ TEST(learning_first){ //char msg[256]; for(size_t i=0; isize; ++i){ - print_predict_by_network_neurons_TYPE_FLOAT(bn,ds->input[i]); + print_predict_by_network_with_error_neurons_TYPE_FLOAT(bn,ds->input[i],ds->target[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;\ @@ -137,16 +139,19 @@ TEST(learning_first){ free_neurons_TYPE_FLOAT(bn); LOG("reps = %ld\n",reps); + randomizeInitWeight = rec_randomizeInitWeight; } TEST(learning_second){ + bool rec_randomizeInitWeight = randomizeInitWeight; + randomizeInitWeight =false; 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_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_all_layers_functions_TYPE_FLOAT(bn, tensorContractnProdThread_TYPE_FLOAT, @@ -156,7 +161,7 @@ TEST(learning_second){ f, df); - setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.5); + setup_all_layers_params_TYPE_FLOAT(bn, 5, 3 , 0.1); size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond); @@ -164,7 +169,8 @@ TEST(learning_second){ char msg[256]; for(size_t i=0; isize; ++i){ - print_predict_by_network_neurons_TYPE_FLOAT(bn,ds->input[i]); + print_predict_by_network_with_error_neurons_TYPE_FLOAT(bn,ds->input[i],ds->target[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;\ @@ -182,15 +188,19 @@ TEST(learning_second){ free_neurons_TYPE_FLOAT(bn); LOG("reps = %ld\n",reps); + randomizeInitWeight = rec_randomizeInitWeight; } TEST(learning_withconfig2){ + bool rec_randomizeInitWeight = randomizeInitWeight; + randomizeInitWeight =false; 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_networks_alloutputs_config_GLOBAL_rdm01_TYPE_FLOAT(setup_networks_alloutputs_config_TYPE_FLOAT(&bn,pconf);bn,pconf); + setup_networks_alloutputs_config_TYPE_FLOAT(&bn,pconf,false,0,1,5000); setup_all_layers_functions_TYPE_FLOAT(bn, tensorContractnProdThread_TYPE_FLOAT, @@ -200,7 +210,7 @@ TEST(learning_withconfig2){ f, df); - setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.5); + setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.1); size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond); @@ -218,9 +228,110 @@ TEST(learning_withconfig2){ free_neurons_TYPE_FLOAT(bn); LOG("reps = %ld\n",reps); + randomizeInitWeight = rec_randomizeInitWeight; } +TEST(learning_cloneuroneset){ + bool rec_randomizeInitWeight = randomizeInitWeight; + randomizeInitWeight =false; + + 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_GLOBAL_rdm01_TYPE_FLOAT(setup_networks_alloutputs_config_TYPE_FLOAT(&bn,pconf);bn,pconf); + setup_networks_alloutputs_config_TYPE_FLOAT(&bn,pconf,false,0,1,5000); + + 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.1); + + //print_neurons_msg_TYPE_FLOAT(bn,"before create clones"); + + cloneuronset_TYPE_FLOAT *clnrnst = create_cloneuronset_from_base_conf_TYPE_FLOAT(bn, pconf, 3); + +// size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond); + size_t reps = learning_cloneuronset_TYPE_FLOAT(clnrnst, ds,cond); + + + char msg[256]; + for(size_t i=0; isize; ++i){ + print_predict_by_network_with_error_neurons_TYPE_FLOAT(bn,ds->input[i],ds->target[i]); + + } + + + free_cloneuronset_TYPE_FLOAT(clnrnst); + + free_data_set_TYPE_FLOAT(ds); + free_neurons_TYPE_FLOAT(bn); + + LOG("reps = %ld\n",reps); + randomizeInitWeight = rec_randomizeInitWeight; + +} + + +TEST(learning_cloneuroneset_LEARN_RATE){ + bool rec_randomizeInitWeight = randomizeInitWeight; + randomizeInitWeight =false; + + 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_GLOBAL_rdm01_TYPE_FLOAT(setup_networks_alloutputs_config_TYPE_FLOAT(&bn,pconf);bn,pconf); + setup_networks_alloutputs_config_TYPE_FLOAT(&bn,pconf,false,0,1,5000); + + 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.4); + float initRate=0.6; + float decayRate=0.85; /* halving*/ + 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); + + //print_neurons_msg_TYPE_FLOAT(bn,"before create clones"); + + cloneuronset_TYPE_FLOAT *clnrnst = create_cloneuronset_from_base_conf_TYPE_FLOAT(bn, pconf, 3); + +// size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond); + size_t reps = learning_cloneuronset_TYPE_FLOAT(clnrnst, ds,cond); + + + char msg[256]; + for(size_t i=0; isize; ++i){ + print_predict_by_network_with_error_neurons_TYPE_FLOAT(bn,ds->input[i],ds->target[i]); + + } + + + free_cloneuronset_TYPE_FLOAT(clnrnst); + + free_data_set_TYPE_FLOAT(ds); + free_neurons_TYPE_FLOAT(bn); + + LOG("reps = %ld\n",reps); + randomizeInitWeight = rec_randomizeInitWeight; + +} + + + int main(int argc, char **argv){ diff --git a/neuron_t/test/xor.txt b/neuron_t/test/xor.txt index c0f21fb..5c93b07 100644 --- a/neuron_t/test/xor.txt +++ b/neuron_t/test/xor.txt @@ -1,5 +1,5 @@ [*,2,1] ((1,0),1) +((0,0),0) ((1,1),0) ((1,0),1) -((0,0),0) diff --git a/tensor_t/src/tensor_t/tensor_t.c b/tensor_t/src/tensor_t/tensor_t.c index b46b47d..1caf422 100644 --- a/tensor_t/src/tensor_t/tensor_t.c +++ b/tensor_t/src/tensor_t/tensor_t.c @@ -402,6 +402,63 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\ free(dimsg);\ }\ \ +\ +void fprint_tensor_##type(char *file_name, tensor_##type *T) {\ + size_t j=0,k=0;\ + long int *coord = malloc(sizeof(long int)*(T->dim)->size); \ + char *val=NULL;\ + FILE *fileWrite = fopen(file_name, "w");\ + if(fileWrite == NULL) {\ + printf("error while opening %s\n",file_name);\ + exit(1);\ + }\ + long int begin , end, beginIter, endIter ;\ + long int (*iter)(long int) ;\ + bool (*cond)(long int, long int) ; \ + if (endian ) {\ + begin = (T->dim->size) - 1; end = 0;\ + iter = decr; cond = isGreatEqThan; \ + /*fprintf(fileWrite,"endian(=true): the bigest index varies first, e.g: [x0,x1,x2,...,xn] xn is the bigest index \n");*/\ + }else{\ + begin = 0 ; end = (T->dim->size) - 1; \ + iter = incr; cond = isLessEqThan; \ + /*fprintf(fileWrite,"endian(=false): the lowest index varies first, e.g: [x0,x1,x2,...,xn] x0 is the lowest index \n");*/\ + }\ + fprintf(fileWrite,"[");\ + for(size_t i=0; i<(T->dim)->size; ++i)\ + fprintf(fileWrite," %ld,", (T->dim)->perm[i]);\ + fprintf(fileWrite,"] \n");\ +\ + for(long int i=0;i<(T->dim)->rank;++i){\ + vCoordFromLin(coord,i,T->dim);\ + if(coord[begin]==0){\ + for(long int j=begin; cond(j,end); j= iter(j) ){\ + if(coord[j]==0) fprintf(fileWrite,"(");\ + else break;\ + }\ + }\ + /*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);\ + 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) {\ + fprintf(fileWrite,")"); ++count;\ + }\ + else break;\ + }\ + if(count == (T->dim)->size-1) fprintf(fileWrite,"\n ");\ + }\ + }\ + \ + free(coord);\ + fprintf(fileWrite,"\n");\ + fclose(fileWrite);\ +}\ +\ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withIndex) {\ if(*tensorContent != NULL) {\ free(*tensorContent);\ @@ -1772,7 +1829,57 @@ void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t }\ } \ \ - +\ +struct arg_6Update_##type{\ + type *M0x;\ + type *M1x;\ + size_t beginRange;\ + size_t endRange;\ + type (*func)(type, type, type);\ + type scalar;\ +};\ +void* run6UpdatCalcfunc_thread_##type(void *arg){\ + struct arg_6Update_##type *arg_t = arg;\ + for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\ + arg_t->M0x[i] = arg_t->func(arg_t->M0x[i], arg_t->M1x[i], arg_t->scalar);\ + }\ +}\ +\ +void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \ + type (*func)(type, type, type),\ + type scalar,\ + size_t nbthread){\ + /*printf(" rankM0=%ld , rank M2:%ld ; iseq :%d \n",(M0->dim)->rank,(M2->dim)->rank,is_equal_dim(M0->dim,M2->dim) );\ +*/\ + /* printDebug_dimension(M0->dim," dim M0 in update6 "); \ + printDebug_dimension(M2->dim," dim M2 in update6 "); \ + */if ( is_equal_dim(M0->dim, M1->dim) /*&& (is_equal_dim(M0->dim, M2->dim))*/){ \ + /*printDebug_dimension(M0->dim," dim M0 in update6 "); \ + */pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\ + struct arg_6Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_6Update_##type *));\ + \ + for(size_t i = 0; i < nbthread; ++i){\ + arg_th[i]=malloc(sizeof(struct arg_6Update_##type));\ + arg_th[i]->M0x=M0->x;\ + arg_th[i]->M1x=M1->x;\ + arg_th[i]->func=func;\ + arg_th[i]->scalar=scalar;\ + arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\ + arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\ + \ + pthread_create(&thrd[i], NULL, run6UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\ + }\ + \ + for(size_t i=0; i< nbthread; ++i){\ + pthread_join(thrd[i], NULL);\ + free(arg_th[i]);\ + }\ + \ + free(thrd);\ + free(arg_th);\ + }\ +} \ +\ GEN_FUNC_TENSOR(TYPE_FLOAT); diff --git a/tensor_t/src/tensor_t/tensor_t.h b/tensor_t/src/tensor_t/tensor_t.h index 456590d..38694c1 100644 --- a/tensor_t/src/tensor_t/tensor_t.h +++ b/tensor_t/src/tensor_t/tensor_t.h @@ -29,6 +29,7 @@ tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim); \ tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim); \ void print_tensor_msg_##type(tensor_##type *T, char *msg);\ +void fprint_tensor_##type(char *file_name, tensor_##type *T);\ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withIndex);\ void split_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, size_t pivotSplit, size_t rangeInPivot);\ void split_copy_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, size_t pivotSplit, size_t rangeInPivot);\ @@ -71,7 +72,10 @@ void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t type(*f1)(type), \ type (*f2)(type,type), \ size_t nbthread);\ - +void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \ + type (*func)(type, type, type),\ + type scalar,\ + size_t nbthread);\ GENERATE_TENSOR_TYPE(TYPE_FLOAT); diff --git a/tensor_t/test/is_good.c b/tensor_t/test/is_good.c index 10e58c6..933fd77 100644 --- a/tensor_t/test/is_good.c +++ b/tensor_t/test/is_good.c @@ -1626,7 +1626,7 @@ float func2(float x){ return x*x+1; } -TEST(update_func_){ +TEST(print_tensor){ dimension *d0=create_dim(3); d0->perm[0]=2; @@ -1648,8 +1648,36 @@ TEST(update_func_){ update_1tensor_func_TYPE_FLOAT(M0, func2, 5); print_tensor_float(M0, "x*x+1 M0 random"); + free_tensor_TYPE_FLOAT(M0); } +TEST(rec_in_file_tensor){ + dimension *d0=create_dim(3); + + d0->perm[0]=2; + d0->perm[1]=3; + d0->perm[2]=4; + + + updateRankDim(d0); + + + tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0); + + LOG("M0->dim->rank = %ld\n",M0->dim->rank); + + init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001); + + print_tensor_float(M0, "init M0 random"); + + update_1tensor_func_TYPE_FLOAT(M0, func2, 5); + + fprint_tensor_TYPE_FLOAT(".ffrec_randomTens.txt",M0); + free_tensor_TYPE_FLOAT(M0); +} + + + int main(int argc, char **argv){