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

  Demo GAR 
  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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00403     	0.60659     	0.00846     	0           
  10          	0.00534     	0.55822     	0.01094     	0           
  100         	0.00839     	0.29462     	0.01558     	0           
  300         	0.01065     	-0.08911    	0.02022     	1           
  500         	0.01029     	-0.02009    	0.01986     	2           
  1000        	0.00935     	0.10257     	0.01806     	5           
---> try to load best state
              	0.00935     	0.10257     	0.01806     	5                eval state : test_on_restore;
              	0.00935     	0.10257     	0.01806     	5                eval state : test_on_last_epoch;
---> final result              	0.00935     	0.10257     	0.01806     	5                eval state : final;
----------> finish x-yl training


---------->
GAR 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.00210     	0.65489     	0.00647     	0           
  10          	0.00260     	0.52138     	0.00705     	0           
  100         	0.00429     	-0.55198    	0.00970     	2           
  300         	0.00492     	0.05748     	0.01071     	5           
  500         	0.00516     	-0.12992    	0.01086     	9           
  1000        	0.00546     	-0.22973    	0.01093     	18          
---> try to load best state
              	0.00546     	-0.22973    	0.01093     	18               eval state : test_on_restore;
              	0.00546     	-0.22973    	0.01093     	18               eval state : test_on_last_epoch;
---> final result
              	0.00546     	-0.22973    	0.01093     	19               eval state : final;module_name : GAR;subset : 1;cp_record_file : True;
---> end


---------->
GAR 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.00215     	0.65579     	0.00650     	0           
  10          	0.00250     	0.54736     	0.00705     	0           
  100         	0.00423     	-1.31562    	0.00969     	2           
  300         	0.00521     	-1.74378    	0.01088     	6           
  500         	0.00516     	-0.02417    	0.01082     	10          
  1000        	0.00531     	-0.21265    	0.01081     	20          
---> try to load best state
              	0.00531     	-0.21265    	0.01081     	20               eval state : test_on_restore;
              	0.00531     	-0.21265    	0.01081     	20               eval state : test_on_last_epoch;
---> final result
              	0.00531     	-0.21265    	0.01081     	20               eval state : final;module_name : GAR;subset : 2;cp_record_file : True;
---> end


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

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

  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: 100.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.00175     	0.74600     	0.00406     	0           
  10          	0.00194     	0.73732     	0.00451     	0           
  100         	0.00411     	0.65733     	0.00862     	0           
  300         	0.00443     	0.68749     	0.00928     	1           
  500         	0.00440     	0.69377     	0.00921     	2           
  1000        	0.00434     	0.69580     	0.00907     	5           
---> try to load best state
              	0.00434     	0.69580     	0.00907     	5                eval state : test_on_restore;
              	0.00434     	0.69580     	0.00907     	5                eval state : test_on_last_epoch;
---> final result              	0.00434     	0.69580     	0.00907     	5                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: 100.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.00138     	0.82382     	0.00535     	0           
  10          	0.00140     	0.80086     	0.00559     	0           
  100         	0.00315     	0.71901     	0.00855     	1           
  300         	0.00306     	0.67298     	0.00843     	4           
  500         	0.00322     	0.61968     	0.00855     	7           
  1000        	0.00344     	0.58340     	0.00892     	12          
---> try to load best state
              	0.00344     	0.58340     	0.00892     	12               eval state : test_on_restore;
              	0.00344     	0.58340     	0.00892     	12               eval state : test_on_last_epoch;
---> final result              	0.00344     	0.58340     	0.00892     	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: 100.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.00138     	0.81770     	0.00538     	0           
  10          	0.00142     	0.80855     	0.00567     	0           
  100         	0.00317     	0.72835     	0.00851     	2           
  300         	0.00305     	0.67074     	0.00842     	4           
  500         	0.00335     	0.55001     	0.00839     	7           
  1000        	0.00379     	0.31269     	0.00893     	13          
---> try to load best state
              	0.00379     	0.31269     	0.00893     	13               eval state : test_on_restore;
              	0.00379     	0.31269     	0.00893     	13               eval state : test_on_last_epoch;
---> final result              	0.00379     	0.31269     	0.00893     	13               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: 100.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.00139     	0.81033     	0.00541     	0           
  10          	0.00144     	0.81269     	0.00576     	0           
  100         	0.00319     	0.72670     	0.00848     	1           
  300         	0.00315     	0.66318     	0.00869     	3           
  500         	0.00329     	0.57996     	0.00899     	5           
  1000        	0.00345     	0.51327     	0.00911     	10          
---> try to load best state
              	0.00345     	0.51327     	0.00911     	10               eval state : test_on_restore;
              	0.00345     	0.51327     	0.00911     	11               eval state : test_on_last_epoch;
---> final result              	0.00345     	0.51327     	0.00911     	11               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: 100.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.00164     	0.80481     	0.00576     	0           
  10          	0.00172     	0.83445     	0.00622     	0           
  100         	0.00325     	0.74346     	0.00850     	1           
  300         	0.00333     	0.71359     	0.00858     	3           
  500         	0.00331     	0.71950     	0.00883     	5           
  1000        	0.00367     	0.54487     	0.00872     	10          
---> try to load best state
              	0.00367     	0.54487     	0.00872     	10               eval state : test_on_restore;
              	0.00367     	0.54487     	0.00872     	10               eval state : test_on_last_epoch;
---> final result              	0.00367     	0.54487     	0.00872     	10               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: 100.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.00219     	0.79962     	0.00612     	0           
  10          	0.00218     	0.81705     	0.00656     	0           
  100         	0.00346     	0.76049     	0.00850     	1           
  300         	0.00346     	0.73288     	0.00856     	3           
  500         	0.00346     	0.75122     	0.00856     	4           
  1000        	0.00347     	0.72854     	0.00856     	10          
---> try to load best state
              	0.00347     	0.72854     	0.00856     	10               eval state : test_on_restore;
              	0.00347     	0.72854     	0.00856     	10               eval state : test_on_last_epoch;
---> final result              	0.00347     	0.72854     	0.00856     	10               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: 100.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.00351     	0.81250     	0.00751     	0           
  10          	0.00407     	0.78467     	0.00851     	0           
  100         	0.00406     	0.78544     	0.00892     	1           
  300         	0.00402     	0.77143     	0.00892     	2           
  500         	0.00404     	0.78234     	0.00892     	5           
  1000        	0.00407     	0.77549     	0.00894     	10          
---> try to load best state
              	0.00407     	0.77549     	0.00894     	10               eval state : test_on_restore;
              	0.00407     	0.77549     	0.00894     	10               eval state : test_on_last_epoch;
---> final result              	0.00407     	0.77549     	0.00894     	10               eval state : final;module_name : SGAR;subset : 32;cp_record_file : True;
---> end

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

  Demo sGAR 
  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': 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: 100.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.00238     	0.69696     	0.00564     	0           
  10          	0.00252     	0.69099     	0.00585     	0           
  100         	0.00433     	0.58863     	0.00883     	0           
  300         	0.00459     	0.63333     	0.01012     	1           
  500         	0.00458     	0.64509     	0.01003     	2           
  1000        	0.00454     	0.64801     	0.00986     	4           
---> try to load best state
              	0.00454     	0.64801     	0.00986     	4                eval state : test_on_restore;
              	0.00454     	0.64801     	0.00986     	4                eval state : test_on_last_epoch;
---> final result              	0.00454     	0.64801     	0.00986     	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': 0, '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: 100.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.00166     	0.90218     	0.00437     	0           
  10          	0.00161     	0.88763     	0.00406     	0           
  100         	0.00462     	0.80602     	0.00950     	1           
  300         	0.00396     	0.81351     	0.00820     	4           
  500         	0.00420     	0.80737     	0.00835     	7           
  1000        	0.00433     	0.75618     	0.00816     	14          
---> try to load best state
              	0.00433     	0.75618     	0.00816     	14               eval state : test_on_restore;
              	0.00433     	0.75618     	0.00816     	14               eval state : test_on_last_epoch;
---> final result              	0.00433     	0.75618     	0.00816     	14               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': 0, '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: 100.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.00177     	0.89023     	0.00480     	0           
  10          	0.00178     	0.88385     	0.00481     	0           
  100         	0.00461     	0.80692     	0.00942     	1           
  300         	0.00405     	0.82096     	0.00829     	4           
  500         	0.00411     	0.81082     	0.00813     	7           
  1000        	0.00544     	0.10482     	0.00941     	14          
---> try to load best state
              	0.00544     	0.10482     	0.00941     	14               eval state : test_on_restore;
              	0.00544     	0.10482     	0.00941     	14               eval state : test_on_last_epoch;
---> final result              	0.00544     	0.10482     	0.00941     	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': 0, '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: 100.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.00183     	0.87565     	0.00495     	0           
  10          	0.00184     	0.88855     	0.00507     	0           
  100         	0.00462     	0.80517     	0.00942     	1           
  300         	0.00425     	0.81829     	0.00861     	4           
  500         	0.00419     	0.80346     	0.00833     	7           
  1000        	0.00450     	0.74648     	0.00863     	13          
---> try to load best state
              	0.00450     	0.74648     	0.00863     	13               eval state : test_on_restore;
              	0.00450     	0.74648     	0.00863     	13               eval state : test_on_last_epoch;
---> final result              	0.00450     	0.74648     	0.00863     	13               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': 0, '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: 100.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.00177     	0.84470     	0.00477     	0           
  10          	0.00181     	0.88167     	0.00494     	0           
  100         	0.00387     	0.80484     	0.00847     	1           
  300         	0.00381     	0.79353     	0.00840     	3           
  500         	0.00388     	0.79066     	0.00843     	5           
  1000        	0.00394     	0.75371     	0.00851     	10          
---> try to load best state
              	0.00394     	0.75371     	0.00851     	10               eval state : test_on_restore;
              	0.00394     	0.75371     	0.00851     	10               eval state : test_on_last_epoch;
---> final result              	0.00394     	0.75371     	0.00851     	10               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': 0, '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: 100.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.00229     	0.81686     	0.00536     	0           
  10          	0.00225     	0.84539     	0.00532     	0           
  100         	0.00450     	0.78466     	0.00910     	1           
  300         	0.00473     	0.77591     	0.00954     	3           
  500         	0.00487     	0.75843     	0.00981     	5           
  1000        	0.00482     	0.75203     	0.00972     	13          
---> try to load best state
              	0.00482     	0.75203     	0.00972     	13               eval state : test_on_restore;
              	0.00482     	0.75203     	0.00972     	13               eval state : test_on_last_epoch;
---> final result              	0.00482     	0.75203     	0.00972     	13               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': 0, '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: 100.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.00359     	0.77583     	0.00777     	0           
  10          	0.00415     	0.73157     	0.00898     	0           
  100         	0.00424     	0.73826     	0.00952     	1           
  300         	0.00424     	0.72877     	0.00953     	3           
  500         	0.00426     	0.72697     	0.00952     	4           
  1000        	0.00428     	0.72569     	0.00958     	10          
---> try to load best state
              	0.00428     	0.72569     	0.00958     	10               eval state : test_on_restore;
              	0.00428     	0.72569     	0.00958     	10               eval state : test_on_last_epoch;
---> final result              	0.00428     	0.72569     	0.00958     	10               eval state : final;module_name : SGAR;subset : 32;cp_record_file : True;
---> end

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

  Demo sGAR 
  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': 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: 100.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.00186     	0.70668     	0.00404     	0           
  10          	0.00202     	0.69678     	0.00436     	0           
  100         	0.00394     	0.56807     	0.00977     	0           
  300         	0.00457     	0.58486     	0.01228     	1           
  500         	0.00453     	0.58690     	0.01217     	1           
  1000        	0.00445     	0.59322     	0.01192     	3           
---> try to load best state
              	0.00445     	0.59322     	0.01192     	3                eval state : test_on_restore;
              	0.00445     	0.59322     	0.01192     	3                eval state : test_on_last_epoch;
---> final result              	0.00445     	0.59322     	0.01192     	3                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': 1, '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: 100.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.00158     	0.90945     	0.00439     	0           
  10          	0.00152     	0.90851     	0.00414     	0           
  100         	0.00415     	0.81857     	0.00927     	1           
  300         	0.00424     	0.80826     	0.00913     	3           
  500         	0.00430     	0.79605     	0.00918     	5           
  1000        	0.00472     	0.57194     	0.00931     	10          
---> try to load best state
              	0.00472     	0.57194     	0.00931     	10               eval state : test_on_restore;
              	0.00472     	0.57194     	0.00931     	10               eval state : test_on_last_epoch;
---> final result              	0.00472     	0.57194     	0.00931     	10               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': 1, '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: 100.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.00156     	0.87682     	0.00482     	0           
  10          	0.00147     	0.90066     	0.00455     	0           
  100         	0.00372     	0.81098     	0.00891     	1           
  300         	0.00376     	0.78301     	0.00889     	3           
  500         	0.00388     	0.78098     	0.00890     	5           
  1000        	0.00405     	0.68568     	0.00904     	10          
---> try to load best state
              	0.00405     	0.68568     	0.00904     	10               eval state : test_on_restore;
              	0.00405     	0.68568     	0.00904     	10               eval state : test_on_last_epoch;
---> final result              	0.00405     	0.68568     	0.00904     	10               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': 1, '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: 100.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.00158     	0.87790     	0.00484     	0           
  10          	0.00151     	0.90522     	0.00466     	0           
  100         	0.00373     	0.81322     	0.00892     	1           
  300         	0.00384     	0.79867     	0.00886     	3           
  500         	0.00389     	0.78188     	0.00889     	5           
  1000        	0.00416     	0.62776     	0.00905     	10          
---> try to load best state
              	0.00416     	0.62776     	0.00905     	10               eval state : test_on_restore;
              	0.00416     	0.62776     	0.00905     	10               eval state : test_on_last_epoch;
---> final result              	0.00416     	0.62776     	0.00905     	10               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': 1, '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: 100.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.00165     	0.87218     	0.00484     	0           
  10          	0.00167     	0.90179     	0.00480     	0           
  100         	0.00382     	0.81852     	0.00885     	1           
  300         	0.00387     	0.80510     	0.00888     	3           
  500         	0.00390     	0.78796     	0.00891     	5           
  1000        	0.00412     	0.61827     	0.00905     	11          
---> try to load best state
              	0.00412     	0.61827     	0.00905     	11               eval state : test_on_restore;
              	0.00412     	0.61827     	0.00905     	11               eval state : test_on_last_epoch;
---> final result              	0.00412     	0.61827     	0.00905     	11               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': 1, '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: 100.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.00241     	0.68957     	0.00776     	0           
  10          	0.00249     	0.65741     	0.00871     	0           
  100         	0.00348     	0.76973     	0.00965     	1           
  300         	0.00358     	0.75231     	0.00984     	3           
  500         	0.00360     	0.69974     	0.00980     	4           
  1000        	0.00366     	0.68471     	0.00992     	10          
---> try to load best state
              	0.00366     	0.68471     	0.00992     	10               eval state : test_on_restore;
              	0.00366     	0.68471     	0.00992     	10               eval state : test_on_last_epoch;
---> final result              	0.00366     	0.68471     	0.00992     	10               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': 1, '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: 100.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.73433     	0.00971     	0           
  10          	0.00408     	0.65950     	0.01123     	0           
  100         	0.00423     	0.66775     	0.01175     	1           
  300         	0.00428     	0.65481     	0.01183     	3           
  500         	0.00428     	0.64632     	0.01180     	5           
  1000        	0.00452     	0.58446     	0.01203     	10          
---> try to load best state
              	0.00452     	0.58446     	0.01203     	10               eval state : test_on_restore;
              	0.00452     	0.58446     	0.01203     	10               eval state : test_on_last_epoch;
---> final result              	0.00452     	0.58446     	0.01203     	10               eval state : final;module_name : SGAR;subset : 32;cp_record_file : True;
---> end

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

  Demo sGAR 
  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': 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: 100.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.00177     	0.68188     	0.00409     	0           
  10          	0.00191     	0.67811     	0.00461     	0           
  100         	0.00405     	0.56094     	0.00916     	0           
  300         	0.00435     	0.62617     	0.01005     	1           
  500         	0.00432     	0.63801     	0.00996     	1           
  1000        	0.00426     	0.64078     	0.00980     	3           
---> try to load best state
              	0.00426     	0.64078     	0.00980     	3                eval state : test_on_restore;
              	0.00426     	0.64078     	0.00980     	3                eval state : test_on_last_epoch;
---> final result              	0.00426     	0.64078     	0.00980     	3                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': 2, '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: 100.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.00162     	0.89302     	0.00446     	0           
  10          	0.00158     	0.90780     	0.00441     	0           
  100         	0.00383     	0.83116     	0.00826     	1           
  300         	0.00350     	0.81834     	0.00693     	3           
  500         	0.00368     	0.78845     	0.00700     	5           
  1000        	0.00403     	0.69535     	0.00731     	10          
---> try to load best state
              	0.00403     	0.69535     	0.00731     	10               eval state : test_on_restore;
              	0.00403     	0.69535     	0.00731     	10               eval state : test_on_last_epoch;
---> final result              	0.00403     	0.69535     	0.00731     	10               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': 2, '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: 100.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.00157     	0.88727     	0.00438     	0           
  10          	0.00154     	0.89743     	0.00443     	0           
  100         	0.00374     	0.83698     	0.00814     	1           
  300         	0.00374     	0.83355     	0.00792     	4           
  500         	0.00380     	0.82817     	0.00800     	7           
  1000        	0.00407     	0.72753     	0.00821     	15          
---> try to load best state
              	0.00407     	0.72753     	0.00821     	15               eval state : test_on_restore;
              	0.00407     	0.72753     	0.00821     	15               eval state : test_on_last_epoch;
---> final result              	0.00407     	0.72753     	0.00821     	15               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': 2, '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: 100.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.00173     	0.87919     	0.00472     	0           
  10          	0.00179     	0.89612     	0.00493     	0           
  100         	0.00382     	0.83427     	0.00812     	1           
  300         	0.00378     	0.83610     	0.00791     	4           
  500         	0.00375     	0.81606     	0.00788     	7           
  1000        	0.00391     	0.71917     	0.00805     	14          
---> try to load best state
              	0.00391     	0.71917     	0.00805     	14               eval state : test_on_restore;
              	0.00391     	0.71917     	0.00805     	14               eval state : test_on_last_epoch;
---> final result              	0.00391     	0.71917     	0.00805     	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': 2, '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: 100.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.00193     	0.85163     	0.00521     	0           
  10          	0.00202     	0.85466     	0.00561     	0           
  100         	0.00366     	0.81951     	0.00809     	1           
  300         	0.00378     	0.81999     	0.00816     	4           
  500         	0.00371     	0.81565     	0.00814     	6           
  1000        	0.00433     	0.61221     	0.00858     	13          
---> try to load best state
              	0.00433     	0.61221     	0.00858     	13               eval state : test_on_restore;
              	0.00433     	0.61221     	0.00858     	13               eval state : test_on_last_epoch;
---> final result              	0.00433     	0.61221     	0.00858     	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': 2, '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: 100.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.00246     	0.78164     	0.00728     	0           
  10          	0.00264     	0.74499     	0.00772     	0           
  100         	0.00365     	0.69227     	0.00954     	1           
  300         	0.00364     	0.68896     	0.00952     	4           
  500         	0.00366     	0.69134     	0.00949     	7           
  1000        	0.00407     	0.48610     	0.00957     	14          
---> try to load best state
              	0.00407     	0.48610     	0.00957     	14               eval state : test_on_restore;
              	0.00407     	0.48610     	0.00957     	14               eval state : test_on_last_epoch;
---> final result              	0.00407     	0.48610     	0.00957     	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': 2, '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: 100.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.00355     	0.75605     	0.00856     	0           
  10          	0.00396     	0.72699     	0.00934     	0           
  100         	0.00404     	0.72248     	0.00971     	1           
  300         	0.00409     	0.71192     	0.00977     	4           
  500         	0.00406     	0.70168     	0.00979     	7           
  1000        	0.00408     	0.70520     	0.00980     	14          
---> try to load best state
              	0.00408     	0.70520     	0.00980     	14               eval state : test_on_restore;
              	0.00408     	0.70520     	0.00980     	14               eval state : test_on_last_epoch;
---> final result              	0.00408     	0.70520     	0.00980     	14               eval state : final;module_name : SGAR;subset : 32;cp_record_file : True;
---> end

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

  Demo sGAR 
  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': 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: 100.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.00166     	0.72355     	0.00382     	0           
  10          	0.00184     	0.71441     	0.00428     	0           
  100         	0.00387     	0.61893     	0.00890     	0           
  300         	0.00433     	0.64386     	0.01016     	1           
  500         	0.00431     	0.64854     	0.01008     	2           
  1000        	0.00425     	0.65133     	0.00993     	4           
---> try to load best state
              	0.00425     	0.65133     	0.00993     	4                eval state : test_on_restore;
              	0.00425     	0.65133     	0.00993     	4                eval state : test_on_last_epoch;
---> final result              	0.00425     	0.65133     	0.00993     	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': 3, '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: 100.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.00174     	0.89466     	0.00418     	0           
  10          	0.00170     	0.88787     	0.00433     	0           
  100         	0.00378     	0.82822     	0.00798     	1           
  300         	0.00381     	0.80314     	0.00655     	4           
  500         	0.00405     	0.78147     	0.00710     	7           
  1000        	0.00414     	0.78230     	0.00789     	13          
---> try to load best state
              	0.00414     	0.78230     	0.00789     	13               eval state : test_on_restore;
              	0.00414     	0.78230     	0.00789     	13               eval state : test_on_last_epoch;
---> final result              	0.00414     	0.78230     	0.00789     	13               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': 3, '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: 100.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.00172     	0.89114     	0.00412     	0           
  10          	0.00168     	0.88815     	0.00427     	0           
  100         	0.00383     	0.82417     	0.00808     	1           
  300         	0.00353     	0.83370     	0.00684     	3           
  500         	0.00380     	0.81468     	0.00746     	6           
  1000        	0.00434     	0.41183     	0.00799     	13          
---> try to load best state
              	0.00434     	0.41183     	0.00799     	13               eval state : test_on_restore;
              	0.00434     	0.41183     	0.00799     	13               eval state : test_on_last_epoch;
---> final result              	0.00434     	0.41183     	0.00799     	13               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': 3, '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: 100.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.00165     	0.88242     	0.00410     	0           
  10          	0.00164     	0.87041     	0.00435     	0           
  100         	0.00395     	0.81820     	0.00848     	1           
  300         	0.00399     	0.81852     	0.00843     	3           
  500         	0.00403     	0.80776     	0.00848     	6           
  1000        	0.00421     	0.75356     	0.00862     	13          
---> try to load best state
              	0.00421     	0.75356     	0.00862     	13               eval state : test_on_restore;
              	0.00421     	0.75356     	0.00862     	13               eval state : test_on_last_epoch;
---> final result              	0.00421     	0.75356     	0.00862     	13               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': 3, '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: 100.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.00160     	0.87827     	0.00433     	0           
  10          	0.00175     	0.87054     	0.00487     	0           
  100         	0.00420     	0.81969     	0.00863     	1           
  300         	0.00423     	0.81943     	0.00863     	4           
  500         	0.00429     	0.80414     	0.00867     	7           
  1000        	0.00434     	0.79057     	0.00874     	14          
---> try to load best state
              	0.00434     	0.79057     	0.00874     	14               eval state : test_on_restore;
              	0.00434     	0.79057     	0.00874     	14               eval state : test_on_last_epoch;
---> final result              	0.00434     	0.79057     	0.00874     	14               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': 3, '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: 100.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.00201     	0.87217     	0.00487     	0           
  10          	0.00212     	0.86077     	0.00545     	0           
  100         	0.00448     	0.82428     	0.00890     	1           
  300         	0.00461     	0.82075     	0.00908     	3           
  500         	0.00469     	0.81462     	0.00922     	6           
  1000        	0.00470     	0.79220     	0.00906     	14          
---> try to load best state
              	0.00470     	0.79220     	0.00906     	14               eval state : test_on_restore;
              	0.00470     	0.79220     	0.00906     	14               eval state : test_on_last_epoch;
---> final result              	0.00470     	0.79220     	0.00906     	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': 3, '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: 100.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.00339     	0.77417     	0.00837     	0           
  10          	0.00394     	0.73480     	0.00938     	0           
  100         	0.00402     	0.73479     	0.00980     	1           
  300         	0.00400     	0.68807     	0.00991     	3           
  500         	0.00406     	0.72297     	0.00984     	6           
  1000        	0.00495     	0.37028     	0.01008     	14          
---> try to load best state
              	0.00495     	0.37028     	0.01008     	14               eval state : test_on_restore;
              	0.00495     	0.37028     	0.01008     	14               eval state : test_on_last_epoch;
---> final result              	0.00495     	0.37028     	0.01008     	14               eval state : final;module_name : SGAR;subset : 32;cp_record_file : True;
---> end

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

  Demo sGAR 
  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': 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: 100.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.00168     	0.65751     	0.00409     	0           
  10          	0.00183     	0.64229     	0.00462     	0           
  100         	0.00392     	0.56581     	0.00994     	0           
  300         	0.00476     	0.57113     	0.01216     	1           
  500         	0.00472     	0.57032     	0.01209     	2           
  1000        	0.00463     	0.57473     	0.01190     	4           
---> try to load best state
              	0.00463     	0.57473     	0.01190     	4                eval state : test_on_restore;
              	0.00463     	0.57473     	0.01190     	4                eval state : test_on_last_epoch;
---> final result              	0.00463     	0.57473     	0.01190     	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': 4, '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: 100.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.00164     	0.83718     	0.00576     	0           
  10          	0.00154     	0.87514     	0.00551     	0           
  100         	0.00366     	0.75158     	0.00949     	1           
  300         	0.00374     	0.73302     	0.00954     	3           
  500         	0.00381     	0.72700     	0.00958     	5           
  1000        	0.00396     	0.58534     	0.00961     	10          
---> try to load best state
              	0.00396     	0.58534     	0.00961     	10               eval state : test_on_restore;
              	0.00396     	0.58534     	0.00961     	10               eval state : test_on_last_epoch;
---> final result              	0.00396     	0.58534     	0.00961     	10               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': 4, '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: 100.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.00172     	0.79711     	0.00608     	0           
  10          	0.00169     	0.85680     	0.00633     	0           
  100         	0.00368     	0.75417     	0.00949     	1           
  300         	0.00385     	0.74329     	0.00952     	4           
  500         	0.00386     	0.73556     	0.00956     	7           
  1000        	0.00394     	0.67482     	0.00964     	15          
---> try to load best state
              	0.00394     	0.67482     	0.00964     	15               eval state : test_on_restore;
              	0.00394     	0.67482     	0.00964     	15               eval state : test_on_last_epoch;
---> final result              	0.00394     	0.67482     	0.00964     	15               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': 4, '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: 100.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.00176     	0.77023     	0.00632     	0           
  10          	0.00181     	0.83591     	0.00675     	0           
  100         	0.00364     	0.73640     	0.00980     	2           
  300         	0.00379     	0.71959     	0.00981     	5           
  500         	0.00382     	0.71080     	0.00980     	10          
  1000        	0.00511     	-0.25123    	0.01048     	21          
---> try to load best state
              	0.00511     	-0.25123    	0.01048     	21               eval state : test_on_restore;
              	0.00511     	-0.25123    	0.01048     	21               eval state : test_on_last_epoch;
---> final result              	0.00511     	-0.25123    	0.01048     	21               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': 4, '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: 100.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.00190     	0.77718     	0.00692     	0           
  10          	0.00202     	0.80757     	0.00727     	0           
  100         	0.00372     	0.70082     	0.01010     	1           
  300         	0.00383     	0.70755     	0.00988     	4           
  500         	0.00381     	0.68469     	0.01001     	7           
  1000        	0.00383     	0.69718     	0.00993     	14          
---> try to load best state
              	0.00383     	0.69718     	0.00993     	14               eval state : test_on_restore;
              	0.00383     	0.69718     	0.00993     	14               eval state : test_on_last_epoch;
---> final result              	0.00383     	0.69718     	0.00993     	14               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': 4, '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: 100.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.00230     	0.75444     	0.00773     	0           
  10          	0.00233     	0.77730     	0.00808     	0           
  100         	0.00365     	0.68692     	0.01059     	1           
  300         	0.00365     	0.69623     	0.01026     	4           
  500         	0.00365     	0.70465     	0.01029     	6           
  1000        	0.00429     	0.38845     	0.01031     	13          
---> try to load best state
              	0.00429     	0.38845     	0.01031     	13               eval state : test_on_restore;
              	0.00429     	0.38845     	0.01031     	13               eval state : test_on_last_epoch;
---> final result              	0.00429     	0.38845     	0.01031     	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': 4, '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: 100.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.00377     	0.70106     	0.01015     	0           
  10          	0.00426     	0.65347     	0.01113     	0           
  100         	0.00439     	0.66270     	0.01166     	1           
  300         	0.00444     	0.63426     	0.01178     	4           
  500         	0.00442     	0.63887     	0.01177     	6           
  1000        	0.00445     	0.64085     	0.01180     	14          
---> try to load best state
              	0.00445     	0.64085     	0.01180     	14               eval state : test_on_restore;
              	0.00445     	0.64085     	0.01180     	14               eval state : test_on_last_epoch;
---> final result              	0.00445     	0.64085     	0.01180     	14               eval state : final;module_name : SGAR;subset : 32;cp_record_file : True;
