Comment utiliser PyTorch pour la formation aux réseaux neuronaux-Tutoriel Python-php.cn

Comment utiliser PyTorch pour la formation aux réseaux neuronaux

Introduction :
PyTorch est un framework d'apprentissage automatique open source basé sur Python. Sa flexibilité et sa simplicité en font le premier choix de nombreux chercheurs et ingénieurs. Cet article vous expliquera comment utiliser PyTorch pour la formation des réseaux neuronaux et fournira des exemples de code correspondants.

1. Installez PyTorch
Avant de commencer, vous devez d'abord installer PyTorch. Vous pouvez choisir la version adaptée à votre système d'exploitation et à votre matériel à installer via le guide d'installation fourni sur le site officiel (https://pytorch.org/). Une fois installée, vous pouvez importer la bibliothèque PyTorch en Python et commencer à écrire du code.

2. Créer un modèle de réseau neuronal
Avant d'utiliser PyTorch pour former un réseau neuronal, vous devez d'abord créer un modèle approprié. PyTorch fournit une classe appelée torch.nn.Module, dont vous pouvez hériter pour définir votre propre modèle de réseau neuronal. torch.nn.Module的类，您可以通过继承该类来定义自己的神经网络模型。

下面是一个简单的例子，展示了如何使用PyTorch构建一个包含两个全连接层的神经网络模型：

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(in_features=784, out_features=256)
        self.fc2 = nn.Linear(in_features=256, out_features=10)
    
    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        x = torch.relu(x)
        x = self.fc2(x)
        return x

net = Net()

Copier après la connexion

在上面的代码中，我们首先定义了一个名为Net的类，并继承了torch.nn.Module类。在__init__方法中，我们定义了两个全连接层fc1和fc2。然后，我们通过forward方法定义了数据在模型中前向传播的过程。最后，我们创建了一个Net的实例。

三、定义损失函数和优化器
在进行训练之前，我们需要定义损失函数和优化器。PyTorch提供了丰富的损失函数和优化器的选择，可以根据具体情况进行选择。

下面是一个示例，展示了如何定义一个使用交叉熵损失函数和随机梯度下降优化器的训练过程：

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=0.01)

Copier après la connexion

在上面的代码中，我们将交叉熵损失函数和随机梯度下降优化器分别赋值给了loss_fn和optimizer变量。net.parameters()表示我们要优化神经网络模型中的所有可学习参数，lr参数表示学习率。

四、准备数据集
在进行神经网络训练之前，我们需要准备好训练数据集和测试数据集。PyTorch提供了一些实用的工具类，可以帮助我们加载和预处理数据集。

下面是一个示例，展示了如何加载MNIST手写数字数据集并进行预处理：

import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,)),
])

train_set = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=32, shuffle=True)

test_set = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=False)

Copier après la connexion

在上面的代码中，我们首先定义了一个transform变量，用于对数据进行预处理。然后，我们使用torchvision.datasets.MNIST类加载MNIST数据集，并使用train=True和train=False参数指定了训练数据集和测试数据集。最后，我们使用torch.utils.data.DataLoader类将数据集转换成一个可以迭代的数据加载器。

五、开始训练
准备好数据集后，我们就可以开始进行神经网络的训练。在一个训练循环中，我们需要依次完成以下步骤：将输入数据输入到模型中，计算损失函数，反向传播更新梯度，优化模型。

下面是一个示例，展示了如何使用PyTorch进行神经网络训练：

for epoch in range(epochs):
    running_loss = 0.0
    for i, data in enumerate(train_loader):
        inputs, labels = data
        
        optimizer.zero_grad()
        
        outputs = net(inputs)
        loss = loss_fn(outputs, labels)
        
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        
        if (i+1) % 100 == 0:
            print('[%d, %5d] loss: %.3f' % (epoch+1, i+1, running_loss/100))
            running_loss = 0.0

Copier après la connexion

在上面的代码中，我们首先使用enumerate函数遍历了训练数据加载器，得到了输入数据和标签。然后，我们将梯度清零，将输入数据输入到模型中，计算预测结果和损失函数。接着，我们通过backward方法计算梯度，再通过step方法更新模型参数。最后，我们累加损失，并根据需要进行打印。

六、测试模型
训练完成后，我们还需要测试模型的性能。我们可以通过计算模型在测试数据集上的准确率来评估模型的性能。

下面是一个示例，展示了如何使用PyTorch测试模型的准确率：

correct = 0
total = 0

with torch.no_grad():
    for data in test_loader:
        inputs, labels = data
        outputs = net(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = 100 * correct / total
print('Accuracy: %.2f %%' % accuracy)

Copier après la connexion

在上面的代码中，我们首先定义了两个变量correct和total，用于计算正确分类的样本和总样本数。接着，我们使用torch.no_grad()

Ce qui suit est un exemple simple montrant comment utiliser PyTorch pour créer un modèle de réseau neuronal contenant deux couches entièrement connectées :

rrreee
Dans le code ci-dessus, nous définissons d'abord une classe nommée Net et héritons de torch.nn. Classe du module. Dans la méthode __init__, nous définissons deux couches entièrement connectées fc1 et fc2. Ensuite, nous définissons le processus de propagation vers l'avant des données dans le modèle via la méthode forward. Enfin, nous créons une instance de Net.

3. Définir la fonction de perte et l'optimiseur

Avant la formation, nous devons définir la fonction de perte et l'optimiseur. PyTorch propose une riche sélection de fonctions de perte et d'optimiseurs, qui peuvent être sélectionnés en fonction de circonstances spécifiques.

Voici un exemple qui montre comment définir un processus d'entraînement à l'aide de la fonction de perte d'entropie croisée et de l'optimiseur de descente de gradient stochastique :
Dans le code ci-dessus, nous attribuons la fonction de perte d'entropie croisée et l'optimiseur de descente de gradient stochastique séparément Les variables loss_fn et optimizer sont données. net.parameters() indique que nous souhaitons optimiser tous les paramètres apprenables dans le modèle de réseau neuronal, et le paramètre lr indique le taux d'apprentissage.

4. Préparer l'ensemble de données🎜Avant d'entraîner le réseau neuronal, nous devons préparer l'ensemble de données d'entraînement et l'ensemble de données de test. PyTorch fournit des classes d'outils pratiques qui peuvent nous aider à charger et prétraiter des ensembles de données. 🎜🎜Voici un exemple montrant comment charger l'ensemble de données de chiffres manuscrits MNIST et le prétraiter : 🎜rrreee🎜Dans le code ci-dessus, nous définissons d'abord une variable transform pour transformer le prétraitement des données. Nous avons ensuite chargé l'ensemble de données MNIST à l'aide de la classe torchvision.datasets.MNIST et spécifié les données d'entraînement à l'aide des paramètres train=True et train=False. définir et tester l’ensemble de données. Enfin, nous utilisons la classe torch.utils.data.DataLoader pour convertir l'ensemble de données en un chargeur de données itérable. 🎜🎜5. Commencer la formation🎜Après avoir préparé l'ensemble de données, nous pouvons commencer à former le réseau neuronal. Dans une boucle de formation, nous devons effectuer les étapes suivantes dans l'ordre : saisir les données d'entrée dans le modèle, calculer la fonction de perte, rétropropager le gradient mis à jour et optimiser le modèle. 🎜🎜Voici un exemple montrant comment utiliser PyTorch pour l'entraînement des réseaux neuronaux : 🎜rrreee🎜Dans le code ci-dessus, nous parcourons d'abord le chargeur de données d'entraînement à l'aide de la fonction enumerate pour obtenir les données d'entrée et l'étiquette. Nous remettons ensuite à zéro les gradients, introduisons les données d'entrée dans le modèle et calculons les prédictions et la fonction de perte. Ensuite, nous calculons le dégradé via la méthode backward, puis mettons à jour les paramètres du modèle via la méthode step. Enfin, nous accumulons les pertes et les imprimons selon les besoins. 🎜🎜 6. Testez le modèle 🎜Une fois la formation terminée, nous devons encore tester les performances du modèle. Nous pouvons évaluer les performances du modèle en calculant sa précision sur l'ensemble de données de test. 🎜🎜Voici un exemple montrant comment tester la précision d'un modèle à l'aide de PyTorch : 🎜rrreee🎜Dans le code ci-dessus, nous définissons d'abord deux variables correct et total, utilisées pour calculer le nombre d'échantillons correctement classés et le nombre total d'échantillons. Ensuite, nous utilisons le gestionnaire de contexte torch.no_grad() pour désactiver les calculs de dégradé, réduisant ainsi la consommation de mémoire. Ensuite, nous calculons séquentiellement les résultats de la prédiction, mettons à jour le nombre d'échantillons correctement classés et le nombre total d'échantillons. Enfin, la précision est calculée en fonction du nombre d'échantillons correctement classés et du nombre total d'échantillons imprimés. 🎜🎜Résumé : 🎜Grâce à l'introduction de cet article, vous avez compris les étapes de base de l'utilisation de PyTorch pour la formation de réseaux neuronaux et avez appris à créer un modèle de réseau neuronal, à définir des fonctions de perte et des optimiseurs, à préparer des ensembles de données, à démarrer la formation. et tester le modèle. J'espère que cet article pourra être utile pour votre travail et vos études sur l'utilisation de PyTorch pour la formation des réseaux neuronaux. 🎜🎜Références : 🎜🎜🎜Site officiel de PyTorch : https://pytorch.org/🎜🎜Documentation de PyTorch : https://pytorch.org/docs/stable/index.html🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!