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

  Demo sGAR 
  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']
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	130.65968   	0.04878     	230.48550   	0           
  10          	115.67155   	0.16104     	207.17157   	0           
  100         	34.86905    	0.41580     	63.66299    	3           
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	0.05934     	-0.47044    	0.13908     	7.43657            	0           
  10          	0.05452     	-0.11993    	0.12545     	0.24769            	1           
  100         	0.02560     	0.55865     	0.04910     	14.70881           	7           
  300         	0.01266     	0.64301     	0.02177     	35.21103           	22          
  500         	0.01055     	0.65380     	0.01881     	46.62729           	36          
  1000        	0.00977     	0.66327     	0.01802     	67.60952           	74          
---> try to load best state
              	0.00977     	0.66327     	0.01802     	67.60952           	74               eval state : test_on_restore;
              	0.00977     	0.66327     	0.01802     	67.60952           	74               eval state : test_on_last_epoch;
---> final result              	0.00977     	0.66327     	0.01802     	67.60952           	74               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_02', '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: 10.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           	0.08171     	-64.90161   	0.14845     	-0.20508           	21          
  10          	0.06438     	-4.57776    	0.11397     	-9.20805           	62          
  100         	0.04021     	0.29992     	0.06467     	-53.04290          	302         
  300         	0.03266     	0.54024     	0.05309     	-72.22675          	817         
  500         	0.03280     	0.54736     	0.05427     	-76.85657          	1323        
  1000        	0.05266     	-3.15218    	0.08755     	-63.64771          	2575        
---> try to load best state
              	0.05266     	-3.15218    	0.08755     	-63.64771          	2594             eval state : test_on_restore;
              	0.05266     	-3.15218    	0.08755     	-63.64771          	2613             eval state : test_on_last_epoch;
---> final result
              	0.05266     	-3.15218    	0.08755     	-63.64771          	2632             eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_02', '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: 10.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           	0.07054     	-8.98100    	0.13071     	1.44436            	24          
  10          	0.05357     	-1.13309    	0.09662     	-6.95781           	83          
  100         	0.03025     	0.63755     	0.05228     	-41.58442          	484         
  300         	0.02576     	0.74118     	0.04502     	-55.48932          	1353        
  500         	0.02632     	0.73666     	0.04606     	-61.92773          	2225        
  1000        	0.04054     	-0.07438    	0.07181     	-57.05843          	4381        
---> try to load best state
              	0.04054     	-0.07438    	0.07181     	-57.05843          	4401             eval state : test_on_restore;
              	0.04054     	-0.07438    	0.07181     	-57.05843          	4422             eval state : test_on_last_epoch;
---> final result
              	0.04054     	-0.07438    	0.07181     	-57.05843          	4442             eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_02', '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: 10.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           	0.06012     	-3.27581    	0.11455     	3.76095            	34          
  10          	0.04563     	-0.40793    	0.08425     	-4.21171           	132         
  100         	0.02725     	0.70090     	0.04770     	-33.97770          	880         
  300         	0.02499     	0.76061     	0.04388     	-43.27121          	2527        
  500         	0.02526     	0.76060     	0.04446     	-46.34115          	4161        
  1000        	0.03164     	0.56064     	0.05738     	-40.21213          	8244        
---> try to load best state
              	0.03164     	0.56064     	0.05738     	-40.21213          	8268             eval state : test_on_restore;
              	0.03164     	0.56064     	0.05738     	-40.21213          	8292             eval state : test_on_last_epoch;
---> final result
              	0.03164     	0.56064     	0.05738     	-40.21213          	8316             eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	0.04723     	-0.57952    	0.09383     	6.26902            	57          
  10          	0.03625     	0.28450     	0.06815     	-1.26354           	935         
  100         	0.02205     	0.77716     	0.03980     	-30.11927          	3048        
  300         	0.02128     	0.80262     	0.03943     	-38.65006          	6911        
  500         	0.02146     	0.80426     	0.03971     	-40.94168          	10859       
  1000        	0.02476     	0.74754     	0.04593     	-36.41013          	20755       
---> try to load best state
              	0.02476     	0.74754     	0.04593     	-36.41013          	20786            eval state : test_on_restore;
              	0.02476     	0.74754     	0.04593     	-36.41013          	20818            eval state : test_on_last_epoch;
---> final result
              	0.02476     	0.74754     	0.04593     	-36.41013          	20849            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': 'NavierStock_mfGent_v1_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', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	0.05447     	-0.23507    	0.12842     	7.54935            	0           
  10          	0.04953     	0.04061     	0.11517     	0.27778            	1           
  100         	0.02406     	0.56532     	0.04563     	11.93346           	7           
  300         	0.01295     	0.63984     	0.02180     	30.90039           	21          
  500         	0.01109     	0.65366     	0.01931     	42.38539           	35          
  1000        	0.01032     	0.66328     	0.01851     	61.49260           	71          
---> try to load best state
              	0.01032     	0.66328     	0.01851     	61.49260           	71               eval state : test_on_restore;
              	0.01032     	0.66328     	0.01851     	61.49260           	71               eval state : test_on_last_epoch;
---> final result              	0.01032     	0.66328     	0.01851     	61.49260           	71               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_02', '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: 10.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           	0.08235     	-36.30819   	0.15020     	0.23541            	22          
  10          	0.06230     	-1.63716    	0.10695     	-8.66761           	70          
  100         	0.04116     	0.39237     	0.06809     	-49.54989          	340         
  300         	0.03056     	0.62312     	0.05146     	-77.80787          	858         
  500         	0.03064     	0.64166     	0.05105     	-87.53555          	1388        
  1000        	0.04197     	0.11895     	0.06774     	-83.73463          	2657        
---> try to load best state
              	0.04197     	0.11895     	0.06774     	-83.73463          	2676             eval state : test_on_restore;
              	0.04197     	0.11895     	0.06774     	-83.73463          	2695             eval state : test_on_last_epoch;
---> final result
              	0.04197     	0.11895     	0.06774     	-83.73463          	2714             eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_02', '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: 10.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           	0.06784     	-6.85088    	0.12708     	2.23038            	24          
  10          	0.05066     	-0.69066    	0.09042     	-5.98273           	84          
  100         	0.03233     	0.60276     	0.05507     	-41.02615          	498         
  300         	0.02762     	0.70960     	0.04745     	-55.70329          	1398        
  500         	0.02799     	0.70252     	0.04795     	-61.45797          	2302        
  1000        	0.04029     	0.07819     	0.07001     	-56.01588          	4526        
---> try to load best state
              	0.04029     	0.07819     	0.07001     	-56.01588          	4546             eval state : test_on_restore;
              	0.04029     	0.07819     	0.07001     	-56.01588          	4567             eval state : test_on_last_epoch;
---> final result
              	0.04029     	0.07819     	0.07001     	-56.01588          	4588             eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_02', '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: 10.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           	0.06128     	-3.31028    	0.11766     	3.14171            	32          
  10          	0.04579     	-0.25560    	0.08404     	-4.81413           	133         
  100         	0.02700     	0.70970     	0.04673     	-37.73146          	935         
  300         	0.02484     	0.75964     	0.04405     	-50.33763          	2693        
  500         	0.02538     	0.74673     	0.04489     	-54.63386          	4447        
  1000        	0.03301     	0.46821     	0.06045     	-50.11690          	8804        
---> try to load best state
              	0.03301     	0.46821     	0.06045     	-50.11690          	8828             eval state : test_on_restore;
              	0.03301     	0.46821     	0.06045     	-50.11690          	8852             eval state : test_on_last_epoch;
---> final result
              	0.03301     	0.46821     	0.06045     	-50.11690          	8877             eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'NavierStock_mfGent_v1_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', 'gaussian_loss']
  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        	gaussian_loss      	time        
  1           	0.04342     	-0.29277    	0.08643     	6.41795            	50          
  10          	0.03361     	0.39566     	0.06302     	-1.06345           	557         
  100         	0.02229     	0.79389     	0.04045     	-30.87112          	2709        
----------------------------------------

  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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	133.77396   	-0.01523    	235.42899   	990157.50000       	0           
  10          	120.63013   	0.08548     	213.41730   	1004861.25000      	0           
  100         	62.05712    	0.31426     	111.78993   	498777.40625       	4           
  300         	34.23037    	0.31649     	64.39600    	106038.71094       	11          
  500         	20.00904    	0.42429     	40.05706    	29151.11133        	18          
----------------------------------------

  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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	184.26822   	0.36679     	293.27094   	1544984.62500      	0           
  10          	170.63803   	0.44747     	269.47302   	1610437.87500      	0           
  100         	97.23465    	0.66330     	146.44269   	763109.18750       	1           
  300         	42.46935    	0.83577     	67.03500    	83631.51562        	4           
  500         	34.47248    	0.90357     	54.80967    	44708.18750        	6           
  1000        	32.78824    	0.96314     	53.04726    	31066.28516        	13          
---> try to load best state
              	32.78824    	0.96314     	53.04726    	31066.28516        	13               eval state : test_on_restore;
              	32.78824    	0.96314     	53.04726    	31066.28516        	13               eval state : test_on_last_epoch;
---> final result              	32.78824    	0.96314     	53.04726    	31066.28516        	13               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: 10.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           	548.77942   	-11.55576   	785.71606   	15889210.00000     	0           
  10          	477.11292   	-12.14555   	711.75177   	16875330.00000     	0           
  100         	118.87447   	-1.47885    	163.26082   	3218372.00000      	1           
  300         	39.03316    	-0.40809    	53.92673    	350267.81250       	3           
  500         	29.24842    	-0.35953    	48.21508    	258937.10938       	6           
----------------------------------------

  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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	184.26822   	0.36679     	293.27094   	1544984.62500      	3           
  10          	170.63803   	0.44747     	269.47302   	1610437.87500      	4           
  100         	97.23465    	0.66330     	146.44269   	763109.18750       	5           
  300         	42.46935    	0.83577     	67.03500    	83631.51562        	8           
  500         	34.47248    	0.90357     	54.80967    	44708.18750        	11          
  1000        	32.78824    	0.96314     	53.04726    	31066.28516        	18          
---> try to load best state
              	32.78824    	0.96314     	53.04726    	31066.28516        	18               eval state : test_on_restore;
              	32.78824    	0.96314     	53.04726    	31066.28516        	18               eval state : test_on_last_epoch;
---> final result              	32.78824    	0.96314     	53.04726    	31066.28516        	18               eval state : final;
----------> finish x-yl training


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

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

  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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	184.26822   	0.36679     	293.27094   	1544984.62500      	0           
  10          	170.63803   	0.44747     	269.47302   	1610437.87500      	0           
  100         	97.23465    	0.66330     	146.44269   	763109.18750       	1           
  300         	42.46935    	0.83577     	67.03500    	83631.51562        	4           
  500         	34.47248    	0.90357     	54.80967    	44708.18750        	7           
  1000        	32.78824    	0.96314     	53.04726    	31066.28516        	13          
---> try to load best state
              	32.78824    	0.96314     	53.04726    	31066.28516        	13               eval state : test_on_restore;
              	32.78824    	0.96314     	53.04726    	31066.28516        	14               eval state : test_on_last_epoch;
---> final result              	32.78824    	0.96314     	53.04726    	31066.28516        	14               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: 10.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           	548.77942   	-11.55576   	785.71606   	15889210.00000     	0           
  10          	477.11292   	-12.14555   	711.75177   	16875330.00000     	0           
  100         	118.87447   	-1.47885    	163.26082   	3218372.00000      	1           
  300         	39.03316    	-0.40809    	53.92673    	350267.81250       	3           
  500         	29.24842    	-0.35953    	48.21508    	258937.10938       	6           
  1000        	19.76462    	-0.66623    	39.28570    	187747.81250       	14          
---> try to load best state
              	19.76462    	-0.66623    	39.28570    	187747.81250       	14               eval state : test_on_restore;
              	19.76462    	-0.66623    	39.28570    	187747.81250       	14               eval state : test_on_last_epoch;
---> final result
              	19.76462    	-0.66623    	39.28570    	187747.81250       	14               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: 10.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           	403.36545   	-3.10609    	606.09631   	8927388.00000      	0           
  10          	330.41266   	-2.86797    	531.49347   	8760864.00000      	0           
  100         	76.76519    	-0.68668    	107.33534   	1050009.25000      	2           
  300         	31.80034    	0.11001     	47.10506    	199417.79688       	7           
  500         	24.13342    	0.08163     	42.14975    	160389.01562       	11          
  1000        	19.42430    	-0.27947    	39.07115    	156983.50000       	19          
---> try to load best state
              	19.42430    	-0.27947    	39.07115    	156983.50000       	19               eval state : test_on_restore;
              	19.42430    	-0.27947    	39.07115    	156983.50000       	19               eval state : test_on_last_epoch;
---> final result
              	19.42430    	-0.27947    	39.07115    	156983.50000       	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': 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: 10.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           	244.42348   	-0.93332    	393.75128   	3405512.00000      	0           
  10          	187.67461   	-0.72869    	330.01852   	3037732.00000      	0           
  100         	46.49884    	0.22886     	64.54758    	310897.09375       	2           
  300         	32.57218    	0.32089     	48.29981    	222907.23438       	5           
  500         	28.79753    	0.21712     	49.50095    	261434.10938       	9           
  1000        	19.49478    	0.30426     	37.71781    	152790.53125       	18          
---> try to load best state
              	19.49478    	0.30426     	37.71781    	152790.53125       	18               eval state : test_on_restore;
              	19.49478    	0.30426     	37.71781    	152790.53125       	18               eval state : test_on_last_epoch;
---> final result
              	19.49478    	0.30426     	37.71781    	152790.53125       	18               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: 10.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           	140.90773   	-0.01060    	231.53928   	977834.37500       	0           
  10          	111.75966   	0.04711     	198.31015   	883582.56250       	0           
  100         	38.21463    	0.27023     	55.48231    	158764.71875       	5           
  300         	29.33138    	0.38670     	44.38110    	109080.12500       	14          
  500         	25.33626    	0.39687     	40.88777    	87419.20312        	24          
  1000        	20.17740    	0.40561     	37.89898    	63657.14062        	47          
---> try to load best state
              	20.17740    	0.40561     	37.89898    	63657.14062        	47               eval state : test_on_restore;
              	20.17740    	0.40561     	37.89898    	63657.14062        	47               eval state : test_on_last_epoch;
---> final result
              	20.17740    	0.40561     	37.89898    	63657.14062        	47               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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	272.18134   	-0.27704    	458.86395   	4178131.25000      	0           
  10          	238.79530   	0.00260     	409.24075   	4039025.75000      	0           
  100         	110.80018   	0.64943     	181.57362   	877919.25000       	1           
  300         	53.32667    	0.85473     	82.91167    	101163.14062       	5           
  500         	45.55262    	0.90798     	69.04765    	58172.05078        	9           
  1000        	41.66306    	0.95801     	63.63194    	32266.32227        	18          
---> try to load best state
              	41.66306    	0.95801     	63.63194    	32266.32227        	18               eval state : test_on_restore;
              	41.66306    	0.95801     	63.63194    	32266.32227        	18               eval state : test_on_last_epoch;
---> final result              	41.66306    	0.95801     	63.63194    	32266.32227        	18               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: 10.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           	541.99487   	-8.09998    	710.29474   	12807143.00000     	0           
  10          	458.69455   	-7.99227    	624.04071   	12778256.00000     	0           
  100         	104.39633   	-0.51412    	143.97435   	2435788.50000      	1           
  300         	58.85736    	-0.20564    	78.30630    	541753.25000       	4           
  500         	38.95821    	-0.18499    	56.39374    	263739.00000       	6           
  1000        	27.01246    	-0.40259    	47.70559    	224349.23438       	13          
---> try to load best state
              	27.01246    	-0.40259    	47.70559    	224349.23438       	13               eval state : test_on_restore;
              	27.01246    	-0.40259    	47.70559    	224349.23438       	13               eval state : test_on_last_epoch;
---> final result
              	27.01246    	-0.40259    	47.70559    	224349.23438       	13               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: 10.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           	414.33255   	-3.36968    	606.54199   	8943725.00000      	0           
  10          	332.92917   	-3.07572    	512.16870   	8088686.50000      	0           
  100         	79.71562    	-0.21651    	106.57476   	927400.62500       	1           
  300         	39.41208    	0.32151     	55.95448    	254079.18750       	4           
  500         	31.95170    	-0.02275    	49.89731    	201178.15625       	7           
  1000        	25.46116    	0.16795     	47.22369    	202689.79688       	13          
---> try to load best state
              	25.46116    	0.16795     	47.22369    	202689.79688       	13               eval state : test_on_restore;
              	25.46116    	0.16795     	47.22369    	202689.79688       	13               eval state : test_on_last_epoch;
---> final result
              	25.46116    	0.16795     	47.22369    	202689.79688       	13               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: 10.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           	246.03540   	-0.55573    	440.55502   	4259692.00000      	0           
  10          	199.24205   	-0.33867    	374.97800   	3800319.25000      	0           
  100         	58.28038    	0.28602     	80.85084    	432382.81250       	2           
  300         	33.44180    	0.39980     	50.95520    	233572.65625       	5           
  500         	27.79624    	0.40881     	47.40747    	202588.54688       	9           
  1000        	23.42879    	0.36696     	45.25207    	199331.64062       	17          
---> try to load best state
              	23.42879    	0.36696     	45.25207    	199331.64062       	17               eval state : test_on_restore;
              	23.42879    	0.36696     	45.25207    	199331.64062       	17               eval state : test_on_last_epoch;
---> final result
              	23.42879    	0.36696     	45.25207    	199331.64062       	17               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: 10.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           	210.24423   	-0.54808    	383.30463   	3003141.00000      	0           
  10          	162.77663   	-0.30683    	315.63034   	2465110.00000      	0           
  100         	48.93668    	0.20230     	72.08291    	189207.93750       	4           
  300         	33.85003    	0.35842     	51.40760    	106699.09375       	14          
  500         	30.31284    	0.35798     	49.30529    	97578.81250        	23          
  1000        	24.69689    	0.38121     	45.89455    	69806.41406        	46          
---> try to load best state
              	24.69689    	0.38121     	45.89455    	69806.41406        	46               eval state : test_on_restore;
              	24.69689    	0.38121     	45.89455    	69806.41406        	46               eval state : test_on_last_epoch;
---> final result
              	24.69689    	0.38121     	45.89455    	69806.41406        	46               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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	234.48203   	0.05774     	378.08466   	2783830.75000      	0           
  10          	207.09108   	0.22552     	337.44717   	2699438.75000      	0           
  100         	105.29540   	0.64008     	157.44527   	728417.00000       	1           
  300         	55.20790    	0.80724     	89.36744    	124668.35156       	5           
  500         	44.94825    	0.86816     	75.60316    	72359.25000        	8           
  1000        	35.64857    	0.95573     	62.07862    	35566.26172        	14          
---> try to load best state
              	35.64857    	0.95573     	62.07862    	35566.26172        	14               eval state : test_on_restore;
              	35.64857    	0.95573     	62.07862    	35566.26172        	14               eval state : test_on_last_epoch;
---> final result              	35.64857    	0.95573     	62.07862    	35566.26172        	14               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: 10.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           	514.64728   	-6.90989    	768.34253   	15237608.00000     	0           
  10          	452.13181   	-6.86545    	712.88873   	16973748.00000     	0           
  100         	117.87036   	-0.82249    	168.70488   	3484437.25000      	1           
  300         	51.68143    	-0.35155    	71.90421    	706023.81250       	3           
  500         	35.18765    	-0.07488    	56.58928    	401498.40625       	6           
  1000        	22.75452    	-0.32555    	47.52854    	281302.87500       	11          
---> try to load best state
              	22.75452    	-0.32555    	47.52854    	281302.87500       	11               eval state : test_on_restore;
              	22.75452    	-0.32555    	47.52854    	281302.87500       	11               eval state : test_on_last_epoch;
---> final result
              	22.75452    	-0.32555    	47.52854    	281302.87500       	11               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: 10.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           	481.13254   	-5.95450    	759.68213   	14860549.00000     	0           
  10          	423.94266   	-5.74935    	712.59729   	16960564.00000     	0           
  100         	112.07023   	-0.45109    	171.52754   	3188979.50000      	1           
  300         	41.43666    	-0.03658    	63.24990    	242058.18750       	4           
  500         	31.43524    	-0.05999    	52.99952    	158631.65625       	6           
  1000        	22.88023    	-0.15134    	47.00481    	139213.92188       	12          
---> try to load best state
              	22.88023    	-0.15134    	47.00481    	139213.92188       	12               eval state : test_on_restore;
              	22.88023    	-0.15134    	47.00481    	139213.92188       	12               eval state : test_on_last_epoch;
---> final result
              	22.88023    	-0.15134    	47.00481    	139213.92188       	12               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: 10.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           	278.95490   	-1.19313    	457.45526   	4643102.00000      	0           
  10          	219.59065   	-0.86818    	387.80292   	4153786.75000      	0           
  100         	51.35382    	0.19069     	74.44392    	314114.56250       	1           
  300         	31.23985    	0.31944     	50.72482    	106384.89062       	5           
  500         	26.64920    	0.29714     	48.62358    	90995.64844        	8           
  1000        	20.75541    	0.29000     	44.07631    	61896.74219        	17          
---> try to load best state
              	20.75541    	0.29000     	44.07631    	61896.74219        	17               eval state : test_on_restore;
              	20.75541    	0.29000     	44.07631    	61896.74219        	17               eval state : test_on_last_epoch;
---> final result
              	20.75541    	0.29000     	44.07631    	61896.74219        	17               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: 10.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           	172.25998   	-0.29289    	310.00430   	1937392.37500      	0           
  10          	134.38622   	-0.16510    	261.92279   	1674418.50000      	0           
  100         	42.73638    	0.26102     	65.44434    	169366.26562       	4           
  300         	33.17421    	0.29390     	54.05627    	121703.35938       	13          
  500         	28.88803    	0.34186     	51.12944    	104736.80469       	22          
  1000        	22.15666    	0.37415     	45.56868    	70476.22656        	55          
---> try to load best state
              	22.15666    	0.37415     	45.56868    	70476.22656        	55               eval state : test_on_restore;
              	22.15666    	0.37415     	45.56868    	70476.22656        	55               eval state : test_on_last_epoch;
---> final result
              	22.15666    	0.37415     	45.56868    	70476.22656        	55               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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	273.06641   	-0.11620    	449.25330   	4208471.00000      	0           
  10          	240.62410   	0.09319     	403.08063   	4165151.50000      	0           
  100         	112.34500   	0.63278     	185.23624   	694430.75000       	3           
  300         	59.94619    	0.84253     	100.51679   	94823.61719        	8           
  500         	47.63363    	0.91013     	80.58192    	53477.58594        	13          
  1000        	35.15072    	0.96432     	60.50955    	27436.09375        	27          
---> try to load best state
              	35.15072    	0.96432     	60.50955    	27436.09375        	27               eval state : test_on_restore;
              	35.15072    	0.96432     	60.50955    	27436.09375        	27               eval state : test_on_last_epoch;
---> final result              	35.15072    	0.96432     	60.50955    	27436.09375        	27               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: 10.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           	662.18658   	-41.76610   	871.04773   	19894086.00000     	0           
  10          	616.41467   	-49.85105   	836.61560   	23878472.00000     	0           
  100         	280.40012   	-4.09101    	373.70596   	22347828.00000     	2           
  300         	142.89308   	-1.11468    	194.68600   	5138828.00000      	5           
  500         	100.25891   	-0.75962    	136.57477   	940310.12500       	9           
  1000        	49.78796    	-0.42804    	71.05553    	137151.85938       	19          
---> try to load best state
              	49.78796    	-0.42804    	71.05553    	137151.85938       	19               eval state : test_on_restore;
              	49.78796    	-0.42804    	71.05553    	137151.85938       	19               eval state : test_on_last_epoch;
---> final result
              	49.78796    	-0.42804    	71.05553    	137151.85938       	19               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: 10.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           	484.51669   	-5.21050    	773.05841   	15353827.00000     	0           
  10          	434.67599   	-5.49865    	737.10822   	17994348.00000     	0           
  100         	113.58905   	-0.23438    	167.14461   	2446891.50000      	2           
  300         	38.71400    	-0.10913    	55.76928    	163018.90625       	8           
  500         	28.83700    	-0.11521    	46.49445    	112347.84375       	14          
  1000        	21.51941    	-0.19375    	42.32513    	96274.48438        	27          
---> try to load best state
              	21.51941    	-0.19375    	42.32513    	96274.48438        	27               eval state : test_on_restore;
              	21.51941    	-0.19375    	42.32513    	96274.48438        	27               eval state : test_on_last_epoch;
---> final result
              	21.51941    	-0.19375    	42.32513    	96274.48438        	27               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: 10.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           	358.73303   	-1.56601    	586.96948   	8313671.00000      	0           
  10          	304.18414   	-1.51311    	534.65015   	8723519.00000      	0           
  100         	70.33163    	0.03158     	107.38168   	603959.50000       	3           
  300         	38.03748    	0.08547     	58.61694    	136049.75000       	8           
  500         	36.02956    	-0.05351    	60.21325    	156056.84375       	12          
  1000        	22.06734    	0.10018     	45.01826    	71901.17969        	23          
---> try to load best state
              	22.06734    	0.10018     	45.01826    	71901.17969        	23               eval state : test_on_restore;
              	22.06734    	0.10018     	45.01826    	71901.17969        	23               eval state : test_on_last_epoch;
---> final result
              	22.06734    	0.10018     	45.01826    	71901.17969        	23               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: 10.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           	219.75806   	-0.52959    	381.54181   	3087832.50000      	0           
  10          	176.12383   	-0.41094    	327.00159   	2768519.25000      	0           
  100         	45.44003    	0.03721     	70.56958    	154171.18750       	5           
  300         	31.90862    	0.25346     	49.37764    	68053.84375        	17          
  500         	28.66733    	0.27067     	46.58815    	58104.28125        	29          
  1000        	21.96917    	0.30501     	41.29992    	1717.90576         	51          
---> try to load best state
              	21.96917    	0.30501     	41.29992    	1717.90576         	51               eval state : test_on_restore;
              	21.96917    	0.30501     	41.29992    	1717.90576         	51               eval state : test_on_last_epoch;
---> final result
              	21.96917    	0.30501     	41.29992    	1717.90576         	51               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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	244.14207   	-0.13617    	423.95627   	3763286.00000      	0           
  10          	216.40515   	0.11001     	372.69632   	3579005.75000      	0           
  100         	105.62657   	0.63986     	168.75980   	833944.50000       	1           
  300         	52.64067    	0.82866     	89.34747    	112850.39062       	3           
  500         	43.10707    	0.89790     	74.51257    	65317.92188        	6           
  1000        	37.85553    	0.95883     	65.63815    	41936.64453        	12          
---> try to load best state
              	37.85553    	0.95883     	65.63815    	41936.64453        	12               eval state : test_on_restore;
              	37.85553    	0.95883     	65.63815    	41936.64453        	12               eval state : test_on_last_epoch;
---> final result              	37.85553    	0.95883     	65.63815    	41936.64453        	12               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: 10.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           	581.39978   	-15.57696   	854.48663   	19057816.00000     	0           
  10          	528.31543   	-21.04035   	806.14026   	22133036.00000     	0           
  100         	184.55653   	-1.17087    	262.25012   	11484339.00000     	1           
  300         	82.13284    	-0.15726    	116.44351   	980206.31250       	4           
  500         	56.56932    	-0.09471    	80.41751    	238600.98438       	6           
  1000        	33.87720    	-0.03009    	57.14897    	148003.57812       	12          
---> try to load best state
              	33.87720    	-0.03009    	57.14897    	148003.57812       	12               eval state : test_on_restore;
              	33.87720    	-0.03009    	57.14897    	148003.57812       	12               eval state : test_on_last_epoch;
---> final result
              	33.87720    	-0.03009    	57.14897    	148003.57812       	12               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: 10.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           	448.99319   	-6.42429    	700.09656   	12359993.00000     	0           
  10          	361.12601   	-6.30123    	598.99579   	11638016.00000     	0           
  100         	62.36552    	0.11322     	86.86452    	505785.90625       	1           
  300         	43.49425    	0.11642     	63.63007    	202686.90625       	4           
  500         	33.29069    	0.17730     	62.25770    	195495.89062       	7           
  1000        	22.33442    	0.18447     	46.30982    	97254.40625        	19          
---> try to load best state
              	22.33442    	0.18447     	46.30982    	97254.40625        	19               eval state : test_on_restore;
              	22.33442    	0.18447     	46.30982    	97254.40625        	19               eval state : test_on_last_epoch;
---> final result
              	22.33442    	0.18447     	46.30982    	97254.40625        	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': 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: 10.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           	273.61475   	-1.47645    	473.76447   	5261540.00000      	0           
  10          	213.49748   	-1.03893    	392.73508   	4571012.00000      	0           
  100         	54.39574    	0.12615     	79.23849    	397030.50000       	4           
  300         	30.40049    	0.36985     	48.20487    	111295.14062       	12          
  500         	26.63505    	0.29965     	47.27260    	88917.51562        	22          
  1000        	20.75239    	0.32658     	42.58350    	63065.47266        	56          
---> try to load best state
              	20.75239    	0.32658     	42.58350    	63065.47266        	56               eval state : test_on_restore;
              	20.75239    	0.32658     	42.58350    	63065.47266        	56               eval state : test_on_last_epoch;
---> final result
              	20.75239    	0.32658     	42.58350    	63065.47266        	56               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: 10.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           	184.19655   	-0.44393    	349.88541   	2641303.25000      	0           
  10          	144.34566   	-0.22148    	284.15277   	2136985.25000      	1           
  100         	44.13356    	0.03343     	68.78471    	212518.79688       	12          
  300         	31.57843    	0.35455     	49.60416    	107535.60156       	30          
  500         	28.17445    	0.31251     	46.53855    	87659.85156        	47          
  1000        	22.07296    	0.39716     	43.72688    	25932.50000        	89          
---> try to load best state
              	22.07296    	0.39716     	43.72688    	25932.50000        	90               eval state : test_on_restore;
              	22.07296    	0.39716     	43.72688    	25932.50000        	90               eval state : test_on_last_epoch;
---> final result
              	22.07296    	0.39716     	43.72688    	25932.50000        	90               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: 10.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	188.30673   	0.43466     	303.41061   	1674663.00000      	0           
  10          	172.93314   	0.52252     	274.97235   	1668529.75000      	0           
  100         	101.77193   	0.69912     	150.59830   	770554.87500       	3           
  300         	52.33941    	0.85304     	83.56390    	127855.31250       	8           
  500         	43.14471    	0.92537     	71.44495    	77519.87500        	14          
  1000        	37.70860    	0.96966     	64.01730    	49376.82422        	29          
---> try to load best state
              	37.70860    	0.96966     	64.01730    	49376.82422        	29               eval state : test_on_restore;
              	37.70860    	0.96966     	64.01730    	49376.82422        	29               eval state : test_on_last_epoch;
---> final result              	37.70860    	0.96966     	64.01730    	49376.82422        	29               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: 10.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           	620.77917   	-36.52938   	882.22412   	20417422.00000     	0           
  10          	598.84302   	-71.13344   	872.10004   	25978126.00000     	0           
  100         	316.78839   	-4.58532    	440.05167   	31517530.00000     	2           
  300         	154.79668   	-1.67242    	231.39789   	8144292.00000      	6           
  500         	103.05737   	-1.24865    	156.86151   	1775073.87500      	10          
  1000        	52.13189    	-0.91908    	88.92152    	385258.87500       	20          
---> try to load best state
              	52.13189    	-0.91908    	88.92152    	385258.87500       	20               eval state : test_on_restore;
              	52.13189    	-0.91908    	88.92152    	385258.87500       	20               eval state : test_on_last_epoch;
---> final result
              	52.13189    	-0.91908    	88.92152    	385258.87500       	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': 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: 10.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           	344.25748   	-3.33337    	541.09344   	6937398.50000      	0           
  10          	272.62582   	-2.62417    	458.18518   	6282374.00000      	0           
  100         	69.22988    	-0.22476    	98.70580    	866237.62500       	2           
  300         	32.13061    	0.24416     	55.90530    	330756.31250       	7           
  500         	27.73786    	0.15695     	53.03664    	303520.03125       	12          
  1000        	22.55972    	0.02704     	50.36101    	312325.84375       	25          
---> try to load best state
              	22.55972    	0.02704     	50.36101    	312325.84375       	25               eval state : test_on_restore;
              	22.55972    	0.02704     	50.36101    	312325.84375       	25               eval state : test_on_last_epoch;
---> final result
              	22.55972    	0.02704     	50.36101    	312325.84375       	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': 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: 10.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           	248.70580   	-0.96235    	437.93823   	4276612.50000      	0           
  10          	198.78525   	-0.61783    	378.45093   	3945605.50000      	0           
  100         	57.15650    	0.37888     	79.88659    	403160.03125       	3           
  300         	32.13434    	0.41341     	51.81239    	187651.20312       	10          
  500         	26.08697    	0.41211     	47.48255    	146769.17188       	17          
  1000        	22.56863    	0.36256     	46.60326    	129662.82031       	33          
---> try to load best state
              	22.56863    	0.36256     	46.60326    	129662.82031       	34               eval state : test_on_restore;
              	22.56863    	0.36256     	46.60326    	129662.82031       	34               eval state : test_on_last_epoch;
---> final result
              	22.56863    	0.36256     	46.60326    	129662.82031       	34               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: 10.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           	141.04239   	0.05198     	242.06694   	1092447.37500      	0           
  10          	113.34230   	0.08288     	209.80791   	990058.50000       	0           
  100         	42.54659    	-0.19090    	69.69769    	224098.40625       	8           
  300         	32.93212    	0.40495     	53.27051    	164868.75000       	23          
  500         	28.91181    	0.41851     	50.77031    	146099.25000       	38          
  1000        	22.87372    	0.42822     	46.22665    	95982.72656        	77          
---> try to load best state
              	22.87372    	0.42822     	46.22665    	95982.72656        	77               eval state : test_on_restore;
              	22.87372    	0.42822     	46.22665    	95982.72656        	78               eval state : test_on_last_epoch;
---> final result
              	22.87372    	0.42822     	46.22665    	95982.72656        	78               eval state : final;module_name : GAR;cp_record_file : True;
