【吴恩达·2022机器学习专项课程】Logistic Regression -Gradient Descent

Gradient Descent

Recall the gradient descent algorithm utilizes the gradient calculation:
$$\begin{array}{rlr}& \text{repeat until convergence:}\{& \\ & w_j=w_j-\alpha \frac{\partial J(\mathbf{w},b)}{\partial w_j}& \text{for j := 0..n-1}\\ & b=b-\alpha \frac{\partial J(\mathbf{w},b)}{\partial b}& \\ & \}& \end{array}\text{\hspace{1em}(1)}$$

Where each iteration performs simultaneous updates on $w_j$ for all $j$, where
$$\begin{array}{rl}\frac{\partial J(\mathbf{w},b)}{\partial w_j}& =\frac{1}{m}\sum _{i=0}^{m-1}(f_{\mathbf{w},b}({\mathbf{x}}^{(i)})-y^{(i)})x_j^{(i)}\\ \frac{\partial J(\mathbf{w},b)}{\partial b}& =\frac{1}{m}\sum _{i=0}^{m-1}(f_{\mathbf{w},b}({\mathbf{x}}^{(i)})-y^{(i)})\end{array}\text{\hspace{1em}(2)(3)}$$

• m is the number of training examples in the data set
• $f_{\mathbf{w},b}(x^{(i)})$ is the model’s prediction, while $y^{(i)}$ is the target
• For a logistic regression model
  $z=\mathbf{w}\cdot \mathbf{x}+b$
  $f_{\mathbf{w},b}(x)=g(z)$
  where $g(z)$ is the sigmoid function:
  $g(z)=\frac{1}{1+e^{-z}}$

Code Description

The gradient descent algorithm implementation has two components:

• compute_gradient_logistic: The calculation of the current gradient, equations (2,3) above.
• gradient_descent: The loop implementing equation (1) above.

compute_gradient_logistic

Implements equation (2),(3) above for all $w_j$ and $b$.
There are many ways to implement this. Outlined below is this:

• initialize variables to accumulate dj_dw and dj_db

• for each example

  • calculate the error for that example $g(\mathbf{w}\cdot {\mathbf{x}}^{(i)}+b)-{\mathbf{y}}^{(i)}$
  • for each input value $x_j^{(i)}$ in this example,
    • multiply the error by the input $x_j^{(i)}$, and add to the corresponding element of dj_dw. (equation 2 above)
  • add the error to dj_db (equation 3 above)

• divide dj_db and dj_dw by total number of examples (m)

• note that ${\mathbf{x}}^{(i)}$ in numpy X[i,:] or X[i] and $x_j^{(i)}$ is X[i,j]

def compute_gradient_logistic(X, y, w, b): 
    """
    Computes the gradient for linear regression 
 
    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
      dj_dw (ndarray (n,)): The gradient of the cost w.r.t. the parameters w. 
      dj_db (scalar)      : The gradient of the cost w.r.t. the parameter b. 
    """
    m,n = X.shape
    dj_dw = np.zeros((n,))                           #(n,)
    dj_db = 0.

    for i in range(m):
        f_wb_i = sigmoid(np.dot(X[i],w) + b)          #(n,)(n,)=scalar
        err_i  = f_wb_i  - y[i]                       #scalar
        for j in range(n):
            dj_dw[j] = dj_dw[j] + err_i * X[i,j]      #scalar
        dj_db = dj_db + err_i
    dj_dw = dj_dw/m                                   #(n,)
    dj_db = dj_db/m                                   #scalar
        
    return dj_db, dj_dw  

gradient_descent

def gradient_descent(X, y, w_in, b_in, alpha, num_iters): 
    """
    Performs batch gradient descent
    
    Args:
      X (ndarray (m,n)   : Data, m examples with n features
      y (ndarray (m,))   : target values
      w_in (ndarray (n,)): Initial values of model parameters  
      b_in (scalar)      : Initial values of model parameter
      alpha (float)      : Learning rate
      num_iters (scalar) : number of iterations to run gradient descent
      
    Returns:
      w (ndarray (n,))   : Updated values of parameters
      b (scalar)         : Updated value of parameter 
    """
    # An array to store cost J and w's at each iteration primarily for graphing later
    J_history = []
    w = copy.deepcopy(w_in)  #avoid modifying global w within function
    b = b_in
    
    for i in range(num_iters):
        # Calculate the gradient and update the parameters
        dj_db, dj_dw = compute_gradient_logistic(X, y, w, b)   

        # Update Parameters using w, b, alpha and gradient
        w = w - alpha * dj_dw               
        b = b - alpha * dj_db               
      
        # Save cost J at each iteration
        if i<100000:      # prevent resource exhaustion 
            J_history.append( compute_cost_logistic(X, y, w, b) )

        # Print cost every at intervals 10 times or as many iterations if < 10
        if i% math.ceil(num_iters / 10) == 0:
            print(f"Iteration {i:4d}: Cost {J_history[-1]}   ")
        
    return w, b, J_history         #return final w,b and J history for graphing