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

  Demo res cigp 
  seed: None 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'FlowMix3D_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           	229.16650   	400.25040   	-218717.34231	0           
  10          	228.86861   	399.94827   	-42056.28915	0           
  100         	227.20862   	398.14847   	-2842.27901 	0           
  300         	226.96686   	397.87500   	-2355.59869 	0           
  500         	227.01396   	397.92734   	-2432.29548 	1           
  1000        	227.12428   	398.04999   	-2631.96184 	2           
---> try to load best state
              	227.12428   	398.04999   	-2631.96184 	2                eval state : test_on_restore;
              	227.12428   	398.04999   	-2631.96184 	2                eval state : test_on_last_epoch;
---> final result
              	227.12428   	398.04999   	-2631.96184 	2                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_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           	231.84033   	406.04324   	-2740.65448 	0           
  10          	231.84033   	406.04324   	-2740.65448 	0           
  100         	231.84033   	406.04324   	-2740.65448 	0           
  300         	231.84033   	406.04324   	-2740.65448 	0           
  500         	231.84033   	406.04324   	-2740.65448 	1           
  1000        	231.84033   	406.04324   	-2740.65448 	2           
---> try to load best state
              	231.84033   	406.04324   	-2740.65448 	2                eval state : test_on_restore;
              	231.84033   	406.04324   	-2740.65448 	2                eval state : test_on_last_epoch;
---> final result
              	231.84033   	406.04324   	-2740.65448 	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': 'FlowMix3D_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           	231.84033   	406.04324   	-2740.65251 	0           
  10          	231.84033   	406.04324   	-2740.65251 	0           
  100         	231.84033   	406.04324   	-2740.65251 	0           
  300         	231.84033   	406.04324   	-2740.65251 	0           
  500         	231.84033   	406.04324   	-2740.65251 	1           
  1000        	231.84033   	406.04324   	-2740.65251 	2           
---> try to load best state
              	231.84033   	406.04324   	-2740.65251 	2                eval state : test_on_restore;
              	231.84033   	406.04324   	-2740.65251 	2                eval state : test_on_last_epoch;
---> final result
              	231.84033   	406.04324   	-2740.65251 	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': 'FlowMix3D_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           	231.84033   	406.04324   	-2740.64734 	0           
  10          	231.84033   	406.04324   	-2740.64734 	0           
  100         	231.84033   	406.04324   	-2740.64734 	0           
  300         	231.84033   	406.04324   	-2740.64734 	0           
  500         	231.84033   	406.04324   	-2740.64734 	1           
  1000        	231.84033   	406.04324   	-2740.64734 	1           
---> try to load best state
              	231.84033   	406.04324   	-2740.64734 	1                eval state : test_on_restore;
              	231.84033   	406.04324   	-2740.64734 	1                eval state : test_on_last_epoch;
---> final result
              	231.84033   	406.04324   	-2740.64734 	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': 'FlowMix3D_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           	231.79378   	405.99063   	-2726.54161 	0           
  10          	231.82585   	406.02496   	-2730.62625 	0           
  100         	231.84013   	406.04297   	-2740.04080 	0           
  300         	231.83998   	406.04272   	-2739.64149 	0           
  500         	231.83983   	406.04251   	-2739.22458 	0           
  1000        	231.83931   	406.04178   	-2738.14767 	1           
---> try to load best state
              	231.83931   	406.04178   	-2738.14767 	1                eval state : test_on_restore;
              	231.83931   	406.04178   	-2738.14767 	1                eval state : test_on_last_epoch;
---> final result
              	231.83931   	406.04178   	-2738.14767 	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'FlowMix3D_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           	136.96867   	288.47672   	-20.63287   	0           
  10          	130.51237   	280.25156   	-18.87523   	0           
  100         	109.15409   	248.18044   	-15.00918   	0           
  300         	103.16663   	237.97774   	-14.41623   	0           
  500         	102.52216   	236.90501   	-14.34115   	0           
  1000        	103.31834   	238.44788   	-14.34687   	1           
---> try to load best state
              	103.31834   	238.44788   	-14.34687   	1                eval state : test_on_restore;
              	103.31834   	238.44788   	-14.34687   	1                eval state : test_on_last_epoch;
---> final result
              	103.31834   	238.44788   	-14.34687   	1                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_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           	110.19608   	244.66406   	-15.06788   	0           
  10          	110.01672   	244.55495   	-15.08661   	0           
  100         	109.98666   	244.53287   	-15.12692   	0           
  300         	110.02512   	244.55556   	-15.11979   	0           
  500         	110.02466   	244.55540   	-15.11915   	0           
  1000        	110.02345   	244.55499   	-15.11744   	1           
---> try to load best state
              	110.02345   	244.55499   	-15.11744   	1                eval state : test_on_restore;
              	110.02345   	244.55499   	-15.11744   	1                eval state : test_on_last_epoch;
---> final result
              	110.02345   	244.55499   	-15.11744   	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': 'FlowMix3D_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           	110.16709   	244.94810   	-14.86680   	0           
  10          	109.94250   	244.95474   	-14.80919   	0           
  100         	109.64278   	245.28629   	-14.92042   	0           
  300         	109.68411   	245.66965   	-15.02659   	0           
  500         	109.71085   	245.86205   	-15.05297   	0           
----------------------------------------

  Demo res cigp 
  seed: None 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'FlowMix3D_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           	229.16650   	400.25040   	-218717.34231	0           
  10          	228.86861   	399.94827   	-42056.28915	0           
  100         	227.20862   	398.14847   	-2842.27901 	0           
  300         	226.96686   	397.87500   	-2355.59869 	0           
  500         	227.01396   	397.92734   	-2432.29548 	0           
  1000        	227.12428   	398.04999   	-2631.96184 	1           
---> try to load best state
              	227.12428   	398.04999   	-2631.96184 	1                eval state : test_on_restore;
              	227.12428   	398.04999   	-2631.96184 	1                eval state : test_on_last_epoch;
---> final result
              	227.12428   	398.04999   	-2631.96184 	1                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_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           	231.84033   	406.04324   	-2740.65448 	0           
  10          	231.84033   	406.04324   	-2740.65448 	0           
  100         	231.84033   	406.04324   	-2740.65448 	0           
  300         	231.84033   	406.04324   	-2740.65448 	0           
  500         	231.84033   	406.04324   	-2740.65448 	0           
  1000        	231.84033   	406.04324   	-2740.65448 	1           
---> try to load best state
              	231.84033   	406.04324   	-2740.65448 	1                eval state : test_on_restore;
              	231.84033   	406.04324   	-2740.65448 	1                eval state : test_on_last_epoch;
---> final result
              	231.84033   	406.04324   	-2740.65448 	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': 'FlowMix3D_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           	231.84033   	406.04324   	-2740.65251 	0           
  10          	231.84033   	406.04324   	-2740.65251 	0           
  100         	231.84033   	406.04324   	-2740.65251 	0           
  300         	231.84033   	406.04324   	-2740.65251 	0           
  500         	231.84033   	406.04324   	-2740.65251 	0           
  1000        	231.84033   	406.04324   	-2740.65251 	1           
---> try to load best state
              	231.84033   	406.04324   	-2740.65251 	1                eval state : test_on_restore;
              	231.84033   	406.04324   	-2740.65251 	1                eval state : test_on_last_epoch;
---> final result
              	231.84033   	406.04324   	-2740.65251 	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': 'FlowMix3D_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           	231.84033   	406.04324   	-2740.64734 	0           
  10          	231.84033   	406.04324   	-2740.64734 	0           
  100         	231.84033   	406.04324   	-2740.64734 	0           
  300         	231.84033   	406.04324   	-2740.64734 	0           
  500         	231.84033   	406.04324   	-2740.64734 	0           
  1000        	231.84033   	406.04324   	-2740.64734 	1           
---> try to load best state
              	231.84033   	406.04324   	-2740.64734 	1                eval state : test_on_restore;
              	231.84033   	406.04324   	-2740.64734 	1                eval state : test_on_last_epoch;
---> final result
              	231.84033   	406.04324   	-2740.64734 	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': 'FlowMix3D_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           	231.79378   	405.99063   	-2726.54161 	0           
  10          	231.82585   	406.02496   	-2730.62625 	0           
  100         	231.84013   	406.04297   	-2740.04080 	0           
  300         	231.83998   	406.04272   	-2739.64149 	0           
  500         	231.83983   	406.04251   	-2739.22458 	1           
  1000        	231.83931   	406.04178   	-2738.14767 	1           
---> try to load best state
              	231.83931   	406.04178   	-2738.14767 	1                eval state : test_on_restore;
              	231.83931   	406.04178   	-2738.14767 	1                eval state : test_on_last_epoch;
---> final result
              	231.83931   	406.04178   	-2738.14767 	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'FlowMix3D_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           	136.96867   	288.47672   	-20.63287   	0           
  10          	130.51237   	280.25156   	-18.87523   	0           
  100         	109.15409   	248.18044   	-15.00918   	0           
  300         	103.16663   	237.97774   	-14.41623   	0           
  500         	102.52216   	236.90501   	-14.34115   	0           
  1000        	103.31834   	238.44788   	-14.34687   	1           
---> try to load best state
              	103.31834   	238.44788   	-14.34687   	1                eval state : test_on_restore;
              	103.31834   	238.44788   	-14.34687   	1                eval state : test_on_last_epoch;
---> final result
              	103.31834   	238.44788   	-14.34687   	1                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_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           	110.19608   	244.66406   	-15.06788   	0           
  10          	110.01672   	244.55495   	-15.08661   	0           
  100         	109.98666   	244.53287   	-15.12692   	0           
  300         	110.02512   	244.55556   	-15.11979   	0           
  500         	110.02466   	244.55540   	-15.11915   	0           
  1000        	110.02345   	244.55499   	-15.11744   	1           
---> try to load best state
              	110.02345   	244.55499   	-15.11744   	1                eval state : test_on_restore;
              	110.02345   	244.55499   	-15.11744   	1                eval state : test_on_last_epoch;
---> final result
              	110.02345   	244.55499   	-15.11744   	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': 'FlowMix3D_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           	110.16709   	244.94810   	-14.86680   	0           
  10          	109.94250   	244.95474   	-14.80919   	0           
  100         	109.64278   	245.28629   	-14.92042   	0           
  300         	109.68411   	245.66965   	-15.02659   	0           
  500         	109.71085   	245.86205   	-15.05297   	0           
  1000        	109.75230   	246.03239   	-15.06745   	1           
---> try to load best state
              	109.75230   	246.03239   	-15.06745   	1                eval state : test_on_restore;
              	109.75230   	246.03239   	-15.06745   	1                eval state : test_on_last_epoch;
---> final result
              	109.75230   	246.03239   	-15.06745   	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': 'FlowMix3D_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           	109.37565   	244.14458   	-14.65270   	0           
  10          	109.22733   	243.98724   	-14.48001   	0           
  100         	108.98933   	243.62556   	-14.15858   	0           
  300         	108.95414   	243.46576   	-13.96635   	0           
  500         	108.95016   	243.41182   	-13.91448   	0           
  1000        	108.90929   	243.32962   	-13.90864   	1           
---> try to load best state
              	108.90929   	243.32962   	-13.90864   	1                eval state : test_on_restore;
              	108.90929   	243.32962   	-13.90864   	1                eval state : test_on_last_epoch;
---> final result
              	108.90929   	243.32962   	-13.90864   	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': 'FlowMix3D_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           	108.68047   	243.85837   	-14.19427   	0           
  10          	108.39557   	243.74312   	-13.82951   	0           
  100         	108.29923   	243.65584   	-13.61576   	0           
  300         	108.19125   	243.51312   	-13.58342   	0           
  500         	108.22650   	243.50916   	-13.64235   	0           
  1000        	108.46433   	243.65492   	-13.92248   	2           
---> try to load best state
              	108.46433   	243.65492   	-13.92248   	2                eval state : test_on_restore;
              	108.46433   	243.65492   	-13.92248   	2                eval state : test_on_last_epoch;
---> final result
              	108.46433   	243.65492   	-13.92248   	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'FlowMix3D_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           	141.62970   	295.41553   	-21.97943   	0           
  10          	135.75763   	288.24619   	-19.63268   	0           
  100         	111.21845   	252.30324   	-15.99886   	0           
  300         	103.88740   	239.70702   	-15.51748   	0           
  500         	102.52061   	237.30698   	-15.41491   	0           
  1000        	102.85236   	237.97977   	-15.43734   	1           
---> try to load best state
              	102.85236   	237.97977   	-15.43734   	1                eval state : test_on_restore;
              	102.85236   	237.97977   	-15.43734   	1                eval state : test_on_last_epoch;
---> final result
              	102.85236   	237.97977   	-15.43734   	1                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_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           	111.34045   	245.16077   	-16.65971   	0           
  10          	111.44284   	245.21040   	-16.72349   	0           
  100         	111.71708   	245.31154   	-16.81891   	0           
  300         	111.71229   	245.31013   	-16.81882   	0           
  500         	111.70416   	245.30774   	-16.81845   	0           
  1000        	111.69922   	245.30627   	-16.81811   	1           
---> try to load best state
              	111.69922   	245.30627   	-16.81811   	1                eval state : test_on_restore;
              	111.69922   	245.30627   	-16.81811   	1                eval state : test_on_last_epoch;
---> final result
              	111.69922   	245.30627   	-16.81811   	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': 'FlowMix3D_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           	110.57678   	244.45587   	-16.10897   	0           
  10          	110.68822   	244.61456   	-16.30508   	0           
  100         	111.31443   	245.13226   	-16.74569   	0           
  300         	111.28293   	245.11722   	-16.73327   	0           
  500         	111.26364   	245.10745   	-16.72512   	0           
  1000        	111.22565   	245.08675   	-16.70772   	1           
---> try to load best state
              	111.22565   	245.08675   	-16.70772   	1                eval state : test_on_restore;
              	111.22565   	245.08675   	-16.70772   	1                eval state : test_on_last_epoch;
---> final result
              	111.22565   	245.08675   	-16.70772   	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': 'FlowMix3D_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           	110.31562   	244.48654   	-16.02342   	0           
  10          	110.23349   	244.29225   	-15.82310   	0           
  100         	110.21671   	244.36685   	-15.78658   	0           
  300         	110.49465   	244.27470   	-15.56228   	0           
  500         	110.84438   	244.34227   	-15.44222   	0           
  1000        	111.54025   	244.64720   	-15.29773   	1           
---> try to load best state
              	111.54025   	244.64720   	-15.29773   	1                eval state : test_on_restore;
              	111.54025   	244.64720   	-15.29773   	1                eval state : test_on_last_epoch;
---> final result
              	111.54025   	244.64720   	-15.29773   	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': 'FlowMix3D_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           	109.15250   	244.19897   	-15.25409   	0           
  10          	108.98547   	244.01202   	-15.20667   	0           
  100         	109.17643   	244.15056   	-15.41697   	0           
  300         	109.03143   	244.06488   	-15.22470   	0           
  500         	109.01196   	244.06047   	-15.10560   	1           
  1000        	109.05859   	244.11153   	-14.92865   	2           
---> try to load best state
              	109.05859   	244.11153   	-14.92865   	2                eval state : test_on_restore;
              	109.05859   	244.11153   	-14.92865   	2                eval state : test_on_last_epoch;
---> final result
              	109.05859   	244.11153   	-14.92865   	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 2 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'FlowMix3D_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           	143.97435   	300.47186   	-20.65250   	0           
  10          	137.87355   	292.61481   	-18.50099   	0           
  100         	116.11007   	259.64233   	-15.07110   	0           
  300         	108.39458   	246.29887   	-14.52816   	0           
  500         	106.76202   	243.40604   	-14.42956   	1           
  1000        	107.08212   	244.10263   	-14.38486   	2           
---> try to load best state
              	107.08212   	244.10263   	-14.38486   	2                eval state : test_on_restore;
              	107.08212   	244.10263   	-14.38486   	2                eval state : test_on_last_epoch;
---> final result
              	107.08212   	244.10263   	-14.38486   	2                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_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           	115.79061   	251.77904   	-15.51949   	0           
  10          	115.80129   	251.78140   	-15.52438   	0           
  100         	115.80579   	251.78238   	-15.52612   	0           
  300         	115.80575   	251.78236   	-15.52610   	0           
  500         	115.80567   	251.78236   	-15.52608   	0           
  1000        	115.80552   	251.78232   	-15.52603   	1           
---> try to load best state
              	115.80552   	251.78232   	-15.52603   	1                eval state : test_on_restore;
              	115.80552   	251.78232   	-15.52603   	1                eval state : test_on_last_epoch;
---> final result
              	115.80552   	251.78232   	-15.52603   	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': 'FlowMix3D_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           	114.20178   	251.08458   	-14.95187   	0           
  10          	114.24197   	251.10684   	-14.99414   	0           
  100         	114.44686   	251.23206   	-15.04740   	0           
  300         	114.35320   	251.17799   	-15.02420   	0           
  500         	114.30413   	251.14684   	-15.00769   	0           
  1000        	114.26652   	251.11880   	-14.97554   	1           
---> try to load best state
              	114.26652   	251.11880   	-14.97554   	1                eval state : test_on_restore;
              	114.26652   	251.11880   	-14.97554   	1                eval state : test_on_last_epoch;
---> final result
              	114.26652   	251.11880   	-14.97554   	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': 'FlowMix3D_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           	111.90851   	249.74545   	-13.94219   	0           
  10          	112.86250   	250.36049   	-14.30579   	0           
  100         	114.63534   	251.34508   	-15.08605   	0           
  300         	114.16637   	251.10266   	-14.90551   	0           
  500         	113.83850   	250.92575   	-14.75951   	0           
  1000        	113.26095   	250.60257   	-14.47575   	1           
---> try to load best state
              	113.26095   	250.60257   	-14.47575   	1                eval state : test_on_restore;
              	113.26095   	250.60257   	-14.47575   	1                eval state : test_on_last_epoch;
---> final result
              	113.26095   	250.60257   	-14.47575   	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': 'FlowMix3D_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           	114.46262   	251.42352   	-14.56905   	0           
  10          	113.61444   	250.60547   	-14.43907   	0           
  100         	113.16703   	250.18333   	-14.14281   	0           
  300         	112.92837   	249.93472   	-14.07929   	0           
  500         	112.85596   	249.83792   	-14.05232   	0           
  1000        	112.86636   	249.80220   	-14.02056   	1           
---> try to load best state
              	112.86636   	249.80220   	-14.02056   	1                eval state : test_on_restore;
              	112.86636   	249.80220   	-14.02056   	1                eval state : test_on_last_epoch;
---> final result
              	112.86636   	249.80220   	-14.02056   	1                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 3 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'FlowMix3D_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           	142.28430   	299.41339   	-18.13008   	0           
  10          	136.60651   	292.02847   	-16.50376   	0           
  100         	127.83466   	279.89227   	-14.52510   	0           
  300         	126.59151   	278.13199   	-14.25242   	0           
  500         	126.92725   	278.68680   	-14.24839   	1           
  1000        	127.64077   	279.87027   	-14.23407   	1           
---> try to load best state
              	127.64077   	279.87027   	-14.23407   	1                eval state : test_on_restore;
              	127.64077   	279.87027   	-14.23407   	1                eval state : test_on_last_epoch;
---> final result
              	127.64077   	279.87027   	-14.23407   	1                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_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           	135.35675   	287.11646   	-15.49630   	0           
  10          	135.38394   	287.13446   	-15.42774   	0           
  100         	135.48875   	287.17920   	-15.40362   	0           
  300         	135.48230   	287.17694   	-15.40092   	0           
  500         	135.47249   	287.17334   	-15.39795   	0           
  1000        	135.45197   	287.16525   	-15.39562   	1           
---> try to load best state
              	135.45197   	287.16525   	-15.39562   	1                eval state : test_on_restore;
              	135.45197   	287.16525   	-15.39562   	1                eval state : test_on_last_epoch;
---> final result
              	135.45197   	287.16525   	-15.39562   	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': 'FlowMix3D_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           	135.27869   	287.07196   	-15.34677   	0           
  10          	135.37657   	287.12347   	-15.36682   	0           
  100         	135.49425   	287.18094   	-15.40648   	0           
  300         	135.49290   	287.18042   	-15.40569   	0           
  500         	135.49153   	287.17981   	-15.40490   	1           
  1000        	135.48921   	287.17880   	-15.40362   	1           
---> try to load best state
              	135.48921   	287.17880   	-15.40362   	1                eval state : test_on_restore;
              	135.48921   	287.17880   	-15.40362   	1                eval state : test_on_last_epoch;
---> final result
              	135.48921   	287.17880   	-15.40362   	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': 'FlowMix3D_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           	132.75151   	285.98965   	-14.31088   	0           
  10          	133.25020   	286.25504   	-14.46278   	0           
  100         	134.19383   	286.70114   	-14.77634   	0           
  300         	133.80681   	286.52676   	-14.63465   	0           
  500         	133.59064   	286.42563   	-14.55477   	0           
  1000        	133.32077   	286.29510   	-14.45390   	1           
---> try to load best state
              	133.32077   	286.29510   	-14.45390   	1                eval state : test_on_restore;
              	133.32077   	286.29510   	-14.45390   	1                eval state : test_on_last_epoch;
---> final result
              	133.32077   	286.29510   	-14.45390   	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': 'FlowMix3D_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           	132.64775   	285.75558   	-15.58390   	0           
  10          	132.88377   	285.99622   	-15.54852   	0           
  100         	132.94844   	286.14572   	-15.21152   	0           
  300         	132.98889   	286.07071   	-15.42709   	0           
  500         	133.03038   	286.03610   	-15.46047   	1           
  1000        	133.09137   	285.99680   	-15.40509   	2           
---> try to load best state
              	133.09137   	285.99680   	-15.40509   	2                eval state : test_on_restore;
              	133.09137   	285.99680   	-15.40509   	2                eval state : test_on_last_epoch;
---> final result
              	133.09137   	285.99680   	-15.40509   	2                eval state : final;module_name : ResGP;cp_record_file : True;
---> end

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

  Demo res cigp 
  seed: 4 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'FlowMix3D_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           	134.84125   	285.12491   	-21.99945   	0           
  10          	129.69356   	278.58139   	-20.08405   	0           
  100         	100.20673   	230.74681   	-17.32935   	0           
  300         	84.23844    	197.80138   	-19.58900   	0           
  500         	79.64472    	187.87917   	-19.42677   	0           
  1000        	76.84222    	182.08543   	-18.56685   	1           
---> try to load best state
              	76.84222    	182.08543   	-18.56685   	1                eval state : test_on_restore;
              	76.84222    	182.08543   	-18.56685   	1                eval state : test_on_last_epoch;
---> final result
              	76.84222    	182.08543   	-18.56685   	1                eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_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           	85.53219    	189.95117   	-21.95764   	0           
  10          	85.34933    	189.88733   	-22.15339   	0           
  100         	85.22617    	189.84468   	-22.27632   	0           
  300         	85.23307    	189.84705   	-22.26974   	0           
  500         	85.23756    	189.84859   	-22.26554   	0           
  1000        	85.24790    	189.85213   	-22.25581   	1           
---> try to load best state
              	85.24790    	189.85213   	-22.25581   	1                eval state : test_on_restore;
              	85.24790    	189.85213   	-22.25581   	1                eval state : test_on_last_epoch;
---> final result
              	85.24790    	189.85213   	-22.25581   	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': 'FlowMix3D_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           	82.59757    	188.55307   	-19.67468   	0           
  10          	82.17419    	188.30084   	-19.66659   	0           
  100         	81.47514    	187.80783   	-20.23271   	0           
  300         	81.35104    	187.73672   	-20.18449   	0           
  500         	81.33768    	187.72902   	-20.17624   	0           
  1000        	81.33811    	187.72775   	-20.16462   	1           
---> try to load best state
              	81.33811    	187.72775   	-20.16462   	1                eval state : test_on_restore;
              	81.33811    	187.72775   	-20.16462   	1                eval state : test_on_last_epoch;
---> final result
              	81.33811    	187.72775   	-20.16462   	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': 'FlowMix3D_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           	82.33308    	187.97552   	-19.81833   	0           
  10          	81.86971    	187.64310   	-19.75526   	0           
  100         	80.49473    	186.55922   	-18.55240   	0           
  300         	80.32141    	186.41399   	-18.12137   	0           
  500         	80.32058    	186.40607   	-18.10702   	1           
  1000        	80.34586    	186.40559   	-18.15128   	2           
---> try to load best state
              	80.34586    	186.40559   	-18.15128   	2                eval state : test_on_restore;
              	80.34586    	186.40559   	-18.15128   	2                eval state : test_on_last_epoch;
---> final result
              	80.34586    	186.40559   	-18.15128   	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': 'FlowMix3D_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           	84.79971    	189.90654   	-16.98055   	0           
  10          	84.66721    	189.72299   	-17.13357   	0           
  100         	85.29263    	190.53598   	-16.51769   	0           
  300         	85.76493    	191.21056   	-16.25058   	0           
  500         	85.95138    	191.48494   	-16.17905   	1           
  1000        	86.14925    	191.77524   	-16.14333   	2           
---> try to load best state
              	86.14925    	191.77524   	-16.14333   	2                eval state : test_on_restore;
              	86.14925    	191.77524   	-16.14333   	2                eval state : test_on_last_epoch;
---> final result
              	86.14925    	191.77524   	-16.14333   	2                eval state : final;module_name : ResGP;cp_record_file : True;
