4. Perceptron

1. Perceptron

El perceptrón es un modelo de clasificación lineal de dos clases. Hasta donde yo lo entiendo, encuentre un hiperplano similar a la "regresión lineal", divida todas las instancias en dos categorías y use el algoritmo de optimización del descenso de gradiente para minimizar los puntos de clasificación errónea. Cuanto más cerca del hiperplano esté el punto de clasificación errónea, menor será el valor de pérdida .

1.1 Modelo de perceptrón

Donde $sign$ función simbólica, es decir, el

modelo de perceptrón puede convertir primero$w\ast X+b\; se$ considera un modelo lineal, donde w es el vector de ponderación y b es el sesgo. Luego sustituya el resultado de la salida del modelo lineal en el$En\; la$ función simbólica$si$$g$$n$ , se emite la categoría correspondiente.

1.2 Estrategias de aprendizaje

Función de pérdida : punto mal clasificado al hiperplano ( $wx+si=0$ ) distancia total.

Entonces, la distancia desde cualquier punto al hiperplano es:

Donde $||w||$ es$w$ es$l_2$Norma.

Porque, para el punto de clasificación errónea:

Por lo tanto, la distancia desde cualquier punto mal clasificado hasta el hiperplano es:

Entonces, la distancia total desde todos los puntos mal clasificados hasta el hiperplano es:

Aquí no consideramos $\frac{1}{||w||}$, Entonces obtuvimos la función de pérdida

que necesitamos : Por lo tanto, debemos minimizar la función de pérdida y usar el descenso de gradiente para obtener los parámetros óptimos requeridos por el modelo.

2. Modo primitivo de perceptrón

No se hablará mucho de los detalles del descenso del gradiente. Aquí necesitamos minimizar el valor de la función de pérdida del modelo para obtener los parámetros del modelo "w, b". Entonces solo necesitamos obtener la derivada parcial de la fórmula de la función de pérdida, y luego de acuerdo con el descenso del gradiente y lo siguiente El algoritmo encuentra los parámetros óptimos del modelo.

2.1 La implementación del algoritmo de modo original

# 感知机算法实现
import numpy as np
import time
# 定义时间装饰器
def timmer(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res = func(*args, **kwargs)
        stop_time = time.time()
        print('Func %s,run time :%s' %(func.__name__,stop_time-start_time))
        return res
    return wrapper

class Perceptron:
    def __init__(self):
        self.weights=None
        self.bias=None

    def sign(self,value):
        return 1 if value>=0 else -1
    @timmer
    def train(self,dataSet,labels,iter=50):
        # 学习率
        lr=0.9
        dataSet = np.array(dataSet)
        n,m = np.shape(dataSet)

        # 初始化参数
        w = np.zeros(m)
        b=0

        # 迭代
        for k in range(iter):
            print("Round{0}:{1}".format(k,iter))
            # 使用随机梯度下降
            for i in range(n):
                if (-labels[i]*self.sign(np.dot(w,dataSet[i])+b)>=0):
                    w=w+lr*labels[i]*dataSet[i]
                    b=b+lr*labels[i]
        self.weights=w
        self.bias=b

    def predict(self, data):
        if (self.weights is not None and self.bias is not None):
            return self.sign(np.dot(self.weights, data) + self.bias)
        else:
            return 0

if __name__ == '__main__':
    data_set = [[3, 3],
                [4, 3],
                [1, 1]]
    labels = [1, 1, -1]

    perceptron = Perceptron()
    perceptron.train(data_set, labels,30)
    print("weights is:", perceptron.weights)
    print("bias is:", perceptron.bias)
    result = perceptron.predict([3, 3])
    print("prediction:", result)