demostración de cúpula de regresión logística

¡Acostúmbrate a escribir juntos! Este es el día 18 de mi participación en el "Nuevo plan diario de Nuggets · Desafío de actualización de abril", haga clic para ver los detalles del evento .

prefacio

¿Qué puede hacer la regresión logística?

Antes de comenzar, aclaremos qué puede hacer la regresión logística. En primer lugar, esta cosa usa el método de descenso de gradiente para corregirlo. Todo el proceso, el proceso de regresión logística es similar a una pequeña red neuronal. Este material se usa principalmente para problemas de clasificación binaria.

Para conocer teorías relacionadas, consulte: Detalles del modelo de regresión logística (Regresión logística) No haré demasiada exploración teórica aquí.

criterios de juicio

Las palabras aquí se basan principalmente en el combate real. Cómo jugar un domo de regresión logística súper simple a mano para demostrar el flujo de trabajo de la red neuronal. Esta inspiración aún proviene de este hermano mayor: BoyC (Old Scroll King: ¡Preferiría morir de agotamiento que matar al viejo despiadado de otra persona!)

La primera es la función de pérdida. largo así.

donde y^ es su valor predicho e y es el valor real. Dado que es un problema de dos clases, al ajustar y calcular la pérdida para la etiqueta 0, cuanto más se acerque el valor de pérdida a 1, mejor. Al ajustar la etiqueta 1, cuanto más cerca a 0, mejor, por lo que la pérdida total valor, cuanto más cerca de 0,5, mejor. Esto se deriva principalmente de su teoría, la conclusión que mencioné directamente aquí.

Luego está la función de predicción.

En nuestra publicación de blog de hoy, lo que estamos haciendo es una clasificación binaria simple, hay diez conjuntos de datos, echemos un vistazo al último efecto:

Por supuesto, aquí, mi cálculo de pérdida sigue siendo un poco problemático, generalmente así, puede considerar la optimización más adelante.

La función directa, en este caso, se llama más apropiadamente función de red, que es así.

def Net(X):
    X = X.T * W
    X = np.sum(X) +B
    X = sigmod(X)
    if(X>=1):
        X = X-0.0001
    elif(X<=0):
        X = X + 0.0001
    return X

复制代码

El motivo del +- 0.0001 aquí es que después del procesamiento sigmod aquí, si un cierto valor está muy cerca de 1 o 0, se tomará como 1 o 0, pero esto no está permitido. Sólo se puede tratar de manera especial. Entonces toda la estructura de la red se ve así. Entonces puedes ver por qué esa función Net es así.

conjunto de datos

En nuestro domo, nuestro conjunto de datos se ve así.

X_train  = np.linspace(1,20,20).reshape((10,2))
classes = ["小猫","小狗"]
Labels = {"小猫":0,"小狗":1}
Y_train = np.array([Labels["小猫"],Labels["小狗"]])
复制代码

estrategia de entrenamiento

之后咱们来说说咱们的这个训练策略。 首先，咱们的这个数据是一行一行输入进去的，前5组属于0标签，后5组属于1标签。之后，为了模拟这个神经网络的batch_size 所以，我这里还干脆在每一轮训练的时候，每进去5组，5组计算完了之后，我再去进行梯度下降，更新权重，每一次计算，我先把所有的梯度加起来，然后后面求平均值然后去更新。（我们现在模拟的是非常简答的网络结构，对于复杂的，我们就需要单独记录梯度然后去更新，这样如果每进去一组我就更新梯度的话是会浪费很多时间的）

梯度更新

这里的话通过求导，我们最后可以发现这个 W1 的 梯度会等于 （当前预测值-实际值）* 当前对于的X1 然后，这里的话，我们既然使用了矩阵，那么我这里更新的时候，直接使用矩阵更新。

同样的，这个B 的话，就是直接 等于 （当前预测值-实际值） 由于我们 是 5 轮 更新一次嘛，所以都要先求个总和然后取平均值。

编码

前面都说的差不多了，那么我们就可以直接进行编码了。 这里由于使用的是梯度下降法，所以的话，我们这里的学习率就是Lr取0.00025 为什么取那么小，因为这个范围0-1本来就很小，参数变化很敏感，梯度下降嘛，容易出现那么几种情况，要么步子太大了过去了，要么就步子太小在局部出不来了，所以那个Lr其实是不太好设置的，在我们实际使用Pytroch的时候，其实我们使用的优化器的那个Lr是动态更新的。但是咱们这里模拟就不搞那么多花里胡哨的了。而且这个我们这里是100轮训练，那个Lr还是我自己调出来的，实际上做的时候，那个参数是作为超参数自适应的。

import numpy as np
import math
X_train  = np.linspace(1,20,20).reshape((10,2))
classes = ["小猫","小狗"]
Labels = {"小猫":0,"小狗":1}
Y_train = np.array([Labels["小猫"],Labels["小狗"]])

W = np.random.randint(0,1,(2,1))
#划分，2个特征决定0,1,一共十组，这十组前五组为0，后五组为1
#对1类的拟合，是越接近0越好，对于0类的拟合是越接近1越好，
# 对于损失函数，也就是说，总体的损失函数是越接近0.5越好

B = 0
m = 5
def sigmod(X):
    return 1/(1+np.exp(-X))

def com_grad(X,Y_,Y_T):
    #返回的是一个
    #   w1
    # {    } 的向量
    #   w2
    W_ = (X.T)*(Y_ - Y_T)
    #计算梯度

    return W_

def Net(X):
    X = X.T * W
    X = np.sum(X) +B
    X = sigmod(X)
    if(X>=1):
        X = X-0.0001
    elif(X<=0):
        X = X + 0.0001
    return X

def loss(pred,Y_t):

    loss_ = -Y_t * math.log(pred) - (1-Y_t)*math.log(1-pred)
    return loss_

ecpho = 100
Lr = 0.000025
for e in range(ecpho):
    Y_T = None
    B_run = 0
    Pred_total = 0
    W_Z = np.zeros((2,1)) # m个运算之后的总的W
    Loss_Total = 0

    loss_y1_y2 = 0 #这个是针对那个不同的Y的损失
    for i in range(len(X_train)):
        X_ = X_train[i]
        pred = Net(X_)
        if((i+1)<=5):
            Y_T = Y_train[0]
        else:
            Y_T = Y_train[1]
        loss_now = loss(pred,Y_T)
        Loss_Total+=loss_now
        loss_y1_y2+= loss_now
        w_c = com_grad(X_,pred,Y_T)
        w_c = w_c.reshape(2,1)
        W_Z+=w_c
        B_run+=(pred-Y_T)
        Pred_total +=pred
        if((i+1)%m==0):
            W_Z = W_Z /m
            B = B_run/m
            W = W - W_Z*Lr
            print("第{}次训练对--{}--标签拟合的平均损失为{}".format(e + 1,Y_T,loss_y1_y2 / m))
            #我们是每m次更新一次，所以更新完之后都要重新刷新
            B_run = 0
            loss_y1_y2 = 0
            W_Z = np.zeros([2, 1])  # m个运算之后的总的W
    print("第{}次训练的平均损失为{}".format(e+1,Loss_Total/10))



# 预测部分，在我们的那个数据里面，前面5个是标签1，后面是0，分别对应不同的类别
inx = 1
for i in X_train:
    P = Net(i)
    if(P<0.5):
        print("第{}组预测为：{}".format(inx,classes[0]))
    else:
        print("第{}组预测为：{}".format(inx, classes[1]))
    inx+=1
复制代码

看大上面后面的写法，有没有发现和我先前写的那个HuClassfiy分类器有那么点类似。 最后效果是这样的

你改一下学习率，例如Lr=0.001

Esto es aleatorio. Por supuesto, esto también está determinado por muchos factores. En algunos casos, la correlación de algunos parámetros es muy pobre y es difícil de ajustar, por lo que este efecto es inevitable. En este caso, todavía determinamos una categoría con dos características. Por ejemplo, el número 1 y 2 en el conjunto de datos determina en conjunto que es una categoría 0, que corresponde a un gatito. Por supuesto, la cúpula anterior todavía tiene muchas deficiencias.