第二周：python实现线性回归（哑变量回归）的高效方法

我怎么觉得自己就像小学生在写青创日记……

知道了pickle是啥。pickle提供了一个简单的持久化功能。可以将对象以文件的形式存放在磁盘上。

获得了一些pickle文件，需要找出最快的回归的方法。

有一个很厉害的人叫Tirthajyoti Sarkar，写了一篇笔记，比较了八种常用的方法：

https://www.freecodecamp.org/news/data-science-with-python-8-ways-to-do-linear-regression-and-measure-their-speed-b5577d75f8b/

他的github上有代码，我就跑了一遍试试。

结果也正如文中所写，发现对于多元线性回归，最快的方法就是

result = np.linalg.lstsq(A, y)

原理应当跟求广义逆矩阵（MoorePenrose_inverse）是一样的，详情见官方文档：https://numpy.org/doc/stable/reference/generated/numpy.linalg.lstsq.html

这个result返回的是个四元变量。所以也可以写成

x, residuals, rank, s = np.linalg.lstsq(A, y)

x就是系数矩阵，residuals就要注意了，它是残差之和！！所以只有一行。哎orz。如果要获得每个残差，就简单计算一下，反正numpy算矩阵乘法快得很。

代码是这样的：

import pickle
import pandas as pd
import numpy as np
import time
from scipy import linspace, polyval, polyfit, sqrt, stats, randn, optimize
import statsmodels.api as sm

file1 = open('D:\实习\哑变量回归数据\LF001.pkl','rb') #factor
#数据从20190121开始有效(第2690列)
file2 = open('D:\实习\哑变量回归数据\sector.pkl','rb') #需要转置，列名为股票代码，行名为日期
temp= pickle.load(file1)
sector = pd.DataFrame(pickle.load(file2))
sector = sector.iloc[:, 2690:]
factor = pd.DataFrame(temp.values.T, index=temp.columns, columns=temp.index)
factor = factor.iloc[:, 2690:]
sector.insert(sector.shape[1], 'temp', 1) #在右面新加一列为1
yx = pd.concat([factor, sector], axis=1, sort=False)  # 列合并
d_yx = yx.dropna()  # 删掉有na的行
# 从323列再切成两个表
# n_yx = d_yx.values
factor = d_yx.iloc[:, :322]
sector = d_yx.iloc[:, 323:]
df_dummies = pd.get_dummies(sector[20190121])
sector = df_dummies
A = sector.values
y = factor.values
start = time.time()
for i in range(0, 500):
    result = np.linalg.lstsq(A, y)
    # x, residuals, rank, s = np.linalg.lstsq(A, y)
    residuals = y - A.dot(result[0])
end = time.time()
print(end-start)

前面数据处理比较周折。因为要用dropna丢掉nan值的数据，所以我是比较蠢的先把两个表合成一个表，然后dropna完了再拆成两个表。

pd.get_dummies特别好使，直接就就把行业转成哑变量了。因为每一列日期都是一样的，所以我就选了第一天的（sector[20190121]）

有一个小技巧就是.values可以把dataframe转成一个ndarray对象，然后就可以放进lstsq这个函数里用了！

残差手算一下，用实际值-拟合值：

residuals = y - A.dot(result[0])

最后学到了一个方法。为了确定这个方法的效率，可以打开任务管理器，看性能

 

 然后把程序循环个几百次，看执行的时候八个线程是不是都是满的。结果确实是，说明这个本身就是并行处理，效率很高。