背景

利用水位来预测大坝所欠水量

1. 正则化线性回归

1.1 可视化数据集

  1.      plt.ion()
  2.     #返回单张图像
  3.     plt.figure()
  4.     #直接输出，不阻塞
  5.     plt.plot(X, y, 'rx', markersize=10)
  6.     plt.xlabel('Change in water level (x)')
  7.     plt.ylabel('Water flowing out of the dam (y)')
  8.     plt.axis([-60, 40, 0, 40])
  9.     plt.pause(2)
  10.     plt.close()

pyplot.ion:
在使用matplotlib的过程中，常常会需要画很多图，但是好像并不能同时展示许多图。这是因为python可视化库matplotlib的显示模式默认为阻塞（block）模式。什么是阻塞模式那？我的理解就是在plt.show()之后，程序会暂停到那儿，并不会继续执行下去。如果需要继续执行程序，就要关闭图片。那如何展示动态图或多个窗口呢？这就要使用plt.ion()这个函数，使matplotlib的显示模式转换为交互（interactive）模式。即使在脚本中遇到plt.show()，代码还是会继续执行。

  • 在交互模式下：
    • plt.plot(x)或plt.imshow(x)是直接出图像，不需要plt.show()
    • 如果在脚本中使用ion()命令开启了交互模式，没有使用ioff()关闭的话，则图像会一闪而过，并不会常留。要想防止这种情况，需要在plt.show()之前加上ioff()命令。
  • 在阻塞模式下：
    • 打开一个窗口以后必须关掉才能打开下一个新的窗口。这种情况下，默认是不能像Matlab一样同时开很多窗口进行对比的。
    • plt.plot(x)或plt.imshow(x)是直接出图像，需要plt.show()后才能显示图像

image.png

1.2 正则化线性回归损失函数

image.png

  1. def linear_reg_cost_function(x, y, theta, linear_lambda):
  2.     theta = np.reshape(theta, (theta.shape[0], 1))
  3.     m = x.shape[0]
  4.     h = np.dot(x, theta)
  5.     j_without_regularization = (1 / (2 * m)) * np.sum((h - y) ** 2)
  6.     j = j_without_regularization + (linear_lambda / (2 * m)) * np.sum(theta[1:] ** 2)
  7.     grad_without_regularization = (np.dot(x.T, h - y) / m)
  8.     grad = grad_without_regularization + (linear_lambda / m) * theta
  9.     grad[0] = grad_without_regularization[0]
  10.     return j, grad

1.3 正则化线性回归梯度下降公式

image.png
j表示吴恩达机器学习作业5（正则化线性回归，偏差与方差） - 图4的索引。

1.4 拟合线性回归

pyplot.plot函数
https://blog.csdn.net/sinat_36219858/article/details/79800460

  1. def train_linear_reg(x, y, train_lambda):
  2.     initial_theta = np.zeros((x.shape[1], 1))
  3.     global grad
  4.     grad = np.zeros((x.shape[1], 1))
  5.     return sciopt.minimize(fun=cost_function, x0=initial_theta, args=(x, y, train_lambda), method="TNC", jac=gradient)
  8. def cost_function(theta, x, y, cf_lambad):
  9.     j, new_grad = linear_reg_cost_function(x, y, theta, cf_lambad)
  10.     global grad
  11.     grad = new_grad
  12.     return j
  14. def gradient(*args):
  15.     global grad
  16.     return grad.flatten()

2. 偏差方差

  1. def learning_curve(x, y, xval, yval, curve_lambda):
  2.     m = x.shape[0]
  3.     m_xval = xval.shape[0]
  5.     error_train = np.zeros((m, 1))
  6.     error_val = np.zeros((m, 1))
  8.     x = np.append(np.ones((m, 1)), x, axis=1)
  9.     xval = np.append(np.ones((m_xval, 1)), xval, axis=1)
  10.     for i in range(m):
  11.         # compute parameter theta
  12.         result = train_linear_reg(x[0:i + 1], y[0:i + 1], curve_lambda)
  13.         theta = result['x']
  15.         # compute training error
  16.         error_train[i] = linear_reg_cost_function(x[0:i + 1], y[0:i + 1], theta, 0)[0]
  18.         # compute cross validation error
  19.         error_val[i] = linear_reg_cost_function(xval, yval, theta, 0)[0]
  20.     return error_train, error_val

3. 多项式回归

3.1 特征映射

  1. def poly_features(x, p):
  2.     m = x.shape[0]
  3.     x_poly = np.zeros((m, p))
  4.     for i in range(p):
  5.         x_poly[:, i] = (x ** (i + 1)).reshape(m, )
  6.     return x_poly
  7. def feature_normalize(x):
  8.     x_norm = np.zeros(x.shape)
  9.     mu = np.mean(x, axis=0)
  10.     sigma = np.std(x, axis=0, ddof=1)
  11.     for i in range(np.shape(x)[0]):
  12.         x_norm[i] = (x[i] - mu) / sigma
  13.     return x_norm, mu, sigma

3.2 学习多项式回归

  1.     lc_pr_lambda = 1
  2.     theta = train_linear_reg(X_poly, y, lc_pr_lambda)['x']
  3.     # Plot training data and fit
  4.     plt.figure()
  5.     plt.plot(X, y, 'rx', markersize=10)
  6.     plot_fit(np.min(X), np.max(X), mu, sigma, theta, p)
  7.     plt.xlabel('Change in water level (x)')
  8.     plt.ylabel('Water flowing out of the dam (y)')
  9.     plt.title('Polynomial Regression Fit (lambda = %f)' % lc_pr_lambda)
  10.     plt.pause(2)
  11.     plt.close()
  13.     error_train, error_val = learning_curve(X_poly, y, X_poly_val, yval, lc_pr_lambda)
  14.     plt.figure()
  15.     plt.plot(np.arange(m), error_train)
  16.     plt.plot(np.arange(m), error_val)
  17.     plt.title('Polynomial Regression Learning Curve (lambda = %f)' % lc_pr_lambda)
  18.     plt.xlabel('Number of training examples')
  19.     plt.ylabel('Error')
  20.     plt.legend(['Train', 'Cross Validation'])

3.3 不同的lamda

  1. def validation_curve(x, y, xval, yval):
  2.     # Selected values of lambda (you should not change this)
  3.     lambda_vec = np.array(([0, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1, 3, 10]))
  4.     len_of_vec = len(lambda_vec)
  5.     # You need to return these variables correctly.
  6.     error_train = np.zeros((len_of_vec, 1))
  7.     error_val = np.zeros((len_of_vec, 1))
  9.     for i in range(len_of_vec):
  10.         lambda_temp = lambda_vec[i]
  12.         # compute parameter theta (learning)
  13.         result = train_linear_reg(x, y, lambda_temp)
  14.         theta = result['x']
  16.         # compute training error
  17.         j, grad = linear_reg_cost_function(x, y, theta, 0)
  18.         error_train[i] = j
  20.         # compute cross validation error
  21.         j, grad = linear_reg_cost_function(xval, yval, theta, 0)
  22.         error_val[i] = j
  23.     return lambda_vec, error_train, error_val

image.png