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

  Demo NAR cigp 
  seed: None 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'poisson_v4_02', '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.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           	104.12158   	141.13937   	-0.06172    	0           
  10          	102.84735   	139.60153   	-0.01304    	0           
  100         	91.27988    	125.34296   	0.34354     	0           
  300         	72.24196    	101.25847   	0.68578     	0           
  500         	60.59178    	85.43239    	0.80909     	0           
  1000        	44.05614    	62.61027    	0.91415     	1           
---> try to load best state
              	44.05614    	62.61027    	0.91415     	1                eval state : test_on_restore;
              	44.05614    	62.61027    	0.91415     	1                eval state : test_on_last_epoch;
---> final result
              	44.05614    	62.61027    	0.91415     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': None, 'train_start_index': 31, '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           	192.31616   	229.04951   	-222.90960  	0           
  10          	192.16205   	228.88673   	-212.21241  	0           
  100         	190.17490   	226.82698   	-128.52743  	0           
  300         	181.16351   	217.83876   	-40.55875   	0           
  500         	165.04453   	201.95326   	-13.89817   	1           
  1000        	113.20204   	148.95364   	-0.90430    	1           
---> try to load best state
              	113.20204   	148.95364   	-0.90430    	1                eval state : test_on_restore;
              	113.20204   	148.95364   	-0.90430    	1                eval state : test_on_last_epoch;
---> final result
              	113.20204   	148.95364   	-0.90430    	1                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': None, 'train_start_index': 30, '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           	191.44389   	228.22124   	-195.25526  	0           
  10          	191.27492   	228.04135   	-185.92022  	0           
  100         	189.12766   	225.79515   	-113.35621  	0           
  300         	179.79358   	216.37837   	-37.30451   	0           
  500         	163.39682   	199.95966   	-13.13118   	1           
  1000        	107.98187   	143.18097   	-0.62281    	2           
---> try to load best state
              	107.98187   	143.18097   	-0.62281    	2                eval state : test_on_restore;
              	107.98187   	143.18097   	-0.62281    	2                eval state : test_on_last_epoch;
---> final result
              	107.98187   	143.18097   	-0.62281    	2                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': None, 'train_start_index': 28, '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           	190.79156   	227.49451   	-176.49940  	0           
  10          	190.59653   	227.28493   	-167.77518  	0           
  100         	188.13496   	224.68518   	-100.28621  	0           
  300         	177.71822   	214.09598   	-31.26175   	0           
  500         	160.20145   	196.52785   	-10.59349   	1           
  1000        	107.14052   	142.16460   	-0.52758    	2           
---> try to load best state
              	107.14052   	142.16460   	-0.52758    	2                eval state : test_on_restore;
              	107.14052   	142.16460   	-0.52758    	2                eval state : test_on_last_epoch;
---> final result
              	107.14052   	142.16460   	-0.52758    	2                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': None, 'train_start_index': 24, '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           	192.00961   	229.16388   	-341.27736  	0           
  10          	191.85220   	228.99986   	-321.73080  	0           
  100         	189.82611   	226.92210   	-177.09205  	0           
  300         	181.02707   	218.25391   	-48.51924   	0           
  500         	166.56448   	204.40588   	-16.55147   	1           
  1000        	122.94972   	162.29135   	-1.76530    	2           
---> try to load best state
              	122.94972   	162.29135   	-1.76530    	2                eval state : test_on_restore;
              	122.94972   	162.29135   	-1.76530    	2                eval state : test_on_last_epoch;
---> final result
              	122.94972   	162.29135   	-1.76530    	2                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': None, 'train_start_index': 16, '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           	191.77325   	228.87292   	-334.90651  	0           
  10          	191.61554   	228.70749   	-316.03445  	0           
  100         	189.59485   	226.61009   	-176.02857  	0           
  300         	180.82802   	217.76561   	-48.13801   	0           
  500         	165.21152   	202.46408   	-14.82100   	1           
  1000        	112.07845   	149.37503   	-0.77299    	2           
---> try to load best state
              	112.07845   	149.37503   	-0.77299    	2                eval state : test_on_restore;
              	112.07845   	149.37503   	-0.77299    	2                eval state : test_on_last_epoch;
---> final result
              	112.07845   	149.37503   	-0.77299    	2                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, '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           	192.41705   	229.75485   	-403.32173  	0           
  10          	192.25778   	229.59445   	-381.02208  	0           
  100         	190.06206   	227.39743   	-204.84428  	0           
  300         	178.49109   	215.89333   	-44.23692   	0           
  500         	155.73489   	192.73834   	-10.65847   	0           
  1000        	93.54604    	123.88853   	0.04372     	1           
---> try to load best state
              	93.54604    	123.88853   	0.04372     	1                eval state : test_on_restore;
              	93.54604    	123.88853   	0.04372     	1                eval state : test_on_last_epoch;
---> final result
              	93.54604    	123.88853   	0.04372     	1                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 0 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'poisson_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           	117.89882   	163.12822   	-0.49781    	0           
  10          	116.78647   	161.90924   	-0.44908    	0           
  100         	106.65556   	150.28943   	-0.06690    	0           
  300         	89.39448    	128.57106   	0.37875     	0           
  500         	77.49991    	112.68848   	0.57797     	0           
  1000        	58.46796    	86.52201    	0.79251     	1           
---> try to load best state
              	58.46796    	86.52201    	0.79251     	1                eval state : test_on_restore;
              	58.46796    	86.52201    	0.79251     	1                eval state : test_on_last_epoch;
---> final result
              	58.46796    	86.52201    	0.79251     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 31, '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           	193.91389   	233.52460   	-126.24127  	0           
  10          	193.74823   	233.37959   	-121.64400  	0           
  100         	191.74860   	231.64790   	-83.39918   	0           
  300         	184.21500   	225.08018   	-35.35990   	0           
  500         	172.53769   	214.18788   	-16.09180   	0           
  1000        	137.20779   	178.36662   	-2.84833    	2           
---> try to load best state
              	137.20779   	178.36662   	-2.84833    	2                eval state : test_on_restore;
              	137.20779   	178.36662   	-2.84833    	2                eval state : test_on_last_epoch;
---> final result
              	137.20779   	178.36662   	-2.84833    	2                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 30, '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           	194.47588   	234.42953   	-133.78699  	0           
  10          	194.31378   	234.28900   	-128.84059  	0           
  100         	192.35126   	232.60835   	-87.72354   	0           
  300         	184.89728   	226.18597   	-36.42665   	0           
  500         	173.35571   	215.43964   	-16.49735   	0           
  1000        	138.29782   	179.71182   	-2.98421    	1           
---> try to load best state
              	138.29782   	179.71182   	-2.98421    	1                eval state : test_on_restore;
              	138.29782   	179.71182   	-2.98421    	1                eval state : test_on_last_epoch;
---> final result
              	138.29782   	179.71182   	-2.98421    	1                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 28, '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           	192.80971   	231.74507   	-124.91754  	0           
  10          	192.64685   	231.60152   	-120.39303  	0           
  100         	190.71281   	229.90915   	-83.03211   	0           
  300         	183.62587   	223.61906   	-36.16746   	0           
  500         	172.60808   	213.06903   	-17.00752   	1           
  1000        	137.01266   	175.90392   	-2.94122    	2           
---> try to load best state
              	137.01266   	175.90392   	-2.94122    	2                eval state : test_on_restore;
              	137.01266   	175.90392   	-2.94122    	2                eval state : test_on_last_epoch;
---> final result
              	137.01266   	175.90392   	-2.94122    	2                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 24, '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           	190.26276   	228.23340   	-91.38862   	0           
  10          	190.09671   	228.08327   	-88.66780   	0           
  100         	188.11311   	226.28485   	-65.13833   	0           
  300         	180.62964   	219.24428   	-31.14523   	0           
  500         	168.44565   	206.82906   	-14.51317   	0           
  1000        	128.90521   	164.36345   	-1.92121    	1           
---> try to load best state
              	128.90521   	164.36345   	-1.92121    	1                eval state : test_on_restore;
              	128.90521   	164.36345   	-1.92121    	1                eval state : test_on_last_epoch;
---> final result
              	128.90521   	164.36345   	-1.92121    	2                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 0, 'train_start_index': 16, '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           	193.15778   	231.26860   	-151.33491  	0           
  10          	193.02501   	231.14012   	-147.44310  	0           
  100         	191.42563   	229.57401   	-112.24094  	0           
  300         	185.10187   	223.20653   	-53.77938   	0           
  500         	173.05872   	210.79578   	-21.61660   	0           
  1000        	128.41846   	163.62064   	-1.97933    	1           
---> try to load best state
              	128.41846   	163.62064   	-1.97933    	1                eval state : test_on_restore;
              	128.41846   	163.62064   	-1.97933    	1                eval state : test_on_last_epoch;
---> final result
              	128.41846   	163.62064   	-1.97933    	1                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_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           	194.55885   	233.15163   	-252.22766  	0           
  10          	194.40112   	232.99321   	-241.16617  	0           
  100         	192.35405   	230.93442   	-149.62594  	0           
  300         	183.19530   	221.74110   	-44.41919   	0           
  500         	167.90735   	206.43202   	-14.25169   	1           
  1000        	123.86944   	161.51924   	-1.40747    	2           
---> try to load best state
              	123.86944   	161.51924   	-1.40747    	2                eval state : test_on_restore;
              	123.86944   	161.51924   	-1.40747    	2                eval state : test_on_last_epoch;
---> final result
              	123.86944   	161.51924   	-1.40747    	2                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 1 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'poisson_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           	132.00604   	175.26294   	-1.36955    	0           
  10          	130.89154   	174.05968   	-1.28235    	0           
  100         	120.53459   	162.56804   	-0.62230    	0           
  300         	102.78435   	141.32678   	0.08535     	0           
  500         	90.35950    	125.74872   	0.38407     	0           
  1000        	69.63863    	99.20836    	0.69433     	1           
---> try to load best state
              	69.63863    	99.20836    	0.69433     	1                eval state : test_on_restore;
              	69.63863    	99.20836    	0.69433     	1                eval state : test_on_last_epoch;
---> final result
              	69.63863    	99.20836    	0.69433     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 31, '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           	183.87369   	220.37024   	-62.08932   	0           
  10          	183.48555   	219.94858   	-59.13222   	0           
  100         	178.94974   	215.07379   	-36.21249   	0           
  300         	164.07965   	199.63174   	-12.00297   	0           
  500         	145.76337   	181.06178   	-4.42947    	1           
  1000        	107.96481   	140.28812   	-0.30079    	2           
---> try to load best state
              	107.96481   	140.28812   	-0.30079    	2                eval state : test_on_restore;
              	107.96481   	140.28812   	-0.30079    	2                eval state : test_on_last_epoch;
---> final result
              	107.96481   	140.28812   	-0.30079    	2                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 30, '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           	184.13058   	220.75612   	-59.45600   	0           
  10          	183.73026   	220.31877   	-56.63225   	0           
  100         	179.04550   	215.25270   	-34.64347   	0           
  300         	163.52606   	199.07565   	-11.18379   	0           
  500         	144.17386   	179.52383   	-3.89803    	0           
  1000        	105.78943   	137.90874   	-0.14952    	1           
---> try to load best state
              	105.78943   	137.90874   	-0.14952    	1                eval state : test_on_restore;
              	105.78943   	137.90874   	-0.14952    	1                eval state : test_on_last_epoch;
---> final result
              	105.78943   	137.90874   	-0.14952    	1                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 28, '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           	184.54388   	221.48140   	-63.38795   	0           
  10          	184.16769   	221.07286   	-60.46198   	0           
  100         	179.76044   	216.34148   	-37.57719   	0           
  300         	165.01096   	201.06171   	-12.57914   	0           
  500         	146.15306   	181.97871   	-4.46762    	1           
  1000        	107.93260   	140.12120   	-0.24700    	2           
---> try to load best state
              	107.93260   	140.12120   	-0.24700    	2                eval state : test_on_restore;
              	107.93260   	140.12120   	-0.24700    	2                eval state : test_on_last_epoch;
---> final result
              	107.93260   	140.12120   	-0.24700    	2                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 24, '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           	185.10048   	221.92978   	-69.63755   	0           
  10          	184.72589   	221.51884   	-66.16668   	0           
  100         	180.35023   	216.76721   	-39.70208   	0           
  300         	165.69640   	201.38329   	-12.48651   	0           
  500         	146.73126   	182.05115   	-4.27304    	0           
  1000        	108.41968   	140.23235   	-0.22110    	2           
---> try to load best state
              	108.41968   	140.23235   	-0.22110    	2                eval state : test_on_restore;
              	108.41968   	140.23235   	-0.22110    	2                eval state : test_on_last_epoch;
---> final result
              	108.41968   	140.23235   	-0.22110    	2                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 1, 'train_start_index': 16, '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           	190.57520   	229.57640   	-166.42175  	0           
  10          	190.30383   	229.27870   	-156.90009  	0           
  100         	187.11086   	225.81461   	-88.43648   	0           
  300         	176.10176   	214.24608   	-26.40367   	0           
  500         	159.95610   	197.60585   	-8.93269    	0           
  1000        	118.40457   	152.48848   	-0.80628    	1           
---> try to load best state
              	118.40457   	152.48848   	-0.80628    	1                eval state : test_on_restore;
              	118.40457   	152.48848   	-0.80628    	1                eval state : test_on_last_epoch;
---> final result
              	118.40457   	152.48848   	-0.80628    	1                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_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           	192.78380   	231.38098   	-435.16406  	0           
  10          	192.64996   	231.23575   	-412.36164  	0           
  100         	190.98878   	229.44681   	-240.71097  	0           
  300         	184.26950   	222.35527   	-72.47023   	0           
  500         	171.65518   	209.17632   	-23.03855   	1           
  1000        	125.42926   	159.34221   	-1.66524    	2           
---> try to load best state
              	125.42926   	159.34221   	-1.66524    	2                eval state : test_on_restore;
              	125.42926   	159.34221   	-1.66524    	2                eval state : test_on_last_epoch;
---> final result
              	125.42926   	159.34221   	-1.66524    	2                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 2 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'poisson_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           	119.27443   	163.15167   	-0.81475    	0           
  10          	118.21024   	161.97707   	-0.75307    	0           
  100         	108.35417   	150.89435   	-0.27693    	0           
  300         	91.20615    	130.46341   	0.26209     	0           
  500         	79.08366    	114.93896   	0.50593     	0           
  1000        	59.10046    	87.73226    	0.76913     	1           
---> try to load best state
              	59.10046    	87.73226    	0.76913     	1                eval state : test_on_restore;
              	59.10046    	87.73226    	0.76913     	1                eval state : test_on_last_epoch;
---> final result
              	59.10046    	87.73226    	0.76913     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 31, '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           	188.72995   	226.70663   	-97.30487   	0           
  10          	188.50418   	226.46577   	-93.65766   	0           
  100         	185.77870   	223.57736   	-63.38671   	0           
  300         	175.33638   	212.79239   	-24.44501   	0           
  500         	158.97887   	196.15990   	-9.21401    	1           
  1000        	116.36226   	150.30135   	-0.76855    	2           
---> try to load best state
              	116.36226   	150.30135   	-0.76855    	2                eval state : test_on_restore;
              	116.36226   	150.30135   	-0.76855    	2                eval state : test_on_last_epoch;
---> final result
              	116.36226   	150.30135   	-0.76855    	2                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 30, '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           	188.60919   	226.69093   	-97.49164   	0           
  10          	188.39529   	226.46652   	-93.93728   	0           
  100         	185.79961   	223.76358   	-64.23995   	0           
  300         	175.70087   	213.49162   	-25.27192   	0           
  500         	159.81512   	197.57990   	-9.74531    	0           
  1000        	119.31168   	154.27904   	-1.01240    	1           
---> try to load best state
              	119.31168   	154.27904   	-1.01240    	1                eval state : test_on_restore;
              	119.31168   	154.27904   	-1.01240    	1                eval state : test_on_last_epoch;
---> final result
              	119.31168   	154.27904   	-1.01240    	1                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 28, '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           	188.43387   	226.19153   	-93.42555   	0           
  10          	188.22729   	225.96620   	-90.11580   	0           
  100         	185.70233   	223.24841   	-62.14472   	0           
  300         	175.63080   	212.84157   	-24.50348   	0           
  500         	159.69569   	196.92763   	-9.47163    	1           
  1000        	119.88792   	154.91016   	-1.03785    	1           
---> try to load best state
              	119.88792   	154.91016   	-1.03785    	1                eval state : test_on_restore;
              	119.88792   	154.91016   	-1.03785    	1                eval state : test_on_last_epoch;
---> final result
              	119.88792   	154.91016   	-1.03785    	1                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 24, '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           	187.71748   	225.58823   	-85.17530   	0           
  10          	187.50687   	225.36259   	-82.24244   	0           
  100         	184.86218   	222.56119   	-56.64869   	0           
  300         	173.99872   	211.49983   	-21.73497   	0           
  500         	157.60847   	195.45134   	-8.60467    	0           
  1000        	120.27244   	156.11876   	-1.10151    	2           
---> try to load best state
              	120.27244   	156.11876   	-1.10151    	2                eval state : test_on_restore;
              	120.27244   	156.11876   	-1.10151    	2                eval state : test_on_last_epoch;
---> final result
              	120.27244   	156.11876   	-1.10151    	2                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 2, 'train_start_index': 16, '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           	186.72983   	224.35979   	-76.28068   	0           
  10          	186.51196   	224.13158   	-73.72606   	0           
  100         	183.82933   	221.33810   	-51.62360   	0           
  300         	173.42545   	210.71591   	-21.21461   	0           
  500         	158.06485   	195.23122   	-8.83853    	0           
  1000        	120.33070   	154.68901   	-1.12488    	1           
---> try to load best state
              	120.33070   	154.68901   	-1.12488    	1                eval state : test_on_restore;
              	120.33070   	154.68901   	-1.12488    	1                eval state : test_on_last_epoch;
---> final result
              	120.33070   	154.68901   	-1.12488    	1                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_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           	192.33252   	231.54385   	-408.34043  	0           
  10          	192.18433   	231.38986   	-385.53563  	0           
  100         	190.36223   	229.49077   	-219.83108  	0           
  300         	182.40085   	221.10281   	-62.26108   	0           
  500         	166.15518   	203.79280   	-17.29515   	1           
  1000        	116.40713   	149.78056   	-1.07382    	2           
---> try to load best state
              	116.40713   	149.78056   	-1.07382    	2                eval state : test_on_restore;
              	116.40713   	149.78056   	-1.07382    	2                eval state : test_on_last_epoch;
---> final result
              	116.40713   	149.78056   	-1.07382    	2                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 3 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'poisson_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           	117.30564   	157.80554   	-0.58636    	0           
  10          	115.94739   	156.24734   	-0.51776    	0           
  100         	103.56819   	141.64384   	-0.01002    	0           
  300         	83.16067    	116.27914   	0.49580     	0           
  500         	70.15813    	99.51624    	0.68382     	0           
  1000        	51.11301    	74.02132    	0.85684     	1           
---> try to load best state
              	51.11301    	74.02132    	0.85684     	1                eval state : test_on_restore;
              	51.11301    	74.02132    	0.85684     	1                eval state : test_on_last_epoch;
---> final result
              	51.11301    	74.02132    	0.85684     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 31, '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           	190.04762   	228.74443   	-54.76843   	0           
  10          	189.75168   	228.45471   	-52.72303   	0           
  100         	186.09714   	224.90747   	-35.24510   	0           
  300         	172.19437   	211.66859   	-12.80724   	0           
  500         	153.65988   	193.60280   	-4.94513    	1           
  1000        	110.64471   	147.08443   	-0.30412    	2           
---> try to load best state
              	110.64471   	147.08443   	-0.30412    	2                eval state : test_on_restore;
              	110.64471   	147.08443   	-0.30412    	2                eval state : test_on_last_epoch;
---> final result
              	110.64471   	147.08443   	-0.30412    	2                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 30, '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           	192.47932   	231.67720   	-80.75517   	0           
  10          	192.20557   	231.40851   	-77.24473   	0           
  100         	188.81059   	228.11328   	-48.70479   	0           
  300         	175.70050   	215.67754   	-16.28503   	0           
  500         	157.69142   	198.22295   	-6.11743    	1           
  1000        	113.00652   	150.12329   	-0.41867    	2           
---> try to load best state
              	113.00652   	150.12329   	-0.41867    	2                eval state : test_on_restore;
              	113.00652   	150.12329   	-0.41867    	2                eval state : test_on_last_epoch;
---> final result
              	113.00652   	150.12329   	-0.41867    	2                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 28, '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           	193.57266   	232.21364   	-80.58969   	0           
  10          	193.31931   	231.96149   	-77.21886   	0           
  100         	190.18594   	228.87737   	-49.73172   	0           
  300         	177.87115   	216.97008   	-17.53349   	0           
  500         	159.84383   	199.19354   	-6.64611    	1           
  1000        	113.40189   	148.82817   	-0.42933    	2           
---> try to load best state
              	113.40189   	148.82817   	-0.42933    	2                eval state : test_on_restore;
              	113.40189   	148.82817   	-0.42933    	2                eval state : test_on_last_epoch;
---> final result
              	113.40189   	148.82817   	-0.42933    	2                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 24, '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           	192.07680   	230.12927   	-81.53342   	0           
  10          	191.83521   	229.88393   	-78.19267   	0           
  100         	188.78668   	226.81929   	-50.43005   	0           
  300         	175.98181   	214.18790   	-16.97241   	0           
  500         	156.60899   	194.67264   	-5.88805    	0           
  1000        	107.45958   	141.67807   	-0.15062    	1           
---> try to load best state
              	107.45958   	141.67807   	-0.15062    	1                eval state : test_on_restore;
              	107.45958   	141.67807   	-0.15062    	1                eval state : test_on_last_epoch;
---> final result
              	107.45958   	141.67807   	-0.15062    	1                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 3, 'train_start_index': 16, '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           	192.39310   	229.76894   	-124.02584  	0           
  10          	192.17828   	229.53874   	-118.27010  	0           
  100         	189.62827   	226.83228   	-74.15811   	0           
  300         	180.45944   	217.33098   	-26.97977   	0           
  500         	166.07639   	202.68198   	-10.35480   	1           
  1000        	118.86078   	153.79166   	-0.77383    	1           
---> try to load best state
              	118.86078   	153.79166   	-0.77383    	1                eval state : test_on_restore;
              	118.86078   	153.79166   	-0.77383    	1                eval state : test_on_last_epoch;
---> final result
              	118.86078   	153.79166   	-0.77383    	1                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_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           	197.36415   	235.47665   	-638.98380  	0           
  10          	197.25493   	235.36069   	-601.98183  	0           
  100         	195.86082   	233.87645   	-332.45540  	0           
  300         	189.62648   	227.21890   	-89.81686   	0           
  500         	177.18483   	213.93539   	-26.68740   	1           
  1000        	125.03709   	157.59654   	-1.55614    	2           
---> try to load best state
              	125.03709   	157.59654   	-1.55614    	2                eval state : test_on_restore;
              	125.03709   	157.59654   	-1.55614    	2                eval state : test_on_last_epoch;
---> final result
              	125.03709   	157.59654   	-1.55614    	2                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
---> end

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

  Demo NAR cigp 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'poisson_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           	118.12601   	159.28279   	-0.61116    	0           
  10          	116.90079   	157.90311   	-0.55091    	0           
  100         	105.73527   	144.92584   	-0.08983    	0           
  300         	86.95615    	121.85671   	0.40929     	0           
  500         	74.43910    	105.65556   	0.61643     	0           
  1000        	55.01357    	79.51255    	0.82282     	1           
---> try to load best state
              	55.01357    	79.51255    	0.82282     	1                eval state : test_on_restore;
              	55.01357    	79.51255    	0.82282     	1                eval state : test_on_last_epoch;
---> final result
              	55.01357    	79.51255    	0.82282     	1                eval state : final;
----------> finish x-yl training


---------->
NAR for 1 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 31, '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           	192.39105   	230.21828   	-188.14062  	0           
  10          	192.16086   	229.98425   	-178.05340  	0           
  100         	189.24658   	227.01842   	-101.43988  	0           
  300         	176.69868   	214.22974   	-26.64561   	0           
  500         	156.40863   	193.10828   	-7.49720    	1           
  1000        	108.12284   	140.61238   	-0.27520    	2           
---> try to load best state
              	108.12284   	140.61238   	-0.27520    	2                eval state : test_on_restore;
              	108.12284   	140.61238   	-0.27520    	2                eval state : test_on_last_epoch;
---> final result
              	108.12284   	140.61238   	-0.27520    	2                eval state : final;module_name : NAR;subset : 1;cp_record_file : True;
---> end


---------->
NAR for 2 subset samples
---> Training x,yl -> yh part

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 30, '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           	191.22247   	228.89807   	-147.44027  	0           
  10          	190.96729   	228.63481   	-139.27860  	0           
  100         	187.75598   	225.33678   	-78.06641   	0           
  300         	174.08525   	211.50426   	-20.11023   	0           
  500         	152.82234   	189.79114   	-5.78698    	0           
  1000        	107.20403   	140.17812   	-0.21125    	1           
---> try to load best state
              	107.20403   	140.17812   	-0.21125    	1                eval state : test_on_restore;
              	107.20403   	140.17812   	-0.21125    	1                eval state : test_on_last_epoch;
---> final result
              	107.20403   	140.17812   	-0.21125    	1                eval state : final;module_name : NAR;subset : 2;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 28, '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           	191.51917   	229.29361   	-149.72479  	0           
  10          	191.26765   	229.02687   	-141.41354  	0           
  100         	188.12854   	225.71074   	-79.32557   	0           
  300         	175.24072   	212.27458   	-20.93151   	0           
  500         	155.23322   	191.47736   	-6.15461    	1           
  1000        	109.95045   	142.70409   	-0.26753    	2           
---> try to load best state
              	109.95045   	142.70409   	-0.26753    	2                eval state : test_on_restore;
              	109.95045   	142.70409   	-0.26753    	2                eval state : test_on_last_epoch;
---> final result
              	109.95045   	142.70409   	-0.26753    	2                eval state : final;module_name : NAR;subset : 4;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 24, '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           	192.36292   	230.13921   	-173.54014  	0           
  10          	192.12854   	229.89288   	-163.94518  	0           
  100         	189.23138   	226.85472   	-92.62838   	0           
  300         	177.30914   	214.50044   	-24.96286   	0           
  500         	157.67538   	194.25726   	-7.13383    	0           
  1000        	110.90195   	144.37999   	-0.30518    	2           
---> try to load best state
              	110.90195   	144.37999   	-0.30518    	2                eval state : test_on_restore;
              	110.90195   	144.37999   	-0.30518    	2                eval state : test_on_last_epoch;
---> final result
              	110.90195   	144.37999   	-0.30518    	2                eval state : final;module_name : NAR;subset : 8;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_v4_02', 'interp_data': False, 'seed': 4, 'train_start_index': 16, '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           	189.22058   	226.48393   	-145.73788  	0           
  10          	188.95956   	226.20358   	-137.61444  	0           
  100         	185.93573   	222.98160   	-79.26251   	0           
  300         	175.60797   	212.27704   	-25.03404   	0           
  500         	159.64435   	196.12422   	-8.50199    	1           
  1000        	115.30339   	149.07071   	-0.57812    	1           
---> try to load best state
              	115.30339   	149.07071   	-0.57812    	1                eval state : test_on_restore;
              	115.30339   	149.07071   	-0.57812    	1                eval state : test_on_last_epoch;
---> final result
              	115.30339   	149.07071   	-0.57812    	1                eval state : final;module_name : NAR;subset : 16;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'poisson_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           	193.90509   	232.80690   	-404.21877  	0           
  10          	193.75096   	232.63472   	-379.58894  	0           
  100         	191.75420   	230.41315   	-200.35413  	0           
  300         	183.03461   	220.95422   	-49.09354   	0           
  500         	168.18854   	205.35666   	-15.10384   	1           
  1000        	121.25124   	155.67596   	-1.27537    	2           
---> try to load best state
              	121.25124   	155.67596   	-1.27537    	2                eval state : test_on_restore;
              	121.25124   	155.67596   	-1.27537    	2                eval state : test_on_last_epoch;
---> final result
              	121.25124   	155.67596   	-1.27537    	2                eval state : final;module_name : NAR;subset : 32;cp_record_file : True;
