----------------------------------------

  Demo sGAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00403     	0.60659     	0.00846     	0           
  10          	0.00452     	0.59602     	0.00920     	0           
  100         	0.00823     	0.45841     	0.01678     	0           
  300         	0.01087     	0.38260     	0.02119     	1           
  500         	0.01027     	0.40340     	0.02031     	2           
  1000        	0.00935     	0.45029     	0.01885     	4           
---> try to load best state
              	0.00935     	0.45029     	0.01885     	4                eval state : test_on_restore;
              	0.00935     	0.45029     	0.01885     	4                eval state : test_on_last_epoch;
---> final result              	0.00935     	0.45029     	0.01885     	4                eval state : final;
---> end


---------->
SGAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 31, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00296     	0.58790     	0.01007     	0           
  10          	0.00294     	0.61350     	0.01117     	0           
  100         	0.00629     	0.49255     	0.01631     	1           
  300         	0.00671     	0.47185     	0.01718     	4           
  500         	0.00671     	0.37674     	0.01721     	6           
  1000        	0.00694     	-0.03705    	0.01713     	12          
---> try to load best state
              	0.00694     	-0.03705    	0.01713     	12               eval state : test_on_restore;
              	0.00694     	-0.03705    	0.01713     	12               eval state : test_on_last_epoch;
---> final result              	0.00694     	-0.03705    	0.01713     	12               eval state : final;module_name : SGAR;subset : 1;cp_record_file : True;
---> end


---------->
SGAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 30, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00298     	0.58324     	0.01010     	0           
  10          	0.00306     	0.52801     	0.01120     	0           
  100         	0.00639     	0.49683     	0.01635     	1           
  300         	0.00668     	0.45138     	0.01727     	4           
  500         	0.00674     	0.40954     	0.01719     	7           
  1000        	0.00693     	0.34297     	0.01716     	14          
---> try to load best state
              	0.00693     	0.34297     	0.01716     	14               eval state : test_on_restore;
              	0.00693     	0.34297     	0.01716     	14               eval state : test_on_last_epoch;
---> final result              	0.00693     	0.34297     	0.01716     	14               eval state : final;module_name : SGAR;subset : 2;cp_record_file : True;
---> end


---------->
SGAR for 4 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 28, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00306     	0.58786     	0.01033     	0           
  10          	0.00318     	0.55743     	0.01145     	0           
  100         	0.00638     	0.50980     	0.01627     	1           
  300         	0.00678     	0.50348     	0.01701     	3           
  500         	0.00672     	0.45581     	0.01703     	6           
  1000        	0.00685     	0.39601     	0.01700     	14          
---> try to load best state
              	0.00685     	0.39601     	0.01700     	14               eval state : test_on_restore;
              	0.00685     	0.39601     	0.01700     	14               eval state : test_on_last_epoch;
---> final result              	0.00685     	0.39601     	0.01700     	14               eval state : final;module_name : SGAR;subset : 4;cp_record_file : True;
---> end


---------->
SGAR for 8 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 24, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00346     	0.60264     	0.01042     	0           
  10          	0.00357     	0.63780     	0.01152     	0           
  100         	0.00660     	0.56287     	0.01618     	1           
  300         	0.00694     	0.53573     	0.01694     	3           
  500         	0.00699     	0.50830     	0.01691     	6           
  1000        	0.00699     	0.45249     	0.01691     	13          
---> try to load best state
              	0.00699     	0.45249     	0.01691     	13               eval state : test_on_restore;
              	0.00699     	0.45249     	0.01691     	13               eval state : test_on_last_epoch;
---> final result              	0.00699     	0.45249     	0.01691     	13               eval state : final;module_name : SGAR;subset : 8;cp_record_file : True;
---> end


---------->
SGAR for 16 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 16, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00470     	0.59943     	0.01146     	0           
  10          	0.00467     	0.61971     	0.01237     	0           
  100         	0.00706     	0.59080     	0.01630     	1           
  300         	0.00732     	0.55661     	0.01695     	3           
  500         	0.00735     	0.53717     	0.01693     	6           
  1000        	0.00731     	0.51790     	0.01692     	14          
---> try to load best state
              	0.00731     	0.51790     	0.01692     	14               eval state : test_on_restore;
              	0.00731     	0.51790     	0.01692     	14               eval state : test_on_last_epoch;
---> final result              	0.00731     	0.51790     	0.01692     	14               eval state : final;module_name : SGAR;subset : 16;cp_record_file : True;
---> end


---------->
SGAR for 32 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00767     	0.58490     	0.01484     	0           
  10          	0.00830     	0.54757     	0.01602     	0           
----------------------------------------

  Demo NAR cigp 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00289     	0.00871     	0.94499     	0           
  10          	0.00287     	0.00862     	0.94596     	0           
  100         	0.00261     	0.00777     	0.95490     	0           
  300         	0.00199     	0.00620     	0.96898     	0           
  500         	0.00172     	0.00552     	0.97395     	1           
  1000        	0.00156     	0.00494     	0.97758     	2           
---> try to load best state
              	0.00156     	0.00494     	0.97758     	2                eval state : test_on_restore;
              	0.00156     	0.00494     	0.97758     	2                eval state : test_on_last_epoch;
---> final result
              	0.00156     	0.00494     	0.97758     	2                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 31, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00916     	0.04774     	-2.74695    	0           
  10          	0.00913     	0.04767     	-2.71601    	0           
  100         	0.00882     	0.04699     	-2.43438    	0           
  300         	0.00824     	0.04565     	-1.95828    	1           
  500         	0.00775     	0.04446     	-1.60691    	1           
  1000        	0.00675     	0.04192     	-1.02751    	3           
---> try to load best state
              	0.00675     	0.04192     	-1.02751    	3                eval state : test_on_restore;
              	0.00675     	0.04192     	-1.02751    	3                eval state : test_on_last_epoch;
---> final result
              	0.00675     	0.04192     	-1.02751    	3                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 30, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00918     	0.04776     	-2.75103    	0           
  10          	0.00915     	0.04769     	-2.72016    	0           
  100         	0.00883     	0.04701     	-2.43699    	0           
  300         	0.00825     	0.04566     	-1.95945    	1           
  500         	0.00775     	0.04447     	-1.60594    	1           
  1000        	0.00674     	0.04190     	-1.02300    	4           
---> try to load best state
              	0.00674     	0.04190     	-1.02300    	4                eval state : test_on_restore;
              	0.00674     	0.04190     	-1.02300    	4                eval state : test_on_last_epoch;
---> final result
              	0.00674     	0.04190     	-1.02300    	4                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


---------->
NAR for 4 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 28, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00928     	0.04786     	-2.77876    	0           
  10          	0.00925     	0.04779     	-2.74805    	0           
  100         	0.00891     	0.04709     	-2.45666    	0           
  300         	0.00829     	0.04571     	-1.96865    	0           
  500         	0.00778     	0.04451     	-1.61009    	1           
  1000        	0.00676     	0.04193     	-1.02435    	2           
---> try to load best state
              	0.00676     	0.04193     	-1.02435    	2                eval state : test_on_restore;
              	0.00676     	0.04193     	-1.02435    	2                eval state : test_on_last_epoch;
---> final result
              	0.00676     	0.04193     	-1.02435    	2                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


---------->
NAR for 8 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 24, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00960     	0.04873     	-2.99431    	0           
  10          	0.00957     	0.04867     	-2.96095    	0           
  100         	0.00926     	0.04803     	-2.66438    	0           
  300         	0.00871     	0.04680     	-2.16390    	0           
  500         	0.00825     	0.04571     	-1.79484    	1           
  1000        	0.00736     	0.04331     	-1.18913    	2           
---> try to load best state
              	0.00736     	0.04331     	-1.18913    	3                eval state : test_on_restore;
              	0.00736     	0.04331     	-1.18913    	3                eval state : test_on_last_epoch;
---> final result
              	0.00736     	0.04331     	-1.18913    	3                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


---------->
NAR for 16 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 16, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01008     	0.05022     	-3.47602    	0           
  10          	0.01004     	0.05015     	-3.43865    	0           
  100         	0.00972     	0.04947     	-3.08998    	0           
  300         	0.00911     	0.04810     	-2.47805    	0           
  500         	0.00860     	0.04690     	-2.02417    	1           
  1000        	0.00766     	0.04438     	-1.30972    	2           
---> try to load best state
              	0.00766     	0.04438     	-1.30972    	2                eval state : test_on_restore;
              	0.00766     	0.04438     	-1.30972    	2                eval state : test_on_last_epoch;
---> final result
              	0.00766     	0.04438     	-1.30972    	2                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


---------->
NAR for 32 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01011     	0.04946     	-4.80873    	0           
  10          	0.01006     	0.04938     	-4.75213    	0           
  100         	0.00965     	0.04856     	-4.22266    	0           
  300         	0.00888     	0.04691     	-3.27356    	0           
  500         	0.00829     	0.04549     	-2.56777    	1           
  1000        	0.00734     	0.04269     	-1.47566    	2           
---> try to load best state
              	0.00734     	0.04269     	-1.47566    	2                eval state : test_on_restore;
              	0.00734     	0.04269     	-1.47566    	2                eval state : test_on_last_epoch;
---> final result
              	0.00734     	0.04269     	-1.47566    	2                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

----------------------------------------

  Demo NAR cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00300     	0.00990     	0.93659     	0           
  10          	0.00298     	0.00978     	0.93792     	0           
  100         	0.00281     	0.00873     	0.94919     	0           
  300         	0.00215     	0.00681     	0.96562     	0           
  500         	0.00177     	0.00566     	0.97248     	0           
  1000        	0.00179     	0.00527     	0.97372     	1           
---> try to load best state
              	0.00179     	0.00527     	0.97372     	1                eval state : test_on_restore;
              	0.00179     	0.00527     	0.97372     	1                eval state : test_on_last_epoch;
---> final result
              	0.00179     	0.00527     	0.97372     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 0, 'train_start_index': 31, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00887     	0.04401     	0.07928     	0           
  10          	0.00884     	0.04394     	0.08858     	0           
  100         	0.00857     	0.04335     	0.17523     	0           
  300         	0.00813     	0.04244     	0.29723     	0           
  500         	0.00782     	0.04183     	0.36729     	1           
  1000        	0.00735     	0.04074     	0.45926     	3           
---> try to load best state
              	0.00735     	0.04074     	0.45926     	3                eval state : test_on_restore;
              	0.00735     	0.04074     	0.45926     	3                eval state : test_on_last_epoch;
---> final result
              	0.00735     	0.04074     	0.45926     	3                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 0, 'train_start_index': 30, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00855     	0.04268     	0.13822     	0           
  10          	0.00852     	0.04262     	0.14802     	0           
  100         	0.00822     	0.04201     	0.23142     	0           
  300         	0.00773     	0.04109     	0.34791     	0           
  500         	0.00740     	0.04046     	0.41447     	1           
  1000        	0.00689     	0.03920     	0.50236     	3           
---> try to load best state
              	0.00689     	0.03920     	0.50236     	3                eval state : test_on_restore;
              	0.00689     	0.03920     	0.50236     	3                eval state : test_on_last_epoch;
---> final result
              	0.00689     	0.03920     	0.50236     	3                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


---------->
NAR for 4 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 0, 'train_start_index': 28, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00840     	0.04173     	0.17635     	0           
  10          	0.00836     	0.04165     	0.18608     	0           
  100         	0.00806     	0.04098     	0.26644     	0           
  300         	0.00756     	0.03989     	0.37990     	1           
  500         	0.00719     	0.03909     	0.44694     	2           
  1000        	0.00660     	0.03754     	0.53740     	3           
---> try to load best state
              	0.00660     	0.03754     	0.53740     	3                eval state : test_on_restore;
              	0.00660     	0.03754     	0.53740     	3                eval state : test_on_last_epoch;
---> final result
              	0.00660     	0.03754     	0.53740     	3                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


---------->
NAR for 8 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 0, 'train_start_index': 24, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01185     	0.05657     	-12.22754   	0           
  10          	0.01183     	0.05652     	-12.10565   	0           
  100         	0.01158     	0.05607     	-10.94306   	0           
  300         	0.01113     	0.05515     	-8.75224    	1           
  500         	0.01077     	0.05430     	-7.08106    	1           
  1000        	0.01005     	0.05228     	-4.47825    	3           
---> try to load best state
              	0.01005     	0.05228     	-4.47825    	3                eval state : test_on_restore;
              	0.01005     	0.05228     	-4.47825    	3                eval state : test_on_last_epoch;
---> final result
              	0.01005     	0.05228     	-4.47825    	3                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


---------->
NAR for 16 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 0, 'train_start_index': 16, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01229     	0.05432     	-11.09275   	0           
  10          	0.01225     	0.05426     	-10.97521   	0           
  100         	0.01186     	0.05372     	-9.86422    	0           
  300         	0.01121     	0.05268     	-7.82913    	1           
  500         	0.01075     	0.05176     	-6.31346    	1           
  1000        	0.00991     	0.04966     	-3.94274    	3           
---> try to load best state
              	0.00991     	0.04966     	-3.94274    	3                eval state : test_on_restore;
              	0.00991     	0.04966     	-3.94274    	3                eval state : test_on_last_epoch;
---> final result
              	0.00991     	0.04966     	-3.94274    	3                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


---------->
NAR for 32 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01248     	0.05544     	-9.82572    	0           
  10          	0.01244     	0.05540     	-9.76584    	0           
  100         	0.01210     	0.05503     	-9.23416    	0           
  300         	0.01151     	0.05439     	-8.36743    	1           
  500         	0.01108     	0.05391     	-7.74653    	1           
  1000        	0.01036     	0.05312     	-6.70904    	3           
---> try to load best state
              	0.01036     	0.05312     	-6.70904    	3                eval state : test_on_restore;
              	0.01036     	0.05312     	-6.70904    	3                eval state : test_on_last_epoch;
---> final result
              	0.01036     	0.05312     	-6.70904    	3                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

----------------------------------------

  Demo NAR cigp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00286     	0.01166     	0.88424     	0           
  10          	0.00283     	0.01154     	0.88678     	0           
  100         	0.00255     	0.01029     	0.91097     	0           
  300         	0.00197     	0.00768     	0.94990     	0           
  500         	0.00166     	0.00647     	0.96299     	0           
  1000        	0.00153     	0.00569     	0.96937     	1           
---> try to load best state
              	0.00153     	0.00569     	0.96937     	1                eval state : test_on_restore;
              	0.00153     	0.00569     	0.96937     	1                eval state : test_on_last_epoch;
---> final result
              	0.00153     	0.00569     	0.96937     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 1, 'train_start_index': 31, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00698     	0.03458     	0.45925     	0           
  10          	0.00694     	0.03444     	0.46858     	0           
  100         	0.00649     	0.03307     	0.54890     	0           
  300         	0.00573     	0.03063     	0.66954     	0           
  500         	0.00516     	0.02880     	0.74554     	1           
  1000        	0.00427     	0.02592     	0.84310     	3           
---> try to load best state
              	0.00427     	0.02592     	0.84310     	3                eval state : test_on_restore;
              	0.00427     	0.02592     	0.84310     	3                eval state : test_on_last_epoch;
---> final result
              	0.00427     	0.02592     	0.84310     	3                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 1, 'train_start_index': 30, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00948     	0.04639     	-1.59716    	0           
  10          	0.00944     	0.04627     	-1.56180    	0           
  100         	0.00901     	0.04509     	-1.24343    	0           
  300         	0.00819     	0.04267     	-0.71207    	1           
  500         	0.00751     	0.04044     	-0.33266    	1           
  1000        	0.00628     	0.03582     	0.23421     	2           
---> try to load best state
              	0.00628     	0.03582     	0.23421     	2                eval state : test_on_restore;
              	0.00628     	0.03582     	0.23421     	2                eval state : test_on_last_epoch;
---> final result
              	0.00628     	0.03582     	0.23421     	2                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


---------->
NAR for 4 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 1, 'train_start_index': 28, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00918     	0.04719     	-1.60224    	0           
  10          	0.00914     	0.04707     	-1.56797    	0           
  100         	0.00877     	0.04592     	-1.25339    	0           
  300         	0.00807     	0.04352     	-0.72951    	1           
  500         	0.00747     	0.04131     	-0.35348    	1           
  1000        	0.00636     	0.03675     	0.21157     	2           
---> try to load best state
              	0.00636     	0.03675     	0.21157     	2                eval state : test_on_restore;
              	0.00636     	0.03675     	0.21157     	2                eval state : test_on_last_epoch;
---> final result
              	0.00636     	0.03675     	0.21157     	2                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


---------->
NAR for 8 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 1, 'train_start_index': 24, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01012     	0.05110     	-3.13637    	0           
  10          	0.01008     	0.05099     	-3.08414    	0           
  100         	0.00971     	0.05002     	-2.63041    	0           
  300         	0.00903     	0.04801     	-1.87865    	1           
  500         	0.00847     	0.04609     	-1.34890    	1           
  1000        	0.00737     	0.04151     	-0.50777    	3           
---> try to load best state
              	0.00737     	0.04151     	-0.50777    	3                eval state : test_on_restore;
              	0.00737     	0.04151     	-0.50777    	3                eval state : test_on_last_epoch;
---> final result
              	0.00737     	0.04151     	-0.50777    	3                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


---------->
NAR for 16 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 1, 'train_start_index': 16, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01276     	0.05913     	-8.55486    	0           
  10          	0.01274     	0.05910     	-8.48120    	0           
  100         	0.01254     	0.05878     	-7.80106    	0           
  300         	0.01218     	0.05813     	-6.77083    	0           
  500         	0.01188     	0.05754     	-6.05186    	1           
  1000        	0.01130     	0.05631     	-4.89046    	3           
---> try to load best state
              	0.01130     	0.05631     	-4.89046    	3                eval state : test_on_restore;
              	0.01130     	0.05631     	-4.89046    	3                eval state : test_on_last_epoch;
---> final result
              	0.01130     	0.05631     	-4.89046    	3                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


---------->
NAR for 32 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01178     	0.05580     	-8.94562    	0           
  10          	0.01174     	0.05577     	-8.88546    	0           
  100         	0.01144     	0.05549     	-8.36093    	0           
  300         	0.01103     	0.05495     	-7.55702    	0           
  500         	0.01075     	0.05448     	-7.02243    	1           
  1000        	0.01024     	0.05347     	-6.16480    	3           
---> try to load best state
              	0.01024     	0.05347     	-6.16480    	3                eval state : test_on_restore;
              	0.01024     	0.05347     	-6.16480    	3                eval state : test_on_last_epoch;
---> final result
              	0.01024     	0.05347     	-6.16480    	3                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

----------------------------------------

  Demo NAR cigp 
  seed: 2 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00316     	0.01023     	0.89165     	0           
  10          	0.00315     	0.01015     	0.89310     	0           
  100         	0.00301     	0.00947     	0.90561     	0           
  300         	0.00259     	0.00846     	0.92355     	0           
  500         	0.00231     	0.00788     	0.93208     	0           
  1000        	0.00206     	0.00724     	0.94051     	1           
---> try to load best state
              	0.00206     	0.00724     	0.94051     	1                eval state : test_on_restore;
              	0.00206     	0.00724     	0.94051     	1                eval state : test_on_last_epoch;
---> final result
              	0.00206     	0.00724     	0.94051     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 2, 'train_start_index': 31, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00724     	0.03403     	0.40806     	0           
  10          	0.00718     	0.03388     	0.41885     	0           
  100         	0.00666     	0.03251     	0.51056     	0           
  300         	0.00585     	0.03000     	0.64437     	1           
  500         	0.00526     	0.02798     	0.72893     	1           
  1000        	0.00423     	0.02447     	0.83941     	3           
---> try to load best state
              	0.00423     	0.02447     	0.83941     	3                eval state : test_on_restore;
              	0.00423     	0.02447     	0.83941     	3                eval state : test_on_last_epoch;
---> final result
              	0.00423     	0.02447     	0.83941     	3                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 2, 'train_start_index': 30, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00688     	0.03219     	0.49237     	0           
  10          	0.00682     	0.03204     	0.50193     	0           
  100         	0.00629     	0.03058     	0.58453     	0           
  300         	0.00548     	0.02798     	0.70310     	0           
  500         	0.00489     	0.02596     	0.77608     	1           
  1000        	0.00392     	0.02262     	0.86788     	3           
---> try to load best state
              	0.00392     	0.02262     	0.86788     	3                eval state : test_on_restore;
              	0.00392     	0.02262     	0.86788     	3                eval state : test_on_last_epoch;
---> final result
              	0.00392     	0.02262     	0.86788     	3                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


---------->
NAR for 4 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 2, 'train_start_index': 28, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00914     	0.03433     	0.41694     	0           
  10          	0.00906     	0.03413     	0.42876     	0           
  100         	0.00831     	0.03226     	0.52912     	0           
  300         	0.00698     	0.02891     	0.67521     	1           
  500         	0.00599     	0.02642     	0.76283     	2           
  1000        	0.00439     	0.02262     	0.86632     	4           
---> try to load best state
              	0.00439     	0.02262     	0.86632     	4                eval state : test_on_restore;
              	0.00439     	0.02262     	0.86632     	4                eval state : test_on_last_epoch;
---> final result
              	0.00439     	0.02262     	0.86632     	4                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


---------->
NAR for 8 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 2, 'train_start_index': 24, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00930     	0.04309     	-1.10928    	0           
  10          	0.00923     	0.04298     	-1.07397    	0           
  100         	0.00860     	0.04191     	-0.78404    	0           
  300         	0.00768     	0.03995     	-0.39011    	1           
  500         	0.00717     	0.03830     	-0.16067    	1           
  1000        	0.00625     	0.03487     	0.17354     	3           
---> try to load best state
              	0.00625     	0.03487     	0.17354     	3                eval state : test_on_restore;
              	0.00625     	0.03487     	0.17354     	3                eval state : test_on_last_epoch;
---> final result
              	0.00625     	0.03487     	0.17354     	3                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


---------->
NAR for 16 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 2, 'train_start_index': 16, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00959     	0.04383     	-1.67709    	0           
  10          	0.00953     	0.04373     	-1.64776    	0           
  100         	0.00899     	0.04284     	-1.38704    	0           
  300         	0.00809     	0.04124     	-0.96599    	0           
  500         	0.00747     	0.04004     	-0.68455    	1           
  1000        	0.00651     	0.03816     	-0.30561    	3           
---> try to load best state
              	0.00651     	0.03816     	-0.30561    	3                eval state : test_on_restore;
              	0.00651     	0.03816     	-0.30561    	3                eval state : test_on_last_epoch;
---> final result
              	0.00651     	0.03816     	-0.30561    	3                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


---------->
NAR for 32 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01059     	0.04474     	-3.09601    	0           
  10          	0.01051     	0.04461     	-3.03389    	0           
  100         	0.00976     	0.04340     	-2.48907    	0           
  300         	0.00848     	0.04106     	-1.65230    	1           
  500         	0.00756     	0.03905     	-1.11598    	1           
  1000        	0.00617     	0.03511     	-0.38544    	3           
---> try to load best state
              	0.00617     	0.03511     	-0.38544    	3                eval state : test_on_restore;
              	0.00617     	0.03511     	-0.38544    	3                eval state : test_on_last_epoch;
---> final result
              	0.00617     	0.03511     	-0.38544    	3                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

----------------------------------------

  Demo NAR cigp 
  seed: 3 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00279     	0.00976     	0.91159     	0           
  10          	0.00277     	0.00966     	0.91310     	0           
  100         	0.00260     	0.00879     	0.92658     	0           
  300         	0.00210     	0.00733     	0.94663     	0           
  500         	0.00183     	0.00668     	0.95420     	0           
  1000        	0.00165     	0.00607     	0.96027     	1           
---> try to load best state
              	0.00165     	0.00607     	0.96027     	1                eval state : test_on_restore;
              	0.00165     	0.00607     	0.96027     	1                eval state : test_on_last_epoch;
---> final result
              	0.00165     	0.00607     	0.96027     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 3, 'train_start_index': 31, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00778     	0.03507     	0.53386     	0           
  10          	0.00770     	0.03485     	0.54446     	0           
  100         	0.00701     	0.03279     	0.63352     	0           
  300         	0.00573     	0.02883     	0.75601     	1           
  500         	0.00481     	0.02541     	0.82640     	2           
  1000        	0.00320     	0.01825     	0.91963     	3           
---> try to load best state
              	0.00320     	0.01825     	0.91963     	3                eval state : test_on_restore;
              	0.00320     	0.01825     	0.91963     	3                eval state : test_on_last_epoch;
---> final result
              	0.00320     	0.01825     	0.91963     	3                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 3, 'train_start_index': 30, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00778     	0.03457     	0.54135     	0           
  10          	0.00771     	0.03436     	0.55191     	0           
  100         	0.00700     	0.03232     	0.63960     	0           
  300         	0.00571     	0.02841     	0.76023     	1           
  500         	0.00479     	0.02507     	0.82929     	1           
  1000        	0.00320     	0.01806     	0.92049     	3           
---> try to load best state
              	0.00320     	0.01806     	0.92049     	3                eval state : test_on_restore;
              	0.00320     	0.01806     	0.92049     	3                eval state : test_on_last_epoch;
---> final result
              	0.00320     	0.01806     	0.92049     	3                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


---------->
NAR for 4 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 3, 'train_start_index': 28, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00764     	0.03360     	0.58407     	0           
  10          	0.00757     	0.03340     	0.59334     	0           
  100         	0.00688     	0.03154     	0.67188     	0           
  300         	0.00569     	0.02819     	0.77776     	1           
  500         	0.00490     	0.02553     	0.83693     	1           
  1000        	0.00363     	0.02041     	0.91381     	3           
---> try to load best state
              	0.00363     	0.02041     	0.91381     	3                eval state : test_on_restore;
              	0.00363     	0.02041     	0.91381     	3                eval state : test_on_last_epoch;
---> final result
              	0.00363     	0.02041     	0.91381     	3                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


---------->
NAR for 8 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 3, 'train_start_index': 24, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00719     	0.03536     	0.51616     	0           
  10          	0.00714     	0.03520     	0.52504     	0           
  100         	0.00663     	0.03379     	0.59845     	0           
  300         	0.00576     	0.03120     	0.69855     	1           
  500         	0.00516     	0.02909     	0.75524     	1           
  1000        	0.00408     	0.02476     	0.83505     	3           
---> try to load best state
              	0.00408     	0.02476     	0.83505     	3                eval state : test_on_restore;
              	0.00408     	0.02476     	0.83505     	3                eval state : test_on_last_epoch;
---> final result
              	0.00408     	0.02476     	0.83505     	3                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


---------->
NAR for 16 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 3, 'train_start_index': 16, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00788     	0.03889     	0.40230     	0           
  10          	0.00784     	0.03877     	0.41214     	0           
  100         	0.00744     	0.03757     	0.49414     	0           
  300         	0.00673     	0.03534     	0.60792     	1           
  500         	0.00623     	0.03347     	0.67361     	1           
  1000        	0.00529     	0.02951     	0.76797     	3           
---> try to load best state
              	0.00529     	0.02951     	0.76797     	3                eval state : test_on_restore;
              	0.00529     	0.02951     	0.76797     	3                eval state : test_on_last_epoch;
---> final result
              	0.00529     	0.02951     	0.76797     	3                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


---------->
NAR for 32 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01078     	0.04955     	-5.92067    	0           
  10          	0.01074     	0.04948     	-5.85388    	0           
  100         	0.01030     	0.04880     	-5.23220    	0           
  300         	0.00964     	0.04736     	-4.11509    	0           
  500         	0.00912     	0.04607     	-3.27804    	1           
  1000        	0.00811     	0.04327     	-1.95418    	3           
---> try to load best state
              	0.00811     	0.04327     	-1.95418    	3                eval state : test_on_restore;
              	0.00811     	0.04327     	-1.95418    	3                eval state : test_on_last_epoch;
---> final result
              	0.00811     	0.04327     	-1.95418    	3                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

----------------------------------------

  Demo NAR cigp 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00299     	0.01154     	0.85365     	0           
  10          	0.00300     	0.01155     	0.85332     	0           
  100         	0.00296     	0.01136     	0.85716     	0           
  300         	0.00284     	0.01093     	0.86587     	0           
  500         	0.00275     	0.01060     	0.87242     	0           
  1000        	0.00256     	0.00997     	0.88428     	1           
---> try to load best state
              	0.00256     	0.00997     	0.88428     	1                eval state : test_on_restore;
              	0.00256     	0.00997     	0.88428     	1                eval state : test_on_last_epoch;
---> final result
              	0.00256     	0.00997     	0.88428     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 4, 'train_start_index': 31, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00623     	0.03753     	-0.30479    	0           
  10          	0.00620     	0.03749     	-0.29931    	0           
  100         	0.00593     	0.03703     	-0.25271    	0           
  300         	0.00545     	0.03611     	-0.17480    	1           
  500         	0.00509     	0.03531     	-0.11555    	1           
  1000        	0.00448     	0.03383     	-0.01119    	3           
---> try to load best state
              	0.00448     	0.03383     	-0.01119    	3                eval state : test_on_restore;
              	0.00448     	0.03383     	-0.01119    	3                eval state : test_on_last_epoch;
---> final result
              	0.00448     	0.03383     	-0.01119    	3                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 4, 'train_start_index': 30, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00673     	0.03734     	-0.31312    	0           
  10          	0.00669     	0.03729     	-0.30718    	0           
  100         	0.00629     	0.03675     	-0.25596    	0           
  300         	0.00563     	0.03576     	-0.17143    	1           
  500         	0.00516     	0.03493     	-0.10832    	1           
  1000        	0.00445     	0.03343     	-0.00022    	3           
---> try to load best state
              	0.00445     	0.03343     	-0.00022    	3                eval state : test_on_restore;
              	0.00445     	0.03343     	-0.00022    	3                eval state : test_on_last_epoch;
---> final result
              	0.00445     	0.03343     	-0.00022    	3                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


---------->
NAR for 4 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 4, 'train_start_index': 28, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00699     	0.03811     	-0.42438    	0           
  10          	0.00694     	0.03805     	-0.41478    	0           
  100         	0.00650     	0.03752     	-0.33341    	0           
  300         	0.00582     	0.03659     	-0.22034    	1           
  500         	0.00540     	0.03585     	-0.15070    	2           
  1000        	0.00473     	0.03447     	-0.04595    	3           
---> try to load best state
              	0.00473     	0.03447     	-0.04595    	3                eval state : test_on_restore;
              	0.00473     	0.03447     	-0.04595    	3                eval state : test_on_last_epoch;
---> final result
              	0.00473     	0.03447     	-0.04595    	3                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


---------->
NAR for 8 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 4, 'train_start_index': 24, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00784     	0.03985     	-0.81025    	0           
  10          	0.00778     	0.03977     	-0.79500    	0           
  100         	0.00725     	0.03898     	-0.66269    	0           
  300         	0.00646     	0.03761     	-0.46256    	1           
  500         	0.00594     	0.03656     	-0.32974    	1           
  1000        	0.00504     	0.03457     	-0.11892    	3           
---> try to load best state
              	0.00504     	0.03457     	-0.11892    	3                eval state : test_on_restore;
              	0.00504     	0.03457     	-0.11892    	3                eval state : test_on_last_epoch;
---> final result
              	0.00504     	0.03457     	-0.11892    	3                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


---------->
NAR for 16 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 4, 'train_start_index': 16, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01071     	0.04836     	-2.36120    	0           
  10          	0.01064     	0.04823     	-2.31930    	0           
  100         	0.00994     	0.04692     	-1.94379    	0           
  300         	0.00873     	0.04447     	-1.36023    	1           
  500         	0.00784     	0.04257     	-0.98400    	2           
  1000        	0.00642     	0.03933     	-0.46807    	3           
---> try to load best state
              	0.00642     	0.03933     	-0.46807    	3                eval state : test_on_restore;
              	0.00642     	0.03933     	-0.46807    	3                eval state : test_on_last_epoch;
---> final result
              	0.00642     	0.03933     	-0.46807    	3                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


---------->
NAR for 32 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'Burget_mfGent_v5', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.01327     	0.05388     	-10.98442   	0           
  10          	0.01320     	0.05377     	-10.77267   	0           
  100         	0.01254     	0.05268     	-8.90921    	0           
  300         	0.01134     	0.05055     	-6.10722    	1           
  500         	0.01038     	0.04869     	-4.40763    	1           
  1000        	0.00864     	0.04490     	-2.27849    	3           
---> try to load best state
              	0.00864     	0.04490     	-2.27849    	3                eval state : test_on_restore;
              	0.00864     	0.04490     	-2.27849    	3                eval state : test_on_last_epoch;
---> final result
              	0.00864     	0.04490     	-2.27849    	3                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
