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

  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: 100.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.00175     	0.74600     	0.00406     	0           
  10          	0.00211     	0.73458     	0.00480     	0           
  100         	0.00414     	0.55883     	0.00761     	0           
  300         	0.00474     	0.49722     	0.00956     	1           
  500         	0.00469     	0.51331     	0.00958     	2           
  1000        	0.00461     	0.52659     	0.00943     	4           
---> try to load best state
              	0.00461     	0.52659     	0.00943     	4                eval state : test_on_restore;
              	0.00461     	0.52659     	0.00943     	4                eval state : test_on_last_epoch;
---> final result              	0.00461     	0.52659     	0.00943     	4                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: 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.00089     	0.88514     	0.00312     	0           
  10          	0.00095     	0.87483     	0.00338     	0           
  100         	0.00307     	-1.79604    	0.00596     	2           
  300         	0.00320     	-0.74595    	0.00652     	5           
  500         	0.00317     	0.24105     	0.00640     	9           
  1000        	0.00330     	0.31121     	0.00642     	18          
---> try to load best state
              	0.00330     	0.31121     	0.00642     	18               eval state : test_on_restore;
              	0.00330     	0.31121     	0.00642     	18               eval state : test_on_last_epoch;
---> final result
              	0.00330     	0.31121     	0.00642     	18               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: 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.00091     	0.88390     	0.00314     	0           
  10          	0.00101     	0.84678     	0.00341     	0           
  100         	0.00298     	-2.02553    	0.00596     	2           
  300         	0.00337     	-0.28980    	0.00657     	5           
  500         	0.00352     	-1.63178    	0.00661     	9           
  1000        	0.00327     	0.30879     	0.00638     	18          
---> try to load best state
              	0.00327     	0.30879     	0.00638     	19               eval state : test_on_restore;
              	0.00327     	0.30879     	0.00638     	19               eval state : test_on_last_epoch;
---> final result
              	0.00327     	0.30879     	0.00638     	19               eval state : final;module_name : GAR;subset : 2;cp_record_file : True;
---> end


---------->
GAR 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.00097     	0.87614     	0.00322     	0           
  10          	0.00104     	0.86057     	0.00346     	0           
  100         	0.00309     	-0.36206    	0.00605     	1           
  300         	0.00291     	0.42357     	0.00632     	5           
  500         	0.00334     	-0.44699    	0.00655     	9           
  1000        	0.00311     	0.33603     	0.00632     	18          
---> try to load best state
              	0.00311     	0.33603     	0.00632     	18               eval state : test_on_restore;
              	0.00311     	0.33603     	0.00632     	18               eval state : test_on_last_epoch;
---> final result
              	0.00311     	0.33603     	0.00632     	18               eval state : final;module_name : GAR;subset : 4;cp_record_file : True;
---> end


---------->
GAR 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.00119     	0.84695     	0.00371     	0           
  10          	0.00126     	0.82687     	0.00398     	0           
  100         	0.00291     	-0.58599    	0.00598     	1           
  300         	0.00338     	-0.22085    	0.00658     	5           
  500         	0.00349     	-0.33352    	0.00654     	9           
  1000        	0.00332     	0.04825     	0.00639     	18          
---> try to load best state
              	0.00332     	0.04825     	0.00639     	18               eval state : test_on_restore;
              	0.00332     	0.04825     	0.00639     	18               eval state : test_on_last_epoch;
---> final result
              	0.00332     	0.04825     	0.00639     	18               eval state : final;module_name : GAR;subset : 8;cp_record_file : True;
---> end


---------->
GAR 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.00173     	0.82288     	0.00421     	0           
  10          	0.00170     	0.79318     	0.00433     	0           
  100         	0.00337     	-0.10580    	0.00633     	1           
  300         	0.00363     	-0.45764    	0.00658     	5           
  500         	0.00378     	-0.90739    	0.00672     	9           
  1000        	0.00349     	-0.30691    	0.00638     	18          
---> try to load best state
              	0.00349     	-0.30691    	0.00638     	18               eval state : test_on_restore;
              	0.00349     	-0.30691    	0.00638     	18               eval state : test_on_last_epoch;
---> final result
              	0.00349     	-0.30691    	0.00638     	18               eval state : final;module_name : GAR;subset : 16;cp_record_file : True;
---> end


---------->
GAR 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.00311     	0.78169     	0.00599     	0           
  10          	0.00332     	0.78441     	0.00634     	0           
  100         	0.00422     	0.03918     	0.00715     	1           
  300         	0.00414     	0.11360     	0.00741     	5           
  500         	0.00438     	-0.21573    	0.00769     	9           
  1000        	0.00495     	-2.70896    	0.00843     	18          
---> try to load best state
              	0.00495     	-2.70896    	0.00843     	19               eval state : test_on_restore;
              	0.00495     	-2.70896    	0.00843     	19               eval state : test_on_last_epoch;
---> final result
              	0.00495     	-2.70896    	0.00843     	19               eval state : final;module_name : GAR;subset : 32;cp_record_file : True;
---> end

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

  Demo GAR 
  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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00238     	0.69696     	0.00564     	0           
  10          	0.00269     	0.69025     	0.00617     	0           
  100         	0.00436     	0.61850     	0.00795     	0           
  300         	0.00486     	0.51146     	0.00960     	1           
  500         	0.00483     	0.49362     	0.00961     	2           
  1000        	0.00474     	0.50922     	0.00946     	4           
---> try to load best state
              	0.00474     	0.50922     	0.00946     	4                eval state : test_on_restore;
              	0.00474     	0.50922     	0.00946     	4                eval state : test_on_last_epoch;
---> final result              	0.00474     	0.50922     	0.00946     	4                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': 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.00105     	0.88743     	0.00252     	0           
  10          	0.00115     	0.88440     	0.00266     	0           
  100         	0.00323     	0.44380     	0.00597     	2           
  300         	0.00399     	0.02283     	0.00699     	5           
  500         	0.00403     	-1.00984    	0.00688     	9           
  1000        	0.00284     	-0.20660    	0.00453     	18          
---> try to load best state
              	0.00284     	-0.20660    	0.00453     	18               eval state : test_on_restore;
              	0.00284     	-0.20660    	0.00453     	18               eval state : test_on_last_epoch;
---> final result
              	0.00284     	-0.20660    	0.00453     	18               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': 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.00111     	0.88858     	0.00283     	0           
  10          	0.00122     	0.88544     	0.00303     	0           
  100         	0.00331     	0.40109     	0.00609     	2           
  300         	0.00373     	0.39451     	0.00667     	5           
  500         	0.00422     	-0.93425    	0.00682     	9           
  1000        	0.00270     	0.14507     	0.00458     	18          
---> try to load best state
              	0.00270     	0.14507     	0.00458     	19               eval state : test_on_restore;
              	0.00270     	0.14507     	0.00458     	19               eval state : test_on_last_epoch;
---> final result
              	0.00270     	0.14507     	0.00458     	19               eval state : final;module_name : GAR;subset : 2;cp_record_file : True;
---> end


---------->
GAR 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.00124     	0.88407     	0.00311     	0           
  10          	0.00128     	0.88397     	0.00327     	0           
  100         	0.00367     	0.51018     	0.00614     	2           
  300         	0.00397     	0.25292     	0.00677     	5           
  500         	0.00348     	0.52162     	0.00636     	9           
  1000        	0.00305     	0.45356     	0.00516     	18          
---> try to load best state
              	0.00305     	0.45356     	0.00516     	18               eval state : test_on_restore;
              	0.00305     	0.45356     	0.00516     	18               eval state : test_on_last_epoch;
---> final result
              	0.00305     	0.45356     	0.00516     	18               eval state : final;module_name : GAR;subset : 4;cp_record_file : True;
---> end


---------->
GAR 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.00142     	0.86341     	0.00336     	0           
  10          	0.00148     	0.82757     	0.00345     	0           
  100         	0.00338     	-0.28107    	0.00575     	2           
  300         	0.00365     	0.09737     	0.00637     	5           
  500         	0.00370     	-0.00087    	0.00656     	9           
  1000        	0.00383     	0.06301     	0.00657     	18          
---> try to load best state
              	0.00383     	0.06301     	0.00657     	18               eval state : test_on_restore;
              	0.00383     	0.06301     	0.00657     	18               eval state : test_on_last_epoch;
---> final result
              	0.00383     	0.06301     	0.00657     	18               eval state : final;module_name : GAR;subset : 8;cp_record_file : True;
---> end


---------->
GAR 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.00201     	0.82437     	0.00433     	0           
  10          	0.00191     	0.80809     	0.00405     	0           
  100         	0.00351     	0.35253     	0.00600     	1           
  300         	0.00401     	-0.03033    	0.00675     	5           
  500         	0.00416     	0.36146     	0.00688     	9           
  1000        	0.00414     	-0.57343    	0.00682     	18          
---> try to load best state
              	0.00414     	-0.57343    	0.00682     	19               eval state : test_on_restore;
              	0.00414     	-0.57343    	0.00682     	19               eval state : test_on_last_epoch;
---> final result
              	0.00414     	-0.57343    	0.00682     	19               eval state : final;module_name : GAR;subset : 16;cp_record_file : True;
---> end


---------->
GAR 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.00329     	0.75120     	0.00616     	0           
  10          	0.00348     	0.75836     	0.00647     	0           
  100         	0.00427     	0.26404     	0.00738     	1           
  300         	0.00429     	0.29193     	0.00762     	5           
  500         	0.00433     	0.37028     	0.00776     	9           
  1000        	0.00484     	0.20913     	0.00825     	19          
---> try to load best state
              	0.00484     	0.20913     	0.00825     	19               eval state : test_on_restore;
              	0.00484     	0.20913     	0.00825     	19               eval state : test_on_last_epoch;
---> final result
              	0.00484     	0.20913     	0.00825     	19               eval state : final;module_name : GAR;subset : 32;cp_record_file : True;
---> end

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

  Demo GAR 
  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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00186     	0.70668     	0.00404     	0           
  10          	0.00217     	0.69591     	0.00460     	0           
  100         	0.00418     	0.50539     	0.00849     	0           
  300         	0.00480     	0.44969     	0.01029     	1           
  500         	0.00481     	0.43881     	0.01045     	2           
  1000        	0.00470     	0.46264     	0.01023     	4           
---> try to load best state
              	0.00470     	0.46264     	0.01023     	4                eval state : test_on_restore;
              	0.00470     	0.46264     	0.01023     	4                eval state : test_on_last_epoch;
---> final result              	0.00470     	0.46264     	0.01023     	4                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': 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.00104     	0.90606     	0.00246     	0           
  10          	0.00120     	0.86643     	0.00277     	0           
  100         	0.00328     	-0.87300    	0.00611     	2           
  300         	0.00369     	-4.33042    	0.00627     	6           
  500         	0.00289     	-0.72638    	0.00455     	9           
  1000        	0.00235     	-1.51082    	0.00379     	18          
---> try to load best state
              	0.00235     	-1.51082    	0.00379     	18               eval state : test_on_restore;
              	0.00235     	-1.51082    	0.00379     	18               eval state : test_on_last_epoch;
---> final result
              	0.00235     	-1.51082    	0.00379     	18               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': 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.00101     	0.89319     	0.00284     	0           
  10          	0.00120     	0.84020     	0.00320     	0           
  100         	0.00322     	-1.58990    	0.00622     	2           
  300         	0.00396     	-0.49417    	0.00709     	5           
  500         	0.00282     	0.24014     	0.00580     	9           
  1000        	0.00280     	-1.71518    	0.00470     	18          
---> try to load best state
              	0.00280     	-1.71518    	0.00470     	18               eval state : test_on_restore;
              	0.00280     	-1.71518    	0.00470     	18               eval state : test_on_last_epoch;
---> final result
              	0.00280     	-1.71518    	0.00470     	19               eval state : final;module_name : GAR;subset : 2;cp_record_file : True;
---> end


---------->
GAR 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.00107     	0.89065     	0.00292     	0           
  10          	0.00119     	0.85153     	0.00324     	0           
  100         	0.00295     	0.14294     	0.00618     	2           
  300         	0.00357     	-0.41197    	0.00687     	5           
  500         	0.00337     	-0.11055    	0.00621     	9           
  1000        	0.00249     	-1.57734    	0.00454     	18          
---> try to load best state
              	0.00249     	-1.57734    	0.00454     	18               eval state : test_on_restore;
              	0.00249     	-1.57734    	0.00454     	19               eval state : test_on_last_epoch;
---> final result
              	0.00249     	-1.57734    	0.00454     	19               eval state : final;module_name : GAR;subset : 4;cp_record_file : True;
---> end


---------->
GAR 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.00126     	0.86815     	0.00328     	0           
  10          	0.00138     	0.81030     	0.00361     	0           
  100         	0.00316     	-0.38119    	0.00629     	2           
  300         	0.00416     	-1.64078    	0.00739     	5           
  500         	0.00372     	-0.15691    	0.00682     	9           
  1000        	0.00291     	0.10865     	0.00553     	19          
---> try to load best state
              	0.00291     	0.10865     	0.00553     	19               eval state : test_on_restore;
              	0.00291     	0.10865     	0.00553     	19               eval state : test_on_last_epoch;
---> final result
              	0.00291     	0.10865     	0.00553     	19               eval state : final;module_name : GAR;subset : 8;cp_record_file : True;
---> end


---------->
GAR 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.00206     	0.74201     	0.00588     	0           
  10          	0.00206     	0.68830     	0.00627     	0           
  100         	0.00367     	0.04822     	0.00841     	2           
  300         	0.00372     	0.19858     	0.00874     	5           
  500         	0.00415     	-0.23152    	0.00893     	9           
  1000        	0.00361     	0.59939     	0.00859     	19          
---> try to load best state
              	0.00361     	0.59939     	0.00859     	19               eval state : test_on_restore;
              	0.00361     	0.59939     	0.00859     	19               eval state : test_on_last_epoch;
---> final result
              	0.00361     	0.59939     	0.00859     	19               eval state : final;module_name : GAR;subset : 16;cp_record_file : True;
---> end


---------->
GAR 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.00320     	0.69844     	0.00718     	0           
  10          	0.00344     	0.71385     	0.00768     	0           
  100         	0.00418     	-0.00233    	0.00863     	1           
  300         	0.00457     	0.39738     	0.00900     	5           
  500         	0.00462     	-0.47161    	0.00919     	9           
  1000        	0.00443     	0.44976     	0.00925     	17          
---> try to load best state
              	0.00443     	0.44976     	0.00925     	17               eval state : test_on_restore;
              	0.00443     	0.44976     	0.00925     	17               eval state : test_on_last_epoch;
---> final result
              	0.00443     	0.44976     	0.00925     	17               eval state : final;module_name : GAR;subset : 32;cp_record_file : True;
---> end

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

  Demo GAR 
  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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00177     	0.68188     	0.00409     	0           
  10          	0.00207     	0.68082     	0.00481     	0           
  100         	0.00411     	0.52252     	0.00823     	0           
  300         	0.00477     	0.46589     	0.01006     	1           
  500         	0.00474     	0.47565     	0.01009     	1           
  1000        	0.00466     	0.48673     	0.00994     	3           
---> try to load best state
              	0.00466     	0.48673     	0.00994     	3                eval state : test_on_restore;
              	0.00466     	0.48673     	0.00994     	3                eval state : test_on_last_epoch;
---> final result              	0.00466     	0.48673     	0.00994     	3                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': 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.00110     	0.89743     	0.00273     	0           
  10          	0.00115     	0.87308     	0.00304     	0           
  100         	0.00310     	-0.07939    	0.00584     	1           
  300         	0.00369     	-0.59427    	0.00654     	4           
  500         	0.00320     	-0.80270    	0.00589     	7           
  1000        	0.00299     	-1.04208    	0.00457     	15          
---> try to load best state
              	0.00299     	-1.04208    	0.00457     	15               eval state : test_on_restore;
              	0.00299     	-1.04208    	0.00457     	15               eval state : test_on_last_epoch;
---> final result
              	0.00299     	-1.04208    	0.00457     	15               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': 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.00107     	0.90025     	0.00260     	0           
  10          	0.00112     	0.89002     	0.00292     	0           
  100         	0.00321     	-0.55416    	0.00598     	1           
  300         	0.00354     	-0.01620    	0.00657     	5           
  500         	0.00372     	-0.25321    	0.00647     	9           
  1000        	0.00267     	-0.51517    	0.00446     	19          
---> try to load best state
              	0.00267     	-0.51517    	0.00446     	19               eval state : test_on_restore;
              	0.00267     	-0.51517    	0.00446     	19               eval state : test_on_last_epoch;
---> final result
              	0.00267     	-0.51517    	0.00446     	19               eval state : final;module_name : GAR;subset : 2;cp_record_file : True;
---> end


---------->
GAR 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.00120     	0.88502     	0.00295     	0           
  10          	0.00129     	0.83900     	0.00328     	0           
  100         	0.00348     	-0.30720    	0.00606     	2           
  300         	0.00362     	-0.03034    	0.00664     	5           
  500         	0.00396     	-0.43307    	0.00671     	9           
  1000        	0.00404     	0.23805     	0.00680     	18          
---> try to load best state
              	0.00404     	0.23805     	0.00680     	18               eval state : test_on_restore;
              	0.00404     	0.23805     	0.00680     	18               eval state : test_on_last_epoch;
---> final result
              	0.00404     	0.23805     	0.00680     	19               eval state : final;module_name : GAR;subset : 4;cp_record_file : True;
---> end


---------->
GAR 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.00134     	0.85925     	0.00344     	0           
  10          	0.00139     	0.83779     	0.00369     	0           
  100         	0.00336     	-0.19617    	0.00617     	1           
  300         	0.00377     	0.09172     	0.00680     	5           
  500         	0.00378     	0.08317     	0.00679     	9           
  1000        	0.00388     	0.21824     	0.00676     	18          
---> try to load best state
              	0.00388     	0.21824     	0.00676     	18               eval state : test_on_restore;
              	0.00388     	0.21824     	0.00676     	18               eval state : test_on_last_epoch;
---> final result
              	0.00388     	0.21824     	0.00676     	18               eval state : final;module_name : GAR;subset : 8;cp_record_file : True;
---> end


---------->
GAR 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.00182     	0.79269     	0.00509     	0           
  10          	0.00189     	0.77434     	0.00531     	0           
  100         	0.00348     	0.43682     	0.00688     	2           
  300         	0.00367     	-0.16815    	0.00728     	5           
  500         	0.00406     	-1.26225    	0.00752     	9           
  1000        	0.00378     	-0.02301    	0.00733     	19          
---> try to load best state
              	0.00378     	-0.02301    	0.00733     	19               eval state : test_on_restore;
              	0.00378     	-0.02301    	0.00733     	19               eval state : test_on_last_epoch;
---> final result
              	0.00378     	-0.02301    	0.00733     	19               eval state : final;module_name : GAR;subset : 16;cp_record_file : True;
---> end


---------->
GAR 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.00323     	0.73012     	0.00685     	0           
  10          	0.00342     	0.73402     	0.00719     	0           
  100         	0.00414     	-0.49391    	0.00788     	2           
  300         	0.00430     	0.18009     	0.00813     	5           
  500         	0.00435     	0.05865     	0.00832     	9           
  1000        	0.00436     	0.39998     	0.00864     	18          
---> try to load best state
              	0.00436     	0.39998     	0.00864     	18               eval state : test_on_restore;
              	0.00436     	0.39998     	0.00864     	18               eval state : test_on_last_epoch;
---> final result
              	0.00436     	0.39998     	0.00864     	19               eval state : final;module_name : GAR;subset : 32;cp_record_file : True;
---> end

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

  Demo GAR 
  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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00166     	0.72355     	0.00382     	0           
  10          	0.00199     	0.71161     	0.00449     	0           
  100         	0.00404     	0.48490     	0.00791     	0           
  300         	0.00470     	0.43279     	0.00992     	1           
  500         	0.00467     	0.45207     	0.00997     	2           
  1000        	0.00458     	0.47533     	0.00980     	4           
---> try to load best state
              	0.00458     	0.47533     	0.00980     	4                eval state : test_on_restore;
              	0.00458     	0.47533     	0.00980     	4                eval state : test_on_last_epoch;
---> final result              	0.00458     	0.47533     	0.00980     	4                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': 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.00104     	0.90560     	0.00245     	0           
  10          	0.00122     	0.88265     	0.00276     	0           
  100         	0.00309     	-0.54175    	0.00556     	2           
  300         	0.00361     	-2.26581    	0.00602     	6           
  500         	0.00348     	-8.94932    	0.00514     	9           
  1000        	0.00294     	-7.98542    	0.00425     	19          
---> try to load best state
              	0.00294     	-7.98542    	0.00425     	19               eval state : test_on_restore;
              	0.00294     	-7.98542    	0.00425     	19               eval state : test_on_last_epoch;
---> final result
              	0.00294     	-7.98542    	0.00425     	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': 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.00103     	0.90352     	0.00242     	0           
  10          	0.00120     	0.88119     	0.00274     	0           
  100         	0.00311     	0.15473     	0.00550     	2           
  300         	0.00363     	-0.35020    	0.00594     	5           
  500         	0.00323     	-3.48097    	0.00501     	9           
  1000        	0.00230     	-2.46423    	0.00367     	19          
---> try to load best state
              	0.00230     	-2.46423    	0.00367     	19               eval state : test_on_restore;
              	0.00230     	-2.46423    	0.00367     	19               eval state : test_on_last_epoch;
---> final result
              	0.00230     	-2.46423    	0.00367     	19               eval state : final;module_name : GAR;subset : 2;cp_record_file : True;
---> end


---------->
GAR 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.00104     	0.90081     	0.00242     	0           
  10          	0.00120     	0.87829     	0.00274     	0           
  100         	0.00327     	0.20796     	0.00573     	2           
  300         	0.00382     	-2.20583    	0.00628     	5           
  500         	0.00352     	-1.11455    	0.00574     	9           
  1000        	0.00277     	-1.23624    	0.00411     	19          
---> try to load best state
              	0.00277     	-1.23624    	0.00411     	19               eval state : test_on_restore;
              	0.00277     	-1.23624    	0.00411     	19               eval state : test_on_last_epoch;
---> final result
              	0.00277     	-1.23624    	0.00411     	19               eval state : final;module_name : GAR;subset : 4;cp_record_file : True;
---> end


---------->
GAR 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.00116     	0.88157     	0.00269     	0           
  10          	0.00132     	0.84977     	0.00303     	0           
  100         	0.00356     	-1.10406    	0.00598     	1           
  300         	0.00368     	0.17616     	0.00637     	5           
  500         	0.00428     	-0.77161    	0.00664     	9           
  1000        	0.00379     	0.00382     	0.00641     	19          
---> try to load best state
              	0.00379     	0.00382     	0.00641     	19               eval state : test_on_restore;
              	0.00379     	0.00382     	0.00641     	19               eval state : test_on_last_epoch;
---> final result
              	0.00379     	0.00382     	0.00641     	19               eval state : final;module_name : GAR;subset : 8;cp_record_file : True;
---> end


---------->
GAR 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.00164     	0.85470     	0.00334     	0           
  10          	0.00175     	0.80107     	0.00359     	0           
  100         	0.00365     	-0.33673    	0.00621     	1           
  300         	0.00377     	0.04507     	0.00659     	5           
  500         	0.00374     	0.56498     	0.00657     	9           
  1000        	0.00399     	-0.07069    	0.00662     	19          
---> try to load best state
              	0.00399     	-0.07069    	0.00662     	19               eval state : test_on_restore;
              	0.00399     	-0.07069    	0.00662     	19               eval state : test_on_last_epoch;
---> final result
              	0.00399     	-0.07069    	0.00662     	19               eval state : final;module_name : GAR;subset : 16;cp_record_file : True;
---> end


---------->
GAR 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.00306     	0.73214     	0.00652     	0           
  10          	0.00324     	0.73655     	0.00683     	0           
  100         	0.00399     	0.21632     	0.00754     	2           
  300         	0.00410     	0.15532     	0.00782     	5           
  500         	0.00450     	-1.29607    	0.00827     	9           
  1000        	0.00455     	-0.28733    	0.00849     	19          
---> try to load best state
              	0.00455     	-0.28733    	0.00849     	19               eval state : test_on_restore;
              	0.00455     	-0.28733    	0.00849     	19               eval state : test_on_last_epoch;
---> final result
              	0.00455     	-0.28733    	0.00849     	19               eval state : final;module_name : GAR;subset : 32;cp_record_file : True;
---> end

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

  Demo GAR 
  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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00168     	0.65751     	0.00409     	0           
  10          	0.00200     	0.63857     	0.00496     	0           
  100         	0.00446     	0.39988     	0.00944     	0           
  300         	0.00518     	0.22299     	0.01155     	1           
  500         	0.00515     	0.30231     	0.01168     	2           
  1000        	0.00507     	0.31270     	0.01155     	4           
---> try to load best state
              	0.00507     	0.31270     	0.01155     	4                eval state : test_on_restore;
              	0.00507     	0.31270     	0.01155     	4                eval state : test_on_last_epoch;
---> final result              	0.00507     	0.31270     	0.01155     	4                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': 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.00116     	0.86402     	0.00415     	0           
  10          	0.00132     	0.80518     	0.00444     	0           
  100         	0.00348     	-3.30329    	0.00732     	2           
  300         	0.00302     	-0.50872    	0.00650     	6           
  500         	0.00250     	-1.12325    	0.00552     	9           
  1000        	0.00264     	-1.34679    	0.00524     	19          
---> try to load best state
              	0.00264     	-1.34679    	0.00524     	19               eval state : test_on_restore;
              	0.00264     	-1.34679    	0.00524     	19               eval state : test_on_last_epoch;
---> final result
              	0.00264     	-1.34679    	0.00524     	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': 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.00120     	0.83810     	0.00438     	0           
  10          	0.00136     	0.78389     	0.00475     	0           
  100         	0.00309     	-0.19161    	0.00743     	2           
  300         	0.00327     	-1.06769    	0.00718     	5           
  500         	0.00261     	-0.10973    	0.00585     	9           
  1000        	0.00380     	-13.61706   	0.00620     	19          
---> try to load best state
              	0.00380     	-13.61706   	0.00620     	19               eval state : test_on_restore;
              	0.00380     	-13.61706   	0.00620     	19               eval state : test_on_last_epoch;
---> final result
              	0.00380     	-13.61706   	0.00620     	19               eval state : final;module_name : GAR;subset : 2;cp_record_file : True;
---> end


---------->
GAR 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.00126     	0.82143     	0.00463     	0           
  10          	0.00142     	0.78242     	0.00508     	0           
  100         	0.00331     	-0.06867    	0.00791     	2           
  300         	0.00354     	-0.88580    	0.00801     	5           
  500         	0.00301     	-2.04361    	0.00661     	9           
  1000        	0.00266     	-0.96791    	0.00562     	19          
---> try to load best state
              	0.00266     	-0.96791    	0.00562     	19               eval state : test_on_restore;
              	0.00266     	-0.96791    	0.00562     	19               eval state : test_on_last_epoch;
---> final result
              	0.00266     	-0.96791    	0.00562     	19               eval state : final;module_name : GAR;subset : 4;cp_record_file : True;
---> end


---------->
GAR 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.00145     	0.81572     	0.00522     	0           
  10          	0.00153     	0.78038     	0.00512     	0           
  100         	0.00350     	-1.05947    	0.00800     	2           
  300         	0.00364     	-0.20458    	0.00843     	5           
  500         	0.00340     	-0.84694    	0.00759     	9           
  1000        	0.00345     	-7.79343    	0.00651     	19          
---> try to load best state
              	0.00345     	-7.79343    	0.00651     	19               eval state : test_on_restore;
              	0.00345     	-7.79343    	0.00651     	19               eval state : test_on_last_epoch;
---> final result
              	0.00345     	-7.79343    	0.00651     	19               eval state : final;module_name : GAR;subset : 8;cp_record_file : True;
---> end


---------->
GAR 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.00192     	0.77516     	0.00583     	0           
  10          	0.00180     	0.75055     	0.00545     	0           
  100         	0.00403     	-1.33082    	0.00871     	2           
  300         	0.00399     	0.04057     	0.00938     	5           
  500         	0.00408     	0.09590     	0.00951     	9           
  1000        	0.00431     	-0.62835    	0.00974     	19          
---> try to load best state
              	0.00431     	-0.62835    	0.00974     	19               eval state : test_on_restore;
              	0.00431     	-0.62835    	0.00974     	19               eval state : test_on_last_epoch;
---> final result
              	0.00431     	-0.62835    	0.00974     	19               eval state : final;module_name : GAR;subset : 16;cp_record_file : True;
---> end


---------->
GAR 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.00352     	0.66024     	0.00847     	0           
  10          	0.00370     	0.66285     	0.00882     	0           
  100         	0.00453     	-0.14532    	0.00994     	2           
  300         	0.00482     	-0.69972    	0.01025     	5           
  500         	0.00477     	0.17015     	0.01033     	9           
  1000        	0.00509     	-0.33446    	0.01070     	19          
---> try to load best state
              	0.00509     	-0.33446    	0.01070     	19               eval state : test_on_restore;
              	0.00509     	-0.33446    	0.01070     	19               eval state : test_on_last_epoch;
---> final result
              	0.00509     	-0.33446    	0.01070     	19               eval state : final;module_name : GAR;subset : 32;cp_record_file : True;
