[新手]从Linear到LSTM，5种方法由浅入深预测股价

import numpy as np

from sklearn.linear_model import LinearRegression

def get_preds_lin_reg(df, target_col, N, pred_min, offset):
    """
    Given a dataframe,get prediction at each timestep
    :param df: dataframe with the values you want to predict
    :param target_col: name of the column you want to predict
    :param N: use previous N values to do prediction
    :param pred_min: all predictions should be >= pred_min
    :param offset: for df we only do predictions for df[offset:]
    :return: pred_list: the predictions for target_col
    """
    # create linear regression object
    regr = LinearRegression(fit_intercepter=True)

    pred_list = []

    for i in range(offset, len(df['adj_close'])):
        X_train = np.array(range(len(df['adj_close'][i-N:i])))
        y_train = np.array(df['adj_close'][i-N:i])
        X_train = X_train.reshape(-1,1)
        y_train = y_train.reshape(-1,1)

        # train the model
        regr.fit(X_train, y_train)

        pred = regr.predict(N)

    # If the values are < pred_min,set it to be pred_min
    pred_list = np.array(pred_list)
    pred_list[pred_list < pred_min] = pred_min

    return pred_list

import math
import numpy as np

from sklearn.metrics import mean_squared_error
from xgboost import XGBRegressor

def get_mape(y_true, y_pred):
    """
    compute mean absolute percentage error (MAPE)
    :param y_true:
    :param y_pred:
    :return:
    """
    y_true, y_pred = np.array(y_true), np.array(y_pred)
    return np.mean(np.abs((y_true- y_pred) / y_true)) * 100

def train_pred_eval_model(X_train_scaled,
                          y_train_scaled,
                          X_test_scaled,
                          y_test,
                          col_mean,
                          col_std,
                          seed = 100,
                          n_estimators = 100,
                          max_depth = 3,
                          learning_rate = 0.1,
                          min_child_weight=1,
                          subsample = 1,
                          colsample_bytree=1,
                          colsample_bylevel=1,
                          gamma = 0):
    """
    train model,do prediction,scale back to original range and do evaluation
    :param X_train_scaled: features for training,Scaled to mean=0 & var = 1
    :param y_train_scaled: target for training.Scaled to have mean=0 & var=1
    :param X_test_scaled: features for test.Each sample is scaled to mean=0 and var=1
    :param y_test: target for test.Actual values, not scaled.
    :param col_mean: means used to scale each sample of X_test_scaled.
    same length as X_test_scaled and y_test
    :param col_std: standard deviations used to scale each sample of X_test_scaled.
    same length as X_test_scaled and y_test
    :param seed: model seed
    :param n_estimators: number of boosted trees to it
    :param max_depth: maximum tree depth for base learners
    :param learning_rate: boosting learning rate (xgb'eta)
    :param min_child_weight: minimum sum of instance weight needed in a child
    :param subsample: subsample ratio of the training instance
    :param colsample_bytree: subsample ratio of columns when constructing each tree
    :param colsample_bylevel: subsample ratio of columns for each split, in each level
    :param gamma: minimum loss reduction required to make a further partition on a leaf node of the tree
    :return:
    rmse:root mean square error of y_test and est
    mape:mean absolute percentage error of y_test and est
    est:predicted values.Same length as y_test.
    """
    model = XGBoostRegressor(seed=model_seed,
                             n_estimators=n_estimators,
                             max_depth=max_depth,
                             learning_rate=learning_rate,
                             min_child_weight=min_child_weight,
                             subsample=subsample,
                             colsample_bytree=colsample_bytree,
                             colsample_bylevel=colsample_bylevel,
                             gamma=gamma)
    # train the model
    model.fit(X_train_scaled,y_train_scaled)

    # get predicted labels and scale back to original range
    est_scaled = model.predict(X_test_scaled)
    est = est_scaled * col_std +  col_mean

    # calculate RMSE
    rmse = math.sqrt(mean_squared_error(y_test,est))
    mape = get_mape(y_test,est)
    return rmse,mape,est

import math
import numpy as np

from keras.models import Sequential
from keras.layers import Dense,Dropout,LSTM

def train_pred_eval_model(x_train_scaled,
                          y_train_scaled,
                          x_test_scales,
                          y_test,
                          mu_test_list,
                          std_test_list,
                          lstm_units=50,
                          dropout_prob=0.5,
                          optimizer='adam',
                          epochs=1,
                          batch_size=1):
    """
    traim,prediction,scale back to original value,do evaluation
    :param x_train_scaled:
    :param y_train_scaled:
    :param x_test_scales:
    :param y_test:
    :param mu_test_list:list of means.Same length as y_test
    :param std_test_list:list of std devs.Same length as y_test
    :param lstm_units:dimensionality of the output space
    :param dropout_prob:fraction of the units to drop
    :param optimizer:optimizer for model.compile()
    :param epochs:epochs for model.fit()
    :param batch_size:batch size for model.fit()
    :return:
    rmse: root mean square error
    mape: mean absolute percentage error
    est:predictions
    """

    # create LSTM network
    model = Sequential()
    model.add(LSTM(units=lstm_units,
                   return_sequences=True,
                   input_shape=(x_train_scaled.shape[1],1)))

    # add dropout with a probability
    model.add(Dropout(dropout_prob))

    model.add(LSTM(units=lstm_units))

    # add dropout with a probability
    model.add(Dropout(dropout_prob))

    model.add(Dense(1))

    # compile and fit the LSTM network
    model.compile(loss='mean_squared_error',
                  optimizer=optimizer)
    model.fit(x_train_scaled,y_train_scaled,epochs=epochs,
              batch_size=batch_size,verbose=0)

    # Do prediction
    est_scaled = model.predict(x_test_scaled)
    est = (est_scaled * np.array(std_test_list).reshape(-1,1)) + 
    np.array(mu_test_list).reshape(-1,1)

    # calculate RMSE and MAPE
    rmse = math.sqrt(mean_squared_error(y_test,est))
    mape = get_mape(y_test, est)
    return rmse,mape,est