Aprendizaje automático: modelo de perceptrón (código manual)

El perceptrón debería ser un modelo muy simple.

1. Construyendo un modelo

El modelo del perceptrón es un modelo de clasificación binaria de regresión lineal múltiple + función de símbolo .
Función de regresión lineal múltiple : 【Z = ${W.}^{T}X$]
función de signo:

• y = signo(Z) = 1, cuando Z>=0
• y = signo(Z) = -1 cuando Z<0

Esta función de signo en realidad juzga la categoría según si el valor de la función de la regresión lineal múltiple es mayor que 0.
En el programa, puedes usar if directamente para juzgar, es decir

if Z>=0: y = 1
else: y = -1
"""太简单了吧"""

2. Modelo de aprendizaje

2.1 Seleccionar función de pérdida

El perceptrón es una clasificación binaria y la clasificación tiene las siguientes cuatro situaciones
cuando el valor lineal multivariado Z ≥ 0:

• ①Clasificación correcta: cuando la categoría y de los datos reales también es 1, entonces y*Z > 0
• ②Error de clasificación: cuando la categoría y de los datos reales es -1, entonces y*Z<0
  cuando el valor lineal multivariado Z <0:
• ①Clasificación correcta: cuando la categoría y de los datos reales también es -1, entonces y*Z > 0
• ②Error de clasificación: cuando la categoría y de los datos reales es 1, entonces y*Z <0

en resumen,

• Cuando la clasificación es incorrecta, y Z es <0, entonces debemos hacer que y Z sea lo más grande posible, es decir, -y * Z lo más pequeño posible.
• Cuando la clasificación es correcta, y Z es > 0, entonces debemos hacer que y Z sea lo más grande posible, es decir, -y*Z lo más pequeño posible.

Por lo tanto, -y * Z se puede utilizar como función de pérdida, y encontrar el valor mínimo de la función de pérdida puede hacer que el modelo de perceptrón sea lo más óptimo posible [pero, de hecho, se calcula por
la distancia desde el punto al hiperplano, y el punto al hiperplano La fórmula para derivar la distancia ]

$pérdida\_=-y\ast z=-y\ast (anchox+segundo)=-{Sí}^T\left(X{W}^t\right)$

2.2 Método de optimización de la función de pérdida

2.2.3 Método de descenso de gradiente

${W.}_{k+}={W.}_{}-el\ast \frac{d(pérdida}{reW)\_}$

$\frac{d(pérdida}{reW)\_}=Y^{T}X$——————no，不是这样的！！！

El perceptrón está algo roto por fuerza bruta: verifica qué valores están mal clasificados uno por uno e inmediatamente corrige el parámetro W hasta que el valor se clasifica correctamente, luego continúa encontrando el valor mal clasificado y continúa corrigiendo el parámetro W. .hasta que uno por uno Después de confirmar que cada valor categórico esté clasificado correctamente, habrá terminado.

Por lo tanto, el gradiente no es el gradiente calculado por todos los datos, sino el gradiente de parámetros de los datos clasificados incorrectamente.

$gradien\_=-y_{}\ast X_{}$
yi y_i aquí$y_{}$es el valor de clasificación real (-1 o 1), $X_{}$es el factor que afecta el valor $(x_{},X_{}...x_{})$ - equivalente a un dato mal clasificado

Por lo tanto, cuando la clasificación es incorrecta (es decir, $y_{}\ast X_{}<0),W_{k+}={W.}_{}-el\ast gradiente\_\_\_\_\_\_\_$

2.3 Implementación de código (comparación manual con sklearn)

from sklearn import linear_model
import pandas as pd
import numpy as np
import time
# 获取所需数据：'推荐分值', '推荐类型'
datas = pd.read_excel('./datas_perception.xlsx')
important_features = ['推荐分值', '推荐类型']
datas_1 = datas[important_features]


# 明确实际类别Y为'推荐类型'，X为'推荐分值'
Y_original = datas_1['推荐类型']
# Y 转为独热编码

Y = np.where(Y_original=='低推荐',1,-1)
X_original = datas_1.drop('推荐类型',axis=1)
rows,columns = X_original.shape

X_0 = np.ones((rows,1))
X = np.concatenate((X_0,X_original),axis=1)



def perception_inhand():
    W0 = np.ones(columns + 1)
    jump = 1
    a = 0.001  # 设置学习率a
    times = 10000000
    num = 0
    num_round = 1
    while jump and num_round<times:
        for i in range(rows):
            mistake = Y[i]*np.matmul(X[i,:],W0.T)
            while mistake < 0 and num<times:
                # print(f"迭代{num + 1}次，该点的分类结果值为{mistake}，参数W为{W0}")
                gradient = -(Y[i]*X[i,:])
                W = W0-a*gradient
                mistake = Y[i] * np.matmul(X[i, :], W.T)
                num += 1
                # print(f"调整后为，该点的分类结果值为{mistake},调整后参数W为{W}")
                W0 = W
                if mistake >= 0:
                    break

            # print(f"第{i+1}个分类正确")
        # 检查是否全部分类正确：实际无需检查的，因为有凸函数梯度是下降的，这个有相应的证明
        jump = 0
        for i in range(rows):
            mistake = Y[i] * np.matmul(X[i, :], W0.T)
            if mistake<0:
                jump = 1
                print(f"______第{
      
      num_round}轮迭代，第{
      
      i}个值分类错误_______")
                break

        num_round += 1
    print("——————————手动：感知机分类器——————————")

    print(f"最终完全分类，模型参数W为{
      
      W}\n")



# sklearn的梯度下降分类器
def perception_sklearn():
    # 1. 建立模型：随机梯度下降分类模型
    classifier = linear_model.Perceptron()

    # 2. 学习模型
    classifier.fit(X_original,Y)
    Y_hat = classifier.predict(X_original) # 模型分类
    labels = classifier.classes_ # 获取分类标签
    w = classifier.coef_ # 获取参数 W
    b = classifier.intercept_ # 获取偏差b，或称W0
    print("——————————sklearn：感知机分类器——————————")
    print(f'模型参数W为：{
      
      w}')

    # 3. 衡量模型
    accurency = classifier.score(X_original,Y_hat)
    print(f"预测准确率：{
      
      accurency*100}%")

perception_inhand()
perception_sklearn()

2.4 Forma dual del perceptrón

En la forma dual, la esencia es la misma que la forma anterior.

La única diferencia es que la actualización de los parámetros en forma dual durante la iteración es la actualización del número de iteraciones para los datos mal clasificados.

Cuando un dato es un punto mal clasificado, realizaremos actualizaciones iterativas paso a paso. La tasa de aprendizaje η de cada actualización iterativa es fija y el gradiente de la actualización iterativa en realidad es fijo yi ∗ xi y_i* $y_{}\ast X_{}$, por lo que la magnitud Δw de cada iteración también es fija.

Esto aparecerá, a veces un dato mal clasificado necesita múltiples iteraciones (por ejemplo, n veces) para que la clasificación sea correcta.

Luego, en la forma dual, el número de iteraciones n también se incluye en la categoría de iteraciones. ——[No hay explicación específica, porque el proceso de iteración real es similar al anterior]