线性回归模型并不适用于分类任务，相比之下，一个新的算法，逻辑回归可能更适合

一、逻辑回归

1.sigmoid函数

代码实现如下

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

2.逻辑回归模型

逻辑回归模型的基本形式如上，作用是输入一个特征或一组特征x，并输出一个介于0和1之间的值，同时在有些地方，也书写成

,这里的分号表示w和b是影响计算的参数，即给定输入特征x时y等于1的概率

二、决策边界

经过推理，我们可以得到，只有当z>=0时，预测值y才等于1，z<0时，预测值y等于0；由此，在实际的样本分类中，决策边界只是正负样本分届的地方，也就是z=0的地方，以下有两个例子用于说明决策边界

例子一：

假设了w均为1，b为-3，通过函数图像我们可以计算得到

就是样本分界的地方

例子二：

如果有多项式的分本，可以看到，经过计算得到了一个圆作为边界

同样，通过升高次数，还有更多其他形状的决策边界

三、逻辑回归的成本函数

1.逻辑回归损失函数的基本形式

由于逻辑回归模型的基本形式是sigmoid函数，这会使得线性回归模型中的成本函数有多个局部最小值，为了解决这个问题，我们需要对成本函数进行重新的定义，从而来实现将成本函数转为凸函数

2.逻辑回归模型损失函数的简化形式

3.成本函数的实现

刚才我们一直讨论的是损失函数，他们都是单个样本的损失函数，而对于成本函数，我们需要实现的是对所有单样本损失函数之和的平均值

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

四、逻辑回归的梯度下降函数

同线性回归模型，唯一不同的是逻辑回归的f_wb是sigmoid函数

def logistic_gradient(X, y, w, b):
    m = X.shape[0]
    df_dw = np.zeros(m)
    df_db = 0
    for i in range(m):
        z_i = np.dot(X[i], w) + b
        f_wb_i = sigmoid(z_i)
        err = f_wb_i-y[i]
        for j in range(m):
            df_dw[j] += err*X[i,j]
        df_db +=err
    df_dw = df_dw/m
    df_db = df_db/m
    return df_dw, df_db

def gradient_descent(X, y, w_in, b_in, alpha, num_iters):
    w = copy.deepcopy(w_in)
    b = b_in

    J_history = []
    for i in range(num_iters):
        df_dw, df_db = logistic_gradient(X, y, w, b)
        w = w - alpha*df_dw
        b = b - alpha*df_db

        if i <100000:
            J_history.append(computer_cost(X, y, w, b))
        if i % math.ceil(num_iters / 10) == 0:
            print(f"Iteration {i:4d}: Cost {J_history[-1]}   ")
    return w, b,J_history

五、过拟合

1.什么是过拟合

2.如何解决过拟合

三种方式

1. 使用更多的数据
2. 选择某些特征，进行特征选择
3. 使用正则化，将w进行正则化的调整

六、正则化

1.带正则化的成本函数

• λ就是正则化系数，如果λ过大会欠拟合，如果λ过小会过拟合
• 除以2m是为了与前半部分式子保持相同的缩放，要求这个式子的最小值，就表明了原本的成本函数要最小，同时后部分的w系数平方和也最小，一个控制成本，一个控制拟合程度，这样就可以平衡模型，使得模型表现尽可能的好

2.正则化的线性回归

成本函数

代码实现

def compute_cost(X, y, w, b, lambda_):
    m = X.shape[0]
    n = len(w)
    cost = 0.
    for i in range(m):
        z_i = np.dot(X[i], w) + b
        cost += (z_i - y[i]) ** 2
    cost = cost / (2 * m)
    reg_cost = 0
    for j in range(n):
        reg_cost += w[j] ** 2
    reg_cost = (lambda_ / (2 * m)) * reg_cost
    return cost + reg_cost

梯度下降函数

代码实现

def compute_gradient(X, y, w, b, lambda_):
    m, n = X.shape
    dj_dw = np.zeros((n,))
    dj_db = 0.

    for i in range(m):
        err = (np.dot(X[i], w) + b) - y[i]
        for j in range(n):
            dj_dw[j] = dj_dw[j] + err * X[i, j]
        dj_db = dj_db + err
    dj_dw = dj_dw / m
    dj_db = dj_db / m

    for j in range(n):
        dj_dw[j] = dj_dw[j] + (lambda_ / m) * w[j]

    return dj_db, dj_dw

2.正则化的逻辑回归

成本函数

代码实现

def sigmoid(x):
    return 1 / (1 + np.exp(-x))


def compute_cost(X, y, w, b, lambda_):
    m = X.shape[0]
    n = len(w)
    cost = 0.

    for i in range(m):
        z_i = np.dot(X, 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)

    reg_cost = 0
    for j in range(n):
        reg_cost += w[j] ** 2

    reg_cost = (lambda_ / (2 * m)) * reg_cost
    return cost + reg_cost

梯度下降函数

代码实现

def compute_gradient(X, y, w, b, lambda_):
    m, n = X.shape[0]
    df_dw = np.zeros((n,))
    df_db = 0.0
    for i in range(m):
        z_i = np.dot(X, w) + b
        f_wb_i = sigmoid(z_i)
        err = f_wb_i - y[i]
        for j in range(m):
            df_dw[j] += err * X[i, j]
        df_db += err
    df_dw = df_dw / m
    df_db = df_db / m

    for j in range(n):
        df_dw[j] = df_dw[j] + (lambda_ / m) * w[j]
    return df_dw, df_db