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

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

Browse Source
This commit is contained in:
fanasina
2025-12-13 05:00:23 +01:00
parent 32207170f6
commit 3d54639d4c
18 changed files with 834 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files
deepQlearn_0/src/deepQlearning/learn_to_drive.c
+72 -25
View File
@@ -2,17 +2,26 @@
char *action_name[8] = {"LEFT", "CENTER", "RIGHT"};
#define THRESHOLD_UP 10
#define UPPER_THRESHOLD 10
#define DIVIDER__ 1
#define USE_THRESHOLD 0
float reLU(float x){
if(x>THRESHOLD_UP) return THRESHOLD_UP;
if(x>0) return x;
if(x!=x){// nan
printf("nan relu ");
}
#if USE_THRESHOLD
if(x>UPPER_THRESHOLD) return UPPER_THRESHOLD;
#endif
if(x>0) return x/DIVIDER__;
return 0;
}
float d_reLU(float x){
if (x>THRESHOLD_UP) return 0;
if (x>0) return 1;
#if USE_THRESHOLD
if (x>UPPER_THRESHOLD) return 0;
#endif
if (x>0) return 1/DIVIDER__;
return 0;
}
@@ -37,7 +46,16 @@ float id(float x){ return x;}
float constOne(float x){return 1;}
struct networks_qlearning * create_nework_qlearning(
void tensorProdTHR_TYPE_FLOAT(tensor_TYPE_FLOAT **MM, tensor_TYPE_FLOAT *M0, tensor_TYPE_FLOAT *M1, size_t nbthread){
return tensorProd_TYPE_FLOAT(MM,M0,M1);
}
void tensorContractnProdTHR_TYPE_FLOAT(tensor_TYPE_FLOAT **MM, tensor_TYPE_FLOAT *M0, tensor_TYPE_FLOAT *M1, size_t contractionNumber, size_t nbthread) {
return tensorContractnProd_TYPE_FLOAT(MM,M0,M1,contractionNumber);
}
struct networks_qlearning * create_network_qlearning(
struct config_layers * config,
bool randomize, float minR, float maxR, int randomRange,
size_t nb_prod_thread,
@@ -55,10 +73,13 @@ struct networks_qlearning * create_nework_qlearning(
copy_weight_in_networks_from_main_to_best(qnets);
setup_all_layers_functions_TYPE_FLOAT(qnets->main_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
//setup_all_layers_functions_TYPE_FLOAT(qnets->main_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
setup_all_layers_params_TYPE_FLOAT(qnets->main_net, nb_prod_thread, nb_calc_thread, learning_rate);
setup_all_layers_functions_TYPE_FLOAT(qnets->target_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
//setup_all_layers_functions_TYPE_FLOAT(qnets->target_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
setup_all_layers_params_TYPE_FLOAT(qnets->target_net, nb_prod_thread, nb_calc_thread, learning_rate);
setup_all_layers_functions_TYPE_FLOAT(qnets->best_net, tensorContractnProdThread_TYPE_FLOAT, tensorProdThread_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
//setup_all_layers_functions_TYPE_FLOAT(qnets->best_net, tensorContractnProdTHR_TYPE_FLOAT, tensorProdTHR_TYPE_FLOAT, D_L2, L2, reLU, d_reLU);
setup_all_layers_params_TYPE_FLOAT(qnets->best_net, nb_prod_thread, nb_calc_thread, learning_rate);
// ne pas mettre fonction d'activation à la sortie , i.e: fonction identité : f(x) = x:
@@ -67,12 +88,12 @@ struct networks_qlearning * create_nework_qlearning(
neurons_TYPE_FLOAT *tmpBest = qnets->best_net;
while(tmpMain){
if(tmpMain->next_layer == NULL){
tmpMain->f_act = id;
tmpMain->d_f_act = constOne;
tmpTarget->f_act = id;
tmpTarget->d_f_act = constOne;
tmpBest->f_act = id;
tmpBest->d_f_act = constOne;
tmpMain->f_act = id_TYPE_FLOAT;//id;
tmpMain->d_f_act = d_id_TYPE_FLOAT; //constOne;
tmpTarget->f_act = id_TYPE_FLOAT;//id;
tmpTarget->d_f_act = d_id_TYPE_FLOAT;//constOne;
tmpBest->f_act = id_TYPE_FLOAT;//id;
tmpBest->d_f_act = d_id_TYPE_FLOAT;// constOne;
}
tmpMain = tmpMain->next_layer;
tmpTarget= tmpTarget->next_layer;
@@ -156,18 +177,18 @@ struct qlearning_params * create_qlearning_params (
){
struct qlearning_params * qparams = malloc(sizeof(struct qlearning_params));
qparams->gamma = gamma;
qparams->learning_rate = learning_rate ;
qparams->discount_factor = discount_factor ;
qparams->gamma = gamma; /* taux d'actualisation (discount rate): default : 0.95 */
qparams->learning_rate = learning_rate ; /* default : 0.001 */
qparams->discount_factor = discount_factor ; /* */
qparams->exploration_factor = exploration_factor ;
qparams->nb_training_before_update_weight_in_target = nb_training_before_update_weight_in_target;
qparams->number_episodes = number_episodes;
qparams->factor_update_learning_rate = 0.995;
qparams->minimum_threshold_learning_rate = 0.0001 ;
qparams->factor_update_exploration_factor = 0.9995 /*0.995*/;
qparams->minimum_threshold_exploration_factor = 0.01;
qparams->minimum_threshold_learning_rate = 0.00001 ;
qparams->factor_update_exploration_factor = 0.995 /*0.995*/;
qparams->minimum_threshold_exploration_factor = 0.0001;
// qparams->threshold_number_same_action = 500;
@@ -250,6 +271,9 @@ void free_RL_agent(struct RL_agent *rlAgent){
#define ACCEPTABLE_REWARD 1000
#define UPDATE_PARAMS 1
#define UPDATE_EXPLOR_FAC 1
void train_qlearning(struct RL_agent * rlAgent,
int action //, long reward
){
@@ -263,8 +287,11 @@ void train_qlearning(struct RL_agent * rlAgent,
calculate_output_by_network_neurons_TYPE_FLOAT(net_target, new_state, &next_action_value);
tensor_TYPE_FLOAT * experimental_values = CREATE_TENSOR_FROM_CPY_DIM_TYPE_FLOAT(action_value->dim);
// print_neurons_msg_TYPE_FLOAT(net_main, " net_main "); getchar();
struct game_status * car_status = rlAgent->car->status;
#if UPDATE_PARAMS
struct qlearning_params * qlParams = rlAgent->qlearnParams;
#endif
copy_tensor_TYPE_FLOAT(experimental_values, action_value) ;
//copy_tensor_TYPE_FLOAT(experimental_values, next_action_value) ;
// experimental_values === Q-tab learning
@@ -277,23 +304,33 @@ void train_qlearning(struct RL_agent * rlAgent,
copy_tensor_TYPE_FLOAT(ttmp->target, experimental_values);
while(ttmp != net_main){
calc_delta_neurons_TYPE_FLOAT(ttmp);
update_weight_neurons_TYPE_FLOAT(ttmp);
//update_weight_neurons_TYPE_FLOAT(ttmp);
ttmp = ttmp->prev_layer;
}
ttmp=net_main->next_layer;
while(ttmp){
update_weight_neurons_TYPE_FLOAT(ttmp);
ttmp = ttmp->next_layer;
}
// ***
if(car_status->cumulative_reward > ACCEPTABLE_REWARD){
#if UPDATE_PARAMS
if((car_status->cumulative_reward > ACCEPTABLE_REWARD) || (rlAgent->status->nb_episodes % 100 == 0) ){
float new_value = ( (net_main->learning_rate < qlParams->minimum_threshold_learning_rate /*0.0001*/) ? net_main->learning_rate :(net_main->learning_rate ) * qlParams->factor_update_learning_rate /*0.995*/ );
UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, net_main, learning_rate, new_value);
qlParams->learning_rate = new_value;
#if UPDATE_EXPLOR_FAC
qlParams->exploration_factor = (qlParams->exploration_factor < qlParams->minimum_threshold_exploration_factor) ? qlParams->exploration_factor : qlParams->exploration_factor * qlParams->factor_update_exploration_factor ;
#endif
}
#endif
// free_tensor_TYPE_FLOAT(action_value);
// free_tensor_TYPE_FLOAT(next_action_value);
free_tensor_TYPE_FLOAT(experimental_values);
}
#define MAX_SUCCESSIVE_ACTION 200
#define SUCCESSIVE_ACTION_CHECK 1
#define MAX_SUCCESSIVE_ACTION 1000
int select_action(struct RL_agent * rlAgent){
//static size_t explore = 0;
int action;
@@ -313,6 +350,7 @@ int select_action(struct RL_agent * rlAgent){
if(proba_explor > rlAgent->qlearnParams->exploration_factor ){
action = ARG_MAX_ARRAY_TYPE_FLOAT( action_value->x, action_value->dim->rank );
//printf(" STRATEGY : action : %d , factor : %f nb_episodes : %ld \n",action,rlAgent->qlearnParams->exploration_factor, rlAgent->status->nb_episodes);
#if SUCCESSIVE_ACTION_CHECK
if(rlAgent->networks->nb_successive_action[action]>MAX_SUCCESSIVE_ACTION){
rlAgent->networks->nb_successive_action[action]=0;
int recAction=action;
@@ -320,8 +358,11 @@ int select_action(struct RL_agent * rlAgent){
action = xrand() % action_value->dim->rank ;
//printf("debug: action=%d recAction=%d\n",action, recAction);
}
struct qlearning_params * qlParams = rlAgent->qlearnParams;
write(1,"#",1);
qlParams->exploration_factor = (qlParams->exploration_factor < 1 ) ? qlParams->exploration_factor / qlParams->factor_update_exploration_factor : qlParams->exploration_factor ;
}
#endif
////else write(1,".",1);
//if(action == ARG_MIN_ARRAY_TYPE_FLOAT( action_value->x, action_value->dim->rank ))
//action = xrand() % action_value->dim->rank ;
@@ -333,12 +374,13 @@ int select_action(struct RL_agent * rlAgent){
//printf(" EXPLORE : action : %d , factor : %f nb_episodes : %ld \n",action,rlAgent->qlearnParams->exploration_factor, rlAgent->status->nb_episodes);
////write(1,"*",1);
}
#if SUCCESSIVE_ACTION_CHECK
for(int a=0;a<COUNT_ACTION;++a){
if(a!=action)
rlAgent->networks->nb_successive_action[a]=0;
}
(rlAgent->networks->nb_successive_action[action])++;
#endif
/*
if(rlAgent->status->last_action == action){
++(rlAgent->status->count_last_action);
@@ -450,7 +492,12 @@ void* learn_to_drive(void * lrnarg){
////pthread_create(&threadPrint, NULL, runPrint, (void*)rlAgent);
// while(true){
for(size_t index_episode = 0; (!is_ending(qlStatus)) && (index_episode < qlParams->number_episodes) ; ++index_episode){
for(size_t index_episode = 0;
(!is_ending(qlStatus))
//|| (car_status->cumulative_reward > 2 * ACCEPTABLE_REWARD)
//|| (index_episode < qlParams->number_episodes)
;
++index_episode){
reset(car);
qlStatus->nb_training_after_updated_weight_in_target = 0;
qlStatus->index_episode = index_episode;
deepQlearn_0/src/deepQlearning/learn_to_drive.h
+1 -1
View File
@@ -99,7 +99,7 @@ struct RL_agent {
};
struct networks_qlearning * create_nework_qlearning(
struct networks_qlearning * create_network_qlearning(
struct config_layers * config,
bool randomize, float minR, float maxR, int randomRange,
size_t nb_prod_thread,
deepQlearn_0/src/deepQlearning/vehicle.c
+14 -7
View File
@@ -7,7 +7,11 @@
//#define CENTER 1
//#define RIGHT 2
#define LIMIT_DISTANCE ((float)((SUBDIVISION-1)/10))/SUBDIVISION
#define MAXDISTANCE 49
#define DIVISER 10
//#define LIMIT_DISTANCE ((float)((SUBDIVISION-1)/10))/SUBDIVISION
#define LIMIT_DISTANCE ((float)((int)(SUBDIVISION/10)-1)/SUBDIVISION)
#define REWARD_STOP -1000
#define REWARD_CONTINUE 100
@@ -420,9 +424,12 @@ float distance2_coordinate(coordinate *c0, coordinate *c1){
diStep_sensor->x[0] += step_sensor * cos(direction_radian);\
diStep_sensor->x[1] -= step_sensor * sin(direction_radian);\
}\
dist = (distance2_coordinate(diStep_sensor, v->coord)/10/*5*/);\
/*dist = (distance2_coordinate(diStep_sensor, v->coord)/10)*/;\
dist = (distance2_coordinate(diStep_sensor, v->coord)/DIVISER);\
/*printf("| dist :%f | ",dist);*/\
v->sensor->x[position] = (float)(MIN((SUBDIVISION-1),dist))/SUBDIVISION ;\
/*v->sensor->x[position] = (float)(MIN((SUBDIVISION-1),dist))/SUBDIVISION ;*/\
if(dist>=0) v->sensor->x[position] = (float)(MIN(MAXDISTANCE,dist))/SUBDIVISION;\
else v->sensor->x[position] = 0;\
#if 0
@@ -581,7 +588,7 @@ void step_vehicle(struct vehicle *v, int action){
}
}
#define RANDOM 0
#define RANDOM 1
void reset(struct vehicle *v){
//static bool init = true;
@@ -615,11 +622,11 @@ void reset(struct vehicle *v){
#endif
#if RANDOM
random = xrand() % 50;
v->direction = 80 - random ;
//v->direction = 80 - random ;
//v->direction = 115 - random ;
// v->direction = random - 25 ;
v->direction = random - 25 ;
#else
v->direction = 70; //-90;
v->direction = 80; //-90;
#endif
v->speed = SPEED;
read_sensor(v);
deepQlearn_0/test/is_good.c
+8 -8
View File
@@ -458,7 +458,7 @@ TEST(first_learn_vehicle_rev50_8){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.001; // 0.00001 /*0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -622,7 +622,7 @@ TEST(first_learn_vehicle_50__9){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.00001 /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -792,7 +792,7 @@ TEST(first_learn_vehicle_50__10){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.00001 /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -964,7 +964,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0; /* 0.000001*/ /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -1143,7 +1143,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.0000001 /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -1265,7 +1265,7 @@ TEST(first_learn_vehicle13){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -1375,7 +1375,7 @@ TEST(first_learn_vehicle){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -1486,7 +1486,7 @@ TEST(first_learn_vehicle){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
deepQlearn_0/test/l1aunch_is_good_m
BIN
View File
Binary file not shown.
neuron_t/src/neuron_t/neuron_t.c
+30 -11
View File
@@ -57,7 +57,8 @@ type power_##type(type b, size_t p){\
void step_based_update_learning_rate_##type(neurons_##type *nr){\
nr->learning_rate=(nr->initial_learning_rate)*power_##type((nr->decay_rate),(1+(nr->iteration_step))/(nr->drop_rate));\
}\
\
type id_##type(type x){ return x;}\
type d_id_##type(type x){ return 1;}\
void setup_learning_rate_params_neurons_##type(neurons_##type *base,type initial_learning_rate, type decay_rate, size_t drop_rate, void (*update_learning_rate)(neurons_##type *)){\
while(base){\
base->initial_learning_rate = initial_learning_rate;\
@@ -123,10 +124,13 @@ void calc_delta_neurons_##type(neurons_##type *nr){\
/*decrement_dim_var(temp_w_d->dim);*/\
\
if(nr->nb_calc_thread < 2){\
for(size_t i = 0; i<(nr->net)->dim->rank; ++i)\
for(size_t i = 0; i<(nr->net)->dim->rank; ++i){\
if(temp_w_d->x[i]!=temp_w_d->x[i]) printf("debug: temp_w_d[%ld]=nan ",i);\
if((nr->net)->x[i] != (nr->net)->x[i]) printf("debug : (nr->net)->x[%ld] = nan ",i) ;\
(nr->delta_out)->x[i]=(nr->d_f_act)((nr->net)->x[i]) * temp_w_d->x[i] ;\
if((nr->delta_out)->x[i] != (nr->delta_out)->x[i] ) printf("debug: (nr->delta_out)->x[%ld]=nan ",i);\
/*print_tensor_msg_##type(nr->delta_out," nr delta_out calc 1 core hidden delta_out");\
*/\
*/}\
}else{\
update_4tensor_func_##type(nr->delta_out, nr->net, temp_w_d,\
funcalc_delta_hidden_out_##type , \
@@ -140,6 +144,8 @@ void calc_delta_neurons_##type(neurons_##type *nr){\
}\
\
type func_only_weight_in_##type(type w0, type w1, type scalar){\
if(w0 != w0) printf("debug: w0=nan ");\
if(w1 != w1) printf("debug: w1=nan ");\
return w0 - scalar * w1;\
}\
void only_update_weight_neurons_##type(neurons_##type *nr){\
@@ -703,6 +709,7 @@ void print_data_set_msg_##type(data_set_##type *ds, char *msg){\
size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dataset, bool (*condition)(type,size_t)){\
neurons_##type *tmp=NULL, *ttmp;\
size_t nbreps=0;\
/*char strNbreps[128];*/\
do{\
for(size_t i=0; i<dataset->size; ++i){\
init_copy_in_out_networks_from_tensors_##type(base, dataset->input[i],dataset->target[i]);\
@@ -714,11 +721,18 @@ size_t learning_online_neurons_##type(neurons_##type *base, data_set_##type *dat
}\
while(ttmp != base){\
calc_delta_neurons_##type(ttmp);\
update_weight_neurons_##type(ttmp);\
/*update_weight_neurons_##type(ttmp);*/\
ttmp = ttmp->prev_layer;\
}\
ttmp = base->next_layer;\
while(ttmp){\
update_weight_neurons_##type(ttmp);\
ttmp = ttmp->next_layer;\
}\
}\
nbreps += (dataset->size);\
/*sprintf(strNbreps, " base %ld ",nbreps);\
print_neurons_msg_##type(base, strNbreps ); getchar();*/\
}while(!condition(error_out_##type(base), nbreps));\
\
\
@@ -730,8 +744,9 @@ size_t learning_online2_neurons_##type(neurons_##type *base, data_set_##type *da
size_t nbreps=0;\
type err=0;\
bool ending=false;\
/*char strNbreps[128];*/\
do{\
for(size_t i=0; i<dataset->size && !ending; ++i){\
for(size_t i=0; i<dataset->size /*&& !ending*/; ++i){\
init_copy_in_out_networks_from_tensors_##type(base, dataset->input[i],dataset->target[i]);\
tmp=base->next_layer;\
while(tmp){\
@@ -744,20 +759,23 @@ size_t learning_online2_neurons_##type(neurons_##type *base, data_set_##type *da
/*update_weight_neurons_##type(ttmp);\
*/ttmp = ttmp->prev_layer;\
}\
tmp = ttmp->next_layer;\
tmp = base/*ttmp*/->next_layer;\
while(tmp){\
update_weight_neurons_##type(tmp);\
tmp = tmp->next_layer;\
}\
err = ABSMAX(err,error_out_##type(base));\
/*if(i%20==0){err = error_out_##type(base);} else err = ABSMAX(err,error_out_##type(base));\
*/err = error_out_##type(base);\
ending = condition(err, ++nbreps);\
/*sprintf(strNbreps, " base %ld ",nbreps );\
print_neurons_msg_##type(base, strNbreps ); getchar();*/\
}\
\
}while(!ending);\
\
\
printf(" ### reps : %ld, err:%f \n",nbreps,err);\
return nbreps;\
/*printf(" ### reps : %ld, err:%f \n",nbreps,err);\
*/return nbreps;\
}\
\
neurons_##type * calculate_output_by_network_neurons_##type(neurons_##type *base, tensor_##type *input, tensor_##type **output_link){\
@@ -804,8 +822,8 @@ void print_predict_by_network_with_error_neurons_##type(neurons_##type *base, te
}\
\
\
printf(" error : %f\n", error_out_##type(base));\
print_tensor_msg_##type(input,"from input:");\
/*printf(" error : %f\n", error_out_##type(base));\
*/print_tensor_msg_##type(input,"from input:");\
\
}\
\
@@ -1021,3 +1039,4 @@ size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##typ
GEN_NEURONS_F_(TYPE_FLOAT)
GEN_NEURONS_F_(TYPE_DOUBLE)
GEN_NEURONS_F_(TYPE_L_DOUBLE)
neuron_t/src/neuron_t/neuron_t.h
+12 -6
View File
@@ -60,6 +60,8 @@ struct func_act_##type {\
void do_not_update_learnig_rate_##type(neurons_##type *N);\
void time_based_update_learning_rate_##type(neurons_##type *nr);\
void step_based_update_learning_rate_##type(neurons_##type *nr);\
type id_##type(type x);\
type d_id_##type(type x);\
void setup_learning_rate_params_neurons_##type(neurons_##type *base,type initial_learning_rate, type decay_rate, size_t drop_rate, void (*update_learning_rate)(neurons_##type *));\
/*void calc_net_neurons_##type(neurons_##type *nr);*/\
void calc_out_neurons_##type(neurons_##type *nr);\
@@ -125,6 +127,7 @@ size_t learning_cloneuronset_##type(cloneuronset_##type *clnrnst, data_set_##typ
GEN_NEURON_(TYPE_FLOAT)
GEN_NEURON_(TYPE_DOUBLE)
GEN_NEURON_(TYPE_L_DOUBLE)
#define UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(type, neuronVar, attribute, value) \
@@ -164,21 +167,24 @@ GEN_NEURON_(TYPE_DOUBLE)
free(vmsg);\
}while(0);\
#define BASH_PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(type, bash_arg, neuronVar, attribute, msg)\
#define BASH_PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(type, bash_arg, neuronVar, attribute, msg, putIndexTens)\
do{\
neurons_##type *tmpn = neuronVar;\
char *vmsg=malloc(strlen(msg)+70);\
size_t i=0;\
size_t lenVMG=0;\
/*size_t i=0;\
size_t lenVMG=0;*/\
size_t lenBSH_T=0;\
while(tmpn){\
lenVMG = sprintf(vmsg,"%s layer %ld",msg,i++);\
BASH_WRITE_IF_EXIST(bash_arg,vmsg,lenVMG);\
/*lenVMG = sprintf(vmsg,"%s layer %ld",msg,i++);\
BASH_WRITE_IF_EXIST(bash_arg,vmsg,lenVMG);*/\
if(tmpn->attribute){\
char *bashSTR=NULL;\
lenBSH_T=sprint_tensor_##type(&bashSTR, tmpn->attribute, true);\
lenBSH_T=sprint_tensor_##type(&bashSTR, tmpn->attribute, putIndexTens);\
if(tmpn/*->next_layer==NULL*/){\
BASH_WRITE_IF_EXIST(bash_arg,bashSTR,lenBSH_T);\
}\
if(bashSTR) free(bashSTR);\
/*if(lenBSH_T==0) getchar();*/\
}\
tmpn = tmpn->next_layer;\
}\
neuron_t/test/is_good.c
+98 -15
View File
@@ -38,6 +38,12 @@ float df(float x){
return exp(-x)/ ((1+exp(-x)) * (1+exp(-x)));
}
float __id_(float x){
return x;
}
float d__id_(float x){
return 1;
}
TEST(init_One){
//endian=false;
@@ -94,7 +100,7 @@ TEST(data_set_from_file){
#define epsilon 0.0001
bool cond(float e, size_t nbreps){
if (nbreps > 20000) return true;
if (nbreps > 2000) return true;
if ((e<epsilon) && (e>-epsilon)) return true;
return false;
}
@@ -106,6 +112,7 @@ TEST(learning_first){
print_data_set_msg_TYPE_FLOAT(ds,"data");
neurons_TYPE_FLOAT *bn=NULL, *tmp ;
setup_networks_OneD_TYPE_FLOAT(&bn, (size_t[]){2,4,1},3,false,0,1,5000); /* 2 input , 1 target; 1 hidden layer with 5 neurons */
//setup_networks_OneD_TYPE_FLOAT(&bn, (size_t[]){2,4,1},3,true,0,1,5000); /* 2 input , 1 target; 1 hidden layer with 5 neurons */
setup_all_layers_functions_TYPE_FLOAT(bn,
tensorContractnProdThread_TYPE_FLOAT,
@@ -115,11 +122,23 @@ TEST(learning_first){
f,
df);
setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.1);
setup_all_layers_params_TYPE_FLOAT(bn, 5/*5*/, 3/*1*/ , 0.5);
neurons_TYPE_FLOAT *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=__id_;
ttmp->d_f_act=d__id_;
}
ttmp=ttmp->next_layer;
}
LOG("%s","setup done\n");
print_neurons_msg_TYPE_FLOAT(bn,"bn before ");
size_t reps = learning_online_neurons_TYPE_FLOAT(bn,ds,cond);
print_neurons_msg_TYPE_FLOAT(bn,"bn after ");
//char msg[256];
for(size_t i=0; i<ds->size; ++i){
@@ -136,16 +155,16 @@ TEST(learning_first){
*/
}
LOG("reps = %ld error=%f\n",reps, error_out_TYPE_FLOAT(bn));
free_data_set_TYPE_FLOAT(ds);
free_neurons_TYPE_FLOAT(bn);
LOG("reps = %ld\n",reps);
randomizeInitWeight = rec_randomizeInitWeight;
}
TEST(learning_second_PRINT){
TEST(learning_second_PRINT){ endian=false;
bool rec_randomizeInitWeight = randomizeInitWeight;
randomizeInitWeight =false;
@@ -162,8 +181,15 @@ TEST(learning_second_PRINT){
f,
df);
setup_all_layers_params_TYPE_FLOAT(bn, 5, 3 , 0.1);
setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.4);
neurons_TYPE_FLOAT *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=__id_;
ttmp->d_f_act=d__id_;
}
ttmp=ttmp->next_layer;
}
size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
@@ -214,8 +240,16 @@ TEST(learning_withconfig2){
f,
df);
setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.1);
setup_all_layers_params_TYPE_FLOAT(bn, 1, 1 , 0.5);
neurons_TYPE_FLOAT *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=__id_;
ttmp->d_f_act=d__id_;
}
ttmp=ttmp->next_layer;
}
size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
@@ -231,6 +265,8 @@ TEST(learning_withconfig2){
free_data_set_TYPE_FLOAT(ds);
free_neurons_TYPE_FLOAT(bn);
free_config_layers(pconf);
LOG("reps = %ld\n",reps);
randomizeInitWeight = rec_randomizeInitWeight;
}
@@ -255,8 +291,15 @@ TEST(learning_cloneuroneset){
f,
df);
setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.1);
setup_all_layers_params_TYPE_FLOAT(bn, 1, 1 , 0.5);
neurons_TYPE_FLOAT *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=__id_;
ttmp->d_f_act=d__id_;
}
ttmp=ttmp->next_layer;
}
//print_neurons_msg_TYPE_FLOAT(bn,"before create clones");
cloneuronset_TYPE_FLOAT *clnrnst = create_cloneuronset_from_base_conf_TYPE_FLOAT(bn, pconf, 3);
@@ -308,7 +351,14 @@ TEST(learning_cloneuroneset_LEARN_RATE){
size_t dropRate = 100;
// setup_learning_rate_params_neurons_TYPE_FLOAT(bn, initRate, decayRate, dropRate, time_based_update_learning_rate_TYPE_FLOAT);
setup_learning_rate_params_neurons_TYPE_FLOAT(bn, initRate, decayRate, dropRate, step_based_update_learning_rate_TYPE_FLOAT);
neurons_TYPE_FLOAT *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=__id_;
ttmp->d_f_act=d__id_;
}
ttmp=ttmp->next_layer;
}
//print_neurons_msg_TYPE_FLOAT(bn,"before create clones");
cloneuronset_TYPE_FLOAT *clnrnst = create_cloneuronset_from_base_conf_TYPE_FLOAT(bn, pconf, 3);
@@ -331,7 +381,6 @@ TEST(learning_cloneuroneset_LEARN_RATE){
LOG("reps = %ld\n",reps);
randomizeInitWeight = rec_randomizeInitWeight;
}
TEST(copy_weight_in_neurons){
@@ -356,7 +405,14 @@ TEST(copy_weight_in_neurons){
df);
setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.1);
neurons_TYPE_FLOAT *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=__id_;
ttmp->d_f_act=d__id_;
}
ttmp=ttmp->next_layer;
}
size_t reps = learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
@@ -396,6 +452,7 @@ TEST(copy_weight_in_neurons){
LOG("reps = %ld\n",reps);
randomizeInitWeight = rec_randomizeInitWeight;
free_config_layers(pconf);
}
@@ -435,7 +492,14 @@ TEST(Extract_weight_in_neurons){
df);
setup_all_layers_params_TYPE_FLOAT(cpyn, 5, 1 , 0.1);
neurons_TYPE_FLOAT *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=__id_;
ttmp->d_f_act=d__id_;
}
ttmp=ttmp->next_layer;
}
EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, cpyn, weight_in, ".ff_bn_weight_in__toExtract.txt")
// copy_weight_in_neurons_TYPE_FLOAT(cpyn, bn);
EXPORT_TO_FILE_TENSOR_ATTRIBUTE_IN_NNEURONS(TYPE_FLOAT, bn, weight_in, ".ff_bn_weight_in__toExtract___exp.txt")
@@ -463,6 +527,8 @@ TEST(Extract_weight_in_neurons){
LOG("reps = %ld\n",reps);
randomizeInitWeight = rec_randomizeInitWeight;
free_config_layers(pconf);
}
@@ -492,7 +558,14 @@ TEST(Extract_EXPORT_weight_in_neurons){
df);
setup_all_layers_params_TYPE_FLOAT(bn, 5, 1 , 0.1);
neurons_TYPE_FLOAT *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=__id_;
ttmp->d_f_act=d__id_;
}
ttmp=ttmp->next_layer;
}
size_t reps = 1;// learning_online2_neurons_TYPE_FLOAT(bn,ds,cond);
EXPORT_TO_FILE_TENSOR_ATTRIBUTE_IN_NNEURONS(TYPE_FLOAT, bn, weight_in, ".ff_bn_weight_in__toCMP__.txt")
@@ -534,6 +607,8 @@ TEST(Extract_EXPORT_weight_in_neurons){
LOG("reps = %ld\n",reps);
randomizeInitWeight = rec_randomizeInitWeight;
free_config_layers(pconf);
}
@@ -596,7 +671,14 @@ TEST(Extract_EXPORT_weight_in_neurons_double){
doubledf);
setup_all_layers_params_TYPE_DOUBLE(cpyn, 5, 1 , 0.1);
neurons_TYPE_DOUBLE *ttmp=bn;
while(ttmp){
if(ttmp->next_layer == NULL){
ttmp->f_act=id_TYPE_DOUBLE;
ttmp->d_f_act=d_id_TYPE_DOUBLE;
}
ttmp=ttmp->next_layer;
}
// EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_DOUBLE, cpyn, weight_in, ".ff_bn_weight_in__toExtract.txt")
// copy_weight_in_neurons_TYPE_DOUBLE(cpyn, bn);
@@ -623,6 +705,7 @@ TEST(Extract_EXPORT_weight_in_neurons_double){
LOG("reps = %ld\n",reps);
randomizeInitWeight = rec_randomizeInitWeight;
free_config_layers(pconf);
}
tensor_t/src/tensor_t/tensor_t.c
+64 -11
View File
@@ -23,6 +23,21 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
printf("\n");
}
int checkContractProdTensorDim(dimension *d0, dimension *d1, ssize_t contractionNumber){
if((d0->size-contractionNumber <0)||(d1->size-contractionNumber <0)) return 0;
if(endian){
ssize_t beginCommonM0=d0->size-contractionNumber;
for(ssize_t i=0; i<contractionNumber; ++i){
if(d0->perm[beginCommonM0+i] != d1->perm[i]) return 0;
}
}else{
ssize_t beginCommonM1=d1->size-contractionNumber;
for(ssize_t i=0; i<contractionNumber; ++i){
if(d0->perm[i] != d1->perm[beginCommonM1+i]) return 0;
}
}
return 1;
}
/*
bool isLessEqThan(long int a, long int b) { return a <= b; }
bool isLessThan(long int a, long int b) { return a < b; }
@@ -399,11 +414,11 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
printf(" |#%ld]: %s, ",i,val);\
/*printf(" %s, ",val);*/\
free(val); val=NULL;\
if(T->x[i] != T->x[i]){\
/*if(T->x[i] != T->x[i]){\
printf("\nALERT NAN\n");\
char c;\
scanf("%c",&c);\
}\
}*/\
if(coord[begin]==(T->dim)->perm[begin]-1){\
size_t count=0;\
for(long int j=begin; cond(j,end); j = iter(j)){\
@@ -456,6 +471,11 @@ void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
else break;\
}\
}\
if(T->x[i] != T->x[i]){\
printf("\nALERT NAN\n");\
;\
return;\
}\
/*fprintf(fileWrite," [");\
for(size_t k=0; k<(T->dim)->size;++k) fprintf(fileWrite," %ld,",coord[k]);\
*/val=type##_TO_STR(T->x[i]);\
@@ -539,6 +559,14 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
free(val); val = NULL;\
(*tensorContent)[cur++]=']';\
(*tensorContent)[cur++]=' ';\
}\
if(T->x[i] != T->x[i]){\
/*char *nanStr="ALERT NAN";\
for(size_t c=0;c<strlen(nanStr);++c)\
(*tensorContent)[cur++]=nanStr[c];*/\
printf(" ALERT NAN ");\
;\
/*return strlen(nanStr)*/;\
}\
val=type##_TO_STR(T->x[i]);\
/*printf(" {%ld} %s [",i,val);*/\
@@ -639,6 +667,12 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
/* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\
prsize_tf("Deep = %d\n", contractionNumber);\
}*/\
if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
printDebug_dimension(M0->dim, "M0 dim");\
printDebug_dimension(M1->dim, "M1 dim");\
getchar();\
}\
\
size_t len0 = M0->dim->size - contractionNumber;\
size_t len1 = M1->dim->size - contractionNumber;\
@@ -727,6 +761,7 @@ void* runProd_thread_##type(void *arg){\
return 0;\
}\
\
\
void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
@@ -863,8 +898,14 @@ void* runProdContract_thread_##type(void *arg){\
M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
\
void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
\
void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
printDebug_dimension(M0->dim, "M0 dim");\
printDebug_dimension(M1->dim, "M1 dim");\
getchar();\
}\
size_t len0 = M0->dim->size - contractionNumber;\
size_t len1 = M1->dim->size - contractionNumber;\
\
@@ -962,6 +1003,15 @@ void* runPro2dContract_thread_##type(void *arg){\
M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
\
void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
/*if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
}*/\
if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
printDebug_dimension(M0->dim, "M0 dim");\
printDebug_dimension(M1->dim, "M1 dim");\
getchar();\
}\
\
size_t len0 = M0->dim->size - contractionNumber;\
size_t len1 = M1->dim->size - contractionNumber;\
@@ -1015,10 +1065,12 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
FREE_dM_S_ ; \
}\
void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
/* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\
prsize_tf("Deep = %d\n", contractionNumber);\
}*/\
\
if (!checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)) {\
printf("error Deep = %ld\n", contractionNumber);\
printDebug_dimension(M0->dim, "M0 dim");\
printDebug_dimension(M1->dim, "M1 dim");\
getchar();\
}\
size_t len0 = M0->dim->size - contractionNumber;\
size_t len1 = M1->dim->size - contractionNumber;\
\
@@ -1259,8 +1311,8 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
if(!filled1){\
++i1;\
(*Tpart1)->x[i++] = x;\
printf("++ x: %f, i1:%ld , rkn1: %ld\n",x,i1,ddim1->rank);\
if(i1 == ddim1->rank){\
/*printf("++ x: %f, i1:%ld , rkn1: %ld\n",x,i1,ddim1->rank);\
*/if(i1 == ddim1->rank){\
filled1=true;\
i1=0;\
filled2=false;\
@@ -1269,8 +1321,8 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
if(!filled2){\
++i2;\
(*Tpart2)->x[j++] = x;\
printf("-----++ x: %f, i2:%ld , rknr: %ld\n",x,i2,ddim2->rank);\
if(i2 == ddim2->rank){\
/*printf("-----++ x: %f, i2:%ld , rknr: %ld\n",x,i2,ddim2->rank);\
*/if(i2 == ddim2->rank){\
filled2=true;\
i2=0;\
filled1=false;\
@@ -1942,3 +1994,4 @@ void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
GEN_FUNC_TENSOR(TYPE_FLOAT);
GEN_FUNC_TENSOR(TYPE_DOUBLE);
GEN_FUNC_TENSOR(TYPE_L_DOUBLE);
tensor_t/src/tensor_t/tensor_t.h
+1
View File
@@ -83,6 +83,7 @@ void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
GENERATE_TENSOR_TYPE(TYPE_FLOAT);
GENERATE_TENSOR_TYPE(TYPE_DOUBLE);
GENERATE_TENSOR_TYPE(TYPE_L_DOUBLE);
#endif /* __TENSOR_T__H__ */
tensor_t/test/is_good.c
+458
View File
@@ -510,6 +510,106 @@ TEST(SplitOne_randomInit){
}
#endif
TEST(tensorProdNoOpt){
dimension *d0=create_dim(3);
dimension *d1=create_dim(2);
#if VALGRIND_
d0->perm[0]=5;
d0->perm[1]=2; //3;
d0->perm[2]=3;
d1->perm[0]=2;
d1->perm[1]=3;//3;
#else
d0->perm[0]=5;
d0->perm[1]=7; //3;
d0->perm[2]=12;
d1->perm[0]=2;
d1->perm[1]=13;//3;
#endif
tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
LOG("M0->dim->rank = %ld\n",M0->dim->rank);
LOG("M1->dim->rank = %ld\n",M1->dim->rank);
for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
print_tensor_float(M0,"M0");
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
float MMM0[d0->perm[0]][d0->perm[1]][d0->perm[2]];
long int coord3[3];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int i2=0;i2<d0->perm[2];++i2){
coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
//printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
}
}
}
float MMM1[d1->perm[0]][d1->perm[1]];
long int coord2[2];
for(long int j0=0;j0<d1->perm[0];++j0){
for(long int j1=0;j1<d1->perm[1];++j1){
coord2[0]=j0; coord2[1]=j1;
MMM1[j0][j1]=M1->x[signedLineFromCoord(coord2, d1)];
}
}
//tensorProd_TYPE_FLOAT(&M,M0,M1);
float MMMm[d0->perm[0]][d0->perm[1]][d0->perm[2]][d1->perm[0]][d1->perm[1]];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int i2=0;i2<d0->perm[2];++i2){
for(long int j0=0;j0<d1->perm[0];++j0){
for(long int j1=0;j1<d1->perm[1];++j1){
MMMm[i0][i1][i2][j0][j1]=MMM0[i0][i1][i2] * MMM1[j0][j1];
//printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
}
}
}
}
}
//LOG("M->dim->rank = %ld\n",M->dim->rank);
//print_tensor_float(M,"M");
//EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
long int coord5[5];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int i2=0;i2<d0->perm[2];++i2){
for(long int j0=0;j0<d1->perm[0];++j0){
for(long int j1=0;j1<d1->perm[1];++j1){
coord5[0]=i0; coord5[1]=i1;coord5[2]=i2;
coord5[3]=j0; coord5[4]=j1;
EXPECT_EQ_TYPE_FLOAT(MMMm[i0][i1][i2][j0][j1], Mn->x[signedLineFromCoord(coord5, Mn->dim)] );
}
}
}
}
}
print_tensor_float(Mn,"Mn");
free_tensor_TYPE_FLOAT(M0);
free_tensor_TYPE_FLOAT(M1);
//free_tensor_TYPE_FLOAT(M);
free_tensor_TYPE_FLOAT(Mn);
}
TEST(tensorProd ){
dimension *d0=create_dim(3);
dimension *d1=create_dim(2);
@@ -563,6 +663,364 @@ TEST(tensorProd ){
free_tensor_TYPE_FLOAT(Mn);
}
TEST(tensorContractnProd_TYPE_FLOATNoOpt ){
dimension *d0=create_dim(3);
dimension *d1=create_dim(3);
#if VALGRIND_
d0->perm[0]=5;
d0->perm[1]=2; //3;
d0->perm[2]=3;
d1->perm[0]=3;
d1->perm[1]=3;//3;
d1->perm[2]=8;
#else
d0->perm[0]=15;
d0->perm[1]=12; //3;
d0->perm[2]=13;
d1->perm[0]=13;
d1->perm[1]=15;//3;
d1->perm[2]=14;
#endif
updateRankDim(d0);
updateRankDim(d1);
tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
LOG("M0->dim->rank = %ld\n",M0->dim->rank);
LOG("M1->dim->rank = %ld\n",M1->dim->rank);
for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
print_tensor_float(M0,"M0");
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
//tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
tensorContractnProd_TYPE_FLOAT(&MnO, M0,M1,1);
//tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,1);
printDebug_dimension(MnO->dim, "dim Contr 1");
float MMM0[d0->perm[0]][d0->perm[1]][d0->perm[2]];
long int coord3[3];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int i2=0;i2<d0->perm[2];++i2){
coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
//printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
}
}
}
float MMM1[d1->perm[0]][d1->perm[1]][d1->perm[2]];
long int coord23[3];
for(long int j0=0;j0<d1->perm[0];++j0){
for(long int j1=0;j1<d1->perm[1];++j1){
for(long int j2=0;j2<d1->perm[2];++j2){
coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
}
}
}
//tensorProd_TYPE_FLOAT(&M,M0,M1);
float MMMm[d0->perm[0]][d0->perm[1]][d1->perm[1]][d1->perm[2]];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int j1=0;j1<d1->perm[1];++j1){
for(long int j2=0;j2<d1->perm[2];++j2){
MMMm[i0][i1][j1][j2]=0;
for(long int i2=0;i2<d0->perm[2];++i2){
MMMm[i0][i1][j1][j2] += MMM0[i0][i1][i2] * MMM1[i2][j1][j2];
//printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
}
}
}
}
}
//LOG("M->dim->rank = %ld\n",M->dim->rank);
//print_tensor_float(M,"M");
//EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
long int coord4[4];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int j1=0;j1<d1->perm[1];++j1){
for(long int j2=0;j2<d1->perm[2];++j2){
coord4[0]=i0; coord4[1]=i1; coord4[2]=j1; coord4[3]=j2;
//EXPECT_EQ_TYPE_FLOAT(MMMm[i0][i1][j1][j2], MnO->x[signedLineFromCoord(coord4, MnO->dim)] );
if(expected_EQ_TYPE_FLOAT(MMMm[i0][i1][j1][j2], MnO->x[signedLineFromCoord(coord4, MnO->dim)] ) == false){
LOG("[ %ld, %ld, %ld, %ld ] [%ld]\n",i0,i1,j1,j2,
signedLineFromCoord(coord4, MnO->dim)
);
}
}
}
}
}
//print_tensor_float(M,"M");
print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++i)
// EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
//EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
//free_tensor_TYPE_FLOAT(M);
free_tensor_TYPE_FLOAT(MnO);
free_tensor_TYPE_FLOAT(M0);
free_tensor_TYPE_FLOAT(M1);
}
TEST(tensorContractnProd_TYPE_FLOATNoOpt2 ){
endian=true; //
dimension *d0=create_dim(3);
dimension *d1=create_dim(3);
#if VALGRIND_
d0->perm[0]=5;
d0->perm[1]=2; //3;
d0->perm[2]=3;
d1->perm[0]=2;
d1->perm[1]=3;//3;
d1->perm[2]=8;
#else
d0->perm[0]=35;
d0->perm[1]=32; //3;
d0->perm[2]=23;
d1->perm[0]=32;
d1->perm[1]=23;//3;
d1->perm[2]=44;
#endif
updateRankDim(d0);
updateRankDim(d1);
tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
LOG("M0->dim->rank = %ld\n",M0->dim->rank);
LOG("M1->dim->rank = %ld\n",M1->dim->rank);
for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
print_tensor_float(M0,"M0");
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
//tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
float MMM0[d0->perm[0]][d0->perm[1]][d0->perm[2]];
long int coord3[3];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int i2=0;i2<d0->perm[2];++i2){
coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
//printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
}
}
}
float MMM1[d1->perm[0]][d1->perm[1]][d1->perm[2]];
long int coord23[3];
for(long int j0=0;j0<d1->perm[0];++j0){
for(long int j1=0;j1<d1->perm[1];++j1){
for(long int j2=0;j2<d1->perm[2];++j2){
coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
}
}
}
//tensorProd_TYPE_FLOAT(&M,M0,M1);
float MMMm[d0->perm[0]][d1->perm[2]];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int j2=0;j2<d1->perm[2];++j2){
MMMm[i0][j2]=0;
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int i2=0;i2<d0->perm[2];++i2){
MMMm[i0][j2] += MMM0[i0][i1][i2] * MMM1[i1][i2][j2];
//printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
}
}
}
}
//LOG("M->dim->rank = %ld\n",M->dim->rank);
//print_tensor_float(M,"M");
//EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
long int coord52[2];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int j2=0;j2<d1->perm[2];++j2){
coord52[0]=i0; coord52[1]=j2;
EXPECT_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] );
if(expected_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] ) == false){
LOG("[ %ld, %ld] [%ld]\n",i0,j2,
signedLineFromCoord(coord52, MnO->dim)
);
}
}
}
//print_tensor_float(M,"M");
print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++i)
// EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
//EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
//free_tensor_TYPE_FLOAT(M);
free_tensor_TYPE_FLOAT(MnO);
free_tensor_TYPE_FLOAT(M0);
free_tensor_TYPE_FLOAT(M1);
}
TEST(tensorContractnProd_TYPE_FLOATNoOpt3endianFalse ){
endian=false;
dimension *d0=create_dim(3);
dimension *d1=create_dim(3);
#if VALGRIND_
d0->perm[0]=5;
d0->perm[1]=2; //3;
d0->perm[2]=3;
d1->perm[0]=4;
d1->perm[1]=2;//3;
d1->perm[2]=5;
#else
d0->perm[0]=13;
d0->perm[1]=12; //3;
d0->perm[2]=35;
d1->perm[0]=32;
d1->perm[1]=12;//3;
d1->perm[2]=13;
#endif
updateRankDim(d0);
updateRankDim(d1);
tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
LOG("M0->dim->rank = %ld\n",M0->dim->rank);
LOG("M1->dim->rank = %ld\n",M1->dim->rank);
for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
print_tensor_float(M0,"M0");
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
//tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
float MMM0[d0->perm[0]][d0->perm[1]][d0->perm[2]];
long int coord3[3];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int i2=0;i2<d0->perm[2];++i2){
coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
//printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
}
}
}
float MMM1[d1->perm[0]][d1->perm[1]][d1->perm[2]];
long int coord23[3];
for(long int j0=0;j0<d1->perm[0];++j0){
for(long int j1=0;j1<d1->perm[1];++j1){
for(long int j2=0;j2<d1->perm[2];++j2){
coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
}
}
}
//tensorProd_TYPE_FLOAT(&M,M0,M1);
float MMMm[d0->perm[0]][d1->perm[2]];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int j2=0;j2<d1->perm[2];++j2){
MMMm[i0][j2]=0;
for(long int i1=0;i1<d0->perm[1];++i1){
for(long int i2=0;i2<d0->perm[2];++i2){
MMMm[i0][j2] += MMM0[i0][i1][i2] * MMM1[i1][i2][j2];
//printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
}
}
}
}
//LOG("M->dim->rank = %ld\n",M->dim->rank);
//print_tensor_float(M,"M");
//EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
long int coord52[2];
for(long int i0=0;i0<d0->perm[0];++i0){
for(long int j2=0;j2<d1->perm[2];++j2){
coord52[0]=i0; coord52[1]=j2;
EXPECT_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] );
if(expected_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] ) == false){
LOG("[ %ld, %ld] [%ld]\n",i0,j2,
signedLineFromCoord(coord52, MnO->dim)
);
}
}
}
//print_tensor_float(M,"M");
print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++i)
// EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
//EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
//free_tensor_TYPE_FLOAT(M);
free_tensor_TYPE_FLOAT(MnO);
free_tensor_TYPE_FLOAT(M0);
free_tensor_TYPE_FLOAT(M1);
}
TEST(tensorContractnProd_TYPE_FLOAT ){
dimension *d0=create_dim(3);
dimension *d1=create_dim(3);
y_network_neural_network_/include/y_net_neur_net/y_nnn_screen_manager.h
+1
View File
@@ -61,6 +61,7 @@ struct arg_bash{
pthread_mutex_t *mut_bash_var;
pthread_cond_t *cond_bash_var;
int go_on;
int weight_net_print;
};
struct arg_bash *create_arg_bash();
y_network_neural_network_/src/y_net_neur_net/y_nnn_manager.c
+11 -4
View File
@@ -129,10 +129,11 @@ void* runBashPrint(void *arg){
while( check_go_on_bash(bash_arg) && (new_bash_exist(bash_arg)) && check_go_on_print_params(pprint) && !is_ending(qlStatus)){
if(/*(qlStatus->nb_episodes %125 == 0) &&*/ pprint->printed){
//pthread_mutex_lock(&(pprint->mut_printed));
if(bash_arg->weight_net_print == 0){
pthread_mutex_lock(&(car->mut_coord));
bash_print_vehicle_n_path(car, pprint->scale_x, pprint->scale_y,bash_arg);
pthread_mutex_unlock(&(car->mut_coord));
}
//pthread_mutex_unlock(&(pprint->mut_printed));
////printf("%s ",pprint->string_space);
len_buf=sprintf(buf,"%s ",pprint->string_space);
@@ -150,7 +151,7 @@ void* runBashPrint(void *arg){
}
////printf("\n< %5.2f > ( %s ) \n", car->direction, action_name[qlStatus->action % COUNT_ACTION]);
len_buf=sprintf(buf,"\n< %5.2f > ( %s ) \n", car->direction, action_name[qlStatus->action % COUNT_ACTION]);
len_buf=sprintf(buf,"\n< %5.2f ( %s ) \n", car->direction, action_name[qlStatus->action % COUNT_ACTION]);
BASH_WRITE_IF_EXIST(bash_arg, buf, len_buf)
//print_weight_in_neurons_TYPE_FLOAT(net_main, "net_main_wei");
//PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, net_main, weight_in, "net_main_we_in");
@@ -158,9 +159,15 @@ void* runBashPrint(void *arg){
//PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, net_target, output, "net_target_out");
//PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, net_main, input, "net_main_input");
////printf(" action : %d , factor : %f nb_episodes : %ld \n",qlStatus->action,rlAgent->qlearnParams->exploration_factor, rlAgent->status->nb_episodes);
BASH_PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, bash_arg, net_main, weight_in, "net_main_we_in");
len_buf=sprintf(buf," action : %d , factor : %f nb_episodes : %ld \n",qlStatus->action,rlAgent->qlearnParams->exploration_factor, rlAgent->status->nb_episodes);
if(bash_arg->weight_net_print){
BASH_PRINT_ATTRIBUTE_TENS_IN_ALL_LAYERS(TYPE_FLOAT, bash_arg, net_target, weight_in, "net_main_we_in", false);
}
len_buf=sprintf(buf," action : %d , learning_rate: %f, factor : %f nb_episodes : %ld \n",
qlStatus->action,
rlAgent->qlearnParams->learning_rate,
rlAgent->qlearnParams->exploration_factor,
rlAgent->status->nb_episodes);
BASH_WRITE_IF_EXIST(bash_arg, buf, len_buf)
FOR_LIST_FORM_BEGIN(TYPE_L_INT, qlStatus->progress_best_cumul){
y_network_neural_network_/src/y_net_neur_net/y_nnn_screen_manager.c
+1
View File
@@ -116,6 +116,7 @@ struct arg_bash *create_arg_bash(){
pthread_cond_init(b_arg->cond_bash_var,NULL);
b_arg->go_on=1;
b_arg->weight_net_print=0;
b_arg->thread_launch=NULL;
b_arg->thread_run_newbash=NULL;
y_network_neural_network_/test/is_good.c
+51 -48
View File
@@ -336,7 +336,7 @@ HIDE_TEST(_first_learn_vehicle_50__9){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.001 /*0.01*/ /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -364,12 +364,12 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
20/*long int nb_training_before_update_weight_in_target*/,
10000/*size_t number_episodes*/
);
#if 0
UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, d_f_act , df );
UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->main_net, f_act, f );
UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, d_f_act , df );
UPDATE_ATTRIBUTE_NEURONE_IN_ALL_LAYERS(TYPE_FLOAT, nnetworks->target_net, f_act , f );
#endif
struct print_params *pprint = create_print_params(
12/*float scale_x*/,12 /*float scale_y*/,
dly/*struct delay_params * dly_p*/
@@ -529,7 +529,7 @@ HIDE_TEST(_first_learn_vehicle_50__10){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.00001 /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -614,33 +614,13 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
}
#endif
TEST(_first_learn_vehicle_50__11_9){
HIDE_TEST(_first_learn_vehicle_50__11_9){
size_t nb_block = 7;
size_t dim= 2;
struct blocks * path = create_blocks(nb_block, dim);
#if 1
copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
copy_coordinate(path->upper_bound_block[0], (float[]){100,250});
copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
copy_coordinate(path->upper_bound_block[1], (float[]){250,80});
copy_coordinate(path->lower_bound_block[2], (float[]){250,0});
copy_coordinate(path->upper_bound_block[2], (float[]){360,140});
copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
copy_coordinate(path->upper_bound_block[3], (float[]){600,140});
copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
copy_coordinate(path->upper_bound_block[4], (float[]){720,300});
copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
copy_coordinate(path->upper_bound_block[5], (float[]){720,350});
copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
#else
copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
copy_coordinate(path->upper_bound_block[0], (float[]){150,250});
copy_coordinate(path->lower_bound_block[1], (float[]){150,0});
@@ -657,9 +637,30 @@ TEST(_first_learn_vehicle_50__11_9){
copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
#else
copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
copy_coordinate(path->upper_bound_block[0], (float[]){100,250});
copy_coordinate(path->lower_bound_block[1], (float[]){100,0});
copy_coordinate(path->upper_bound_block[1], (float[]){250,80});
copy_coordinate(path->lower_bound_block[2], (float[]){250,0});
copy_coordinate(path->upper_bound_block[2], (float[]){360,140});
copy_coordinate(path->lower_bound_block[3], (float[]){360,70});
copy_coordinate(path->upper_bound_block[3], (float[]){600,140});
copy_coordinate(path->lower_bound_block[4], (float[]){600,90});
copy_coordinate(path->upper_bound_block[4], (float[]){720,300});
copy_coordinate(path->lower_bound_block[5], (float[]){300,300});
copy_coordinate(path->upper_bound_block[5], (float[]){720,350});
copy_coordinate(path->lower_bound_block[6], (float[]){0,250});
copy_coordinate(path->upper_bound_block[6], (float[]){410,300});
///////////////////////////////////////
#if 0
copy_coordinate(path->lower_bound_block[0], (float[]){0,3});
copy_coordinate(path->upper_bound_block[0], (float[]){4,7});
copy_coordinate(path->lower_bound_block[1], (float[]){1,0});
@@ -675,6 +676,7 @@ TEST(_first_learn_vehicle_50__11_9){
copy_coordinate(path->lower_bound_block[6], (float[]){1,7});
copy_coordinate(path->upper_bound_block[6], (float[]){8,9.75});
#endif
#endif
@@ -683,15 +685,15 @@ TEST(_first_learn_vehicle_50__11_9){
struct vehicle *car = create_vehicle(path);
config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,24,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
//config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,14,14,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
//config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,4,4,3}); /* 3 input , 3 target; 2 hidden layer with 14 neurons each */
bool randomize=true;
float minR = -0.5, maxR = 0.5;
int randomRange = 500;
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.001; /* 0.00001*/ /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
float learning_rate = 0.01; /* 0.00001*/ /* 0.001*/;
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -771,7 +773,7 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
}
#if 1
HIDE_TEST(_first_learn_vehicle_50__11){
TEST(_first_learn_vehicle_50__11){
size_t nb_block = 7;
size_t dim= 2;
struct blocks * path = create_blocks(nb_block, dim);
@@ -873,15 +875,16 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
struct vehicle *car = create_vehicle(path);
config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,24,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
//config_layers *pconf = create_config_layers_from_OneD(4,(size_t[]){3,14,14,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
//config_layers *pconf = create_config_layers_from_OneD(3,(size_t[]){3,24,3}); /* 3 input , 3 target; 2 hidden layer with 24 neurons each */
bool randomize=true;
float minR = -0.5, maxR = 0.5;
//float minR = 0, maxR = 1;
int randomRange = 500;
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0; /* 0.000001*/ /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
float learning_rate = 0.0007 /*0.001*//* 0.0001*/; /* 0.000001*/ /* 0.001*/;
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -894,8 +897,8 @@ EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, wei
//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20250508_17h50m56s_26300.txt");
//EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_17h50m56s_26300.txt");
EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_.symlink");
EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_.symlink");
///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_.symlink");
///EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_.symlink");
/*
EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->main_net, weight_in, ".ff_main_20250508_23h02m40s_29000.txt");
EXTRACT_FILE_TO_TENSOR_ATTRIBUTE_NNEURONS(TYPE_FLOAT, nnetworks->target_net, weight_in, ".ff_target_20250508_23h02m40s_29000.txt");
@@ -910,7 +913,7 @@ struct status_qlearning *qlstatus = create_status_qlearning ();
0.95/*float gamma*/,
learning_rate,
0 /* (not used!)float discount_factor*/,
0.0001/*0.99*/ /*float exploration_factor*/,
1.0/*0.99*//*0.0001*//*0.99*/ /*float exploration_factor*/,
20/*long int nb_training_before_update_weight_in_target*/,
10000/*size_t number_episodes*/
);
@@ -1086,7 +1089,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.0000001 /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -1233,7 +1236,7 @@ HIDE_TEST(__first_learn_vehicle13){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -1371,7 +1374,7 @@ HIDE_TEST(first_learn_vehicle){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -1482,7 +1485,7 @@ HIDE_TEST(first_learn_vehicle){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -2006,7 +2009,7 @@ HIDE_TEST(first_learn_vehicle_rev50_8){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.001; // 0.00001 /*0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -2170,7 +2173,7 @@ HIDE_TEST(first_learn_vehicle_50__9){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.00001 /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -2340,7 +2343,7 @@ HIDE_TEST(first_learn_vehicle_50__10){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.00001 /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -2512,7 +2515,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0; /* 0.000001*/ /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -2691,7 +2694,7 @@ copy_coordinate(path->lower_bound_block[0], (float[]){0,0});
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.0000001 /* 0.001*/;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -2813,7 +2816,7 @@ HIDE_TEST(_first_learn_vehicle13){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -2951,7 +2954,7 @@ HIDE_TEST(first_learn_vehicle){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
@@ -3062,7 +3065,7 @@ HIDE_TEST(first_learn_vehicle){
size_t nb_prod_thread = 2;
size_t nb_calc_thread = 4;
float learning_rate = 0.1;
struct networks_qlearning *nnetworks = create_nework_qlearning(
struct networks_qlearning *nnetworks = create_network_qlearning(
pconf,
randomize, minR, maxR, randomRange,
nb_prod_thread, nb_calc_thread,
ytest_t/libytest.so
BIN
View File
Binary file not shown.