1.LogisticRegression

这里就不仔细介绍 原理了
详细的原理请参考吴恩达 深度学习 课程 移步网易教育好啦
PS：我也有写视频课的笔记 如果觉得有问题可以阅览一下我的笔记哦 也许有提到你的疑问啦 我是按照自己听课的时候思维逻辑写的笔记
（超小声：有够懒的 笔记不知道什么时候才会跟着补完……

我知道写下这些可能没有人会看到 但都是我一行一行写的代码
如果你看到了 给我点个赞吧 鼓励一下小朋友吧 :b

下面的代码都是jupyter notebook
可以直接运行的代码！ 自己亲手敲的那种！（叉腰～）
具体的介绍 我就用注释写在下面啦

有问题留言哦

import numpy as np

# input: x, w, b output: z 
def layer(x,w,b):
    return np.dot(x , w)+b

# 定义 损失函数
# input: pred_y & true_y output : loss(pre_y,true_y)
def mse(pred_y, true_y):
    return 0.5 * (pred_y - true_y)**2

# input: pre_y & true_y output: dl_y

def mse_grad(pred_y, true_y):
    return pred_y - true_y

# 激活函数 
# input: (w*x+b) 线性模型 output:  pre_y
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# input : pre_y output:dy_z
def sigmoid_grad(y):
    return y * (1-y)


# input: x   output: dz_w,dz_b
def layer_grad(x):
    return x, 1

# input: x,w,b   output ---> pre_y
def forward(x,w,b):
    z=layer(x,w,b)
    return sigmoid(z)

# backward :input: pre_y , true_y  output ---> dw,db
# 反向传播的主要目的就是更新dw,db 这里的导数计算需要一定的微积分基础哦
def backward(pred_y, true_y,x):
    dl_y = mse_grad(pred_y,true_y)
    dy_z = sigmoid_grad(pred_y)
    dz_w, dz_b = layer_grad(x)
    
    dw = dl_y * dy_z * dz_w
    db = dl_y * dy_z
    
    return dw, db

# 这里多说两句 一定要算清楚 计算是最基础的 需要自己动笔算的鸭
# 这里变量比较多 主要是要弄清楚每个函数的 输入和输出
# 第一次写 我也比较懵逼 所以我都标注了每个函数的输入和输出 
# 因为当函数变多的时候 如果自己都搞不清楚 输入和输出的话 很容易就把自己搞晕了

# 定义class
class LogisticRegression(object):

    def __init__(self, in_size, lr):
        self.w = np.random.randn(in_size)
        self.b = np.random.randn(1)
        self.lr = lr
    
    def forward(self,x):
        return forward(x,self.w,self.b)
    
    def backward(self, pred_y, true_y, x):
        return backward(pred_y, true_y, x)
    
# 更新参数（w,b）
    def step(self, dw, db):
        self.w -= self.lr * dw
        self.b -= self.lr * db

# 训练函数 其实都是调用之前写好的函数了
def train(model, X, Y, epochs):
    losses = []
 # epochs ： 训练轮次
    for i in range(epochs):
        inds = list(range(X.shape[0]))
        np.random.shuffle(inds) # 打乱顺序 ： 随机梯度下降
        loss = 0
      
        for ind in inds:
        # 从输入矩阵里面 取出来一个样本
            x = X[ind] 
            y = Y[ind]
            
            pred_y = model.forward(x)
            
            #累计loss 
            loss += mse(pred_y, y) 
                        
            dw, db = model.backward(pred_y, y, x)
            model.step(dw, db)
        
        # 输出每一轮的loss 可以观察到每一轮数值都在下降
        print("epoch{}, loss = {}".format(i, loss / X.shape[0]))
        
        losses.append(loss)
    
    return losses


# 观察一下训练的结果 输入的是准确率
def test(model, X, Y):
    correct_cnt = 0
    for i in range(X.shape[0]):
        x = X[I]
        y = Y[I]
        pred_y = model.forward(x)
        
        pred_y = 1 if pred_y > 0.5 else 0
        
        correct_cnt += (y == pred_y)
    
    return correct_cnt / X.shape[0]

n = 10000    #样本维数
input_size = 5 
epochs = 500

#初始化w,b
w = np.random.randn(input_size)
b = np.random.randn(1)

# model 实例
true_lr = LogisticRegression(input_size, 0.001)
true_lr.w = w
true_lr.b = b


# 随机生成的数据 这样生成的数据是服从正态分布的
X = [np.random.randn(input_size) for i in range(n)]
Y = [1 if true_lr.forward(X[i]) > 0.5 else 0 for i in range(n)]
X = np.array(X)
Y = np.array(Y)

lr = LogisticRegression(input_size, 0.01)

# 激动人心的时刻！！ 让我们开始训练吧！干巴爹
losses = train(lr, X, Y, epochs)

#让我们欣赏一下 自己的杰作 （画个图 看看）
import matplotlib.pyplot as plt
plt.plot(range(epochs), losses)

#测试一下看看
test_X = [np.random.randn(input_size) for i in range(n)]
test_Y = [1 if true_lr.forward(X[i]) > 0.5 else 0 for i in range(n)]
test_X = np.array(test_X)
test_Y = np.array(test_Y)

test(lr, test_X, test_Y)

哈哈哈 ！ 我很满意！