task2逻辑回归总结

一、Logistic回归模型
线性回归y=ax+b中的y值并无限制，即值域[-∞, +∞]；而对于逻辑回归，输入值可以连续，但输出值为离散值。
逻辑回归也被称为广义的线性回归，但它不是回归算法而是分类算法
常用的逻辑回归函数sigmoid函数如下：

二、代价函数

三、梯度下降法求回归模型的系数

class LGR_GD():
    def __init__(self):
        self.w = None 
        self.n_iters = None
        #sigmoid函数
    def sigmoid(self, X):
        z = X.dot(self.w.T)
        return 1/(1 + np.exp(-z))
    def fit(self,X,y,alpha=0.03,loss = 1e-10): # 设定步长为0.002，判断是否收敛的条件为1e-10
        y = y.reshape(-1,1) #重塑y值的维度以便矩阵运算
        [m,d] = np.shape(X) #自变量的维度
        self.w = np.zeros((1,d)) #将参数的初始值定为0
        tol = 1e5
        self.n_iters = 0
        #============================= show me your code =======================
        while tol > loss: #设置收敛条件
            tmp = self.sigmoid(X)- y
            tol = np.abs(np.sum(tmp))
            self.w = self.w - 1/m * alpha * np.dot(tmp.T, X)
            self.n_iters += 1 #更新迭代次数
            self.n_iters += 1 #更新迭代次数
         #============================= show me your code =======================
    def predict(self, X):
        # 用已经拟合的参数值预测新自变量
        y_pred = X.dot(self.w)
        return y_pred  

if __name__ == "__main__":
    lr_gd = LGR_GD()
    lr_gd.fit(Xs,ys)

    ax = plt.axes()

    df_X.query('label == 0').plot.scatter(x=0, y=1, ax=ax, color='blue')
    df_X.query('label == 1').plot.scatter(x=0, y=1, ax=ax, color='red')

    _xs = np.array([np.min(Xs[:,1]), np.max(Xs[:,1])])
    _ys = (lr_gd.w[0][0] + lr_gd.w[0][1] * _xs) / (- lr_gd.w[0][2])
    plt.plot(_xs, _ys, lw=1)

四 牛顿法

class LGR_NT():
    def __init__(self):
        self.w = None
        self.n_iters = None
    def sigmoid(self, X):
        z = X.dot(self.w.T)
        return 1/(1 + np.exp(-z))
    def fit(self,X,y,loss = 1e-10): # 判断是否收敛的条件为1e-10
        y = y.reshape(-1,1) #重塑y值的维度以便矩阵运算
        [m,d] = np.shape(X) #自变量的维度
        self.w = np.zeros((1,d)) #将参数的初始值定为0
        tol = 1e5
        n_iters =0
        Hessian = np.zeros((d,d))
        loss_f = 0
        #============================= show me your code =======================
        while tol > loss:
            A = 1/(1 + np.exp(-X.dot(self.w.T)))
            grad = np.dot((A-y).T, X)/m 
            for i in range(d):
                for j in range(d):
                    Hessian[i][j] = np.mean(A*(1 - A)*X[:,i]*X[:,j])
            self.w = self.w - (np.linalg.inv(Hessian).dot(grad.T)).T
            loss_next = -(np.dot(np.log(A).T, y)+np.dot(np.log(1 - A).T, (1-y)))/m
            tol = np.abs(loss_next - loss_f)  #abs函数用于返回数值的绝对值 
            loss_f = loss_next           
            n_iters += 1    
        #============================= show me your code =======================
        self.n_iters = n_iters
        
    def predict(self, X):
        # 用已经拟合的参数值预测新自变量
        y_pred = X.dot(self.w)
        return y_pred  

if __name__ == "__main__":
    lgr_nt = LGR_NT()
    lgr_nt.fit(Xs,ys)