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

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.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        	gaussian_loss      	time        
  1           	171.29591   	-0.62289    	285.77493   	1129459.00000      	0           
  10          	149.15819   	-0.35631    	254.65767   	1012340.62500      	0           
  100         	75.71984    	0.26126     	135.77512   	279789.21875       	5           
  300         	49.05381    	0.23431     	100.68788   	150027.09375       	15          
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: 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        	gaussian_loss      	time        
  1           	130.65968   	0.04878     	230.48550   	976038.50000       	0           
  10          	115.89237   	0.15861     	207.43233   	994727.93750       	0           
  100         	40.88594    	0.41502     	75.50146    	337298.46875       	5           
  300         	19.65431    	0.47968     	40.40858    	60555.32031        	15          
  500         	17.24706    	0.48657     	36.51234    	37535.23047        	25          
  1000        	16.82879    	0.46450     	36.89405    	27575.35938        	51          
---> try to load best state
              	16.82879    	0.46450     	36.89405    	27575.35938        	51               eval state : test_on_restore;
              	16.82879    	0.46450     	36.89405    	27575.35938        	51               eval state : test_on_last_epoch;
---> final result              	16.82879    	0.46450     	36.89405    	27575.35938        	51               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 4, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	531.52942   	-15.13995   	760.48236   	14911722.00000     	0           
  10          	394.84274   	-12.57575   	593.03558   	11176378.00000     	0           
  100         	38.23454    	-0.21351    	60.84253    	994055.81250       	1           
  300         	19.65458    	-2.20803    	39.54019    	1789542.62500      	5           
  500         	21.28416    	-5.24141    	40.61465    	2366328.75000      	9           
  1000        	20.70958    	-5.85735    	40.73822    	3002044.75000      	17          
---> try to load best state
              	20.70958    	-5.85735    	40.73822    	3002044.75000      	17               eval state : test_on_restore;
              	20.70958    	-5.85735    	40.73822    	3002044.75000      	17               eval state : test_on_last_epoch;
---> final result
              	20.70958    	-5.85735    	40.73822    	3002044.75000      	17               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 8, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	385.38782   	-3.86054    	579.75256   	8232000.50000      	0           
  10          	291.43536   	-2.93955    	463.49258   	6453253.50000      	0           
  100         	28.93333    	-0.29021    	56.88136    	713741.75000       	4           
  300         	19.94196    	-3.36098    	39.67858    	1068919.25000      	10          
  500         	22.55714    	-8.55745    	40.96946    	1441233.62500      	14          
  1000        	19.47038    	-3.80256    	39.42355    	1490835.50000      	24          
---> try to load best state
              	19.47038    	-3.80256    	39.42355    	1490835.50000      	24               eval state : test_on_restore;
              	19.47038    	-3.80256    	39.42355    	1490835.50000      	25               eval state : test_on_last_epoch;
---> final result
              	19.47038    	-3.80256    	39.42355    	1490835.50000      	25               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 16, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	228.47905   	-1.14173    	371.80521   	3101375.25000      	0           
  10          	158.25266   	-0.72310    	276.50153   	2121294.25000      	0           
  100         	24.29872    	-1.21567    	42.74068    	307978.59375       	3           
  300         	19.07271    	-0.99910    	37.61201    	752109.56250       	8           
  500         	19.58790    	-1.61731    	38.32411    	1043122.18750      	14          
  1000        	17.49321    	-0.20100    	36.85059    	1153319.87500      	27          
---> try to load best state
              	17.49321    	-0.20100    	36.85059    	1153319.87500      	27               eval state : test_on_restore;
              	17.49321    	-0.20100    	36.85059    	1153319.87500      	27               eval state : test_on_last_epoch;
---> final result
              	17.49321    	-0.20100    	36.85059    	1153319.87500      	27               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	131.03136   	-0.03780    	213.68898   	854346.43750       	0           
  10          	94.70866    	0.03035     	166.07809   	636582.43750       	0           
  100         	23.50412    	-1.72298    	40.63830    	209271.45312       	6           
  300         	19.08732    	-1.09880    	37.15590    	387725.65625       	19          
  500         	18.84309    	-1.15958    	37.46377    	490129.56250       	33          
  1000        	17.39939    	0.06068     	36.74829    	534424.25000       	66          
---> try to load best state
              	17.39939    	0.06068     	36.74829    	534424.25000       	66               eval state : test_on_restore;
              	17.39939    	0.06068     	36.74829    	534424.25000       	67               eval state : test_on_last_epoch;
---> final result
              	17.39939    	0.06068     	36.74829    	534424.25000       	67               eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 0 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: 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        	gaussian_loss      	time        
  1           	196.75124   	-0.58729    	378.20691   	2939867.25000      	0           
  10          	166.95528   	-0.30939    	331.50748   	2822480.25000      	0           
  100         	46.21051    	0.39492     	100.21826   	510922.81250       	6           
  300         	25.16128    	0.46073     	51.65910    	87560.28125        	18          
  500         	22.53036    	0.44405     	46.93857    	55107.89062        	29          
  1000        	21.60988    	0.38096     	46.26627    	35424.11328        	54          
---> try to load best state
              	21.60988    	0.38096     	46.26627    	35424.11328        	54               eval state : test_on_restore;
              	21.60988    	0.38096     	46.26627    	35424.11328        	54               eval state : test_on_last_epoch;
---> final result              	21.60988    	0.38096     	46.26627    	35424.11328        	54               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 4, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	520.19061   	-10.74051   	679.75275   	11771089.00000     	0           
  10          	370.77985   	-7.42979    	511.84479   	7941737.50000      	0           
  100         	44.84669    	-0.09001    	66.06842    	1106039.12500      	1           
  300         	23.81258    	-2.06627    	44.64808    	1851908.12500      	5           
  500         	24.00495    	-1.95260    	45.43822    	2248429.25000      	8           
  1000        	27.36423    	-12.55800   	45.45107    	2455018.75000      	16          
---> try to load best state
              	27.36423    	-12.55800   	45.45107    	2455018.75000      	16               eval state : test_on_restore;
              	27.36423    	-12.55800   	45.45107    	2455018.75000      	17               eval state : test_on_last_epoch;
---> final result
              	27.36423    	-12.55800   	45.45107    	2455018.75000      	17               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 8, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	394.69833   	-4.36289    	579.60541   	8235901.00000      	0           
  10          	248.88013   	-2.62063    	395.82819   	4778862.50000      	0           
  100         	35.05727    	-0.02191    	53.84180    	565172.62500       	2           
  300         	24.44279    	-1.09647    	45.96547    	1134321.37500      	6           
  500         	22.83825    	-0.88773    	44.58909    	1302889.50000      	10          
  1000        	21.55264    	0.29526     	44.53651    	1452728.62500      	20          
---> try to load best state
              	21.55264    	0.29526     	44.53651    	1452728.62500      	20               eval state : test_on_restore;
              	21.55264    	0.29526     	44.53651    	1452728.62500      	20               eval state : test_on_last_epoch;
---> final result
              	21.55264    	0.29526     	44.53651    	1452728.62500      	20               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 16, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	229.05690   	-0.62612    	418.23087   	3899174.00000      	0           
  10          	160.64500   	-0.25775    	304.83551   	2520818.25000      	0           
  100         	32.44818    	-0.09016    	50.55909    	386408.78125       	2           
  300         	23.47651    	-0.83881    	45.61545    	935777.87500       	8           
  500         	23.04172    	-1.52249    	45.31244    	1258286.62500      	13          
  1000        	25.48628    	-3.14053    	45.56269    	1660902.75000      	26          
---> try to load best state
              	25.48628    	-3.14053    	45.56269    	1660902.75000      	26               eval state : test_on_restore;
              	25.48628    	-3.14053    	45.56269    	1660902.75000      	26               eval state : test_on_last_epoch;
---> final result
              	25.48628    	-3.14053    	45.56269    	1660902.75000      	27               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	193.95273   	-0.67510    	362.05606   	2771976.75000      	0           
  10          	127.04498   	-0.30530    	250.99786   	1637671.50000      	0           
  100         	27.64206    	-1.24685    	47.77360    	237330.81250       	6           
  300         	23.33990    	-0.82505    	44.83693    	396502.06250       	19          
  500         	23.70064    	-1.47448    	44.89935    	477357.06250       	33          
  1000        	23.58628    	-0.57381    	44.51610    	557536.12500       	65          
---> try to load best state
              	23.58628    	-0.57381    	44.51610    	557536.12500       	65               eval state : test_on_restore;
              	23.58628    	-0.57381    	44.51610    	557536.12500       	66               eval state : test_on_last_epoch;
---> final result
              	23.58628    	-0.57381    	44.51610    	557536.12500       	66               eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 1 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: 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        	gaussian_loss      	time        
  1           	160.41031   	-0.31743    	307.53506   	1920367.37500      	0           
  10          	136.38959   	-0.12242    	268.55600   	1830111.25000      	0           
  100         	39.62469    	0.42269     	73.02271    	292515.71875       	5           
  300         	21.77633    	0.47172     	46.49144    	77543.86719        	15          
  500         	18.44090    	0.47255     	41.90529    	45238.51562        	26          
  1000        	16.45175    	0.42706     	38.69908    	24556.04688        	49          
---> try to load best state
              	16.45175    	0.42706     	38.69908    	24556.04688        	50               eval state : test_on_restore;
              	16.45175    	0.42706     	38.69908    	24556.04688        	50               eval state : test_on_last_epoch;
---> final result              	16.45175    	0.42706     	38.69908    	24556.04688        	50               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 4, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	494.87125   	-8.16531    	741.22241   	14208588.00000     	0           
  10          	432.93381   	-7.32345    	673.18329   	13804700.00000     	0           
  100         	57.76202    	0.07303     	93.04394    	1855930.62500      	1           
  300         	19.03284    	-2.15035    	43.01242    	2169338.25000      	5           
  500         	18.13401    	-0.32218    	42.57759    	2838782.25000      	8           
  1000        	21.89495    	-31.34547   	44.56385    	3559292.00000      	16          
---> try to load best state
              	21.89495    	-31.34547   	44.56385    	3559292.00000      	16               eval state : test_on_restore;
              	21.89495    	-31.34547   	44.56385    	3559292.00000      	16               eval state : test_on_last_epoch;
---> final result
              	21.89495    	-31.34547   	44.56385    	3559292.00000      	16               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 8, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	461.36340   	-6.87913    	732.77094   	13854084.00000     	0           
  10          	409.07956   	-6.51730    	680.26654   	14606072.00000     	0           
  100         	49.02325    	0.10862     	84.99326    	1608868.25000      	2           
  300         	19.66105    	-3.19545    	42.38532    	1084515.87500      	5           
  500         	18.91901    	-1.23772    	41.74095    	1105586.37500      	9           
  1000        	17.32812    	0.38983     	41.07549    	1059732.62500      	19          
---> try to load best state
              	17.32812    	0.38983     	41.07549    	1059732.62500      	19               eval state : test_on_restore;
              	17.32812    	0.38983     	41.07549    	1059732.62500      	19               eval state : test_on_last_epoch;
---> final result
              	17.32812    	0.38983     	41.07549    	1059732.62500      	19               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 16, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	264.49368   	-1.37688    	433.30991   	4240630.00000      	0           
  10          	183.40265   	-0.87942    	318.57608   	2820505.50000      	0           
  100         	29.00323    	-0.19809    	48.08182    	343235.62500       	3           
  300         	20.72033    	-4.99287    	40.96063    	502723.06250       	8           
  500         	19.76207    	-3.98377    	40.80976    	546395.87500       	13          
  1000        	17.33784    	-0.94950    	39.56684    	487347.31250       	26          
---> try to load best state
              	17.33784    	-0.94950    	39.56684    	487347.31250       	26               eval state : test_on_restore;
              	17.33784    	-0.94950    	39.56684    	487347.31250       	27               eval state : test_on_last_epoch;
---> final result
              	17.33784    	-0.94950    	39.56684    	487347.31250       	27               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	159.46883   	-0.39248    	289.07013   	1744523.00000      	0           
  10          	105.56324   	-0.19108    	205.16722   	1076398.25000      	0           
  100         	26.90781    	-1.15475    	47.04282    	249408.15625       	7           
  300         	18.77587    	-0.44351    	40.90508    	363132.28125       	20          
  500         	19.61367    	-2.75265    	41.63128    	448961.75000       	33          
  1000        	20.55332    	-4.40107    	42.40316    	533830.06250       	66          
---> try to load best state
              	20.55332    	-4.40107    	42.40316    	533830.06250       	66               eval state : test_on_restore;
              	20.55332    	-4.40107    	42.40316    	533830.06250       	66               eval state : test_on_last_epoch;
---> final result
              	20.55332    	-4.40107    	42.40316    	533830.06250       	66               eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 2 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: 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        	gaussian_loss      	time        
  1           	203.33586   	-0.56942    	375.68076   	2999457.50000      	0           
  10          	174.61314   	-0.32920    	331.68188   	2946240.50000      	0           
  100         	43.34622    	0.35736     	93.63638    	408000.00000       	5           
  300         	22.47389    	0.45101     	51.34619    	72727.91406        	16          
  500         	18.32820    	0.39124     	42.54720    	38774.98047        	26          
  1000        	16.01829    	0.30982     	36.46934    	20827.42188        	55          
---> try to load best state
              	16.01829    	0.30982     	36.46934    	20827.42188        	55               eval state : test_on_restore;
              	16.01829    	0.30982     	36.46934    	20827.42188        	55               eval state : test_on_last_epoch;
---> final result              	16.01829    	0.30982     	36.46934    	20827.42188        	55               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 4, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	650.31085   	-69.53140   	846.59619   	18796348.00000     	0           
  10          	604.38055   	-56.00679   	800.81915   	20258004.00000     	0           
  100         	125.99655   	-1.56235    	168.29053   	7044865.00000      	1           
  300         	21.15928    	-3.76272    	39.97852    	2802488.00000      	5           
  500         	18.19201    	-1.65456    	38.17468    	3694265.25000      	8           
  1000        	30.35774    	-91.73593   	46.42427    	3467757.25000      	17          
---> try to load best state
              	30.35774    	-91.73593   	46.42427    	3467757.25000      	17               eval state : test_on_restore;
              	30.35774    	-91.73593   	46.42427    	3467757.25000      	17               eval state : test_on_last_epoch;
---> final result
              	30.35774    	-91.73593   	46.42427    	3467757.25000      	17               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 8, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	462.36621   	-6.02501    	745.96185   	14328630.00000     	0           
  10          	418.92307   	-5.28656    	701.21307   	15529158.00000     	0           
  100         	56.56271    	-0.09170    	100.94680   	1766860.62500      	2           
  300         	18.22820    	-1.67333    	38.08367    	611792.56250       	6           
  500         	18.22588    	-1.31078    	37.98884    	722873.06250       	10          
  1000        	17.39709    	-1.87236    	37.24588    	779824.81250       	18          
---> try to load best state
              	17.39709    	-1.87236    	37.24588    	779824.81250       	18               eval state : test_on_restore;
              	17.39709    	-1.87236    	37.24588    	779824.81250       	18               eval state : test_on_last_epoch;
---> final result
              	17.39709    	-1.87236    	37.24588    	779824.81250       	18               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 16, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	338.67319   	-1.82367    	555.71893   	7506920.00000      	0           
  10          	291.77499   	-1.43107    	501.22983   	7489554.00000      	0           
  100         	45.28321    	-0.33542    	89.73248    	1050652.00000      	2           
  300         	19.98161    	-5.48340    	43.07066    	514190.93750       	7           
  500         	19.81596    	-2.48567    	41.01910    	505574.31250       	12          
  1000        	16.28032    	0.14540     	38.73713    	489695.53125       	27          
---> try to load best state
              	16.28032    	0.14540     	38.73713    	489695.53125       	27               eval state : test_on_restore;
              	16.28032    	0.14540     	38.73713    	489695.53125       	27               eval state : test_on_last_epoch;
---> final result
              	16.28032    	0.14540     	38.73713    	489695.53125       	27               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	205.87971   	-0.65326    	360.55286   	2840871.25000      	0           
  10          	157.35628   	-0.42984    	293.15909   	2320573.75000      	0           
  100         	25.97782    	-0.55518    	46.40660    	215882.79688       	7           
  300         	17.44262    	-0.49456    	34.77710    	210238.96875       	22          
  500         	18.39331    	-2.16473    	36.09126    	261077.65625       	37          
  1000        	16.72885    	-0.86675    	34.61731    	237045.06250       	74          
---> try to load best state
              	16.72885    	-0.86675    	34.61731    	237045.06250       	74               eval state : test_on_restore;
              	16.72885    	-0.86675    	34.61731    	237045.06250       	74               eval state : test_on_last_epoch;
---> final result
              	16.72885    	-0.86675    	34.61731    	237045.06250       	75               eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 3 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: 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        	gaussian_loss      	time        
  1           	174.21561   	-0.43841    	345.09113   	2544165.00000      	0           
  10          	149.63606   	-0.20242    	298.11938   	2374272.75000      	0           
  100         	41.64949    	0.41710     	91.98065    	472087.90625       	6           
  300         	22.93625    	0.46961     	52.98317    	95637.89062        	18          
  500         	19.86498    	0.48243     	46.92938    	55900.90234        	29          
  1000        	18.12217    	0.44873     	43.53709    	31551.18164        	57          
---> try to load best state
              	18.12217    	0.44873     	43.53709    	31551.18164        	57               eval state : test_on_restore;
              	18.12217    	0.44873     	43.53709    	31551.18164        	57               eval state : test_on_last_epoch;
---> final result              	18.12217    	0.44873     	43.53709    	31551.18164        	57               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 4, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	559.85797   	-18.62873   	829.83942   	17992338.00000     	0           
  10          	371.65796   	-13.42166   	597.05023   	11634662.00000     	0           
  100         	55.71731    	-0.04825    	85.96335    	2285680.50000      	2           
  300         	24.28769    	-5.81815    	49.25437    	2818039.25000      	5           
  500         	27.13980    	-6.11373    	49.71496    	2302842.50000      	9           
  1000        	22.96560    	-7.55428    	50.62633    	1593205.00000      	19          
---> try to load best state
              	22.96560    	-7.55428    	50.62633    	1593205.00000      	19               eval state : test_on_restore;
              	22.96560    	-7.55428    	50.62633    	1593205.00000      	19               eval state : test_on_last_epoch;
---> final result
              	22.96560    	-7.55428    	50.62633    	1593205.00000      	20               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 8, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	426.44321   	-7.50776    	673.80316   	11499766.00000     	0           
  10          	282.03793   	-5.40368    	483.91580   	7315522.50000      	0           
  100         	34.06249    	0.25191     	54.91835    	627907.56250       	2           
  300         	21.77499    	-7.99459    	43.47204    	796300.31250       	7           
  500         	19.94980    	-3.93282    	41.82641    	789151.37500       	11          
  1000        	18.42164    	-1.59242    	40.02591    	649923.68750       	21          
---> try to load best state
              	18.42164    	-1.59242    	40.02591    	649923.68750       	21               eval state : test_on_restore;
              	18.42164    	-1.59242    	40.02591    	649923.68750       	21               eval state : test_on_last_epoch;
---> final result
              	18.42164    	-1.59242    	40.02591    	649923.68750       	21               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 16, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	257.18555   	-1.81561    	451.21368   	4833095.50000      	0           
  10          	164.48109   	-0.95704    	313.26794   	2877900.00000      	0           
  100         	30.91216    	-0.06283    	56.80067    	524700.06250       	2           
  300         	19.41920    	-2.32440    	39.87912    	567007.00000       	7           
  500         	17.49871    	-0.01982    	38.79039    	571111.93750       	13          
  1000        	18.58808    	-4.88039    	39.34936    	577266.12500       	24          
---> try to load best state
              	18.58808    	-4.88039    	39.34936    	577266.12500       	24               eval state : test_on_restore;
              	18.58808    	-4.88039    	39.34936    	577266.12500       	24               eval state : test_on_last_epoch;
---> final result
              	18.58808    	-4.88039    	39.34936    	577266.12500       	24               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	170.22145   	-0.57098    	329.48550   	2393152.00000      	0           
  10          	113.56639   	-0.25058    	228.77254   	1417540.37500      	0           
  100         	24.79430    	-0.83304    	46.23026    	253463.93750       	5           
  300         	20.07532    	-1.46671    	41.38022    	388906.96875       	19          
  500         	18.73906    	-0.52405    	40.36643    	412648.43750       	33          
  1000        	18.45841    	-0.52641    	40.64296    	435444.68750       	70          
---> try to load best state
              	18.45841    	-0.52641    	40.64296    	435444.68750       	70               eval state : test_on_restore;
              	18.45841    	-0.52641    	40.64296    	435444.68750       	70               eval state : test_on_last_epoch;
---> final result
              	18.45841    	-0.52641    	40.64296    	435444.68750       	70               eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: 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        	gaussian_loss      	time        
  1           	129.60701   	0.08387     	242.31181   	1108466.75000      	0           
  10          	114.63148   	0.19497     	213.97398   	1073630.62500      	0           
  100         	40.42037    	0.40452     	76.60441    	345002.96875       	5           
  300         	22.49220    	0.44011     	48.46873    	93035.85156        	17          
  500         	19.55797    	0.47694     	44.23070    	59342.30469        	29          
  1000        	17.83884    	0.46554     	41.66516    	39370.92969        	62          
---> try to load best state
              	17.83884    	0.46554     	41.66516    	39370.92969        	62               eval state : test_on_restore;
              	17.83884    	0.46554     	41.66516    	39370.92969        	62               eval state : test_on_last_epoch;
---> final result              	17.83884    	0.46554     	41.66516    	39370.92969        	62               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	603.21521   	-67.19831   	858.70630   	19345618.00000     	0           
  10          	571.27863   	-55.14994   	822.56879   	19904924.00000     	0           
  100         	53.52217    	-0.86747    	85.72227    	1980899.50000      	2           
  300         	27.01267    	-2.09259    	61.79116    	6746625.50000      	5           
  500         	23.09816    	-5.69979    	48.68910    	5236152.00000      	9           
  1000        	22.47509    	-2.49891    	45.40810    	3461909.25000      	18          
---> try to load best state
              	22.47509    	-2.49891    	45.40810    	3461909.25000      	18               eval state : test_on_restore;
              	22.47509    	-2.49891    	45.40810    	3461909.25000      	18               eval state : test_on_last_epoch;
---> final result
              	22.47509    	-2.49891    	45.40810    	3461909.25000      	18               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	327.43198   	-4.10945    	517.43561   	6399411.00000      	0           
  10          	232.74445   	-2.74618    	390.18463   	4384009.00000      	0           
  100         	30.40261    	-0.86415    	58.43398    	711584.56250       	2           
  300         	21.78452    	-3.04441    	47.45216    	1871707.50000      	6           
  500         	21.54974    	-4.68735    	46.24223    	2417559.00000      	10          
  1000        	19.05778    	-0.25207    	44.59647    	2621768.25000      	19          
---> try to load best state
              	19.05778    	-0.25207    	44.59647    	2621768.25000      	20               eval state : test_on_restore;
              	19.05778    	-0.25207    	44.59647    	2621768.25000      	20               eval state : test_on_last_epoch;
---> final result
              	19.05778    	-0.25207    	44.59647    	2621768.25000      	20               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 16, '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	235.75784   	-1.13190    	419.60220   	3989166.00000      	0           
  10          	161.93097   	-0.61433    	310.94302   	2673551.75000      	0           
  100         	29.27310    	-0.85718    	50.97692    	392697.78125       	3           
  300         	20.80796    	-2.83453    	42.95323    	802543.43750       	8           
  500         	20.85719    	-3.83864    	42.60583    	1031818.87500      	14          
  1000        	19.54733    	-4.93854    	42.30161    	1176082.62500      	27          
---> try to load best state
              	19.54733    	-4.93854    	42.30161    	1176082.62500      	27               eval state : test_on_restore;
              	19.54733    	-4.93854    	42.30161    	1176082.62500      	28               eval state : test_on_last_epoch;
---> final result
              	19.54733    	-4.93854    	42.30161    	1176082.62500      	28               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
GAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', '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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	127.99687   	0.00626     	216.87083   	894775.31250       	0           
  10          	101.98413   	0.07941     	184.78505   	797724.75000       	0           
  100         	26.66494    	-0.88714    	49.90720    	285337.62500       	7           
  300         	20.25878    	-1.38534    	42.58396    	524640.68750       	20          
  500         	19.57731    	-0.70459    	42.63566    	677555.43750       	34          
  1000        	18.71307    	-0.89830    	42.14351    	790156.25000       	69          
---> try to load best state
              	18.71307    	-0.89830    	42.14351    	790156.25000       	69               eval state : test_on_restore;
              	18.71307    	-0.89830    	42.14351    	790156.25000       	69               eval state : test_on_last_epoch;
---> final result
              	18.71307    	-0.89830    	42.14351    	790156.25000       	69               eval state : final;module_name : GAR;cp_record_file : True;
