diff --git a/examples/benchmarks/LSTM/workflow_config_lstm_Alpha158.yaml b/examples/benchmarks/LSTM/workflow_config_lstm_Alpha158.yaml
index 522f6443cbf..1ca162cdd47 100755
--- a/examples/benchmarks/LSTM/workflow_config_lstm_Alpha158.yaml
+++ b/examples/benchmarks/LSTM/workflow_config_lstm_Alpha158.yaml
@@ -62,11 +62,11 @@ task:
             n_epochs: 200
             lr: 1e-3
             early_stop: 10
-            batch_size: 800
+            batch_size: 2000
             metric: loss
             loss: mse
-            n_jobs: 20
-            GPU: 0
+            n_jobs: 6
+            GPU: "xpu"
     dataset:
         class: TSDatasetH
         module_path: qlib.data.dataset
diff --git a/qlib/_version.py b/qlib/_version.py
new file mode 100644
index 00000000000..4d6b3b09ee9
--- /dev/null
+++ b/qlib/_version.py
@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.9.8.dev18'
+__version_tuple__ = version_tuple = (0, 9, 8, 'dev18')
+
+__commit_id__ = commit_id = 'g477160e4a'
diff --git a/qlib/contrib/model/pytorch_adarnn.py b/qlib/contrib/model/pytorch_adarnn.py
index c1585a6ac0a..ec47fabd5c5 100644
--- a/qlib/contrib/model/pytorch_adarnn.py
+++ b/qlib/contrib/model/pytorch_adarnn.py
@@ -12,7 +12,7 @@
 import torch.nn.functional as F
 import torch.optim as optim
 from torch.autograd import Function
-from qlib.contrib.model.pytorch_utils import count_parameters
+from qlib.contrib.model.pytorch_utils import count_parameters, empty_cache
 from qlib.data.dataset import DatasetH
 from qlib.data.dataset.handler import DataHandlerLP
 from qlib.log import get_module_logger
@@ -81,7 +81,10 @@ def __init__(
         self.optimizer = optimizer.lower()
         self.loss = loss
         self.n_splits = n_splits
-        self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -298,7 +301,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
         return best_score
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
@@ -396,7 +399,10 @@ def __init__(
         self.model_type = model_type
         self.trans_loss = trans_loss
         self.len_seq = len_seq
-        self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
         in_size = self.n_input
 
         features = nn.ModuleList()
@@ -558,7 +564,10 @@ def __init__(self, loss_type="cosine", input_dim=512, GPU=0):
         """
         self.loss_type = loss_type
         self.input_dim = input_dim
-        self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
 
     def compute(self, X, Y):
         """Compute adaptation loss
diff --git a/qlib/contrib/model/pytorch_add.py b/qlib/contrib/model/pytorch_add.py
index c94a03ecc31..02e6aa1e4f9 100644
--- a/qlib/contrib/model/pytorch_add.py
+++ b/qlib/contrib/model/pytorch_add.py
@@ -83,7 +83,10 @@ def __init__(
         self.optimizer = optimizer.lower()
         self.base_model = base_model
         self.model_path = model_path
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.gamma = gamma
@@ -414,7 +417,7 @@ def fit(
         save_path = get_or_create_path(save_path)
         torch.save(best_param, save_path)
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         x_test = dataset.prepare(segment, col_set="feature", data_key=DataHandlerLP.DK_I)
diff --git a/qlib/contrib/model/pytorch_alstm.py b/qlib/contrib/model/pytorch_alstm.py
index d1c619ebf41..c0b4d3ad3b8 100644
--- a/qlib/contrib/model/pytorch_alstm.py
+++ b/qlib/contrib/model/pytorch_alstm.py
@@ -11,6 +11,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -70,7 +71,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -262,7 +266,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_alstm_ts.py b/qlib/contrib/model/pytorch_alstm_ts.py
index 95b5cf95d8b..96a9022128d 100644
--- a/qlib/contrib/model/pytorch_alstm_ts.py
+++ b/qlib/contrib/model/pytorch_alstm_ts.py
@@ -11,6 +11,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -74,7 +75,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.n_jobs = n_jobs
         self.seed = seed
 
@@ -282,7 +286,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_gats.py b/qlib/contrib/model/pytorch_gats.py
index 16439b3783a..3c5c1b37704 100644
--- a/qlib/contrib/model/pytorch_gats.py
+++ b/qlib/contrib/model/pytorch_gats.py
@@ -11,6 +11,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 import torch
 import torch.nn as nn
 import torch.optim as optim
@@ -75,7 +76,10 @@ def __init__(
         self.loss = loss
         self.base_model = base_model
         self.model_path = model_path
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -296,7 +300,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_gats_ts.py b/qlib/contrib/model/pytorch_gats_ts.py
index 09f0ac08b25..a212d1a55bb 100644
--- a/qlib/contrib/model/pytorch_gats_ts.py
+++ b/qlib/contrib/model/pytorch_gats_ts.py
@@ -10,6 +10,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 import torch
 import torch.nn as nn
 import torch.optim as optim
@@ -94,7 +95,10 @@ def __init__(
         self.loss = loss
         self.base_model = base_model
         self.model_path = model_path
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.n_jobs = n_jobs
         self.seed = seed
 
@@ -310,7 +314,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_general_nn.py b/qlib/contrib/model/pytorch_general_nn.py
index 503c5a2a50c..9c7e586bcc8 100644
--- a/qlib/contrib/model/pytorch_general_nn.py
+++ b/qlib/contrib/model/pytorch_general_nn.py
@@ -26,6 +26,7 @@
     get_or_create_path,
 )
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 from ...model.utils import ConcatDataset
 
@@ -83,7 +84,10 @@ def __init__(
         self.optimizer = optimizer.lower()
         self.loss = loss
         self.weight_decay = weight_decay
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.n_jobs = n_jobs
         self.seed = seed
 
@@ -329,7 +333,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(
         self,
diff --git a/qlib/contrib/model/pytorch_gru.py b/qlib/contrib/model/pytorch_gru.py
index 06aa6810b80..615acee4884 100755
--- a/qlib/contrib/model/pytorch_gru.py
+++ b/qlib/contrib/model/pytorch_gru.py
@@ -17,6 +17,7 @@
 from ...data.dataset import DatasetH
 from ...data.dataset.handler import DataHandlerLP
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 from ...model.base import Model
 from ...utils import get_or_create_path
 from .pytorch_utils import count_parameters
@@ -70,7 +71,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -287,7 +291,7 @@ def fit(
                 rec.log_metrics(step=i, **{k: v})
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_gru_ts.py b/qlib/contrib/model/pytorch_gru_ts.py
index 65da5ac4b40..98c4573994e 100755
--- a/qlib/contrib/model/pytorch_gru_ts.py
+++ b/qlib/contrib/model/pytorch_gru_ts.py
@@ -10,6 +10,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -72,7 +73,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.n_jobs = n_jobs
         self.seed = seed
 
@@ -276,7 +280,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_hist.py b/qlib/contrib/model/pytorch_hist.py
index 779cde9c859..a427ac420be 100644
--- a/qlib/contrib/model/pytorch_hist.py
+++ b/qlib/contrib/model/pytorch_hist.py
@@ -13,6 +13,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 import torch
 import torch.nn as nn
 import torch.optim as optim
@@ -80,7 +81,10 @@ def __init__(
         self.model_path = model_path
         self.stock2concept = stock2concept
         self.stock_index = stock_index
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -326,6 +330,8 @@ def fit(
         self.logger.info("best score: %.6lf @ %d" % (best_score, best_epoch))
         self.HIST_model.load_state_dict(best_param)
         torch.save(best_param, save_path)
+        if self.use_gpu:
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_igmtf.py b/qlib/contrib/model/pytorch_igmtf.py
index 0bddc5a0f5f..2c033779c14 100644
--- a/qlib/contrib/model/pytorch_igmtf.py
+++ b/qlib/contrib/model/pytorch_igmtf.py
@@ -11,6 +11,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -74,7 +75,10 @@ def __init__(
         self.loss = loss
         self.base_model = base_model
         self.model_path = model_path
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -322,7 +326,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_krnn.py b/qlib/contrib/model/pytorch_krnn.py
index d97920b4dc5..b74a71872e9 100644
--- a/qlib/contrib/model/pytorch_krnn.py
+++ b/qlib/contrib/model/pytorch_krnn.py
@@ -11,6 +11,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -276,7 +277,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -485,7 +489,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_localformer.py b/qlib/contrib/model/pytorch_localformer.py
index 42851dd6a28..c7b5c94c895 100644
--- a/qlib/contrib/model/pytorch_localformer.py
+++ b/qlib/contrib/model/pytorch_localformer.py
@@ -12,6 +12,7 @@
 import math
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -58,7 +59,10 @@ def __init__(
         self.optimizer = optimizer.lower()
         self.loss = loss
         self.n_jobs = n_jobs
-        self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
         self.logger = get_module_logger("TransformerModel")
         self.logger.info("Naive Transformer:" "\nbatch_size : {}" "\ndevice : {}".format(self.batch_size, self.device))
@@ -211,7 +215,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_localformer_ts.py b/qlib/contrib/model/pytorch_localformer_ts.py
index ae60a399682..81287fab7ed 100644
--- a/qlib/contrib/model/pytorch_localformer_ts.py
+++ b/qlib/contrib/model/pytorch_localformer_ts.py
@@ -11,6 +11,7 @@
 import math
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -56,7 +57,10 @@ def __init__(
         self.optimizer = optimizer.lower()
         self.loss = loss
         self.n_jobs = n_jobs
-        self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
         self.logger = get_module_logger("TransformerModel")
         self.logger.info(
@@ -198,7 +202,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_lstm.py b/qlib/contrib/model/pytorch_lstm.py
index 3ba09097acd..2626a501dbd 100755
--- a/qlib/contrib/model/pytorch_lstm.py
+++ b/qlib/contrib/model/pytorch_lstm.py
@@ -11,6 +11,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -69,7 +70,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -257,7 +261,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_lstm_ts.py b/qlib/contrib/model/pytorch_lstm_ts.py
index a0fc34d5832..ed609223623 100755
--- a/qlib/contrib/model/pytorch_lstm_ts.py
+++ b/qlib/contrib/model/pytorch_lstm_ts.py
@@ -10,6 +10,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -71,7 +72,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.n_jobs = n_jobs
         self.seed = seed
 
@@ -271,7 +275,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_nn.py b/qlib/contrib/model/pytorch_nn.py
index 190d1ba45ad..307303ab550 100644
--- a/qlib/contrib/model/pytorch_nn.py
+++ b/qlib/contrib/model/pytorch_nn.py
@@ -17,7 +17,7 @@
 import torch.nn as nn
 import torch.optim as optim
 
-from .pytorch_utils import count_parameters
+from .pytorch_utils import count_parameters, empty_cache
 from ...model.base import Model
 from ...data.dataset import DatasetH
 from ...data.dataset.handler import DataHandlerLP
@@ -332,7 +332,7 @@ def fit(
             # restore the optimal parameters after training
             self.dnn_model.load_state_dict(torch.load(save_path, map_location=self.device))
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def get_lr(self):
         assert len(self.train_optimizer.param_groups) == 1
diff --git a/qlib/contrib/model/pytorch_sandwich.py b/qlib/contrib/model/pytorch_sandwich.py
index 344368143ff..04e153a3b92 100644
--- a/qlib/contrib/model/pytorch_sandwich.py
+++ b/qlib/contrib/model/pytorch_sandwich.py
@@ -11,6 +11,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -152,7 +153,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -355,7 +359,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_sfm.py b/qlib/contrib/model/pytorch_sfm.py
index c971f1a58c5..e14e093554c 100644
--- a/qlib/contrib/model/pytorch_sfm.py
+++ b/qlib/contrib/model/pytorch_sfm.py
@@ -10,6 +10,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -233,7 +234,10 @@ def __init__(
         self.eval_steps = eval_steps
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -410,8 +414,8 @@ def fit(
         self.logger.info("best score: %.6lf @ %d" % (best_score, best_epoch))
         self.sfm_model.load_state_dict(best_param)
         torch.save(best_param, save_path)
-        if self.device != "cpu":
-            torch.cuda.empty_cache()
+        if self.use_gpu:
+            empty_cache(self.device)
 
     def mse(self, pred, label):
         loss = (pred - label) ** 2
diff --git a/qlib/contrib/model/pytorch_tabnet.py b/qlib/contrib/model/pytorch_tabnet.py
index 3c698edade3..c9edf82edf4 100644
--- a/qlib/contrib/model/pytorch_tabnet.py
+++ b/qlib/contrib/model/pytorch_tabnet.py
@@ -9,6 +9,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -69,7 +70,10 @@ def __init__(
         self.n_epochs = n_epochs
         self.logger = get_module_logger("TabNet")
         self.pretrain_n_epochs = pretrain_n_epochs
-        self.device = "cuda:%s" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu"
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.loss = loss
         self.metric = metric
         self.early_stop = early_stop
@@ -212,7 +216,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_tcn.py b/qlib/contrib/model/pytorch_tcn.py
index f6e7e953a00..bacd6b7159d 100755
--- a/qlib/contrib/model/pytorch_tcn.py
+++ b/qlib/contrib/model/pytorch_tcn.py
@@ -11,6 +11,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -75,7 +76,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
 
         self.logger.info(
@@ -267,7 +271,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_tcn_ts.py b/qlib/contrib/model/pytorch_tcn_ts.py
index a6cc38885c3..20475f5a143 100755
--- a/qlib/contrib/model/pytorch_tcn_ts.py
+++ b/qlib/contrib/model/pytorch_tcn_ts.py
@@ -10,6 +10,7 @@
 import copy
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -73,7 +74,10 @@ def __init__(
         self.early_stop = early_stop
         self.optimizer = optimizer.lower()
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.n_jobs = n_jobs
         self.seed = seed
 
@@ -261,7 +265,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_tcts.py b/qlib/contrib/model/pytorch_tcts.py
index d8736627c2b..ae56714036e 100644
--- a/qlib/contrib/model/pytorch_tcts.py
+++ b/qlib/contrib/model/pytorch_tcts.py
@@ -11,6 +11,7 @@
 import random
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -73,7 +74,10 @@ def __init__(
         self.batch_size = batch_size
         self.early_stop = early_stop
         self.loss = loss
-        self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() else "cpu")
         self.use_gpu = torch.cuda.is_available()
         self.seed = seed
         self.input_dim = input_dim
@@ -344,7 +348,7 @@ def training(
         self.fitted = True
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
         return best_loss
 
diff --git a/qlib/contrib/model/pytorch_tra.py b/qlib/contrib/model/pytorch_tra.py
index bc9a6aa9779..5f4ef894f2b 100644
--- a/qlib/contrib/model/pytorch_tra.py
+++ b/qlib/contrib/model/pytorch_tra.py
@@ -26,6 +26,7 @@
 from qlib.log import get_module_logger
 from qlib.model.base import Model
 from qlib.contrib.data.dataset import MTSDatasetH
+from .pytorch_utils import empty_cache
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
@@ -83,6 +84,8 @@ def __init__(
         freeze_predictors=False,
         transport_method="none",
         memory_mode="sample",
+        GPU=0,
+        **kwargs,
     ):
         self.logger = get_module_logger("TRA")
 
@@ -132,15 +135,20 @@ def __init__(
             if SummaryWriter is not None:
                 self._writer = SummaryWriter(log_dir=self.logdir)
 
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % (GPU) if torch.cuda.is_available() and GPU >= 0 else "cpu")
+
         self._init_model()
 
     def _init_model(self):
         self.logger.info("init TRAModel...")
 
-        self.model = eval(self.model_type)(**self.model_config).to(device)
+        self.model = eval(self.model_type)(**self.model_config).to(self.device)
         print(self.model)
 
-        self.tra = TRA(self.model.output_size, **self.tra_config).to(device)
+        self.tra = TRA(self.model.output_size, **self.tra_config).to(self.device)
         print(self.tra)
 
         if self.init_state:
@@ -496,6 +504,9 @@ def fit(self, dataset, evals_result=dict()):
             with open(self.logdir + "/info.json", "w") as f:
                 json.dump(info, f)
 
+        if self.use_gpu:
+            empty_cache(self.device)
+
     def predict(self, dataset, segment="test"):
         assert isinstance(dataset, MTSDatasetH), "TRAModel only supports `qlib.contrib.data.dataset.MTSDatasetH`"
 
diff --git a/qlib/contrib/model/pytorch_transformer.py b/qlib/contrib/model/pytorch_transformer.py
index d05b9f4cad1..622d4ee8dfb 100644
--- a/qlib/contrib/model/pytorch_transformer.py
+++ b/qlib/contrib/model/pytorch_transformer.py
@@ -12,6 +12,7 @@
 import math
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -57,7 +58,10 @@ def __init__(
         self.optimizer = optimizer.lower()
         self.loss = loss
         self.n_jobs = n_jobs
-        self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
         self.logger = get_module_logger("TransformerModel")
         self.logger.info("Naive Transformer:" "\nbatch_size : {}" "\ndevice : {}".format(self.batch_size, self.device))
@@ -210,7 +214,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset: DatasetH, segment: Union[Text, slice] = "test"):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_transformer_ts.py b/qlib/contrib/model/pytorch_transformer_ts.py
index 70590e03e5f..3dac6400e91 100644
--- a/qlib/contrib/model/pytorch_transformer_ts.py
+++ b/qlib/contrib/model/pytorch_transformer_ts.py
@@ -11,6 +11,7 @@
 import math
 from ...utils import get_or_create_path
 from ...log import get_module_logger
+from .pytorch_utils import empty_cache
 
 import torch
 import torch.nn as nn
@@ -55,7 +56,10 @@ def __init__(
         self.optimizer = optimizer.lower()
         self.loss = loss
         self.n_jobs = n_jobs
-        self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
+        if isinstance(GPU, str):
+            self.device = torch.device(GPU)
+        else:
+            self.device = torch.device("cuda:%d" % GPU if torch.cuda.is_available() and GPU >= 0 else "cpu")
         self.seed = seed
         self.logger = get_module_logger("TransformerModel")
         self.logger.info("Naive Transformer:" "\nbatch_size : {}" "\ndevice : {}".format(self.batch_size, self.device))
@@ -196,7 +200,7 @@ def fit(
         torch.save(best_param, save_path)
 
         if self.use_gpu:
-            torch.cuda.empty_cache()
+            empty_cache(self.device)
 
     def predict(self, dataset):
         if not self.fitted:
diff --git a/qlib/contrib/model/pytorch_utils.py b/qlib/contrib/model/pytorch_utils.py
index eb35c383b06..2099a788d61 100644
--- a/qlib/contrib/model/pytorch_utils.py
+++ b/qlib/contrib/model/pytorch_utils.py
@@ -4,6 +4,9 @@
 import torch.nn as nn
 
 
+import torch
+
+
 def count_parameters(models_or_parameters, unit="m"):
     """
     This function is to obtain the storage size unit of a (or multiple) models.
@@ -35,3 +38,19 @@ def count_parameters(models_or_parameters, unit="m"):
     elif unit is not None:
         raise ValueError("Unknown unit: {:}".format(unit))
     return counts
+
+
+def get_device_type(device):
+    if isinstance(device, torch.device):
+        return device.type
+    return str(device).split(":")[0]
+
+
+def empty_cache(device):
+    dtype = get_device_type(device)
+    if dtype == "cuda":
+        torch.cuda.empty_cache()
+    elif dtype == "xpu":
+        torch.xpu.empty_cache()
+    elif dtype == "mps":
+        torch.mps.empty_cache()