经济数据预测 | Python实现机器学习(MLP、XGBoost)金融市场预测

  * 学习总结
  * 参考资料

    def create_ae_mlp(num_columns, 
                  num_labels, 
                  hidden_units, 
                  dropout_rates, 
                  ls = 1e-2, 
                  lr = 1e-3):
    # 定义输入
    inp = tf.keras.layers.Input(shape = (num_columns, ))
    x0 = tf.keras.layers.BatchNormalization()(inp)
    # 高斯加噪
    noise_x0 = tf.keras.layers.GaussianNoise(dropout_rates[0])(x0)
    # 编码器
    encoder = tf.keras.layers.Dense(hidden_units[0])(encoder)
    encoder = tf.keras.layers.BatchNormalization()(encoder)
    encoder = tf.keras.layers.Activation('swish')(encoder)
    # 解码器
    decoder = tf.keras.layers.Dropout(dropout_rates[1])(encoder)
    decoder = tf.keras.layers.Dense(num_columns, name = 'decoder')(decoder)
    # Classification Layer
    x_ae = tf.keras.layers.Dense(hidden_units[1])(decoder)
    x_ae = tf.keras.layers.BatchNormalization()(x_ae)
    x_ae = tf.keras.layers.Activation('swish')(x_ae)
    x_ae = tf.keras.layers.Dropout(dropout_rates[2])(x_ae)
    # Autoencoder的分类器
    out_ae = tf.keras.layers.Dense(num_labels,
                                   activation='sigmoid', 
                                   name = 'ae_action')(x_ae)
    # 拼接原始输入和编码器输入
    x = tf.keras.layers.Concatenate()([x0, encoder])
    # MLP的网络层
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.Dropout(dropout_rates[3])(x)
    for i in range(2, len(hidden_units)):
        x = tf.keras.layers.Dense(hidden_units[i])(x)
        x = tf.keras.layers.BatchNormalization()(x)
        x = tf.keras.layers.Activation('swish')(x)
        x = tf.keras.layers.Dropout(dropout_rates[i + 2])(x)
    # MLP的分类器
    out = tf.keras.layers.Dense(num_labels, activation = 'sigmoid', name = 'action')(x)
    # 定义输入输出
    model = tf.keras.models.Model(inputs = inp, outputs = [decoder, out_ae, out])
    # 定义优化器，损失函数和Metrics
    model.compile(optimizer = tf.keras.optimizers.Adam(learning_rate = lr),
                  loss = {'decoder': tf.keras.losses.MeanSquaredError(), 
                          'ae_action': tf.keras.losses.BinaryCrossentropy(label_smoothing = ls),
                          'action': tf.keras.losses.BinaryCrossentropy(label_smoothing = ls), 
                         },
                  metrics = {'decoder': tf.keras.metrics.MeanAbsoluteError(name = 'MAE'), 
                             'ae_action': tf.keras.metrics.AUC(name = 'AUC'), 
                             'action': tf.keras.metrics.AUC(name = 'AUC'), 
                            }, 
                 )
    
    return model

    import numpy as np
    from sklearn.model_selection import KFold
    from sklearn.model_selection._split import _BaseKFold, indexable, _num_samples
    from sklearn.utils.validation import _deprecate_positional_args
    
    
    # modified code for group gaps; source
    # https://github.com/getgaurav2/scikit-learn/blob/d4a3af5cc9da3a76f0266932644b884c99724c57/sklearn/model_selection/_split.py#L2243
    class PurgedGroupTimeSeriesSplit(_BaseKFold):
    """
    Parameters
    ----------
    n_splits : int, default=5
        Number of splits. Must be at least 2.
    max_train_group_size : int, default=Inf
        Maximum group size for a single training set.
    group_gap : int, default=None
        Gap between train and test
    max_test_group_size : int, default=Inf
        We discard this number of groups from the end of each train split
    """
    
    @_deprecate_positional_args
    def __init__(self,
                 n_splits=5,
                 *,
                 max_train_group_size=np.inf,
                 max_test_group_size=np.inf,
                 group_gap=None,
                 verbose=False
                 ):
        super().__init__(n_splits, shuffle=False, random_state=None)
        self.max_train_group_size = max_train_group_size
        self.group_gap = group_gap
        self.max_test_group_size = max_test_group_size
        self.verbose = verbose
    
    def split(self, X, y=None, groups=None):
        """Generate indices to split data into training and test set.
        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            Training data, where n_samples is the number of samples
            and n_features is the number of features.
        y : array-like of shape (n_samples,)
            Always ignored, exists for compatibility.
        groups : array-like of shape (n_samples,)
            Group labels for the samples used while splitting the dataset into
            train/test set.
        Yields
        ------
        train : ndarray
            The training set indices for that split.
        test : ndarray
            The testing set indices for that split.
        """
        if groups is None:
            raise ValueError(
                "The 'groups' parameter should not be None")
        X, y, groups = indexable(X, y, groups)
        n_samples = _num_samples(X)
        n_splits = self.n_splits
        group_gap = self.group_gap
        max_test_group_size = self.max_test_group_size
        max_train_group_size = self.max_train_group_size
        n_folds = n_splits + 1
        group_dict = {}
        u, ind = np.unique(groups, return_index=True)
        unique_groups = u[np.argsort(ind)]
        n_samples = _num_samples(X)
        n_groups = _num_samples(unique_groups)
        for idx in np.arange(n_samples):
            if (groups[idx] in group_dict):
                group_dict[groups[idx]].append(idx)
            else:
                group_dict[groups[idx]] = [idx]
        if n_folds > n_groups:
            raise ValueError(
                ("Cannot have number of folds={0} greater than"
                 " the number of groups={1}").format(n_folds,
                                                     n_groups))
    
        group_test_size = min(n_groups // n_folds, max_test_group_size)
        group_test_starts = range(n_groups - n_splits * group_test_size,
                                  n_groups, group_test_size)
        for group_test_start in group_test_starts:
            train_array = []
            test_array = []
    
            group_st = max(0, group_test_start - group_gap - max_train_group_size)
            for train_group_idx in unique_groups[group_st:(group_test_start - group_gap)]:
                train_array_tmp = group_dict[train_group_idx]
    
                train_array = np.sort(np.unique(
                    np.concatenate((train_array,
                                    train_array_tmp)),
                    axis=None), axis=None)
    
            train_end = train_array.size
    
            for test_group_idx in unique_groups[group_test_start:
            group_test_start +
            group_test_size]:
                test_array_tmp = group_dict[test_group_idx]
                test_array = np.sort(np.unique(
                    np.concatenate((test_array,
                                    test_array_tmp)),
                    axis=None), axis=None)
    
            test_array = test_array[group_gap:]
    
            if self.verbose > 0:
                pass
    
            yield [int(i) for i in train_array], [int(i) for i in test_array]

    X = train.loc[:, train.columns.str.contains('feature')].values
    y = train.loc[:, 'action'].astype('int').values
    
    X_ = X
    y_ = train.loc[:, 'action3'].astype('int').values
    
    clf1 = xgb.XGBClassifier(
    n_estimators=100,
    max_depth=11,
    learning_rate=0.05,
    subsample=0.90,
    colsample_bytree=0.7,
    missing=-999,
    random_state=21,
    tree_method='gpu_hist',  # THE MAGICAL PARAMETER
    reg_alpha=10,
    reg_lambda=10,
    )
    
    clf1.fit(X_, y_)
    
    clf2 = xgb.XGBClassifier(
    n_estimators=100,
    max_depth=11,
    learning_rate=0.05,
    subsample=0.90,
    colsample_bytree=0.7,
    missing=-999,
    random_state=210,
    tree_method='gpu_hist',  # THE MAGICAL PARAMETER
    reg_alpha=10,
    reg_lambda=10,
    )
    
    
    clf2.fit(X_, y_)
    
    clf3 = xgb.XGBClassifier(
    n_estimators=100,
    max_depth=11,
    learning_rate=0.05,
    subsample=0.90,
    colsample_bytree=0.7,
    missing=-999,
    random_state=2010,
    tree_method='gpu_hist',  # THE MAGICAL PARAMETER
    reg_alpha=10,
    reg_lambda=10,
    )
    
    clf3.fit(X_, y_)