Python金融大数据分析练习题（基础+股票预测）

一、使用numpy/pandas编程实现以下题目
0.首先引入所需要的包

import numpy as np
import pandas as pd

1.创建一个长度为8的一维全为0的ndarray对象，然后让第5个元素等于1

nd1 = np.zeros(8)
nd1[4] = 1
nd1

2.创建一个元素为从20到59的ndarray对象

np.arange(20,60)

3.使用np.random.random创建一个10*10的ndarray对象，并打印出最大最小元素

nd3 = np.random.rand(10,10)
print(nd3)
print("最大值为："+str(np.max(nd3)))
print("最小值为："+str(np.min(nd3)))

4.创建一个10*10的ndarray对象，且矩阵边界全为1，里面全为0

nd4 = np.zeros(shape=(10,10))
nd4[[0,9]] = 1
nd4[:,[0,9]] = 1
nd4

5.给定一个4维矩阵，并计算得到最后两维的和

nd5 = np.random.randint(0,5,size=(2,3,4,5))
nd5
nd5.sum(axis=(-1,-2))

6.创建一个64随机矩阵和一个43随机矩阵，求两个矩阵的积

nd6_1 = np.random.rand(6,4)
print(nd6_1)
print("************************************************")
nd6_2 = np.random.rand(4,3)
print(nd6_2)
print("************************************************")
nd6_sum = np.matmul(nd6_1,nd6_2)
print("两个矩阵的乘积为：\n"+str(nd6_sum))

7.创建一个5*5的随机矩阵，并让矩阵的每一行的元素都减去该行的平均值

nd7 = np.random.rand(5,5)
print(nd7)
nd7 - nd7.mean(axis=1).reshape(5,1)

8.随机创建一个15*5的矩阵，并将其进行正则化

#【注：正则的概念：假设a是矩阵中的一个元素，max/min分别是矩阵元素的最大最小值，则正则化后a = (a - min)/(max - min)】
nd8 = np.random.randint(0,5,size=(15,5))
print(nd8)
nd8_min = nd8.min()
nd8_max = nd8.max()
nd8_down = nd8_max - nd8_min
result8 = (nd8-nd8_min)/nd8_down
print(result8)

9.DataFrame数据创建
(1) 从NumPy数组创建DataFrame，命名为df1（注：使用numpy生成20个0-100随机数）
(2) 从NumPy数组创建DataFrame，命名为df2（注：使用numpy生成20个0-100固定步长的数）
(3) 从NumPy数组创建DataFrame，命名为df3（使用numpy生成20个指定分布（如标准正态分布）的数）
(4) 将df1、df2、df3按照行合并为新DataFrame，命名为df
(5) 将df1、df2、df3按照列合并为新DataFrame, 命名为df

#(1)从NumPy数组创建DataFrame，命名为df1（注：使用numpy生成20个0-100随机数）
tem1 = np.random.randint(1,100,20)
df1 = pd.DataFrame(tem1)
df1

#(2)从NumPy数组创建DataFrame，命名为df2（注：使用numpy生成20个0-100固定步长的数）
tem2 = np.arange(0,100,5)
df2 = pd.DataFrame(tem2)
df2

#(3)从NumPy数组创建DataFrame，命名为df3（使用numpy生成20个指定分布（如标准正态分布）的数）
tem3 = np.random.normal(0,1,20)
df3 = pd.DataFrame(tem3)
df3

#(4)将df1、df2、df3按照行合并为新DataFrame，命名为df
df = pd.concat([df1,df2,df3],axis=0,ignore_index=True)
df

#(5)将df1、df2、df3按照列合并为新DataFrame, 命名为df
df = pd.concat([df1,df2,df3],axis=1,ignore_index=True)
df

10.数据查看

#(1)查看上述合成的df所有数据的最小值、25%分位数、中位数、75%分位数、最大值
print("最小值、25%分位数、中位数、75%分位数、最大值分别为:"+str(np.percentile(df,q=[0,25,50,75,100])))

11.数据修改

#(1)修改df的列名为col1，col2，col3
df.columns = ['col1','col2','col3']
df

12.数据提取
(1) 提取第一列中不在第二列出现的数字
(2) 提取第一列和第二列出现频率最高的三个数字
(3) 提取第一列中可以整除5的数字位置
(4) 提取第一列位置在1,10,15的数字

#(1)提取第一列中不在第二列出现的数字
df['col1'][~df['col1'].isin(df['col2'])]

#(2)提取第一列和第二列出现频率最高的三个数字
tem12_2 = df['col1'].append(df['col2'])
tem12_2.value_counts().index[:3]

#(3)提取第一列中可以整除5的数字位置
tem3 = np.where(df['col1'] % 5==0) #不能直接用argwhere
print(tem3)

#(4)提取第一列位置在1,10,15的数字
df['col1'].take([1,10,15])

13.数据计算
(1) 计算第一列数字前一个与后一个的差值
(2) 按行计算df的每一行均值
(3) 对第二列计算移动平均值（每次移动三个位置，不可以使用自定义函数）

#(1)计算第一列数字前一个与后一个的差值
df['col1'].diff().tolist()

#(2)按行计算df的每一行均值
df[['col1','col2','col3']].mean(axis=1)

#(3)对第二列计算移动平均值（每次移动三个位置，不可以使用自定义函数）
np.convolve(df['col2'], np.ones(3)/3, mode='valid')

14.数据查找

#(1)查找第一列的局部最大值位置（即比它前一个与后一个数字的都大的数字）
nd14 = np.diff(np.sign(np.diff(df['col1'])))
np.where(nd14 == -2)[0] + 1

二、股票次日收盘价预测分析（利用tushare模块获取数据）
(1) 数据获取（股票任选)
→ data = tushare.get_k_data(stock_code, start=‘2020-03-01’, end=‘2020-04-30’).reset_index(drop = True)
(2) 使用不同的回归分析模型，基于股票当天的开盘价（open）、最高价（high）、最低价（low）和成交量（volume）来预测该股票次日的收盘价。
→ 线性回归、岭回归、Lasso回归、树回归、多层感知机回归
(3) 使用不同评价指标，对比分析不同模型在股票预测时性能（注意用语言描述不同结果的对比分析）
→ MSE、MAE、RMSE、R2
(4) 绘制拟合曲线结果

#(1)数据获取：股票任选
#import pandas as pd
#from pandas import DataFrame,Series
import tushare
stock_code="600519" #贵州茅台
data = tushare.get_k_data(stock_code, start='2020-03-01', end='2020-04-30').reset_index(drop = True)
print(data.head())
#data

#(2)使用不同的回归分析模型，基于股票当天的开盘价（open）、最高价（high）、最低价（low）和成交量（volume）来预测该股票次日的收盘价。
import matplotlib.pyplot as plt
import datetime
import math
#前期工作——数据读取
from sklearn.model_selection import train_test_split
list=['open','high','low','volume']
Feature=data[list].values
Target=np.array(data['close'])
#将数据划分为训练集和测试集
trainingFeature,testFeature,trainingTarget,testTarget = train_test_split(Feature,Target,test_size=0.2,random_state=11) 

#①线性回归——LinearRegression回归
#<1>建模
from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(trainingFeature,trainingTarget)
print("系数矩阵: \n",model.coef_)
print("模型截距: \n",model.intercept_)
print("回归模型: \n",model)
#<2>使用模型预测
predictedTarget_1 = model.predict(testFeature)
#<3>测试集画图+画拟合曲线
plt.plot(testTarget, label='test')
plt.plot(predictedTarget_1,label='pred')
plt.legend()
plt.show() 
#<4>模型的评估:MSE+MAE+RMSE+R方
from sklearn.metrics import mean_squared_error,mean_absolute_error
#计算并输出均方误差（Mean Squared Error,MSE)
print("均方误差(MSE)：%0.4f" % mean_squared_error(predictedTarget_1,testTarget))
#计算并且输出平均绝对误差（Mean Absolute Error,MAE)
print("平均绝对误差(MAE)：%0.4f" % mean_absolute_error(predictedTarget_1,testTarget))
#计算并输出均方根误差(Root Mean Squared Error,RMSE)
sum_mean = 0
for i in range(len(predictedTarget_1)):
    sum_mean += (predictedTarget_1[i] - testTarget[i]) ** 2
sum_erro = np.sqrt(sum_mean/len(predictedTarget_1))
print("均方根误差(RMSE)：%0.4f" % sum_erro)
#计算并输出绝对系数(R方)即预测精度，越接近1说明越好
print("决定系数（R2）:%0.4f" % model.score(testFeature,testTarget))

#②岭回归——Ridge回归
#<1>建模
from sklearn.linear_model import Ridge
model = Ridge()
model.fit(trainingFeature,trainingTarget)
print("系数矩阵: \n",model.coef_)
print("模型截距: \n",model.intercept_)
print("回归模型: \n",model)
#<2>使用模型预测
predictedTarget_2 = model.predict(testFeature,)
#<3>测试集画图+拟合曲线
plt.plot(testTarget, label='test')
plt.plot(predictedTarget_2,label='pred')
plt.legend()
plt.show()
#<4>模型评估:MSE+MAE+RMSE+R方
from sklearn.metrics import mean_squared_error,mean_absolute_error
#计算并输出均方误差（Mean Squared Error,MSE)
print("均方误差(MSE)：%0.4f" % mean_squared_error(predictedTarget_2,testTarget))
#计算并且输出平均绝对误差（Mean Absolute Error,MAE)
print("平均绝对误差(MAE)：%0.4f" % mean_absolute_error(predictedTarget_2,testTarget))
#计算并输出均方根误差(Root Mean Squared Error,RMSE)
sum_mean = 0
for i in range(len(predictedTarget_2)):
    sum_mean += (predictedTarget_2[i] - testTarget[i]) ** 2
sum_erro = np.sqrt(sum_mean/len(predictedTarget_2))
print("均方根误差(RMSE)：%0.4f" % sum_erro)
#计算并输出绝对系数R方即预测精度，越接近1说明越好
print("决定系数（R2）:%0.4f" % model.score(testFeature,testTarget))

#③Lasso回归
#<1>建模
from sklearn.linear_model import Lasso
model = Lasso(alpha=0.01) #调节alpha可以实现对拟合的程度
model.fit(trainingFeature,trainingTarget) #回归建模
print("系数矩阵: \n",model.coef_)
print("模型截距: \n",model.intercept_)
print("回归模型: \n",model)
#<2>使用模型预测
predictedTarget_3 = model.predict(testFeature)
#<3>测试集画图+拟合曲线
plt.plot(testTarget, label='test')
plt.plot(predictedTarget_3,label='pred')
plt.legend()
plt.show()
#<4>模型评估:MSE+MAE+RMSE+R方
from sklearn.metrics import mean_squared_error,mean_absolute_error
#计算并输出均方误差（Mean Squared Error,MSE)
print("均方误差(MSE)：%0.4f" % mean_squared_error(predictedTarget_3,testTarget))
#计算并且输出平均绝对误差（Mean Absolute Error,MAE)
print("平均绝对误差(MAE)：%0.4f" % mean_absolute_error(predictedTarget_3,testTarget))
#计算并输出均方根误差(Root Mean Squared Error,RMSE)
sum_mean = 0
for i in range(len(predictedTarget_3)):
    sum_mean +=( predictedTarget_3[i] - testTarget[i] )** 2
sum_erro = np.sqrt(sum_mean/len(predictedTarget_3))
print("均方根误差(RMSE)：%0.4f" % sum_erro)
#计算并输出绝对系数R方即预测精度，越接近1说明越好
print("决定系数（R2）:%0.4f" % model.score(testFeature,testTarget))

#④树回归
#<1>建模
from sklearn.tree import DecisionTreeRegressor
model = DecisionTreeRegressor()
model.fit(trainingFeature,trainingTarget)
print("回归模型: \n",model)
#<2>使用模型预测
predictedTarget_4 = model.predict(testFeature)
#<3>测试集画图+拟合曲线
plt.plot(testTarget, label='test')
plt.plot(predictedTarget_4,label='pred')
plt.legend()
plt.show()
#<4>模型评估:MSE+MAE+RMSE+R方
from sklearn.metrics import mean_squared_error,mean_absolute_error
#计算并输出均方误差（Mean Squared Error,MSE)
print("均方误差(MSE)：%0.4f" % mean_squared_error(predictedTarget_4,testTarget))
#计算并且输出平均绝对误差（Mean Absolute Error,MAE)
print("平均绝对误差(MAE)：%0.4f" % mean_absolute_error(predictedTarget_4,testTarget))
#计算并输出均方根误差(Root Mean Squared Error,RMSE)
sum_mean = 0
for i in range(len(predictedTarget_4)):
    sum_mean += (predictedTarget_4[i] - testTarget[i]) ** 2    
sum_erro = np.sqrt(sum_mean/len(predictedTarget_4))
print("均方根误差(RMSE)：%0.4f" % sum_erro)
#计算并输出绝对系数R方即预测精度，越接近1说明越好
print("决定系数（R2）:%0.4f" % model.score(testFeature,testTarget))

#⑤多层感知机回归
#<1>建模
from sklearn.neural_network import MLPRegressor
model =MLPRegressor(solver="adam",alpha=1e-5,hidden_layer_sizes=(5,2),random_state=1)
model.fit(trainingFeature,trainingTarget)
print("回归模型: \n",model)
layer_index = 0
for wi in model.coefs_:
    layer_index += 1 #表示第几层神经网络  
    print("第%d层网络层：" % layer_index)
    print("权重矩阵维度：",wi.shape)
    print("系数矩阵： \n",wi)
#<2>使用模型预测
predictedTarget_5 = model.predict(testFeature)
#<3>测试集画图+拟合曲线
plt.plot(testTarget, label='test')
plt.plot(predictedTarget_5,label='pred')
plt.legend()
plt.show()
#<4>模型评估:MSE+MAE+RMSE+R方
from sklearn.metrics import mean_squared_error,mean_absolute_error
#计算并输出均方误差（Mean Squared Error,MSE)
print("均方误差(MSE)：%0.4f" % mean_squared_error(predictedTarget_5,testTarget))
#计算并且输出平均绝对误差（Mean Absolute Error,MAE)
print("平均绝对误差(MAE)：%0.4f" % mean_absolute_error(predictedTarget_5,testTarget))
#计算并输出均方根误差(Root Mean Squared Error,RMSE)
sum_mean = 0
for i in range(len(predictedTarget_5)):
    sum_mean += (predictedTarget_5[i] - testTarget[i]) ** 2    
sum_erro = np.sqrt(sum_mean/len(predictedTarget_5))
print("均方根误差(RMSE)：%0.4f" % sum_erro)
#计算并输出绝对系数R方即预测精度，越接近1说明越好
print("决定系数（R2）:%0.4f" % model.score(testFeature,testTarget))
#不同模型预测结果的对比分析
from prettytable import PrettyTable #用表格的方式呈现结果
x = PrettyTable(["模型名称", "均方误差MSE", "平均绝对误差MAE", "均方根误差RMSE","预测精度R2"])
#print(x)
x.add_row(["线性回归",34.9664, 4.6853, 5.9132, 0.9890])
x.add_row(["岭回归",34.9796, 4.6862, 5.9144, 0.9890])
x.add_row(["Lasso回归", 34.9676, 4.6851, 5.9133, 0.9890])
x.add_row(["树回归",379.9384, 14.0033, 19.4920, 0.8808])
x.add_row(["多层感知机回归", 3302243.7340, 1339.7096, 1817.2077, -1035.1232])
print(x)
print("可以看到MSE最小的是线性回归模型，\nMAE最小的是Lasso回归(和线性回归没差多少)，\nRMSE最小的是线性回归，\n预测精度R2中线性回归、岭回归和Lasso回归相同且是最大的,\n所以总的来说，线性回归的预测效果是最好的。")