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值，我们可以重用中间计算。

推导。

线性回归通常像这样解决：

给定数据集（x_1，y_1）...（x_n，y_n），我们求解最小二乘法形式A x = b。
A是一个n x 2矩阵，其中x值为一列，第二列为1，向量b包含y值，x具有斜率和截距。
我们将两边乘以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.]]

由于矢量化和矩阵乘法的渐近加速，这应该非常快。

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

1 个答案:

推导。