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

  Demo res cigp 
  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]'], '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           	64.68929    	160.13614   	0.83152     	0           
  10          	37.51498    	92.08133    	0.94846     	0           
  100         	15.88540    	38.70943    	0.99092     	0           
  300         	14.42441    	34.62028    	0.99261     	1           
  500         	14.09064    	33.55347    	0.99304     	2           
  1000        	14.01570    	33.06474    	0.99327     	4           
---> try to load best state
              	14.01570    	33.06474    	0.99327     	4                eval state : test_on_restore;
              	14.01570    	33.06474    	0.99327     	4                eval state : test_on_last_epoch;
---> final result
              	14.01570    	33.06474    	0.99327     	4                eval state : final;
----------> finish x-yl training


---------->
res cigp for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, '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': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	78.84667    	175.65997   	0.45532     	0           
  10          	75.26909    	169.59085   	0.50837     	0           
  100         	46.22095    	112.55424   	0.80554     	0           
  300         	32.75453    	76.96663    	0.90839     	0           
  500         	30.94359    	71.49531    	0.92053     	0           
  1000        	29.89735    	68.28088    	0.92725     	1           
---> try to load best state
              	29.89735    	68.28088    	0.92725     	1                eval state : test_on_restore;
              	29.89735    	68.28088    	0.92725     	1                eval state : test_on_last_epoch;
---> final result
              	29.89735    	68.28088    	0.92725     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, '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': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	58.07357    	135.87953   	0.72777     	0           
  10          	53.30914    	126.36468   	0.76506     	0           
  100         	26.11187    	57.74739    	0.93253     	0           
  300         	20.93030    	46.55948    	0.95563     	0           
  500         	20.77146    	46.51689    	0.95610     	1           
  1000        	20.73785    	46.53010    	0.95617     	3           
---> try to load best state
              	20.73785    	46.53010    	0.95617     	3                eval state : test_on_restore;
              	20.73785    	46.53010    	0.95617     	3                eval state : test_on_last_epoch;
---> final result
              	20.73785    	46.53010    	0.95617     	3                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, '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': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	37.67235    	89.90500    	0.86545     	0           
  10          	33.03988    	80.21707    	0.88746     	0           
  100         	16.55778    	37.11220    	0.98002     	0           
  300         	15.63842    	36.16909    	0.98618     	0           
  500         	15.65186    	36.25626    	0.98587     	1           
  1000        	15.65199    	36.26495    	0.98563     	1           
---> try to load best state
              	15.65199    	36.26495    	0.98563     	1                eval state : test_on_restore;
              	15.65199    	36.26495    	0.98563     	1                eval state : test_on_last_epoch;
---> final result
              	15.65199    	36.26495    	0.98563     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 32 samples
---> Training x,yl -> yh part

---> 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]', 'y[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.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, '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
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	24.23580    	56.34005    	0.92872     	0           
  10          	22.31328    	51.66230    	0.93719     	0           
  100         	14.75373    	33.83713    	0.98835     	0           
  300         	14.52406    	34.28038    	0.99179     	1           
  500         	14.64382    	34.57332    	0.99127     	2           
  1000        	14.68242    	34.67004    	0.99109     	4           
---> try to load best state
              	14.68242    	34.67004    	0.99109     	4                eval state : test_on_restore;
              	14.68242    	34.67004    	0.99109     	4                eval state : test_on_last_epoch;
---> final result
              	14.68242    	34.67004    	0.99109     	4                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  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]'], '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           	84.55990    	224.30556   	0.39694     	0           
  10          	42.56939    	114.93116   	0.91147     	0           
  100         	21.72644    	49.43461    	0.98401     	0           
  300         	20.28494    	45.09462    	0.98590     	1           
  500         	19.87243    	44.03842    	0.98628     	2           
  1000        	19.54061    	43.34706    	0.98651     	4           
---> try to load best state
              	19.54061    	43.34706    	0.98651     	4                eval state : test_on_restore;
              	19.54061    	43.34706    	0.98651     	4                eval state : test_on_last_epoch;
---> final result
              	19.54061    	43.34706    	0.98651     	4                eval state : final;
----------> finish x-yl training


---------->
res cigp for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	73.39788    	159.93533   	0.59841     	0           
  10          	67.98689    	149.81174   	0.65717     	0           
  100         	33.64676    	74.74587    	0.91155     	0           
  300         	31.86991    	65.07435    	0.93462     	0           
  500         	31.92433    	64.82822    	0.93515     	0           
  1000        	32.00301    	65.25997    	0.93388     	1           
---> try to load best state
              	32.00301    	65.25997    	0.93388     	1                eval state : test_on_restore;
              	32.00301    	65.25997    	0.93388     	1                eval state : test_on_last_epoch;
---> final result
              	32.00301    	65.25997    	0.93388     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	62.01204    	138.76315   	0.72072     	0           
  10          	56.30414    	127.53975   	0.76524     	0           
  100         	31.65662    	67.53899    	0.92111     	0           
  300         	29.12225    	60.88430    	0.93112     	0           
  500         	28.95648    	60.49788    	0.93137     	0           
  1000        	28.95319    	60.48164    	0.93133     	1           
---> try to load best state
              	28.95319    	60.48164    	0.93133     	1                eval state : test_on_restore;
              	28.95319    	60.48164    	0.93133     	1                eval state : test_on_last_epoch;
---> final result
              	28.95319    	60.48164    	0.93133     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	43.47617    	105.09418   	0.85462     	0           
  10          	40.66108    	97.51708    	0.87406     	0           
  100         	25.71513    	57.34064    	0.94914     	0           
  300         	22.74943    	50.83518    	0.96537     	0           
  500         	22.53889    	50.44987    	0.96654     	1           
  1000        	22.50123    	50.37707    	0.96677     	2           
---> try to load best state
              	22.50123    	50.37707    	0.96677     	2                eval state : test_on_restore;
              	22.50123    	50.37707    	0.96677     	2                eval state : test_on_last_epoch;
---> final result
              	22.50123    	50.37707    	0.96677     	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 32 samples
---> Training x,yl -> yh part

---> 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]', 'y[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.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, '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
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	38.18782    	92.05139    	0.87417     	0           
  10          	34.49862    	82.63610    	0.89514     	0           
  100         	20.34785    	44.74657    	0.97528     	0           
  300         	19.63407    	43.81147    	0.98479     	1           
  500         	19.68595    	44.01130    	0.98512     	2           
  1000        	19.68536    	44.03871    	0.98525     	5           
---> try to load best state
              	19.68536    	44.03871    	0.98525     	5                eval state : test_on_restore;
              	19.68536    	44.03871    	0.98525     	5                eval state : test_on_last_epoch;
---> final result
              	19.68536    	44.03871    	0.98525     	5                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 1 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': 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           	75.99600    	184.52997   	0.65714     	0           
  10          	38.91063    	95.88019    	0.93148     	0           
  100         	20.92976    	53.67852    	0.97633     	0           
  300         	19.67145    	51.19997    	0.97837     	1           
  500         	19.06485    	49.89431    	0.97955     	2           
  1000        	18.18255    	47.84325    	0.98140     	4           
---> try to load best state
              	18.18255    	47.84325    	0.98140     	4                eval state : test_on_restore;
              	18.18255    	47.84325    	0.98140     	4                eval state : test_on_last_epoch;
---> final result
              	18.18255    	47.84325    	0.98140     	4                eval state : final;
----------> finish x-yl training


---------->
res cigp for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	76.61143    	173.65248   	0.48647     	0           
  10          	72.40764    	166.87218   	0.54919     	0           
  100         	41.28078    	98.94273    	0.85934     	0           
  300         	37.02643    	80.80419    	0.90667     	0           
  500         	36.89179    	79.93567    	0.90812     	0           
  1000        	36.87162    	79.67155    	0.90830     	1           
---> try to load best state
              	36.87162    	79.67155    	0.90830     	1                eval state : test_on_restore;
              	36.87162    	79.67155    	0.90830     	1                eval state : test_on_last_epoch;
---> final result
              	36.87162    	79.67155    	0.90830     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	73.16138    	171.71271   	0.51662     	0           
  10          	69.39929    	166.14908   	0.56432     	0           
  100         	40.67791    	103.94624   	0.84228     	0           
  300         	24.28161    	56.77329    	0.94792     	0           
  500         	23.03113    	53.77774    	0.95227     	0           
  1000        	22.25514    	52.21338    	0.95390     	1           
---> try to load best state
              	22.25514    	52.21338    	0.95390     	1                eval state : test_on_restore;
              	22.25514    	52.21338    	0.95390     	1                eval state : test_on_last_epoch;
---> final result
              	22.25514    	52.21338    	0.95390     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	42.82425    	106.46457   	0.83953     	0           
  10          	38.80944    	96.88435    	0.86472     	0           
  100         	20.99537    	50.83963    	0.96031     	0           
  300         	18.91787    	48.92284    	0.97429     	0           
  500         	18.85171    	49.15646    	0.97471     	1           
  1000        	18.84159    	49.31226    	0.97478     	1           
---> try to load best state
              	18.84159    	49.31226    	0.97478     	1                eval state : test_on_restore;
              	18.84159    	49.31226    	0.97478     	2                eval state : test_on_last_epoch;
---> final result
              	18.84159    	49.31226    	0.97478     	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	30.23940    	78.23100    	0.89800     	0           
  10          	27.47868    	71.24138    	0.91205     	0           
  100         	18.90486    	49.25340    	0.97338     	0           
  300         	18.17114    	49.23898    	0.98072     	1           
  500         	18.17368    	49.40935    	0.98093     	2           
  1000        	18.19601    	49.53154    	0.98093     	4           
---> try to load best state
              	18.19601    	49.53154    	0.98093     	4                eval state : test_on_restore;
              	18.19601    	49.53154    	0.98093     	4                eval state : test_on_last_epoch;
---> final result
              	18.19601    	49.53154    	0.98093     	4                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 2 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': 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.56605    	207.01630   	0.61547     	0           
  10          	39.70878    	111.36401   	0.91968     	0           
  100         	23.80297    	59.13639    	0.97571     	0           
  300         	22.11681    	53.95059    	0.97915     	1           
  500         	21.36058    	51.80280    	0.98062     	2           
  1000        	20.34916    	49.10175    	0.98250     	4           
---> try to load best state
              	20.34916    	49.10175    	0.98250     	4                eval state : test_on_restore;
              	20.34916    	49.10175    	0.98250     	4                eval state : test_on_last_epoch;
---> final result
              	20.34916    	49.10175    	0.98250     	4                eval state : final;
----------> finish x-yl training


---------->
res cigp for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	91.82359    	196.90707   	0.15932     	0           
  10          	90.95804    	195.59607   	0.20603     	0           
  100         	78.03732    	174.22888   	0.54701     	0           
  300         	54.19892    	125.46442   	0.78066     	0           
  500         	44.07743    	102.09811   	0.84461     	0           
  1000        	35.66150    	80.95013    	0.89310     	1           
---> try to load best state
              	35.66150    	80.95013    	0.89310     	1                eval state : test_on_restore;
              	35.66150    	80.95013    	0.89310     	1                eval state : test_on_last_epoch;
---> final result
              	35.66150    	80.95013    	0.89310     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	75.41269    	173.26360   	0.54128     	0           
  10          	72.12878    	167.65134   	0.58938     	0           
  100         	41.60341    	97.97693    	0.86817     	0           
  300         	27.77502    	63.66809    	0.93404     	0           
  500         	26.51181    	60.99787    	0.93781     	0           
  1000        	26.22295    	60.43396    	0.93846     	1           
---> try to load best state
              	26.22295    	60.43396    	0.93846     	1                eval state : test_on_restore;
              	26.22295    	60.43396    	0.93846     	1                eval state : test_on_last_epoch;
---> final result
              	26.22295    	60.43396    	0.93846     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	56.49497    	134.50183   	0.76002     	0           
  10          	51.87385    	125.14129   	0.79395     	0           
  100         	23.88317    	56.96805    	0.95316     	0           
  300         	21.78001    	53.37692    	0.95395     	0           
  500         	21.95562    	54.00263    	0.95032     	1           
  1000        	22.04460    	54.26394    	0.94881     	1           
---> try to load best state
              	22.04460    	54.26394    	0.94881     	1                eval state : test_on_restore;
              	22.04460    	54.26394    	0.94881     	1                eval state : test_on_last_epoch;
---> final result
              	22.04460    	54.26394    	0.94881     	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	37.67995    	91.45982    	0.87095     	0           
  10          	34.17631    	82.91781    	0.88928     	0           
  100         	20.04722    	47.16543    	0.97458     	0           
  300         	18.81646    	45.97553    	0.98551     	1           
  500         	18.80320    	46.05160    	0.98566     	2           
  1000        	18.80637    	46.07967    	0.98566     	5           
---> try to load best state
              	18.80637    	46.07967    	0.98566     	5                eval state : test_on_restore;
              	18.80637    	46.07967    	0.98566     	5                eval state : test_on_last_epoch;
---> final result
              	18.80637    	46.07967    	0.98566     	5                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 3 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': 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.30335    	209.08717   	0.49110     	0           
  10          	40.74389    	103.61861   	0.92066     	0           
  100         	20.48189    	52.16479    	0.97915     	0           
  300         	18.57152    	47.49986    	0.98233     	1           
  500         	17.90269    	45.80355    	0.98346     	2           
  1000        	17.21288    	43.91983    	0.98472     	4           
---> try to load best state
              	17.21288    	43.91983    	0.98472     	4                eval state : test_on_restore;
              	17.21288    	43.91983    	0.98472     	4                eval state : test_on_last_epoch;
---> final result
              	17.21288    	43.91983    	0.98472     	4                eval state : final;
----------> finish x-yl training


---------->
res cigp for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	87.51578    	192.70358   	0.08357     	0           
  10          	86.01694    	190.54515   	0.12491     	0           
  100         	72.01694    	167.52681   	0.40260     	0           
  300         	57.05019    	137.46806   	0.57723     	0           
  500         	50.10075    	121.66400   	0.65312     	0           
  1000        	41.78551    	101.21372   	0.75706     	1           
---> try to load best state
              	41.78551    	101.21372   	0.75706     	1                eval state : test_on_restore;
              	41.78551    	101.21372   	0.75706     	1                eval state : test_on_last_epoch;
---> final result
              	41.78551    	101.21372   	0.75706     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	68.03574    	158.17085   	0.52382     	0           
  10          	61.41315    	146.23781   	0.61258     	0           
  100         	28.19594    	67.66822    	0.92772     	0           
  300         	25.69136    	61.03189    	0.94011     	0           
  500         	25.45794    	60.52241    	0.94078     	0           
  1000        	25.36617    	60.33709    	0.94103     	1           
---> try to load best state
              	25.36617    	60.33709    	0.94103     	1                eval state : test_on_restore;
              	25.36617    	60.33709    	0.94103     	1                eval state : test_on_last_epoch;
---> final result
              	25.36617    	60.33709    	0.94103     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	43.78427    	108.56733   	0.80538     	0           
  10          	38.58280    	97.44740    	0.84297     	0           
  100         	21.60303    	50.88598    	0.95238     	0           
  300         	19.30201    	45.55516    	0.96532     	0           
  500         	19.09350    	45.12771    	0.96649     	1           
  1000        	19.05106    	45.04857    	0.96676     	2           
---> try to load best state
              	19.05106    	45.04857    	0.96676     	2                eval state : test_on_restore;
              	19.05106    	45.04857    	0.96676     	2                eval state : test_on_last_epoch;
---> final result
              	19.05106    	45.04857    	0.96676     	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	32.31636    	83.90698    	0.88716     	0           
  10          	29.08493    	74.48957    	0.90722     	0           
  100         	17.37096    	43.03914    	0.98043     	0           
  300         	16.87737    	42.49414    	0.98631     	1           
  500         	16.91257    	42.56952    	0.98629     	2           
  1000        	16.94581    	42.60987    	0.98622     	5           
---> try to load best state
              	16.94581    	42.60987    	0.98622     	5                eval state : test_on_restore;
              	16.94581    	42.60987    	0.98622     	5                eval state : test_on_last_epoch;
---> final result
              	16.94581    	42.60987    	0.98622     	5                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 4 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': 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           	64.41850    	154.16219   	0.85957     	0           
  10          	39.27601    	92.11664    	0.95262     	0           
  100         	20.77731    	51.66080    	0.98297     	0           
  300         	19.24681    	48.48490    	0.98477     	1           
  500         	18.68410    	47.14214    	0.98561     	2           
  1000        	18.06490    	45.44364    	0.98672     	4           
---> try to load best state
              	18.06490    	45.44364    	0.98672     	4                eval state : test_on_restore;
              	18.06490    	45.44364    	0.98672     	4                eval state : test_on_last_epoch;
---> final result
              	18.06490    	45.44364    	0.98672     	4                eval state : final;
----------> finish x-yl training


---------->
res cigp for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	92.20224    	197.05313   	0.14126     	0           
  10          	91.54709    	196.21028   	0.17086     	0           
  100         	77.50595    	171.58226   	0.52495     	0           
  300         	59.57393    	134.29153   	0.73025     	0           
  500         	53.21164    	120.36713   	0.77997     	0           
  1000        	49.17078    	111.38776   	0.80811     	1           
---> try to load best state
              	49.17078    	111.38776   	0.80811     	1                eval state : test_on_restore;
              	49.17078    	111.38776   	0.80811     	1                eval state : test_on_last_epoch;
---> final result
              	49.17078    	111.38776   	0.80811     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	52.47729    	122.40144   	0.77570     	0           
  10          	47.35011    	111.05573   	0.81790     	0           
  100         	26.70658    	59.83726    	0.94223     	0           
  300         	23.46894    	54.68664    	0.95610     	0           
  500         	23.27760    	54.65126    	0.95675     	0           
  1000        	23.24491    	54.68225    	0.95684     	1           
---> try to load best state
              	23.24491    	54.68225    	0.95684     	1                eval state : test_on_restore;
              	23.24491    	54.68225    	0.95684     	1                eval state : test_on_last_epoch;
---> final result
              	23.24491    	54.68225    	0.95684     	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	41.37765    	101.95429   	0.85371     	0           
  10          	38.06272    	93.60973    	0.87457     	0           
  100         	23.60202    	54.16034    	0.95468     	0           
  300         	20.95523    	50.34612    	0.96637     	0           
  500         	20.79432    	50.20291    	0.96702     	1           
  1000        	20.77285    	50.18857    	0.96711     	1           
---> try to load best state
              	20.77285    	50.18857    	0.96711     	1                eval state : test_on_restore;
              	20.77285    	50.18857    	0.96711     	1                eval state : test_on_last_epoch;
---> final result
              	20.77285    	50.18857    	0.96711     	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


---------->
res cigp for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, '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}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	27.33093    	63.96175    	0.92286     	0           
  10          	25.52483    	59.11725    	0.93135     	0           
  100         	18.59364    	46.21812    	0.98081     	0           
  300         	17.77427    	46.43698    	0.98630     	1           
  500         	17.77739    	46.63453    	0.98622     	2           
  1000        	17.78818    	46.71353    	0.98616     	5           
---> try to load best state
              	17.78818    	46.71353    	0.98616     	5                eval state : test_on_restore;
              	17.78818    	46.71353    	0.98616     	5                eval state : test_on_last_epoch;
---> final result
              	17.78818    	46.71353    	0.98616     	5                eval state : final;module_name : ResGP;cp_record_file : True;
