Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Olá a todos, sou Wei Xue AI. Hoje apresentarei a vocês a explicação detalhada da base e do código da rede neural do Curso 8-Rede Neural PyTorch do Engenheiro de Algoritmo de Inteligência Artificial (Intermediário). A rede neural é um modelo de computação que imita a conexão dos neurônios no cérebro humano e é amplamente utilizada no reconhecimento de imagens, processamento de linguagem natural e outras áreas. Este artigo apresentará o conceito, estrutura, amostras, treinamento e avaliação de redes neurais, juntamente com código executável completo.

Explicação detalhada dos fundamentos e código da rede neural

1. Conceito de rede neural

Uma rede neural consiste em um grande número de nós (ou neurônios) e nas arestas que conectam esses nós. Cada nó representa um neurônio e cada aresta representa uma conexão entre neurônios. A principal função da rede neural é extrair informações úteis dos dados por meio de soma ponderada e transformação não linear dos dados de entrada.

2. Estrutura da rede neural

As redes neurais são geralmente divididas em camada de entrada, camada oculta e camada de saída. A camada de entrada recebe dados externos, a camada oculta processa os dados e a camada de saída produz o resultado final. Os nós de cada camada são conectados aos nós da próxima camada e cada conexão tem um peso correspondente.

2.1 Fórmula de cálculo da rede neural

A saída da rede neural pode ser calculada pela seguinte fórmula:
$$a^{(eu)}=e({por}^{(eu)})$$
$${por}^{(eu)}=c^{(eu)}{a}^{(eu-1)}+b^{(eu)}$$
em,$a^{(eu)}$ Indica o primeiro$eu$ A saída da camada,${por}^{(eu)}$ Indica o primeiro$eu$ O resultado da soma ponderada das camadas,$c^{(eu)}$ e$b^{(eu)}$ Representar respectivamente o$eu$ pesos e vieses da camada,$e(\cdot )$ representa a função de ativação.

2.2 Código executável

Aqui está um exemplo de uma estrutura de rede neural simples:

import numpy as np
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
def feedforward(X, weights, biases):
    a = X
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        a = sigmoid(z)
    return a
# 定义输入数据
X = np.array([[1, 2], [3, 4]])
# 定义权重和偏置
weights = [np.array([[0.1, 0.2], [0.3, 0.4]]), np.array([[0.5], [0.6]])]
biases = [np.array([0.1, 0.2]), np.array([0.3])]
# 计算输出
output = feedforward(X, weights, biases)
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. Amostra de rede neural

Uma amostra de uma rede neural inclui dados de entrada e rótulos correspondentes. Durante o processo de treinamento, a rede neural ajusta continuamente os pesos e as tendências para tornar a saída o mais próximo possível do rótulo.

3.1 Função de perda

O objetivo do treinamento das redes neurais é minimizar a função de perda. As funções de perda comumente usadas incluem erro quadrático médio (MSE) e perda de entropia cruzada. A fórmula para o erro quadrático médio é a seguinte:
$$Eu(c,b)=\frac{1}{2eu}\sum _{eu=1}^{eu}(e^{(eu)}-a^{(eu)}{)}^2$$
em,$eu$ representa o número de amostras,$e^{(eu)}$ e$a^{(eu)}$ Representar respectivamente o$eu$ rótulos e valores previstos de amostras.

3.2 Código executável

Aqui está um exemplo simples de geração de amostra e cálculo de perda:

import numpy as np
def mse_loss(y_true, y_pred):
    return np.mean((y_true - y_pred) ** 2)
# 定义标签
y_true = np.array([[1], [0]])
# 计算损失
loss = mse_loss(y_true, output)
print(loss)
1
2
3
4
5
6
7
8

4. Treinamento de redes neurais

O processo de treinamento da rede neural inclui propagação direta e retropropagação. A propagação direta calcula a saída da rede neural e a retropropagação calcula o gradiente da função de perda em relação aos pesos e desvios e atualiza os pesos e desvios.

4.1 Retropropagação

O algoritmo de retropropagação calcula gradientes por meio da regra da cadeia.Pela primeira vez$eu$ peso da camada$c^{(eu)}$, seu gradiente pode ser expresso como:
$$\frac{\partial Eu}{\partial c^{(eu)}}=a^{(eu-1)}\cdot (e^{\prime }({por}^{(eu)})\cdot {\delta }^{(eu)})$$
em,${\delta }^{(eu)}$ Indica o primeiro$eu$ erro de camada,$e^{\prime }(\cdot )$ representa a derivada da função de ativação.

4.2 Código para treinamento de redes neurais

Aqui está um exemplo simples de treinamento de rede neural:

import numpy as np
def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))
def backpropagation(X, y_true, weights, biases):
    gradients_w = [np.zeros(w.shape) for w in weights]
    gradients_b = [np.zeros(b.shape) for b in biases]
    # 前向传播
    a = X
    activations = [a]
    zs = []
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        zs.append(z)
        a = sigmoid(z)
        activations.append(a)
    # 计算输出层误差
    delta = activations[-1] - y_true
    gradients_b[-1] = delta
    gradients_w[-1] = np.dot(activations[-2].T, delta)
    # 反向传播
    for l in range(2, len(weights) + 1):
        z = zs[-l]
        sp = sigmoid_derivative(z)
        delta = np.dot(delta, weights[-l + 1].T) * sp
        gradients_b[-l] = delta
        gradients_w[-l] = np.dot(activations[-l - 1].T, delta)
    return gradients_w, gradients_b
# 定义学习率
learning_rate = 0.1
# 进行一次梯度下降
gradients_w, gradients_b = backpropagation(X, y_true, weights, biases)
# 更新权重和偏置
for w, grad_w in zip(weights, gradients_w):
    w -= learning_rate * grad_w
for b, grad_b in zip(biases, gradients_b):
    b -= learning_rate * grad_b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

5. Avaliação de Redes Neurais

A avaliação de redes neurais geralmente é feita calculando o valor da precisão ou da função de perda no conjunto de teste. A precisão refere-se à razão entre o número de amostras previstas corretamente pelo modelo e o número total de amostras.

5.1 Precisão

A fórmula de cálculo para precisão é a seguinte:
$$\text{Precisão}=\frac{\text{Número de previsões corretas}}{\text{Número total de previsões}}$$

5.2 Implementação do código

Aqui está um exemplo simples de avaliação de rede neural:

def predict(X, weights, biases):
    a = X
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        a = sigmoid(z)
    return np.round(a)
# 定义测试数据
X_test = np.array([[2, 3], [4, 5]])
# 进行预测
predictions = predict(X_test, weights, biases)
print(predictions)
# 计算准确率
y_test = np.array([[1], [0]])
accuracy = np.mean(predictions == y_test)
print("Accuracy:", accuracy)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Resumir

Neste artigo, implementamos uma rede neural simples, incluindo propagação direta, retropropagação, gradiente descendente e processo de avaliação. Embora esta rede seja simples, ela demonstra os princípios básicos e métodos de implementação das redes neurais. Em aplicações práticas, a estrutura das redes neurais será mais complexa, envolvendo mais camadas e nós, além de algoritmos de otimização e técnicas de regularização mais avançados. Além disso, estruturas modernas de aprendizagem profunda (como TensorFlow e PyTorch) fornecem implementação mais eficiente e funções de diferenciação automática, tornando a construção e o treinamento de redes neurais mais convenientes.