Python量化交易04——机器学习的交易策略

 参考书目:深入浅出Python量化交易实战

---

学量化肯定要用的上机器学习这种强大的预测技术。本次使用机器学习构建一些简单的预测进行量化交易，使用Python进行回测。

---

获取数据

1.  
   import pandas as pd
2.  
   import tushare as ts
3.  
   import numpy as np
4.  
    
5.  
   from sklearn.neighbors import KNeighborsClassifier
6.  
   import matplotlib.pyplot as plt
7.  
   import seaborn as sns

 #首先我们来定义一个函数，用来获取数据

1.  
   #传入的三个参数分别是开始日期，结束日期和输出的文件名
2.  
   def load_stock(start_date, end_date, output_file):
3.  
   #首先让程序尝试读取已下载并保存的文件
4.  
   try:
5.  
   df = pd.read_pickle(output_file)
6.  
   #如果文件已存在，则打印载入股票数据文件完毕
7.  
   print('载入股票数据文件完毕')
8.  
   #如果没有找到文件，则重新进行下载
9.  
   except FileNotFoundError:
10.  
    print('文件未找到，重新下载中')
11.  
    #这里制定下载中国平安（601318）的交易数据
12.  
    #下载源为yahoo
13.  
    df = ts.get_k_data('601318', start_date, end_date)
14.  
    df = df.set_index('date')
15.  
    #下载成功后保存为pickle文件
16.  
    df.to_pickle(output_file)
17.  
    #并通知我们下载完成
18.  
    print('下载完成')
19.  
    #最后将下载的数据表进行返回
20.  
    return df

 #下面使用我们定义好的函数来获取中国平安的交易数据
#获取三年的数据，从2017年3月9日至2022年的12月25日
#保存为名为601318的pickle文件

1.  
   zgpa = load_stock(start_date = '2017-03-09',
2.  
   end_date = '2022-12-25',
3.  
   output_file = '601318.pkl')

查看数据前五行

zgpa.head()

 特征构建

 #下面我们来定义一个用于分类的函数，给数据表增加三个字段
#首先是开盘价减收盘价，命名为‘Open-Close’
#其次是最高价减最低价，命名为‘High-Low’

1.  
   def classification_tc(df):
2.  
   df['Open-Close'] = df['open'] - df['close']
3.  
   df['High-Low'] = df['high'] - df['low']
4.  
   #在添加一个target字段，如果次日收盘价高于当日收盘价，则标记为1，反之为0
5.  
   df['target'] = np.where(df['close'].shift(-1)>df['close'], 1, 0)
6.  
   #去掉有空值的行
7.  
   df = df.dropna()
8.  
   #将‘Open-Close’和‘High-Low’作为数据集的特征
9.  
   X = df[['Open-Close', 'High-Low']]
10.  
    #将target赋值给y
11.  
    y = df['target']
12.  
    #将处理好的数据表以及X与y进行返回
13.  
    return(df,X,y)

#下面定义一个用于回归的函数
#特征的添加和分类函数类似
#只不过target字段改为次日收盘价减去当日收盘价

1.  
   #下面定义一个用于回归的函数
2.  
   #特征的添加和分类函数类似
3.  
   #只不过target字段改为次日收盘价减去当日收盘价
4.  
   def regression_tc(df):
5.  
   df['Open-Close'] = df['open'] - df['close']
6.  
   df['High-Low'] = df['high'] - df['low']
7.  
   df['target'] = df['close'].shift(-1) - df['close']
8.  
   df = df.dropna()
9.  
   X = df[['Open-Close', 'High-Low']]
10.  
    y = df['target']
11.  
    #将处理好的数据表以及X与y进行返回
12.  
    return(df,X,y)

#使用classification_tc函数生成数据集的特征与目标

1.  
   from sklearn.model_selection import train_test_split
2.  
   df, X, y = classification_tc(zgpa)
3.  
   #将数据集拆分为训练集与验证集
4.  
   X_train, X_test, y_train, y_test =\
5.  
   train_test_split(X, y, shuffle=False,train_size=0.8)

shuffle=False表示安装顺序进行划分，因为股市具有时间性，只能用前面的数据训练后面的数据。

查看数据：

df.head()

 这就构建 了一个用于分类的数据，target为响应变量，表示明天股票表示涨或者跌。可以用机器学习的模型去预测准确率。

---

机器学习建模

采用十分钟常见的机器学习分类算法进行准确率对比

1.  
   from sklearn.linear_model import LogisticRegression
2.  
   from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
3.  
   from sklearn.neighbors import KNeighborsClassifier
4.  
   from sklearn.tree import DecisionTreeClassifier
5.  
   from sklearn.ensemble import RandomForestClassifier
6.  
   from sklearn.ensemble import GradientBoostingClassifier
7.  
   from xgboost.sklearn import XGBClassifier
8.  
   from sklearn.svm import SVC
9.  
   from sklearn.neural_network import MLPClassifier

1.  
   #逻辑回归
2.  
   model1 = LogisticRegression(C=1e10)
3.  
    
4.  
   #线性判别分析
5.  
   model2 = LinearDiscriminantAnalysis()
6.  
    
7.  
   #K近邻
8.  
   model3 = KNeighborsClassifier(n_neighbors=50)
9.  
    
10.  
    #决策树
11.  
    model4 = DecisionTreeClassifier(random_state=77)
12.  
     
13.  
    #随机森林
14.  
    model5= RandomForestClassifier(n_estimators=1000, max_features='sqrt',random_state=10)
15.  
     
16.  
    #梯度提升
17.  
    model6 = GradientBoostingClassifier(random_state=123)
18.  
     
19.  
    #极端梯度提升
20.  
    model7 = XGBClassifier(eval_metric=['logloss','auc','error'],n_estimators=1000,use_label_encoder=False,
21.  
    colsample_bytree=0.8,learning_rate=0.1,random_state=77)
22.  
     
23.  
    #支持向量机
24.  
    model8 = SVC(kernel="rbf", random_state=77)
25.  
     
26.  
    #神经网络
27.  
    model9 = MLPClassifier(hidden_layer_sizes=(16,8), random_state=77, max_iter=10000)
28.  
     
29.  
    model_list=[model1,model2,model3,model4,model5,model6,model7,model8,model9]
30.  
    model_name=['逻辑回归','线性判别','K近邻','决策树','随机森林','梯度提升','极端梯度提升','支持向量机','神经网络']

训练测试他们

1.  
   for i in range(9):
2.  
   model_C=model_list[i]
3.  
   name=model_name[i]
4.  
   model_C.fit(X_train, y_train)
5.  
   s=model_C.score(X_test, y_test)
6.  
   print(name '方法在验证集的准确率为：' str(s))

 可以看到XGboost 的准确率最高，下面使用XG进行训练和预测。

 #使用XGboost模型预测每日股票的涨跌，保存为‘Predict_Signal’，将0映射为-1，方便很后面的收益计算。

1.  
    
2.  
   model7.fit(X_train, y_train)
3.  
   df['Predict_Signal'] =model7.predict(X)
4.  
   df['Predict_Signal']=df['Predict_Signal'].map({0:-1,1:1})
5.  
   #在数据集中添加一个字段，用当日收盘价除以前一日收盘价，并取其自然对数
6.  
   df['Return'] = np.log(df['close']/df['close'].shift(1))
7.  
   #查看一下
8.  
   df.head()

 #定义一个计算累计回报的函数

1.  
   def cum_return(df, split_value):
2.  
   #该股票基准收益为‘Return’的总和*100
3.  
   cum_return = df[split_value:]['Return'].cumsum()*100
4.  
   #将计算结果进行返回
5.  
   return cum_return

 #再定义一个计算使用策略交易的收益

1.  
   def strategy_return(df, split_value):
2.  
   #使用策略交易的收益为模型‘zgpa_Return’乘以模型预测的涨跌幅
3.  
   df['Strategy_Return'] = df['Return']*df['Predict_Signal'].shift(1)
4.  
   #将每日策略交易的收益加和并乘以100
5.  
   cum_strategy_return = df[split_value:]['Strategy_Return'].cumsum()*100
6.  
   #将计算结果进行返回
7.  
   return cum_strategy_return

 #定义一个绘图函数，用来对比基准收益和算法交易的收益

1.  
   def plot_chart(cum_returns, cum_strategy_return, symbol):
2.  
   #首先是定义画布的尺寸
3.  
   plt.figure(figsize=(9,6))
4.  
   #使用折线图绘制基准收益
5.  
   plt.plot(cum_returns, '--',label='%s Returns'%symbol)
6.  
   #使用折线图绘制算法交易收益
7.  
   plt.plot(cum_strategy_return, label = 'Strategy Returns')
8.  
   #添加图注
9.  
   plt.legend()
10.  
    plt.xticks(np.arange(0,286,36),rotation=20)
11.  
    #显示图像
12.  
    plt.show()

 计算并且画图

1.  
   #首先来计算基准收益（预测集）
2.  
   cum_returns = cum_return(df, split_value=len(X_train))
3.  
   #然后是计算使用算法交易带来的收益（同样只计算预测集）
4.  
   cum_strategy_return = strategy_return(df, split_value=len(X_train))
5.  
   #用图像来进行对比
6.  
   plot_chart(cum_returns, cum_strategy_return, 'zgpa')

 可以看到策略收益还是高不少。

虽然其预测的准确率只有53%，但是作为股市预测，已经让你的胜率从50%上升了3个点已经是很难得了，就可以从随机的买卖变成了一个大概率赚钱的策略。

当然选取更多的特征变量效果说不定会更好。

这篇好文章是转载于：学新通技术网