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

  Demo GAR 
  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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	98.37616    	0.18386     	134.77779   	0           
  10          	86.24568    	0.48869     	119.57893   	0           
  100         	26.55851    	0.97601     	36.41343    	0           
  300         	6.89214     	0.99815     	9.79841     	1           
  500         	4.81708     	0.99889     	7.26136     	2           
  1000        	4.06032     	0.99902     	6.63375     	3           
---> try to load best state
              	4.06032     	0.99902     	6.63375     	3                eval state : test_on_restore;
              	4.06032     	0.99902     	6.63375     	3                eval state : test_on_last_epoch;
---> final result              	4.06032     	0.99902     	6.63375     	3                eval state : final;
----------> finish x-yl training


---------->
GAR 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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	17.95520    	0.97857     	33.08335    	0           
  10          	13.56280    	0.98972     	23.51815    	0           
  100         	3.57038     	0.99916     	6.88013     	0           
  300         	3.16097     	0.99928     	6.24336     	2           
  500         	3.58056     	0.99920     	6.62653     	4           
  1000        	4.09024     	0.99910     	7.00964     	8           
---> try to load best state
              	4.09024     	0.99910     	7.00964     	8                eval state : test_on_restore;
              	4.09024     	0.99910     	7.00964     	8                eval state : test_on_last_epoch;
---> final result
              	4.09024     	0.99910     	7.00964     	8                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	16.64031    	0.98194     	30.47192    	0           
  10          	12.78441    	0.99102     	22.06975    	0           
  100         	3.55890     	0.99918     	6.80238     	0           
  300         	3.13497     	0.99928     	6.23709     	2           
  500         	3.72981     	0.99918     	6.73545     	4           
  1000        	4.16044     	0.99908     	7.08034     	8           
---> try to load best state
              	4.16044     	0.99908     	7.08034     	8                eval state : test_on_restore;
              	4.16044     	0.99908     	7.08034     	8                eval state : test_on_last_epoch;
---> final result
              	4.16044     	0.99908     	7.08034     	8                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	17.66552    	0.97987     	32.06002    	0           
  10          	13.62561    	0.98981     	23.29042    	0           
  100         	3.74379     	0.99909     	7.10703     	0           
  300         	3.24152     	0.99926     	6.30784     	1           
  epoch 460 reach nan state
---> try to load best state
              	3.50860     	0.99920     	6.60762     	2                eval state : test_on_restore;
              	3.24152     	0.99926     	6.30784     	2                eval state : test_on_last_epoch;
---> final result
              	3.24152     	0.99926     	6.30784     	2                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	18.30499    	0.97752     	33.38849    	0           
  10          	14.51805    	0.98839     	24.62112    	0           
  100         	3.95395     	0.99904     	7.31794     	0           
  300         	3.21906     	0.99928     	6.24557     	1           
  500         	3.70375     	0.99917     	6.70848     	2           
  1000        	4.27394     	0.99902     	7.28503     	5           
---> try to load best state
              	4.27394     	0.99902     	7.28503     	5                eval state : test_on_restore;
              	4.27394     	0.99902     	7.28503     	5                eval state : test_on_last_epoch;
---> final result
              	4.27394     	0.99902     	7.28503     	5                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	17.71341    	0.97996     	31.96969    	0           
  10          	13.47603    	0.99013     	23.01586    	0           
  100         	3.92617     	0.99905     	7.26997     	0           
  300         	3.37272     	0.99922     	6.56201     	2           
  500         	3.81136     	0.99908     	7.11454     	3           
  1000        	4.49524     	0.99887     	7.81979     	6           
---> try to load best state
              	4.49524     	0.99887     	7.81979     	6                eval state : test_on_restore;
              	4.49524     	0.99887     	7.81979     	6                eval state : test_on_last_epoch;
---> final result
              	4.49524     	0.99887     	7.81979     	6                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	17.92710    	0.98012     	32.25740    	0           
  10          	13.57187    	0.98988     	23.34079    	0           
  100         	4.41919     	0.99885     	7.87431     	0           
  300         	4.40219     	0.99878     	8.23840     	1           
  500         	5.16272     	0.99828     	9.67581     	3           
  1000        	5.85475     	0.99765     	11.07598    	6           
---> try to load best state
              	5.85475     	0.99765     	11.07598    	6                eval state : test_on_restore;
              	5.85475     	0.99765     	11.07598    	6                eval state : test_on_last_epoch;
---> final result
              	5.85475     	0.99765     	11.07598    	6                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': '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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	112.44916   	-0.16295    	154.67416   	0           
  10          	101.76920   	0.16912     	141.99951   	0           
  100         	31.66511    	0.95496     	46.49469    	0           
  300         	7.80697     	0.99764     	11.31458    	0           
  500         	5.32066     	0.99872     	7.98032     	1           
  1000        	4.39482     	0.99892     	7.07700     	2           
---> try to load best state
              	4.39482     	0.99892     	7.07700     	2                eval state : test_on_restore;
              	4.39482     	0.99892     	7.07700     	2                eval state : test_on_last_epoch;
---> final result              	4.39482     	0.99892     	7.07700     	2                eval state : final;
----------> finish x-yl training


---------->
GAR 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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	25.15442    	0.96319     	43.79240    	0           
  10          	19.80310    	0.97892     	32.94541    	0           
  100         	4.82544     	0.99855     	8.86339     	0           
  300         	3.46656     	0.99920     	6.57622     	1           
  500         	3.86955     	0.99911     	6.97929     	3           
  1000        	4.40809     	0.99899     	7.45753     	6           
---> try to load best state
              	4.40809     	0.99899     	7.45753     	6                eval state : test_on_restore;
              	4.40809     	0.99899     	7.45753     	6                eval state : test_on_last_epoch;
---> final result
              	4.40809     	0.99899     	7.45753     	6                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	25.14194    	0.96295     	43.88842    	0           
  10          	19.70222    	0.97897     	32.89050    	0           
  100         	4.88688     	0.99850     	8.98260     	0           
  300         	3.45829     	0.99920     	6.55833     	1           
  500         	3.84149     	0.99911     	6.95947     	3           
  1000        	4.36849     	0.99899     	7.43508     	6           
---> try to load best state
              	4.36849     	0.99899     	7.43508     	6                eval state : test_on_restore;
              	4.36849     	0.99899     	7.43508     	6                eval state : test_on_last_epoch;
---> final result
              	4.36849     	0.99899     	7.43508     	6                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	24.90407    	0.96343     	43.31854    	0           
  10          	19.34072    	0.97968     	32.16671    	0           
  100         	4.69612     	0.99859     	8.73286     	0           
  300         	3.42745     	0.99920     	6.57960     	1           
  500         	3.82944     	0.99911     	6.97820     	3           
  1000        	4.43508     	0.99897     	7.52865     	6           
---> try to load best state
              	4.43508     	0.99897     	7.52865     	6                eval state : test_on_restore;
              	4.43508     	0.99897     	7.52865     	6                eval state : test_on_last_epoch;
---> final result
              	4.43508     	0.99897     	7.52865     	6                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	23.17308    	0.96771     	40.88776    	0           
  10          	17.57620    	0.98301     	29.81160    	0           
  100         	4.52738     	0.99871     	8.45591     	0           
  300         	3.48608     	0.99918     	6.64130     	1           
  500         	3.91011     	0.99908     	7.10147     	3           
  1000        	4.57580     	0.99890     	7.73590     	7           
---> try to load best state
              	4.57580     	0.99890     	7.73590     	7                eval state : test_on_restore;
              	4.57580     	0.99890     	7.73590     	7                eval state : test_on_last_epoch;
---> final result
              	4.57580     	0.99890     	7.73590     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	23.69417    	0.96522     	41.65753    	0           
  10          	18.41814    	0.98158     	30.57877    	0           
  100         	4.83847     	0.99861     	8.70410     	0           
  300         	3.77958     	0.99909     	7.04107     	2           
  500         	4.18919     	0.99894     	7.60838     	3           
  1000        	4.85439     	0.99872     	8.30086     	7           
---> try to load best state
              	4.85439     	0.99872     	8.30086     	7                eval state : test_on_restore;
              	4.85439     	0.99872     	8.30086     	7                eval state : test_on_last_epoch;
---> final result
              	4.85439     	0.99872     	8.30086     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.05008    	0.97183     	37.36289    	0           
  10          	15.86621    	0.98455     	27.78442    	0           
  100         	5.60905     	0.99815     	9.69205     	0           
  300         	4.74680     	0.99868     	8.52955     	2           
  500         	5.44938     	0.99822     	9.87084     	4           
  1000        	5.92304     	0.99764     	11.13193    	8           
---> try to load best state
              	5.92304     	0.99764     	11.13193    	8                eval state : test_on_restore;
              	5.92304     	0.99764     	11.13193    	8                eval state : test_on_last_epoch;
---> final result
              	5.92304     	0.99764     	11.13193    	8                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': '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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	127.04747   	-0.88964    	171.64540   	0           
  10          	115.58669   	-0.29394    	158.53766   	0           
  100         	37.11378    	0.93651     	55.21571    	0           
  300         	9.14739     	0.99688     	12.98638    	1           
  500         	5.51350     	0.99877     	7.88124     	2           
  1000        	4.26140     	0.99903     	6.69603     	4           
---> try to load best state
              	4.26140     	0.99903     	6.69603     	4                eval state : test_on_restore;
              	4.26140     	0.99903     	6.69603     	4                eval state : test_on_last_epoch;
---> final result              	4.26140     	0.99903     	6.69603     	4                eval state : final;
----------> finish x-yl training


---------->
GAR 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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	22.42867    	0.96865     	40.49985    	0           
  10          	17.17229    	0.98241     	30.22439    	0           
  100         	4.85166     	0.99849     	9.05902     	0           
  300         	3.85877     	0.99906     	7.14088     	2           
  500         	4.17356     	0.99897     	7.54611     	4           
  1000        	4.62273     	0.99884     	7.99256     	8           
---> try to load best state
              	4.62273     	0.99884     	7.99256     	8                eval state : test_on_restore;
              	4.62273     	0.99884     	7.99256     	8                eval state : test_on_last_epoch;
---> final result
              	4.62273     	0.99884     	7.99256     	8                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	22.28271    	0.96918     	40.37894    	0           
  10          	17.03949    	0.98273     	30.09421    	0           
  100         	4.81611     	0.99850     	9.03394     	0           
  300         	3.82285     	0.99908     	7.11040     	2           
  500         	4.22262     	0.99896     	7.57344     	4           
  1000        	4.61902     	0.99884     	8.00346     	8           
---> try to load best state
              	4.61902     	0.99884     	8.00346     	8                eval state : test_on_restore;
              	4.61902     	0.99884     	8.00346     	8                eval state : test_on_last_epoch;
---> final result
              	4.61902     	0.99884     	8.00346     	8                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	21.81527    	0.97088     	39.04053    	0           
  10          	16.80653    	0.98378     	29.14112    	0           
  100         	4.78833     	0.99854     	8.90567     	1           
  300         	3.70197     	0.99912     	6.95648     	2           
  500         	4.06158     	0.99901     	7.43606     	4           
  1000        	4.55318     	0.99886     	7.93653     	8           
---> try to load best state
              	4.55318     	0.99886     	7.93653     	8                eval state : test_on_restore;
              	4.55318     	0.99886     	7.93653     	8                eval state : test_on_last_epoch;
---> final result
              	4.55318     	0.99886     	7.93653     	8                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	21.19948    	0.97234     	38.03677    	0           
  10          	16.59482    	0.98428     	28.67278    	0           
  100         	5.02303     	0.99847     	9.11674     	0           
  300         	3.87882     	0.99908     	7.16146     	2           
  500         	4.31274     	0.99893     	7.74460     	4           
  1000        	4.73025     	0.99878     	8.23855     	8           
---> try to load best state
              	4.73025     	0.99878     	8.23855     	8                eval state : test_on_restore;
              	4.73025     	0.99878     	8.23855     	8                eval state : test_on_last_epoch;
---> final result
              	4.73025     	0.99878     	8.23855     	8                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	22.76030    	0.97029     	39.65361    	0           
  10          	18.00898    	0.98305     	30.22811    	0           
  100         	5.12053     	0.99858     	8.88387     	0           
  300         	3.96876     	0.99908     	7.14523     	2           
  500         	4.36123     	0.99892     	7.75196     	3           
  1000        	4.92300     	0.99870     	8.45186     	7           
---> try to load best state
              	4.92300     	0.99870     	8.45186     	7                eval state : test_on_restore;
              	4.92300     	0.99870     	8.45186     	7                eval state : test_on_last_epoch;
---> final result
              	4.92300     	0.99870     	8.45186     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	25.10881    	0.96485     	43.99132    	0           
  10          	19.41411    	0.98024     	32.82700    	0           
  100         	5.48359     	0.99832     	9.60848     	0           
  300         	4.67612     	0.99870     	8.53356     	2           
  500         	5.29639     	0.99824     	9.78423     	3           
  1000        	5.99528     	0.99755     	11.35732    	7           
---> try to load best state
              	5.99528     	0.99755     	11.35732    	7                eval state : test_on_restore;
              	5.99528     	0.99755     	11.35732    	7                eval state : test_on_last_epoch;
---> final result
              	5.99528     	0.99755     	11.35732    	7                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': '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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	113.75020   	-0.43280    	156.15828   	0           
  10          	102.81490   	-0.01143    	143.83394   	0           
  100         	32.18534    	0.94596     	49.28086    	0           
  300         	6.98050     	0.99803     	10.10149    	1           
  500         	4.79380     	0.99885     	7.35826     	2           
  1000        	4.04340     	0.99898     	6.74356     	4           
---> try to load best state
              	4.04340     	0.99898     	6.74356     	4                eval state : test_on_restore;
              	4.04340     	0.99898     	6.74356     	4                eval state : test_on_last_epoch;
---> final result              	4.04340     	0.99898     	6.74356     	4                eval state : final;
----------> finish x-yl training


---------->
GAR 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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	22.53638    	0.96813     	39.52380    	0           
  10          	17.60056    	0.98248     	29.38273    	0           
  100         	5.16864     	0.99842     	9.17730     	0           
  300         	3.41264     	0.99918     	6.64461     	2           
  500         	3.75808     	0.99908     	7.04998     	4           
  1000        	4.27314     	0.99898     	7.43211     	8           
---> try to load best state
              	4.27314     	0.99898     	7.43211     	8                eval state : test_on_restore;
              	4.27314     	0.99898     	7.43211     	8                eval state : test_on_last_epoch;
---> final result
              	4.27314     	0.99898     	7.43211     	8                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	22.47904    	0.96831     	39.48617    	0           
  10          	17.57564    	0.98252     	29.38534    	0           
  100         	5.18748     	0.99842     	9.18871     	0           
  300         	3.43267     	0.99918     	6.65168     	2           
  500         	3.75425     	0.99908     	7.05394     	3           
  1000        	4.31946     	0.99898     	7.47388     	7           
---> try to load best state
              	4.31946     	0.99898     	7.47388     	7                eval state : test_on_restore;
              	4.31946     	0.99898     	7.47388     	7                eval state : test_on_last_epoch;
---> final result
              	4.31946     	0.99898     	7.47388     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	22.11010    	0.96884     	39.00455    	0           
  10          	17.44751    	0.98282     	29.10126    	0           
  100         	5.07262     	0.99847     	9.06930     	0           
  300         	3.49653     	0.99917     	6.69898     	2           
  500         	3.87666     	0.99905     	7.19447     	4           
  1000        	4.45438     	0.99891     	7.69559     	7           
---> try to load best state
              	4.45438     	0.99891     	7.69559     	7                eval state : test_on_restore;
              	4.45438     	0.99891     	7.69559     	7                eval state : test_on_last_epoch;
---> final result
              	4.45438     	0.99891     	7.69559     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	22.66095    	0.96659     	40.03481    	0           
  10          	17.71026    	0.98251     	29.48178    	0           
  100         	4.63370     	0.99866     	8.49130     	0           
  300         	3.54977     	0.99916     	6.73513     	2           
  500         	3.93583     	0.99905     	7.21018     	3           
  1000        	4.43574     	0.99889     	7.76287     	7           
---> try to load best state
              	4.43574     	0.99889     	7.76287     	7                eval state : test_on_restore;
              	4.43574     	0.99889     	7.76287     	7                eval state : test_on_last_epoch;
---> final result
              	4.43574     	0.99889     	7.76287     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	21.24049    	0.97046     	38.21266    	0           
  10          	16.87569    	0.98435     	28.24286    	0           
  100         	4.65246     	0.99867     	8.46888     	0           
  300         	3.74841     	0.99910     	7.01022     	2           
  500         	4.18096     	0.99894     	7.60778     	4           
  1000        	4.79427     	0.99872     	8.34697     	7           
---> try to load best state
              	4.79427     	0.99872     	8.34697     	7                eval state : test_on_restore;
              	4.79427     	0.99872     	8.34697     	7                eval state : test_on_last_epoch;
---> final result
              	4.79427     	0.99872     	8.34697     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.36404    	0.97176     	36.82084    	0           
  10          	16.65950    	0.98335     	28.33225    	0           
  100         	5.32098     	0.99835     	9.22905     	0           
  300         	4.53800     	0.99873     	8.34447     	2           
  500         	5.23200     	0.99824     	9.71106     	3           
  1000        	5.75312     	0.99761     	11.10728    	7           
---> try to load best state
              	5.75312     	0.99761     	11.10728    	7                eval state : test_on_restore;
              	5.75312     	0.99761     	11.10728    	7                eval state : test_on_last_epoch;
---> final result
              	5.75312     	0.99761     	11.10728    	7                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': '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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	110.73895   	-0.23867    	149.98233   	0           
  10          	97.42073    	0.20622     	134.02596   	0           
  100         	27.32637    	0.97057     	38.87145    	0           
  300         	6.87054     	0.99816     	9.76088     	1           
  500         	4.82884     	0.99889     	7.26810     	2           
  1000        	4.06777     	0.99902     	6.63172     	3           
---> try to load best state
              	4.06777     	0.99902     	6.63172     	3                eval state : test_on_restore;
              	4.06777     	0.99902     	6.63172     	3                eval state : test_on_last_epoch;
---> final result              	4.06777     	0.99902     	6.63172     	3                eval state : final;
----------> finish x-yl training


---------->
GAR 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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.05654    	0.97229     	37.12368    	0           
  10          	14.84707    	0.98582     	26.71803    	0           
  100         	4.14694     	0.99888     	7.83754     	0           
  300         	3.45928     	0.99919     	6.66234     	2           
  500         	3.86537     	0.99908     	7.11505     	3           
  1000        	4.43536     	0.99896     	7.51359     	7           
---> try to load best state
              	4.43536     	0.99896     	7.51359     	7                eval state : test_on_restore;
              	4.43536     	0.99896     	7.51359     	7                eval state : test_on_last_epoch;
---> final result
              	4.43536     	0.99896     	7.51359     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.62549    	0.97086     	37.78446    	0           
  10          	15.33326    	0.98510     	27.24154    	0           
  100         	4.26224     	0.99884     	7.93525     	0           
  300         	3.43774     	0.99918     	6.67538     	2           
  500         	3.88058     	0.99906     	7.15137     	3           
  1000        	4.44160     	0.99896     	7.52799     	7           
---> try to load best state
              	4.44160     	0.99896     	7.52799     	7                eval state : test_on_restore;
              	4.44160     	0.99896     	7.52799     	7                eval state : test_on_last_epoch;
---> final result
              	4.44160     	0.99896     	7.52799     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	21.76513    	0.96798     	39.30975    	0           
  10          	16.12865    	0.98374     	28.14545    	0           
  100         	4.28274     	0.99883     	7.99491     	0           
  300         	3.44905     	0.99917     	6.69160     	2           
  500         	3.92038     	0.99907     	7.13894     	4           
  1000        	4.42660     	0.99896     	7.51848     	7           
---> try to load best state
              	4.42660     	0.99896     	7.51848     	7                eval state : test_on_restore;
              	4.42660     	0.99896     	7.51848     	7                eval state : test_on_last_epoch;
---> final result
              	4.42660     	0.99896     	7.51848     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	21.88618    	0.96814     	39.54111    	0           
  10          	16.22390    	0.98374     	28.33082    	0           
  100         	4.27836     	0.99882     	8.00442     	0           
  300         	3.43180     	0.99917     	6.72862     	2           
  500         	3.88595     	0.99905     	7.20814     	3           
  1000        	4.46259     	0.99891     	7.69978     	7           
---> try to load best state
              	4.46259     	0.99891     	7.69978     	7                eval state : test_on_restore;
              	4.46259     	0.99891     	7.69978     	7                eval state : test_on_last_epoch;
---> final result
              	4.46259     	0.99891     	7.69978     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	22.65096    	0.96570     	41.31767    	0           
  10          	17.01915    	0.98195     	29.83647    	0           
  100         	4.47514     	0.99875     	8.25083     	0           
  300         	3.63896     	0.99912     	6.97515     	2           
  500         	4.05190     	0.99898     	7.52923     	3           
  1000        	4.62760     	0.99880     	8.12405     	7           
---> try to load best state
              	4.62760     	0.99880     	8.12405     	7                eval state : test_on_restore;
              	4.62760     	0.99880     	8.12405     	7                eval state : test_on_last_epoch;
---> final result
              	4.62760     	0.99880     	8.12405     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.73126    	0.97344     	36.77844    	0           
  10          	15.69143    	0.98652     	26.37458    	0           
  100         	4.52691     	0.99883     	7.91683     	0           
  300         	4.42888     	0.99879     	8.19828     	2           
  500         	5.18037     	0.99829     	9.59796     	3           
  1000        	5.90790     	0.99759     	11.15798    	7           
---> try to load best state
              	5.90790     	0.99759     	11.15798    	7                eval state : test_on_restore;
              	5.90790     	0.99759     	11.15798    	7                eval state : test_on_last_epoch;
---> final result
              	5.90790     	0.99759     	11.15798    	7                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': '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, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	111.95085   	-0.28591    	152.21786   	0           
  10          	100.05972   	0.12504     	138.09648   	0           
  100         	31.18666    	0.95780     	44.89335    	0           
  300         	7.41764     	0.99785     	10.56194    	1           
  500         	5.07346     	0.99881     	7.55004     	2           
  1000        	4.23510     	0.99897     	6.83528     	4           
---> try to load best state
              	4.23510     	0.99897     	6.83528     	4                eval state : test_on_restore;
              	4.23510     	0.99897     	6.83528     	4                eval state : test_on_last_epoch;
---> final result              	4.23510     	0.99897     	6.83528     	4                eval state : final;
----------> finish x-yl training


---------->
GAR 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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	19.74214    	0.97389     	35.73055    	0           
  10          	14.89019    	0.98641     	25.91609    	0           
  100         	4.17937     	0.99887     	7.82339     	0           
  300         	3.46448     	0.99919     	6.63055     	2           
  500         	3.90759     	0.99908     	7.07295     	3           
  1000        	4.40369     	0.99899     	7.40265     	6           
---> try to load best state
              	4.40369     	0.99899     	7.40265     	6                eval state : test_on_restore;
              	4.40369     	0.99899     	7.40265     	6                eval state : test_on_last_epoch;
---> final result
              	4.40369     	0.99899     	7.40265     	6                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.16019    	0.97248     	36.88925    	0           
  10          	15.29247    	0.98544     	26.92355    	0           
  100         	4.31414     	0.99886     	7.91207     	0           
  300         	3.63040     	0.99915     	6.76216     	1           
  500         	3.98769     	0.99905     	7.21572     	2           
  1000        	4.49723     	0.99894     	7.58326     	6           
---> try to load best state
              	4.49723     	0.99894     	7.58326     	6                eval state : test_on_restore;
              	4.49723     	0.99894     	7.58326     	6                eval state : test_on_last_epoch;
---> final result
              	4.49723     	0.99894     	7.58326     	6                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.64863    	0.97148     	37.61390    	0           
  10          	15.95658    	0.98418     	27.98531    	0           
  100         	4.60260     	0.99869     	8.43736     	0           
  300         	3.65286     	0.99912     	6.89211     	1           
  500         	4.07549     	0.99902     	7.33475     	3           
  1000        	4.60502     	0.99890     	7.72614     	5           
---> try to load best state
              	4.60502     	0.99890     	7.72614     	5                eval state : test_on_restore;
              	4.60502     	0.99890     	7.72614     	5                eval state : test_on_last_epoch;
---> final result
              	4.60502     	0.99890     	7.72614     	5                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.70510    	0.97133     	38.12783    	0           
  10          	15.98074    	0.98435     	28.20585    	0           
  100         	4.73815     	0.99866     	8.52827     	0           
  300         	3.69299     	0.99915     	6.82435     	1           
  500         	4.09217     	0.99902     	7.35274     	2           
  1000        	4.61892     	0.99888     	7.79304     	5           
---> try to load best state
              	4.61892     	0.99888     	7.79304     	5                eval state : test_on_restore;
              	4.61892     	0.99888     	7.79304     	5                eval state : test_on_last_epoch;
---> final result
              	4.61892     	0.99888     	7.79304     	5                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	20.75940    	0.97296     	37.45380    	0           
  10          	16.19888    	0.98510     	27.85301    	0           
  100         	4.61307     	0.99870     	8.41834     	0           
  300         	3.82985     	0.99906     	7.16800     	2           
  500         	4.30101     	0.99892     	7.74882     	4           
  1000        	4.82325     	0.99876     	8.27235     	7           
---> try to load best state
              	4.82325     	0.99876     	8.27235     	7                eval state : test_on_restore;
              	4.82325     	0.99876     	8.27235     	7                eval state : test_on_last_epoch;
---> final result
              	4.82325     	0.99876     	8.27235     	7                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': '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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	21.64658    	0.97124     	37.94043    	0           
  10          	16.68621    	0.98512     	27.42227    	0           
  100         	4.88041     	0.99868     	8.45106     	0           
  300         	4.62241     	0.99872     	8.43520     	2           
  500         	5.30750     	0.99823     	9.84226     	3           
  1000        	5.95182     	0.99757     	11.27930    	7           
---> try to load best state
              	5.95182     	0.99757     	11.27930    	7                eval state : test_on_restore;
              	5.95182     	0.99757     	11.27930    	7                eval state : test_on_last_epoch;
---> final result
              	5.95182     	0.99757     	11.27930    	7                eval state : final;module_name : GAR;subset : 32;cp_record_file : True;
