吴恩达机器学习L1W3L05-逻辑回归的成本函数

目标

在本实验中，你将:

检查执行情况并利用成本函数进行逻辑回归。

python 复制代码

import numpy as np
%matplotlib widget
import matplotlib.pyplot as plt
from lab_utils_common import  plot_data, sigmoid, dlc
plt.style.use('./deeplearning.mplstyle')

数据集

python 复制代码

X_train = np.array([[0.5, 1.5], [1,1], [1.5, 0.5], [3, 0.5], [2, 2], [1, 2.5]])  #(m,n)
y_train = np.array([0, 0, 0, 1, 1, 1])                                           #(m,)

我们将使用一个辅助函数来绘制这些数据。标签为 y = 1 y=1 y=1的数据点显示为红色叉，而标签为 y = 0 y=0 y=0的数据点显示为蓝色圆。

python 复制代码

fig,ax = plt.subplots(1,1,figsize=(4,4))
plot_data(X_train, y_train, ax)

# Set both axes to be from 0-4
ax.axis([0, 4, 0, 3.5])
ax.set_ylabel('$x_1$', fontsize=12)
ax.set_xlabel('$x_0$', fontsize=12)
plt.show()

成本函数

在之前的实验中，您开发了"逻辑损失"函数。回想一下，loss被定义为应用于一个示例。在这里，您将损失组合成包含所有示例的成本。

回想一下，对于逻辑回归，成本函数是这样的形式
J ( w , b ) = 1 m ∑ i = 0 m − 1 [ l o s s ( f w , b ( x ( i ) ) , y ( i ) ) ] (1) J(\mathbf{w},b) = \frac{1}{m} \sum_{i=0}^{m-1} \left[ loss(f_{\mathbf{w},b}(\mathbf{x}^{(i)}), y^{(i)}) \right] \tag{1} J(w,b)=m1i=0∑m−1[loss(fw,b(x(i)),y(i))](1)

l o s s ( f w , b ( x ( i ) ) , y ( i ) ) loss(f_{\mathbf{w},b}(\mathbf{x}^{(i)}), y^{(i)}) loss(fw,b(x(i)),y(i)) 是一个单数据点成本
l o s s ( f w , b ( x ( i ) ) , y ( i ) ) = − y ( i ) log ⁡ ( f w , b ( x ( i ) ) ) − ( 1 − y ( i ) ) log ⁡ ( 1 − f w , b ( x ( i ) ) ) (2) loss(f_{\mathbf{w},b}(\mathbf{x}^{(i)}), y^{(i)}) = -y^{(i)} \log\left(f_{\mathbf{w},b}\left( \mathbf{x}^{(i)} \right) \right) - \left( 1 - y^{(i)}\right) \log \left( 1 - f_{\mathbf{w},b}\left( \mathbf{x}^{(i)} \right) \right) \tag{2} loss(fw,b(x(i)),y(i))=−y(i)log(fw,b(x(i)))−(1−y(i))log(1−fw,b(x(i)))(2)

式中，m为数据集中的训练样例个数，
f w , b ( x ( i ) ) = g ( z ( i ) ) z ( i ) = w ⋅ x ( i ) + b g ( z ( i ) ) = 1 1 + e − z ( i ) \begin{align} f_{\mathbf{w},b}(\mathbf{x^{(i)}}) &= g(z^{(i)})\tag{3} \\ z^{(i)} &= \mathbf{w} \cdot \mathbf{x}^{(i)}+ b\tag{4} \\ g(z^{(i)}) &= \frac{1}{1+e^{-z^{(i)}}}\tag{5} \end{align} fw,b(x(i))z(i)g(z(i))=g(z(i))=w⋅x(i)+b=1+e−z(i)1(3)(4)(5)

代码描述

'compute_cost_logistic'算法遍历所有示例，计算每个示例求和的损失。

注意变量X和y不是标量值，而是形状分别为( m , n m, n m,n)和(𝑚,)的矩阵，其中 𝑛 是特征的数量，𝑚是训练样例的数量。

python 复制代码

def compute_cost_logistic(X, y, w, b):
    """
    Computes cost

    Args:
      X (ndarray (m,n)): Data, m examples with n features
      y (ndarray (m,)) : target values
      w (ndarray (n,)) : model parameters  
      b (scalar)       : model parameter
      
    Returns:
      cost (scalar): cost
    """

    m = X.shape[0]
    cost = 0.0
    for i in range(m):
        z_i = np.dot(X[i],w) + b
        f_wb_i = sigmoid(z_i)
        cost +=  -y[i]*np.log(f_wb_i) - (1-y[i])*np.log(1-f_wb_i)
             
    cost = cost / m
    return cost

使用下面的单元格检查成本函数的实现。

python 复制代码

w_tmp = np.array([1,1])
b_tmp = -3
print(compute_cost_logistic(X_train, y_train, w_tmp, b_tmp))

期望产量:0.3668667864055175

例子

现在，让我们看看不同w值下的代价函数输出是什么。

在前面的实验中，您绘制了 b = − 3 , w 0 = 1 , w 1 = 1 b = -3, w_0 = 1, w_1 = 1 b=−3,w0=1,w1=1的决策边界。也就是说，你有' w = np.array([-3,1,1]) '。
假设您想看看 b = − 4 , w 0 = 1 , w 1 = 1 b = -4, w_0 = 1, w_1 = 1 b=−4,w0=1,w1=1，或' w = np.array([-4,1,1]) '是否提供了更好的模型。

让我们首先绘制这两个不同的 b b b值的决策边界，看看哪一个更适合数据。

对于 b = − 3 , w 0 = 1 , w 1 = 1 b = -3, w_0 = 1, w_1 = 1 b=−3,w0=1,w1=1，我们将绘制 − 3 + x 0 + x 1 = 0 -3 + x_0+x_1 = 0 −3+x0+x1=0(用蓝色表示)
对于 b = − 4 , w 0 = 1 , w 1 = 1 b = -4, w_0 = 1, w_1 = 1 b=−4,w0=1,w1=1，我们将绘制 − 4 + x 0 + x 1 = 0 -4 + x_0+x_1 = 0 −4+x0+x1=0(用洋红色表示)

python 复制代码

import matplotlib.pyplot as plt

# Choose values between 0 and 6
x0 = np.arange(0,6)

# Plot the two decision boundaries
x1 = 3 - x0
x1_other = 4 - x0

fig,ax = plt.subplots(1, 1, figsize=(4,4))
# Plot the decision boundary
ax.plot(x0,x1, c=dlc["dlblue"], label="$b$=-3")
ax.plot(x0,x1_other, c=dlc["dlmagenta"], label="$b$=-4")
ax.axis([0, 4, 0, 4])

# Plot the original data
plot_data(X_train,y_train,ax)
ax.axis([0, 4, 0, 4])
ax.set_ylabel('$x_1$', fontsize=12)
ax.set_xlabel('$x_0$', fontsize=12)
plt.legend(loc="upper right")
plt.title("Decision Boundary")
plt.show()

从这张图中可以看出，w = np.array([-4,1,1])对于训练数据来说是一个较差的模型。让我们看看成本函数的实现是否反映了这一点。

python 复制代码

w_array1 = np.array([1,1])
b_1 = -3
w_array2 = np.array([1,1])
b_2 = -4

print("Cost for b = -3 : ", compute_cost_logistic(X_train, y_train, w_array1, b_1))
print("Cost for b = -4 : ", compute_cost_logistic(X_train, y_train, w_array2, b_2))

预期结果

Cost for b = -3 : 0.3668667864055175

Cost for b = -4 : 0.5036808636748461

您可以看到代价函数的行为符合预期，并且w = np.array([-4,1,1])的代价确实高于w = np.array([-3,1,1])的代价

祝贺

在本实验中，您检查并使用了逻辑回归的成本函数。