如何对动态数据框执行 OLS 回归并估计斜率系数？

Question

我有一个像下面这样的数据框，它的结构不是固定的，它可以在不同的时刻有不同的列数。

    A_Name  B_Info  Value_Yn  Value_Yn-1   Value_Yn-2   ......  Value_Y1
0   AA      X1        0.9       0.8           0.7       ......   0.1   
1   BB      Y1        0.1       0.2           0.3       ......   0.9
2   CC      Z1        -0.9       -0.8         -0.7      ......   -0.1
3   DD      L1        -0.1       -0.2         -0.3      ......   -0.9

我想对 X 和 Y 值分别为的每一行执行线性回归

X = [n, n-1, n-2, .....2, 1]

Y = [Value_Yn, Value_Yn-1, Value_Yn-2.......Value_Y2, Value_Y1]

这里的 'n' 是以 'Value_' 为前缀的列数

假设 n = 9

我的价值是

对于第 0 行

X = [9, 8, 7, 6, 5, 4, 3, 2, 1]
Y = [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1]

对于第 1 行

X = [9, 8, 7, 6, 5, 4, 3, 2, 1]
Y = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

其他行也一样...

我想要以这种格式输出...

    A_Name  B_Info  Intercept  Slope_Coefficent
0   AA      X1        0         0.1  
1   BB      Y1        1         -0.1
2   CC      Z1        0         -0.1        
3   DD      L1        -1        0.1

数据集很大，通过循环来做不是正确的方法......

Answer 1

这个问题可以用 numpy 和线性代数来解决。基本思想是，由于您一遍又一遍地重用相同的 x 值，我们可以重用中间计算。

推导。

线性回归通常这样解决：

1. 给定一个数据集 (x_1, y_1) ... (x_n, y_n)，我们求解最小二乘 A x = b 形式的问题。
2. A 是一个 n x 2 矩阵，其中 x 值为一列，第二列为一，向量 b 包含 y 值，x 具有斜率和截距。
3. 我们将两边乘以 A 转置，得到 A^T A x= A^T b，这是一个可求解斜率和截距的二维系统。

假设您的数据框有 k 行。您正在尝试对相同的 x 值但不同的 y 值进行 k 次最小二乘。这转化为使用相同的 A 和不同的 b 解决底层最小二乘问题 k 次。

我们可以通过两种方式利用它。第一种是只计算 A^T A 一次。第二个，也是大部分加速的结果，是同时使用矩阵乘法一次解决所有 k 个最小二乘问题。这个想法是将所有 k b 作为矩阵 B 的列插入。然后，将右侧的小 b 替换为大 B，并执行所有相同的矩阵乘法。您最终会得到一个矩阵 X，其列与 B 的列相对应。

请注意，B 是列为 Y_1、Y_2、... Y_n 的矩阵的转置。所以这是你的数据帧的转置。

换句话说，X = (A^T A)^(-1) A^T B，其中 B 是数据帧的转置。如果数学不清楚，这是我的代码（使用虚拟数据）。如果有什么不起作用，请告诉我。

import numpy as np
import numpy.linalg as la

n = 3
k= 10
#replace this with your data matrix whose columns are the Y's
yvals = np.arange(k*n).reshape(k,n)
xvals = np.arange(1,n+1)
print "X values:", xvals
print "Y Values:"
print yvals

A = np.zeros((n,2))
A[:,0] = xvals
A[:,1] = 1

Q = A.T.dot(A)
#slopes are the first column, intercepts are the second
res =  la.inv(Q).dot(A.T.dot(yvals.T)).T
print res

输出：

X values: [1 2 3]
Y Values:
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]
 [15 16 17]
 [18 19 20]
 [21 22 23]
 [24 25 26]
 [27 28 29]]
Result:
[[  1.  -1.]
 [  1.   2.]
 [  1.   5.]
 [  1.   8.]
 [  1.  11.]
 [  1.  14.]
 [  1.  17.]
 [  1.  20.]
 [  1.  23.]
 [  1.  26.]]

由于矩阵乘法的向量化和渐近加速，这应该相当快。