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

  Demo sGAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'poisson_v4_02', '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           	98.37616    	0.18386     	134.77779   	0           
  10          	86.18122    	0.48916     	119.51752   	0           
  100         	22.18892    	0.98256     	31.43187    	0           
  300         	7.21742     	0.99822     	10.32205    	1           
  500         	4.05270     	0.99946     	5.73496     	1           
  1000        	1.95656     	0.99989     	2.71802     	3           
---> try to load best state
              	1.95656     	0.99989     	2.71802     	3                eval state : test_on_restore;
              	1.95656     	0.99989     	2.71802     	3                eval state : test_on_last_epoch;
---> final result              	1.95656     	0.99989     	2.71802     	3                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', '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           	16.55421    	0.98136     	30.84071    	0           
  10          	10.37899    	0.99346     	19.73231    	0           
  100         	0.83337     	0.99996     	1.59045     	0           
  300         	1.15837     	0.99994     	1.75523     	1           
  500         	2.03792     	0.99983     	3.09093     	2           
  1000        	3.21452     	0.99954     	5.03872     	5           
---> try to load best state
              	3.21452     	0.99954     	5.03872     	5                eval state : test_on_restore;
              	3.21452     	0.99954     	5.03872     	5                eval state : test_on_last_epoch;
---> final result              	3.21452     	0.99954     	5.03872     	5                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': 'poisson_v4_02', '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           	15.46376    	0.98427     	28.48077    	0           
  10          	9.89799     	0.99403     	18.88822    	0           
  100         	0.81975     	0.99996     	1.56281     	0           
  300         	1.16059     	0.99994     	1.76420     	1           
  500         	2.05292     	0.99983     	3.12054     	3           
  1000        	3.23821     	0.99954     	5.06818     	6           
---> try to load best state
              	3.23821     	0.99954     	5.06818     	6                eval state : test_on_restore;
              	3.23821     	0.99954     	5.06818     	6                eval state : test_on_last_epoch;
---> final result              	3.23821     	0.99954     	5.06818     	6                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': 'poisson_v4_02', '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           	16.32346    	0.98253     	29.90010    	0           
  10          	10.13255    	0.99369     	19.33116    	0           
  100         	0.94198     	0.99995     	1.77266     	0           
  300         	1.14701     	0.99995     	1.73401     	1           
  500         	2.09408     	0.99981     	3.24282     	2           
  1000        	4.29980     	0.99929     	6.10083     	5           
---> try to load best state
              	4.29980     	0.99929     	6.10083     	5                eval state : test_on_restore;
              	4.29980     	0.99929     	6.10083     	5                eval state : test_on_last_epoch;
---> final result              	4.29980     	0.99929     	6.10083     	5                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': 'poisson_v4_02', '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           	17.33668    	0.97992     	31.46396    	0           
  10          	11.48644    	0.99191     	21.67306    	0           
  100         	1.07194     	0.99994     	1.93965     	0           
  300         	1.25210     	0.99993     	1.92309     	1           
  500         	2.19931     	0.99980     	3.38175     	2           
  1000        	3.32174     	0.99952     	5.17938     	5           
---> try to load best state
              	3.32174     	0.99952     	5.17938     	5                eval state : test_on_restore;
              	3.32174     	0.99952     	5.17938     	5                eval state : test_on_last_epoch;
---> final result              	3.32174     	0.99952     	5.17938     	5                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': 'poisson_v4_02', '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           	16.51456    	0.98255     	29.87246    	0           
  10          	10.34575    	0.99369     	19.40331    	0           
  100         	1.13045     	0.99994     	1.95981     	0           
  300         	1.33294     	0.99992     	2.08079     	1           
  500         	2.17691     	0.99979     	3.49158     	2           
  1000        	3.39692     	0.99948     	5.47393     	5           
---> try to load best state
              	3.39692     	0.99948     	5.47393     	5                eval state : test_on_restore;
              	3.39692     	0.99948     	5.47393     	5                eval state : test_on_last_epoch;
---> final result              	3.39692     	0.99948     	5.47393     	5                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': 'poisson_v4_02', '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           	16.49018    	0.98280     	30.06003    	0           
  10          	10.08344    	0.99410     	18.68000    	0           
  100         	1.38513     	0.99991     	2.33540     	0           
  300         	1.78095     	0.99986     	2.99600     	1           
  500         	2.59020     	0.99968     	4.53344     	2           
  1000        	3.80419     	0.99928     	6.65518     	5           
---> try to load best state
              	3.80419     	0.99928     	6.65518     	5                eval state : test_on_restore;
              	3.80419     	0.99928     	6.65518     	5                eval state : test_on_last_epoch;
---> final result              	3.80419     	0.99928     	6.65518     	5                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': 'poisson_v4_02', '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           	112.44916   	-0.16295    	154.67416   	0           
  10          	101.69065   	0.17025     	141.93137   	0           
  100         	26.87807    	0.96711     	40.27554    	0           
  300         	8.82906     	0.99702     	13.31641    	1           
  500         	5.01987     	0.99911     	7.50641     	1           
  1000        	2.40186     	0.99981     	3.53958     	3           
---> try to load best state
              	2.40186     	0.99981     	3.53958     	3                eval state : test_on_restore;
              	2.40186     	0.99981     	3.53958     	3                eval state : test_on_last_epoch;
---> final result              	2.40186     	0.99981     	3.53958     	3                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', '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           	23.07239    	0.96774     	40.85124    	0           
  10          	14.85273    	0.98736     	26.68376    	0           
  100         	1.38890     	0.99989     	2.67494     	0           
  300         	1.39086     	0.99992     	2.06439     	1           
  500         	2.39962     	0.99976     	3.67471     	2           
  1000        	3.59150     	0.99944     	5.59326     	5           
---> try to load best state
              	3.59150     	0.99944     	5.59326     	5                eval state : test_on_restore;
              	3.59150     	0.99944     	5.59326     	5                eval state : test_on_last_epoch;
---> final result              	3.59150     	0.99944     	5.59326     	5                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': 'poisson_v4_02', '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           	23.09094    	0.96750     	40.95298    	0           
  10          	14.94910    	0.98723     	26.81202    	0           
  100         	1.41037     	0.99988     	2.73807     	0           
  300         	1.34365     	0.99993     	1.98295     	1           
  500         	2.29963     	0.99978     	3.57128     	2           
  1000        	4.12064     	0.99931     	6.08408     	5           
---> try to load best state
              	4.12064     	0.99931     	6.08408     	5                eval state : test_on_restore;
              	4.12064     	0.99931     	6.08408     	5                eval state : test_on_last_epoch;
---> final result              	4.12064     	0.99931     	6.08408     	5                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': 'poisson_v4_02', '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           	23.14300    	0.96749     	40.63041    	0           
  10          	14.57578    	0.98801     	25.97674    	0           
  100         	1.30648     	0.99990     	2.54960     	0           
  300         	1.40563     	0.99992     	2.07516     	1           
  500         	2.40146     	0.99976     	3.64484     	2           
  1000        	3.56436     	0.99944     	5.58029     	5           
---> try to load best state
              	3.56436     	0.99944     	5.58029     	5                eval state : test_on_restore;
              	3.56436     	0.99944     	5.58029     	5                eval state : test_on_last_epoch;
---> final result              	3.56436     	0.99944     	5.58029     	5                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': 'poisson_v4_02', '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           	21.99584    	0.97062     	38.69513    	0           
  10          	13.34601    	0.98977     	24.08482    	0           
  100         	1.34678     	0.99990     	2.57375     	0           
  300         	1.42648     	0.99992     	2.13338     	1           
  500         	2.37593     	0.99976     	3.69457     	2           
  1000        	3.63855     	0.99942     	5.71563     	5           
---> try to load best state
              	3.63855     	0.99942     	5.71563     	5                eval state : test_on_restore;
              	3.63855     	0.99942     	5.71563     	5                eval state : test_on_last_epoch;
---> final result              	3.63855     	0.99942     	5.71563     	5                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': 'poisson_v4_02', '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           	22.34179    	0.96852     	39.32433    	0           
  10          	14.19494    	0.98805     	25.41915    	0           
  100         	1.46790     	0.99988     	2.66445     	0           
  300         	1.71520     	0.99988     	2.62026     	1           
  500         	2.52489     	0.99972     	4.04470     	2           
  1000        	3.82149     	0.99935     	6.08658     	5           
---> try to load best state
              	3.82149     	0.99935     	6.08658     	5                eval state : test_on_restore;
              	3.82149     	0.99935     	6.08658     	5                eval state : test_on_last_epoch;
---> final result              	3.82149     	0.99935     	6.08658     	5                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': 'poisson_v4_02', '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           	18.76690    	0.97494     	35.10294    	0           
  10          	13.15071    	0.98816     	24.71992    	0           
  100         	1.84159     	0.99982     	3.28961     	0           
  300         	2.09439     	0.99980     	3.57910     	1           
  500         	2.90630     	0.99958     	5.17816     	2           
  1000        	4.14911     	0.99909     	7.37162     	5           
---> try to load best state
              	4.14911     	0.99909     	7.37162     	5                eval state : test_on_restore;
              	4.14911     	0.99909     	7.37162     	5                eval state : test_on_last_epoch;
---> final result              	4.14911     	0.99909     	7.37162     	5                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': 'poisson_v4_02', '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           	127.04747   	-0.88964    	171.64540   	0           
  10          	115.50613   	-0.29199    	158.45839   	0           
  100         	34.49421    	0.94362     	52.03197    	0           
  300         	11.15951    	0.99501     	16.80957    	1           
  500         	6.00020     	0.99868     	8.91253     	2           
  1000        	2.53225     	0.99980     	3.63211     	4           
---> try to load best state
              	2.53225     	0.99980     	3.63211     	4                eval state : test_on_restore;
              	2.53225     	0.99980     	3.63211     	4                eval state : test_on_last_epoch;
---> final result              	2.53225     	0.99980     	3.63211     	4                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', '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           	20.94153    	0.97203     	38.10632    	0           
  10          	12.65716    	0.99001     	23.81493    	0           
  100         	1.27849     	0.99991     	2.32267     	0           
  300         	1.51119     	0.99991     	2.26097     	1           
  500         	2.55543     	0.99972     	3.97542     	2           
  1000        	4.02819     	0.99936     	6.02046     	5           
---> try to load best state
              	4.02819     	0.99936     	6.02046     	5                eval state : test_on_restore;
              	4.02819     	0.99936     	6.02046     	5                eval state : test_on_last_epoch;
---> final result              	4.02819     	0.99936     	6.02046     	5                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': 'poisson_v4_02', '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           	20.89354    	0.97237     	38.07149    	0           
  10          	12.57205    	0.99022     	23.67720    	0           
  100         	1.27698     	0.99991     	2.32461     	0           
  300         	1.52763     	0.99991     	2.31512     	1           
  500         	2.50544     	0.99973     	3.92337     	2           
  1000        	4.19369     	0.99933     	6.18280     	5           
---> try to load best state
              	4.19369     	0.99933     	6.18280     	5                eval state : test_on_restore;
              	4.19369     	0.99933     	6.18280     	5                eval state : test_on_last_epoch;
---> final result              	4.19369     	0.99933     	6.18280     	5                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': 'poisson_v4_02', '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           	20.27980    	0.97418     	36.63274    	0           
  10          	12.30260    	0.99098     	22.82436    	0           
  100         	1.28556     	0.99991     	2.32840     	0           
  300         	1.53555     	0.99990     	2.33870     	1           
  500         	2.45451     	0.99975     	3.85040     	2           
  1000        	3.67286     	0.99940     	5.80271     	5           
---> try to load best state
              	3.67286     	0.99940     	5.80271     	5                eval state : test_on_restore;
              	3.67286     	0.99940     	5.80271     	5                eval state : test_on_last_epoch;
---> final result              	3.67286     	0.99940     	5.80271     	5                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': 'poisson_v4_02', '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           	19.78461    	0.97541     	35.77533    	0           
  10          	12.35598    	0.99106     	22.68623    	0           
  100         	1.38857     	0.99990     	2.47448     	0           
  300         	1.63522     	0.99989     	2.53104     	1           
  500         	2.59269     	0.99971     	4.13547     	2           
  1000        	3.81023     	0.99935     	6.03642     	5           
---> try to load best state
              	3.81023     	0.99935     	6.03642     	5                eval state : test_on_restore;
              	3.81023     	0.99935     	6.03642     	5                eval state : test_on_last_epoch;
---> final result              	3.81023     	0.99935     	6.03642     	5                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': 'poisson_v4_02', '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           	21.54014    	0.97304     	37.59496    	0           
  10          	13.98115    	0.98927     	25.15230    	0           
  100         	1.48774     	0.99989     	2.60503     	0           
  300         	1.74359     	0.99987     	2.71945     	1           
  500         	2.66671     	0.99969     	4.25062     	2           
  1000        	3.86221     	0.99934     	6.11761     	5           
---> try to load best state
              	3.86221     	0.99934     	6.11761     	5                eval state : test_on_restore;
              	3.86221     	0.99934     	6.11761     	5                eval state : test_on_last_epoch;
---> final result              	3.86221     	0.99934     	6.11761     	5                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': 'poisson_v4_02', '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           	23.57331    	0.96833     	41.53632    	0           
  10          	14.63554    	0.98806     	26.76069    	0           
  100         	2.07322     	0.99979     	3.56823     	0           
  300         	2.19910     	0.99979     	3.61618     	1           
  500         	3.16534     	0.99954     	5.30829     	2           
  1000        	4.14123     	0.99913     	7.25838     	5           
---> try to load best state
              	4.14123     	0.99913     	7.25838     	5                eval state : test_on_restore;
              	4.14123     	0.99913     	7.25838     	5                eval state : test_on_last_epoch;
---> final result              	4.14123     	0.99913     	7.25838     	5                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': 'poisson_v4_02', '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           	113.75020   	-0.43280    	156.15828   	0           
  10          	102.74926   	-0.01039    	143.76639   	0           
  100         	27.86107    	0.95937     	43.47932    	0           
  300         	7.40820     	0.99791     	11.15804    	1           
  500         	4.08025     	0.99943     	5.99292     	1           
  1000        	2.02781     	0.99987     	2.90034     	3           
---> try to load best state
              	2.02781     	0.99987     	2.90034     	3                eval state : test_on_restore;
              	2.02781     	0.99987     	2.90034     	3                eval state : test_on_last_epoch;
---> final result              	2.02781     	0.99987     	2.90034     	3                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', '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           	21.41925    	0.97088     	37.62714    	0           
  10          	13.47631    	0.98902     	24.20332    	0           
  100         	1.28579     	0.99990     	2.51766     	0           
  300         	1.17961     	0.99995     	1.73458     	1           
  500         	2.08341     	0.99982     	3.26640     	2           
  1000        	3.48854     	0.99946     	5.44127     	5           
---> try to load best state
              	3.48854     	0.99946     	5.44127     	5                eval state : test_on_restore;
              	3.48854     	0.99946     	5.44127     	5                eval state : test_on_last_epoch;
---> final result              	3.48854     	0.99946     	5.44127     	5                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': 'poisson_v4_02', '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           	21.35300    	0.97104     	37.57107    	0           
  10          	13.51679    	0.98898     	24.27877    	0           
  100         	1.27602     	0.99990     	2.52030     	0           
  300         	1.17434     	0.99995     	1.73374     	1           
  500         	2.33553     	0.99978     	3.53238     	2           
  1000        	3.30841     	0.99950     	5.26874     	5           
---> try to load best state
              	3.30841     	0.99950     	5.26874     	5                eval state : test_on_restore;
              	3.30841     	0.99950     	5.26874     	5                eval state : test_on_last_epoch;
---> final result              	3.30841     	0.99950     	5.26874     	5                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': 'poisson_v4_02', '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           	21.07836    	0.97151     	37.12954    	0           
  10          	13.57481    	0.98887     	24.25144    	0           
  100         	1.24766     	0.99990     	2.51053     	0           
  300         	1.28467     	0.99993     	1.98423     	1           
  500         	2.25888     	0.99977     	3.59414     	2           
  1000        	3.43426     	0.99946     	5.49247     	5           
---> try to load best state
              	3.43426     	0.99946     	5.49247     	5                eval state : test_on_restore;
              	3.43426     	0.99946     	5.49247     	5                eval state : test_on_last_epoch;
---> final result              	3.43426     	0.99946     	5.49247     	5                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': 'poisson_v4_02', '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           	21.41075    	0.96976     	37.97212    	0           
  10          	14.77985    	0.98725     	25.77698    	0           
  100         	1.32969     	0.99989     	2.60629     	0           
  300         	1.27807     	0.99993     	2.00020     	1           
  500         	2.20492     	0.99978     	3.58761     	3           
  1000        	3.30937     	0.99949     	5.38485     	5           
---> try to load best state
              	3.30937     	0.99949     	5.38485     	5                eval state : test_on_restore;
              	3.30937     	0.99949     	5.38485     	5                eval state : test_on_last_epoch;
---> final result              	3.30937     	0.99949     	5.38485     	5                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': 'poisson_v4_02', '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           	20.09512    	0.97332     	36.15374    	0           
  10          	14.21172    	0.98841     	24.89701    	0           
  100         	1.38800     	0.99989     	2.57120     	0           
  300         	1.42804     	0.99992     	2.26853     	1           
  500         	3.39797     	0.99956     	4.90454     	2           
  1000        	3.40304     	0.99945     	5.62388     	6           
---> try to load best state
              	3.40304     	0.99945     	5.62388     	6                eval state : test_on_restore;
              	3.40304     	0.99945     	5.62388     	6                eval state : test_on_last_epoch;
---> final result              	3.40304     	0.99945     	5.62388     	6                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': 'poisson_v4_02', '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           	19.30933    	0.97428     	34.84551    	0           
  10          	14.15404    	0.98741     	25.54543    	0           
  100         	1.67608     	0.99985     	3.03712     	0           
  300         	1.77984     	0.99986     	3.00032     	1           
  500         	2.97560     	0.99960     	4.90157     	2           
  1000        	4.35523     	0.99912     	7.11705     	5           
---> try to load best state
              	4.35523     	0.99912     	7.11705     	5                eval state : test_on_restore;
              	4.35523     	0.99912     	7.11705     	5                eval state : test_on_last_epoch;
---> final result              	4.35523     	0.99912     	7.11705     	5                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': 'poisson_v4_02', '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           	110.73895   	-0.23867    	149.98233   	0           
  10          	97.35378    	0.20690     	133.95259   	0           
  100         	23.31498    	0.97780     	34.17411    	0           
  300         	7.22460     	0.99815     	10.56460    	1           
  500         	4.07153     	0.99946     	5.85742     	2           
  1000        	2.00563     	0.99988     	2.82129     	4           
---> try to load best state
              	2.00563     	0.99988     	2.82129     	4                eval state : test_on_restore;
              	2.00563     	0.99988     	2.82129     	4                eval state : test_on_last_epoch;
---> final result              	2.00563     	0.99988     	2.82129     	4                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', '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           	18.76041    	0.97549     	34.87904    	0           
  10          	10.66687    	0.99267     	20.34964    	0           
  100         	0.99552     	0.99995     	1.82515     	0           
  300         	1.20484     	0.99995     	1.75024     	1           
  500         	2.25075     	0.99979     	3.49071     	2           
  1000        	3.50481     	0.99945     	5.55079     	5           
---> try to load best state
              	3.50481     	0.99945     	5.55079     	5                eval state : test_on_restore;
              	3.50481     	0.99945     	5.55079     	5                eval state : test_on_last_epoch;
---> final result              	3.50481     	0.99945     	5.55079     	5                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': 'poisson_v4_02', '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           	19.27444    	0.97419     	35.51872    	0           
  10          	11.01962    	0.99227     	20.79721    	0           
  100         	1.02682     	0.99994     	1.90325     	0           
  300         	1.20529     	0.99994     	1.79045     	1           
  500         	2.30354     	0.99978     	3.55910     	2           
  1000        	3.52196     	0.99945     	5.55744     	5           
---> try to load best state
              	3.52196     	0.99945     	5.55744     	5                eval state : test_on_restore;
              	3.52196     	0.99945     	5.55744     	5                eval state : test_on_last_epoch;
---> final result              	3.52196     	0.99945     	5.55744     	5                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': 'poisson_v4_02', '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           	20.38772    	0.97153     	36.93608    	0           
  10          	11.54627    	0.99162     	21.49505    	0           
  100         	1.07048     	0.99994     	1.96483     	0           
  300         	1.20517     	0.99994     	1.80106     	1           
  500         	2.26554     	0.99978     	3.54739     	3           
  1000        	3.54896     	0.99944     	5.60768     	6           
---> try to load best state
              	3.54896     	0.99944     	5.60768     	6                eval state : test_on_restore;
              	3.54896     	0.99944     	5.60768     	6                eval state : test_on_last_epoch;
---> final result              	3.54896     	0.99944     	5.60768     	6                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': 'poisson_v4_02', '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           	20.45448    	0.97167     	37.12603    	0           
  10          	11.63861    	0.99168     	21.51056    	0           
  100         	1.07741     	0.99994     	1.98455     	0           
  300         	1.23078     	0.99994     	1.85039     	1           
  500         	2.25684     	0.99978     	3.58879     	2           
  1000        	3.51486     	0.99944     	5.62768     	5           
---> try to load best state
              	3.51486     	0.99944     	5.62768     	5                eval state : test_on_restore;
              	3.51486     	0.99944     	5.62768     	5                eval state : test_on_last_epoch;
---> final result              	3.51486     	0.99944     	5.62768     	5                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': 'poisson_v4_02', '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           	20.99858    	0.96976     	38.66522    	0           
  10          	12.25743    	0.99055     	22.86227    	0           
  100         	1.14524     	0.99993     	2.12027     	0           
  300         	1.36782     	0.99992     	2.15682     	1           
  500         	2.57241     	0.99971     	4.07651     	3           
  1000        	3.66395     	0.99939     	5.94646     	5           
---> try to load best state
              	3.66395     	0.99939     	5.94646     	5                eval state : test_on_restore;
              	3.66395     	0.99939     	5.94646     	5                eval state : test_on_last_epoch;
---> final result              	3.66395     	0.99939     	5.94646     	5                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': 'poisson_v4_02', '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           	19.19178    	0.97684     	34.35572    	0           
  10          	11.48347    	0.99209     	21.48795    	0           
  100         	1.46667     	0.99990     	2.45615     	0           
  300         	1.88197     	0.99985     	3.08402     	1           
  500         	2.54639     	0.99968     	4.52419     	2           
  1000        	3.75504     	0.99927     	6.67003     	5           
---> try to load best state
              	3.75504     	0.99927     	6.67003     	5                eval state : test_on_restore;
              	3.75504     	0.99927     	6.67003     	5                eval state : test_on_last_epoch;
---> final result              	3.75504     	0.99927     	6.67003     	5                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': 'poisson_v4_02', '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           	111.95085   	-0.28591    	152.21786   	0           
  10          	99.98380    	0.12573     	138.01912   	0           
  100         	26.95933    	0.96751     	39.80746    	0           
  300         	7.93045     	0.99766     	11.66072    	1           
  500         	4.34993     	0.99936     	6.27285     	1           
  1000        	2.08840     	0.99987     	2.95650     	3           
---> try to load best state
              	2.08840     	0.99987     	2.95650     	3                eval state : test_on_restore;
              	2.08840     	0.99987     	2.95650     	3                eval state : test_on_last_epoch;
---> final result              	2.08840     	0.99987     	2.95650     	3                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', '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           	18.32466    	0.97700     	33.51838    	0           
  10          	11.32225    	0.99185     	21.20183    	0           
  100         	0.90242     	0.99995     	1.74231     	0           
  300         	1.19422     	0.99994     	1.78512     	1           
  500         	2.23255     	0.99980     	3.41951     	2           
  1000        	3.50546     	0.99947     	5.43000     	5           
---> try to load best state
              	3.50546     	0.99947     	5.43000     	5                eval state : test_on_restore;
              	3.50546     	0.99947     	5.43000     	5                eval state : test_on_last_epoch;
---> final result              	3.50546     	0.99947     	5.43000     	5                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': 'poisson_v4_02', '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           	18.73624    	0.97562     	34.65600    	0           
  10          	11.69180    	0.99120     	21.97298    	0           
  100         	0.92237     	0.99995     	1.78325     	0           
  300         	1.27061     	0.99993     	1.93706     	1           
  500         	2.32299     	0.99978     	3.56689     	2           
  1000        	3.52789     	0.99946     	5.48353     	5           
---> try to load best state
              	3.52789     	0.99946     	5.48353     	5                eval state : test_on_restore;
              	3.52789     	0.99946     	5.48353     	5                eval state : test_on_last_epoch;
---> final result              	3.52789     	0.99946     	5.48353     	5                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': 'poisson_v4_02', '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           	19.16008    	0.97475     	35.37361    	0           
  10          	12.09239    	0.99065     	22.59735    	0           
  100         	0.97189     	0.99994     	1.88833     	0           
  300         	1.30035     	0.99993     	1.99687     	1           
  500         	2.35815     	0.99976     	3.68966     	3           
  1000        	3.59793     	0.99943     	5.61103     	5           
---> try to load best state
              	3.59793     	0.99943     	5.61103     	5                eval state : test_on_restore;
              	3.59793     	0.99943     	5.61103     	5                eval state : test_on_last_epoch;
---> final result              	3.59793     	0.99943     	5.61103     	5                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': 'poisson_v4_02', '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           	19.42759    	0.97431     	36.01955    	0           
  10          	12.25047    	0.99033     	23.16982    	0           
  100         	1.12063     	0.99992     	2.23230     	0           
  300         	1.33688     	0.99993     	2.03572     	1           
  500         	2.47801     	0.99974     	3.80782     	2           
  1000        	3.52635     	0.99946     	5.51421     	5           
---> try to load best state
              	3.52635     	0.99946     	5.51421     	5                eval state : test_on_restore;
              	3.52635     	0.99946     	5.51421     	5                eval state : test_on_last_epoch;
---> final result              	3.52635     	0.99946     	5.51421     	5                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': 'poisson_v4_02', '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           	19.40649    	0.97601     	35.26023    	0           
  10          	12.55258    	0.99076     	22.78010    	0           
  100         	1.17046     	0.99992     	2.20046     	0           
  300         	1.46374     	0.99991     	2.33058     	1           
  500         	2.68123     	0.99971     	4.17271     	2           
  1000        	4.02976     	0.99932     	6.12515     	5           
---> try to load best state
              	4.02976     	0.99932     	6.12515     	5                eval state : test_on_restore;
              	4.02976     	0.99932     	6.12515     	5                eval state : test_on_last_epoch;
---> final result              	4.02976     	0.99932     	6.12515     	5                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': 'poisson_v4_02', '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           	20.79393    	0.97353     	36.05018    	0           
  10          	12.45739    	0.99093     	22.70093    	0           
  100         	1.57030     	0.99989     	2.65293     	0           
  300         	1.96346     	0.99984     	3.21043     	1           
  500         	2.79650     	0.99964     	4.76946     	2           
  1000        	3.86519     	0.99923     	6.87001     	5           
---> try to load best state
              	3.86519     	0.99923     	6.87001     	5                eval state : test_on_restore;
              	3.86519     	0.99923     	6.87001     	5                eval state : test_on_last_epoch;
---> final result              	3.86519     	0.99923     	6.87001     	5                eval state : final;module_name : SGAR;subset : 32;cp_record_file : True;
