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

  Demo GAR 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], '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.1, '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_normalzie: 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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	154.78062   	-12.25370   	314.89493   	0           
  10          	97.85018    	-8.21072    	227.00179   	0           
  100         	57.15165    	-3.01459    	127.20757   	0           
  300         	55.58719    	-2.57913    	123.31052   	1           
  500         	55.40596    	-2.56647    	122.98919   	3           
  1000        	54.99532    	-2.54684    	122.29178   	6           
  2500        	54.14532    	-2.59465    	120.99375   	13          
---> try to load best state
              	55.82233    	-2.90040    	123.34670   	15               eval state : test_on_restore;
              	70.37205    	-6.03005    	144.02652   	15               eval state : test_on_last_epoch;
---> final result              	55.82233    	-2.90040    	123.34670   	15               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	64.11096    	-7.56709    	130.87781   	0           
  10          	57.39872    	-4.87060    	123.74926   	0           
  100         	59.51458    	-5.07730    	128.57388   	0           
  300         	56.56416    	-4.81557    	124.31715   	1           
  500         	56.87139    	-3.49966    	124.88580   	2           
  1000        	61.13569    	-3.76108    	132.27260   	4           
  epoch 1048 reach nan state
---> try to load best state
              	60.92174    	-3.65044    	132.19867   	4                eval state : test_on_restore;
              	61.13569    	-3.76108    	132.27260   	4                eval state : test_on_last_epoch;
---> final result
              	60.92174    	-3.65044    	132.19867   	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	62.65143    	-5.79361    	130.23248   	0           
  10          	58.24180    	-3.70700    	126.64041   	0           
  100         	56.80944    	-3.38666    	126.51056   	0           
  300         	56.30308    	-3.05873    	126.92922   	1           
  500         	56.59935    	-2.75010    	128.89598   	2           
----------------------------------------

  Demo GAR 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], '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_normalzie: True
  output_normalize: True
  noise_init: 500.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	151.78786   	-9.84420    	314.77780   	0           
  10          	143.33528   	-8.81750    	304.26422   	0           
  100         	106.89402   	-7.25396    	246.40483   	0           
  300         	88.73324    	-7.59724    	210.55589   	1           
  500         	85.41497    	-7.62967    	203.51305   	2           
  1000        	84.85626    	-7.64038    	202.30801   	6           
  2500        	84.94678    	-7.63984    	202.55403   	14          
---> try to load best state
              	85.50303    	-7.67711    	203.63191   	16               eval state : test_on_restore;
              	83.79198    	-7.37411    	201.46935   	16               eval state : test_on_last_epoch;
---> final result              	83.79198    	-7.37411    	201.46935   	16               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	92.31381    	-9.18256    	207.85425   	0           
  10          	88.21387    	-8.07866    	203.46217   	0           
  100         	89.98916    	-9.41376    	206.66269   	0           
  300         	89.06116    	-8.11404    	206.29333   	1           
  500         	90.55178    	-7.57693    	209.19212   	2           
  1000        	97.58075    	-7.17101    	222.34787   	4           
  epoch 1048 reach nan state
---> try to load best state
              	97.39669    	-7.10804    	222.31461   	4                eval state : test_on_restore;
              	97.58075    	-7.17101    	222.34787   	4                eval state : test_on_last_epoch;
---> final result
              	97.39669    	-7.10804    	222.31461   	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	90.85305    	-8.21338    	207.28685   	0           
  10          	87.78552    	-7.77641    	204.90230   	0           
  100         	86.18275    	-7.93721    	203.84615   	0           
----------------------------------------

  Demo GAR 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], '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_normalzie: True
  output_normalize: True
  noise_init: 50.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	158.46243   	-12.09436   	320.66510   	0           
  10          	151.96330   	-10.88117   	312.43628   	0           
  100         	115.00816   	-10.09621   	251.66890   	0           
  300         	83.87258    	-13.65190   	185.53282   	2           
  500         	72.69434    	-8.60052    	160.00340   	2           
  1000        	63.31709    	-4.13648    	138.60550   	5           
  2500        	59.09246    	-3.04094    	129.73055   	12          
---> try to load best state
              	58.54207    	-2.94226    	128.65857   	14               eval state : test_on_restore;
              	59.57964    	-3.10244    	130.10898   	14               eval state : test_on_last_epoch;
---> final result              	58.54207    	-2.94226    	128.65857   	14               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	66.39827    	-7.50862    	135.70895   	0           
  10          	59.69719    	-4.85360    	128.53099   	0           
  100         	61.27077    	-5.30108    	132.29918   	0           
  300         	58.16095    	-4.58427    	127.65333   	1           
  500         	58.34023    	-3.44634    	127.92043   	2           
  1000        	62.36132    	-3.86510    	134.51158   	4           
  epoch 1048 reach nan state
---> try to load best state
              	62.18008    	-3.78768    	134.43913   	4                eval state : test_on_restore;
              	62.36132    	-3.86510    	134.51158   	4                eval state : test_on_last_epoch;
---> final result
              	62.18008    	-3.78768    	134.43913   	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	65.02194    	-5.74650    	135.16090   	0           
  10          	60.69696    	-3.89738    	131.62723   	0           
  100         	58.98030    	-3.93024    	130.82237   	0           
  300         	58.15156    	-3.69436    	130.29518   	1           
  500         	58.17512    	-3.33409    	131.56140   	2           
  1000        	57.16644    	-2.79871    	129.71410   	4           
  epoch 1066 reach nan state
---> try to load best state
              	57.88901    	-3.42868    	129.85585   	5                eval state : test_on_restore;
              	57.16644    	-2.79871    	129.71410   	5                eval state : test_on_last_epoch;
---> final result
              	57.16644    	-2.79871    	129.71410   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	66.76576    	-5.90203    	137.25031   	0           
  10          	75.55596    	-9.94525    	151.26018   	0           
  100         	63.29833    	-4.63785    	136.55815   	0           
  300         	59.62833    	-2.57152    	133.72020   	1           
----------------------------------------

  Demo GAR 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], '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_normalzie: True
  output_normalize: True
  noise_init: 70.0
  grid_config: {'grid_size': [-1], 'type': 'fixed', 'dimension_map': 'identity', 'auto_broadcast_grid_size': True, 'squeeze_to_01': False}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	157.25008   	-11.68492   	319.59259   	0           
  10          	150.51775   	-10.56620   	311.08722   	0           
  100         	112.44798   	-9.43309    	248.85124   	0           
  300         	80.74841    	-12.56235   	181.00478   	1           
  500         	69.50021    	-7.79304    	154.71892   	3           
  1000        	60.25029    	-3.50624    	133.02608   	4           
  2500        	56.49575    	-2.66127    	124.91750   	10          
---> try to load best state
              	56.09343    	-2.62765    	124.16914   	12               eval state : test_on_restore;
              	57.03353    	-2.76266    	125.51658   	12               eval state : test_on_last_epoch;
---> final result              	56.09343    	-2.62765    	124.16914   	12               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	64.22083    	-7.35169    	131.43878   	0           
  10          	57.52568    	-4.67883    	124.24049   	0           
  100         	59.30481    	-4.85932    	128.49263   	0           
  300         	56.26385    	-4.52980    	124.01472   	1           
  500         	56.51847    	-3.17177    	124.42577   	2           
  1000        	60.68850    	-3.50294    	131.42467   	4           
  epoch 1048 reach nan state
---> try to load best state
              	60.50465    	-3.41958    	131.35219   	4                eval state : test_on_restore;
              	60.68850    	-3.50294    	131.42467   	4                eval state : test_on_last_epoch;
---> final result
              	60.50465    	-3.41958    	131.35219   	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	62.82253    	-5.52659    	130.84712   	0           
  10          	58.42660    	-3.64131    	127.24631   	0           
  100         	56.74771    	-3.38754    	126.75568   	0           
  300         	56.11369    	-3.15613    	126.75675   	1           
  500         	56.29370    	-2.82799    	128.43327   	2           
  1000        	55.29614    	-2.32069    	126.49395   	4           
  epoch 1066 reach nan state
---> try to load best state
              	56.05655    	-3.06201    	126.62797   	5                eval state : test_on_restore;
              	55.29614    	-2.32069    	126.49395   	5                eval state : test_on_last_epoch;
---> final result
              	55.29614    	-2.32069    	126.49395   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	64.56877    	-5.47394    	132.96913   	0           
  10          	73.70728    	-9.33865    	147.55571   	0           
  100         	61.70158    	-4.09869    	133.50536   	0           
  300         	58.28130    	-2.24724    	131.37950   	1           
  500         	58.05128    	-2.17147    	133.35411   	2           
  1000        	56.61199    	-2.17662    	130.73514   	5           
  epoch 1085 reach nan state
---> try to load best state
              	58.06648    	-3.34373    	131.56052   	5                eval state : test_on_restore;
              	56.61199    	-2.17662    	130.73514   	5                eval state : test_on_last_epoch;
---> final result
              	56.61199    	-2.17662    	130.73514   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	68.64742    	-4.96935    	137.36285   	0           
  10          	82.22778    	-8.12764    	163.40875   	0           
  100         	67.06315    	-3.53058    	142.85942   	0           
  300         	66.42197    	-2.67121    	141.48009   	1           
  500         	66.42887    	-2.38538    	143.10246   	2           
  1000        	58.28135    	-2.24963    	131.62221   	5           
----------------------------------------

  Demo GAR 
  seed: 0 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], '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_normalzie: 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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	153.94591   	-10.53408   	315.62720   	0           
  10          	146.01221   	-10.50391   	305.27405   	0           
  100         	108.25216   	-7.87893    	244.41216   	0           
  300         	85.61137    	-7.70971    	198.29887   	1           
  500         	80.66850    	-7.26034    	187.56662   	2           
  1000        	80.22141    	-7.11377    	186.55525   	4           
  2500        	82.59768    	-7.25293    	191.83228   	11          
---> try to load best state
              	83.33242    	-7.31707    	193.49565   	13               eval state : test_on_restore;
              	83.10085    	-7.54133    	192.97214   	13               eval state : test_on_last_epoch;
---> final result              	83.10085    	-7.54133    	192.97214   	13               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	91.91233    	-9.72059    	199.50378   	0           
  10          	90.09387    	-10.05043   	199.46974   	0           
  100         	89.03619    	-10.74737   	199.24690   	0           
  300         	84.96879    	-8.80291    	194.31496   	1           
  500         	83.88483    	-8.03568    	192.82617   	2           
  1000        	83.73187    	-7.93209    	192.56601   	4           
  epoch 1058 reach nan state
---> try to load best state
              	84.19910    	-8.76257    	192.29085   	5                eval state : test_on_restore;
              	83.73187    	-7.93209    	192.56601   	5                eval state : test_on_last_epoch;
---> final result
              	84.19910    	-8.76257    	192.29085   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	94.24344    	-10.23580   	201.89108   	0           
  10          	108.59237   	-15.87259   	220.24741   	0           
  100         	98.92923    	-13.93626   	211.48672   	0           
  300         	91.68362    	-9.98764    	202.88602   	1           
  500         	88.48041    	-9.06142    	199.00317   	2           
  1000        	84.65884    	-8.15713    	194.20920   	5           
  epoch 1583 reach nan state
---> try to load best state
              	84.80029    	-8.12741    	194.24103   	8                eval state : test_on_restore;
              	84.65884    	-8.15713    	194.20920   	8                eval state : test_on_last_epoch;
---> final result
              	84.65884    	-8.15713    	194.20920   	8                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	92.08655    	-9.76667    	200.27574   	0           
  10          	100.74632   	-11.78935   	213.06456   	0           
  100         	89.08364    	-10.64761   	199.34634   	0           
  300         	88.54050    	-9.35234    	198.43051   	1           
  500         	88.55015    	-9.49292    	198.68918   	2           
  1000        	86.54710    	-8.74646    	196.61024   	4           
  epoch 1110 reach nan state
---> try to load best state
              	86.71917    	-8.67285    	196.78946   	5                eval state : test_on_restore;
              	86.54710    	-8.74646    	196.61024   	5                eval state : test_on_last_epoch;
---> final result
              	86.54710    	-8.74646    	196.61024   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 0, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	91.39136    	-7.80485    	200.41945   	0           
  10          	101.75077   	-9.27093    	217.91064   	0           
  100         	94.34332    	-11.30870   	205.99136   	0           
  300         	92.80070    	-10.17177   	203.80934   	1           
  500         	91.92206    	-9.74626    	203.10725   	2           
  1000        	87.49479    	-8.75815    	197.52386   	5           
  epoch 1109 reach nan state
---> try to load best state
              	87.57151    	-8.75968    	197.61394   	5                eval state : test_on_restore;
              	87.49479    	-8.75815    	197.52386   	5                eval state : test_on_last_epoch;
---> final result
              	87.49479    	-8.75815    	197.52386   	5                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': 'FlowMix3D_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': 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_normalzie: 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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	155.89417   	-10.39067   	321.38535   	0           
  10          	148.93623   	-9.71102    	312.35602   	0           
  100         	113.24637   	-8.44337    	256.25369   	0           
  300         	91.64156    	-7.96732    	213.63527   	1           
  500         	85.57633    	-7.51808    	200.85345   	2           
  1000        	83.83982    	-7.27804    	197.12915   	4           
  2500        	86.69971    	-7.65195    	203.26556   	12          
---> try to load best state
              	87.10336    	-7.70904    	204.46576   	14               eval state : test_on_restore;
              	83.28170    	-7.01070    	198.65718   	14               eval state : test_on_last_epoch;
---> final result              	83.28170    	-7.01070    	198.65718   	14               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	96.22168    	-10.90699   	207.72786   	0           
  10          	111.02866   	-18.71257   	222.68317   	0           
  100         	139.09491   	-37.79435   	256.41385   	0           
  300         	139.61340   	-36.60440   	257.85135   	1           
  500         	144.03581   	-33.63303   	265.16147   	2           
  1000        	225.76709   	-26.12155   	368.24387   	4           
  epoch 1095 reach nan state
---> try to load best state
              	226.67839   	-28.12680   	368.08551   	5                eval state : test_on_restore;
              	225.76709   	-26.12155   	368.24387   	5                eval state : test_on_last_epoch;
---> final result
              	226.67839   	-28.12680   	368.08551   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	98.60929    	-12.07728   	208.57797   	0           
  10          	124.64492   	-19.64037   	237.03625   	0           
  100         	121.87518   	-31.75412   	235.76306   	0           
  300         	109.99010   	-18.92255   	223.94394   	1           
  500         	107.35651   	-15.60417   	220.50885   	2           
  1000        	118.24210   	-10.69383   	230.26103   	4           
  epoch 1146 reach nan state
---> try to load best state
              	119.40354   	-10.09122   	231.76662   	5                eval state : test_on_restore;
              	118.24210   	-10.69383   	230.26103   	5                eval state : test_on_last_epoch;
---> final result
              	118.24210   	-10.69383   	230.26103   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	97.45927    	-9.18976    	208.31804   	0           
  10          	112.75123   	-10.30760   	228.57726   	0           
  100         	104.39319   	-10.35111   	222.29794   	0           
  300         	98.75138    	-8.02929    	213.89885   	1           
  500         	94.72742    	-7.19240    	207.63004   	2           
  1000        	87.18115    	-8.92351    	198.60249   	5           
  epoch 1121 reach nan state
---> try to load best state
              	87.70065    	-10.21067   	198.23116   	6                eval state : test_on_restore;
              	87.18115    	-8.92351    	198.60249   	6                eval state : test_on_last_epoch;
---> final result
              	87.70065    	-10.21067   	198.23116   	6                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 1, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	93.79861    	-8.22886    	206.97054   	0           
  10          	104.31360   	-9.15462    	222.13498   	0           
  100         	92.59619    	-10.70299   	207.27283   	0           
  300         	89.26086    	-10.90879   	202.49519   	1           
  500         	88.20855    	-10.61914   	201.18912   	2           
  1000        	83.76868    	-9.23924    	195.39604   	5           
  epoch 1064 reach nan state
---> try to load best state
              	83.75433    	-9.12274    	195.33826   	5                eval state : test_on_restore;
              	83.76868    	-9.23924    	195.39604   	5                eval state : test_on_last_epoch;
---> final result
              	83.75433    	-9.12274    	195.33826   	5                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': 'FlowMix3D_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], 'outputs_format': ['y[0]'], 'force_2d': 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_normalzie: 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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	153.56622   	-10.87567   	320.94781   	0           
  10          	146.26041   	-10.53053   	310.99161   	0           
  100         	115.36106   	-8.31091    	260.34415   	0           
  300         	97.79075    	-8.11538    	225.22398   	1           
  500         	93.50072    	-7.98317    	216.02975   	2           
  1000        	92.42874    	-7.87371    	213.78491   	5           
  2500        	94.16019    	-7.99509    	217.66827   	12          
---> try to load best state
              	94.21967    	-7.94122    	218.19684   	14               eval state : test_on_restore;
              	91.37998    	-7.36524    	214.11960   	14               eval state : test_on_last_epoch;
---> final result              	91.37998    	-7.36524    	214.11960   	14               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	106.60281   	-16.44942   	224.73195   	0           
  10          	132.97795   	-30.38728   	249.65915   	0           
  100         	161.64217   	-107.66784  	280.64056   	0           
  300         	139.17519   	-56.41780   	255.70927   	1           
  500         	126.86630   	-40.96502   	244.35944   	2           
  1000        	110.89157   	-25.14220   	229.98576   	4           
  2500        	110.87550   	-25.27477   	229.94159   	11          
---> try to load best state
              	110.87494   	-25.27490   	229.94092   	14               eval state : test_on_restore;
              	110.87550   	-25.27477   	229.94159   	14               eval state : test_on_last_epoch;
---> final result
              	110.87494   	-25.27490   	229.94092   	14               eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	103.25248   	-11.21628   	223.55246   	0           
  10          	116.10248   	-13.20847   	239.00192   	0           
  100         	94.72510    	-12.38253   	214.50558   	0           
  300         	91.90208    	-11.23276   	210.80463   	1           
  500         	91.82970    	-10.19769   	210.83257   	2           
  1000        	89.74496    	-9.10332    	210.23969   	5           
  epoch 1092 reach nan state
---> try to load best state
              	90.75925    	-10.23884   	210.58110   	5                eval state : test_on_restore;
              	89.74496    	-9.10332    	210.23969   	5                eval state : test_on_last_epoch;
---> final result
              	89.74496    	-9.10332    	210.23969   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	99.64512    	-9.94900    	221.86859   	0           
  10          	113.19388   	-11.69751   	237.74738   	0           
  100         	108.85886   	-12.96987   	234.99309   	0           
  300         	96.17395    	-10.45761   	219.42230   	1           
  500         	91.44186    	-8.78890    	213.31911   	2           
  1000        	92.53451    	-8.74295    	214.83435   	5           
  epoch 1180 reach nan state
---> try to load best state
              	92.65873    	-8.41795    	215.05945   	5                eval state : test_on_restore;
              	92.53451    	-8.74295    	214.83435   	5                eval state : test_on_last_epoch;
---> final result
              	92.53451    	-8.74295    	214.83435   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 2, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	101.21700   	-9.43603    	222.62286   	0           
  10          	110.07922   	-10.08515   	234.94963   	0           
  100         	108.14291   	-10.98448   	233.73447   	0           
  300         	102.83219   	-9.32179    	229.03862   	1           
  500         	100.35166   	-8.81965    	227.16383   	2           
  1000        	95.09735    	-8.93759    	220.47537   	5           
  2500        	93.84393    	-7.99351    	219.10667   	12          
---> try to load best state
              	93.68278    	-7.98015    	218.84589   	15               eval state : test_on_restore;
              	93.84393    	-7.99351    	219.10667   	15               eval state : test_on_last_epoch;
---> final result
              	93.68278    	-7.98015    	218.84589   	15               eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 3 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], '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_normalzie: 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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	152.73190   	-9.24419    	320.74789   	0           
  10          	146.22237   	-8.73324    	311.68848   	0           
  100         	123.71699   	-8.55332    	276.06845   	0           
  300         	113.93803   	-7.91780    	258.10220   	1           
  500         	113.89068   	-7.90300    	258.01697   	2           
  1000        	117.50883   	-8.08507    	264.94617   	4           
  2500        	120.96786   	-8.09226    	271.59277   	12          
---> try to load best state
              	121.45734   	-7.90055    	272.64426   	14               eval state : test_on_restore;
              	120.54636   	-7.89804    	271.34006   	14               eval state : test_on_last_epoch;
---> final result              	120.54636   	-7.89804    	271.34006   	14               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	132.73372   	-22.83910   	280.15860   	0           
  10          	148.92494   	-30.81556   	293.29495   	0           
  100         	133.55162   	-35.94834   	281.36615   	0           
  300         	127.85900   	-12.54164   	277.49045   	1           
  500         	126.66640   	-11.81830   	276.54404   	2           
  1000        	125.67822   	-11.22248   	275.97046   	4           
  epoch 1316 reach nan state
---> try to load best state
              	125.70502   	-11.21184   	275.98135   	5                eval state : test_on_restore;
              	125.67822   	-11.22248   	275.97046   	5                eval state : test_on_last_epoch;
---> final result
              	125.67822   	-11.22248   	275.97046   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	132.21544   	-19.80113   	280.11407   	0           
  10          	150.72932   	-34.89270   	294.23550   	0           
  100         	133.81477   	-20.02117   	279.97159   	0           
  300         	127.33724   	-13.20530   	276.52344   	1           
  500         	125.23599   	-11.08171   	274.88416   	2           
  1000        	120.54877   	-8.72721    	271.54742   	4           
  2500        	120.56824   	-8.09596    	271.87057   	11          
---> try to load best state
              	120.94104   	-9.18118    	272.11032   	14               eval state : test_on_restore;
              	120.56824   	-8.09596    	271.87057   	14               eval state : test_on_last_epoch;
---> final result
              	120.56824   	-8.09596    	271.87057   	14               eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	128.44157   	-10.79643   	278.82385   	0           
  10          	138.35359   	-10.67153   	288.93350   	0           
  100         	127.33488   	-10.21275   	277.65936   	0           
  300         	124.58149   	-9.56568    	275.00284   	1           
  500         	122.90128   	-8.71078    	273.55884   	2           
  1000        	119.19118   	-8.12765    	270.74838   	4           
  epoch 1075 reach nan state
---> try to load best state
              	119.27832   	-8.10825    	270.76431   	5                eval state : test_on_restore;
              	119.19118   	-8.12765    	270.74838   	5                eval state : test_on_last_epoch;
---> final result
              	119.19118   	-8.12765    	270.74838   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 3, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	126.75888   	-9.56407    	277.70041   	0           
  10          	130.13757   	-8.54046    	281.26038   	0           
  100         	121.86523   	-8.72773    	270.25891   	0           
  300         	122.41214   	-8.47253    	272.48926   	1           
  500         	122.56429   	-8.27409    	273.32309   	2           
  1000        	120.64215   	-7.70111    	272.45364   	5           
  epoch 1515 reach nan state
---> try to load best state
              	120.38931   	-7.47351    	272.24518   	8                eval state : test_on_restore;
              	120.64215   	-7.70111    	272.45364   	8                eval state : test_on_last_epoch;
---> final result
              	120.38931   	-7.47351    	272.24518   	8                eval state : final;module_name : GAR;cp_record_file : True;
---> end

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

  Demo GAR 
  seed: 4 
  interp_data: False 

----------------------------------------
---> Training x -> yl part
---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]'], '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_normalzie: 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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	156.04570   	-11.25692   	318.52505   	0           
  10          	149.03784   	-10.26353   	309.68994   	0           
  100         	110.25224   	-8.77367    	246.77292   	0           
  300         	78.07240    	-11.10875   	177.78262   	1           
  500         	66.62036    	-7.34532    	150.53070   	2           
  1000        	57.32780    	-3.30536    	128.06175   	5           
  2500        	54.01019    	-2.57401    	120.68528   	12          
---> try to load best state
              	53.89861    	-2.62219    	120.54170   	15               eval state : test_on_restore;
              	54.96955    	-2.77946    	122.13804   	15               eval state : test_on_last_epoch;
---> final result              	53.89861    	-2.62219    	120.54170   	15               eval state : final;
----------> finish x-yl training


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 4, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	62.33258    	-7.47879    	128.08141   	0           
  10          	55.68367    	-4.74602    	120.93814   	0           
  100         	57.73713    	-4.70810    	125.79123   	0           
  300         	54.82273    	-4.46521    	121.57204   	1           
  500         	55.15920    	-3.20802    	122.17339   	2           
  1000        	59.50387    	-3.46389    	129.66658   	4           
  epoch 1048 reach nan state
---> try to load best state
              	59.31122    	-3.36182    	129.59435   	4                eval state : test_on_restore;
              	59.50387    	-3.46389    	129.66658   	4                eval state : test_on_last_epoch;
---> final result
              	59.31122    	-3.36182    	129.59435   	4                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 8, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	60.90486    	-5.69992    	127.43784   	0           
  10          	56.45563    	-3.58964    	123.80287   	0           
  100         	54.91873    	-3.09037    	123.71333   	0           
  300         	54.47774    	-2.77090    	124.28226   	1           
  500         	54.83395    	-2.47221    	126.37074   	2           
  1000        	53.87494    	-1.98434    	124.35693   	4           
  epoch 1066 reach nan state
---> try to load best state
              	54.63269    	-2.78045    	124.47986   	5                eval state : test_on_restore;
              	53.87494    	-1.98434    	124.35693   	5                eval state : test_on_last_epoch;
---> final result
              	53.87494    	-1.98434    	124.35693   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 16, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	62.67015    	-5.37753    	129.57494   	0           
  10          	72.17840    	-8.99595    	144.70926   	0           
  100         	60.64256    	-3.73576    	131.59344   	0           
  300         	57.47633    	-2.06095    	130.15128   	1           
  500         	57.30033    	-1.96141    	132.40948   	2           
  1000        	55.86982    	-1.99766    	129.74754   	5           
  epoch 1085 reach nan state
---> try to load best state
              	57.37300    	-3.27094    	130.59909   	5                eval state : test_on_restore;
              	55.86982    	-1.99766    	129.74754   	5                eval state : test_on_last_epoch;
---> final result
              	55.86982    	-1.99766    	129.74754   	5                eval state : final;module_name : GAR;cp_record_file : True;
---> end


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

---> module config
  dataset: {'name': 'FlowMix3D_MF', 'interp_data': False, 'seed': 4, 'train_start_index': 0, 'train_sample': 32, 'eval_start_index': 0, 'eval_sample': 128, 'inputs_format': ['x[0]', 'y[0]'], 'outputs_format': ['y[-1]'], 'force_2d': 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.001, 'optional_param': 0.001, 'noise': 0.001}
  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}
---> training record
  epoch       	mae         	r2          	rmse        	time        
  1           	66.75043    	-5.03219    	133.92134   	0           
  10          	80.83874    	-7.99783    	160.83865   	0           
  100         	66.11565    	-3.27424    	141.09843   	0           
  300         	65.53498    	-2.45226    	139.81767   	1           
  500         	65.53823    	-2.17284    	141.55602   	2           
  1000        	57.40528    	-2.07469    	130.39668   	5           
  epoch 2329 reach nan state
---> try to load best state
              	57.51288    	-2.01350    	130.69463   	12               eval state : test_on_restore;
              	57.40528    	-2.07469    	130.39668   	12               eval state : test_on_last_epoch;
---> final result
              	57.40528    	-2.07469    	130.39668   	12               eval state : final;module_name : GAR;cp_record_file : True;
