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

  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: 1e-05
  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           	653.56390   	-174134312.03321	889.81885   	683.32727          	0           
  10          	475.06345   	-23.72682   	664.88141   	718627.00000       	0           
  100         	134.68498   	-0.67822    	244.17796   	38443.25781        	5           
  300         	107.80392   	-0.01937    	198.63234   	22261.47266        	16          
----------------------------------------

  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       	5           
  300         	34.23037    	0.31649     	64.39600    	106038.71094       	16          
  500         	20.00904    	0.42429     	40.05706    	29151.11133        	26          
  1000        	16.32413    	0.46598     	34.83477    	15342.11816        	53          
---> try to load best state
              	16.32413    	0.46598     	34.83477    	15342.11816        	53               eval state : test_on_restore;
              	16.32413    	0.46598     	34.83477    	15342.11816        	53               eval state : test_on_last_epoch;
---> final result              	16.32413    	0.46598     	34.83477    	15342.11816        	53               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           	534.07550   	-16.36510   	761.33588   	14915283.00000     	0           
  10          	186.79376   	-7.99052    	277.99451   	2555323.50000      	0           
  100         	17.94498    	0.08398     	37.30665    	206024.45312       	2           
  300         	19.91048    	-2.22032    	38.80178    	288092.03125       	5           
  500         	17.78119    	-0.44647    	36.96564    	291960.87500       	9           
  1000        	17.62114    	-0.33836    	36.76534    	379662.65625       	19          
---> try to load best state
              	17.62114    	-0.33836    	36.76534    	379662.65625       	19               eval state : test_on_restore;
              	17.62114    	-0.33836    	36.76534    	379662.65625       	19               eval state : test_on_last_epoch;
---> final result
              	17.62114    	-0.33836    	36.76534    	379662.65625       	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': 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           	390.68723   	-4.25068    	583.14661   	8261465.00000      	0           
  10          	156.56580   	-2.79614    	242.63805   	1796678.25000      	0           
  100         	21.28971    	-5.89161    	43.04458    	199711.64062       	4           
  300         	19.16343    	-3.59640    	38.18243    	177283.12500       	8           
  500         	28.02090    	-4.62904    	44.98385    	292333.25000       	13          
  1000        	21.56975    	-10.30059   	37.80333    	246208.71875       	23          
---> try to load best state
              	21.56975    	-10.30059   	37.80333    	246208.71875       	23               eval state : test_on_restore;
              	21.56975    	-10.30059   	37.80333    	246208.71875       	23               eval state : test_on_last_epoch;
---> final result
              	21.56975    	-10.30059   	37.80333    	246208.71875       	23               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           	235.89537   	-1.31856    	378.06500   	3148387.00000      	0           
  10          	107.37633   	-1.25136    	177.27744   	850669.93750       	0           
  100         	18.49774    	-0.76303    	36.18043    	104997.64062       	3           
  300         	21.31674    	-4.34073    	37.71203    	161317.73438       	9           
  500         	18.07271    	-0.76306    	35.32113    	160023.25000       	15          
  1000        	18.15130    	-3.04675    	35.70512    	209129.50000       	32          
---> try to load best state
              	18.15130    	-3.04675    	35.70512    	209129.50000       	32               eval state : test_on_restore;
              	18.15130    	-3.04675    	35.70512    	209129.50000       	32               eval state : test_on_last_epoch;
---> final result
              	18.15130    	-3.04675    	35.70512    	209129.50000       	32               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           	136.91925   	-0.22048    	220.62192   	881185.25000       	0           
  10          	85.45275    	-0.31273    	143.56145   	457522.53125       	0           
  100         	18.83447    	-1.37590    	36.06586    	76933.47656        	7           
  300         	19.55956    	-2.68612    	37.09497    	99193.26562        	22          
  500         	17.43929    	-1.72397    	35.34281    	92750.06250        	36          
  1000        	16.64853    	-0.26673    	34.51980    	99692.41406        	65          
---> try to load best state
              	16.64853    	-0.26673    	34.51980    	99692.41406        	65               eval state : test_on_restore;
              	16.64853    	-0.26673    	34.51980    	99692.41406        	65               eval state : test_on_last_epoch;
---> final result
              	16.64853    	-0.26673    	34.51980    	99692.41406        	65               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           	201.50603   	-0.65754    	383.25662   	2931965.75000      	0           
  10          	173.96982   	-0.39129    	339.11237   	2788105.00000      	0           
  100         	71.34476    	0.25304     	140.80367   	562808.00000       	4           
  300         	38.14405    	0.33211     	72.80405    	99176.51562        	12          
  500         	25.40151    	0.41114     	49.66529    	35187.07031        	20          
  1000        	21.73683    	0.41765     	44.62524    	21271.13672        	39          
---> try to load best state
              	21.73683    	0.41765     	44.62524    	21271.13672        	39               eval state : test_on_restore;
              	21.73683    	0.41765     	44.62524    	21271.13672        	39               eval state : test_on_last_epoch;
---> final result              	21.73683    	0.41765     	44.62524    	21271.13672        	39               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           	468.85831   	-14.74135   	627.81818   	9991825.00000      	0           
  10          	237.80685   	-6.36967    	330.56348   	3549892.50000      	0           
  100         	24.81565    	-0.92276    	45.90995    	296812.90625       	1           
  300         	24.52570    	-2.65013    	45.52800    	331395.56250       	4           
  500         	25.29381    	-5.70393    	46.19594    	338536.87500       	6           
  1000        	23.95549    	-3.57407    	45.92412    	408956.78125       	13          
---> try to load best state
              	23.95549    	-3.57407    	45.92412    	408956.78125       	13               eval state : test_on_restore;
              	23.95549    	-3.57407    	45.92412    	408956.78125       	13               eval state : test_on_last_epoch;
---> final result
              	23.95549    	-3.57407    	45.92412    	408956.78125       	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           	397.36240   	-5.12997    	579.61938   	8154159.50000      	0           
  10          	199.58670   	-2.90546    	306.44559   	2865334.50000      	0           
  100         	26.19452    	-2.46688    	47.31544    	217193.31250       	2           
  300         	27.24864    	-2.80033    	47.80998    	255803.90625       	7           
  500         	23.95244    	-2.27860    	45.95681    	254379.75000       	10          
  1000        	22.13112    	0.34157     	45.28432    	299199.71875       	18          
---> try to load best state
              	22.13112    	0.34157     	45.28432    	299199.71875       	18               eval state : test_on_restore;
              	22.13112    	0.34157     	45.28432    	299199.71875       	18               eval state : test_on_last_epoch;
---> final result
              	22.13112    	0.34157     	45.28432    	299199.71875       	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': 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           	232.26840   	-1.04831    	418.99936   	3843673.75000      	0           
  10          	138.51360   	-0.56861    	253.56441   	1722836.00000      	0           
  100         	24.45562    	-0.98087    	46.59597    	160701.84375       	2           
  300         	24.12503    	-1.68316    	45.39991    	210231.98438       	7           
  500         	25.85866    	-6.40798    	47.71931    	286555.12500       	12          
  1000        	22.35954    	-0.29754    	44.28488    	305550.34375       	24          
---> try to load best state
              	22.35954    	-0.29754    	44.28488    	305550.34375       	24               eval state : test_on_restore;
              	22.35954    	-0.29754    	44.28488    	305550.34375       	24               eval state : test_on_last_epoch;
---> final result
              	22.35954    	-0.29754    	44.28488    	305550.34375       	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': 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           	203.14059   	-0.91341    	370.10355   	2796616.00000      	0           
  10          	128.39661   	-0.57905    	244.73495   	1470596.12500      	0           
  100         	24.81063    	-1.25620    	45.57817    	97663.39062        	5           
  300         	24.45619    	-1.87426    	45.94093    	108757.55469       	16          
  500         	23.15560    	-0.72189    	45.29409    	112453.01562       	26          
  1000        	22.83408    	-1.04431    	45.04097    	130024.47656       	64          
---> try to load best state
              	22.83408    	-1.04431    	45.04097    	130024.47656       	64               eval state : test_on_restore;
              	22.83408    	-1.04431    	45.04097    	130024.47656       	64               eval state : test_on_last_epoch;
---> final result
              	22.83408    	-1.04431    	45.04097    	130024.47656       	64               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           	165.94788   	-0.38171    	314.00500   	1941125.12500      	0           
  10          	144.68875   	-0.19263    	278.36719   	1853731.62500      	0           
  100         	67.03021    	0.26464     	120.78635   	466876.68750       	7           
  300         	38.52908    	0.32604     	72.78844    	104817.53906       	21          
  500         	27.12289    	0.39173     	57.54517    	48450.50391        	33          
  1000        	21.12290    	0.40219     	48.76931    	32067.66016        	57          
---> try to load best state
              	21.12290    	0.40219     	48.76931    	32067.66016        	57               eval state : test_on_restore;
              	21.12290    	0.40219     	48.76931    	32067.66016        	57               eval state : test_on_last_epoch;
---> final result              	21.12290    	0.40219     	48.76931    	32067.66016        	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': 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           	498.74799   	-8.90790    	742.91260   	14243904.00000     	0           
  10          	162.25804   	-4.08433    	249.74927   	2053314.50000      	0           
  100         	23.18631    	0.18489     	51.69025    	422975.50000       	2           
  300         	22.48097    	-0.06464    	50.56602    	438450.46875       	6           
  500         	23.14405    	-0.27443    	51.68331    	531542.00000       	10          
  1000        	41.95110    	-15.96053   	65.75702    	1328077.25000      	19          
---> try to load best state
              	41.95110    	-15.96053   	65.75702    	1328077.25000      	20               eval state : test_on_restore;
              	41.95110    	-15.96053   	65.75702    	1328077.25000      	20               eval state : test_on_last_epoch;
---> final result
              	41.95110    	-15.96053   	65.75702    	1328077.25000      	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': 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           	465.21451   	-7.41699    	734.00641   	13866844.00000     	0           
  10          	180.53960   	-3.01011    	288.47562   	2742264.25000      	0           
  100         	25.64025    	-0.01464    	54.08131    	449685.25000       	2           
  300         	23.30527    	-0.31859    	49.93275    	229391.43750       	8           
  500         	23.71993    	-1.29430    	50.82408    	222553.81250       	12          
  1000        	21.05736    	0.39300     	49.17801    	233066.87500       	23          
---> try to load best state
              	21.05736    	0.39300     	49.17801    	233066.87500       	23               eval state : test_on_restore;
              	21.05736    	0.39300     	49.17801    	233066.87500       	23               eval state : test_on_last_epoch;
---> final result
              	21.05736    	0.39300     	49.17801    	233066.87500       	23               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           	269.23007   	-1.56289    	437.07004   	4230929.00000      	0           
  10          	138.86540   	-1.12815    	233.38736   	1481838.12500      	0           
  100         	22.10943    	-0.28823    	47.51344    	152551.32812       	3           
  300         	24.24504    	-1.82631    	49.47542    	137285.25000       	8           
  500         	23.30217    	-1.98546    	49.01569    	129841.02344       	12          
  1000        	26.34169    	-7.51888    	49.66175    	144912.62500       	22          
---> try to load best state
              	26.34169    	-7.51888    	49.66175    	144912.62500       	22               eval state : test_on_restore;
              	26.34169    	-7.51888    	49.66175    	144912.62500       	22               eval state : test_on_last_epoch;
---> final result
              	26.34169    	-7.51888    	49.66175    	144912.62500       	22               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           	166.88652   	-0.63316    	296.13184   	1766904.25000      	0           
  10          	105.29164   	-0.46287    	193.54645   	901818.25000       	0           
  100         	24.43453    	-1.15796    	50.83343    	125451.24219       	5           
  300         	23.60910    	-1.44678    	49.70987    	117773.35938       	16          
  500         	22.96550    	-1.09563    	48.71146    	113576.43750       	29          
  1000        	22.46331    	-1.27239    	48.18475    	122965.47656       	61          
---> try to load best state
              	22.46331    	-1.27239    	48.18475    	122965.47656       	61               eval state : test_on_restore;
              	22.46331    	-1.27239    	48.18475    	122965.47656       	61               eval state : test_on_last_epoch;
---> final result
              	22.46331    	-1.27239    	48.18475    	122965.47656       	61               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           	209.39142   	-0.63970    	382.03119   	3023222.50000      	0           
  10          	182.27165   	-0.41043    	341.09055   	2959576.75000      	0           
  100         	72.48859    	0.17330     	144.44620   	452172.25000       	5           
  300         	41.02586    	0.28379     	83.26399    	81558.16406        	16          
  500         	28.34748    	0.36051     	62.51815    	35763.48047        	28          
  1000        	20.22946    	0.28869     	46.71121    	18155.05859        	58          
---> try to load best state
              	20.22946    	0.28869     	46.71121    	18155.05859        	58               eval state : test_on_restore;
              	20.22946    	0.28869     	46.71121    	18155.05859        	58               eval state : test_on_last_epoch;
---> final result              	20.22946    	0.28869     	46.71121    	18155.05859        	58               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           	650.59778   	-74.36439   	846.07678   	18769140.00000     	0           
  10          	233.08650   	-24.32546   	315.84003   	3387480.00000      	0           
  100         	32.92790    	0.04551     	57.01223    	702808.75000       	2           
  300         	24.55558    	-2.99772    	48.26554    	987076.62500       	6           
  500         	22.31059    	-1.60714    	47.16450    	334549.21875       	10          
  1000        	22.64927    	-6.45539    	47.05059    	150981.03125       	19          
---> try to load best state
              	22.64927    	-6.45539    	47.05059    	150981.03125       	19               eval state : test_on_restore;
              	22.64927    	-6.45539    	47.05059    	150981.03125       	20               eval state : test_on_last_epoch;
---> final result
              	22.64927    	-6.45539    	47.05059    	150981.03125       	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': 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           	465.59271   	-6.39334    	747.40558   	14345925.00000     	0           
  10          	224.06778   	-2.56231    	358.12027   	4216371.00000      	0           
  100         	22.81338    	-1.19218    	49.34869    	296693.53125       	2           
  300         	23.26312    	-2.28402    	47.68353    	183385.89062       	6           
  500         	20.82949    	-1.18468    	45.24276    	167475.35938       	9           
  1000        	19.59865    	0.06156     	45.01577    	200453.84375       	17          
---> try to load best state
              	19.59865    	0.06156     	45.01577    	200453.84375       	17               eval state : test_on_restore;
              	19.59865    	0.06156     	45.01577    	200453.84375       	17               eval state : test_on_last_epoch;
---> final result
              	19.59865    	0.06156     	45.01577    	200453.84375       	17               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           	343.72650   	-1.96776    	559.69238   	7537846.00000      	0           
  10          	166.48569   	-1.10687    	269.79141   	2184867.50000      	0           
  100         	21.85632    	-0.42470    	49.95380    	176625.09375       	1           
  300         	22.65768    	-3.23329    	49.84733    	129539.80469       	5           
  500         	25.42229    	-8.41183    	51.70214    	154977.50000       	9           
  1000        	49.07821    	-9.76518    	75.57523    	494255.37500       	26          
---> try to load best state
              	49.07821    	-9.76518    	75.57523    	494255.37500       	26               eval state : test_on_restore;
              	49.07821    	-9.76518    	75.57523    	494255.37500       	26               eval state : test_on_last_epoch;
---> final result
              	49.07821    	-9.76518    	75.57523    	494255.37500       	26               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           	212.77737   	-0.73032    	367.00000   	2860044.25000      	0           
  10          	128.43512   	-0.39122    	232.24780   	1389435.75000      	1           
  100         	23.30829    	-2.51472    	45.87383    	88212.95312        	9           
  300         	22.46755    	-2.62165    	44.77785    	73129.34375        	26          
  500         	19.93172    	-0.39553    	42.29873    	60501.83594        	46          
  1000        	18.70496    	-0.02790    	41.26968    	61822.98828        	81          
---> try to load best state
              	18.70496    	-0.02790    	41.26968    	61822.98828        	81               eval state : test_on_restore;
              	18.70496    	-0.02790    	41.26968    	61822.98828        	81               eval state : test_on_last_epoch;
---> final result
              	18.70496    	-0.02790    	41.26968    	61822.98828        	82               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           	178.73163   	-0.51850    	351.19940   	2589695.50000      	0           
  10          	156.14822   	-0.28951    	307.02496   	2432946.00000      	0           
  100         	66.18559    	0.26012     	131.76524   	558668.31250       	5           
  300         	38.08454    	0.28288     	77.91927    	109128.50000       	14          
  500         	24.55752    	0.40643     	55.83963    	41140.32812        	26          
  1000        	19.73479    	0.44457     	46.99942    	21672.71875        	57          
---> try to load best state
              	19.73479    	0.44457     	46.99942    	21672.71875        	57               eval state : test_on_restore;
              	19.73479    	0.44457     	46.99942    	21672.71875        	57               eval state : test_on_last_epoch;
---> final result              	19.73479    	0.44457     	46.99942    	21672.71875        	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: 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           	552.41272   	-20.78530   	818.97931   	17512004.00000     	0           
  10          	215.10945   	-6.06131    	324.83875   	3574959.00000      	0           
  100         	25.73778    	-0.41008    	52.25668    	501588.37500       	2           
  300         	26.74000    	-4.89409    	53.98647    	409907.31250       	6           
  500         	23.32662    	-0.36672    	53.37249    	237484.70312       	10          
  1000        	25.52550    	-7.26887    	55.52254    	249839.67188       	19          
---> try to load best state
              	25.52550    	-7.26887    	55.52254    	249839.67188       	19               eval state : test_on_restore;
              	25.52550    	-7.26887    	55.52254    	249839.67188       	19               eval state : test_on_last_epoch;
---> final result
              	25.52550    	-7.26887    	55.52254    	249839.67188       	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': 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           	429.84824   	-8.66491    	674.60980   	11472803.00000     	0           
  10          	160.81737   	-3.43035    	265.76273   	2272888.00000      	0           
  100         	21.70667    	-0.13741    	48.74453    	215000.90625       	3           
  300         	21.45919    	-1.41973    	45.22948    	130164.96875       	8           
  500         	37.72113    	-11.24475   	62.22222    	267183.09375       	12          
  1000        	21.05012    	-10.33253   	43.48643    	121948.86719       	24          
---> try to load best state
              	21.05012    	-10.33253   	43.48643    	121948.86719       	24               eval state : test_on_restore;
              	21.05012    	-10.33253   	43.48643    	121948.86719       	24               eval state : test_on_last_epoch;
---> final result
              	21.05012    	-10.33253   	43.48643    	121948.86719       	24               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           	247.44302   	-2.65455    	427.77530   	4272981.00000      	0           
  10          	159.55241   	-1.28305    	296.48038   	2577572.25000      	0           
  100         	21.95124    	-1.32263    	45.80841    	166333.78125       	3           
  300         	23.80844    	-8.65460    	46.01678    	154868.09375       	9           
  500         	24.35701    	-11.54406   	45.10466    	130069.14844       	15          
  1000        	18.36759    	0.28441     	41.58786    	106362.11719       	30          
---> try to load best state
              	18.36759    	0.28441     	41.58786    	106362.11719       	30               eval state : test_on_restore;
              	18.36759    	0.28441     	41.58786    	106362.11719       	30               eval state : test_on_last_epoch;
---> final result
              	18.36759    	0.28441     	41.58786    	106362.11719       	30               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           	180.26988   	-0.76869    	340.38086   	2492474.25000      	0           
  10          	111.48426   	-0.68669    	214.87650   	1210182.50000      	0           
  100         	24.16866    	-3.33030    	46.88121    	117115.02344       	7           
  300         	26.27022    	-13.16662   	49.09036    	136177.82812       	23          
  500         	23.26718    	-11.06539   	45.00345    	105685.42188       	38          
  1000        	20.08168    	-3.14351    	42.73823    	106491.18750       	76          
---> try to load best state
              	20.08168    	-3.14351    	42.73823    	106491.18750       	76               eval state : test_on_restore;
              	20.08168    	-3.14351    	42.73823    	106491.18750       	77               eval state : test_on_last_epoch;
---> final result
              	20.08168    	-3.14351    	42.73823    	106491.18750       	77               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           	133.08690   	0.02935     	247.76411   	1121271.87500      	0           
  10          	119.32175   	0.13102     	221.97202   	1089563.87500      	0           
  100         	62.73518    	0.33263     	114.62636   	483881.62500       	6           
  300         	37.96854    	0.26372     	72.65565    	126330.46094       	19          
  500         	24.58631    	0.44597     	52.85658    	47631.83594        	29          
  1000        	19.62718    	0.46830     	45.60094    	27820.73047        	58          
---> try to load best state
              	19.62718    	0.46830     	45.60094    	27820.73047        	58               eval state : test_on_restore;
              	19.62718    	0.46830     	45.60094    	27820.73047        	58               eval state : test_on_last_epoch;
---> final result              	19.62718    	0.46830     	45.60094    	27820.73047        	58               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           	603.54639   	-73.01133   	858.15002   	19316598.00000     	0           
  10          	226.08615   	-22.24737   	316.07663   	3374693.00000      	0           
  100         	25.30039    	-1.82889    	49.71402    	560478.50000       	3           
  300         	24.54520    	-1.98874    	54.06900    	1252446.25000      	8           
  500         	21.96427    	0.13072     	50.92891    	586956.06250       	12          
  1000        	39.44372    	-35.40251   	68.59286    	625180.00000       	22          
---> try to load best state
              	39.44372    	-35.40251   	68.59286    	625180.00000       	22               eval state : test_on_restore;
              	39.44372    	-35.40251   	68.59286    	625180.00000       	22               eval state : test_on_last_epoch;
---> final result
              	39.44372    	-35.40251   	68.59286    	625180.00000       	23               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           	334.82489   	-4.79945    	523.49054   	6484076.00000      	0           
  10          	132.72105   	-2.97208    	212.25478   	1331011.25000      	0           
  100         	23.32905    	-2.08456    	52.99868    	311951.59375       	2           
  300         	23.15955    	-3.07259    	51.33051    	388884.37500       	7           
  500         	22.26333    	-2.89153    	49.83953    	415649.75000       	12          
  1000        	28.05629    	-4.22078    	54.29444    	645980.00000       	24          
---> try to load best state
              	28.05629    	-4.22078    	54.29444    	645980.00000       	25               eval state : test_on_restore;
              	28.05629    	-4.22078    	54.29444    	645980.00000       	25               eval state : test_on_last_epoch;
---> final result
              	28.05629    	-4.22078    	54.29444    	645980.00000       	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           	241.09995   	-1.58729    	423.18271   	3989277.00000      	0           
  10          	130.16759   	-0.96401    	235.12390   	1508636.75000      	0           
  100         	21.10521    	-0.27959    	46.69783    	159016.81250       	3           
  300         	22.83668    	-4.46843    	47.56803    	195229.28125       	10          
  500         	22.11598    	-5.26309    	46.31247    	194225.65625       	16          
  1000        	23.24983    	-19.32366   	47.62474    	238654.26562       	33          
---> try to load best state
              	23.24983    	-19.32366   	47.62474    	238654.26562       	33               eval state : test_on_restore;
              	23.24983    	-19.32366   	47.62474    	238654.26562       	33               eval state : test_on_last_epoch;
---> final result
              	23.24983    	-19.32366   	47.62474    	238654.26562       	33               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           	133.16583   	-0.06772    	223.73882   	917044.25000       	0           
  10          	89.77538    	0.01603     	158.14888   	553288.62500       	1           
  100         	26.12065    	-6.00481    	50.92761    	135933.70312       	8           
  300         	24.04140    	-6.88773    	47.99575    	151489.25000       	23          
  500         	20.91810    	-1.45970    	46.39461    	150967.48438       	39          
  1000        	19.65815    	-0.13230    	45.75097    	168081.14062       	76          
---> try to load best state
              	19.65815    	-0.13230    	45.75097    	168081.14062       	76               eval state : test_on_restore;
              	19.65815    	-0.13230    	45.75097    	168081.14062       	76               eval state : test_on_last_epoch;
---> final result
              	19.65815    	-0.13230    	45.75097    	168081.14062       	76               eval state : final;module_name : GAR;cp_record_file : True;
