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

  Demo res cigp 
  seed: None 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'MolecularDynamic_MF', 'interp_data': False, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  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           	5.46412     	7.79607     	-19125071.41060	0           
  10          	5.46385     	7.79565     	-6037007.14509	0           
  100         	5.47717     	7.81723     	-11568.78195	0           
  300         	5.49882     	7.85535     	-835.75470  	0           
  500         	5.49728     	7.85919     	-283.13618  	1           
  1000        	5.47152     	7.84088     	-74.54732   	2           
---> try to load best state
              	5.47152     	7.84088     	-74.54732   	2                eval state : test_on_restore;
              	5.47152     	7.84088     	-74.54732   	2                eval state : test_on_last_epoch;
---> final result
              	5.47152     	7.84088     	-74.54732   	2                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	5.83831     	8.35928     	-84.79881   	0           
  10          	5.83831     	8.35928     	-84.79881   	0           
  100         	5.83831     	8.35928     	-84.79881   	0           
  300         	5.83831     	8.35928     	-84.79881   	0           
  500         	5.83831     	8.35928     	-84.79881   	1           
  1000        	5.83831     	8.35928     	-84.79881   	2           
---> try to load best state
              	5.83831     	8.35928     	-84.79881   	2                eval state : test_on_restore;
              	5.83831     	8.35928     	-84.79881   	2                eval state : test_on_last_epoch;
---> final result
              	5.83831     	8.35928     	-84.79881   	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': 'MolecularDynamic_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           	5.83831     	8.35928     	-84.79883   	0           
  10          	5.83831     	8.35928     	-84.79883   	0           
  100         	5.83831     	8.35928     	-84.79883   	0           
  300         	5.83831     	8.35928     	-84.79883   	0           
  500         	5.83831     	8.35928     	-84.79883   	1           
  1000        	5.83831     	8.35928     	-84.79883   	2           
---> try to load best state
              	5.83831     	8.35928     	-84.79883   	2                eval state : test_on_restore;
              	5.83831     	8.35928     	-84.79883   	2                eval state : test_on_last_epoch;
---> final result
              	5.83831     	8.35928     	-84.79883   	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': 'MolecularDynamic_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           	5.83831     	8.35928     	-84.79885   	0           
  10          	5.83831     	8.35928     	-84.79885   	0           
  100         	5.83831     	8.35928     	-84.79885   	0           
  300         	5.83831     	8.35928     	-84.79885   	0           
  500         	5.83831     	8.35928     	-84.79885   	1           
  1000        	5.83831     	8.35928     	-84.79885   	2           
---> try to load best state
              	5.83831     	8.35928     	-84.79885   	2                eval state : test_on_restore;
              	5.83831     	8.35928     	-84.79885   	2                eval state : test_on_last_epoch;
---> final result
              	5.83831     	8.35928     	-84.79885   	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': 'MolecularDynamic_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           	5.83836     	8.35932     	-84.84229   	0           
  10          	5.83835     	8.35931     	-84.82864   	0           
  100         	5.83831     	8.35928     	-84.79894   	0           
  300         	5.83831     	8.35928     	-84.79894   	0           
  500         	5.83831     	8.35928     	-84.79896   	1           
  1000        	5.83832     	8.35928     	-84.79909   	2           
---> try to load best state
              	5.83832     	8.35928     	-84.79909   	2                eval state : test_on_restore;
              	5.83832     	8.35928     	-84.79909   	2                eval state : test_on_last_epoch;
---> final result
              	5.83832     	8.35928     	-84.79909   	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'MolecularDynamic_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  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           	2.19682     	3.38630     	-2.80923    	0           
  10          	1.71870     	2.66809     	-1.50944    	0           
  100         	1.99292     	3.18268     	-2.17355    	0           
  300         	2.36800     	3.84937     	-2.21041    	0           
  500         	2.55390     	4.17186     	-2.13907    	1           
  1000        	2.66613     	4.39263     	-2.00922    	2           
---> try to load best state
              	2.66613     	4.39263     	-2.00922    	2                eval state : test_on_restore;
              	2.66613     	4.39263     	-2.00922    	2                eval state : test_on_last_epoch;
---> final result
              	2.66613     	4.39263     	-2.00922    	2                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	3.32957     	5.20559     	-4.65577    	0           
  10          	3.38146     	5.26252     	-4.85004    	0           
  100         	3.56133     	5.50055     	-5.41731    	0           
  300         	3.20987     	4.99688     	-5.29639    	0           
  500         	2.97456     	4.64598     	-5.16036    	0           
  1000        	2.74197     	4.29628     	-4.91271    	1           
---> try to load best state
              	2.74197     	4.29628     	-4.91271    	1                eval state : test_on_restore;
              	2.74197     	4.29628     	-4.91271    	1                eval state : test_on_last_epoch;
---> final result
              	2.74197     	4.29628     	-4.91271    	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': 'MolecularDynamic_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           	3.33912     	5.22481     	-4.49958    	0           
  10          	3.39526     	5.28542     	-4.68726    	0           
  100         	3.92583     	5.99093     	-5.59493    	0           
  300         	4.43797     	6.80994     	-5.16138    	0           
  500         	4.57078     	7.05064     	-4.80575    	0           
  1000        	4.65008     	7.20355     	-4.53437    	1           
---> try to load best state
              	4.65008     	7.20355     	-4.53437    	1                eval state : test_on_restore;
              	4.65008     	7.20355     	-4.53437    	1                eval state : test_on_last_epoch;
---> final result
              	4.65008     	7.20355     	-4.53437    	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': 'MolecularDynamic_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           	3.50306     	5.46118     	-4.51122    	0           
  10          	3.54847     	5.53647     	-4.44967    	0           
  100         	3.44023     	5.30618     	-4.61987    	0           
  300         	4.73467     	7.10618     	-6.69245    	0           
  500         	5.76094     	8.62219     	-7.30054    	0           
  1000        	6.83554     	10.27299    	-6.56694    	1           
---> try to load best state
              	6.83554     	10.27299    	-6.56694    	1                eval state : test_on_restore;
              	6.83554     	10.27299    	-6.56694    	1                eval state : test_on_last_epoch;
---> final result
              	6.83554     	10.27299    	-6.56694    	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	3.80870     	5.82529     	-5.49616    	0           
  10          	3.86310     	6.01226     	-4.23853    	0           
  100         	3.32535     	5.04878     	-5.91695    	0           
  300         	3.91870     	5.80407     	-9.67920    	0           
  500         	4.38089     	6.47074     	-11.04400   	0           
  1000        	4.73485     	6.99806     	-11.19986   	1           
---> try to load best state
              	4.73485     	6.99806     	-11.19986   	1                eval state : test_on_restore;
              	4.73485     	6.99806     	-11.19986   	1                eval state : test_on_last_epoch;
---> final result
              	4.73485     	6.99806     	-11.19986   	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'MolecularDynamic_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  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           	1.47471     	2.17294     	-0.60739    	0           
  10          	1.30368     	2.04968     	-0.23809    	0           
  100         	1.96209     	2.99189     	-0.83603    	0           
  300         	1.85907     	2.85564     	-0.67231    	0           
  500         	1.79672     	2.77500     	-0.58679    	1           
  1000        	1.69614     	2.64695     	-0.46883    	2           
---> try to load best state
              	1.69614     	2.64695     	-0.46883    	2                eval state : test_on_restore;
              	1.69614     	2.64695     	-0.46883    	2                eval state : test_on_last_epoch;
---> final result
              	1.69614     	2.64695     	-0.46883    	2                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	2.31729     	3.91763     	-1.62228    	0           
  10          	2.31729     	3.91763     	-1.62228    	0           
  100         	2.31729     	3.91763     	-1.62228    	0           
  300         	2.31729     	3.91763     	-1.62228    	0           
  500         	2.31729     	3.91763     	-1.62228    	0           
  1000        	2.31729     	3.91763     	-1.62228    	1           
---> try to load best state
              	2.31729     	3.91763     	-1.62228    	1                eval state : test_on_restore;
              	2.31729     	3.91763     	-1.62228    	1                eval state : test_on_last_epoch;
---> final result
              	2.31729     	3.91763     	-1.62228    	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': 'MolecularDynamic_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           	2.36503     	3.96330     	-2.98543    	0           
  10          	2.44434     	4.02211     	-3.39408    	0           
  100         	2.62915     	4.28838     	-3.54700    	0           
  300         	2.46270     	4.11863     	-2.64879    	0           
  500         	2.28195     	3.86973     	-2.20711    	0           
  1000        	2.09373     	3.58558     	-1.86234    	1           
---> try to load best state
              	2.09373     	3.58558     	-1.86234    	1                eval state : test_on_restore;
              	2.09373     	3.58558     	-1.86234    	1                eval state : test_on_last_epoch;
---> final result
              	2.09373     	3.58558     	-1.86234    	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': 'MolecularDynamic_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           	2.98121     	4.79240     	-3.31032    	0           
  10          	2.67579     	4.38605     	-2.68739    	0           
  100         	2.32057     	3.93019     	-2.59708    	0           
  300         	2.31650     	3.92622     	-2.56088    	0           
  500         	2.31758     	3.92715     	-2.57195    	0           
  1000        	2.32088     	3.92999     	-2.60423    	1           
---> try to load best state
              	2.32088     	3.92999     	-2.60423    	1                eval state : test_on_restore;
              	2.32088     	3.92999     	-2.60423    	1                eval state : test_on_last_epoch;
---> final result
              	2.32088     	3.92999     	-2.60423    	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	2.70846     	4.34204     	-4.09206    	0           
  10          	2.83489     	4.55326     	-3.39718    	0           
  100         	2.42862     	4.01229     	-3.50967    	0           
  300         	2.41918     	4.00394     	-3.45161    	0           
  500         	2.42546     	4.00964     	-3.48891    	1           
  1000        	2.44159     	4.02497     	-3.57506    	2           
---> try to load best state
              	2.44159     	4.02497     	-3.57506    	2                eval state : test_on_restore;
              	2.44159     	4.02497     	-3.57506    	2                eval state : test_on_last_epoch;
---> final result
              	2.44159     	4.02497     	-3.57506    	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 2 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'MolecularDynamic_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  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           	1.28887     	1.95074     	-0.39441    	0           
  10          	1.23395     	1.85894     	-0.33850    	0           
  100         	1.60338     	2.51786     	-0.55230    	0           
  300         	2.12581     	3.48400     	-0.58290    	0           
  500         	2.45607     	4.10761     	-0.56947    	1           
  1000        	2.93281     	5.03568     	-0.53690    	1           
---> try to load best state
              	2.93281     	5.03568     	-0.53690    	1                eval state : test_on_restore;
              	2.93281     	5.03568     	-0.53690    	1                eval state : test_on_last_epoch;
---> final result
              	2.93281     	5.03568     	-0.53690    	1                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	3.83121     	6.62601     	-1.47287    	0           
  10          	3.85388     	6.66674     	-1.39239    	0           
  100         	3.26687     	5.81179     	-1.07825    	0           
  300         	3.43251     	6.08227     	-1.20129    	0           
  500         	3.44003     	6.09405     	-1.20950    	0           
  1000        	3.42367     	6.06907     	-1.21015    	1           
---> try to load best state
              	3.42367     	6.06907     	-1.21015    	1                eval state : test_on_restore;
              	3.42367     	6.06907     	-1.21015    	1                eval state : test_on_last_epoch;
---> final result
              	3.42367     	6.06907     	-1.21015    	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': 'MolecularDynamic_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           	3.62727     	6.35584     	-1.47667    	0           
  10          	3.69960     	6.44186     	-1.60239    	0           
  100         	5.31872     	8.80129     	-2.17327    	0           
  300         	5.59644     	9.29286     	-2.05378    	0           
  500         	5.66856     	9.42639     	-2.01481    	0           
  1000        	5.74433     	9.54210     	-2.02459    	1           
---> try to load best state
              	5.74433     	9.54210     	-2.02459    	1                eval state : test_on_restore;
              	5.74433     	9.54210     	-2.02459    	1                eval state : test_on_last_epoch;
---> final result
              	5.74433     	9.54210     	-2.02459    	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': 'MolecularDynamic_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           	3.88609     	6.70182     	-1.76083    	0           
  10          	3.72229     	6.52449     	-1.49642    	0           
  100         	4.75700     	7.80045     	-2.51466    	0           
  300         	5.49941     	8.99458     	-2.38922    	0           
  500         	5.74907     	9.43863     	-2.26317    	1           
  1000        	5.86493     	9.66452     	-2.17287    	2           
---> try to load best state
              	5.86493     	9.66452     	-2.17287    	2                eval state : test_on_restore;
              	5.86493     	9.66452     	-2.17287    	2                eval state : test_on_last_epoch;
---> final result
              	5.86493     	9.66452     	-2.17287    	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': 'MolecularDynamic_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           	3.96199     	6.69420     	-2.02546    	0           
  10          	3.92149     	6.57878     	-2.26779    	0           
  100         	3.69262     	6.39100     	-1.87749    	0           
  300         	3.68389     	6.38478     	-1.86181    	0           
  500         	3.68325     	6.38359     	-1.86234    	1           
  1000        	3.68224     	6.38096     	-1.86320    	2           
---> try to load best state
              	3.68224     	6.38096     	-1.86320    	2                eval state : test_on_restore;
              	3.68224     	6.38096     	-1.86320    	2                eval state : test_on_last_epoch;
---> final result
              	3.68224     	6.38096     	-1.86320    	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 3 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'MolecularDynamic_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  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           	0.87586     	1.48982     	-0.28394    	0           
  10          	1.01576     	1.63664     	-0.44569    	0           
  100         	0.84735     	1.42724     	-0.12192    	0           
  300         	0.70120     	1.27763     	0.10973     	0           
  500         	0.78256     	1.38233     	0.10773     	1           
  1000        	0.99984     	1.73038     	0.02361     	2           
---> try to load best state
              	0.99984     	1.73038     	0.02361     	2                eval state : test_on_restore;
              	0.99984     	1.73038     	0.02361     	2                eval state : test_on_last_epoch;
---> final result
              	0.99984     	1.73038     	0.02361     	2                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	1.08068     	1.82094     	-0.08974    	0           
  10          	1.10268     	1.85143     	-0.08097    	0           
  100         	1.39750     	2.43745     	0.02899     	0           
  300         	1.73542     	3.17206     	0.09476     	0           
  500         	1.91872     	3.48488     	0.10478     	0           
  1000        	2.07508     	3.70700     	0.10763     	1           
---> try to load best state
              	2.07508     	3.70700     	0.10763     	1                eval state : test_on_restore;
              	2.07508     	3.70700     	0.10763     	1                eval state : test_on_last_epoch;
---> final result
              	2.07508     	3.70700     	0.10763     	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': 'MolecularDynamic_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           	1.10376     	1.84856     	-0.06730    	0           
  10          	1.10147     	1.84457     	-0.06088    	0           
  100         	1.24452     	2.16301     	-0.28611    	0           
  300         	1.41497     	2.46103     	-0.15467    	0           
  500         	1.37714     	2.43159     	0.01296     	0           
  1000        	1.38726     	2.52631     	0.11633     	1           
---> try to load best state
              	1.38726     	2.52631     	0.11633     	1                eval state : test_on_restore;
              	1.38726     	2.52631     	0.11633     	1                eval state : test_on_last_epoch;
---> final result
              	1.38726     	2.52631     	0.11633     	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': 'MolecularDynamic_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           	1.08400     	1.83338     	-0.12009    	0           
  10          	1.11640     	1.87953     	-0.10847    	0           
  100         	1.23222     	2.20371     	-0.31310    	0           
  300         	1.69594     	2.82055     	-1.44362    	0           
  500         	2.01072     	3.29208     	-2.39815    	0           
  1000        	2.25415     	3.81085     	-2.17988    	1           
---> try to load best state
              	2.25415     	3.81085     	-2.17988    	1                eval state : test_on_restore;
              	2.25415     	3.81085     	-2.17988    	1                eval state : test_on_last_epoch;
---> final result
              	2.25415     	3.81085     	-2.17988    	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	1.13157     	1.98792     	-0.17335    	0           
  10          	1.16382     	2.02917     	-0.41062    	0           
  100         	1.16011     	2.05064     	0.05843     	0           
  300         	1.24762     	2.40543     	0.00413     	0           
  500         	1.50005     	2.85712     	-0.22905    	0           
  1000        	2.03623     	3.50535     	-0.74079    	1           
---> try to load best state
              	2.03623     	3.50535     	-0.74079    	2                eval state : test_on_restore;
              	2.03623     	3.50535     	-0.74079    	2                eval state : test_on_last_epoch;
---> final result
              	2.03623     	3.50535     	-0.74079    	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 4 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'MolecularDynamic_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  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           	0.20337     	0.35013     	0.43110     	0           
  10          	0.34280     	0.62046     	0.33431     	0           
  100         	0.64747     	1.06113     	0.00505     	0           
  300         	0.24875     	0.47388     	0.41139     	0           
  500         	0.44969     	0.71910     	0.28726     	0           
  1000        	1.01962     	1.64246     	-0.77506    	2           
---> try to load best state
              	1.01962     	1.64246     	-0.77506    	2                eval state : test_on_restore;
              	1.01962     	1.64246     	-0.77506    	2                eval state : test_on_last_epoch;
---> final result
              	1.01962     	1.64246     	-0.77506    	2                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	0.95931     	1.60494     	-0.82700    	0           
  10          	0.96710     	1.62225     	-0.83330    	0           
  100         	1.03234     	1.74547     	-0.73971    	0           
  300         	1.02701     	1.74246     	-0.69649    	0           
  500         	1.01602     	1.72685     	-0.69662    	0           
  1000        	1.00602     	1.70851     	-0.69997    	1           
---> try to load best state
              	1.00602     	1.70851     	-0.69997    	1                eval state : test_on_restore;
              	1.00602     	1.70851     	-0.69997    	1                eval state : test_on_last_epoch;
---> final result
              	1.00602     	1.70851     	-0.69997    	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': 'MolecularDynamic_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           	0.93519     	1.55469     	-0.77726    	0           
  10          	0.90359     	1.50209     	-0.73648    	0           
  100         	0.83557     	1.40799     	-0.78318    	0           
  300         	0.97592     	1.68356     	-0.70233    	0           
  500         	0.99557     	1.73837     	-0.64612    	0           
  1000        	0.99163     	1.74917     	-0.60315    	1           
---> try to load best state
              	0.99163     	1.74917     	-0.60315    	1                eval state : test_on_restore;
              	0.99163     	1.74917     	-0.60315    	1                eval state : test_on_last_epoch;
---> final result
              	0.99163     	1.74917     	-0.60315    	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': 'MolecularDynamic_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           	0.82699     	1.35556     	-0.36515    	0           
  10          	0.80331     	1.31523     	-0.33861    	0           
  100         	0.66358     	1.09551     	-0.24573    	0           
  300         	0.77756     	1.39721     	-0.72828    	0           
  500         	0.90747     	1.62336     	-0.71324    	0           
  1000        	0.97443     	1.73204     	-0.60703    	1           
---> try to load best state
              	0.97443     	1.73204     	-0.60703    	1                eval state : test_on_restore;
              	0.97443     	1.73204     	-0.60703    	1                eval state : test_on_last_epoch;
---> final result
              	0.97443     	1.73204     	-0.60703    	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'MolecularDynamic_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           	0.61958     	1.04908     	-0.16595    	0           
  10          	0.65147     	1.13630     	-0.45191    	0           
  100         	0.63209     	1.16343     	-0.51399    	0           
  300         	0.89665     	1.74537     	-1.15783    	0           
  500         	1.01373     	1.96753     	-1.07035    	0           
  1000        	1.07627     	2.08443     	-0.92009    	1           
---> try to load best state
              	1.07627     	2.08443     	-0.92009    	1                eval state : test_on_restore;
              	1.07627     	2.08443     	-0.92009    	1                eval state : test_on_last_epoch;
---> final result
              	1.07627     	2.08443     	-0.92009    	1                eval state : final;module_name : ResGP;cp_record_file : True;
