Crie e treine redes neurais do zero

Visão geral

Muito conhecimento teórico já foi dito antes, agora é hora de começar a prática. Vamos tentar construir uma rede neural do zero e treiná-la para encadear todo o processo.

Para ser mais intuitivo e fácil de entender, seguimos os seguintes princípios:

1. Não use bibliotecas de terceiros para simplificar a lógica;
2. Sem otimização de desempenho: evite introduzir conceitos e técnicas adicionais, aumentando a complexidade;

Conjunto de dados

Primeiro, precisamos de um conjunto de dados. Para facilitar a visualização, usamos uma função binária como função objetivo e, em seguida, geramos o conjunto de dados por amostragem nele.

Observação: em projetos de engenharia reais, a função objetivo é desconhecida, mas podemos fazer uma amostra nela.

Função objetiva

$$o(x, y) = \begin{cases} 1 & x^2 + y^2 < 1 \\ 0 & \text{otherwise}\end{cases}$$

Código mostrar como abaixo:

def o(x, y):
    return 1.0 if x*x + y*y < 1 else 0.0

Gerar conjunto de dados

sample_density = 10
xs = [
    [-2.0 + 4 * x/sample_density, -2.0 + 4 * y/sample_density]
    for x in range(sample_density+1)
    for y in range(sample_density+1)
]
dataset = [
    (x, y, o(x, y))
    for x, y in xs
]

O conjunto de dados gerado é: [[-2.0, -2.0, 0.0], [-2.0, -1.6, 0.0], ...]

Construir uma rede neural

Função de ativação

import math

def sigmoid(x):
    return 1 / (1 + math.exp(-x))

Neurônio

from random import seed, random

seed(0)

class Neuron:
    def __init__(self, num_inputs):
        self.weights = [random()-0.5 for _ in range(num_inputs)]
        self.bias = 0.0

    def forward(self, inputs):
        # z = wx + b
        z = sum([
            i * w
            for i, w in zip(inputs, self.weights)
        ]) + self.bias
        return sigmoid(z)

A expressão do neurônio é:

$$\text{sigmoid}(\mathbf w \mathbf x + b)$$

• $\mathbf w$: vetor, correspondente ao array de pesos no código
• $b$: corresponde ao viés no código

Nota: Os parâmetros no neurônio são inicializados aleatoriamente. No entanto, para garantir experimentos reproduzíveis, uma semente aleatória é definida(seed(0))

Redes neurais

class MyNet:
    def __init__(self, num_inputs, hidden_shapes):
        layer_shapes = hidden_shapes + [1]
        input_shapes = [num_inputs] + hidden_shapes
        self.layers = [
            [
                Neuron(pre_layer_size)
                for _ in range(layer_size)
            ]
            for layer_size, pre_layer_size in zip(layer_shapes, input_shapes)
        ]

    def forward(self, inputs):
        for layer in self.layers:
            inputs = [
                neuron.forward(inputs)
                for neuron in layer
            ]
        # return the output of the last neuron
        return inputs[0]

Construa uma rede neural da seguinte forma:

net = MyNet(2, [4])

Neste ponto, temos uma rede neural (rede), que pode chamar sua função de rede neural:

print(net.forward([0, 0]))

Obtenha o valor da função 0,55..., a rede neural neste momento é uma rede não treinada.

Treine a rede neural

Função de perda

Primeiro defina uma função de perda:

def square_loss(predict, target):
    return (predict-target)**2

Calcular o gradiente

O cálculo do gradiente é complicado, especialmente para redes neurais profundas. Back Propagation Algorithm é um algoritmo projetado especificamente para calcular o gradiente de uma rede neural.

Devido à sua complexidade, não será descrito aqui. Os interessados ​​podem consultar o código detalhado a seguir. Além disso, o atual framework de deep learning tem a função de calcular automaticamente o gradiente.

Defina a função derivada:

def sigmoid_derivative(x):
    _output = sigmoid(x)
    return _output * (1 - _output)

def square_loss_derivative(predict, target):
    return 2 * (predict-target)

Encontre a derivada parcial (parte dos dados é armazenada em cache na função forward para facilitar a derivada):

class Neuron:
    ...

    def forward(self, inputs):
        self.inputs_cache = inputs

        # z = wx + b
        self.z_cache = sum([
            i * w
            for i, w in zip(inputs, self.weights)
        ]) + self.bias
        return sigmoid(self.z_cache)

    def zero_grad(self):
        self.d_weights = [0.0 for w in self.weights]
        self.d_bias = 0.0

    def backward(self, d_a):
        d_loss_z = d_a * sigmoid_derivative(self.z_cache)
        self.d_bias += d_loss_z
        for i in range(len(self.inputs_cache)):
            self.d_weights[i] += d_loss_z * self.inputs_cache[i]
        return [d_loss_z * w for w in self.weights]


class MyNet:
    ...

    def zero_grad(self):
        for layer in self.layers:
            for neuron in layer:
                neuron.zero_grad()

    def backward(self, d_loss):
        d_as = [d_loss]
        for layer in reversed(self.layers):
            da_list = [
                neuron.backward(d_a)
                for neuron, d_a in zip(layer, d_as)
            ]
            d_as = [sum(da) for da in zip(*da_list)]

• Derivadas parciais são armazenadas em d_weights e d_bias respectivamente
• A função zero_grad é usada para limpar o gradiente, incluindo cada derivada parcial
• A função backward é usada para calcular a derivada parcial e armazenar seu valor cumulativamente

Atualizar parâmetros

Use o método de descida de gradiente para atualizar os parâmetros:

class Neuron:
    ...

    def update_params(self, learning_rate):
        self.bias -= learning_rate * self.d_bias
        for i in range(len(self.weights)):
            self.weights[i] -= learning_rate * self.d_weights[i]


class MyNet:
    ...

    def update_params(self, learning_rate):
        for layer in self.layers:
            for neuron in layer:
                neuron.update_params(learning_rate)

Realize o treinamento

def one_step(learning_rate):
    net.zero_grad()

    loss = 0.0
    num_samples = len(dataset)
    for x, y, z in dataset:
        predict = net.forward([x, y])
        loss += square_loss(predict, z)

        net.backward(square_loss_derivative(predict, z) / num_samples)

    net.update_params(learning_rate)
    return loss / num_samples


def train(epoch, learning_rate):
    for i in range(epoch):
        loss = one_step(learning_rate)
        if i == 0 or (i+1) % 100 == 0:
            print(f"{i+1} {loss:.4f}")

Treinamento 2000 passos:

train(2000, learning_rate=10)

Observação: uma taxa de aprendizado relativamente grande é usada aqui, relacionada à situação do projeto. A taxa de aprendizado em projetos reais geralmente é muito pequena

$\text{log y}$

Inferência

Após o treinamento, o modelo pode ser usado para inferência:

def inference(x, y):
    return net.forward([x, y])

print(inference(1, 2))

Consulte o código completo:nn_from_scratch.py

Resumo

Os passos desta prática são os seguintes:

1. Construa uma função objetivo virtual: $o(x, y)$;
2. Amostragem em $o(x, y)$ para obter o conjunto de dados, ou seja, a função do conjunto de dados: $d(x, y)$
3. Construiu uma rede neural totalmente conectada com uma camada oculta, ou seja, função de rede neural: $f(x, y)$
4. Use o método de gradiente descendente para treinar a rede neural para que $f(x, y)$ se aproxime de $d(x, y)$

A parte mais complicada é encontrar o gradiente, que usa o algoritmo de retropropagação. Em projetos reais, o uso de estruturas convencionais de aprendizado profundo para desenvolvimento pode salvar o código para gradientes e diminuir o limite.

Nos experimentos de classificação 3D do laboratório, o segundo conjunto de dados é muito semelhante ao desta prática, então você pode entrar e operá-lo.