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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	221.67513   	-18222739456.31991	267.66602   	0           
  10          	221.49471   	-42912651.55373	267.43420   	0           
----------------------------------------

  Demo sGAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_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           	98.38963    	0.18338     	134.79471   	0           
  10          	86.95364    	0.47265     	120.48721   	0           
  100         	40.02437    	0.94098     	55.53881    	0           
  300         	19.25310    	0.98714     	27.23418    	1           
  500         	13.26472    	0.99389     	18.94439    	1           
  1000        	7.89892     	0.99782     	11.35999    	3           
---> try to load best state
              	7.89892     	0.99782     	11.35999    	3                eval state : test_on_restore;
              	7.89892     	0.99782     	11.35999    	3                eval state : test_on_last_epoch;
---> final result              	7.89892     	0.99782     	11.35999    	3                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	35.39088    	0.93692     	57.44469    	0           
  10          	29.71613    	0.95530     	47.34474    	0           
  epoch 82 reach nan state
---> try to load best state
              	23.48249    	0.97526     	34.09772    	0                eval state : test_on_restore;
              	29.71613    	0.95530     	47.34474    	0                eval state : test_on_last_epoch;
---> final result              	23.48249    	0.97526     	34.09772    	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	33.05981    	0.94060     	54.53902    	0           
  10          	25.84098    	0.96382     	42.76433    	0           
  epoch 82 reach nan state
---> try to load best state
              	21.14250    	0.97841     	31.64708    	0                eval state : test_on_restore;
              	25.84098    	0.96382     	42.76433    	0                eval state : test_on_last_epoch;
---> final result              	21.14250    	0.97841     	31.64708    	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	24.67210    	0.96461     	41.62828    	0           
  10          	16.38376    	0.98569     	27.61020    	0           
  epoch 82 reach nan state
---> try to load best state
              	8.57439     	0.99654     	13.88204    	0                eval state : test_on_restore;
              	16.38376    	0.98569     	27.61020    	0                eval state : test_on_last_epoch;
---> final result              	8.57439     	0.99654     	13.88204    	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end


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

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

  Demo sGAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'FlowMix3D_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           	238.32483   	-62012.01788	401.27856   	0           
  10          	237.97212   	-17553.47299	400.95642   	0           
  100         	236.47784   	-2678.99457 	399.49908   	0           
---> try to load best state
              	236.47784   	-2678.99457 	399.49908   	0                eval state : test_on_restore;
              	236.47784   	-2678.99457 	399.49908   	0                eval state : test_on_last_epoch;
---> final result              	236.47784   	-2678.99457 	399.49908   	0                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	241.76917   	-8344.47637 	408.25330   	0           
  10          	242.01398   	-32615.38798	409.14151   	0           
  100         	252.07289   	-74977.51918	424.98560   	0           
---> try to load best state
              	252.07289   	-74977.51918	424.98560   	0                eval state : test_on_restore;
              	252.07289   	-74977.51918	424.98560   	0                eval state : test_on_last_epoch;
---> final result              	252.07289   	-74977.51918	424.98560   	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	241.68068   	-8348.65608 	408.24930   	0           
  10          	243.76453   	-35234.83251	410.67154   	0           
  100         	254.15068   	-22746.89550	423.77603   	0           
---> try to load best state
              	254.15068   	-22746.89550	423.77603   	0                eval state : test_on_restore;
              	254.15068   	-22746.89550	423.77603   	0                eval state : test_on_last_epoch;
---> final result              	254.15068   	-22746.89550	423.77603   	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end

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

  Demo sGAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'MolecularDynamic_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           	5.46404     	-21641504.87641	5.75401     	0           
  10          	5.46336     	-4843781.04709	5.75321     	0           
  100         	5.46841     	-74520.56454	5.75723     	0           
---> try to load best state
              	5.46841     	-74520.56454	5.75723     	0                eval state : test_on_restore;
              	5.46841     	-74520.56454	5.75723     	0                eval state : test_on_last_epoch;
---> final result              	5.46841     	-74520.56454	5.75723     	0                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'MolecularDynamic_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	6.04960     	-78096.43827	6.17078     	0           
  10          	7.99231     	-100833.19114	8.10497     	0           
  100         	27.19317    	-2807900.75669	33.91966    	0           
---> try to load best state
              	27.19317    	-2807900.75669	33.91966    	0                eval state : test_on_restore;
              	27.19317    	-2807900.75669	33.91966    	0                eval state : test_on_last_epoch;
---> final result              	27.19317    	-2807900.75669	33.91966    	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'MolecularDynamic_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	5.83532     	-76256.23370	5.99642     	0           
  10          	5.84911     	-74547.78161	6.00711     	0           
  100         	5.72971     	-70022.23324	5.91266     	0           
---> try to load best state
              	5.72971     	-70022.23324	5.91266     	0                eval state : test_on_restore;
              	5.72971     	-70022.23324	5.91266     	0                eval state : test_on_last_epoch;
---> final result              	5.72971     	-70022.23324	5.91266     	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end

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

  Demo sGAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'plasmonic2_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           	0.06940     	0.91897     	0.17700     	0           
  10          	0.06337     	0.92808     	0.17036     	0           
  100         	0.03542     	0.95899     	0.14998     	0           
---> try to load best state
              	0.03542     	0.95899     	0.14998     	0                eval state : test_on_restore;
              	0.03542     	0.95899     	0.14998     	0                eval state : test_on_last_epoch;
---> final result              	0.03542     	0.95899     	0.14998     	0                eval state : final;
---> end


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

---> module config
  dataset: {'name': 'plasmonic2_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.06077     	0.43471     	0.21820     	0           
  10          	0.07314     	0.36521     	0.27644     	0           
  100         	0.13440     	0.16706     	0.59446     	0           
---> try to load best state
              	0.13440     	0.16706     	0.59446     	0                eval state : test_on_restore;
              	0.13440     	0.16706     	0.59446     	0                eval state : test_on_last_epoch;
---> final result              	0.13440     	0.16706     	0.59446     	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'plasmonic2_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']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.05652     	0.43405     	0.21736     	0           
  10          	0.06846     	0.43712     	0.27488     	0           
  100         	0.12915     	0.28862     	0.55892     	0           
---> try to load best state
              	0.12915     	0.28862     	0.55892     	0                eval state : test_on_restore;
              	0.12915     	0.28862     	0.55892     	0                eval state : test_on_last_epoch;
---> final result              	0.12915     	0.28862     	0.55892     	0                eval state : final;module_name : SGAR;cp_record_file : True;
---> end

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

  Demo sGAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	221.67674   	-12739921673.64004	267.66913   	0           
  10          	221.81779   	-11541048.98470	267.85083   	0           
  100         	138.87572   	-0.96954    	173.61241   	2           
  300         	109.30210   	0.28415     	140.57233   	5           
  500         	114.45884   	0.11534     	145.11708   	8           
  1000        	112.71742   	0.12185     	144.11877   	17          
---> try to load best state
              	112.71742   	0.12185     	144.11877   	17               eval state : test_on_restore;
              	112.71742   	0.12185     	144.11877   	17               eval state : test_on_last_epoch;
---> final result
              	112.71742   	0.12185     	144.11877   	17               eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

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

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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: 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           	768.66284   	-1112184850.63043	977.73248   	7589.13379         	0           
  10          	619.11377   	-73.91283   	809.57642   	10427944.00000     	0           
  100         	541.39172   	-59.99237   	729.22321   	5184220.00000      	3           
  300         	366.53412   	-9.20857    	538.88318   	1858671.62500      	8           
  500         	336.07318   	-5.49859    	507.70386   	1574115.75000      	12          
  epoch 506 reach nan state
---> try to load best state
              	336.28879   	-5.49267    	507.62973   	1512206.00000      	13               eval state : test_on_restore;
              	336.57901   	-5.51971    	507.88779   	1500904.50000      	13               eval state : test_on_last_epoch;
---> final result              	336.28879   	-5.49267    	507.62973   	1512206.00000      	13               eval state : final;
----------> finish x-yl training


---------->
SGAR 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: 1e-05
  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.11163   	-32.27641   	822.15936   	95624400.00000     	0           
  10          	567.10474   	-25.89278   	743.56866   	103147336.00000    	0           
  100         	328.89279   	-5.34960    	493.02002   	123376440.00000    	3           
  300         	331.07114   	-5.57285    	494.54681   	1549925120.00000   	9           
  epoch 494 reach nan state
---> try to load best state
----------------------------------------

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	394.03043   	-4963793146.33210	611.34900   	0           
  10          	394.00388   	-445184189.72485	611.29083   	0           
  100         	196.69693   	-1.36016    	327.66144   	0           
  300         	191.93578   	0.03940     	323.32709   	1           
  500         	216.74693   	-0.50890    	369.99036   	2           
  1000        	246.18338   	-1.40452    	411.17206   	3           
---> try to load best state
              	246.18338   	-1.40452    	411.17206   	3                eval state : test_on_restore;
              	246.18338   	-1.40452    	411.17206   	3                eval state : test_on_last_epoch;
---> final result
              	246.18338   	-1.40452    	411.17206   	3                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 8
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	394.04144   	-1299234924.82768	600.55457   	0           
  10          	393.99557   	-88410361.71077	600.49414   	0           
  100         	109.43474   	0.78755     	196.47084   	0           
  300         	115.96756   	0.75422     	197.39815   	1           
  500         	115.89223   	0.78918     	192.47066   	2           
  1000        	107.96474   	0.79541     	185.26018   	4           
---> try to load best state
              	107.96474   	0.79541     	185.26018   	4                eval state : test_on_restore;
              	107.96474   	0.79541     	185.26018   	4                eval state : test_on_last_epoch;
---> final result
              	107.96474   	0.79541     	185.26018   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 16
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	393.37701   	-1474628863.24883	599.85907   	0           
  10          	393.20343   	-5138444.59366	599.47650   	0           
  100         	117.85753   	0.85064     	202.10301   	0           
  300         	84.61857    	0.91583     	142.37859   	1           
  500         	80.98347    	0.95445     	132.62099   	2           
  1000        	68.34889    	0.96356     	111.54755   	4           
---> try to load best state
              	68.34889    	0.96356     	111.54755   	4                eval state : test_on_restore;
              	68.34889    	0.96356     	111.54755   	4                eval state : test_on_last_epoch;
---> final result
              	68.34889    	0.96356     	111.54755   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 32
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	393.14529   	-1777470309.24484	598.75836   	0           
  10          	393.01947   	-15507948.53795	598.53662   	0           
  100         	118.79037   	0.78604     	212.65495   	0           
  300         	106.42906   	0.90131     	184.72237   	1           
  500         	83.85083    	0.92058     	154.41096   	2           
  1000        	76.91811    	0.96139     	121.98499   	4           
---> try to load best state
              	76.91811    	0.96139     	121.98499   	4                eval state : test_on_restore;
              	76.91811    	0.96139     	121.98499   	4                eval state : test_on_last_epoch;
---> final result
              	76.91811    	0.96139     	121.98499   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	424.72507   	-4323732941.66549	648.73969   	0           
  10          	424.68787   	-534737537.48928	648.68085   	0           
  100         	206.26262   	-282.40314  	327.95425   	0           
  300         	207.55475   	-2.22594    	311.82843   	1           
  500         	257.44556   	-0.75924    	398.46674   	2           
  1000        	238.63127   	-0.47546    	366.49673   	3           
---> try to load best state
              	238.63127   	-0.47546    	366.49673   	3                eval state : test_on_restore;
              	238.63127   	-0.47546    	366.49673   	3                eval state : test_on_last_epoch;
---> final result
              	238.63127   	-0.47546    	366.49673   	3                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 8
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	391.69263   	-1667761586.35325	601.41583   	0           
  10          	391.62259   	-28405589.94593	601.32855   	0           
  100         	151.27087   	0.59013     	241.19606   	0           
  300         	167.89906   	0.74605     	276.78162   	1           
  500         	167.04366   	0.70137     	281.92432   	2           
  1000        	177.96289   	0.67171     	297.55606   	4           
---> try to load best state
              	177.96289   	0.67171     	297.55606   	4                eval state : test_on_restore;
              	177.96289   	0.67171     	297.55606   	4                eval state : test_on_last_epoch;
---> final result
              	177.96289   	0.67171     	297.55606   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 16
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	393.86905   	-2058152964.26221	609.15936   	0           
  10          	393.77948   	-28755350.69576	609.01807   	0           
  100         	117.86559   	0.79523     	196.19083   	0           
  300         	119.23058   	0.75785     	200.48273   	1           
  500         	101.94724   	0.91043     	164.80542   	2           
  1000        	96.95641    	0.90569     	156.84621   	4           
---> try to load best state
              	96.95641    	0.90569     	156.84621   	4                eval state : test_on_restore;
              	96.95641    	0.90569     	156.84621   	4                eval state : test_on_last_epoch;
---> final result
              	96.95641    	0.90569     	156.84621   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 32
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	393.24130   	-2803917324.30956	607.56104   	0           
  10          	393.22351   	-189162429.03712	607.60059   	0           
  100         	141.64293   	0.81359     	249.76212   	0           
----------------------------------------

  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           	768.66284   	-1112184850.63043	977.73248   	7589.13379         	0           
  10          	619.11377   	-73.91283   	809.57642   	10427944.00000     	0           
  100         	541.39172   	-59.99237   	729.22321   	5184220.00000      	3           
  300         	366.53412   	-9.20857    	538.88318   	1858671.62500      	10          
  500         	336.07318   	-5.49859    	507.70386   	1574115.75000      	16          
  epoch 506 reach nan state
---> try to load best state
              	336.28879   	-5.49267    	507.62973   	1512206.00000      	16               eval state : test_on_restore;
              	336.57901   	-5.51971    	507.88779   	1500904.50000      	16               eval state : test_on_last_epoch;
---> final result              	336.28879   	-5.49267    	507.62973   	1512206.00000      	16               eval state : final;
----------> finish x-yl training

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

  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.1, 'optional_param': 0.1, 'noise': 0.1}
  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           	768.66632   	-1309141590.32782	977.73633   	8517.16602         	0           
  10          	257.04739   	-0.66112    	398.81815   	8844725.00000      	0           
  100         	167.69823   	0.43840     	301.72324   	2539710.75000      	2           
  epoch 291 reach nan state
---> try to load best state
              	206.74786   	-1.98620    	321.28537   	69338.17969        	8                eval state : test_on_restore;
              	387.00589   	0.52542     	570.73120   	3631.24976         	8                eval state : test_on_last_epoch;
---> final result              	206.74786   	-1.98620    	321.28537   	69338.17969        	8                eval state : final;
----------> finish x-yl training

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

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	205.10651   	0.24342     	328.96970   	14992755.00000     	0           
  10          	175.74535   	0.45204     	263.84030   	10998945.00000     	0           
  100         	94.94333    	0.71704     	182.24837   	2644783.00000      	3           
  epoch 111 reach nan state
---> try to load best state
              	109.67699   	-5.74770    	191.09097   	nan                	3                eval state : test_on_restore;
              	111.61690   	-6.11210    	192.07639   	nan                	3                eval state : test_on_last_epoch;
---> final result              	109.67699   	-5.74770    	191.09097   	nan                	3                eval state : final;
----------> finish x-yl training

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

  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.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	188.05772   	0.52967     	278.24771   	13454758.00000     	0           
  epoch 5 reach nan state
---> try to load best state
              	269.91489   	-0.09661    	350.29742   	nan                	0                eval state : test_on_restore;
              	269.91489   	-0.09661    	350.29742   	nan                	0                eval state : test_on_last_epoch;
---> final result              	269.91489   	-0.09661    	350.29742   	nan                	0                eval state : final;
----------> finish x-yl training

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

  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.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	205.10651   	0.24342     	328.96970   	14992755.00000     	0           
  10          	175.74535   	0.45204     	263.84030   	10998945.00000     	0           
  100         	94.94333    	0.71704     	182.24837   	2644783.00000      	3           
  epoch 111 reach nan state
---> try to load best state
              	109.67699   	-5.74770    	191.09097   	nan                	3                eval state : test_on_restore;
              	111.61690   	-6.11210    	192.07639   	nan                	3                eval state : test_on_last_epoch;
---> final result              	109.67699   	-5.74770    	191.09097   	nan                	3                eval state : final;
----------> finish x-yl training

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

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'RQ': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	171.22382   	0.36158     	274.62094   	10588741.00000     	0           
  10          	165.86726   	0.38530     	262.35388   	15981011.00000     	0           
  epoch 21 reach nan state
---> try to load best state
----------------------------------------

  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.05, 'optional_param': 0.05, 'noise': 0.05}
  kernel: {'K1': {'RQ': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	167.41640   	0.29773     	277.54019   	10638681.00000     	0           
  10          	167.12936   	0.15369     	279.32904   	16125299.00000     	0           
  100         	94.48277    	0.78657     	176.82202   	4051108.75000      	2           
  300         	70.57786    	0.85316     	135.56850   	1534726.25000      	7           
  500         	64.12138    	0.86701     	120.38474   	897284.25000       	12          
  epoch 775 reach nan state
---> try to load best state
              	190.55260   	-22.45898   	262.40924   	nan                	19               eval state : test_on_restore;
              	187.76413   	-34.67497   	236.53000   	nan                	19               eval state : test_on_last_epoch;
---> final result              	187.76413   	-34.67497   	236.53000   	nan                	19               eval state : final;
----------> finish x-yl training

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

  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.05, 'optional_param': 0.05, 'noise': 0.05}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	215.19716   	0.06342     	344.53778   	16223990.00000     	0           
  10          	186.57098   	0.15531     	305.55472   	15352646.00000     	0           
  100         	108.38566   	0.66106     	205.76707   	4057427.75000      	3           
  epoch 244 reach nan state
---> try to load best state
              	186.11482   	-25.46987   	347.07285   	nan                	7                eval state : test_on_restore;
              	483.41202   	-87.86838   	582.53815   	nan                	7                eval state : test_on_last_epoch;
---> final result              	186.11482   	-25.46987   	347.07285   	nan                	7                eval state : final;
----------> finish x-yl training

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

  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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	168.55449   	0.24697     	280.88614   	10830602.00000     	0           
  10          	155.16194   	0.30934     	262.09564   	11396834.00000     	0           
  100         	114.83559   	0.73534     	208.34283   	8119480.00000      	2           
  epoch 289 reach nan state
---> try to load best state
              	120.02865   	-1.84789    	175.95770   	2613887.50000      	8                eval state : test_on_restore;
              	481.60867   	-3.78242    	576.09766   	593792.37500       	8                eval state : test_on_last_epoch;
---> final result              	120.02865   	-1.84789    	175.95770   	2613887.50000      	8                eval state : final;
----------> finish x-yl training

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

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	168.30531   	0.25165     	280.47943   	10792799.00000     	0           
  10          	145.51262   	0.44100     	245.39531   	9326490.00000      	0           
  100         	62.25391    	0.85017     	112.57555   	1497372.75000      	2           
  300         	33.83849    	0.96501     	54.51937    	155644.51562       	8           
  500         	32.64236    	0.98343     	54.84227    	101017.99219       	13          
  epoch 893 reach nan state
---> try to load best state
              	160.96300   	-3.26783    	216.52107   	800288.62500       	23               eval state : test_on_restore;
              	1186.20630  	-67.38502   	1576.91553  	15830552.00000     	23               eval state : test_on_last_epoch;
---> final result              	160.96300   	-3.26783    	216.52107   	800288.62500       	23               eval state : final;
----------> finish x-yl training

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

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	168.30531   	0.25165     	280.47943   	10792799.00000     	0           
  10          	145.51262   	0.44100     	245.39531   	9326490.00000      	0           
  100         	62.25391    	0.85017     	112.57555   	1497372.75000      	3           
  300         	33.83849    	0.96501     	54.51937    	155644.51562       	9           
  500         	32.64236    	0.98343     	54.84227    	101017.99219       	14          
---> try to load best state
              	123.97485   	-3.52858    	145.41940   	534064.25000       	22               eval state : test_on_restore;
              	499.10938   	-10.46517   	693.74414   	6813016.00000      	22               eval state : test_on_last_epoch;
---> final result              	123.97485   	-3.52858    	145.41940   	534064.25000       	22               eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	7110.08008  	-3.59003    	8364.34668  	16236850176.00000  	0           
  10          	3543.42993  	-3.22218    	4341.03613  	3365728256.00000   	0           
  100         	123.91319   	-2.72491    	146.00577   	2365450.00000      	2           
  epoch 187 reach nan state
---> try to load best state
              	416.48825   	-5.27027    	585.32507   	41549896.00000     	5                eval state : test_on_restore;
              	123.91319   	-2.72491    	146.00577   	2365450.00000      	5                eval state : test_on_last_epoch;
---> final result
              	123.91319   	-2.72491    	146.00577   	2365450.00000      	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	5114.24512  	-1.69187    	6611.76611  	8623385600.00000   	0           
  10          	2173.09814  	-1.35402    	3001.29614  	1287977984.00000   	0           
  100         	630.42712   	-8.39902    	876.34760   	64583836.00000     	4           
  300         	306.69641   	-2.67067    	432.12183   	7401265.00000      	9           
  500         	115.61521   	-4.92841    	136.40588   	353842.56250       	14          
  1000        	121.66256   	-4.36258    	146.21349   	565392.12500       	26          
---> try to load best state
              	121.66256   	-4.36258    	146.21349   	565392.12500       	26               eval state : test_on_restore;
              	121.66256   	-4.36258    	146.21349   	565392.12500       	26               eval state : test_on_last_epoch;
---> final result
              	121.66256   	-4.36258    	146.21349   	565392.12500       	26               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	3739.12207  	-1.34902    	5077.90381  	4145653248.00000   	0           
  10          	1631.24976  	-1.03773    	2313.51343  	615799616.00000    	0           
----------------------------------------

  Demo cigp 
  seed: None 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	81.21147    	113.18404   	0.44433     	0           
  10          	36.59027    	51.73092    	0.93943     	0           
  100         	5.97960     	9.10036     	0.99835     	0           
  300         	2.54656     	3.95056     	0.99969     	0           
  500         	1.65537     	2.58347     	0.99987     	0           
  1000        	0.91836     	1.43547     	0.99996     	1           
---> try to load best state
              	0.91836     	1.43547     	0.99996     	1                eval state : test_on_restore;
              	0.91836     	1.43547     	0.99996     	1                eval state : test_on_last_epoch;
---> final result
              	0.91836     	1.43547     	0.99996     	1                eval state : final;module_name : cigp;cp_record_file : True;
---> end

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

  Demo cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	96.87286    	137.66396   	0.05442     	0           
  10          	45.57851    	68.23431    	0.87112     	0           
  100         	7.42134     	11.72915    	0.99726     	0           
  300         	3.47830     	5.48375     	0.99942     	1           
  500         	2.41393     	3.78449     	0.99973     	2           
  1000        	1.46379     	2.26839     	0.99990     	2           
---> try to load best state
              	1.46379     	2.26839     	0.99990     	2                eval state : test_on_restore;
              	1.46379     	2.26839     	0.99990     	2                eval state : test_on_last_epoch;
---> final result
              	1.46379     	2.26839     	0.99990     	2                eval state : final;module_name : cigp;cp_record_file : True;
---> end

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

  Demo cigp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	107.08154   	146.06450   	-0.31950    	0           
  10          	54.21706    	79.06296    	0.81193     	0           
  100         	10.03824    	15.61870    	0.99493     	0           
  300         	4.37513     	6.88861     	0.99906     	0           
  500         	2.89919     	4.56174     	0.99960     	0           
----------------------------------------

  Demo hogp 
  seed: None 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[-1]'], '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           	199.93047   	-470952965.43535	237.92058   	882.71954          	0           
  10          	168.71213   	-32.86102   	204.95589   	394358.50000       	0           
  100         	68.66351    	0.51775     	95.45322    	21169.58594        	0           
  300         	33.01402    	0.91653     	55.18428    	6498.74072         	2           
  500         	32.11263    	0.92823     	53.96067    	6141.61865         	3           
  1000        	26.71221    	0.94551     	48.15351    	4731.34570         	7           
---> try to load best state
              	26.71221    	0.94551     	48.15351    	4731.34570         	7                eval state : test_on_restore;
              	26.71221    	0.94551     	48.15351    	4731.34570         	7                eval state : test_on_last_epoch;
---> final result
              	26.71221    	0.94551     	48.15351    	4731.34570         	7                eval state : final;module_name : hogp;cp_record_file : True;
---> end

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

  Demo hogp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[-1]'], '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           	200.41484   	-289789781.77052	238.35605   	1022.38208         	0           
  10          	167.36436   	-23.74950   	204.10332   	519858.09375       	0           
  100         	80.63599    	0.28868     	110.11126   	24600.44727        	2           
  300         	39.30186    	0.87933     	63.13700    	6245.26855         	3           
  500         	34.28902    	0.91951     	56.62298    	4963.38818         	5           
  1000        	30.36095    	0.93560     	52.28913    	4427.97754         	8           
---> try to load best state
              	30.36095    	0.93560     	52.28913    	4427.97754         	8                eval state : test_on_restore;
              	30.36095    	0.93560     	52.28913    	4427.97754         	8                eval state : test_on_last_epoch;
---> final result
              	30.36095    	0.93560     	52.28913    	4427.97754         	8                eval state : final;module_name : hogp;cp_record_file : True;
---> end

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

  Demo hogp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[-1]'], '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           	198.73404   	-484367358.05473	239.27722   	1566.94971         	0           
  10          	171.84988   	-39.77104   	211.28648   	721711.00000       	0           
  100         	86.60783    	0.10584     	117.65367   	18544.69141        	0           
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: 0.0001
  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           	790.03992   	-1650703.40120	1005.05084  	6429.53906         	8           
  epoch 2 reach nan state
---> try to load best state
              	512.90387   	-28.47470   	696.64050   	nan                	16               eval state : test_on_restore;
              	512.90387   	-28.47470   	696.64050   	nan                	16               eval state : test_on_last_epoch;
---> final result              	512.90387   	-28.47470   	696.64050   	nan                	16               eval state : final;
----------> finish x-yl training


---------->
SGAR 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: 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           	791.97931   	-360208719.37956	1007.21680  	804.38092          	10          
  epoch 2 reach nan state
---> try to load best state
              	721.64398   	-457.13747  	927.23779   	429519.65625       	20               eval state : test_on_restore;
              	721.64398   	-457.13747  	927.23779   	429519.65625       	20               eval state : test_on_last_epoch;
---> final result              	721.64398   	-457.13747  	927.23779   	429519.65625       	20               eval state : final;
----------> finish x-yl training


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

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

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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: 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           	768.63470   	-430232950.24653	977.70062   	773.79773          	0           
  10          	564.72302   	-32.64164   	748.41638   	913224.43750       	0           
  100         	326.81589   	-4.21295    	489.62793   	167788.35938       	3           
  epoch 162 reach nan state
---> try to load best state
              	285.89505   	-1.78766    	446.13052   	65197.65625        	5                eval state : test_on_restore;
              	337.85437   	-4.43097    	490.47220   	2914.19043         	5                eval state : test_on_last_epoch;
---> final result              	285.89505   	-1.78766    	446.13052   	65197.65625        	5                eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	5396.34619  	-8.98228    	5935.47949  	844055296.00000    	0           
  10          	1112.61267  	-13.62951   	1413.26514  	31410350.00000     	0           
  100         	303.36603   	-3.96635    	447.21854   	3005054.00000      	2           
  epoch 180 reach nan state
---> try to load best state
              	271.47400   	-1.72649    	417.95566   	4009382.50000      	5                eval state : test_on_restore;
              	303.36603   	-3.96635    	447.21854   	3005054.00000      	5                eval state : test_on_last_epoch;
---> final result
              	271.47400   	-1.72649    	417.95566   	4009382.50000      	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	3392.31152  	-3.65865    	4178.46045  	358651968.00000    	0           
  10          	627.72162   	-2.30322    	852.00403   	9429810.00000      	0           
----------------------------------------

  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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	201.47392   	0.16778     	324.67017   	1474157.87500      	0           
  10          	168.50450   	0.40945     	272.27737   	1172149.25000      	0           
  100         	99.15924    	0.69841     	188.20558   	265403.12500       	3           
  epoch 156 reach nan state
---> try to load best state
              	92.40476    	0.46268     	174.91896   	nan                	5                eval state : test_on_restore;
              	233.97995   	-24.90562   	288.96454   	nan                	5                eval state : test_on_last_epoch;
---> final result              	92.40476    	0.46268     	174.91896   	nan                	5                eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	6579.79492  	-3.47790    	7748.45068  	1457467904.00000   	0           
  10          	1323.23401  	-6.04383    	1752.81091  	48873432.00000     	0           
  100         	198.89845   	-1.66699    	301.67999   	1381800.50000      	2           
  epoch 180 reach nan state
---> try to load best state
              	86.15894    	0.56128     	152.32152   	578043.37500       	4                eval state : test_on_restore;
              	198.89845   	-1.66699    	301.67999   	1381800.50000      	4                eval state : test_on_last_epoch;
---> final result
              	86.15894    	0.56128     	152.32152   	578043.37500       	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	4773.48682  	-1.79126    	6166.33936  	788912512.00000    	0           
  10          	964.19989   	-1.54972    	1320.49792  	23056490.00000     	0           
  100         	120.92487   	0.25749     	198.84952   	502818.06250       	2           
  epoch 187 reach nan state
---> try to load best state
              	78.60674    	0.66575     	148.02568   	449352.15625       	5                eval state : test_on_restore;
              	120.92487   	0.25749     	198.84952   	502818.06250       	5                eval state : test_on_last_epoch;
---> final result
              	78.60674    	0.66575     	148.02568   	449352.15625       	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	3253.10889  	-1.28366    	4453.85986  	337923008.00000    	0           
  10          	560.73022   	-0.73488    	814.61035   	6936292.50000      	0           
----------------------------------------

  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.03, 'optional_param': 0.03, 'noise': 0.03}
  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           	177.41978   	0.42415     	280.19330   	1399968.25000      	0           
  10          	151.10910   	0.56922     	232.88780   	1407203.12500      	0           
  epoch 64 reach nan state
---> try to load best state
              	221.17593   	-26.56758   	275.26413   	nan                	2                eval state : test_on_restore;
              	1153.17908  	-1.98913    	1399.85571  	nan                	2                eval state : test_on_last_epoch;
---> final result              	221.17593   	-26.56758   	275.26413   	nan                	2                eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	4457.75244  	-1.53117    	5847.40576  	840915200.00000    	0           
  10          	971.28491   	-3.88353    	1380.29187  	30683492.00000     	0           
  100         	272.73438   	-3.81807    	365.11935   	1993305.62500      	2           
  epoch 180 reach nan state
---> try to load best state
              	224.21266   	-15.26523   	271.74255   	1686546.25000      	5                eval state : test_on_restore;
              	272.73438   	-3.81807    	365.11935   	1993305.62500      	5                eval state : test_on_last_epoch;
---> final result
              	224.21266   	-15.26523   	271.74255   	1686546.25000      	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	3445.55225  	-0.62653    	4683.64941  	460826976.00000    	0           
  10          	817.00732   	-0.91706    	1126.08289  	16759156.00000     	0           
----------------------------------------

  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           	180.12846   	0.35337     	286.07675   	1467204.87500      	0           
  10          	167.08652   	0.43635     	264.12634   	1418620.62500      	0           
  100         	97.80976    	0.69313     	168.86987   	785467.06250       	3           
  epoch 195 reach nan state
---> try to load best state
              	259.22610   	-31.15698   	318.35928   	nan                	6                eval state : test_on_restore;
              	577.37268   	-11.85211   	685.81250   	nan                	6                eval state : test_on_last_epoch;
---> final result              	259.22610   	-31.15698   	318.35928   	nan                	6                eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	4265.04785  	-1.14008    	5719.58154  	807116160.00000    	0           
  10          	968.65308   	-3.31539    	1375.29211  	30465328.00000     	0           
  100         	289.73376   	-4.11550    	375.80176   	2094105.00000      	3           
  epoch 180 reach nan state
---> try to load best state
              	253.53662   	-19.08406   	300.17731   	2025254.87500      	5                eval state : test_on_restore;
              	289.73376   	-4.11550    	375.80176   	2094105.00000      	5                eval state : test_on_last_epoch;
---> final result
              	253.53662   	-19.08406   	300.17731   	2025254.87500      	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	3505.88452  	-0.44762    	4715.69873  	465222464.00000    	0           
  10          	870.08923   	-0.84203    	1179.42041  	18220328.00000     	0           
----------------------------------------

  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': {'RQ': {'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           	136.23752   	0.48702     	223.98549   	879217.06250       	0           
  10          	127.97928   	0.54256     	208.70520   	885644.75000       	0           
  100         	85.08095    	0.73461     	148.95267   	813456.93750       	2           
  300         	61.64883    	0.87272     	111.20918   	254893.75000       	8           
  500         	54.93928    	0.89293     	99.36861    	139474.59375       	13          
---> try to load best state
              	61.61969    	0.36930     	97.99960    	102623.27344       	20               eval state : test_on_restore;
              	221.33296   	-10.96204   	259.45282   	271371.50000       	20               eval state : test_on_last_epoch;
---> final result              	61.61969    	0.36930     	97.99960    	102623.27344       	20               eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	6515.31201  	-3.06793    	7751.80859  	1464756992.00000   	0           
  10          	1285.79626  	-4.53269    	1727.24146  	47724636.00000     	0           
  100         	196.89267   	-1.52831    	295.47943   	1321909.50000      	2           
  epoch 180 reach nan state
---> try to load best state
              	71.42480    	0.44259     	110.44981   	301042.59375       	4                eval state : test_on_restore;
              	196.89267   	-1.52831    	295.47943   	1321909.50000      	4                eval state : test_on_last_epoch;
---> final result
              	71.42480    	0.44259     	110.44981   	301042.59375       	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	4702.18408  	-1.66829    	6144.73975  	781759168.00000    	0           
  10          	946.27148   	-1.30401    	1315.87036  	22838452.00000     	0           
  100         	118.24433   	0.03274     	193.47472   	480792.28125       	2           
  epoch 187 reach nan state
---> try to load best state
              	73.56786    	0.40015     	129.32137   	346175.62500       	5                eval state : test_on_restore;
              	118.24433   	0.03274     	193.47472   	480792.28125       	5                eval state : test_on_last_epoch;
---> final result
              	73.56786    	0.40015     	129.32137   	346175.62500       	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	3200.08691  	-1.18431    	4439.77051  	335428544.00000    	0           
  10          	549.53827   	-0.55650    	810.55249   	6879473.50000      	0           
  100         	75.14010    	0.51418     	121.96088   	156915.32812       	3           
----------------------------------------

  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': {'RQ': {'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           	136.23752   	0.48702     	223.98549   	879217.06250       	0           
  10          	127.97928   	0.54256     	208.70520   	885644.75000       	0           
  100         	85.08095    	0.73461     	148.95267   	813456.93750       	2           
  300         	61.64883    	0.87272     	111.20918   	254893.75000       	8           
  500         	54.93928    	0.89293     	99.36861    	139474.59375       	13          
---> try to load best state
              	61.61969    	0.36930     	97.99960    	102623.27344       	21               eval state : test_on_restore;
              	221.33296   	-10.96204   	259.45282   	271371.50000       	21               eval state : test_on_last_epoch;
---> final result              	61.61969    	0.36930     	97.99960    	102623.27344       	21               eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	6314.44385  	-2.49214    	7618.48340  	1480657152.00000   	0           
  10          	1468.54907  	-2.25866    	2454.94092  	98257896.00000     	0           
  100         	425.60956   	-11.35586   	637.39166   	4226333.00000      	2           
  300         	351.84381   	-5.52227    	548.18756   	4932137.00000      	8           
  500         	280.34338   	-2.14685    	453.80484   	5037698.00000      	13          
  epoch 619 reach nan state
---> try to load best state
              	184.91948   	-0.05259    	302.95206   	2739515.50000      	16               eval state : test_on_restore;
              	280.34338   	-2.14685    	453.80484   	5037698.00000      	16               eval state : test_on_last_epoch;
---> final result
              	184.91948   	-0.05259    	302.95206   	2739515.50000      	16               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	4108.05859  	-1.36581    	5504.06885  	703115776.00000    	0           
  10          	945.43457   	-0.81566    	1590.24072  	35910588.00000     	0           
  100         	254.73047   	-0.54474    	378.86441   	1276302.87500      	2           
  300         	176.77049   	0.17341     	275.11826   	1096388.25000      	8           
  500         	116.07856   	0.53199     	214.17476   	1029921.68750      	13          
  epoch 598 reach nan state
---> try to load best state
              	91.69555    	0.56564     	179.46898   	847801.50000       	16               eval state : test_on_restore;
              	116.07856   	0.53199     	214.17476   	1029921.68750      	16               eval state : test_on_last_epoch;
---> final result
              	91.69555    	0.56564     	179.46898   	847801.50000       	16               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	2443.11743  	-0.82326    	3501.92627  	254684800.00000    	0           
  10          	512.62402   	-0.09981    	866.99359   	9549449.00000      	0           
  100         	116.57841   	0.50230     	187.01695   	277941.12500       	3           
  300         	65.23801    	0.74056     	105.62795   	162557.40625       	8           
  500         	51.84681    	0.57149     	85.53777    	201581.84375       	15          
  epoch 591 reach nan state
---> try to load best state
              	53.25927    	0.45090     	86.28637    	262953.71875       	17               eval state : test_on_restore;
              	51.84681    	0.57149     	85.53777    	201581.84375       	17               eval state : test_on_last_epoch;
---> final result
              	51.84681    	0.57149     	85.53777    	201581.84375       	17               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'RQ': {'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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	1324.10620  	-0.33325    	2080.78027  	76632064.00000     	0           
  10          	313.40454   	0.33584     	520.87640   	2829998.25000      	0           
  100         	82.72507    	0.67422     	131.54410   	129136.67188       	3           
----------------------------------------

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	394.03250   	-8381488473.42801	611.35840   	0           
  10          	393.96991   	-224339177.02833	611.18188   	0           
  100         	173.20488   	-0.38779    	293.25928   	0           
  300         	191.28197   	0.06354     	329.88275   	1           
  500         	206.17474   	-0.24227    	354.06604   	2           
  1000        	214.90550   	-0.40551    	363.13705   	4           
---> try to load best state
              	214.90550   	-0.40551    	363.13705   	4                eval state : test_on_restore;
              	214.90550   	-0.40551    	363.13705   	4                eval state : test_on_last_epoch;
---> final result
              	214.90550   	-0.40551    	363.13705   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 8
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	394.03500   	-3508931517.47115	600.55176   	0           
  10          	393.93713   	-13572270.27815	600.46930   	0           
  100         	114.66991   	0.78192     	200.41707   	0           
  300         	119.63314   	0.77117     	208.09941   	1           
  500         	117.93427   	0.75505     	187.61586   	2           
  1000        	138.34428   	0.67772     	220.79904   	4           
---> try to load best state
              	138.34428   	0.67772     	220.79904   	4                eval state : test_on_restore;
              	138.34428   	0.67772     	220.79904   	4                eval state : test_on_last_epoch;
---> final result
              	138.34428   	0.67772     	220.79904   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 16
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	393.37900   	-3054447030.98441	599.88025   	0           
  10          	393.26837   	-7090774.78940	599.64343   	0           
  100         	119.57097   	0.86075     	203.82593   	0           
  300         	105.89228   	0.88614     	185.69885   	1           
  500         	90.62197    	0.91393     	158.68008   	2           
  1000        	86.03806    	0.94141     	140.98709   	4           
---> try to load best state
              	86.03806    	0.94141     	140.98709   	4                eval state : test_on_restore;
              	86.03806    	0.94141     	140.98709   	4                eval state : test_on_last_epoch;
---> final result
              	86.03806    	0.94141     	140.98709   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 32
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	393.14868   	-3981350949.97863	598.75525   	0           
  10          	393.09537   	-32019374.80959	598.60608   	0           
  100         	117.49988   	0.86429     	202.90067   	0           
  300         	108.10625   	0.85320     	193.94139   	1           
  500         	86.44712    	0.95347     	132.69440   	2           
  1000        	61.32525    	0.97275     	96.20069    	5           
---> try to load best state
              	61.32525    	0.97275     	96.20069    	5                eval state : test_on_restore;
              	61.32525    	0.97275     	96.20069    	5                eval state : test_on_last_epoch;
---> final result
              	61.32525    	0.97275     	96.20069    	5                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	424.73547   	-7342404729.84131	648.76068   	0           
  10          	424.84995   	-177362394.70141	648.92914   	0           
  100         	209.92950   	-1226.17647 	333.30334   	0           
  300         	177.20679   	-0.66704    	283.89996   	1           
  500         	189.78564   	-0.12503    	292.85712   	2           
  1000        	209.32457   	-0.57923    	329.62888   	4           
---> try to load best state
              	209.32457   	-0.57923    	329.62888   	4                eval state : test_on_restore;
              	209.32457   	-0.57923    	329.62888   	4                eval state : test_on_last_epoch;
---> final result
              	209.32457   	-0.57923    	329.62888   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 8
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	391.69244   	-1945405735.82822	601.40875   	0           
  10          	391.54718   	-5292150.72585	601.16656   	0           
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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           	180.12846   	0.35337     	286.07675   	1467204.87500      	0           
  10          	167.08652   	0.43635     	264.12634   	1418620.62500      	0           
  100         	97.80976    	0.69313     	168.86987   	785467.06250       	3           
  epoch 195 reach nan state
---> try to load best state
              	259.22610   	-31.15698   	318.35928   	nan                	6                eval state : test_on_restore;
              	577.37268   	-11.85211   	685.81250   	nan                	6                eval state : test_on_last_epoch;
---> final result              	259.22610   	-31.15698   	318.35928   	nan                	6                eval state : final;
----------> finish x-yl training


---------->
SGAR 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': {'Periodic': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K2': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K3': {'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           	707.39050   	-4.09683    	881.97693   	12526860.00000     	0           
  10          	707.07336   	-4.00994    	881.50580   	12291940.00000     	0           
  100         	701.36475   	-3.15080    	874.28687   	17876924.00000     	2           
  300         	695.84723   	-2.85274    	867.63635   	16060433.00000     	6           
  500         	695.02338   	-2.78777    	867.02679   	8332993.50000      	10          
---> try to load best state
              	740.14478   	-3.86710    	905.19312   	93907.36719        	16               eval state : test_on_restore;
              	966.95465   	-4.88411    	1134.60266  	3819.48706         	16               eval state : test_on_last_epoch;
---> final result              	740.14478   	-3.86710    	905.19312   	93907.36719        	16               eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'Periodic': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K2': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K3': {'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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	832.28894   	-26.09554   	1089.37000  	28050266.00000     	0           
  10          	807.44739   	-9.53676    	1016.64111  	31869474.00000     	0           
  100         	771.72052   	-352.67737  	969.92920   	130510992.00000    	2           
  300         	767.90070   	-1705.31566 	966.20325   	155291152.00000    	6           
  500         	767.26355   	-1673.47708 	966.16248   	154873616.00000    	10          
  epoch 969 reach nan state
---> try to load best state
              	765.48975   	-2837.89550 	961.47205   	157805168.00000    	19               eval state : test_on_restore;
              	767.26355   	-1673.47708 	966.16248   	154873616.00000    	19               eval state : test_on_last_epoch;
---> final result
              	765.48975   	-2837.89550 	961.47205   	157805168.00000    	19               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'Periodic': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K2': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K3': {'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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	872.21661   	-24.01803   	1171.50281  	32119226.00000     	0           
  10          	825.81671   	-28.68132   	1034.48840  	21892300.00000     	0           
  100         	725.25476   	-7.29127    	884.15894   	22740226.00000     	2           
----------------------------------------

  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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'Periodic': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K2': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K3': {'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           	707.15942   	-3.94875    	881.60675   	12505614.00000     	0           
  10          	705.74377   	-3.72526    	879.85309   	12056197.00000     	0           
  100         	695.93256   	-2.89276    	867.73016   	15676417.00000     	2           
  epoch 236 reach nan state
---> try to load best state
              	694.69049   	-2.48846    	867.59503   	6726886.50000      	5                eval state : test_on_restore;
              	698.16028   	-1.89946    	870.41888   	5386961.00000      	5                eval state : test_on_last_epoch;
---> final result              	694.69049   	-2.48846    	867.59503   	6726886.50000      	5                eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  kernel: {'K1': {'Periodic': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K2': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K3': {'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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	777.63147   	-22.01839   	1017.71130  	24645036.00000     	0           
  10          	751.70923   	-6.98665    	965.40656   	28798168.00000     	0           
----------------------------------------

  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.03, 'optional_param': 0.03, 'noise': 0.03}
  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           	177.41978   	0.42415     	280.19330   	1399968.25000      	0           
  10          	151.10910   	0.56922     	232.88780   	1407203.12500      	0           
  epoch 64 reach nan state
---> try to load best state
              	221.17593   	-26.56758   	275.26413   	nan                	2                eval state : test_on_restore;
              	1153.17908  	-1.98913    	1399.85571  	nan                	2                eval state : test_on_last_epoch;
---> final result              	221.17593   	-26.56758   	275.26413   	nan                	2                eval state : final;
----------> finish x-yl training


---------->
SGAR 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.03, 'optional_param': 0.03, 'noise': 0.03}
  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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	5563.68408  	-2.16197    	6819.03906  	1225419264.00000   	0           
  10          	1117.42249  	-1.51200    	2002.34839  	68200064.00000     	0           
  100         	467.88525   	-8.42576    	684.45966   	4686964.00000      	3           
  300         	399.71750   	-5.00093    	603.11511   	4990145.50000      	10          
  500         	331.74142   	-2.90770    	514.25061   	4702180.00000      	17          
----------------------------------------

  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           	180.12846   	0.35337     	286.07675   	1467204.87500      	0           
  10          	167.08652   	0.43635     	264.12634   	1418620.62500      	0           
  100         	97.80976    	0.69313     	168.86987   	785467.06250       	3           
  epoch 195 reach nan state
---> try to load best state
              	259.22610   	-31.15698   	318.35928   	nan                	6                eval state : test_on_restore;
              	577.37268   	-11.85211   	685.81250   	nan                	6                eval state : test_on_last_epoch;
---> final result              	259.22610   	-31.15698   	318.35928   	nan                	6                eval state : final;
----------> finish x-yl training


---------->
SGAR 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: True
  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, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	1789.28552  	-4.03719    	2289.36719  	133212168.00000    	0           
  10          	680.85632   	-5.56572    	971.67126   	20800876.00000     	0           
  100         	255.82262   	-25.40158   	304.06790   	1941502.62500      	3           
  300         	257.21573   	-30.67914   	305.03067   	4998742.00000      	10          
  500         	256.85004   	-31.34873   	304.06976   	11149346.00000     	20          
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	176.94778   	0.38169     	280.49817   	1450593.62500      	0           
  10          	162.59531   	0.46612     	256.71661   	1398738.50000      	0           
  epoch 31 reach nan state
---> try to load best state
              	283.72366   	-1.10282    	366.21600   	nan                	1                eval state : test_on_restore;
              	283.72366   	-1.10282    	366.21600   	nan                	1                eval state : test_on_last_epoch;
---> final result              	283.72366   	-1.10282    	366.21600   	nan                	1                eval state : final;
----------> finish x-yl training


---------->
SGAR 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: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	1670.52905  	-1.79694    	2201.41992  	123293768.00000    	0           
  10          	795.42523   	-2.49356    	1096.13452  	26779740.00000     	0           
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	209.49881   	0.05161     	334.57318   	1559444.37500      	0           
  10          	191.71765   	0.18959     	309.53732   	1406041.62500      	0           
  100         	124.98257   	0.58454     	217.30121   	560417.00000       	3           
  300         	99.93796    	0.68266     	190.54881   	286806.78125       	9           
  epoch 454 reach nan state
---> try to load best state
              	93.77080    	0.67202     	180.54834   	nan                	13               eval state : test_on_restore;
              	261.48947   	-40.66047   	319.09134   	nan                	13               eval state : test_on_last_epoch;
---> final result              	93.77080    	0.67202     	180.54834   	nan                	13               eval state : final;
----------> finish x-yl training


---------->
SGAR 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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	2643.21484  	-8.30798    	2991.74048  	221681280.00000    	0           
  10          	1222.70398  	-9.86410    	1437.50122  	46749628.00000     	0           
  100         	83.75492    	0.65475     	157.06099   	1487027.50000      	3           
  300         	73.95469    	0.73866     	141.53662   	5737153.00000      	8           
  500         	71.73008    	0.74634     	133.09618   	15646070.00000     	13          
  1000        	73.83392    	0.76479     	135.02266   	29331222.00000     	23          
---> try to load best state
              	73.83392    	0.76479     	135.02266   	29331222.00000     	23               eval state : test_on_restore;
              	73.83392    	0.76479     	135.02266   	29331222.00000     	23               eval state : test_on_last_epoch;
---> final result
              	73.83392    	0.76479     	135.02266   	29331222.00000     	23               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	2091.80811  	-4.19411    	2566.02393  	144662272.00000    	0           
  10          	982.95215   	-5.29146    	1245.27393  	31059350.00000     	0           
  100         	132.41727   	-0.56873    	201.78403   	1809849.12500      	3           
  300         	68.56953    	0.77114     	130.56255   	2916268.50000      	8           
  500         	65.72688    	0.76852     	122.19942   	10014925.00000     	13          
  1000        	63.25830    	0.76593     	115.64571   	7885354.50000      	23          
---> try to load best state
              	63.25830    	0.76593     	115.64571   	7885354.50000      	23               eval state : test_on_restore;
              	63.25830    	0.76593     	115.64571   	7885354.50000      	23               eval state : test_on_last_epoch;
---> final result
              	63.25830    	0.76593     	115.64571   	7885354.50000      	23               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	1507.38000  	-3.13276    	1974.45435  	69135224.00000     	0           
  10          	610.66461   	-1.93206    	843.08044   	11560663.00000     	0           
  100         	118.64192   	-0.57131    	189.49911   	1169349.37500      	3           
  300         	71.32548    	0.68046     	127.95624   	2440446.50000      	9           
  500         	70.34254    	0.65776     	124.39355   	8679462.00000      	14          
  1000        	61.86892    	0.78358     	118.23959   	3079559.00000      	26          
---> try to load best state
              	61.86892    	0.78358     	118.23959   	3079559.00000      	26               eval state : test_on_restore;
              	61.86892    	0.78358     	118.23959   	3079559.00000      	26               eval state : test_on_last_epoch;
---> final result
              	61.86892    	0.78358     	118.23959   	3079559.00000      	26               eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	1198.00500  	-4.01954    	1632.88721  	34370016.00000     	0           
  10          	381.11606   	-0.39737    	585.82178   	3857435.75000      	0           
  100         	74.36261    	0.69185     	142.29488   	467152.46875       	3           
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	394.03094   	-10308904340.56077	611.35541   	0           
  10          	394.03125   	-1026051882.49735	611.37683   	0           
  100         	173.65199   	-0.23515    	281.02795   	0           
  300         	173.67628   	0.33411     	300.30692   	1           
  500         	198.61797   	-0.12227    	348.12982   	2           
  1000        	202.97798   	-0.20217    	352.31705   	4           
---> try to load best state
              	202.97798   	-0.20217    	352.31705   	4                eval state : test_on_restore;
              	202.97798   	-0.20217    	352.31705   	4                eval state : test_on_last_epoch;
---> final result
              	202.97798   	-0.20217    	352.31705   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 8
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	394.03406   	-2794177874.47827	600.55005   	0           
  10          	393.94781   	-26889058.52690	600.44684   	0           
  100         	144.10828   	0.73826     	243.82758   	0           
  300         	124.73627   	0.68216     	203.89745   	1           
  500         	140.85258   	0.69473     	220.01007   	2           
  1000        	138.79515   	0.68773     	216.07518   	4           
---> try to load best state
              	138.79515   	0.68773     	216.07518   	4                eval state : test_on_restore;
              	138.79515   	0.68773     	216.07518   	4                eval state : test_on_last_epoch;
---> final result
              	138.79515   	0.68773     	216.07518   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 16
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	393.38156   	-3309775924.90594	599.87268   	0           
  10          	393.30695   	-24259154.63914	599.69354   	0           
  100         	119.36697   	0.81364     	207.25282   	0           
  300         	82.08892    	0.94466     	130.97832   	1           
  500         	75.83597    	0.95999     	120.63145   	2           
  1000        	79.01920    	0.95815     	127.06952   	4           
---> try to load best state
              	79.01920    	0.95815     	127.06952   	4                eval state : test_on_restore;
              	79.01920    	0.95815     	127.06952   	4                eval state : test_on_last_epoch;
---> final result
              	79.01920    	0.95815     	127.06952   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 32
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	393.14969   	-4689403290.74372	598.75745   	0           
  10          	393.03955   	-29126686.61972	598.65771   	0           
  100         	113.45399   	0.81516     	203.19647   	0           
  300         	107.70234   	0.89267     	188.21962   	1           
  500         	82.92450    	0.94479     	137.79768   	2           
  1000        	55.12212    	0.97218     	91.61436    	4           
---> try to load best state
              	55.12212    	0.97218     	91.61436    	4                eval state : test_on_restore;
              	55.12212    	0.97218     	91.61436    	4                eval state : test_on_last_epoch;
---> final result
              	55.12212    	0.97218     	91.61436    	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	424.72574   	-9067838744.08627	648.73694   	0           
  10          	424.80148   	-299530386.21611	648.87115   	0           
  100         	203.12428   	-151.79614  	324.37415   	0           
  300         	183.14182   	-0.38493    	285.28528   	1           
  500         	210.09488   	-0.50862    	330.09308   	2           
  1000        	207.09520   	-0.69936    	321.57205   	4           
---> try to load best state
              	207.09520   	-0.69936    	321.57205   	4                eval state : test_on_restore;
              	207.09520   	-0.69936    	321.57205   	4                eval state : test_on_last_epoch;
---> final result
              	207.09520   	-0.69936    	321.57205   	4                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 8
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	391.69638   	-3371878152.05636	601.41901   	0           
  10          	391.64661   	-18144032.82092	601.33331   	0           
  100         	169.86868   	0.42629     	267.30716   	0           
  300         	155.82465   	0.78472     	254.44762   	1           
  500         	169.54340   	0.72295     	278.82660   	2           
----------------------------------------

  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': {'RQ': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	156.02409   	0.31447     	261.81390   	963082.75000       	0           
  10          	147.88791   	0.38403     	248.19157   	955080.18750       	0           
  100         	112.47279   	0.63746     	206.55463   	792620.93750       	2           
  epoch 268 reach nan state
---> try to load best state
              	98.79240    	0.18327     	169.81815   	321406.78125       	6                eval state : test_on_restore;
              	481.27762   	-4.11584    	569.01471   	60907.98047        	6                eval state : test_on_last_epoch;
---> final result              	98.79240    	0.18327     	169.81815   	321406.78125       	6                eval state : final;
----------> finish x-yl training


---------->
SGAR 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': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	2141.05249  	-5.59251    	2564.64282  	154765200.00000    	0           
  10          	995.79736   	-7.92935    	1246.40002  	33388056.00000     	0           
  100         	160.95171   	-1.32655    	229.34442   	3013478.00000      	2           
  300         	94.63068    	0.20107     	154.89691   	7897764.50000      	7           
  epoch 314 reach nan state
---> try to load best state
              	94.57932    	0.20159     	154.79184   	7940869.00000      	7                eval state : test_on_restore;
              	94.63068    	0.20107     	154.89691   	7897764.50000      	7                eval state : test_on_last_epoch;
---> final result
              	94.57932    	0.20159     	154.79184   	7940869.00000      	7                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	1562.37646  	-3.38653    	2060.01074  	85724480.00000     	0           
  10          	725.32227   	-3.76125    	989.48114   	18074352.00000     	0           
  100         	129.44913   	-0.07254    	189.48260   	1653874.37500      	2           
  300         	93.92178    	0.30004     	151.44853   	4802291.50000      	7           
  epoch 333 reach nan state
---> try to load best state
              	94.00562    	0.30000     	151.56400   	4842340.00000      	8                eval state : test_on_restore;
              	93.92178    	0.30004     	151.44853   	4802291.50000      	8                eval state : test_on_last_epoch;
---> final result
              	93.92178    	0.30004     	151.44853   	4802291.50000      	8                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	1067.01282  	-2.55323    	1488.91187  	36788408.00000     	0           
  10          	442.35730   	-1.51548    	639.63214   	6187841.00000      	0           
  100         	105.13863   	-0.01463    	165.31703   	1019292.31250      	2           
  300         	98.08080    	0.06071     	154.59131   	4487814.00000      	7           
  epoch 345 reach nan state
---> try to load best state
              	94.73711    	0.09973     	151.95793   	4349781.00000      	8                eval state : test_on_restore;
              	98.08080    	0.06071     	154.59131   	4487814.00000      	8                eval state : test_on_last_epoch;
---> final result
              	94.73711    	0.09973     	151.95793   	4349781.00000      	8                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR 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': {'RQ': {'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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	725.74939   	-1.83286    	1090.73596  	15755318.00000     	0           
  10          	231.92819   	0.05007     	352.60730   	1499041.87500      	0           
  100         	94.22595    	0.04470     	153.70282   	767820.50000       	3           
  300         	90.88517    	0.07828     	147.88438   	3273227.50000      	8           
  epoch 370 reach nan state
---> try to load best state
              	91.21549    	0.09141     	147.70721   	4637685.00000      	10               eval state : test_on_restore;
              	90.88517    	0.07828     	147.88438   	3273227.50000      	10               eval state : test_on_last_epoch;
---> final result
              	91.21549    	0.09141     	147.70721   	4637685.00000      	10               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': {'RQ': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	224.98784   	-0.26084    	382.33038   	2276269.75000      	0           
  10          	208.61713   	-0.08186    	357.31927   	2137269.25000      	0           
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	209.49881   	0.05161     	334.57318   	1559444.37500      	0           
  10          	191.71765   	0.18959     	309.53732   	1406041.62500      	0           
  100         	124.98257   	0.58454     	217.30121   	560417.00000       	3           
  300         	99.93796    	0.68266     	190.54881   	286806.78125       	9           
  epoch 454 reach nan state
---> try to load best state
              	93.77080    	0.67202     	180.54834   	nan                	13               eval state : test_on_restore;
              	261.48947   	-40.66047   	319.09134   	nan                	13               eval state : test_on_last_epoch;
---> final result              	93.77080    	0.67202     	180.54834   	nan                	13               eval state : final;
----------> finish x-yl training


---------->
SGAR 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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	2643.21484  	-8.30798    	2991.74048  	221681280.00000    	0           
  10          	1222.70398  	-9.86410    	1437.50122  	46749628.00000     	0           
  100         	83.75492    	0.65475     	157.06099   	1487027.50000      	3           
  300         	73.95469    	0.73866     	141.53662   	5737153.00000      	8           
  500         	71.73008    	0.74634     	133.09618   	15646070.00000     	13          
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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': {'Periodic': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K2': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K3': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	707.40472   	-4.11173    	882.00897   	9675575.00000      	14          
----------------------------------------

  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': {'Local_Periodic': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K2': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K3': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2', 'gaussian_loss']
  optimizer: adam
  exp_restrict: False
  input_normalzie: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	707.40472   	-4.11173    	882.00897   	9675575.00000      	0           
  10          	706.12201   	-3.69637    	880.18463   	9489014.00000      	0           
  100         	696.08350   	-2.95120    	867.98114   	6815115.50000      	2           
  epoch 190 reach nan state
---> try to load best state
              	696.11865   	-3.02334    	867.59290   	3394408.00000      	4                eval state : test_on_restore;
              	716.18127   	-1.91484    	891.80389   	55026.28516        	4                eval state : test_on_last_epoch;
---> final result              	696.11865   	-3.02334    	867.59290   	3394408.00000      	4                eval state : final;
----------> finish x-yl training

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

  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': {'Local_Periodic': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K2': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}, 'K3': {'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           	707.39050   	-4.09683    	881.97693   	12526860.00000     	0           
  10          	707.07336   	-4.00994    	881.50580   	12291940.00000     	0           
  100         	701.36475   	-3.15080    	874.28687   	17876924.00000     	3           
  300         	695.84723   	-2.85274    	867.63635   	16060433.00000     	8           
  500         	695.02338   	-2.78777    	867.02679   	8332993.50000      	15          
---> try to load best state
              	740.14478   	-3.86710    	905.19312   	93907.36719        	22               eval state : test_on_restore;
              	966.95465   	-4.88411    	1134.60266  	3819.48706         	22               eval state : test_on_last_epoch;
---> final result              	740.14478   	-3.86710    	905.19312   	93907.36719        	22               eval state : final;
----------> finish x-yl training

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

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl 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           	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 DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	202.85690   	-58789853871.82121	443.80917   	0           
  10          	202.85788   	-231736086.01452	443.85818   	0           
  100         	93.81390    	-0.55038    	225.70984   	1           
  300         	104.70006   	-0.13858    	258.93347   	4           
  500         	109.14774   	-0.25271    	264.78320   	7           
  1000        	113.69784   	-0.54669    	278.30240   	14          
---> try to load best state
              	113.69784   	-0.54669    	278.30240   	14               eval state : test_on_restore;
              	113.69784   	-0.54669    	278.30240   	15               eval state : test_on_last_epoch;
---> final result
              	113.69784   	-0.54669    	278.30240   	15               eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 8
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	202.65057   	-25269226784.79773	436.32703   	0           
  10          	202.57193   	-4342148.90780	436.12662   	0           
  100         	62.16306    	0.79537     	149.71864   	1           
  300         	60.96743    	0.74041     	145.36729   	4           
  500         	62.61035    	0.77771     	144.72865   	8           
----------------------------------------

  Demo GAR 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
----------------------------------------

  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            	0           
  100         	0.02560     	0.55865     	0.04910     	14.70881           	7           
  300         	0.01266     	0.64301     	0.02177     	35.21103           	23          
  500         	0.01055     	0.65380     	0.01881     	46.62729           	39          
---> try to load best state
              	0.01244     	0.51002     	0.02038     	62.39934           	66               eval state : test_on_restore;
              	0.08499     	-1.40470    	0.12877     	117.27515          	66               eval state : test_on_last_epoch;
---> final result              	0.01244     	0.51002     	0.02038     	62.39934           	67               eval state : final;
----------> finish x-yl training


---------->
SGAR 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: True
  input_normalize: True
  output_normalize: True
  noise_init: 1.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	gaussian_loss      	time        
  1           	0.08674     	-62.79775   	0.16523     	0.11724            	1           
  10          	0.05700     	-1.42435    	0.10180     	-8.94446           	4           
  100         	0.03191     	0.54616     	0.04979     	-50.37658          	22          
----------------------------------------

  Demo NAR cigp 
  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': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.05078     	0.12395     	0.06357     	0           
  10          	0.02568     	0.05839     	0.76783     	0           
  100         	0.01395     	0.02793     	0.87345     	0           
  300         	0.01369     	0.02733     	0.87639     	2           
  500         	0.01379     	0.02764     	0.87668     	3           
  1000        	0.01398     	0.02822     	0.87699     	7           
---> try to load best state
              	0.01398     	0.02822     	0.87699     	7                eval state : test_on_restore;
              	0.01398     	0.02822     	0.87699     	7                eval state : test_on_last_epoch;
---> final result
              	0.01398     	0.02822     	0.87699     	7                eval state : final;
----------> finish x-yl training


---------->
NAR 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': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.10287     	0.20067     	-14452399049740654.00000	0           
  10          	0.10287     	0.20067     	-14452399049740654.00000	0           
  100         	0.10287     	0.20067     	-14452399049740654.00000	2           
  300         	0.10287     	0.20067     	-14452399049740654.00000	4           
  500         	0.10287     	0.20067     	-14452399049740654.00000	7           
  1000        	0.10287     	0.20067     	-14452399049740654.00000	13          
---> try to load best state
              	0.10287     	0.20067     	-14452399049740654.00000	13               eval state : test_on_restore;
              	0.10287     	0.20067     	-14452399049740654.00000	14               eval state : test_on_last_epoch;
---> final result
              	0.10287     	0.20067     	-14452399049740654.00000	14               eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR 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': ['np.concatenate([x[0],y[0]], axis=1)'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.09426     	0.18381     	-36392778581011248.00000	0           
----------------------------------------

  Demo DMFAL 
  seed: None 
  interp_data: True 

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

  Demo DMFAL 
  seed: None 
  interp_data: False 

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

  Demo DMFAL 
  seed: None 
  interp_data: False 

----------------------------------------
---> 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]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.10287     	-130033253649.20097	0.20067     	0           
  10          	0.10289     	-86742305.72578	0.20070     	1           
  100         	0.07948     	-43.36566   	0.16074     	12          
  300         	0.09086     	-6.83782    	0.17892     	34          
----------------------------------------

  Demo DMFAL 
  seed: None 
  interp_data: False 

----------------------------------------
---> 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]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.10287     	-48217752610.16337	0.20067     	0           
  10          	0.10283     	-59716184.81335	0.20060     	2           
  100         	0.08532     	-21.14289   	0.17292     	13          
  300         	0.09748     	-8.61871    	0.19014     	37          
----------------------------------------

  Demo cigp 
  seed: None 
  interp_data: False 

----------------------------------------
---> 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[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	63.13343    	156.71193   	0.83593     	0           
  10          	36.87385    	90.71107    	0.94932     	0           
  100         	15.79971    	38.90184    	0.99074     	0           
  300         	14.61545    	35.49615    	0.99218     	1           
  500         	14.38860    	34.66316    	0.99254     	2           
  1000        	14.46009    	34.40448    	0.99271     	4           
---> try to load best state
              	14.46009    	34.40448    	0.99271     	4                eval state : test_on_restore;
              	14.46009    	34.40448    	0.99271     	4                eval state : test_on_last_epoch;
---> final result
              	14.46009    	34.40448    	0.99271     	4                eval state : final;module_name : cigp;cp_record_file : True;
---> end

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

  Demo cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> 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[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	82.62383    	220.08998   	0.41295     	0           
  10          	41.89978    	112.52849   	0.91289     	0           
  100         	20.74999    	46.84942    	0.98525     	0           
  300         	19.59150    	43.89660    	0.98640     	1           
  500         	19.26440    	43.39375    	0.98653     	3           
  1000        	19.02967    	43.19144    	0.98655     	5           
---> try to load best state
              	19.02967    	43.19144    	0.98655     	5                eval state : test_on_restore;
              	19.02967    	43.19144    	0.98655     	5                eval state : test_on_last_epoch;
---> final result
              	19.02967    	43.19144    	0.98655     	5                eval state : final;module_name : cigp;cp_record_file : True;
---> end

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

  Demo cigp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> 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[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	73.47257    	180.56525   	0.67540     	0           
  10          	38.28290    	96.25652    	0.93005     	0           
  100         	21.02941    	56.26140    	0.97486     	0           
  300         	20.00013    	54.52683    	0.97635     	1           
  500         	19.53391    	53.57729    	0.97726     	2           
  1000        	18.86131    	51.96050    	0.97881     	4           
---> try to load best state
              	18.86131    	51.96050    	0.97881     	4                eval state : test_on_restore;
              	18.86131    	51.96050    	0.97881     	4                eval state : test_on_last_epoch;
---> final result
              	18.86131    	51.96050    	0.97881     	4                eval state : final;module_name : cigp;cp_record_file : True;
---> end

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

  Demo cigp 
  seed: 2 
  interp_data: False 

----------------------------------------
---> 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[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	71.49778    	203.14903   	0.61975     	0           
  10          	38.28015    	108.86745   	0.92138     	0           
  100         	22.42171    	56.31075    	0.97898     	0           
  300         	20.81431    	51.45928    	0.98202     	1           
  500         	20.11755    	49.48783    	0.98329     	2           
  1000        	19.23371    	47.10473    	0.98485     	4           
---> try to load best state
              	19.23371    	47.10473    	0.98485     	4                eval state : test_on_restore;
              	19.23371    	47.10473    	0.98485     	4                eval state : test_on_last_epoch;
---> final result
              	19.23371    	47.10473    	0.98485     	4                eval state : final;module_name : cigp;cp_record_file : True;
---> end

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

  Demo cigp 
  seed: 3 
  interp_data: False 

----------------------------------------
---> 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[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	78.99025    	204.18246   	0.51524     	0           
  10          	39.24823    	99.42223    	0.92829     	0           
  100         	19.66125    	49.52296    	0.98192     	0           
  300         	17.96850    	45.50288    	0.98448     	1           
  500         	17.42724    	44.09829    	0.98536     	2           
  1000        	16.94761    	42.58491    	0.98632     	5           
---> try to load best state
              	16.94761    	42.58491    	0.98632     	5                eval state : test_on_restore;
              	16.94761    	42.58491    	0.98632     	5                eval state : test_on_last_epoch;
---> final result
              	16.94761    	42.58491    	0.98632     	5                eval state : final;module_name : cigp;cp_record_file : True;
---> end

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

  Demo cigp 
  seed: 4 
  interp_data: False 

----------------------------------------
---> 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[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	62.28471    	149.77893   	0.86560     	0           
  10          	38.32797    	90.58087    	0.95359     	0           
  100         	20.21304    	52.88122    	0.98233     	0           
  300         	18.87074    	50.48159    	0.98369     	1           
  500         	18.40248    	49.31810    	0.98445     	2           
  1000        	17.90359    	47.62181    	0.98565     	4           
---> try to load best state
              	17.90359    	47.62181    	0.98565     	4                eval state : test_on_restore;
              	17.90359    	47.62181    	0.98565     	4                eval state : test_on_last_epoch;
---> final result
              	17.90359    	47.62181    	0.98565     	4                eval state : final;module_name : cigp;cp_record_file : True;
