线性回归算法适用于一个数据集，但不适用于另一个类似的数据集。为什么？

Question

我按照教程创建了一个线性回归算法，并将其应用于所提供的数据集，并且工作正常。但是，相同的算法不适用于另一个类似的数据集。有人能告诉我为什么会这样吗？

def computeCost(X, y, theta):
    inner = np.power(((X * theta.T) - y), 2)
    return np.sum(inner) / (2 * len(X))

def gradientDescent(X, y, theta, alpha, iters):
    temp = np.matrix(np.zeros(theta.shape))
    params = int(theta.ravel().shape[1])
    cost = np.zeros(iters)

    for i in range(iters):
        err = (X * theta.T) - y

        for j in range(params):
            term = np.multiply(err, X[:,j])
            temp[0, j] = theta[0, j] - ((alpha / len(X)) * np.sum(term))

        theta = temp
        cost[i] = computeCost(X, y, theta)

    return theta, cost

alpha = 0.01
iters = 1000

g, cost = gradientDescent(X, y, theta, alpha, iters)  
print(g)

在通过this数据集运行算法时，我得到输出为matrix([[ nan, nan]])并出现以下错误：

C:\Anaconda3\lib\site-packages\ipykernel\__main__.py:2: RuntimeWarning: overflow encountered in power
  from ipykernel import kernelapp as app
C:\Anaconda3\lib\site-packages\ipykernel\__main__.py:11: RuntimeWarning: invalid value encountered in double_scalars

但是，this数据集工作正常并输出matrix([[-3.24140214, 1.1272942 ]])

两个数据集都是相似的，我已经多次使用它，但似乎无法弄清楚为什么它在一个数据集上工作而在其他数据集上不工作。欢迎任何帮助。

编辑：感谢Mark_M提供的编辑提示： - ）

Answer 1

[更好的问题，顺便说一句]

很难确切知道这里发生了什么，但基本上你的成本是错误的方向并且失去控制，当你试图平衡价值时会导致溢出。

我认为在你的情况下，它归结为你的步长（alpha）太大，这可能导致梯度下降走错路。你需要观察梯度下降的成本，并确保它总是下降，如果它不是某个东西被破坏或alpha是大的。

就个人而言，我会重新评估代码并尝试摆脱循环。这是一个偏好问题，但我发现使用X和Y作为列向量更容易。这是一个最小的例子：

from numpy import genfromtxt
# this is your 'bad' data set from github
my_data = genfromtxt('testdata.csv', delimiter=',')

def computeCost(X, y, theta):
    inner = np.power(((X @ theta.T) - y), 2)
    return np.sum(inner) / (2 * len(X))

def gradientDescent(X, y, theta, alpha, iters):
    for i in range(iters):
        # you don't need the extra loop - this can be vectorize
        # making it much faster and simpler
        theta = theta - (alpha/len(X)) * np.sum((X @ theta.T - y) * X, axis=0)
        cost = computeCost(X, y, theta)
        if i % 10 == 0: # just look at cost every ten loops for debugging
            print(cost)
    return (theta, cost)

# notice small alpha value
alpha = 0.0001
iters = 100

# here x is columns
X = my_data[:, 0].reshape(-1,1)
ones = np.ones([X.shape[0], 1])
X = np.hstack([ones, X]) 

# theta is a row vector
theta = np.array([[1.0, 1.0]])

# y is a columns vector
y = my_data[:, 1].reshape(-1,1)

g, cost = gradientDescent(X, y, theta, alpha, iters)  
print(g, cost)

另一个有用的技术是在进行回归之前规范化数据。当您有多个功能尝试最小化时，此功能尤其有用。

作为旁注 - 如果你的步长是正确的，那么无论你做了多少次迭代都不会出现溢出，因为每次迭代都会降低成本，降低的速度会慢。

经过1000次迭代后，我得到了一个theta和费用：

[[ 1.03533399  1.45914293]] 56.041973778

100后：

[[ 1.01166889  1.45960806]] 56.0481988054

您可以使用它来查看iPython笔记本中的适合度：

%matplotlib inline
import matplotlib.pyplot as plt

plt.scatter(my_data[:, 0].reshape(-1,1), y)
axes = plt.gca()
x_vals = np.array(axes.get_xlim())
y_vals = g[0][0] + g[0][1]* x_vals
plt.plot(x_vals, y_vals, '--')