【吴恩达机器学习-week1】Regression Model-回归模型

支持我的工作 🎉
如果您想看到更详细、排版更精美的该系列文章，请访问：2022吴恩达机器学习Deeplearning.ai课程作业

C1_W1_Lab03_Model_Representation_Soln

Tools

# 导入NumPy和Matplotlib
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('./deeplearning.mplstyle')

代码解读：

• numpy

  NumPy是Python中用于科学计算的一个重要库。它提供了高性能的多维数组对象（称为ndarray），以及用于处理这些数组的各种函数。NumPy的主要功能包括：

  1. ndarray对象：Numpy的核心是**ndarray**，这是一个N维数组对象，所有的元素都是相同类型的。它可以是一维、二维或多维数组。Numpy中的许多函数和方法都接受和返回ndarray对象。
  2. 数学函数：NumPy提供了大量的数学函数，包括基本的算术运算、三角函数、指数和对数函数等。这些函数可以直接应用于ndarray对象，也可以作为通用函数（ufunc）应用于数组的每个元素。
  3. 广播：Numpy的广播机制允许对不同形状的数组进行算术运算，而无需复制数据。这使得编写简洁且高效的代码变得更容易。
  4. 线性代数：NumPy提供了线性代数运算的函数，如矩阵乘法、求逆、行列式计算等。这些功能对于解决线性代数问题非常有用。
  5. 随机数生成：NumPy包含了用于生成各种概率分布的随机数的函数，如均匀分布、正态分布等。
  6. 文件IO：NumPy可以读取和写入数组数据到磁盘，支持多种文件格式。

  由于NumPy提供了高效的数组操作和数学函数，它成为了许多科学计算和数据分析库的基础，例如SciPy、Pandas和Matplotlib。

• Matplotlib

  Matplotlib是Python中用于绘制数据可视化图表的一个广泛使用的库。它提供了各种功能强大的工具，用于创建静态、交互式和动态的图形，涵盖了几乎所有类型的科学、工程和统计学中常见的图表类型。

  Matplotlib的主要特点包括：

  1. 简单易用：Matplotlib提供了简单而直观的API，使得用户能够轻松地创建各种类型的图表。
  2. 支持多种图表类型：Matplotlib支持绘制线图、散点图、柱状图、饼图、等高线图、3D图等各种常见的图表类型，以及许多高级和定制化的图表类型。
  3. 高度可定制：用户可以对图表的各个方面进行高度定制，包括线条样式、颜色、标签、标题、坐标轴范围等，以满足不同的需求。
  4. 广泛的文档和社区支持：Matplotlib拥有丰富的文档和示例库，以及庞大的社区支持，用户可以轻松地找到解决问题的方法或获取灵感。
  5. 与其他Python库集成：Matplotlib与其他常用的Python库（如NumPy、Pandas、SciPy）良好集成，使得用户可以轻松地将数据从这些库中导入并进行可视化。
  6. 支持多种输出格式：Matplotlib可以将图表保存为各种格式的文件，包括PNG、PDF、SVG等，也可以直接嵌入到Jupyter Notebook中。

  由于其强大而灵活的功能，Matplotlib被广泛应用于数据分析、科学研究、工程可视化、教学以及出版物制作等领域。

• pyplot

  pyplot是Matplotlib库中的一个子模块，它提供了一个类似于MATLAB的绘图接口，使得用户可以轻松地创建各种类型的图表。通过pyplot模块，用户可以进行图表的绘制、装饰和显示，而无需深入了解Matplotlib的底层机制。

  具体来说，pyplot模块包含了一系列函数，用于创建、定制和显示图表，例如绘制线图、散点图、柱状图、饼图等。用户可以使用这些函数来控制图表的各个方面，如图表的标题、标签、颜色、线型、坐标轴范围等。

  使用pyplot模块的一般流程如下：

  1. 导入matplotlib.pyplot模块：

     import matplotlib.pyplot as plt
     

  2. 使用pyplot提供的函数创建图表，例如绘制一条简单的曲线：

     x = [1, 2, 3, 4, 5]
     y = [2, 4, 6, 8, 10]
     plt.plot(x, y)
     

  3. 可选地，进行图表的装饰，如添加标题、标签等：

     plt.title('Simple Plot')
     plt.xlabel('X-axis')
     plt.ylabel('Y-axis')
     

  4. 最后，显示图表：

     plt.show()
     

  pyplot模块简化了Matplotlib的使用，特别适用于快速绘制简单图表或进行交互式数据探索。然而，对于更复杂的图形定制和布局，以及在Matplotlib中实现更高级功能，可能需要直接使用Matplotlib的其他模块和类。

• plt.style.use('./deeplearning.mplstyle')

  plt.style.use是Matplotlib库中的一个函数，用于设置当前图表的样式。通过使用不同的样式，可以改变图表的外观，包括线条样式、颜色、字体、背景等。

  具体来说，plt.style.use函数接受一个样式文件的路径或样式名称作为参数，然后将当前图表的样式设置为指定的样式。这样做可以使得图表在绘制时自动应用指定的样式，而无需在每个图表中单独设置样式。

  例如，如果你有一个名为deeplearning.mplstyle的样式文件，你可以通过以下方式将其应用到当前图表：

  import matplotlib.pyplot as plt
  plt.style.use('./deeplearning.mplstyle')
  

  这将使得当前图表使用deeplearning.mplstyle中定义的样式进行绘制。

  Matplotlib提供了一些内置的样式，例如'ggplot'、'seaborn'等，你也可以在Matplotlib官方文档中找到更多的样式。此外，你可以创建自己的样式文件，以满足特定的需求或匹配特定的风格。

问题陈述

• 使用房价预测的例子

• 使用一个简单的数据集，只有两个数据点：

  尺寸（1000平方英尺）	价格（1000美元）
  1.0	300
  2.0	500

• 你想要通过这两个点拟合一个线性回归模型，这样你就可以为其他房子预测房价

创建训练集

创建你的 x_train 和 y_train 变量。数据存储在一维的NumPy数组中。

x_train = np.array([1.0, 2.0])
y_train = np.array([300.0, 500.0])
print(f"x_train = {x_train}")
print(f"y_train = {y_train}")

# print
x_train = [1. 2.]
y_train = [300. 500.]

训练样本数量 m

你将使用 m 来表示训练样本的数量。Numpy数组有一个 .shape 参数。x_train.shape 返回一个python元组，其中每个维度都有一个条目。x_train.shape[0] 是数组的长度和样本数，如下所示。

# m is the number of training examples
print(f"x_train.shape: {x_train.shape}")
m = x_train.shape[0]
print(f"Number of training examples is: {m}")

# print
x_train.shape: (2,)
Number of training examples is: 2

• 怎么理解：print(f"x_train.shape: {x_train.shape}")
  • 这行代码是Python中的字符串格式化输出。它的作用是将花括号中的表达式的值插入到字符串中。
  • 在这个例子中，x_train.shape是一个数组或矩阵的形状，这种形式通常是(行数, 列数)的形式，或者更高维的形式。
  • 通过使用{}来代表要插入的值，f字符串前缀告诉Python解释器这是一个格式化字符串。这样，x_train.shape的实际值会被插入到字符串中。这个语句的输出类似于：“x_train.shape: (100, 20)”，其中100和20是实际的行数和列数值。
• 怎么理解：m = x_train.shape[0]
  • 这行代码是在Python中用于获取训练数据集（x_train）的行数，并将结果赋值给变量m。
  • 在这里，x_train.shape返回一个包含数据集维度信息的元组，例如(100, 20)，其中100表示行数，20表示列数。通过取元组的第一个元素，即x_train.shape[0]，就可以获取数据集的行数。将这个行数赋值给变量m，可以在后续的代码中使用m来表示数据集的行数。

也可以使用Python的 len() 函数，如下所示。

m = len(x_train)
print(f"Number of training examples is: {m}")

训练样本 $x_i,y_i$

你将使用（$x^{(i)}$, $y^{(i)}$）表示第 $i^{th}$训练样本。

由于Python是从零开始索引的，所以$（x^{(0)},y^{(0)}）$是$（1.0，300.0）$，$（x^{(1)},y^{(1)}）$是$（2.0，500.0）$。

要访问Numpy数组中的值，可以使用数组的偏移索引。例如，访问 x_train 的位置零的语法是 x_train[0]。

i = 0 # Change this to 1 to see (x^1, y^1)

x_i = x_train[i]
y_i = y_train[i]
print(f"(x^({i}), y^({i})) = ({x_i}, {y_i})")

# print
(x^(0), y^(0)) = (1.0, 300.0)

绘制数据

你可以使用 matplotlib 库中的 scatter() 函数绘制这两个点，如下所示。

• 函数参数 marker 和 c 将点显示为红色十字（默认为蓝色点）。

你可以使用 matplotlib 库中的其他函数来设置要显示的标题和标签。

# Plot the data points
plt.scatter(x_train, y_train, marker='x', c='r')
# Set the title
plt.title("Housing Prices")
# Set the y-axis label
plt.ylabel('Price (in 1000s of dollars)')
# Set the x-axis label
plt.xlabel('Size (1000 sqft)')
plt.show()

• 怎么理解这句话：plt.scatter(x_train, y_train, marker='x', c='r')

  这句话是在使用 Matplotlib 库的 scatter() 函数绘制散点图。解释一下：

  • plt.scatter: 这是 Matplotlib 库中用于绘制散点图的函数。
  • (x_train, y_train): 这是要绘制的数据点的 x 和 y 坐标。在这个例子中，x_train 是房屋尺寸，y_train 是房屋价格。
  • marker='x': 这是指定散点的标记类型。在这里，'x' 表示使用红色十字作为标记。
  • c='r': 这是指定散点的颜色。在这里，'r' 表示红色。

  因此，这句话的意思是将 x_train 和 y_train 中的数据点绘制为红色的十字标记。

模型函数

如讲座中所述，线性回归的模型函数（它是一个将 x 映射到 y 的函数）表示为

$f_{w,b}(x^{(i)})=w{x}^{(i)}+b$

The formula above is how you can represent straight lines - different values of $w$ and $b$ give you different straight lines on the plot.

• NOTE：你可以调整模型的 w

w = 100
b = 100
print(f"w: {w}")
print(f"b: {b}")

现在，让我们计算你的两个数据点的 $f_{w,b}(x^{(i)})$ 的值。你可以为每个数据点显式地写出这个值，如下所示：

对于 $x^{(0)}$，$f_{wb}=w\ast x[0]+b$

对于 $x^{(1)}$，$f_{wb}=w\ast x[1]+b$

对于大量的数据点，这样做会变得笨拙和重复。因此，你可以使用 for 循环计算函数的输出，如下面的 compute_model_output 函数所示。

def compute_model_output(x, w, b):
    """
    Computes the prediction of a linear model
    Args:
      x：data 
      w：weight
      b：bias
      y (ndarray (m,)): target values
    """
    m = x.shape[0] # 获取了输入数据 x 的行数，也就是样本的数量
    f_wb = np.zeros(m) # 创建了一个大小为 m 的全零数组 f_wb，用于存储模型的预测输出
    for i in range(m):
        f_wb[i] = w * x[i] + b # 计算了线性模型的预测输出
        
    return f_wb # 返回了存储了所有预测输出的数组 f_wb

执行 compute_model_output 函数并绘制线性模型的预测结果与实际数据之间的对比图

tmp_f_wb = compute_model_output(x_train, w, b,) # 模型对训练数据的预测输出

# 绘制了模型的预测输出，使用蓝色线条表示，并给出了标签 "Our Prediction"
plt.plot(x_train, tmp_f_wb, c='b',label='Our Prediction')

# 绘制了训练数据的真实值，使用红色的 "x" 标记表示，并给出了标签 "Actual Values"
plt.scatter(x_train, y_train, marker='x', c='r',label='Actual Values')

# Set the title
plt.title("Housing Prices")
# Set the y-axis label
plt.ylabel('Price (in 1000s of dollars)')
# Set the x-axis label
plt.xlabel('Size (1000 sqft)')
plt.legend() # 用于显示图例，将标签显示在图表上
plt.show()

如图，设置的 $w$ 和 $b$ 并没有得到适合我们数据的线。

挑战

尝试使用不同的 $w$ 和 $b$ 值进行实验。对于一个适合我们数据的线，这些值应该是多少呢？

提示：

w = 200 and b = 100

预测

• 现在我们有了一个模型，我们可以用它来进行我们最初的预测。

• 让我们预测一栋面积为 1200 平方英尺的房屋的价格。由于单位是以千平方英尺为单位，那么 $x$ 是 1.2。

w = 200                         
b = 100    
x_i = 1.2
cost_1200sqft = w * x_i + b    

print(f"${cost_1200sqft:.0f} thousand dollars")

#print
$340 thousand dollars

• 怎么理解这句话：print(f"${cost_1200sqft:.0f} thousand dollars")

  这行代码使用 f-string 格式化字符串，将预测价格打印出来。:0f 指定了浮点数的格式为不带小数点的形式，而 ${} 则将价格输出为美元形式，并在字符串末尾添加了 “thousand dollars”，表示单位为千美元。

总结

在这个实验中，学到了：

• 线性回归建立了一个模型，建立了特征和目标之间的关系。
• 在上面的示例中，特征是房屋大小，目标是房屋价格。
• 对于简单线性回归，模型有两个参数 $\ast w\ast$ 和 $\ast b\ast$，它们的值使用训练数据进行“拟合”。
• 一旦确定了模型的参数，就可以使用模型对新的数据进行预测。

C1_W1_Lab04_Cost_function_Soln

目标

在本实验中，您将：

• 实现并探索具有一个变量的线性回归的成本函数。

Tools

在本实验中，我们将使用以下工具：

• NumPy，一个流行的科学计算库
• Matplotlib，一个流行的绘图库
• 位于本地目录中的lab_utils_uni.py文件中的本地绘图程序

import numpy as np
%matplotlib widget
import matplotlib.pyplot as plt
from lab_utils_uni import plt_intuition, plt_stationary, plt_update_onclick, soup_bowl
plt.style.use('./deeplearning.mplstyle')

• 怎么理解这句话：%matplotlib widget

  %matplotlib widget是一个IPython魔术命令，用于指示IPython或Jupyter Notebook在绘制Matplotlib图形时使用交互式的后端，使得图形可以在图形界面中进行交互，例如放大、缩小、平移等操作。这个命令使得Matplotlib的图形输出能够在IPython或Jupyter Notebook中以交互式的方式显示，而不是简单地静态显示。

问题陈述

您希望有一个能够根据房屋面积预测房价的模型。让我们使用与上一实验相同的两个数据点：

面积（1000平方英尺）	价格（千美元）
1	300
2	500

x_train = np.array([1.0, 2.0])           #(size in 1000 square feet)
y_train = np.array([300.0, 500.0])           #(price in 1000s of dollars)

计算成本

在这个任务中，“成本”这个术语可能有点令人困惑，因为数据是房屋成本。在这里，成本是衡量我们的模型如何预测房价的指标。术语“价格”用于房屋数据。

具有一个变量的成本方程式为：

$$J(w,b)=\frac{1}{2m}\sum _{i=0}^{m-1}(f_{w,b}(x^{(i)})-y^{(i)}{)}^2\text{\hspace{1em}(1)}$$

其中

$$f_{w,b}(x^{(i)})=w{x}^{(i)}+b\text{\hspace{1em}(2)}$$

• $f_{w,b}(x^{(i)})$ 是使用参数 $w,b$ 对示例 $i$ 进行的预测值
• $(f_{w,b}(x^{(i)})-y^{(i)}{)}^2$ 是目标值和预测之间的平方差
• 这些差异在所有 $m$ 个示例上求和，然后除以 2m 以产生成本$J(w,b)$

注意，在讲座中，求和范围通常是从1到m，而代码中是从0到m-1。

以下代码通过循环遍历每个示例来计算成本。在每次循环中：

1. 计算了预测值 f_wb。
2. 计算了目标值与预测值之间的差异，并对其进行了平方。
3. 将这个平方差累加到总成本中。

def compute_cost(x, y, w, b): 
    # number of training examples
    m = x.shape[0] 
    
    cost_sum = 0 
    # 复现公式（1）
    for i in range(m): 
        f_wb = w * x[i] + b   
        cost = (f_wb - y[i]) ** 2   
        cost_sum = cost_sum + cost  
    total_cost = (1 / (2 * m)) * cost_sum  

    return total_cost

成本函数的直观性

您的目标是找到一个模型 $f_{w,b}(x)=wx+b$，具有参数 $w,b$，能够准确预测给定输入 $x$ 的房屋价值。成本是衡量模型在训练数据上的准确性的指标。

成本方程式（1）上述显示，如果 $w$ 和 $b$ 能够被选择，使得预测值 $f_{w,b}(x)$ 与目标数据 $y$ 匹配，那么 $(f_{w,b}(x^{(i)})-y^{(i)}{)}^2$ 项将为零，成本将最小化。在这个简单的两点示例中，您可以实现这一点！

在上一次的实验中，您确定$b=100$ 提供了最优解，所以让我们将 $b$ 设置为$100$，并专注于 $w$。
在下面，使用滑块控制来选择最小化成本的 $w$ 值。图表更新可能需要几秒钟的时间。

plt_intuition(x_train,y_train)

💡 此处需要下载node.js：访问 Node.js 官方网站：https://nodejs.org/

• plt_intuition(x_train,y_train) 的实现细节和部分解释：

  def plt_intuition(x_train, y_train):
  
      w_range = np.array([200-200,200+200])
      tmp_b = 100
  
      w_array = np.arange(*w_range, 5)
      cost = np.zeros_like(w_array)
      for i in range(len(w_array)):
          tmp_w = w_array[i]
          cost[i] = compute_cost(x_train, y_train, tmp_w, tmp_b)
  
      @interact(w=(*w_range,10),continuous_update=False)
      def func( w=150):
          f_wb = np.dot(x_train, w) + tmp_b
  
          fig, ax = plt.subplots(1, 2, constrained_layout=True, figsize=(8,4))
          fig.canvas.toolbar_position = 'bottom'
  
          mk_cost_lines(x_train, y_train, w, tmp_b, ax[0])
          plt_house_x(x_train, y_train, f_wb=f_wb, ax=ax[0])
  
          ax[1].plot(w_array, cost)
          cur_cost = compute_cost(x_train, y_train, w, tmp_b)
          ax[1].scatter(w,cur_cost, s=100, color=dldarkred, zorder= 10, label= f"cost at w={w}")
          ax[1].hlines(cur_cost, ax[1].get_xlim()[0],w, lw=4, color=dlpurple, ls='dotted')
          ax[1].vlines(w, ax[1].get_ylim()[0],cur_cost, lw=4, color=dlpurple, ls='dotted')
          ax[1].set_title("Cost vs. w, (b fixed at 100)")
          ax[1].set_ylabel('Cost')
          ax[1].set_xlabel('w')
          ax[1].legend(loc='upper center')
          fig.suptitle(f"Minimize Cost: Current Cost = {cur_cost:0.0f}", fontsize=12)
          plt.show()
  

  解释：这段代码是一个自定义函数 plt_intuition，用于可视化线性回归模型。它接受训练数据集 x_train 和 y_train 作为输入参数。

  • 怎么理解：w_range = np.array([200-200,200+200])

    这段代码定义了一个包含两个元素的NumPy数组 w_range，其取值范围是从 0 到 400。

    让我们来分解一下：

    • [200-200,200+200] 首先计算了两个值，即 0 和 400。
    • 然后将这两个值作为数组的两个元素，形成了 w_range。

    因此，w_range 是一个包含了两个值的数组，分别是 0 和 400，表示了$w$ 参数的取值范围。

  • 怎么理解：tmp_b = 100

    用于表示线性回归模型中的截距（intercept）参数 $b$ 的值。通过将其设置为 $100$，可以在可视化过程中专注于调整斜率参数 $w$，而不必担心截距参数 $b$ 的影响。

  • 怎么理解：w_array = np.arange(*w_range, 5)

    这行代码使用 np.arange 函数创建了一个包含一系列 $w$ 参数值的数组 w_array。np.arange 函数的参数是 *w_range，这表示它会接受 w_range 数组中的两个值作为起始和结束值，并使用步长为 5 来生成这些值。

    具体地说，w_range 是一个包含两个元素的数组，分别是 0 和 400。因此，np.arange(*w_range, 5) 将生成从 0 到 400（不包括 400）的所有可能的 $w$ 参数值，并且这些值之间的间隔是 5。生成的数组将存储在 w_array 中。

  • 怎么理解：cost = np.zeros_like(w_array)

    这行代码创建了一个名为 cost 的NumPy数组，并且这个数组的形状与 w_array 相同。np.zeros_like() 函数的作用是生成一个与指定数组形状相同、所有元素值为0的新数组。

    因此，cost = np.zeros_like(w_array) 将会创建一个与 w_array 具有相同形状的全零数组，用于存储后续计算得到的成本值。这个数组将会在接下来的循环中使用，每个元素将存储对应 $w$ 参数值下的成本。

成本函数可视化 - 3D

你可以通过绘制三维图或使用等高线图来观察成本随着 $w$ 和 $b$ 的变化而变化。 值得注意的是，本课程中的一些绘图可能会变得相当复杂。 绘图例程已提供，虽然阅读代码来熟悉方法可能是有益的，但并不是必需的以成功完成课程。 这些例程在本地目录中的 lab_utils_uni.py 中。

更大的数据集

查看具有更多数据点的情景是有益的。该数据集包含不在同一条直线上的数据点。这对成本方程意味着什么？我们能找到使成本为 0 的 $w$ 和 $b$ 吗？

x_train = np.array([1.0, 1.7, 2.0, 2.5, 3.0, 3.2])
y_train = np.array([250, 300, 480,  430,   630, 730,])

在等高线图中，点击一个点来选择 $w$ 和 $b$ 以达到最低成本。使用等高线来指导你的选择。

plt.close('all') 
fig, ax, dyn_items = plt_stationary(x_train, y_train)
updater = plt_update_onclick(fig, ax, x_train, y_train, dyn_items)

• 怎么理解：plt.close('all')

  关闭所有已打开的图形窗口

• 怎么理解：fig, ax, dyn_items = plt_stationary(x_train, y_train)

  这行代码执行了一个函数 plt_stationary(x_train, y_train)，并将其返回的结果分别赋值给了变量 fig、ax 和 dyn_items。

  通常这种情况下，函数的返回值被设计为一个元组（或类似元组的对象），而元组的每个元素都有特定的含义。在这个例子中，函数 plt_stationary(x_train, y_train) 返回了一个包含三个元素的元组，分别是：

  • fig：表示图形对象，即整个图形窗口。
  • ax：表示坐标轴对象，即图形中的坐标系。
  • dyn_items：可能是一些动态的图形元素，例如等高线、数据点等。

  因此，通过这行代码，你可以将函数返回的这三个重要的对象分别赋值给了变量 fig、ax 和 dyn_items，以便后续的操作和修改。

• 怎么理解这句话：updater = plt_update_onclick(fig, ax, x_train, y_train, dyn_items)

  plt_update_onclick() 函数被设计用于创建一个交互式的图形更新器。根据函数名和参数的含义，它会在给定的图形 (fig) 和坐标轴 (ax) 上添加一个点击事件的监听器，以便在用户点击等高线图上的某一点时执行相应的更新操作。

  这个函数会使用传递给它的 x_train 和 y_train 数据，以及 dyn_items 中的动态图形元素，来实现图形的动态更新功能。

  因此，通过将函数返回的更新器对象赋值给变量 updater，可以在后续的代码中使用该对象来控制图形的交互操作和更新行为。

  

在上面的左图中，请注意虚线。

这些虚线表示训练集中每个样本贡献的成本部分。在这种情况下，大约为 $w=209$ 和 $b=2.4$ 的值提供了较低的成本。请注意，由于我们的训练示例不在一条直线上，最小成本并不是零。

凸成本曲面

成本函数对损失进行平方处理，确保了 "误差曲面 "像汤碗一样是凸的。

它总是有一个最小值，可以在所有维度上沿着梯度到达该值。在上一幅图中，由于 $w$ 和 $b$ 维度的比例不同，这一点不容易识别。下图中的 $w$ 和 $b$ 是对称的，在讲座中已经展示过：

soup_bowl()

• 怎么理解：soup_bowl()

  soup_bowl() 指代一个用来创建或绘制凸成本曲面的函数。

  在这个语境中，“soup bowl” 指的是一个类似汤碗形状的曲面，通常用来比喻一个凸起的、具有单一最小值的曲面。因此，soup_bowl() 函数被设计用来创建或绘制一个类似汤碗形状的凸成本曲面，以便在数据可视化中展示成本函数的性质和最小值的位置。

  通过调用这个函数，可以生成一个图形或数据结构，来展示成本函数的凸性和最小值的位置，以便更好地理解成本函数的特性。

  

  总结

  你已经学会了以下内容：

  • 成本方程提供了一个衡量预测值与训练数据匹配程度的指标。
  • 最小化成本可以提供 $w$、$b$ 的最佳值。