fanasina/y_project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add functions calculate parallel updates neurons, and debug some leak functions

Browse Source
This commit is contained in:
fanasina
2024-02-28 09:57:21 +01:00
parent 2fc2fe477f
commit 924ff3a7dd
11 changed files with 707 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dimension_t/src/dimension_t/dimension_t.c
+24
View File
@@ -28,6 +28,11 @@ dimension *
create_dim(size_t sz){
return CREATE_PERMUTATION_TYPE_SIZE_T(sz);
}
dimension* clone_dim(dimension *dim){
return init_copy_dim(dim->perm,dim->size);
}
dimension *
create_reverse_dim(size_t sz){
dimension *dim = CREATE_PERMUTATION_TYPE_SIZE_T(sz);
@@ -40,6 +45,15 @@ void free_dimension(dimension *d){
if(d) free_permut_TYPE_SIZE_T(d);
}
bool is_equal_dim(dimension *d0, dimension *d1){
if(d0->size != d1->size) return false;
if(d0->rank != d1->rank) return false;
for(size_t i=0;i<d0->size; ++i)
if(d0->perm[i] != d1->perm[i]) return false;
return true;
}
dimension* sub_copy_minus_dim_head(dimension *root, size_t minusSubdim){
if(minusSubdim < (root->size)){
dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T(root->perm, (root->size)-minusSubdim);
@@ -160,6 +174,16 @@ void increment_dim_var(dimension *d){
}
}
void decrement_dim_var(dimension *d){
if(endian){
(d->perm[0])--;
}
else{
(d->perm[d->size - 1])--;
}
}
void add_dimension(dimension **d, dimension *d0, dimension *d1) {
(*d) = create_dim(d0->size + d1->size);
for (size_t i = 0; i < d0->size; i++) (*d)->perm[i] = d0->perm[i];
dimension_t/src/dimension_t/dimension_t.h
+4
View File
@@ -20,8 +20,11 @@ dimension * create_dim(size_t size);
dimension * create_reverse_dim(size_t size);
dimension* init_dim(size_t *t, size_t sz);
dimension* init_copy_dim(size_t *t, size_t sz);
dimension* clone_dim(dimension *dim);
void free_dimension(dimension *d);
bool is_equal_dim(dimension *d0, dimension *d1);
dimension* sub_minus_dim_head(dimension *t, size_t minusSubdim);
dimension* sub_minus_dim_tail(dimension *t, size_t minusSubdim);
dimension* sub_dim_head(dimension *t, size_t subdim);
@@ -49,6 +52,7 @@ size_t* CoordFromLin(size_t line, dimension *dim);
void vCoordFromLin(size_t *ret, size_t line, dimension *dim );
void increment_dim_var(dimension *d);
void decrement_dim_var(dimension *d);
struct list_perm_in_dim{
size_t index;
neuron_t/src/neuron_t/neuron_t.c
+202 -29
View File
@@ -10,40 +10,71 @@ 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");*/\
/*print_tensor_msg_##type((nr->input)," input calc");*/\
nr->TensorContraction(&(nr->net), nr->input, nr->weight_in, contractNB, nr->nb_thread );\
nr->TensorContraction(&(nr->net), nr->input, nr->weight_in, contractNB, nr->nb_prod_thread );\
/*print_tensor_msg_##type((nr->net)," net calc");*/\
}\
\
void calc_out_neurons_##type(neurons_##type *nr){\
calc_net_neurons_##type(nr);\
for(size_t i = 0; i<(nr->net)->dim->rank; ++i){\
(nr->output)->x[i]=(nr->f_act)((nr->net)->x[i]);\
}\
if(nr->nb_calc_thread <2){\
for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\
(nr->output)->x[i]=(nr->f_act)((nr->net)->x[i]);\
}else\
update_2tensor_func_##type(nr->output,nr->net,nr->f_act,nr->nb_calc_thread);\
/*print_tensor_msg_##type((nr->output)," output calc");\
*/\
}\
type funcalc_delta_target_##type (type net, type target, type output, type(*df1_df_act)(type), type (*df2_dL)(type,type)){\
return df1_df_act(net)*df2_dL(target,output);\
}\
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){\
if(nr->next_layer == NULL){\
for(size_t i = 0; i<(nr->net)->dim->rank; ++i){\
(nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i])*(nr->dL)((nr->target)->x[i],(nr->output)->x[i]);\
if(nr->nb_calc_thread < 2){\
for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\
(nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i])*(nr->dL)((nr->target)->x[i],(nr->output)->x[i]);\
/*print_tensor_msg_##type(nr->delta_out," nr delta_out calc 1 core target delta_out");\
*/\
}else{\
update_5tensor_func_##type(nr->delta_out, nr->net, nr->target, nr->output,\
funcalc_delta_target_##type , \
nr->d_f_act , \
nr->dL, \
nr->nb_calc_thread);\
/*print_tensor_msg_##type(nr->delta_out," nr delta_out calc parallel target delta_out");\
*/\
}\
/*print_tensor_msg_##type(nr->delta_out," nr delta_out calc delta_out last layer");*/\
}else{\
tensor_##type *temp_w_d;\
tensor_##type *temp_w_d=NULL;\
size_t cntrctnb=(((nr->next_layer)->weight_in)->dim)->size-(((nr->next_layer)->delta_out)->dim)->size ;\
/*print_tensor_msg_##type((nr->next_layer)->weight_in," nxt weight_in calc delta_out");*/\
/*print_tensor_msg_##type((nr->next_layer)->delta_out," nxt delta_out calc delta_out");*/\
nr->TensorContraction(&temp_w_d, ((nr->next_layer)->weight_in), (nr->next_layer)->delta_out,cntrctnb,nr->nb_thread);\
nr->TensorContraction(&temp_w_d, ((nr->next_layer)->weight_in), (nr->next_layer)->delta_out,cntrctnb,nr->nb_prod_thread);\
/*print_tensor_msg_##type(temp_w_d," nxt tmp calc delta_out");*/\
/*decrement_dim_var(temp_w_d->dim);*/\
\
for(size_t i = 0; i<(nr->net)->dim->rank; ++i){\
(nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i]) * temp_w_d->x[i] ;\
if(nr->nb_calc_thread < 2){\
for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\
(nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i]) * temp_w_d->x[i] ;\
/*print_tensor_msg_##type(nr->delta_out," nr delta_out calc 1 core hidden delta_out");\
*/\
}else{\
update_4tensor_func_##type(nr->delta_out, nr->net, temp_w_d,\
funcalc_delta_hidden_out_##type , \
nr->d_f_act , \
nr->nb_calc_thread);\
/*print_tensor_msg_##type(nr->delta_out," nr delta_out calc parallel hidden delta_out");\
*/\
}\
/*print_tensor_msg_##type(nr->delta_out," nr delta_out calc delta_out");*/\
free_tensor_##type(temp_w_d);\
}\
}\
void update_weight_neurons_##type(neurons_##type *nr){\
tensor_##type *tmp_e_w;\
nr->TensorProduct(&(tmp_e_w), nr->input, nr->delta_out, nr->nb_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->delta_out," nr delta_out update wei");*/\
/*print_tensor_msg_##type(tmp_e_w," tmp_e_w update wei");*/\
@@ -85,7 +116,7 @@ void link_layers_##type(neurons_##type *nPrev, neurons_##type *nNext ){\
\
\
\
void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_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){\
neurons_##type *tmp_l=NULL, *ttmp_l=NULL;\
for(size_t l=0; l<nb_layers; ++l){\
tmp_l = malloc(sizeof(neurons_##type)); \
@@ -107,7 +138,7 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_
tmp_l->next_layer = NULL;\
\
if(ttmp_l != NULL){\
dimension *dim=init_copy_dim(tab_in_layers[l-1],sz_layers[l-1]);\
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;\
@@ -123,10 +154,12 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_
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);\
init_random_x_##type(ttmp_l->weight_in,0,1,5000);\
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(tab_in_layers[l],sz_layers[l]);\
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);\
@@ -138,8 +171,9 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_
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);\
init_random_x_##type(tmp_l->weight_in,0,1,5000);\
\
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);\
*/\
}\
\
}\
@@ -151,6 +185,10 @@ void setup_networks_alloutputs_##type(neurons_##type **base_nr, size_t **tab_in_
}\
}\
\
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_all_layers_functions_##type(neurons_##type *base, \
void (*TensorContraction)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread),/* nbthread is ignored if not required ! */\
void (*TensorProduct)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread),/* nbthread is ignored if not required ! */\
@@ -172,32 +210,34 @@ void setup_all_layers_functions_##type(neurons_##type *base, \
}\
\
void setup_all_layers_params_##type(neurons_##type *base,\
size_t nb_thread,\
size_t nb_prod_thread,\
size_t nb_calc_thread,\
type learning_rate){\
\
neurons_##type *temp = base;\
while(temp){\
temp->nb_thread=nb_thread;\
temp->nb_prod_thread=nb_prod_thread;\
temp->nb_calc_thread=nb_calc_thread;\
temp->learning_rate=learning_rate;\
temp=temp->next_layer;\
}\
}\
\
\
void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *tab_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){\
size_t *sz_layers=malloc(nb_layers*sizeof(size_t));\
for(size_t i=0; i<nb_layers;++i) sz_layers[i]=1;\
size_t **ttab_in_layers=malloc(nb_layers*sizeof(size_t));\
size_t **tarray_dim_in_layers=malloc(nb_layers*sizeof(size_t));\
for(size_t i=0; i<nb_layers;++i) {\
ttab_in_layers[i]=malloc(sizeof(size_t));\
ttab_in_layers[i][0]=tab_in_layers[i];\
tarray_dim_in_layers[i]=malloc(sizeof(size_t));\
tarray_dim_in_layers[i][0]=array_dim_in_layers[i];\
}\
setup_networks_alloutputs_##type(base_nr, ttab_in_layers, sz_layers, nb_layers);\
setup_networks_alloutputs_##type(base_nr, tarray_dim_in_layers, sz_layers, nb_layers);\
\
for(size_t i=0; i<nb_layers;++i) {\
free(ttab_in_layers[i]);\
free(tarray_dim_in_layers[i]);\
}\
free(ttab_in_layers);\
free(tarray_dim_in_layers);\
free(sz_layers);\
}\
void init_in_out_all_networks_OneD_##type(neurons_##type *nr, type *in, size_t sz_in, type *out, size_t sz_out){\
@@ -213,9 +253,73 @@ void init_in_out_all_networks_OneD_##type(neurons_##type *nr, type *in, size_t s
}\
}\
}\
void init_copy_in_out_networks_from_tensors_##type(neurons_##type *nr, tensor_##type *input, tensor_##type *target){\
if(((nr->output)->dim)->rank == (input->dim)->rank){\
for(size_t i=0;i<(input->dim)->rank;++i) (nr->output)->x[i]=input->x[i];\
}\
neurons_##type *tmp=nr;\
while(tmp->next_layer) tmp=tmp->next_layer;\
\
if(((tmp->target)->dim)->rank == (target->dim)->rank){\
for(size_t i=0; i< (target->dim)->rank; ++i) {\
(tmp->target)->x[i] = target->x[i]; \
}\
}\
}\
\
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 ;\
}\
neurons_##type *tmp=nr;\
while(tmp->next_layer) tmp=tmp->next_layer;\
\
if(is_equal_dim((base->target)->dim, target->dim)){\
tmp->target = target; \
}\
}\
neurons_##type * clone_neurons_base_from_input_target_tensors_##type(neurons_##type *base_nr, tensor_##type *input, tensor_##type *target){\
neurons_##type *nr = malloc(sizeof(neurons_##type));\
neurons_##type *tmpnr = nr, *tmpbs=base_nr, *prevLayer = NULL;\
while(tmpbs){\
tmpnr->id_layer = tmpbs->id_layer;\
tmpnr->nb_prod_thread = tmpbs->nb_prod_thread;\
tmpnr->learning_rate = tmpbs->learning_rate;\
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 print_neurons_msg_##type(neurons_##type *nr, char *msg){\
char *val=NULL;\
while(nr){\
printf("%s, layer %ld\n",msg,nr->id_layer); \
val=type##_TO_STR(nr->learning_rate);\
printf("%s, layer %ld nb_prod_thread:%ld nb_calc_thread:%ld, learning_rate:%s\n",msg,nr->id_layer,nr->nb_prod_thread,nr->nb_calc_thread, val); \
free(val); val=NULL;\
PR_LINE;\
if(nr->input) print_tensor_msg_##type(nr->input," input "); else printf(" input NULL\n");\
PR_LINE;\
@@ -263,6 +367,75 @@ type error_out_##type(neurons_##type *base){\
for(size_t i=0; i< ((base->target)->dim)->rank; ++i) sum += base->L((base->target)->x[i], (base->output)->x[i]);\
return sum / (((base->target)->dim)->rank);\
}\
void free_data_set_##type(data_set_##type *ds){\
if(ds){\
for(size_t i=0;i<ds->size;++i){\
free_tensor_##type(ds->input[i]);\
free_tensor_##type(ds->target[i]);\
}\
free(ds->input);\
free(ds->target);\
free(ds);\
}\
\
}\
data_set_##type * fill_data_set_from_file_##type(char * file_input, size_t pivotSplit){\
data_set_##type * ds=malloc(sizeof(data_set_##type));\
tensor_##type *input, *target;\
parse_file_InputOutput_withDim_to_tensors_##type(&input,&target,file_input,pivotSplit);\
ds->size=(input->dim)->perm[0];\
ds->input=fromInput_to_array_tensor_##type(input);\
ds->target=fromInput_to_array_tensor_##type(target);\
free_tensor_##type(input);\
free_tensor_##type(target);\
return ds;\
}\
void print_data_set_msg_##type(data_set_##type *ds, char *msg){\
printf("data_set : %s\n",msg);\
char mmsg[256];\
for(size_t i=0; i<ds->size; ++i){\
sprintf(mmsg," (%s) - >input[%ld] ",msg,i);\
print_tensor_msg_##type(ds->input[i],mmsg);\
}\
for(size_t i=0; i<ds->size; ++i){\
sprintf(mmsg," (%s) - >target[%ld] ",msg,i);\
print_tensor_msg_##type(ds->target[i],mmsg);\
}\
}\
size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dataset, bool (*condition)(type,size_t)){\
neurons_##type *tmp=NULL, *ttmp;\
size_t nbreps=0;\
do{\
for(size_t i=0; i<dataset->size; ++i){\
init_copy_in_out_networks_from_tensors_##type(base, dataset->input[i],dataset->target[i]);\
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;\
}\
}\
\
}while(!condition(error_out_##type(base), nbreps++));\
\
\
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 nbreps=0;\
type err=0;\
do{\
\
}while(!condition(err,nbreps++));\
return nbreps;\
}\
GEN_NEURONS_F_(TYPE_FLOAT)
neuron_t/src/neuron_t/neuron_t.h
+39 -6
View File
@@ -2,15 +2,24 @@
#define __NEURON_T_C__H
#include <stdlib.h>
#include <pthread.h>
//#include "tools_t/tools_t.h"
#include "tensor_t/tensor_t.h"
struct config_layers{
size_t nb_layers;
size_t *sz_layers;
size_t **array_dim_in_layers;
};
typedef struct config_layers config_layers;
#define GEN_NEURON_(type)\
\
struct neurons_##type {/* layer */\
size_t id_layer;\
size_t nb_thread;\
size_t nb_prod_thread;\
size_t nb_calc_thread;\
type learning_rate;\
tensor_##type *input; \
tensor_##type *net; /* output tensor_prodContract */\
@@ -35,14 +44,18 @@ struct func_act_##type {\
type (*func_act)(type x); /* function activation */\
type (*deriv_func_act)(type x); /* derivate func act */\
};\
\
/*void calc_net_neurons_##type(neurons_##type *nr);*/\
void calc_out_neurons_##type(neurons_##type *nr);\
void calc_delta_neurons_##type(neurons_##type *nr);\
void update_weight_neurons_##type(neurons_##type *nr);\
/*void setup_networks_##type(neurons_##type **base_nr, size_t **tab_in_layers, size_t *tab_sz_layers, size_t nb_layers);*/\
/*void setup_networks_##type(neurons_##type **base_nr, size_t **array_dim_in_layers, size_t *tab_sz_layers, size_t nb_layers);*/\
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 **tab_in_layers, size_t *sz_layers, size_t nb_layers);\
void setup_networks_OneD_##type(neurons_##type **base_nr, size_t *tab_in_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);\
void setup_networks_alloutputs_config_##type(neurons_##type **base_nr, config_layers *lconf);\
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);\
\
@@ -57,10 +70,30 @@ void setup_all_layers_functions_##type(neurons_##type *base, \
type (*d_f_act)(type x)\
);\
void setup_all_layers_params_##type(neurons_##type *base,\
size_t nb_thread,\
size_t nb_prod_thread,\
size_t nb_calc_thread,\
type learning_rate);\
type error_out_##type(neurons_##type *base);\
struct data_set_##type{\
size_t size;\
tensor_##type **input;\
tensor_##type **target;\
};\
typedef struct data_set_##type data_set_##type;\
void free_data_set_##type(data_set_##type *ds);\
data_set_##type* fill_data_set_from_file_##type(char * file_input, size_t pivotSplit);\
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));\
\
struct set_cloneurons_##type{\
size_t nb_clone;\
config_layers *conf;\
neurons_##type *base;\
neurons_##type **cloneurons;\
};\
typedef struct set_cloneurons_##type set_cloneurons_##type;\
size_t learning_set_cloneurons_##type(set_cloneurons_##type *clon, data_set_##type *dataset, neurons_##type *base, bool (*condition)(type, size_t));\
GEN_NEURON_(TYPE_FLOAT)
GEN_NEURON_(TYPE_DOUBLE)
neuron_t/test/Makefile
+1 -1
View File
@@ -14,7 +14,7 @@ NEURODIR=$(PWD)/..
DIMDIR=$(PWD)/../../dimension_t
INCLUDE_DIR=$(PWD)/../src
CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src #"-D DEBUG=1"
LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL -lm
LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL -lm -lpthread
#SRC_DIR=$(ROOT_DIR)/src
#SRC=$(wildcard */*/*.c)
neuron_t/test/is_good.c
+60 -3
View File
@@ -52,9 +52,9 @@ TEST(init_One){
f,
df);
setup_all_layers_params_TYPE_FLOAT(bn, 2, 0.7);
setup_all_layers_params_TYPE_FLOAT(bn, 2, 3, 0.7);
//print_neurons_msg_TYPE_FLOAT(bn,"bn");
print_neurons_msg_TYPE_FLOAT(bn,"bn init");
tmp=bn->next_layer;
while(tmp){
@@ -71,13 +71,70 @@ TEST(init_One){
}
print_neurons_msg_TYPE_FLOAT(bn,"bn");
print_neurons_msg_TYPE_FLOAT(bn,"bn after ");
LOG(" error : %f\n", error_out_TYPE_FLOAT(bn));
free_neurons_TYPE_FLOAT(bn);
}
TEST(data_set_from_file){
data_set_TYPE_FLOAT *ds= fill_data_set_from_file_TYPE_FLOAT("data.txt",1);
print_data_set_msg_TYPE_FLOAT(ds,"data");
free_data_set_TYPE_FLOAT(ds);
}
#define epsilon 0.0001
bool cond(float e, size_t nbreps){
//if (nbreps > 5) return true;
if ((e<epsilon) && (e>-epsilon)) return true;
return false;
}
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");
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_online_neurons_TYPE_FLOAT(bn,ds,cond);
char msg[256];
for(size_t i=0; i<ds->size; ++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);
}
int main(int argc, char **argv){
tensor_t/src/tensor_t/cl_tensor_t.c
+4 -4
View File
@@ -181,7 +181,7 @@
void cl_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
(*MM)=CREATE_TENSOR_##type(dd); \
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd); \
tensor_##type *M = *MM; \
char *file_cl_src = "../src/kernel_ProdTensor.cl"; \
char *func_cl_nameEndian = "prodTensorLin_" #type; \
@@ -235,7 +235,7 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
dimension *dd;\
add_dimension(&dd, dSub0, dSub1);\
updateRankDim(dd);\
*MM = CREATE_TENSOR_##type(dd);\
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
tensor_##type *M= *MM;\
char *file_cl_src = "../src/kernel_ProdContractnTensor.cl"; \
/*char *func_cl_name = "prodContractnTensorLin_" #type;*/ \
@@ -272,7 +272,7 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
void cl2d_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t div0Wsz, size_t div1Wsz) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
(*MM)=CREATE_TENSOR_##type(dd); \
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd); \
tensor_##type *M = *MM; \
char *file_cl_src = "../src/kernel_2d_ProdTensor.cl"; \
/*char *func_cl_name = "prodTensor2dLin_" #type;*/ \
@@ -324,7 +324,7 @@ void cl2d_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tens
dimension *dd;\
add_dimension(&dd, dSub0, dSub1);\
updateRankDim(dd);\
*MM = CREATE_TENSOR_##type(dd);\
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
tensor_##type *M= *MM;\
char *file_cl_src = "../src/kernel_2d_ProdContractnTensor.cl"; \
char *func_cl_nameEndian = "prodContractnTensor2dLin_" #type; \
tensor_t/src/tensor_t/tensor_t.c
+256 -10
View File
@@ -61,6 +61,16 @@ long int decr(long int i) { return i - 1; }
return r_tens;\
}\
\
void _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(tensor_##type **M, dimension *dd){\
if(*M){ \
if(!is_equal_dim((*M)->dim, dd)){\
free_tensor_##type(*M);\
(*M)=CREATE_TENSOR_##type(dd);\
}else free_dimension(dd); /* because it is not used */\
}else{\
(*M)=CREATE_TENSOR_##type(dd);\
}\
}\
tensor_##type* init_tensor_head_##type(tensor_##type *troot ,dimension *dim){\
tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
updateRankDim(dim);\
@@ -107,6 +117,18 @@ tensor_##type* init_copy_tensor_head_##type(tensor_##type *troot ,dimension *dim
r_tens->x = malloc(sizeof(type)*dim->rank);\
return r_tens;\
}\
\
tensor_##type* CLONE_TENSOR_##type(tensor_##type *tens){\
if(tens){\
tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
r_tens->dim = clone_dim(tens->dim);\
r_tens->x = malloc(sizeof(type) * (tens->dim)->rank);\
for(size_t i=0; i<(tens->dim)->rank;++i)\
r_tens->x[i]=tens->x[i];\
return r_tens;\
}\
return NULL;\
}\
\
void free_tensor_##type(tensor_##type * tens){\
if(tens){\
@@ -486,7 +508,7 @@ void split_copy_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tens
void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
(*MM)=CREATE_TENSOR_##type(dd); \
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd); \
tensor_##type *M = *MM; \
size_t* coord; \
coord = malloc(sizeof(size_t)*(dd->size)); \
@@ -512,7 +534,7 @@ void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
(*MM)=CREATE_TENSOR_##type(dd); \
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd); \
tensor_##type *M = *MM; \
size_t m_idx;\
for(size_t i=0; i<M0->dim->rank; ++i){\
@@ -567,7 +589,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
add_dimension(&dd, dSub0, dSub1);\
/*printDebug_dimension(dd,"dd");*/\
updateRankDim(dd);\
*MM = CREATE_TENSOR_##type(dd);\
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
tensor_##type *M= *MM;\
\
\
@@ -625,7 +647,7 @@ void* runProd_thread_##type(void *arg){\
void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
(*MM)=CREATE_TENSOR_##type(dd); \
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd); \
tensor_##type *M = *MM; \
\
\
@@ -687,7 +709,7 @@ void* runProd_thread2d_##type(void *arg){\
void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
(*MM)=CREATE_TENSOR_##type(dd); \
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd); \
tensor_##type *M = *MM; \
\
\
@@ -779,7 +801,7 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
dimension *dd;\
add_dimension(&dd, dSub0, dSub1);\
updateRankDim(dd);\
*MM = CREATE_TENSOR_##type(dd);\
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
tensor_##type *M= *MM;\
\
\
@@ -876,7 +898,7 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
dimension *dd;\
add_dimension(&dd, dSub0, dSub1);\
updateRankDim(dd);\
*MM = CREATE_TENSOR_##type(dd);\
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
tensor_##type *M= *MM;\
\
\
@@ -942,7 +964,7 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
add_dimension(&dd, dSub0, dSub1);\
/*printDebug_dimension(dd,"dd");*/\
updateRankDim(dd);\
*MM = CREATE_TENSOR_##type(dd);\
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
tensor_##type *M= *MM;\
\
size_t* coord;\
@@ -1202,7 +1224,6 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
ttmp=ppEnd;\
}\
\
/*tens = create_tensor_from_list_array_##type(l_a,dim);*/\
*Tpart1 = create_tensor_from_list_array_##type(l_a1,ddim1);\
*Tpart2 = create_tensor_from_list_array_##type(l_a2,ddim2);\
free_array_chainlist_##type(l_a1);\
@@ -1396,7 +1417,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
fclose(f_input);\
}\
\
tensor_##type ** formInput_to_array_tensor_##type(tensor_##type *tens){\
tensor_##type ** fromInput_to_array_tensor_##type(tensor_##type *tens){\
tensor_##type **re_tens=malloc((tens->dim)->perm[0]*sizeof(tensor_##type *));\
dimension *dim=create_dim((tens->dim)->size - 1);\
for(size_t i=0; i<dim->size; ++i) dim->perm[i]=(tens->dim)->perm[i+1];\
@@ -1498,6 +1519,231 @@ tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dper
free(coord_tr);\
return tens_tr;\
}\
struct arg_1Update_##type{\
type *M0x;\
size_t beginRange;\
size_t endRange;\
type (*func)(type);\
};\
void* run1UpdatCalcfunc_thread_##type(void *arg){\
struct arg_1Update_##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]);\
}\
}\
\
void update_1tensor_func_##type(tensor_##type *M0, type (*func)(type), size_t nbthread){\
\
pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
struct arg_1Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_1Update_##type *));\
\
for(size_t i = 0; i < nbthread; ++i){\
arg_th[i]=malloc(sizeof(struct arg_1Update_##type));\
arg_th[i]->M0x=M0->x;\
arg_th[i]->func=func;\
arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
\
pthread_create(&thrd[i], NULL, run1UpdatCalcfunc_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);\
} \
\
struct arg_2Update_##type{\
type *M0x;\
type *M1x;\
size_t beginRange;\
size_t endRange;\
type (*func)(type);\
};\
void* run2UpdatCalcfunc_thread_##type(void *arg){\
struct arg_2Update_##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->M1x[i]);\
}\
}\
\
void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, type (*func)(type), size_t nbthread){\
if ( is_equal_dim(M0->dim,M1->dim)){ \
pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
struct arg_2Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_2Update_##type *));\
\
for(size_t i = 0; i < nbthread; ++i){\
arg_th[i]=malloc(sizeof(struct arg_2Update_##type));\
arg_th[i]->M0x=M0->x;\
arg_th[i]->M1x=M1->x;\
arg_th[i]->func=func;\
arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
\
pthread_create(&thrd[i], NULL, run2UpdatCalcfunc_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);\
}\
} \
\
struct arg_3Update_##type{\
type *M0x;\
type *M1x;\
type *M2x;\
size_t beginRange;\
size_t endRange;\
type (*func)(type, type);\
};\
void* run3UpdatCalcfunc_thread_##type(void *arg){\
struct arg_3Update_##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->M1x[i], arg_t->M2x[i]);\
}\
}\
\
void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, type (*func)(type,type), size_t nbthread){\
if ( is_equal_dim(M0->dim,M1->dim) && (is_equal_dim(M0->dim, M2->dim))){ \
pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
struct arg_3Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_3Update_##type *));\
\
for(size_t i = 0; i < nbthread; ++i){\
arg_th[i]=malloc(sizeof(struct arg_3Update_##type));\
arg_th[i]->M0x=M0->x;\
arg_th[i]->M1x=M1->x;\
arg_th[i]->M2x=M2->x;\
arg_th[i]->func=func;\
arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
\
pthread_create(&thrd[i], NULL, run3UpdatCalcfunc_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);\
}\
} \
\
\
struct arg_4Update_##type{\
type *M0x;\
type *M1x;\
type *M2x;\
size_t beginRange;\
size_t endRange;\
type (*func)(type, type, type(*f1)(type));\
type(*f1)(type);\
};\
void* run4UpdatCalcfunc_thread_##type(void *arg){\
struct arg_4Update_##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->M1x[i], arg_t->M2x[i], arg_t->f1);\
}\
}\
\
void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
type (*func)(type, type, type(*f1)(type)),\
type(*f1)(type),\
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 update4 "); \
printDebug_dimension(M2->dim," dim M2 in update4 "); \
*/if ( is_equal_dim(M0->dim, M1->dim) /*&& (is_equal_dim(M0->dim, M2->dim))*/){ \
/*printDebug_dimension(M0->dim," dim M0 in update4 "); \
*/pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
struct arg_4Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_4Update_##type *));\
\
for(size_t i = 0; i < nbthread; ++i){\
arg_th[i]=malloc(sizeof(struct arg_4Update_##type));\
arg_th[i]->M0x=M0->x;\
arg_th[i]->M1x=M1->x;\
arg_th[i]->M2x=M2->x;\
arg_th[i]->func=func;\
arg_th[i]->f1=f1;\
arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
\
pthread_create(&thrd[i], NULL, run4UpdatCalcfunc_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);\
}\
} \
\
struct arg_5Update_##type{\
type *M0x;\
type *M1x;\
type *M2x;\
type *M3x;\
size_t beginRange;\
size_t endRange;\
type (*func)(type, type, type, type(*f1)(type), type (*f2)(type,type) );\
type(*f1)(type);\
type (*f2)(type,type);\
};\
void* run5UpdatCalcfunc_thread_##type(void *arg){\
struct arg_5Update_##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->M1x[i], arg_t->M2x[i], arg_t->M3x[i], arg_t->f1, arg_t->f2);\
}\
}\
\
void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, tensor_##type *M3 , \
type (*func) (type, type, type, type(*f1)(type), type (*f2)(type,type)), \
type(*f1)(type), \
type (*f2)(type,type), \
size_t nbthread){\
if ( is_equal_dim(M0->dim,M1->dim) && (is_equal_dim(M0->dim, M2->dim))&& (is_equal_dim(M0->dim, M3->dim))){ \
pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
struct arg_5Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_5Update_##type *));\
/*printDebug_dimension(M0->dim," dim M0 in update5 "); */ \
for(size_t i = 0; i < nbthread; ++i){\
arg_th[i]=malloc(sizeof(struct arg_5Update_##type));\
arg_th[i]->M0x=M0->x;\
arg_th[i]->M1x=M1->x;\
arg_th[i]->M2x=M2->x;\
arg_th[i]->M3x=M3->x;\
arg_th[i]->func=func;\
arg_th[i]->f1=f1;\
arg_th[i]->f2=f2;\
arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
\
pthread_create(&thrd[i], NULL, run5UpdatCalcfunc_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);
tensor_t/src/tensor_t/tensor_t.h
+19 -1
View File
@@ -17,6 +17,8 @@ struct tensor_##type{\
typedef struct tensor_##type tensor_##type;\
tensor_##type * CREATE_TENSOR_##type(dimension *dim); \
tensor_##type* CREATE_TENSOR_FROM_CPY_DIM_##type(dimension *dim);\
void _RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(tensor_##type **M, dimension *dd);\
tensor_##type* CLONE_TENSOR_##type(tensor_##type *tens);\
void free_tensor_##type(tensor_##type * tens); \
tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
@@ -42,7 +44,7 @@ void init_random_x_##type(tensor_##type *M, type minR, type maxR, int randomRan
tensor_##type * parseInput_withDim_to_tensor_##type(char *input);\
void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *input, size_t pivotSplit);\
void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *file_name_input, size_t pivotSplit);\
tensor_##type ** formInput_to_array_tensor_##type(tensor_##type *tens);\
tensor_##type ** fromInput_to_array_tensor_##type(tensor_##type *tens);\
struct array_chainlist_##type{\
size_t index;\
type x;\
@@ -54,6 +56,22 @@ tensor_##type * create_tensor_from_list_array_##type( array_chainlist_##type *l_
void free_array_chainlist_##type(array_chainlist_##type *l_a);\
tensor_##type * transpose_notOpt_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);\
void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
type (*func)(type), size_t nbthread);\
void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
type (*func)(type, type), size_t nbthread);\
void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
type (*func)(type, type, type(*f1)(type)),\
type(*f1)(type),\
size_t nbthread);\
void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, tensor_##type *M3 , \
type (*func) (type, type, type, type(*f1)(type), type (*f2)(type,type)), \
type(*f1)(type), \
type (*f2)(type,type), \
size_t nbthread);\
GENERATE_TENSOR_TYPE(TYPE_FLOAT);
tensor_t/test/is_good.c
+64 -39
View File
@@ -544,8 +544,8 @@ TEST(tensorProd ){
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
tensorProd_TYPE_FLOAT(&M,M0,M1);
tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
@@ -603,8 +603,8 @@ TEST(tensorContractnProd_TYPE_FLOAT ){
print_tensor_float(M0,"M0");
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *MnO;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
@@ -664,8 +664,8 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
// print_tensor_float(M0,"M0");
// print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *MnO;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
// print_tensor_float(M,"M");
@@ -717,8 +717,8 @@ TEST(tensorContractnProd_TYPE_DOUBLE_2_1 ){
print_tensor_double(M0,"M0");
print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
//print_tensor_double(M,"M");
@@ -774,8 +774,8 @@ TEST(tensorContractnProd_TYPE_DOUBLE_2_2 ){
print_tensor_double(M0,"M0");
print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
//print_tensor_double(M,"M");
@@ -836,8 +836,8 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
//print_tensor_double(M,"M");
@@ -897,8 +897,8 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
//print_tensor_double(M,"M");
@@ -959,8 +959,8 @@ TEST(Pthread_tensorContractnPro2d_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
size_t nbthread = 5;
@@ -1017,8 +1017,8 @@ TEST(contract_dim1){
print_tensor_double(M0,"M0");
print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
size_t nbthread = 5;
@@ -1085,8 +1085,8 @@ TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
size_t nbthread = 5;
@@ -1146,8 +1146,8 @@ TEST(tensorProd_vs ){
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
tensorProd_TYPE_FLOAT(&M,M0,M1);
//tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
@@ -1201,8 +1201,8 @@ TEST(tensorProd_vsThread ){
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
size_t nbthread = 5;
@@ -1258,8 +1258,8 @@ TEST(tensorProd_vsThread2d ){
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
size_t nbthread = 5;
@@ -1379,7 +1379,7 @@ TEST(parseInputOutput_unknownpart_to_tensor){
"((0,0,0,1,2)"\
"(0,0,0,2,4)) ";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1401,7 +1401,7 @@ TEST(parseInputOutput_knownpart_to_tensor){
"((0,0,0,1,2)"\
"(0,0,0,2,4)) ";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1423,7 +1423,7 @@ TEST(parseInputOutput_unknownpart2dimInput_to_tensor){
"((0,0,0),(8,8,8),1,2)"\
"(0,0,0),(8,8,8),2,4)) ";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1445,7 +1445,7 @@ TEST(parseInputOutput_knownpart2dimInput_to_tensor){
"((0,0,0),(8,8,8),1,2)"\
"(0,0,0),(8,8,8),2,4)) ";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1468,7 +1468,7 @@ TEST(parseInputOutput_unknownpart1dimInput_2output_to_tensor){
"((0,0,0),(8,8,8)8,1,2)"\
"(0,0,0),(8,8,8)8,2,4)) ";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 2);
print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1491,7 +1491,7 @@ TEST(parseInputOutput_knownpart1dimInput_2output_to_tensor){
"((0,0,0),(8,8,8)8,1,2)"\
"(0,0,0),(8,8,8)8,2,4)) ";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 2);
print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1514,7 +1514,7 @@ TEST(parseInputOutput_unknownpart1dimInput_1output_to_tensor){
"((0,0,0),(8,8,8)8,1,2)"\
"(0,0,0),(8,8,8)8,2,4)) ";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1537,7 +1537,7 @@ TEST(parseInputOutput_knownpart1dimInput_1output_to_tensor){
"((0,0,0),(8,8,8)8,1,5)"\
"(0,0,0),(8,8,8)8,2,4)) ";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
@@ -1553,7 +1553,7 @@ TEST(parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
endian=true;
char *inputfile="input.txt";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
@@ -1571,7 +1571,7 @@ TEST(parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
endian=true;
char *inputfile="unkinput.txt";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
@@ -1589,14 +1589,14 @@ TEST(array_from_parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
endian=true;
char *inputfile="unkinput.txt";
tensor_TYPE_FLOAT *t0,*t1;
tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
print_tensor_msg_TYPE_FLOAT(t1," t1 from inputfile" );
tensor_TYPE_FLOAT **arrt0 = formInput_to_array_tensor_TYPE_FLOAT(t0);
tensor_TYPE_FLOAT **arrt1 = formInput_to_array_tensor_TYPE_FLOAT(t1);
tensor_TYPE_FLOAT **arrt0 = fromInput_to_array_tensor_TYPE_FLOAT(t0);
tensor_TYPE_FLOAT **arrt1 = fromInput_to_array_tensor_TYPE_FLOAT(t1);
size_t sz0=(t0->dim)->perm[0];
@@ -1622,8 +1622,33 @@ TEST(array_from_parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
free_tensor_TYPE_FLOAT(t1);
}
float func2(float x){
return x*x+1;
}
TEST(update_func_){
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);
print_tensor_float(M0, "x*x+1 M0 random");
}
tensor_t/test_cl/is_good.c
+32 -32
View File
@@ -86,8 +86,8 @@ TEST(tensorProd ){
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
tensorProd_TYPE_FLOAT(&M,M0,M1);
tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
@@ -131,8 +131,8 @@ TEST(tensorContractnProd_TYPE_FLOAT ){
print_tensor_float(M0,"M0");
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *MnO;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnProd_TYPE_FLOAT(&M, M0,M1,1);
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,1);
@@ -180,8 +180,8 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
// print_tensor_float(M0,"M0");
// print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *MnO;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
// print_tensor_float(M,"M");
@@ -231,8 +231,8 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
// print_tensor_float(M0,"M0");
// print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *MnO;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnProdNotOpt_TYPE_FLOAT(&M, M0,M1,2);
// print_tensor_float(M,"M");
@@ -280,8 +280,8 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
//tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
@@ -341,8 +341,8 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
//print_tensor_double(M,"M");
@@ -392,8 +392,8 @@ TEST(TensorProdCL){
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
tensorProd_TYPE_FLOAT(&M,M0,M1);
cl_tensorProd_TYPE_FLOAT(&Mn,M0,M1);
@@ -452,8 +452,8 @@ TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
size_t nbth=10;
@@ -523,8 +523,8 @@ TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
size_t nbth=15;
@@ -598,8 +598,8 @@ TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
size_t nbth=10;
@@ -675,8 +675,8 @@ TEST(VScltensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
size_t nbth = 10;
@@ -741,8 +741,8 @@ TEST(VScl2dtensorContractnProd_TYPE_DOUBLE2 ){
//print_tensor_double(M0,"M0");
//print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO;
tensor_TYPE_DOUBLE *M=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
size_t nbth = 10;
@@ -799,8 +799,8 @@ TEST(tensorProd_vs2d ){
print_tensor_float(M1,"M1");*/
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
cl_tensorProd_TYPE_FLOAT(&M,M0,M1);
tensorProd_TYPE_FLOAT(&Mn,M0,M1);
@@ -847,8 +847,8 @@ TEST(tensorProd_vs2d ){
print_tensor_float(M1,"M1");*/
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
tensorProd_TYPE_FLOAT(&M,M0,M1);
//cl2d_tensorProd_TYPE_FLOAT(&Mn,M0,M1,24,24);
@@ -896,8 +896,8 @@ TEST(tensorProd_vs2d_Endian ){
print_tensor_float(M1,"M1");*/
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
cl_tensorProd_TYPE_FLOAT(&M,M0,M1);
tensorProd_TYPE_FLOAT(&Mn,M0,M1);
@@ -942,8 +942,8 @@ TEST(tensorProd_vs2d_Endian ){
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
tensorProd_TYPE_FLOAT(&M,M0,M1);
//cl2d_tensorProd_TYPE_FLOAT(&Mn,M0,M1,24,24);