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

  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': 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.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           	138.77553   	250.73946   	0.74367     	0           
  10          	138.07928   	249.10339   	0.74967     	0           
  100         	131.43466   	234.79117   	0.79442     	0           
  300         	118.30173   	210.62581   	0.84537     	1           
  500         	106.90660   	191.83754   	0.87399     	2           
  1000        	86.12368    	156.51593   	0.91808     	4           
---> try to load best state
              	86.12368    	156.51593   	0.91808     	4                eval state : test_on_restore;
              	86.12368    	156.51593   	0.91808     	4                eval state : test_on_last_epoch;
---> final result
              	86.12368    	156.51593   	0.91808     	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': 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           	191.68529   	284.49466   	-0.22838    	0           
  10          	185.33202   	277.33670   	-0.11653    	0           
  100         	149.45175   	233.41859   	0.35496     	0           
  300         	128.69719   	205.51257   	0.57078     	0           
  500         	121.40717   	195.44695   	0.64030     	1           
  1000        	115.00610   	186.48509   	0.69932     	2           
---> try to load best state
              	115.00610   	186.48509   	0.69932     	2                eval state : test_on_restore;
              	115.00610   	186.48509   	0.69932     	2                eval state : test_on_last_epoch;
---> final result
              	115.00610   	186.48509   	0.69932     	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           	154.81813   	238.48839   	0.36738     	0           
  10          	146.73285   	228.39735   	0.44311     	0           
  100         	112.64664   	182.45815   	0.70772     	0           
  300         	98.75079    	164.85916   	0.80040     	0           
  500         	95.52327    	161.98471   	0.81847     	1           
  1000        	93.88120    	161.03183   	0.82412     	2           
---> try to load best state
              	93.88120    	161.03183   	0.82412     	2                eval state : test_on_restore;
              	93.88120    	161.03183   	0.82412     	2                eval state : test_on_last_epoch;
---> final result
              	93.88120    	161.03183   	0.82412     	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           	118.66721   	191.01631   	0.65202     	0           
  10          	111.30610   	182.91023   	0.69481     	0           
  100         	91.14172    	159.40961   	0.82605     	0           
  300         	87.15205    	156.14796   	0.85530     	0           
  500         	87.12054    	156.38255   	0.84516     	1           
  1000        	87.33749    	156.82349   	0.83140     	2           
---> try to load best state
              	87.33749    	156.82349   	0.83140     	2                eval state : test_on_restore;
              	87.33749    	156.82349   	0.83140     	2                eval state : test_on_last_epoch;
---> final result
              	87.33749    	156.82349   	0.83140     	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           	95.20551    	163.15828   	0.76488     	0           
  10          	92.21665    	160.47084   	0.77900     	0           
  100         	85.93594    	154.69098   	0.82660     	0           
  300         	85.44582    	154.91589   	0.83008     	1           
  500         	85.53588    	155.14619   	0.82164     	2           
  1000        	85.70342    	155.45761   	0.81271     	4           
---> try to load best state
              	85.70342    	155.45761   	0.81271     	4                eval state : test_on_restore;
              	85.70342    	155.45761   	0.81271     	4                eval state : test_on_last_epoch;
---> final result
              	85.70342    	155.45761   	0.81271     	4                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': 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.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           	197.50684   	358.35605   	-0.09550    	0           
  10          	195.69128   	355.58313   	-0.05976    	0           
  100         	179.63795   	330.06586   	0.21359     	0           
  300         	154.71494   	286.79059   	0.51320     	1           
  500         	138.81902   	256.73804   	0.64668     	2           
  1000        	111.81945   	205.44865   	0.80404     	3           
---> try to load best state
              	111.81945   	205.44865   	0.80404     	3                eval state : test_on_restore;
              	111.81945   	205.44865   	0.80404     	3                eval state : test_on_last_epoch;
---> final result
              	111.81945   	205.44865   	0.80404     	3                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           	187.80486   	283.89548   	-0.16444    	0           
  10          	178.52191   	273.70273   	-0.00908    	0           
  100         	130.31340   	220.61932   	0.56683     	0           
  300         	120.30880   	207.60075   	0.69496     	0           
  500         	119.51891   	205.75351   	0.71469     	1           
  1000        	119.46053   	204.61729   	0.72635     	2           
---> try to load best state
              	119.46053   	204.61729   	0.72635     	2                eval state : test_on_restore;
              	119.46053   	204.61729   	0.72635     	2                eval state : test_on_last_epoch;
---> final result
              	119.46053   	204.61729   	0.72635     	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': 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           	167.70526   	262.51666   	0.17668     	0           
  10          	158.20984   	252.11386   	0.28959     	0           
  100         	126.08862   	214.08557   	0.61596     	0           
  300         	120.15714   	206.57452   	0.64448     	0           
  500         	119.07110   	205.42682   	0.63575     	1           
  1000        	118.33864   	204.71889   	0.62022     	2           
---> try to load best state
              	118.33864   	204.71889   	0.62022     	2                eval state : test_on_restore;
              	118.33864   	204.71889   	0.62022     	2                eval state : test_on_last_epoch;
---> final result
              	118.33864   	204.71889   	0.62022     	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           	135.70969   	231.86456   	0.55378     	0           
  10          	131.92592   	226.70273   	0.59883     	0           
  100         	120.11684   	212.04880   	0.67883     	0           
  300         	115.53980   	207.78629   	0.64130     	0           
  500         	114.75280   	207.17284   	0.61164     	1           
  1000        	114.35536   	206.94107   	0.58371     	2           
---> try to load best state
              	114.35536   	206.94107   	0.58371     	2                eval state : test_on_restore;
              	114.35536   	206.94107   	0.58371     	2                eval state : test_on_last_epoch;
---> final result
              	114.35536   	206.94107   	0.58371     	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           	127.12365   	221.86906   	0.59189     	0           
  10          	122.31624   	216.33916   	0.63891     	0           
  100         	111.71098   	204.05470   	0.67632     	0           
  300         	111.84945   	203.16841   	0.52517     	1           
  500         	112.00250   	203.00876   	0.50008     	1           
  1000        	112.22006   	203.02631   	0.48871     	3           
---> try to load best state
              	112.22006   	203.02631   	0.48871     	3                eval state : test_on_restore;
              	112.22006   	203.02631   	0.48871     	3                eval state : test_on_last_epoch;
---> final result
              	112.22006   	203.02631   	0.48871     	3                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': 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.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           	178.59821   	302.61151   	0.42124     	0           
  10          	177.11867   	300.35889   	0.43536     	0           
  100         	163.57587   	279.92032   	0.54745     	0           
  300         	141.27914   	245.65298   	0.68483     	0           
  500         	126.71380   	221.32901   	0.75538     	1           
  1000        	101.88340   	178.40077   	0.84983     	2           
---> try to load best state
              	101.88340   	178.40077   	0.84983     	2                eval state : test_on_restore;
              	101.88340   	178.40077   	0.84983     	2                eval state : test_on_last_epoch;
---> final result
              	101.88340   	178.40077   	0.84983     	2                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           	192.32845   	285.97586   	-0.33390    	0           
  10          	185.05368   	278.20898   	-0.17640    	0           
  100         	142.12364   	225.47597   	0.42544     	0           
  300         	126.64476   	202.63199   	0.60911     	0           
  500         	122.84641   	196.64661   	0.65859     	0           
  1000        	120.00758   	192.05754   	0.69758     	1           
---> try to load best state
              	120.00758   	192.05754   	0.69758     	1                eval state : test_on_restore;
              	120.00758   	192.05754   	0.69758     	1                eval state : test_on_last_epoch;
---> final result
              	120.00758   	192.05754   	0.69758     	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           	185.05032   	283.26312   	-0.25246    	0           
  10          	178.65129   	276.81586   	-0.13448    	0           
  100         	145.34900   	233.92418   	0.32993     	0           
  300         	124.88961   	203.33875   	0.60146     	0           
  500         	116.56559   	191.52963   	0.69551     	0           
  1000        	108.84003   	181.87718   	0.76328     	1           
---> try to load best state
              	108.84003   	181.87718   	0.76328     	1                eval state : test_on_restore;
              	108.84003   	181.87718   	0.76328     	1                eval state : test_on_last_epoch;
---> final result
              	108.84003   	181.87718   	0.76328     	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': 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           	132.69031   	212.10060   	0.54839     	0           
  10          	126.20761   	203.76668   	0.60550     	0           
  100         	105.82648   	178.60832   	0.75952     	0           
  300         	100.98947   	175.56662   	0.76990     	0           
  500         	100.71022   	176.13989   	0.74356     	1           
  1000        	100.89151   	176.97180   	0.70988     	2           
---> try to load best state
              	100.89151   	176.97180   	0.70988     	2                eval state : test_on_restore;
              	100.89151   	176.97180   	0.70988     	2                eval state : test_on_last_epoch;
---> final result
              	100.89151   	176.97180   	0.70988     	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           	112.31552   	189.71117   	0.67159     	0           
  10          	108.61562   	185.51329   	0.69945     	0           
  100         	101.69560   	178.61670   	0.72364     	0           
  300         	102.66709   	180.81308   	0.64925     	1           
  500         	102.81452   	181.18730   	0.63185     	1           
  1000        	103.01075   	181.54607   	0.62123     	3           
---> try to load best state
              	103.01075   	181.54607   	0.62123     	3                eval state : test_on_restore;
              	103.01075   	181.54607   	0.62123     	3                eval state : test_on_last_epoch;
---> final result
              	103.01075   	181.54607   	0.62123     	3                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': 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.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           	173.74155   	334.46317   	0.34726     	0           
  10          	172.35533   	332.10190   	0.36470     	0           
  100         	160.53122   	310.73581   	0.49882     	0           
  300         	142.60095   	275.76715   	0.65226     	0           
  500         	130.60809   	252.00232   	0.72724     	1           
  1000        	109.52187   	209.76738   	0.82739     	2           
---> try to load best state
              	109.52187   	209.76738   	0.82739     	2                eval state : test_on_restore;
              	109.52187   	209.76738   	0.82739     	2                eval state : test_on_last_epoch;
---> final result
              	109.52187   	209.76738   	0.82739     	2                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           	222.54645   	328.41867   	-1.31839    	0           
  10          	220.93974   	326.90002   	-1.17097    	0           
  100         	207.40746   	314.00949   	-0.46511    	0           
  300         	192.05389   	296.95639   	-0.09387    	0           
  500         	183.00967   	286.60767   	0.05421     	0           
  1000        	169.70882   	271.26245   	0.22597     	1           
---> try to load best state
              	169.70882   	271.26245   	0.22597     	1                eval state : test_on_restore;
              	169.70882   	271.26245   	0.22597     	1                eval state : test_on_last_epoch;
---> final result
              	169.70882   	271.26245   	0.22597     	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           	191.82152   	300.67920   	-0.20704    	0           
  10          	186.31990   	294.80753   	-0.08747    	0           
  100         	155.08212   	255.83594   	0.40319     	0           
  300         	131.81755   	228.33038   	0.61482     	0           
  500         	124.10420   	219.87985   	0.67266     	0           
  1000        	118.07421   	213.89955   	0.71082     	1           
---> try to load best state
              	118.07421   	213.89955   	0.71082     	1                eval state : test_on_restore;
              	118.07421   	213.89955   	0.71082     	1                eval state : test_on_last_epoch;
---> final result
              	118.07421   	213.89955   	0.71082     	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': 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           	158.57608   	260.60397   	0.34295     	0           
  10          	151.27347   	252.47600   	0.41943     	0           
  100         	118.70940   	215.97133   	0.68205     	0           
  300         	109.82863   	208.32545   	0.74258     	0           
  500         	109.99712   	208.91495   	0.70519     	1           
  1000        	110.83112   	210.01901   	0.66160     	2           
---> try to load best state
              	110.83112   	210.01901   	0.66160     	2                eval state : test_on_restore;
              	110.83112   	210.01901   	0.66160     	2                eval state : test_on_last_epoch;
---> final result
              	110.83112   	210.01901   	0.66160     	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': 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           	127.41951   	225.63890   	0.59180     	0           
  10          	122.68175   	220.54880   	0.62848     	0           
  100         	109.23862   	207.93114   	0.70642     	0           
  300         	107.45867   	206.51213   	0.65371     	1           
  500         	107.80475   	206.61609   	0.62625     	1           
  1000        	108.26276   	207.01649   	0.60669     	3           
---> try to load best state
              	108.26276   	207.01649   	0.60669     	3                eval state : test_on_restore;
              	108.26276   	207.01649   	0.60669     	3                eval state : test_on_last_epoch;
---> final result
              	108.26276   	207.01649   	0.60669     	3                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': 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.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           	190.19420   	346.10031   	0.05073     	0           
  10          	188.35249   	342.78323   	0.08269     	0           
  100         	171.96010   	312.76385   	0.32758     	0           
  300         	147.71516   	265.29257   	0.59212     	0           
  500         	131.57915   	235.04662   	0.70670     	1           
  1000        	105.94860   	188.88913   	0.82916     	2           
---> try to load best state
              	105.94860   	188.88913   	0.82916     	2                eval state : test_on_restore;
              	105.94860   	188.88913   	0.82916     	2                eval state : test_on_last_epoch;
---> final result
              	105.94860   	188.88913   	0.82916     	2                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           	217.55086   	319.60165   	-1.53894    	0           
  10          	215.04002   	317.12372   	-1.41980    	0           
  100         	199.51468   	300.62915   	-0.84236    	0           
  300         	187.13742   	286.66769   	-0.57661    	0           
  500         	181.08795   	279.54630   	-0.47307    	0           
  1000        	173.68263   	270.50601   	-0.35667    	1           
---> try to load best state
              	173.68263   	270.50601   	-0.35667    	1                eval state : test_on_restore;
              	173.68263   	270.50601   	-0.35667    	1                eval state : test_on_last_epoch;
---> final result
              	173.68263   	270.50601   	-0.35667    	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': 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           	180.96031   	278.32697   	-0.26132    	0           
  10          	169.56856   	265.66406   	-0.04655    	0           
  100         	118.57762   	204.42210   	0.67330     	0           
  300         	112.31989   	194.32132   	0.75692     	0           
  500         	111.33966   	192.84003   	0.76491     	0           
  1000        	110.70276   	191.89204   	0.76694     	1           
---> try to load best state
              	110.70276   	191.89204   	0.76694     	1                eval state : test_on_restore;
              	110.70276   	191.89204   	0.76694     	1                eval state : test_on_last_epoch;
---> final result
              	110.70276   	191.89204   	0.76694     	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': 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           	137.73454   	225.96722   	0.45405     	0           
  10          	129.52606   	216.21356   	0.54215     	0           
  100         	109.37960   	189.55037   	0.75019     	0           
  300         	105.84314   	184.88110   	0.77351     	0           
  500         	105.29562   	184.08406   	0.76742     	1           
  1000        	105.03262   	183.65331   	0.75795     	2           
---> try to load best state
              	105.03262   	183.65331   	0.75795     	2                eval state : test_on_restore;
              	105.03262   	183.65331   	0.75795     	2                eval state : test_on_last_epoch;
---> final result
              	105.03262   	183.65331   	0.75795     	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           	118.52380   	204.46219   	0.64974     	0           
  10          	114.06246   	197.99841   	0.69032     	0           
  100         	103.73425   	183.53539   	0.74182     	0           
  300         	103.94815   	182.92728   	0.63100     	1           
  500         	104.27216   	183.27136   	0.60469     	1           
  1000        	104.57219   	183.64084   	0.59089     	3           
---> try to load best state
              	104.57219   	183.64084   	0.59089     	3                eval state : test_on_restore;
              	104.57219   	183.64084   	0.59089     	3                eval state : test_on_last_epoch;
---> final result
              	104.57219   	183.64084   	0.59089     	3                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': 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.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           	135.78708   	241.20796   	0.78973     	0           
  10          	135.16093   	239.71599   	0.79409     	0           
  100         	129.75902   	226.75250   	0.82699     	0           
  300         	118.67701   	204.69368   	0.86559     	0           
  500         	108.11190   	187.74069   	0.88647     	1           
  1000        	89.72105    	157.15001   	0.91848     	2           
---> try to load best state
              	89.72105    	157.15001   	0.91848     	2                eval state : test_on_restore;
              	89.72105    	157.15001   	0.91848     	2                eval state : test_on_last_epoch;
---> final result
              	89.72105    	157.15001   	0.91848     	2                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           	209.08186   	303.85941   	-0.88714    	0           
  10          	207.86044   	302.86276   	-0.82202    	0           
  100         	194.55917   	288.77100   	-0.33117    	0           
  300         	180.73564   	270.51517   	-0.01048    	0           
  500         	174.03809   	261.50339   	0.10156     	0           
  1000        	165.30330   	249.59042   	0.22271     	1           
---> try to load best state
              	165.30330   	249.59042   	0.22271     	1                eval state : test_on_restore;
              	165.30330   	249.59042   	0.22271     	1                eval state : test_on_last_epoch;
---> final result
              	165.30330   	249.59042   	0.22271     	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': 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           	137.11520   	214.38921   	0.49950     	0           
  10          	128.81233   	203.02257   	0.58373     	0           
  100         	103.40768   	167.71419   	0.79784     	0           
  300         	96.23222    	160.53471   	0.84283     	0           
  500         	94.70093    	159.81142   	0.84988     	0           
  1000        	93.96230    	159.87163   	0.85132     	1           
---> try to load best state
              	93.96230    	159.87163   	0.85132     	1                eval state : test_on_restore;
              	93.96230    	159.87163   	0.85132     	1                eval state : test_on_last_epoch;
---> final result
              	93.96230    	159.87163   	0.85132     	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': 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           	119.97807   	194.83669   	0.66417     	0           
  10          	115.10969   	187.62872   	0.70416     	0           
  100         	100.87350   	165.33604   	0.82023     	0           
  300         	94.46776    	159.60995   	0.85234     	0           
  500         	93.30128    	158.97449   	0.85423     	1           
  1000        	92.65016    	158.74275   	0.85320     	2           
---> try to load best state
              	92.65016    	158.74275   	0.85320     	2                eval state : test_on_restore;
              	92.65016    	158.74275   	0.85320     	2                eval state : test_on_last_epoch;
---> final result
              	92.65016    	158.74275   	0.85320     	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           	95.23686    	159.25902   	0.78791     	0           
  10          	92.97554    	156.83804   	0.80382     	0           
  100         	88.84103    	154.27568   	0.86105     	0           
  300         	88.95003    	155.85727   	0.85328     	1           
  500         	89.11621    	156.35434   	0.84741     	1           
  1000        	89.32079    	156.87309   	0.84133     	3           
---> try to load best state
              	89.32079    	156.87309   	0.84133     	3                eval state : test_on_restore;
              	89.32079    	156.87309   	0.84133     	3                eval state : test_on_last_epoch;
---> final result
              	89.32079    	156.87309   	0.84133     	3                eval state : final;module_name : ResGP;cp_record_file : True;
