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

  Demo lar cigp 
  seed: None 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	64.68929    	160.13614   	0.83152     	0           
  10          	37.51498    	92.08133    	0.94846     	0           
  100         	15.88540    	38.70943    	0.99092     	0           
  300         	14.42441    	34.62028    	0.99261     	1           
  500         	14.09064    	33.55347    	0.99304     	2           
  1000        	14.01570    	33.06474    	0.99327     	4           
---> try to load best state
              	14.01570    	33.06474    	0.99327     	4                eval state : test_on_restore;
              	14.01570    	33.06474    	0.99327     	4                eval state : test_on_last_epoch;
---> final result
              	14.01570    	33.06474    	0.99327     	4                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	72.02307    	160.68828   	0.46535     	0           
  10          	106.90543   	255.72218   	-0.27533    	0           
  100         	49.99476    	120.66575   	0.85689     	0           
  300         	49.76782    	119.98684   	0.85783     	0           
  500         	51.28905    	123.29230   	0.84649     	0           
  1000        	88.47338    	200.79475   	0.17275     	1           
---> try to load best state
              	88.47338    	200.79475   	0.17275     	1                eval state : test_on_restore;
              	88.47338    	200.79475   	0.17275     	1                eval state : test_on_last_epoch;
---> final result
              	88.47338    	200.79475   	0.17275     	1                eval state : final;
              	88.47338    	200.79475   	0.17275     	1                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	50.85144    	119.78013   	0.75826     	0           
  10          	59.66101    	142.85291   	0.79814     	0           
  100         	26.65702    	76.52032    	0.93984     	0           
  300         	26.64311    	76.82199    	0.93982     	0           
  500         	26.58313    	76.88680    	0.93995     	1           
  1000        	26.52030    	77.05611    	0.94009     	3           
---> try to load best state
              	26.52030    	77.05611    	0.94009     	3                eval state : test_on_restore;
              	26.52030    	77.05611    	0.94009     	3                eval state : test_on_last_epoch;
---> final result
              	26.52030    	77.05611    	0.94009     	3                eval state : final;
              	26.52030    	77.05611    	0.94009     	3                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	32.91343    	78.77059    	0.88910     	0           
  10          	27.22112    	66.58863    	0.97200     	0           
  100         	16.28794    	40.74331    	0.98689     	0           
  300         	16.25580    	40.23516    	0.98749     	0           
  500         	16.28190    	40.02966    	0.98782     	1           
  1000        	16.38635    	39.89190    	0.98819     	2           
---> try to load best state
              	16.38635    	39.89190    	0.98819     	2                eval state : test_on_restore;
              	16.38635    	39.89190    	0.98819     	2                eval state : test_on_last_epoch;
---> final result
              	16.38635    	39.89190    	0.98819     	2                eval state : final;
              	16.38635    	39.89190    	0.98819     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	23.92188    	54.99655    	0.93911     	0           
  10          	21.64811    	54.04411    	0.98285     	0           
  100         	14.17753    	35.65316    	0.99100     	0           
  300         	14.11794    	35.19885    	0.99132     	2           
  500         	14.10079    	34.93087    	0.99153     	3           
  1000        	14.08276    	34.51703    	0.99187     	6           
---> try to load best state
              	14.08276    	34.51703    	0.99187     	6                eval state : test_on_restore;
              	14.08276    	34.51703    	0.99187     	6                eval state : test_on_last_epoch;
---> final result
              	14.08276    	34.51703    	0.99187     	6                eval state : final;
              	14.08276    	34.51703    	0.99187     	6                eval state : final;module_name : LarGP;cp_record_file : True;
---> end

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

  Demo lar cigp 
  seed: 0 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	84.55990    	224.30556   	0.39694     	0           
  10          	42.56939    	114.93116   	0.91147     	0           
  100         	21.72644    	49.43461    	0.98401     	0           
  300         	20.28494    	45.09462    	0.98590     	1           
  500         	19.87243    	44.03842    	0.98628     	1           
  1000        	19.54061    	43.34706    	0.98651     	3           
---> try to load best state
              	19.54061    	43.34706    	0.98651     	3                eval state : test_on_restore;
              	19.54061    	43.34706    	0.98651     	3                eval state : test_on_last_epoch;
---> final result
              	19.54061    	43.34706    	0.98651     	3                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	69.42556    	146.59998   	0.63639     	0           
  10          	132.98077   	284.20697   	-0.33627    	0           
  100         	110.58198   	235.54201   	0.23824     	0           
  300         	189.02051   	409.14059   	-29.47709   	0           
  500         	189.01880   	409.13538   	-29.46958   	1           
  1000        	189.01755   	409.13120   	-29.46507   	1           
---> try to load best state
              	189.01755   	409.13120   	-29.46507   	1                eval state : test_on_restore;
              	189.01755   	409.13120   	-29.46507   	1                eval state : test_on_last_epoch;
---> final result
              	189.01755   	409.13120   	-29.46507   	1                eval state : final;
              	189.01755   	409.13120   	-29.46507   	1                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	56.00662    	123.77612   	0.75441     	0           
  10          	78.05386    	180.84503   	0.70493     	0           
  100         	42.67027    	98.16809    	0.91210     	0           
  300         	42.16523    	97.01815    	0.91435     	0           
  500         	41.96399    	96.55988    	0.91540     	1           
  1000        	41.73307    	96.01130    	0.91676     	2           
---> try to load best state
              	41.73307    	96.01130    	0.91676     	2                eval state : test_on_restore;
              	41.73307    	96.01130    	0.91676     	2                eval state : test_on_last_epoch;
---> final result
              	41.73307    	96.01130    	0.91676     	2                eval state : final;
              	41.73307    	96.01130    	0.91676     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	40.35734    	95.01672    	0.87269     	0           
  10          	34.11732    	83.30182    	0.95342     	0           
  100         	21.60470    	50.97116    	0.97618     	0           
  300         	21.54046    	50.73130    	0.97659     	0           
  500         	21.49876    	50.53999    	0.97687     	1           
  1000        	21.48812    	50.34782    	0.97724     	2           
---> try to load best state
              	21.48812    	50.34782    	0.97724     	2                eval state : test_on_restore;
              	21.48812    	50.34782    	0.97724     	2                eval state : test_on_last_epoch;
---> final result
              	21.48812    	50.34782    	0.97724     	2                eval state : final;
              	21.48812    	50.34782    	0.97724     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	35.10252    	81.94275    	0.89532     	0           
  10          	25.65587    	61.97966    	0.97528     	0           
  100         	19.30906    	42.81883    	0.98539     	0           
  300         	19.26822    	42.83111    	0.98562     	2           
  500         	19.25952    	42.89995    	0.98573     	3           
  1000        	19.25414    	43.07479    	0.98587     	6           
---> try to load best state
              	19.25414    	43.07479    	0.98587     	6                eval state : test_on_restore;
              	19.25414    	43.07479    	0.98587     	6                eval state : test_on_last_epoch;
---> final result
              	19.25414    	43.07479    	0.98587     	6                eval state : final;
              	19.25414    	43.07479    	0.98587     	6                eval state : final;module_name : LarGP;cp_record_file : True;
---> end

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

  Demo lar cigp 
  seed: 1 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	75.99600    	184.52997   	0.65714     	0           
  10          	38.91063    	95.88019    	0.93148     	0           
  100         	20.92976    	53.67852    	0.97633     	0           
  300         	19.67145    	51.19997    	0.97837     	1           
  500         	19.06485    	49.89431    	0.97955     	2           
  1000        	18.18255    	47.84325    	0.98140     	4           
---> try to load best state
              	18.18255    	47.84325    	0.98140     	4                eval state : test_on_restore;
              	18.18255    	47.84325    	0.98140     	4                eval state : test_on_last_epoch;
---> final result
              	18.18255    	47.84325    	0.98140     	4                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	69.67972    	158.57646   	0.50611     	0           
  10          	132.31438   	294.52014   	-0.66340    	0           
  100         	80.87279    	181.44305   	0.64223     	0           
  300         	81.20853    	182.26581   	0.64065     	0           
  500         	81.09811    	182.04684   	0.64259     	1           
  1000        	80.92738    	181.71007   	0.64558     	1           
---> try to load best state
              	80.92738    	181.71007   	0.64558     	1                eval state : test_on_restore;
              	80.92738    	181.71007   	0.64558     	1                eval state : test_on_last_epoch;
---> final result
              	80.92738    	181.71007   	0.64558     	2                eval state : final;
              	80.92738    	181.71007   	0.64558     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	66.29153    	158.02701   	0.51858     	0           
  10          	85.99569    	231.63831   	0.19294     	0           
  100         	26.80631    	75.58119    	0.94813     	0           
  300         	25.95256    	74.16240    	0.94978     	0           
  500         	25.79292    	73.88650    	0.95024     	0           
  1000        	25.53716    	73.42818    	0.95101     	1           
---> try to load best state
              	25.53716    	73.42818    	0.95101     	1                eval state : test_on_restore;
              	25.53716    	73.42818    	0.95101     	1                eval state : test_on_last_epoch;
---> final result
              	25.53716    	73.42818    	0.95101     	2                eval state : final;
              	25.53716    	73.42818    	0.95101     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	39.36639    	94.58107    	0.86121     	0           
  10          	34.21551    	84.31185    	0.94143     	0           
  100         	20.79949    	55.91841    	0.97337     	0           
  300         	20.66580    	55.74606    	0.97380     	0           
  500         	20.54470    	55.56121    	0.97413     	1           
  1000        	20.35038    	55.26629    	0.97464     	2           
---> try to load best state
              	20.35038    	55.26629    	0.97464     	2                eval state : test_on_restore;
              	20.35038    	55.26629    	0.97464     	2                eval state : test_on_last_epoch;
---> final result
              	20.35038    	55.26629    	0.97464     	2                eval state : final;
              	20.35038    	55.26629    	0.97464     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	28.41557    	70.80547    	0.91328     	0           
  10          	25.01669    	64.19858    	0.96866     	0           
  100         	19.59447    	54.16884    	0.97666     	0           
  300         	19.46974    	53.90090    	0.97701     	1           
  500         	19.40520    	53.72951    	0.97723     	3           
  1000        	19.28151    	53.38109    	0.97762     	6           
---> try to load best state
              	19.28151    	53.38109    	0.97762     	6                eval state : test_on_restore;
              	19.28151    	53.38109    	0.97762     	6                eval state : test_on_last_epoch;
---> final result
              	19.28151    	53.38109    	0.97762     	6                eval state : final;
              	19.28151    	53.38109    	0.97762     	6                eval state : final;module_name : LarGP;cp_record_file : True;
---> end

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

  Demo lar cigp 
  seed: 2 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	73.56605    	207.01630   	0.61547     	0           
  10          	39.70878    	111.36401   	0.91968     	0           
  100         	23.80297    	59.13639    	0.97571     	0           
  300         	22.11681    	53.95059    	0.97915     	1           
  500         	21.36058    	51.80280    	0.98062     	2           
  1000        	20.34916    	49.10175    	0.98250     	4           
---> try to load best state
              	20.34916    	49.10175    	0.98250     	4                eval state : test_on_restore;
              	20.34916    	49.10175    	0.98250     	4                eval state : test_on_last_epoch;
---> final result
              	20.34916    	49.10175    	0.98250     	4                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	86.71059    	183.31876   	0.15654     	0           
  10          	153.67332   	336.68942   	-7.17531    	0           
  100         	67.16585    	159.26144   	0.67749     	0           
  300         	57.79638    	139.42392   	0.77360     	0           
  500         	59.23968    	141.76770   	0.76251     	0           
  1000        	63.09927    	148.61232   	0.72769     	1           
---> try to load best state
              	63.09927    	148.61232   	0.72769     	1                eval state : test_on_restore;
              	63.09927    	148.61232   	0.72769     	1                eval state : test_on_last_epoch;
---> final result
              	63.09927    	148.61232   	0.72769     	1                eval state : final;
              	63.09927    	148.61232   	0.72769     	1                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	66.97360    	160.21632   	0.55480     	0           
  10          	71.50190    	198.55894   	0.66411     	0           
  100         	31.80405    	88.37047    	0.93425     	0           
  300         	31.50319    	87.78274    	0.93507     	0           
  500         	31.32504    	87.50632    	0.93556     	0           
  1000        	31.05104    	87.13428    	0.93627     	1           
---> try to load best state
              	31.05104    	87.13428    	0.93627     	1                eval state : test_on_restore;
              	31.05104    	87.13428    	0.93627     	2                eval state : test_on_last_epoch;
---> final result
              	31.05104    	87.13428    	0.93627     	2                eval state : final;
              	31.05104    	87.13428    	0.93627     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	49.05066    	120.07815   	0.79256     	0           
  10          	41.65434    	119.05007   	0.90551     	0           
  100         	27.49056    	85.17836    	0.94249     	0           
  300         	27.97581    	87.08877    	0.94054     	0           
  500         	27.99836    	87.34291    	0.94044     	1           
  1000        	27.96944    	87.58156    	0.94047     	2           
---> try to load best state
              	27.96944    	87.58156    	0.94047     	2                eval state : test_on_restore;
              	27.96944    	87.58156    	0.94047     	2                eval state : test_on_last_epoch;
---> final result
              	27.96944    	87.58156    	0.94047     	2                eval state : final;
              	27.96944    	87.58156    	0.94047     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	33.71238    	82.78069    	0.89129     	0           
  10          	27.35278    	72.49001    	0.96737     	0           
  100         	21.27415    	53.59613    	0.98042     	0           
  300         	21.01947    	52.68989    	0.98111     	2           
  500         	20.83146    	52.02133    	0.98162     	3           
  1000        	20.48239    	50.84295    	0.98248     	6           
---> try to load best state
              	20.48239    	50.84295    	0.98248     	6                eval state : test_on_restore;
              	20.48239    	50.84295    	0.98248     	7                eval state : test_on_last_epoch;
---> final result
              	20.48239    	50.84295    	0.98248     	7                eval state : final;
              	20.48239    	50.84295    	0.98248     	7                eval state : final;module_name : LarGP;cp_record_file : True;
---> end

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

  Demo lar cigp 
  seed: 3 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	81.30335    	209.08717   	0.49110     	0           
  10          	40.74389    	103.61861   	0.92066     	0           
  100         	20.48189    	52.16479    	0.97915     	0           
  300         	18.57152    	47.49986    	0.98233     	1           
  500         	17.90269    	45.80355    	0.98346     	2           
  1000        	17.21288    	43.91983    	0.98472     	4           
---> try to load best state
              	17.21288    	43.91983    	0.98472     	4                eval state : test_on_restore;
              	17.21288    	43.91983    	0.98472     	4                eval state : test_on_last_epoch;
---> final result
              	17.21288    	43.91983    	0.98472     	4                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	84.06921    	185.11720   	-0.02436    	0           
  10          	165.51691   	378.51520   	-18.38124   	0           
  100         	127.39244   	294.21167   	-3.74806    	0           
  300         	173.32503   	393.80508   	-26.22984   	0           
  500         	192.72600   	433.91782   	-95.57949   	0           
  1000        	192.72321   	433.91248   	-95.51020   	1           
---> try to load best state
              	192.72321   	433.91248   	-95.51020   	1                eval state : test_on_restore;
              	192.72321   	433.91248   	-95.51020   	1                eval state : test_on_last_epoch;
---> final result
              	192.72321   	433.91248   	-95.51020   	1                eval state : final;
              	192.72321   	433.91248   	-95.51020   	1                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	61.00814    	144.57739   	0.56445     	0           
  10          	88.86061    	208.06415   	0.35696     	0           
  100         	47.12372    	111.53838   	0.85888     	0           
  300         	46.69212    	110.83889   	0.86107     	0           
  500         	46.29649    	110.16521   	0.86305     	1           
  1000        	45.65779    	109.10215   	0.86613     	1           
---> try to load best state
              	45.65779    	109.10215   	0.86613     	2                eval state : test_on_restore;
              	45.65779    	109.10215   	0.86613     	2                eval state : test_on_last_epoch;
---> final result
              	45.65779    	109.10215   	0.86613     	2                eval state : final;
              	45.65779    	109.10215   	0.86613     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	39.90279    	99.32671    	0.83075     	0           
  10          	42.77391    	107.22472   	0.88986     	0           
  100         	24.87490    	64.04308    	0.95889     	0           
  300         	24.76324    	63.65628    	0.95955     	0           
  500         	24.72440    	63.49843    	0.95991     	1           
  1000        	24.66521    	63.25041    	0.96046     	2           
---> try to load best state
              	24.66521    	63.25041    	0.96046     	2                eval state : test_on_restore;
              	24.66521    	63.25041    	0.96046     	2                eval state : test_on_last_epoch;
---> final result
              	24.66521    	63.25041    	0.96046     	2                eval state : final;
              	24.66521    	63.25041    	0.96046     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	30.60373    	77.38129    	0.90456     	0           
  10          	25.44524    	63.80448    	0.97180     	0           
  100         	17.30738    	45.07804    	0.98421     	0           
  300         	17.17989    	44.59936    	0.98465     	2           
  500         	17.12301    	44.34075    	0.98489     	3           
  1000        	17.04313    	43.91873    	0.98527     	6           
---> try to load best state
              	17.04313    	43.91873    	0.98527     	6                eval state : test_on_restore;
              	17.04313    	43.91873    	0.98527     	6                eval state : test_on_last_epoch;
---> final result
              	17.04313    	43.91873    	0.98527     	6                eval state : final;
              	17.04313    	43.91873    	0.98527     	6                eval state : final;module_name : LarGP;cp_record_file : True;
---> end

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

  Demo lar cigp 
  seed: 4 
  interp_data: True 

----------------------------------------
---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	64.41850    	154.16219   	0.85957     	0           
  10          	39.27601    	92.11664    	0.95262     	0           
  100         	20.77731    	51.66080    	0.98297     	0           
  300         	19.24681    	48.48490    	0.98477     	1           
  500         	18.68410    	47.14214    	0.98561     	2           
  1000        	18.06490    	45.44364    	0.98672     	4           
---> try to load best state
              	18.06490    	45.44364    	0.98672     	4                eval state : test_on_restore;
              	18.06490    	45.44364    	0.98672     	4                eval state : test_on_last_epoch;
---> final result
              	18.06490    	45.44364    	0.98672     	4                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	84.35358    	183.95657   	0.07436     	0           
  10          	152.51875   	360.18417   	-7.26186    	0           
  100         	87.39002    	203.70053   	0.20992     	0           
  300         	87.00132    	202.79768   	0.22347     	0           
  500         	85.16006    	197.74231   	0.28070     	0           
  1000        	91.76270    	209.04695   	0.14375     	1           
---> try to load best state
              	91.76270    	209.04695   	0.14375     	1                eval state : test_on_restore;
              	91.76270    	209.04695   	0.14375     	1                eval state : test_on_last_epoch;
---> final result
              	91.76270    	209.04695   	0.14375     	1                eval state : final;
              	91.76270    	209.04695   	0.14375     	1                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	45.04094    	106.73113   	0.80958     	0           
  10          	41.75407    	109.51488   	0.89624     	0           
  100         	28.03608    	75.13505    	0.95421     	0           
  300         	28.07319    	75.04601    	0.95455     	0           
  500         	28.12700    	75.05325    	0.95474     	1           
  1000        	28.22555    	75.07973    	0.95503     	1           
---> try to load best state
              	28.22555    	75.07973    	0.95503     	2                eval state : test_on_restore;
              	28.22555    	75.07973    	0.95503     	2                eval state : test_on_last_epoch;
---> final result
              	28.22555    	75.07973    	0.95503     	2                eval state : final;
              	28.22555    	75.07973    	0.95503     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	38.31286    	91.80177    	0.87157     	0           
  10          	36.74564    	90.14525    	0.93748     	0           
  100         	24.10585    	61.80384    	0.96701     	0           
  300         	24.01204    	61.47366    	0.96738     	0           
  500         	23.94156    	61.23399    	0.96765     	1           
  1000        	23.82423    	60.83280    	0.96809     	2           
---> try to load best state
              	23.82423    	60.83280    	0.96809     	2                eval state : test_on_restore;
              	23.82423    	60.83280    	0.96809     	2                eval state : test_on_last_epoch;
---> final result
              	23.82423    	60.83280    	0.96809     	2                eval state : final;
              	23.82423    	60.83280    	0.96809     	2                eval state : final;module_name : LarGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'SOFC_MF', 'interp_data': True, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.1, 'optional_param': 0.1, 'noise': 0.1}
  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_rho'}
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	26.84177    	60.44727    	0.93439     	0           
  10          	25.07425    	61.68858    	0.97732     	0           
  100         	19.39123    	54.13858    	0.98047     	0           
  300         	19.12294    	53.33708    	0.98119     	1           
  500         	18.90866    	52.54626    	0.98187     	3           
  1000        	18.57338    	51.19981    	0.98299     	6           
---> try to load best state
              	18.57338    	51.19981    	0.98299     	6                eval state : test_on_restore;
              	18.57338    	51.19981    	0.98299     	6                eval state : test_on_last_epoch;
---> final result
              	18.57338    	51.19981    	0.98299     	6                eval state : final;
              	18.57338    	51.19981    	0.98299     	6                eval state : final;module_name : LarGP;cp_record_file : True;
