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

  Demo GAR 
  seed: 0 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, '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}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00238     	0.69696     	0.00564     	0           
  10          	0.00269     	0.69025     	0.00617     	0           
  100         	0.00436     	0.61850     	0.00795     	0           
  300         	0.00486     	0.51146     	0.00960     	1           
  500         	0.00483     	0.49362     	0.00961     	2           
---> try to load best state
              	0.00479     	0.51371     	0.00953     	4                eval state : test_on_restore;
              	0.00498     	0.30614     	0.00966     	4                eval state : test_on_last_epoch;
---> final result              	0.00479     	0.51371     	0.00953     	4                eval state : final;
----------> finish x-yl training


---------->
SGAR for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.01682     	-0.26831    	0.03773     	0           
  10          	0.01557     	-0.35282    	0.03574     	0           
  100         	0.01025     	-1.50675    	0.02494     	1           
  300         	0.00743     	-1.50819    	0.02125     	2           
  epoch 472 reach nan state
---> try to load best state
              	0.00824     	-3.76523    	0.02826     	3                eval state : test_on_restore;
              	0.00743     	-1.50819    	0.02125     	3                eval state : test_on_last_epoch;
---> final result
              	0.00743     	-1.50819    	0.02125     	3                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00677     	0.01892     	0.01506     	0           
  10          	0.00676     	-0.10690    	0.01731     	0           
  100         	0.00615     	-0.42504    	0.01388     	0           
  300         	0.00589     	0.00782     	0.01541     	2           
  epoch 402 reach nan state
---> try to load best state
              	0.00690     	-1.83947    	0.02255     	3                eval state : test_on_restore;
              	0.00589     	0.00782     	0.01541     	3                eval state : test_on_last_epoch;
---> final result
              	0.00589     	0.00782     	0.01541     	3                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00340     	0.75193     	0.00628     	0           
  10          	0.00356     	0.75297     	0.00658     	0           
  100         	0.00513     	0.12006     	0.00793     	1           
  300         	0.00505     	-0.10193    	0.00817     	4           
  epoch 320 reach nan state
---> try to load best state
              	0.00524     	0.11232     	0.00854     	5                eval state : test_on_restore;
              	0.00505     	-0.10193    	0.00817     	5                eval state : test_on_last_epoch;
---> final result
              	0.00505     	-0.10193    	0.00817     	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00333     	0.75610     	0.00623     	0           
  10          	0.00350     	0.76318     	0.00652     	0           
  100         	0.00485     	0.03636     	0.00776     	2           
  epoch 287 reach nan state
---> try to load best state
              	0.00486     	0.06640     	0.00793     	6                eval state : test_on_restore;
              	0.00485     	0.03636     	0.00776     	6                eval state : test_on_last_epoch;
---> final result
              	0.00485     	0.03636     	0.00776     	6                eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 1 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, '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}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00186     	0.70668     	0.00404     	0           
  10          	0.00217     	0.69591     	0.00460     	0           
  100         	0.00418     	0.50539     	0.00849     	0           
  300         	0.00480     	0.44969     	0.01029     	1           
  500         	0.00481     	0.43881     	0.01045     	2           
---> try to load best state
              	0.00482     	0.42582     	0.01028     	4                eval state : test_on_restore;
              	0.00495     	0.21979     	0.01033     	4                eval state : test_on_last_epoch;
---> final result              	0.00482     	0.42582     	0.01028     	4                eval state : final;
----------> finish x-yl training


---------->
SGAR for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.01176     	-0.36338    	0.02584     	0           
  10          	0.01189     	-0.60723    	0.02916     	0           
  100         	0.00798     	-0.93282    	0.02060     	0           
  300         	0.00678     	-0.02951    	0.02033     	2           
  epoch 499 reach nan state
---> try to load best state
              	0.00815     	-1.30760    	0.02641     	4                eval state : test_on_restore;
              	0.00678     	-0.02951    	0.02033     	4                eval state : test_on_last_epoch;
---> final result
              	0.00678     	-0.02951    	0.02033     	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00435     	0.52218     	0.01061     	0           
  10          	0.00431     	0.41961     	0.01116     	0           
  100         	0.00602     	-2.22262    	0.01178     	1           
  300         	0.00552     	-0.11239    	0.01266     	3           
  epoch 424 reach nan state
---> try to load best state
              	0.00481     	0.26780     	0.01389     	4                eval state : test_on_restore;
              	0.00552     	-0.11239    	0.01266     	4                eval state : test_on_last_epoch;
---> final result
              	0.00552     	-0.11239    	0.01266     	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00331     	0.65711     	0.00717     	0           
  10          	0.00353     	0.67993     	0.00759     	0           
  100         	0.00495     	-0.16155    	0.00901     	1           
  300         	0.00488     	-0.03459    	0.00906     	3           
  epoch 352 reach nan state
---> try to load best state
              	0.06296     	-5.74252    	0.16034     	3                eval state : test_on_restore;
              	0.00488     	-0.03459    	0.00906     	3                eval state : test_on_last_epoch;
---> final result
              	0.00488     	-0.03459    	0.00906     	3                eval state : final;module_name : GAR;cp_record_file : True;
---> end


---------->
SGAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, 'slice_param': [0.6, 0.4]}
  connection_method: res_mapping
  lr: {'kernel': 0.01, 'optional_param': 0.01, 'noise': 0.01}
  kernel: {'K1': {'SE': {'exp_restrict': True, 'length_scale': 1.0, 'scale': 1.0}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: True
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00330     	0.65620     	0.00721     	0           
  10          	0.00353     	0.68794     	0.00769     	0           
  100         	0.00520     	-0.92440    	0.00904     	1           
  300         	0.00360     	0.04097     	0.00644     	5           
  epoch 334 reach nan state
---> try to load best state
              	0.00350     	0.16278     	0.00632     	6                eval state : test_on_restore;
              	0.00360     	0.04097     	0.00644     	6                eval state : test_on_last_epoch;
---> final result
              	0.00350     	0.16278     	0.00632     	6                eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 2 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', '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': False, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': True, '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}}}
  auto_broadcast_kernel: True
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 100.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
  input_normalzie: True
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.00177     	0.68188     	0.00409     	0           
  10          	0.00207     	0.68082     	0.00481     	0           
  100         	0.00411     	0.52252     	0.00823     	0           
  300         	0.00477     	0.46589     	0.01006     	1           
  500         	0.00474     	0.47565     	0.01009     	2           
---> try to load best state
              	0.00469     	0.48193     	0.00998     	3                eval state : test_on_restore;
              	0.00470     	0.44713     	0.00994     	3                eval state : test_on_last_epoch;
---> final result              	0.00470     	0.44713     	0.00994     	3                eval state : final;
----------> finish x-yl training


---------->
SGAR for 4 samples
---> Training x,yl -> yh part

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

  Demo NAR cigp 
  seed: None 
  interp_data: True 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00305     	0.00875     	0.93956     	0           
  10          	0.00303     	0.00866     	0.94061     	0           
  100         	0.00277     	0.00779     	0.95061     	0           
  300         	0.00193     	0.00592     	0.96866     	1           
  500         	0.00152     	0.00479     	0.97734     	2           
  1000        	0.00134     	0.00415     	0.98140     	4           
---> try to load best state
              	0.00134     	0.00415     	0.98140     	4                eval state : test_on_restore;
              	0.00134     	0.00415     	0.98140     	4                eval state : test_on_last_epoch;
---> final result
              	0.00134     	0.00415     	0.98140     	4                eval state : final;
----------> finish x-yl training


---------->
NAR for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.04176     	0.08219     	-133132579546.06018	0           
  10          	0.04176     	0.08219     	-133132579546.06018	0           
  100         	0.04176     	0.08219     	-133132579546.06018	0           
  300         	0.04176     	0.08219     	-133132579546.06018	1           
  500         	0.04176     	0.08219     	-133132579546.06018	2           
  1000        	0.04176     	0.08219     	-133132579546.06018	3           
---> try to load best state
              	0.04176     	0.08219     	-133132579546.06018	3                eval state : test_on_restore;
              	0.04176     	0.08219     	-133132579546.06018	3                eval state : test_on_last_epoch;
---> final result
              	0.04176     	0.08219     	-133132579546.06018	3                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.03200     	0.07097     	-80388086082.14275	0           
  10          	0.03200     	0.07097     	-80388086082.14275	0           
  100         	0.03200     	0.07097     	-80388086082.14275	0           
  300         	0.03200     	0.07097     	-80388086082.14275	1           
  500         	0.03200     	0.07097     	-80388086082.14275	2           
  1000        	0.03200     	0.07097     	-80388086082.14275	4           
---> try to load best state
              	0.03200     	0.07097     	-80388086082.14275	4                eval state : test_on_restore;
              	0.03200     	0.07097     	-80388086082.14275	4                eval state : test_on_last_epoch;
---> final result
              	0.03200     	0.07097     	-80388086082.14275	4                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02824     	0.06809     	-79396331101.62317	0           
  10          	0.02824     	0.06809     	-79396331101.62317	0           
  100         	0.02824     	0.06809     	-79396331101.62317	0           
  300         	0.02824     	0.06809     	-79396331101.62317	1           
  500         	0.02824     	0.06809     	-79396331101.62317	3           
  1000        	0.02824     	0.06809     	-79396331101.62317	5           
---> try to load best state
              	0.02824     	0.06809     	-79396331101.62317	5                eval state : test_on_restore;
              	0.02824     	0.06809     	-79396331101.62317	5                eval state : test_on_last_epoch;
---> final result
              	0.02824     	0.06809     	-79396331101.62317	5                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': True, 'seed': None, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02669     	0.06726     	-75478530537.43645	0           
  10          	0.02669     	0.06726     	-75478530537.43645	0           
  100         	0.02669     	0.06726     	-75478530537.43645	1           
----------------------------------------

  Demo DMFAL 
  seed: 0 
  interp_data: False 

----------------------------------------
---> module config
  dataset: {'name': 'burger_v4_02', '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]', 'y[-1]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  second_fidelity_sample: 4
  second_fidelity_start_index: 0
  non_subset: False
  lr: {'opt_param': 0.01}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  nn_param: {'hlayers_w': [40, 40], 'hlayers_d': [2, 2], 'base_dim': [32, 32], 'activation': 'relu', 'M': 2}
  reg_strength: 0.001
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	0.02102     	-42012043094.82997	0.07780     	0           
  10          	0.02102     	-230142111.59408	0.07778     	0           
  100         	0.01277     	-59.67353   	0.05443     	0           
  300         	0.01403     	-100.20989  	0.05845     	2           
  500         	0.01264     	-57.02968   	0.05394     	3           
  1000        	0.01143     	-42.16566   	0.05045     	7           
---> try to load best state
              	0.01143     	-42.16566   	0.05045     	7                eval state : test_on_restore;
              	0.01143     	-42.16566   	0.05045     	7                eval state : test_on_last_epoch;
---> final result
              	0.01143     	-42.16566   	0.05045     	7                eval state : final;module_name : dmfal;cp_record_file : True;
---> end

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

  Demo DMFAL 
  seed: 0 
  interp_data: False 

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

  Demo NAR cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00300     	0.00990     	0.93659     	0           
  10          	0.00298     	0.00978     	0.93792     	0           
  100         	0.00281     	0.00873     	0.94919     	0           
  300         	0.00215     	0.00681     	0.96562     	0           
  500         	0.00177     	0.00566     	0.97248     	1           
  1000        	0.00179     	0.00527     	0.97372     	2           
---> try to load best state
              	0.00179     	0.00527     	0.97372     	2                eval state : test_on_restore;
              	0.00179     	0.00527     	0.97372     	2                eval state : test_on_last_epoch;
---> final result
              	0.00179     	0.00527     	0.97372     	2                eval state : final;
----------> finish x-yl training


---------->
NAR for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02102     	0.07780     	-66866948165.93520	0           
  10          	0.02102     	0.07780     	-66866948165.93520	0           
  100         	0.02102     	0.07780     	-66866948165.93520	0           
  300         	0.02102     	0.07780     	-66866948165.93520	0           
  500         	0.02102     	0.07780     	-66866948165.93520	1           
  1000        	0.02102     	0.07780     	-66866948165.93520	2           
---> try to load best state
              	0.02102     	0.07780     	-66866948165.93520	2                eval state : test_on_restore;
              	0.02102     	0.07780     	-66866948165.93520	2                eval state : test_on_last_epoch;
---> final result
              	0.02102     	0.07780     	-66866948165.93520	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02040     	0.07319     	-48681928996.02127	0           
  10          	0.02040     	0.07319     	-48681928996.02127	0           
  100         	0.02040     	0.07319     	-48681928996.02127	0           
  300         	0.02040     	0.07319     	-48681928996.02127	0           
  500         	0.02040     	0.07319     	-48681928996.02127	1           
  1000        	0.02040     	0.07319     	-48681928996.02127	2           
---> try to load best state
              	0.02040     	0.07319     	-48681928996.02127	2                eval state : test_on_restore;
              	0.02040     	0.07319     	-48681928996.02127	2                eval state : test_on_last_epoch;
---> final result
              	0.02040     	0.07319     	-48681928996.02127	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02491     	0.06729     	-51810954167.82037	0           
  10          	0.02491     	0.06729     	-51810954167.82037	0           
  100         	0.02491     	0.06729     	-51810954167.82037	0           
  300         	0.02491     	0.06729     	-51810954167.82037	0           
  500         	0.02491     	0.06729     	-51810954167.82037	1           
  1000        	0.02491     	0.06729     	-51810954167.82037	3           
---> try to load best state
              	0.02491     	0.06729     	-51810954167.82037	3                eval state : test_on_restore;
              	0.02491     	0.06729     	-51810954167.82037	3                eval state : test_on_last_epoch;
---> final result
              	0.02491     	0.06729     	-51810954167.82037	3                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02400     	0.06729     	-90285584765.74506	0           
  10          	0.02400     	0.06729     	-90285584765.74506	0           
  100         	0.02400     	0.06729     	-90285584765.74506	0           
  300         	0.02400     	0.06729     	-90285584765.74506	1           
  500         	0.02400     	0.06729     	-90285584765.74506	2           
  1000        	0.02400     	0.06729     	-90285584765.74506	3           
---> try to load best state
              	0.02400     	0.06729     	-90285584765.74506	3                eval state : test_on_restore;
              	0.02400     	0.06729     	-90285584765.74506	3                eval state : test_on_last_epoch;
---> final result
              	0.02400     	0.06729     	-90285584765.74506	3                eval state : final;module_name : NAR;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00286     	0.01166     	0.88424     	0           
  10          	0.00283     	0.01154     	0.88678     	0           
  100         	0.00255     	0.01029     	0.91097     	0           
  300         	0.00197     	0.00768     	0.94990     	0           
  500         	0.00166     	0.00647     	0.96299     	1           
  1000        	0.00153     	0.00569     	0.96937     	2           
---> try to load best state
              	0.00153     	0.00569     	0.96937     	2                eval state : test_on_restore;
              	0.00153     	0.00569     	0.96937     	2                eval state : test_on_last_epoch;
---> final result
              	0.00153     	0.00569     	0.96937     	2                eval state : final;
----------> finish x-yl training


---------->
NAR for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02070     	0.07614     	-57950248532.67905	0           
  10          	0.02070     	0.07614     	-57950248532.67905	0           
  100         	0.02070     	0.07614     	-57950248532.67905	0           
  300         	0.02070     	0.07614     	-57950248532.67905	0           
  500         	0.02070     	0.07614     	-57950248532.67905	1           
  1000        	0.02070     	0.07614     	-57950248532.67905	2           
---> try to load best state
              	0.02070     	0.07614     	-57950248532.67905	2                eval state : test_on_restore;
              	0.02070     	0.07614     	-57950248532.67905	2                eval state : test_on_last_epoch;
---> final result
              	0.02070     	0.07614     	-57950248532.67905	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02081     	0.07195     	-56627404159.57314	0           
  10          	0.02081     	0.07195     	-56627404159.57314	0           
  100         	0.02081     	0.07195     	-56627404159.57314	0           
  300         	0.02081     	0.07195     	-56627404159.57314	0           
  500         	0.02081     	0.07195     	-56627404159.57314	1           
  1000        	0.02081     	0.07195     	-56627404159.57314	2           
---> try to load best state
              	0.02081     	0.07195     	-56627404159.57314	2                eval state : test_on_restore;
              	0.02081     	0.07195     	-56627404159.57314	2                eval state : test_on_last_epoch;
---> final result
              	0.02081     	0.07195     	-56627404159.57314	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02608     	0.06772     	-84824558440.86528	0           
  10          	0.02608     	0.06772     	-84824558440.86528	0           
  100         	0.02608     	0.06772     	-84824558440.86528	0           
  300         	0.02608     	0.06772     	-84824558440.86528	0           
  500         	0.02608     	0.06772     	-84824558440.86528	1           
  1000        	0.02608     	0.06772     	-84824558440.86528	1           
---> try to load best state
              	0.02608     	0.06772     	-84824558440.86528	2                eval state : test_on_restore;
              	0.02608     	0.06772     	-84824558440.86528	2                eval state : test_on_last_epoch;
---> final result
              	0.02608     	0.06772     	-84824558440.86528	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02354     	0.06737     	-82517470442.49828	0           
  10          	0.02354     	0.06737     	-82517470442.49828	0           
  100         	0.02354     	0.06737     	-82517470442.49828	0           
  300         	0.02354     	0.06737     	-82517470442.49828	0           
  500         	0.02354     	0.06737     	-82517470442.49828	1           
  1000        	0.02354     	0.06737     	-82517470442.49828	2           
---> try to load best state
              	0.02354     	0.06737     	-82517470442.49828	2                eval state : test_on_restore;
              	0.02354     	0.06737     	-82517470442.49828	2                eval state : test_on_last_epoch;
---> final result
              	0.02354     	0.06737     	-82517470442.49828	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 2 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00316     	0.01023     	0.89165     	0           
  10          	0.00315     	0.01015     	0.89310     	0           
  100         	0.00301     	0.00947     	0.90561     	0           
  300         	0.00259     	0.00846     	0.92355     	0           
  500         	0.00231     	0.00788     	0.93208     	0           
  1000        	0.00206     	0.00724     	0.94051     	1           
---> try to load best state
              	0.00206     	0.00724     	0.94051     	1                eval state : test_on_restore;
              	0.00206     	0.00724     	0.94051     	1                eval state : test_on_last_epoch;
---> final result
              	0.00206     	0.00724     	0.94051     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02667     	0.06911     	-55634787171.35291	0           
  10          	0.02667     	0.06911     	-55634787171.35291	0           
  100         	0.02667     	0.06911     	-55634787171.35291	0           
  300         	0.02667     	0.06911     	-55634787171.35291	0           
  500         	0.02667     	0.06911     	-55634787171.35291	1           
  1000        	0.02667     	0.06911     	-55634787171.35291	1           
---> try to load best state
              	0.02667     	0.06911     	-55634787171.35291	1                eval state : test_on_restore;
              	0.02667     	0.06911     	-55634787171.35291	1                eval state : test_on_last_epoch;
---> final result
              	0.02667     	0.06911     	-55634787171.35291	1                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02356     	0.06741     	-49233539324.21560	0           
  10          	0.02356     	0.06741     	-49233539324.21560	0           
  100         	0.02356     	0.06741     	-49233539324.21560	0           
  300         	0.02356     	0.06741     	-49233539324.21560	0           
  500         	0.02356     	0.06741     	-49233539324.21560	0           
  1000        	0.02356     	0.06741     	-49233539324.21560	1           
---> try to load best state
              	0.02356     	0.06741     	-49233539324.21560	2                eval state : test_on_restore;
              	0.02356     	0.06741     	-49233539324.21560	2                eval state : test_on_last_epoch;
---> final result
              	0.02356     	0.06741     	-49233539324.21560	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02598     	0.06816     	-74020899088.38049	0           
  10          	0.02598     	0.06816     	-74020899088.38049	0           
  100         	0.02598     	0.06816     	-74020899088.38049	0           
  300         	0.02598     	0.06816     	-74020899088.38049	0           
  500         	0.02598     	0.06816     	-74020899088.38049	1           
  1000        	0.02598     	0.06816     	-74020899088.38049	2           
---> try to load best state
              	0.02598     	0.06816     	-74020899088.38049	2                eval state : test_on_restore;
              	0.02598     	0.06816     	-74020899088.38049	2                eval state : test_on_last_epoch;
---> final result
              	0.02598     	0.06816     	-74020899088.38049	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02886     	0.07036     	-89189433332.69766	0           
  10          	0.02886     	0.07036     	-89189433332.69766	0           
  100         	0.02886     	0.07036     	-89189433332.69766	0           
  300         	0.02886     	0.07036     	-89189433332.69766	1           
  500         	0.02886     	0.07036     	-89189433332.69766	2           
  1000        	0.02886     	0.07036     	-89189433332.69766	4           
---> try to load best state
              	0.02886     	0.07036     	-89189433332.69766	4                eval state : test_on_restore;
              	0.02886     	0.07036     	-89189433332.69766	4                eval state : test_on_last_epoch;
---> final result
              	0.02886     	0.07036     	-89189433332.69766	4                eval state : final;module_name : NAR;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 3 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00279     	0.00976     	0.91159     	0           
  10          	0.00277     	0.00966     	0.91310     	0           
  100         	0.00260     	0.00879     	0.92658     	0           
  300         	0.00210     	0.00733     	0.94663     	0           
  500         	0.00183     	0.00668     	0.95420     	1           
  1000        	0.00165     	0.00607     	0.96027     	2           
---> try to load best state
              	0.00165     	0.00607     	0.96027     	2                eval state : test_on_restore;
              	0.00165     	0.00607     	0.96027     	2                eval state : test_on_last_epoch;
---> final result
              	0.00165     	0.00607     	0.96027     	2                eval state : final;
----------> finish x-yl training


---------->
NAR for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02737     	0.06970     	-61854542970.90547	0           
  10          	0.02737     	0.06970     	-61854542970.90547	0           
  100         	0.02737     	0.06970     	-61854542970.90547	0           
  300         	0.02737     	0.06970     	-61854542970.90547	0           
  500         	0.02737     	0.06970     	-61854542970.90547	1           
  1000        	0.02737     	0.06970     	-61854542970.90547	2           
---> try to load best state
              	0.02737     	0.06970     	-61854542970.90547	2                eval state : test_on_restore;
              	0.02737     	0.06970     	-61854542970.90547	2                eval state : test_on_last_epoch;
---> final result
              	0.02737     	0.06970     	-61854542970.90547	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02261     	0.06784     	-49736220314.98135	0           
  10          	0.02261     	0.06784     	-49736220314.98135	0           
  100         	0.02261     	0.06784     	-49736220314.98135	0           
  300         	0.02261     	0.06784     	-49736220314.98135	0           
  500         	0.02261     	0.06784     	-49736220314.98135	1           
  1000        	0.02261     	0.06784     	-49736220314.98135	2           
---> try to load best state
              	0.02261     	0.06784     	-49736220314.98135	2                eval state : test_on_restore;
              	0.02261     	0.06784     	-49736220314.98135	2                eval state : test_on_last_epoch;
---> final result
              	0.02261     	0.06784     	-49736220314.98135	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02792     	0.06934     	-70508595646.21909	0           
  10          	0.02792     	0.06934     	-70508595646.21909	0           
  100         	0.02792     	0.06934     	-70508595646.21909	0           
  300         	0.02792     	0.06934     	-70508595646.21909	0           
  500         	0.02792     	0.06934     	-70508595646.21909	1           
  1000        	0.02792     	0.06934     	-70508595646.21909	2           
---> try to load best state
              	0.02792     	0.06934     	-70508595646.21909	2                eval state : test_on_restore;
              	0.02792     	0.06934     	-70508595646.21909	2                eval state : test_on_last_epoch;
---> final result
              	0.02792     	0.06934     	-70508595646.21909	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02688     	0.06859     	-79507032493.60786	0           
  10          	0.02688     	0.06859     	-79507032493.60786	0           
  100         	0.02688     	0.06859     	-79507032493.60786	0           
  300         	0.02688     	0.06859     	-79507032493.60786	1           
  500         	0.02688     	0.06859     	-79507032493.60786	2           
  1000        	0.02688     	0.06859     	-79507032493.60786	4           
---> try to load best state
              	0.02688     	0.06859     	-79507032493.60786	4                eval state : test_on_restore;
              	0.02688     	0.06859     	-79507032493.60786	4                eval state : test_on_last_epoch;
---> final result
              	0.02688     	0.06859     	-79507032493.60786	4                eval state : final;module_name : NAR;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': True, 'x_sample_to_last_dim': False, 'y_sample_to_last_dim': False, 'slice_param': [0.6, 0.4]}
  lr: {'kernel': 0.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.00299     	0.01154     	0.85365     	0           
  10          	0.00300     	0.01155     	0.85332     	0           
  100         	0.00296     	0.01136     	0.85716     	0           
  300         	0.00284     	0.01093     	0.86587     	0           
  500         	0.00275     	0.01060     	0.87242     	0           
  1000        	0.00256     	0.00997     	0.88428     	1           
---> try to load best state
              	0.00256     	0.00997     	0.88428     	1                eval state : test_on_restore;
              	0.00256     	0.00997     	0.88428     	2                eval state : test_on_last_epoch;
---> final result
              	0.00256     	0.00997     	0.88428     	2                eval state : final;
----------> finish x-yl training


---------->
NAR for 4 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.03555     	0.08437     	-223549993701.70294	0           
  10          	0.03555     	0.08437     	-223549993701.70294	0           
  100         	0.03555     	0.08437     	-223549993701.70294	0           
  300         	0.03555     	0.08437     	-223549993701.70294	0           
  500         	0.03555     	0.08437     	-223549993701.70294	1           
  1000        	0.03555     	0.08437     	-223549993701.70294	2           
---> try to load best state
              	0.03555     	0.08437     	-223549993701.70294	2                eval state : test_on_restore;
              	0.03555     	0.08437     	-223549993701.70294	2                eval state : test_on_last_epoch;
---> final result
              	0.03555     	0.08437     	-223549993701.70294	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 8 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02589     	0.06841     	-68799825403.51643	0           
  10          	0.02589     	0.06841     	-68799825403.51643	0           
  100         	0.02589     	0.06841     	-68799825403.51643	0           
  300         	0.02589     	0.06841     	-68799825403.51643	0           
  500         	0.02589     	0.06841     	-68799825403.51643	1           
  1000        	0.02589     	0.06841     	-68799825403.51643	2           
---> try to load best state
              	0.02589     	0.06841     	-68799825403.51643	2                eval state : test_on_restore;
              	0.02589     	0.06841     	-68799825403.51643	2                eval state : test_on_last_epoch;
---> final result
              	0.02589     	0.06841     	-68799825403.51643	2                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 16 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02450     	0.06763     	-66376520462.70633	0           
  10          	0.02450     	0.06763     	-66376520462.70633	0           
  100         	0.02450     	0.06763     	-66376520462.70633	0           
  300         	0.02450     	0.06763     	-66376520462.70633	1           
  500         	0.02450     	0.06763     	-66376520462.70633	1           
  1000        	0.02450     	0.06763     	-66376520462.70633	3           
---> try to load best state
              	0.02450     	0.06763     	-66376520462.70633	3                eval state : test_on_restore;
              	0.02450     	0.06763     	-66376520462.70633	3                eval state : test_on_last_epoch;
---> final result
              	0.02450     	0.06763     	-66376520462.70633	3                eval state : final;module_name : NAR;cp_record_file : True;
---> end


---------->
NAR for 32 samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'burger_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['np.concatenate([x[0],y[0]], axis=1)'], '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.001, 'optional_param': 0.001, 'noise': 0.001}
  kernel: {'K1': {'SE': {'exp_restrict': False, 'length_scale': 1.0, 'scale': 1.0}}}
  evaluate_method: ['mae', 'rmse', 'r2']
  optimizer: adam
  exp_restrict: False
  input_normalize: True
  output_normalize: True
  noise_init: 10.0
---> training record
  epoch       	mae         	rmse        	r2          	time        
  1           	0.02477     	0.06748     	-63094495763.97588	0           
  10          	0.02477     	0.06748     	-63094495763.97588	0           
  100         	0.02477     	0.06748     	-63094495763.97588	0           
  300         	0.02477     	0.06748     	-63094495763.97588	1           
  500         	0.02477     	0.06748     	-63094495763.97588	1           
  1000        	0.02477     	0.06748     	-63094495763.97588	3           
---> try to load best state
              	0.02477     	0.06748     	-63094495763.97588	3                eval state : test_on_restore;
              	0.02477     	0.06748     	-63094495763.97588	3                eval state : test_on_last_epoch;
---> final result
              	0.02477     	0.06748     	-63094495763.97588	3                eval state : final;module_name : NAR;cp_record_file : True;
