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

  Demo res cigp 
  seed: None 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 64, '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.001, 'optional_param': 0.001, 'noise': 0.001}
  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: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	53.46056    	136.22884   	0.86429     	0           
  10          	53.06068    	135.07552   	0.86717     	0           
  100         	49.48153    	125.29778   	0.88946     	0           
  300         	44.43283    	112.62782   	0.91407     	2           
  500         	41.76944    	106.38201   	0.92481     	4           
  1000        	35.98731    	92.58617    	0.94495     	7           
---> try to load best state
              	35.98731    	92.58617    	0.94495     	7                eval state : test_on_restore;
              	35.98731    	92.58617    	0.94495     	7                eval state : test_on_last_epoch;
---> final result
              	35.98731    	92.58617    	0.94495     	7                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': 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': 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           	90.36595    	191.92963   	0.33851     	0           
  10          	87.05800    	186.37889   	0.39960     	0           
  100         	60.77729    	137.37862   	0.73730     	0           
  300         	48.27223    	111.77792   	0.85586     	0           
  500         	46.61035    	108.44289   	0.86975     	1           
  1000        	45.66836    	106.58798   	0.87732     	2           
---> try to load best state
              	45.66836    	106.58798   	0.87732     	2                eval state : test_on_restore;
              	45.66836    	106.58798   	0.87732     	2                eval state : test_on_last_epoch;
---> final result
              	45.66836    	106.58798   	0.87732     	2                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': 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': 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           	71.80466    	157.29430   	0.65465     	0           
  10          	67.43900    	149.22617   	0.69715     	0           
  100         	43.32611    	100.41847   	0.88524     	0           
  300         	39.71907    	96.12081    	0.90373     	0           
  500         	39.62431    	96.23173    	0.90269     	1           
  1000        	39.60418    	96.27386    	0.90230     	2           
---> try to load best state
              	39.60418    	96.27386    	0.90230     	2                eval state : test_on_restore;
              	39.60418    	96.27386    	0.90230     	2                eval state : test_on_last_epoch;
---> final result
              	39.60418    	96.27386    	0.90230     	2                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': 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': 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           	53.27847    	121.00987   	0.80831     	0           
  10          	49.34013    	114.30701   	0.83295     	0           
  100         	36.98688    	92.74068    	0.92317     	0           
  300         	36.94082    	93.37391    	0.90664     	1           
  500         	36.96827    	93.49006    	0.90476     	1           
  1000        	36.96790    	93.50327    	0.90457     	3           
---> try to load best state
              	36.96790    	93.50327    	0.90457     	3                eval state : test_on_restore;
              	36.96790    	93.50327    	0.90457     	3                eval state : test_on_last_epoch;
---> final result
              	36.96790    	93.50327    	0.90457     	3                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': 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': 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.47298    	99.57877    	0.87392     	0           
  10          	40.18838    	97.38274    	0.88091     	0           
  100         	36.25778    	91.76264    	0.91407     	0           
  300         	36.30667    	92.27896    	0.90289     	1           
  500         	36.36222    	92.44273    	0.90058     	2           
  1000        	36.38379    	92.51246    	0.89973     	4           
---> try to load best state
              	36.38379    	92.51246    	0.89973     	4                eval state : test_on_restore;
              	36.38379    	92.51246    	0.89973     	4                eval state : test_on_last_epoch;
---> final result
              	36.38379    	92.51246    	0.89973     	4                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 64, '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           	39.26236    	95.77027    	0.89273     	0           
  10          	38.39227    	94.46008    	0.89901     	0           
  100         	35.99603    	92.59363    	0.91299     	0           
  300         	36.37864    	93.32604    	0.90446     	2           
  500         	36.45742    	93.46876    	0.90240     	3           
  1000        	36.48940    	93.53725    	0.90146     	7           
---> try to load best state
              	36.48940    	93.53725    	0.90146     	7                eval state : test_on_restore;
              	36.48940    	93.53725    	0.90146     	7                eval state : test_on_last_epoch;
---> final result
              	36.48940    	93.53725    	0.90146     	7                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 64, '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.001, 'optional_param': 0.001, 'noise': 0.001}
  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: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	52.61123    	133.19896   	0.87289     	0           
  10          	52.22468    	132.01955   	0.87583     	0           
  100         	49.00703    	122.34389   	0.89751     	0           
  300         	44.56427    	110.44833   	0.91919     	2           
  500         	41.87788    	104.76004   	0.92818     	3           
  1000        	36.03321    	91.71634    	0.94647     	6           
---> try to load best state
              	36.03321    	91.71634    	0.94647     	6                eval state : test_on_restore;
              	36.03321    	91.71634    	0.94647     	6                eval state : test_on_last_epoch;
---> final result
              	36.03321    	91.71634    	0.94647     	6                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': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	84.15495    	176.09714   	0.52039     	0           
  10          	79.18755    	167.18393   	0.58389     	0           
  100         	47.83589    	108.34966   	0.86276     	0           
  300         	46.11236    	102.97976   	0.88920     	0           
  500         	46.31656    	103.12703   	0.88924     	0           
  1000        	46.65118    	103.63298   	0.88708     	1           
---> try to load best state
              	46.65118    	103.63298   	0.88708     	1                eval state : test_on_restore;
              	46.65118    	103.63298   	0.88708     	1                eval state : test_on_last_epoch;
---> final result
              	46.65118    	103.63298   	0.88708     	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': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.99211    	157.56960   	0.65127     	0           
  10          	68.72849    	147.99533   	0.69961     	0           
  100         	46.06757    	104.30871   	0.86725     	0           
  300         	44.05487    	101.18969   	0.87108     	0           
  500         	43.94492    	101.04679   	0.87031     	1           
  1000        	43.94510    	101.04272   	0.87016     	2           
---> try to load best state
              	43.94510    	101.04272   	0.87016     	2                eval state : test_on_restore;
              	43.94510    	101.04272   	0.87016     	2                eval state : test_on_last_epoch;
---> final result
              	43.94510    	101.04272   	0.87016     	2                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': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	55.91349    	128.44754   	0.80536     	0           
  10          	53.33991    	122.73361   	0.82673     	0           
  100         	40.75679    	98.85944    	0.90075     	0           
  300         	38.60710    	96.16711    	0.90771     	0           
  500         	38.50185    	96.05517    	0.90741     	1           
  1000        	38.49591    	96.06921    	0.90725     	2           
---> try to load best state
              	38.49591    	96.06921    	0.90725     	2                eval state : test_on_restore;
              	38.49591    	96.06921    	0.90725     	2                eval state : test_on_last_epoch;
---> final result
              	38.49591    	96.06921    	0.90725     	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': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	51.12783    	118.30415   	0.82610     	0           
  10          	47.70328    	111.54431   	0.84888     	0           
  100         	36.46268    	91.94247    	0.92458     	0           
  300         	36.52396    	91.92118    	0.91260     	1           
  500         	36.61871    	92.07150    	0.90966     	2           
  1000        	36.64650    	92.12913    	0.90871     	4           
---> try to load best state
              	36.64650    	92.12913    	0.90871     	4                eval state : test_on_restore;
              	36.64650    	92.12913    	0.90871     	4                eval state : test_on_last_epoch;
---> final result
              	36.64650    	92.12913    	0.90871     	4                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 64, '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           	39.85233    	95.52025    	0.88967     	0           
  10          	39.06133    	94.28230    	0.89286     	0           
  100         	36.50591    	92.18970    	0.91342     	0           
  300         	36.72293    	92.76001    	0.90815     	2           
  500         	36.76508    	92.89947    	0.90634     	3           
  1000        	36.78687    	92.96874    	0.90550     	7           
---> try to load best state
              	36.78687    	92.96874    	0.90550     	7                eval state : test_on_restore;
              	36.78687    	92.96874    	0.90550     	7                eval state : test_on_last_epoch;
---> final result
              	36.78687    	92.96874    	0.90550     	7                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 64, '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.001, 'optional_param': 0.001, 'noise': 0.001}
  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: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	58.51264    	150.86597   	0.81905     	0           
  10          	58.01769    	149.51288   	0.82324     	0           
  100         	53.82416    	138.03043   	0.85542     	0           
  300         	48.32969    	123.44357   	0.88883     	1           
  500         	45.59203    	116.82271   	0.90171     	3           
  1000        	39.54088    	102.15575   	0.92729     	6           
---> try to load best state
              	39.54088    	102.15575   	0.92729     	6                eval state : test_on_restore;
              	39.54088    	102.15575   	0.92729     	6                eval state : test_on_last_epoch;
---> final result
              	39.54088    	102.15575   	0.92729     	6                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': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.95422    	190.64880   	0.36795     	0           
  10          	83.95503    	184.47636   	0.43976     	0           
  100         	55.17128    	128.08199   	0.79149     	0           
  300         	50.90615    	115.99648   	0.84814     	0           
  500         	50.88686    	115.59422   	0.85001     	0           
  1000        	50.98293    	115.53203   	0.85030     	1           
---> try to load best state
              	50.98293    	115.53203   	0.85030     	1                eval state : test_on_restore;
              	50.98293    	115.53203   	0.85030     	1                eval state : test_on_last_epoch;
---> final result
              	50.98293    	115.53203   	0.85030     	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': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	84.71984    	188.94585   	0.40007     	0           
  10          	81.15434    	183.83078   	0.45551     	0           
  100         	55.16658    	131.66199   	0.77201     	0           
  300         	42.00075    	104.39576   	0.89232     	0           
  500         	41.30810    	103.49014   	0.89328     	1           
  1000        	41.00583    	103.19235   	0.89045     	2           
---> try to load best state
              	41.00583    	103.19235   	0.89045     	2                eval state : test_on_restore;
              	41.00583    	103.19235   	0.89045     	2                eval state : test_on_last_epoch;
---> final result
              	41.00583    	103.19235   	0.89045     	2                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': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	57.84741    	134.42540   	0.77251     	0           
  10          	54.32296    	127.30669   	0.80153     	0           
  100         	40.28665    	101.52713   	0.90428     	0           
  300         	39.81361    	102.40726   	0.89250     	0           
  500         	39.92858    	102.72618   	0.88815     	1           
  1000        	39.99331    	102.88760   	0.88593     	2           
---> try to load best state
              	39.99331    	102.88760   	0.88593     	2                eval state : test_on_restore;
              	39.99331    	102.88760   	0.88593     	2                eval state : test_on_last_epoch;
---> final result
              	39.99331    	102.88760   	0.88593     	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': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	47.40223    	115.26405   	0.83738     	0           
  10          	45.29379    	111.19683   	0.85321     	0           
  100         	39.98937    	103.62631   	0.89338     	0           
  300         	40.19329    	104.11914   	0.87844     	1           
  500         	40.25881    	104.23541   	0.87640     	2           
  1000        	40.29842    	104.32643   	0.87538     	4           
---> try to load best state
              	40.29842    	104.32643   	0.87538     	4                eval state : test_on_restore;
              	40.29842    	104.32643   	0.87538     	4                eval state : test_on_last_epoch;
---> final result
              	40.29842    	104.32643   	0.87538     	4                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 64, '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.03537    	106.12428   	0.86576     	0           
  10          	42.07107    	104.58880   	0.87288     	0           
  100         	39.82045    	103.48011   	0.88022     	0           
  300         	40.31919    	104.74567   	0.86913     	2           
  500         	40.37653    	104.87195   	0.86690     	3           
  1000        	40.40065    	104.93808   	0.86598     	7           
---> try to load best state
              	40.40065    	104.93808   	0.86598     	7                eval state : test_on_restore;
              	40.40065    	104.93808   	0.86598     	7                eval state : test_on_last_epoch;
---> final result
              	40.40065    	104.93808   	0.86598     	7                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 2 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 64, '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.001, 'optional_param': 0.001, 'noise': 0.001}
  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: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	63.15240    	176.22296   	0.74257     	0           
  10          	62.63614    	174.83255   	0.74817     	0           
  100         	58.24139    	162.78555   	0.79169     	0           
  300         	52.33691    	145.70906   	0.84120     	1           
  500         	49.08754    	136.23416   	0.86413     	3           
  1000        	42.07421    	116.97044   	0.90426     	6           
---> try to load best state
              	42.07421    	116.97044   	0.90426     	6                eval state : test_on_restore;
              	42.07421    	116.97044   	0.90426     	6                eval state : test_on_last_epoch;
---> final result
              	42.07421    	116.97044   	0.90426     	6                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': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	106.80016   	220.97095   	-0.15455    	0           
  10          	105.93098   	219.79179   	-0.08545    	0           
  100         	93.43511    	201.26462   	0.37172     	0           
  300         	70.87714    	162.29968   	0.66087     	0           
  500         	61.60234    	145.62282   	0.73838     	0           
  1000        	54.14049    	132.38142   	0.79574     	1           
---> try to load best state
              	54.14049    	132.38142   	0.79574     	1                eval state : test_on_restore;
              	54.14049    	132.38142   	0.79574     	1                eval state : test_on_last_epoch;
---> final result
              	54.14049    	132.38142   	0.79574     	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': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.09860    	200.17755   	0.36196     	0           
  10          	88.05623    	195.37086   	0.42334     	0           
  100         	59.48331    	142.16925   	0.77024     	0           
  300         	48.22074    	123.11733   	0.83863     	0           
  500         	47.39939    	122.04046   	0.83866     	1           
  1000        	47.22605    	121.83755   	0.83809     	2           
---> try to load best state
              	47.22605    	121.83755   	0.83809     	2                eval state : test_on_restore;
              	47.22605    	121.83755   	0.83809     	2                eval state : test_on_last_epoch;
---> final result
              	47.22605    	121.83755   	0.83809     	2                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': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.09052    	168.47832   	0.63825     	0           
  10          	68.86901    	161.33359   	0.68027     	0           
  100         	44.82806    	119.87228   	0.85756     	0           
  300         	44.52024    	119.79053   	0.82440     	0           
  500         	44.80667    	120.22669   	0.81747     	1           
  1000        	44.92117    	120.40907   	0.81482     	3           
---> try to load best state
              	44.92117    	120.40907   	0.81482     	3                eval state : test_on_restore;
              	44.92117    	120.40907   	0.81482     	3                eval state : test_on_last_epoch;
---> final result
              	44.92117    	120.40907   	0.81482     	3                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': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.33159    	138.76088   	0.77061     	0           
  10          	53.25231    	133.64099   	0.79185     	0           
  100         	42.38691    	116.88438   	0.85612     	0           
  300         	42.62579    	116.94495   	0.83213     	1           
  500         	42.68473    	117.08463   	0.82872     	2           
  1000        	42.69997    	117.13163   	0.82742     	4           
---> try to load best state
              	42.69997    	117.13163   	0.82742     	4                eval state : test_on_restore;
              	42.69997    	117.13163   	0.82742     	4                eval state : test_on_last_epoch;
---> final result
              	42.69997    	117.13163   	0.82742     	4                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 64, '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           	46.39949    	122.20742   	0.83545     	0           
  10          	45.25962    	120.22864   	0.84439     	0           
  100         	42.12265    	116.18419   	0.85202     	0           
  300         	42.37600    	116.75491   	0.83622     	2           
  500         	42.42860    	116.90833   	0.83322     	3           
  1000        	42.45095    	116.97367   	0.83207     	7           
---> try to load best state
              	42.45095    	116.97367   	0.83207     	7                eval state : test_on_restore;
              	42.45095    	116.97367   	0.83207     	7                eval state : test_on_last_epoch;
---> final result
              	42.45095    	116.97367   	0.83207     	7                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 3 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 64, '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.001, 'optional_param': 0.001, 'noise': 0.001}
  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: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	59.84759    	148.10597   	0.83536     	0           
  10          	59.39468    	146.89270   	0.83882     	0           
  100         	55.25026    	136.34229   	0.86603     	0           
  300         	48.98098    	121.60396   	0.89738     	2           
  500         	45.46777    	113.59148   	0.91188     	3           
  1000        	38.59393    	97.41632    	0.93721     	6           
---> try to load best state
              	38.59393    	97.41632    	0.93721     	6                eval state : test_on_restore;
              	38.59393    	97.41632    	0.93721     	6                eval state : test_on_last_epoch;
---> final result
              	38.59393    	97.41632    	0.93721     	6                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': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	99.05886    	207.39494   	-0.03102    	0           
  10          	97.69049    	205.37453   	0.01369     	0           
  100         	84.91933    	184.65004   	0.31377     	0           
  300         	71.16780    	158.61781   	0.50234     	0           
  500         	64.95044    	145.48859   	0.58476     	0           
  1000        	57.51756    	129.39702   	0.69803     	1           
---> try to load best state
              	57.51756    	129.39702   	0.69803     	2                eval state : test_on_restore;
              	57.51756    	129.39702   	0.69803     	2                eval state : test_on_last_epoch;
---> final result
              	57.51756    	129.39702   	0.69803     	2                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': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	80.62527    	175.58775   	0.44643     	0           
  10          	74.52866    	164.97784   	0.54280     	0           
  100         	45.07602    	105.34409   	0.88411     	0           
  300         	43.49641    	101.83747   	0.89517     	0           
  500         	43.39254    	101.61550   	0.89528     	1           
  1000        	43.35360    	101.53451   	0.89529     	2           
---> try to load best state
              	43.35360    	101.53451   	0.89529     	2                eval state : test_on_restore;
              	43.35360    	101.53451   	0.89529     	2                eval state : test_on_last_epoch;
---> final result
              	43.35360    	101.53451   	0.89529     	2                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': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.81998    	134.80458   	0.75232     	0           
  10          	54.34250    	126.38493   	0.79236     	0           
  100         	40.79934    	99.09019    	0.89999     	0           
  300         	39.33714    	97.00159    	0.90466     	0           
  500         	39.23386    	96.86076    	0.90441     	1           
  1000        	39.21898    	96.85123    	0.90430     	2           
---> try to load best state
              	39.21898    	96.85123    	0.90430     	2                eval state : test_on_restore;
              	39.21898    	96.85123    	0.90430     	2                eval state : test_on_last_epoch;
---> final result
              	39.21898    	96.85123    	0.90430     	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': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	48.90699    	116.01354   	0.83852     	0           
  10          	46.22111    	109.86637   	0.85908     	0           
  100         	38.26374    	95.28973    	0.91786     	0           
  300         	38.56682    	96.01044    	0.90747     	1           
  500         	38.61059    	96.13937    	0.90491     	1           
  1000        	38.63135    	96.20522    	0.90363     	3           
---> try to load best state
              	38.63135    	96.20522    	0.90363     	3                eval state : test_on_restore;
              	38.63135    	96.20522    	0.90363     	3                eval state : test_on_last_epoch;
---> final result
              	38.63135    	96.20522    	0.90363     	3                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 64, '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.69497    	100.81950   	0.88195     	0           
  10          	40.90635    	99.52127    	0.88842     	0           
  100         	38.55267    	97.14956    	0.90159     	0           
  300         	38.91768    	97.80075    	0.89113     	2           
  500         	38.98795    	97.92389    	0.88886     	3           
  1000        	39.01342    	97.98080    	0.88789     	7           
---> try to load best state
              	39.01342    	97.98080    	0.88789     	7                eval state : test_on_restore;
              	39.01342    	97.98080    	0.88789     	7                eval state : test_on_last_epoch;
---> final result
              	39.01342    	97.98080    	0.88789     	7                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 4 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 64, '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.001, 'optional_param': 0.001, 'noise': 0.001}
  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: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	53.09381    	136.35614   	0.86075     	0           
  10          	52.68904    	135.19226   	0.86376     	0           
  100         	49.35825    	125.51224   	0.88666     	0           
  300         	44.78922    	113.32309   	0.91104     	1           
  500         	42.15400    	107.15361   	0.92186     	3           
  1000        	36.47205    	93.26900    	0.94284     	6           
---> try to load best state
              	36.47205    	93.26900    	0.94284     	6                eval state : test_on_restore;
              	36.47205    	93.26900    	0.94284     	6                eval state : test_on_last_epoch;
---> final result
              	36.47205    	93.26900    	0.94284     	6                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': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	103.66875   	212.68581   	-0.05246    	0           
  10          	103.01087   	211.91278   	-0.01552    	0           
  100         	89.10538    	189.12990   	0.40901     	0           
  300         	72.03049    	156.12465   	0.64402     	0           
  500         	66.08800    	144.44579   	0.70061     	1           
  1000        	62.36390    	137.16147   	0.73264     	2           
---> try to load best state
              	62.36390    	137.16147   	0.73264     	2                eval state : test_on_restore;
              	62.36390    	137.16147   	0.73264     	2                eval state : test_on_last_epoch;
---> final result
              	62.36390    	137.16147   	0.73264     	2                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': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	65.10709    	144.65218   	0.70279     	0           
  10          	60.09285    	135.04645   	0.75255     	0           
  100         	41.11663    	98.25114    	0.89719     	0           
  300         	39.14439    	96.35995    	0.90167     	0           
  500         	39.09391    	96.49780    	0.89984     	1           
  1000        	39.09204    	96.56248    	0.89915     	2           
---> try to load best state
              	39.09204    	96.56248    	0.89915     	2                eval state : test_on_restore;
              	39.09204    	96.56248    	0.89915     	2                eval state : test_on_last_epoch;
---> final result
              	39.09204    	96.56248    	0.89915     	2                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': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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           	55.75188    	129.29391   	0.79503     	0           
  10          	52.65434    	122.83975   	0.81912     	0           
  100         	40.29102    	96.55507    	0.90503     	0           
  300         	38.46446    	94.72086    	0.90781     	0           
  500         	38.38440    	94.68097    	0.90728     	1           
  1000        	38.37619    	94.67497    	0.90718     	2           
---> try to load best state
              	38.37619    	94.67497    	0.90718     	2                eval state : test_on_restore;
              	38.37619    	94.67497    	0.90718     	2                eval state : test_on_last_epoch;
---> final result
              	38.37619    	94.67497    	0.90718     	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': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.01743    	102.35362   	0.86295     	0           
  10          	41.50973    	99.48219    	0.87091     	0           
  100         	37.23290    	93.43945    	0.90424     	0           
  300         	37.43940    	94.19925    	0.89807     	1           
  500         	37.52073    	94.40710    	0.89642     	1           
  1000        	37.54580    	94.48006    	0.89576     	3           
---> try to load best state
              	37.54580    	94.48006    	0.89576     	3                eval state : test_on_restore;
              	37.54580    	94.48006    	0.89576     	3                eval state : test_on_last_epoch;
---> final result
              	37.54580    	94.48006    	0.89576     	3                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 64, '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           	40.06061    	96.96166    	0.88718     	0           
  10          	39.35816    	95.85538    	0.89283     	0           
  100         	36.68651    	93.47219    	0.91007     	0           
  300         	37.02058    	94.19933    	0.90032     	2           
  500         	37.09331    	94.36019    	0.89806     	3           
  1000        	37.12573    	94.43982    	0.89700     	7           
---> try to load best state
              	37.12573    	94.43982    	0.89700     	7                eval state : test_on_restore;
              	37.12573    	94.43982    	0.89700     	7                eval state : test_on_last_epoch;
---> final result
              	37.12573    	94.43982    	0.89700     	7                eval state : final;module_name : ResGP;cp_record_file : True;
