Update R and workflow

qlib/contrib/data/handler.py

@@ -9,6 +9,7 @@ from ...log import TimeInspector
 from inspect import getfullargspec
 import copy
 
+
 class ALPHA360_Denoise(DataHandlerLP):
     def __init__(self, instruments="csi500", start_time=None, end_time=None, fit_start_time=None, fit_end_time=None):
         data_loader = {

qlib/contrib/model/gbdt.py

@@ -12,6 +12,7 @@ from ...data.dataset.handler import DataHandlerLP
 
 class LGBModel(ModelFT):
     """LightGBM Model"""
+
     def __init__(self, loss="mse", **kwargs):
         if loss not in {"mse", "binary"}:
             raise NotImplementedError
@@ -20,9 +21,9 @@ class LGBModel(ModelFT):
         self.model = None
 
     def _prepare_data(self, dataset: DatasetH):
-        df_train, df_valid = dataset.prepare(["train", "valid"],
-                                             col_set=["feature", "label"],
-                                             data_key=DataHandlerLP.DK_L)
+        df_train, df_valid = dataset.prepare(
+            ["train", "valid"], col_set=["feature", "label"], data_key=DataHandlerLP.DK_L
+        )
         x_train, y_train = df_train["feature"], df_train["label"]
         x_valid, y_valid = df_valid["feature"], df_valid["label"]
 
@@ -36,23 +37,27 @@ class LGBModel(ModelFT):
         dvalid = lgb.Dataset(x_valid.values, label=y_valid)
         return dtrain, dvalid
 
-    def fit(self,
-            dataset: DatasetH,
-            num_boost_round=1000,
-            early_stopping_rounds=50,
-            verbose_eval=20,
-            evals_result=dict(),
-            **kwargs):
+    def fit(
+        self,
+        dataset: DatasetH,
+        num_boost_round=1000,
+        early_stopping_rounds=50,
+        verbose_eval=20,
+        evals_result=dict(),
+        **kwargs
+    ):
         dtrain, dvalid = self._prepare_data(dataset)
-        self.model = lgb.train(self.params,
-                               dtrain,
-                               num_boost_round=num_boost_round,
-                               valid_sets=[dtrain, dvalid],
-                               valid_names=["train", "valid"],
-                               early_stopping_rounds=early_stopping_rounds,
-                               verbose_eval=verbose_eval,
-                               evals_result=evals_result,
-                               **kwargs)
+        self.model = lgb.train(
+            self.params,
+            dtrain,
+            num_boost_round=num_boost_round,
+            valid_sets=[dtrain, dvalid],
+            valid_names=["train", "valid"],
+            early_stopping_rounds=early_stopping_rounds,
+            verbose_eval=verbose_eval,
+            evals_result=evals_result,
+            **kwargs
+        )
         evals_result["train"] = list(evals_result["train"].values())[0]
         evals_result["valid"] = list(evals_result["valid"].values())[0]
 
@@ -76,10 +81,12 @@ class LGBModel(ModelFT):
             verbose level
         """
         dtrain, _ = self._prepare_data(dataset)
-        self.model = lgb.train(self.params,
-                               dtrain,
-                               num_boost_round=num_boost_round,
-                               init_model=self.model,
-                               valid_sets=[dtrain],
-                               valid_names=["train"],
-                               verbose_eval=verbose_eval)
+        self.model = lgb.train(
+            self.params,
+            dtrain,
+            num_boost_round=num_boost_round,
+            init_model=self.model,
+            valid_sets=[dtrain],
+            valid_names=["train"],
+            verbose_eval=verbose_eval,
+        )

qlib/contrib/model/pytorch_gru.py

@@ -50,7 +50,7 @@ class GRU(Model):
         dropout=0.0,
         n_epochs=200,
         lr=0.001,
-        metric='IC',
+        metric="IC",
         batch_size=2000,
         early_stop=20,
         loss="mse",
@@ -134,48 +134,48 @@ class GRU(Model):
                 os.environ["CUDA_VISIBLE_DEVICES"] = self.visible_GPU
 
     def mse(self, pred, label):
-        loss = (pred - label)**2
+        loss = (pred - label) ** 2
         return torch.mean(loss)
 
     def loss_fn(self, pred, label):
         mask = ~torch.isnan(label)
 
-        if self.loss == 'mse':
+        if self.loss == "mse":
             return self.mse(pred[mask], label[mask])
 
-        raise ValueError('unknown loss `%s`'%self.loss)
+        raise ValueError("unknown loss `%s`" % self.loss)
 
     def metric_fn(self, pred, label):
 
         mask = torch.isfinite(label)
-        if self.metric == 'IC':
+        if self.metric == "IC":
             return self.cal_ic(pred[mask], label[mask])
 
-        if self.metric == '' or self.metric == 'loss': # use loss
+        if self.metric == "" or self.metric == "loss":  # use loss
             return -self.loss_fn(pred[mask], label[mask])
 
-        raise ValueError('unknown metric `%s`'%self.metric)
+        raise ValueError("unknown metric `%s`" % self.metric)
 
     def cal_ic(self, pred, label):
-        return torch.mean(pred * label) 
+        return torch.mean(pred * label)
 
     def train_epoch(self, x_train, y_train):
 
         x_train_values = x_train.values
-        y_train_values = np.squeeze(y_train.values)*100
+        y_train_values = np.squeeze(y_train.values) * 100
 
         self.gru_model.train()
 
         indices = np.arange(len(x_train_values))
         np.random.shuffle(indices)
 
-        for i in range(len(indices))[::self.batch_size]:
+        for i in range(len(indices))[:: self.batch_size]:
 
             if len(indices) - i < self.batch_size:
                 break
 
-            feature = torch.from_numpy(x_train_values[indices[i:i+self.batch_size]]).float()
-            label = torch.from_numpy(y_train_values[indices[i:i+self.batch_size]]).float()
+            feature = torch.from_numpy(x_train_values[indices[i : i + self.batch_size]]).float()
+            label = torch.from_numpy(y_train_values[indices[i : i + self.batch_size]]).float()
 
             if self.use_gpu:
                 feature = feature.cuda()
@@ -186,10 +186,9 @@ class GRU(Model):
 
             self.train_optimizer.zero_grad()
             loss.backward()
-            torch.nn.utils.clip_grad_value_(self.gru_model.parameters(), 3.)
+            torch.nn.utils.clip_grad_value_(self.gru_model.parameters(), 3.0)
             self.train_optimizer.step()
 
-
     def test_epoch(self, data_x, data_y):
 
         # prepare training data
@@ -204,13 +203,13 @@ class GRU(Model):
         indices = np.arange(len(x_values))
         np.random.shuffle(indices)
 
-        for i in range(len(indices))[::self.batch_size]:
+        for i in range(len(indices))[:: self.batch_size]:
 
             if len(indices) - i < self.batch_size:
                 break
 
-            feature = torch.from_numpy(x_values[indices[i:i+self.batch_size]]).float()
-            label = torch.from_numpy(y_values[indices[i:i+self.batch_size]]).float()
+            feature = torch.from_numpy(x_values[indices[i : i + self.batch_size]]).float()
+            label = torch.from_numpy(y_values[indices[i : i + self.batch_size]]).float()
 
             if self.use_gpu:
                 feature = feature.cuda()
@@ -255,13 +254,13 @@ class GRU(Model):
         # return
 
         for step in range(self.n_epochs):
-            self.logger.info('Epoch%d:', step)
-            self.logger.info('training...')
+            self.logger.info("Epoch%d:", step)
+            self.logger.info("training...")
             self.train_epoch(x_train, y_train)
-            self.logger.info('evaluating...')
+            self.logger.info("evaluating...")
             train_loss, train_score = self.test_epoch(x_train, y_train)
             val_loss, val_score = self.test_epoch(x_valid, y_valid)
-            self.logger.info('train %.6f, valid %.6f'%(train_score, val_score))
+            self.logger.info("train %.6f, valid %.6f" % (train_score, val_score))
             evals_result["train"].append(train_score)
             evals_result["valid"].append(val_score)
 
@@ -273,17 +272,16 @@ class GRU(Model):
             else:
                 stop_steps += 1
                 if stop_steps >= self.early_stop:
-                    self.logger.info('early stop')
+                    self.logger.info("early stop")
                     break
 
-        self.logger.info('best score: %.6lf @ %d'%(best_score, best_epoch))
+        self.logger.info("best score: %.6lf @ %d" % (best_score, best_epoch))
         self.gru_model.load_state_dict(best_param)
         torch.save(best_param, save_path)
-        
+
         if self.use_gpu:
             torch.cuda.empty_cache()
 
-
     def predict(self, dataset):
         if not self._fitted:
             raise ValueError("model is not fitted yet!")
@@ -295,16 +293,15 @@ class GRU(Model):
         sample_num = x_values.shape[0]
         preds = []
 
-        for begin in range(sample_num)[::self.batch_size]:
+        for begin in range(sample_num)[:: self.batch_size]:
 
-            if sample_num-begin < self.batch_size:
+            if sample_num - begin < self.batch_size:
                 end = sample_num
             else:
-                end = begin+self.batch_size
+                end = begin + self.batch_size
 
             x_batch = torch.from_numpy(x_values[begin:end]).float()
 
-
             if self.use_gpu:
                 x_batch = x_batch.cuda()