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

  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': 128, '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           	50.23768    	129.70575   	0.87994     	0           
  10          	49.83587    	128.59578   	0.88239     	0           
  100         	46.42620    	119.34004   	0.90125     	1           
  300         	42.27537    	108.25125   	0.92082     	3           
  500         	40.56353    	103.67871   	0.92820     	5           
  1000        	35.95199    	92.36927    	0.94459     	11          
---> try to load best state
              	35.95199    	92.36927    	0.94459     	11               eval state : test_on_restore;
              	35.95199    	92.36927    	0.94459     	11               eval state : test_on_last_epoch;
---> final result
              	35.95199    	92.36927    	0.94459     	11               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.47153    	191.73135   	0.33307     	0           
  10          	87.13554    	186.16156   	0.39467     	0           
  100         	60.85084    	137.03812   	0.73516     	0           
  300         	48.34022    	111.40170   	0.85481     	0           
  500         	46.67735    	108.06485   	0.86884     	0           
  1000        	45.73671    	106.20975   	0.87650     	1           
---> try to load best state
              	45.73671    	106.20975   	0.87650     	1                eval state : test_on_restore;
              	45.73671    	106.20975   	0.87650     	1                eval state : test_on_last_epoch;
---> final result
              	45.73671    	106.20975   	0.87650     	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.84680    	157.19208   	0.65187     	0           
  10          	67.48183    	149.12665   	0.69472     	0           
  100         	43.49574    	100.34929   	0.88405     	0           
  300         	39.87238    	96.05757    	0.90251     	0           
  500         	39.77830    	96.16968    	0.90142     	1           
  1000        	39.75898    	96.21220    	0.90102     	2           
---> try to load best state
              	39.75898    	96.21220    	0.90102     	2                eval state : test_on_restore;
              	39.75898    	96.21220    	0.90102     	2                eval state : test_on_last_epoch;
---> final result
              	39.75898    	96.21220    	0.90102     	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.31844    	120.98120   	0.80657     	0           
  10          	49.39170    	114.29324   	0.83131     	0           
  100         	37.09700    	92.66723    	0.92124     	0           
  300         	37.02969    	93.30800    	0.90442     	0           
  500         	37.05573    	93.42845    	0.90247     	1           
  1000        	37.05587    	93.44445    	0.90226     	3           
---> try to load best state
              	37.05587    	93.44445    	0.90226     	3                eval state : test_on_restore;
              	37.05587    	93.44445    	0.90226     	3                eval state : test_on_last_epoch;
---> final result
              	37.05587    	93.44445    	0.90226     	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.57467    	99.53806    	0.87194     	0           
  10          	40.28663    	97.31760    	0.87879     	0           
  100         	36.32475    	91.61794    	0.91156     	0           
  300         	36.39032    	92.18995    	0.90013     	1           
  500         	36.44684    	92.35918    	0.89778     	2           
  1000        	36.46707    	92.42888    	0.89692     	4           
---> try to load best state
              	36.46707    	92.42888    	0.89692     	4                eval state : test_on_restore;
              	36.46707    	92.42888    	0.89692     	4                eval state : test_on_last_epoch;
---> final result
              	36.46707    	92.42888    	0.89692     	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.29337    	95.70657    	0.89073     	0           
  10          	38.45398    	94.38627    	0.89685     	0           
  100         	35.99652    	92.46209    	0.91051     	0           
  300         	36.38453    	93.23371    	0.90199     	2           
  500         	36.46591    	93.38897    	0.89991     	4           
  1000        	36.49824    	93.46133    	0.89896     	7           
---> try to load best state
              	36.49824    	93.46133    	0.89896     	7                eval state : test_on_restore;
              	36.49824    	93.46133    	0.89896     	7                eval state : test_on_last_epoch;
---> final result
              	36.49824    	93.46133    	0.89896     	7                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 128, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	38.91166    	95.35535    	0.89212     	0           
  10          	38.14793    	94.23070    	0.89802     	0           
  100         	36.06726    	92.48204    	0.91106     	1           
  300         	36.39273    	93.28716    	0.90326     	3           
  500         	36.47109    	93.47466    	0.90078     	5           
  1000        	36.51176    	93.58147    	0.89936     	10          
---> try to load best state
              	36.51176    	93.58147    	0.89936     	10               eval state : test_on_restore;
              	36.51176    	93.58147    	0.89936     	10               eval state : test_on_last_epoch;
---> final result
              	36.51176    	93.58147    	0.89936     	10               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': 128, '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           	50.23768    	129.70575   	0.87994     	0           
  10          	49.83587    	128.59576   	0.88239     	0           
  100         	46.42620    	119.34003   	0.90125     	1           
  300         	42.27537    	108.25124   	0.92082     	3           
  500         	40.56353    	103.67870   	0.92820     	5           
  1000        	35.95199    	92.36926    	0.94459     	9           
---> try to load best state
              	35.95199    	92.36926    	0.94459     	9                eval state : test_on_restore;
              	35.95199    	92.36926    	0.94459     	9                eval state : test_on_last_epoch;
---> final result
              	35.95199    	92.36926    	0.94459     	9                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           	83.01917    	174.95451   	0.51475     	0           
  10          	78.12200    	166.12216   	0.57975     	0           
  100         	47.43060    	108.43494   	0.86134     	0           
  300         	45.84880    	103.48439   	0.88658     	0           
  500         	46.14152    	103.71763   	0.88624     	0           
  1000        	46.58817    	104.27782   	0.88382     	1           
---> try to load best state
              	46.58817    	104.27782   	0.88382     	1                eval state : test_on_restore;
              	46.58817    	104.27782   	0.88382     	1                eval state : test_on_last_epoch;
---> final result
              	46.58817    	104.27782   	0.88382     	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           	72.84052    	156.45233   	0.64883     	0           
  10          	67.61334    	146.94046   	0.69814     	0           
  100         	45.20031    	104.16417   	0.86625     	0           
  300         	43.38974    	101.35742   	0.86917     	0           
  500         	43.30210    	101.24411   	0.86829     	0           
  1000        	43.30580    	101.24442   	0.86812     	1           
---> try to load best state
              	43.30580    	101.24442   	0.86812     	1                eval state : test_on_restore;
              	43.30580    	101.24442   	0.86812     	1                eval state : test_on_last_epoch;
---> final result
              	43.30580    	101.24442   	0.86812     	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': 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.11327    	127.70049   	0.80434     	0           
  10          	52.62079    	122.12485   	0.82590     	0           
  100         	40.35142    	99.03978    	0.89989     	0           
  300         	38.44411    	96.55923    	0.90640     	0           
  500         	38.34794    	96.46401    	0.90601     	1           
  1000        	38.34593    	96.48006    	0.90583     	2           
---> try to load best state
              	38.34593    	96.48006    	0.90583     	2                eval state : test_on_restore;
              	38.34593    	96.48006    	0.90583     	2                eval state : test_on_last_epoch;
---> final result
              	38.34593    	96.48006    	0.90583     	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           	50.56651    	118.03990   	0.82481     	0           
  10          	47.28258    	111.52021   	0.84771     	0           
  100         	36.79452    	92.95839    	0.92246     	0           
  300         	36.78680    	92.91181    	0.90900     	0           
  500         	36.89265    	93.04955    	0.90579     	1           
  1000        	36.92546    	93.10440    	0.90476     	3           
---> try to load best state
              	36.92546    	93.10440    	0.90476     	3                eval state : test_on_restore;
              	36.92546    	93.10440    	0.90476     	3                eval state : test_on_last_epoch;
---> final result
              	36.92546    	93.10440    	0.90476     	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': 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.54031    	95.82401    	0.88686     	0           
  10          	38.84650    	94.68861    	0.88870     	0           
  100         	36.25656    	92.78063    	0.90704     	0           
  300         	36.42558    	93.31721    	0.90297     	1           
  500         	36.46563    	93.44028    	0.90136     	3           
  1000        	36.48468    	93.50214    	0.90059     	6           
---> try to load best state
              	36.48468    	93.50214    	0.90059     	6                eval state : test_on_restore;
              	36.48468    	93.50214    	0.90059     	6                eval state : test_on_last_epoch;
---> final result
              	36.48468    	93.50214    	0.90059     	6                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 128, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	38.91166    	95.35533    	0.89212     	0           
  10          	38.14793    	94.23067    	0.89802     	0           
  100         	36.06727    	92.48203    	0.91106     	1           
  300         	36.39275    	93.28717    	0.90326     	2           
  500         	36.47126    	93.47481    	0.90078     	4           
  1000        	36.51187    	93.58170    	0.89936     	9           
---> try to load best state
              	36.51187    	93.58170    	0.89936     	9                eval state : test_on_restore;
              	36.51187    	93.58170    	0.89936     	9                eval state : test_on_last_epoch;
---> final result
              	36.51187    	93.58170    	0.89936     	9                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': 128, '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           	50.23769    	129.70576   	0.87994     	0           
  10          	49.83586    	128.59578   	0.88239     	0           
  100         	46.42620    	119.34004   	0.90125     	0           
  300         	42.27536    	108.25123   	0.92082     	2           
  500         	40.56353    	103.67870   	0.92820     	3           
  1000        	35.95199    	92.36925    	0.94459     	7           
---> try to load best state
              	35.95199    	92.36925    	0.94459     	7                eval state : test_on_restore;
              	35.95199    	92.36925    	0.94459     	7                eval state : test_on_last_epoch;
---> final result
              	35.95199    	92.36925    	0.94459     	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': 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           	86.54545    	187.90254   	0.40189     	0           
  10          	82.52657    	181.63786   	0.47015     	0           
  100         	53.95168    	124.18817   	0.80808     	0           
  300         	49.73602    	111.57062   	0.86109     	0           
  500         	49.68878    	111.11810   	0.86267     	0           
  1000        	49.75322    	111.03035   	0.86284     	1           
---> try to load best state
              	49.75322    	111.03035   	0.86284     	1                eval state : test_on_restore;
              	49.75322    	111.03035   	0.86284     	1                eval state : test_on_last_epoch;
---> final result
              	49.75322    	111.03035   	0.86284     	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           	83.59386    	186.42374   	0.43069     	0           
  10          	80.06568    	181.24382   	0.48377     	0           
  100         	53.84684    	127.49269   	0.78957     	0           
  300         	40.27547    	97.86203    	0.90463     	0           
  500         	39.51875    	96.73644    	0.90562     	0           
  1000        	39.16673    	96.29877    	0.90336     	1           
---> try to load best state
              	39.16673    	96.29877    	0.90336     	1                eval state : test_on_restore;
              	39.16673    	96.29877    	0.90336     	1                eval state : test_on_last_epoch;
---> final result
              	39.16673    	96.29877    	0.90336     	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           	56.62579    	130.28741   	0.78979     	0           
  10          	53.02738    	122.73824   	0.81808     	0           
  100         	37.53754    	93.17998    	0.92160     	0           
  300         	37.15228    	93.56014    	0.91205     	0           
  500         	37.27103    	93.84443    	0.90824     	1           
  1000        	37.32492    	93.97642    	0.90636     	2           
---> try to load best state
              	37.32492    	93.97642    	0.90636     	2                eval state : test_on_restore;
              	37.32492    	93.97642    	0.90636     	2                eval state : test_on_last_epoch;
---> final result
              	37.32492    	93.97642    	0.90636     	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           	45.42662    	109.09366   	0.85593     	0           
  10          	43.12632    	104.42213   	0.87189     	0           
  100         	36.48206    	94.03674    	0.91887     	0           
  300         	37.02283    	94.61711    	0.90447     	1           
  500         	37.10748    	94.73569    	0.90226     	1           
  1000        	37.13253    	94.80343    	0.90132     	3           
---> try to load best state
              	37.13253    	94.80343    	0.90132     	3                eval state : test_on_restore;
              	37.13253    	94.80343    	0.90132     	3                eval state : test_on_last_epoch;
---> final result
              	37.13253    	94.80343    	0.90132     	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': 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           	40.43034    	98.14472    	0.88810     	0           
  10          	39.24570    	96.08929    	0.89641     	0           
  100         	36.19062    	93.14047    	0.91296     	0           
  300         	36.57573    	94.28976    	0.90240     	1           
  500         	36.61672    	94.42290    	0.90012     	3           
  1000        	36.63343    	94.48534    	0.89921     	6           
---> try to load best state
              	36.63343    	94.48534    	0.89921     	6                eval state : test_on_restore;
              	36.63343    	94.48534    	0.89921     	6                eval state : test_on_last_epoch;
---> final result
              	36.63343    	94.48534    	0.89921     	6                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 128, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	38.91166    	95.35532    	0.89212     	0           
  10          	38.14793    	94.23067    	0.89802     	0           
  100         	36.06726    	92.48203    	0.91106     	0           
  300         	36.39269    	93.28709    	0.90326     	2           
  500         	36.47115    	93.47481    	0.90078     	4           
  1000        	36.51192    	93.58173    	0.89936     	9           
---> try to load best state
              	36.51192    	93.58173    	0.89936     	9                eval state : test_on_restore;
              	36.51192    	93.58173    	0.89936     	9                eval state : test_on_last_epoch;
---> final result
              	36.51192    	93.58173    	0.89936     	9                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': 128, '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           	50.23770    	129.70576   	0.87994     	0           
  10          	49.83587    	128.59576   	0.88239     	0           
  100         	46.42619    	119.34001   	0.90125     	0           
  300         	42.27538    	108.25124   	0.92082     	2           
  500         	40.56352    	103.67870   	0.92820     	3           
  1000        	35.95200    	92.36928    	0.94459     	7           
---> try to load best state
              	35.95200    	92.36928    	0.94459     	7                eval state : test_on_restore;
              	35.95200    	92.36928    	0.94459     	7                eval state : test_on_last_epoch;
---> final result
              	35.95200    	92.36928    	0.94459     	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': 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           	102.30694   	210.61572   	-0.02163    	0           
  10          	101.44331   	209.38080   	0.03767     	0           
  100         	89.04154    	189.80824   	0.44696     	0           
  300         	66.39806    	147.38173   	0.71462     	0           
  500         	56.92819    	128.39018   	0.78693     	0           
  1000        	49.21236    	112.59141   	0.84102     	1           
---> try to load best state
              	49.21236    	112.59141   	0.84102     	1                eval state : test_on_restore;
              	49.21236    	112.59141   	0.84102     	1                eval state : test_on_last_epoch;
---> final result
              	49.21236    	112.59141   	0.84102     	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           	86.69640    	188.61307   	0.43961     	0           
  10          	83.66106    	183.46567   	0.49577     	0           
  100         	54.40085    	124.20324   	0.81591     	0           
  300         	42.63948    	100.78919   	0.88435     	0           
  500         	41.73784    	99.32031    	0.88589     	0           
  1000        	41.53963    	99.03033    	0.88579     	1           
---> try to load best state
              	41.53963    	99.03033    	0.88579     	1                eval state : test_on_restore;
              	41.53963    	99.03033    	0.88579     	1                eval state : test_on_last_epoch;
---> final result
              	41.53963    	99.03033    	0.88579     	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           	68.57999    	154.08589   	0.69245     	0           
  10          	64.35738    	146.08752   	0.73131     	0           
  100         	39.17474    	96.57781    	0.90559     	0           
  300         	38.56213    	95.70666    	0.88557     	0           
  500         	38.85106    	96.17545    	0.87894     	1           
  1000        	38.96881    	96.37495    	0.87634     	2           
---> try to load best state
              	38.96881    	96.37495    	0.87634     	2                eval state : test_on_restore;
              	38.96881    	96.37495    	0.87634     	2                eval state : test_on_last_epoch;
---> final result
              	38.96881    	96.37495    	0.87634     	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           	51.59501    	120.34760   	0.81616     	0           
  10          	48.38749    	114.20840   	0.83659     	0           
  100         	36.58673    	93.19781    	0.91588     	0           
  300         	36.68676    	93.14582    	0.90216     	1           
  500         	36.75004    	93.28547    	0.89921     	2           
  1000        	36.76501    	93.33194    	0.89811     	4           
---> try to load best state
              	36.76501    	93.33194    	0.89811     	4                eval state : test_on_restore;
              	36.76501    	93.33194    	0.89811     	4                eval state : test_on_last_epoch;
---> final result
              	36.76501    	93.33194    	0.89811     	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           	41.12318    	100.21072   	0.88108     	0           
  10          	39.81304    	97.63712    	0.89182     	0           
  100         	36.06837    	92.17510    	0.92026     	0           
  300         	36.31963    	92.79203    	0.90729     	2           
  500         	36.38173    	92.97073    	0.90389     	3           
  1000        	36.40596    	93.04617    	0.90255     	7           
---> try to load best state
              	36.40596    	93.04617    	0.90255     	7                eval state : test_on_restore;
              	36.40596    	93.04617    	0.90255     	7                eval state : test_on_last_epoch;
---> final result
              	36.40596    	93.04617    	0.90255     	7                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 128, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	38.91166    	95.35534    	0.89212     	0           
  10          	38.14793    	94.23071    	0.89802     	0           
  100         	36.06727    	92.48203    	0.91106     	1           
  300         	36.39273    	93.28721    	0.90326     	3           
  500         	36.47112    	93.47482    	0.90078     	5           
  1000        	36.51181    	93.58157    	0.89936     	11          
---> try to load best state
              	36.51181    	93.58157    	0.89936     	11               eval state : test_on_restore;
              	36.51181    	93.58157    	0.89936     	11               eval state : test_on_last_epoch;
---> final result
              	36.51181    	93.58157    	0.89936     	11               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': 128, '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           	50.23769    	129.70575   	0.87994     	0           
  10          	49.83586    	128.59576   	0.88239     	0           
  100         	46.42621    	119.34005   	0.90125     	1           
  300         	42.27538    	108.25125   	0.92082     	3           
  500         	40.56353    	103.67871   	0.92820     	5           
  1000        	35.95198    	92.36924    	0.94459     	9           
---> try to load best state
              	35.95198    	92.36924    	0.94459     	9                eval state : test_on_restore;
              	35.95198    	92.36924    	0.94459     	9                eval state : test_on_last_epoch;
---> final result
              	35.95198    	92.36924    	0.94459     	9                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           	97.28065    	204.84892   	-0.00197    	0           
  10          	95.92699    	202.82861   	0.04171     	0           
  100         	83.26661    	182.07079   	0.33590     	0           
  300         	69.55137    	155.78929   	0.52061     	0           
  500         	63.34262    	142.43246   	0.60124     	1           
  1000        	55.87907    	125.95293   	0.71195     	2           
---> try to load best state
              	55.87907    	125.95293   	0.71195     	2                eval state : test_on_restore;
              	55.87907    	125.95293   	0.71195     	2                eval state : test_on_last_epoch;
---> final result
              	55.87907    	125.95293   	0.71195     	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           	78.75050    	172.80647   	0.46310     	0           
  10          	72.64742    	162.08577   	0.55803     	0           
  100         	43.05459    	101.05364   	0.89162     	0           
  300         	41.43075    	97.33955    	0.90263     	0           
  500         	41.32587    	97.10041    	0.90278     	1           
  1000        	41.28407    	97.01242    	0.90281     	2           
---> try to load best state
              	41.28407    	97.01242    	0.90281     	2                eval state : test_on_restore;
              	41.28407    	97.01242    	0.90281     	2                eval state : test_on_last_epoch;
---> final result
              	41.28407    	97.01242    	0.90281     	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           	57.10923    	131.97432   	0.76266     	0           
  10          	52.66227    	123.49444   	0.80147     	0           
  100         	38.99030    	95.51547    	0.90556     	0           
  300         	37.44629    	93.30898    	0.91079     	1           
  500         	37.32309    	93.15365    	0.91067     	1           
  1000        	37.30111    	93.13934    	0.91060     	3           
---> try to load best state
              	37.30111    	93.13934    	0.91060     	3                eval state : test_on_restore;
              	37.30111    	93.13934    	0.91060     	3                eval state : test_on_last_epoch;
---> final result
              	37.30111    	93.13934    	0.91060     	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': 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           	47.12532    	112.51178   	0.84658     	0           
  10          	44.40807    	106.20583   	0.86648     	0           
  100         	36.01727    	90.81271    	0.92487     	0           
  300         	36.22847    	91.47321    	0.91652     	1           
  500         	36.27143    	91.59570    	0.91423     	2           
  1000        	36.29070    	91.65615    	0.91309     	4           
---> try to load best state
              	36.29070    	91.65615    	0.91309     	4                eval state : test_on_restore;
              	36.29070    	91.65615    	0.91309     	4                eval state : test_on_last_epoch;
---> final result
              	36.29070    	91.65615    	0.91309     	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': 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           	39.50100    	96.53876    	0.89033     	0           
  10          	38.65984    	95.13586    	0.89701     	0           
  100         	35.95011    	92.37022    	0.91384     	0           
  300         	36.36499    	93.10124    	0.90386     	2           
  500         	36.44794    	93.23627    	0.90152     	4           
  1000        	36.47754    	93.29547    	0.90053     	7           
---> try to load best state
              	36.47754    	93.29547    	0.90053     	8                eval state : test_on_restore;
              	36.47754    	93.29547    	0.90053     	8                eval state : test_on_last_epoch;
---> final result
              	36.47754    	93.29547    	0.90053     	8                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 128, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	38.91166    	95.35532    	0.89212     	0           
  10          	38.14793    	94.23067    	0.89802     	0           
  100         	36.06726    	92.48201    	0.91106     	1           
  300         	36.39269    	93.28709    	0.90326     	3           
  500         	36.47115    	93.47461    	0.90078     	6           
  1000        	36.51185    	93.58184    	0.89936     	11          
---> try to load best state
              	36.51185    	93.58184    	0.89936     	11               eval state : test_on_restore;
              	36.51185    	93.58184    	0.89936     	11               eval state : test_on_last_epoch;
---> final result
              	36.51185    	93.58184    	0.89936     	11               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': 128, '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           	50.23769    	129.70576   	0.87994     	0           
  10          	49.83587    	128.59578   	0.88239     	0           
  100         	46.42621    	119.34007   	0.90125     	0           
  300         	42.27537    	108.25124   	0.92082     	2           
  500         	40.56353    	103.67871   	0.92820     	4           
  1000        	35.95199    	92.36926    	0.94459     	8           
---> try to load best state
              	35.95199    	92.36926    	0.94459     	9                eval state : test_on_restore;
              	35.95199    	92.36926    	0.94459     	9                eval state : test_on_last_epoch;
---> final result
              	35.95199    	92.36926    	0.94459     	9                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           	102.57848   	211.56201   	-0.05250    	0           
  10          	101.91912   	210.78514   	-0.01537    	0           
  100         	88.02490    	187.93442   	0.41062     	0           
  300         	70.91811    	154.83786   	0.64625     	0           
  500         	64.93466    	143.12645   	0.70298     	1           
  1000        	61.17290    	135.82368   	0.73512     	2           
---> try to load best state
              	61.17290    	135.82368   	0.73512     	2                eval state : test_on_restore;
              	61.17290    	135.82368   	0.73512     	2                eval state : test_on_last_epoch;
---> final result
              	61.17290    	135.82368   	0.73512     	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           	63.95171    	143.20628   	0.70489     	0           
  10          	58.96891    	133.56088   	0.75475     	0           
  100         	40.17934    	96.72055    	0.90072     	0           
  300         	38.25559    	94.91368    	0.90561     	0           
  500         	38.21392    	95.06496    	0.90374     	1           
  1000        	38.21474    	95.13253    	0.90305     	2           
---> try to load best state
              	38.21474    	95.13253    	0.90305     	2                eval state : test_on_restore;
              	38.21474    	95.13253    	0.90305     	2                eval state : test_on_last_epoch;
---> final result
              	38.21474    	95.13253    	0.90305     	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           	54.78383    	127.96239   	0.79743     	0           
  10          	51.77243    	121.52199   	0.82155     	0           
  100         	39.65630    	95.35326    	0.90799     	0           
  300         	37.85495    	93.54754    	0.91088     	0           
  500         	37.77531    	93.50980    	0.91033     	1           
  1000        	37.76678    	93.50325    	0.91023     	2           
---> try to load best state
              	37.76678    	93.50325    	0.91023     	2                eval state : test_on_restore;
              	37.76678    	93.50325    	0.91023     	2                eval state : test_on_last_epoch;
---> final result
              	37.76678    	93.50325    	0.91023     	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           	42.23822    	101.15424   	0.86603     	0           
  10          	40.82119    	98.33743    	0.87384     	0           
  100         	36.66613    	92.44622    	0.90696     	0           
  300         	36.82013    	93.15402    	0.90060     	1           
  500         	36.89344    	93.35826    	0.89890     	2           
  1000        	36.91595    	93.43156    	0.89822     	4           
---> try to load best state
              	36.91595    	93.43156    	0.89822     	4                eval state : test_on_restore;
              	36.91595    	93.43156    	0.89822     	4                eval state : test_on_last_epoch;
---> final result
              	36.91595    	93.43156    	0.89822     	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': 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           	39.42281    	95.82217    	0.89012     	0           
  10          	38.73773    	94.75199    	0.89564     	0           
  100         	36.11868    	92.50997    	0.91237     	0           
  300         	36.44051    	93.24856    	0.90256     	2           
  500         	36.51107    	93.40815    	0.90028     	4           
  1000        	36.54126    	93.48731    	0.89921     	7           
---> try to load best state
              	36.54126    	93.48731    	0.89921     	7                eval state : test_on_restore;
              	36.54126    	93.48731    	0.89921     	7                eval state : test_on_last_epoch;
---> final result
              	36.54126    	93.48731    	0.89921     	7                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 128, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  res_cigp: {'type_name': 'res_standard'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	38.91166    	95.35533    	0.89212     	0           
  10          	38.14793    	94.23069    	0.89802     	0           
  100         	36.06726    	92.48203    	0.91106     	1           
  300         	36.39272    	93.28711    	0.90326     	3           
  500         	36.47114    	93.47466    	0.90078     	5           
  1000        	36.51195    	93.58176    	0.89936     	11          
---> try to load best state
              	36.51195    	93.58176    	0.89936     	11               eval state : test_on_restore;
              	36.51195    	93.58176    	0.89936     	11               eval state : test_on_last_epoch;
---> final result
              	36.51195    	93.58176    	0.89936     	11               eval state : final;module_name : ResGP;cp_record_file : True;
