Le but de ce tutoriel est de fournir une compréhension complète de la façon de construire un modèle de transformateur à l'aide de pytorch. Le transformateur est l'un des modèles les plus puissants de l'apprentissage automatique moderne. Ils ont révolutionné le domaine, en particulier dans les tâches de traitement du langage naturel (NLP) telles que la traduction du langage et la résumé de texte. Les réseaux de mémoire à court terme (LSTM) ont été remplacés par des transformateurs dans ces tâches en raison de leur capacité à gérer les dépendances à longue portée et les calculs parallèles.
L'outil utilisé dans ce guide pour construire le transformateur est Pytorch, une bibliothèque d'apprentissage machine-source ouverte populaire connue pour sa simplicité, sa polyvalence et son efficacité. Avec un graphique de calcul dynamique et des bibliothèques étendues, Pytorch est devenu un incontournable pour les chercheurs et les développeurs dans le domaine de l'apprentissage automatique et de l'intelligence artificielle.
Pour ceux qui ne sont pas familiers avec Pytorch, une visite au cours de Datacamp, l'introduction à l'apprentissage en profondeur avec Pytorch est recommandée pour une solide mise à la terre.
Introduit pour la première fois dans l'attention du papier est tout ce dont vous avez besoin par Vaswani et al., Les transformateurs sont depuis devenus la pierre angulaire de nombreuses tâches PNL en raison de leur conception et de leur efficacité uniques.
Au cœur des transformateurs se trouve le mécanisme d'attention, en particulier le concept d '«auto-attention», qui permet au modèle de peser et de hiérarchiser différentes parties des données d'entrée. Ce mécanisme est ce qui permet aux transformateurs de gérer les dépendances à longue portée dans les données. Il s'agit fondamentalement d'un schéma de pondération qui permet à un modèle de se concentrer sur différentes parties de l'entrée lors de la production d'une sortie.
Ce mécanisme permet au modèle de considérer différents mots ou caractéristiques dans la séquence d'entrée, en attribuant à chacun un «poids» qui signifie son importance pour produire une sortie donnée.
Par exemple, dans une tâche de traduction de phrase, tout en traduisant un mot particulier, le modèle peut attribuer des poids d'attention plus élevés à des mots grammaticalement ou sémantiquement liés au mot cible. Ce processus permet au transformateur de capturer les dépendances entre les mots ou les caractéristiques, quelle que soit leur distance les unes des autres dans la séquence.
L'impact des transformateursdans le domaine de la PNL ne peut pas être surestimé. Ils ont surclassé les modèles traditionnels dans de nombreuses tâches, démontrant une capacité supérieure à comprendre et à générer un langage humain de manière plus nuancée.
Pour une compréhension plus profonde de la PNL, l'introduction de Datacamp au traitement du langage naturel dans le cours Python est une ressource recommandée.
Avant de plonger dans la construction d'un transformateur, il est essentiel de configurer correctement l'environnement de travail. D'abord et avant tout, Pytorch doit être installé. Pytorch (version stable actuelle - 2.0.1) peut être facilement installée via des gestionnaires de packages PIP ou conda.
Pour PIP, utilisez la commande:
pip3 install torch torchvision torchaudio
Pour conda, utilisez la commande:
pip3 install torch torchvision torchaudio
pour l'utilisation de pytorch avec un processeur, visitez la documentation Pytorch.
De plus, il est avantageux d'avoir une compréhension de base des concepts d'apprentissage en profondeur, car ceux-ci seront fondamentaux pour comprendre le fonctionnement des transformateurs. Pour ceux qui ont besoin d'un rafraîchissement, le cours Datacamp Deep Learning in Python est une ressource précieuse qui couvre les concepts clés de l'apprentissage en profondeur.
Pour construire le modèle de transformateur, les étapes suivantes sont nécessaires:
Nous allons commencer par l'importation de la bibliothèque Pytorch pour les fonctionnalités de base, le module de réseau neuronal pour la création de réseaux de neurones, le module d'optimisation pour les réseaux de formation et les fonctions d'utilité de données pour gérer les données. De plus, nous importerons le module de mathématiques Python standard pour les opérations mathématiques et le module de copie pour créer des copies d'objets complexes.
Ces outils définissent les bases de la définition de l'architecture du modèle, de la gestion des données et de l'établissement du processus de formation.
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
Le mécanisme d'attention multi-tête calcule l'attention entre chaque paire de positions dans une séquence. Il se compose de plusieurs «têtes d'attention» qui capturent différents aspects de la séquence d'entrée.
Pour en savoir plus sur l'attention multi-tête, consultez cette section Mécanismes d'attention du cours des concepts de modèles de grande langue (LLMS).
Figure 1. Attention multi-tête (source: image créée par l'auteur)
import torch import torch.nn as nn import torch.optim as optim import torch.utils.data as data import math import copy
Définition et initialisation de classe:
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
# Ensure that the model dimension (d_model) is divisible by the number of heads
assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
# Initialize dimensions
self.d_model = d_model # Model's dimension
self.num_heads = num_heads # Number of attention heads
self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
# Linear layers for transforming inputs
self.W_q = nn.Linear(d_model, d_model) # Query transformation
self.W_k = nn.Linear(d_model, d_model) # Key transformation
self.W_v = nn.Linear(d_model, d_model) # Value transformation
self.W_o = nn.Linear(d_model, d_model) # Output transformation
def scaled_dot_product_attention(self, Q, K, V, mask=None):
# Calculate attention scores
attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
# Apply mask if provided (useful for preventing attention to certain parts like padding)
if mask is not None:
attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
# Softmax is applied to obtain attention probabilities
attn_probs = torch.softmax(attn_scores, dim=-1)
# Multiply by values to obtain the final output
output = torch.matmul(attn_probs, V)
return output
def split_heads(self, x):
# Reshape the input to have num_heads for multi-head attention
batch_size, seq_length, d_model = x.size()
return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)
def combine_heads(self, x):
# Combine the multiple heads back to original shape
batch_size, _, seq_length, d_k = x.size()
return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)
def forward(self, Q, K, V, mask=None):
# Apply linear transformations and split heads
Q = self.split_heads(self.W_q(Q))
K = self.split_heads(self.W_k(K))
V = self.split_heads(self.W_v(V))
# Perform scaled dot-product attention
attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
# Combine heads and apply output transformation
output = self.W_o(self.combine_heads(attn_output))
return outputLa classe est définie comme une sous-classe du nn.module de Pytorch.
L'initialisation vérifie si d_model est divisible par num_heads, puis définit les poids de transformation pour la requête, la clé, la valeur et la sortie.
Attention au produit de point à l'échelle:
pip3 install torch torchvision torchaudio
Têtes de fractionnement:
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
Cette méthode remodèle l'entrée x dans la forme (Batch_size, num_heads, seq_length, d_k). Il permet au modèle de traiter simultanément les têtes d'attention, permettant un calcul parallèle.
combinant têtes:
import torch import torch.nn as nn import torch.optim as optim import torch.utils.data as data import math import copy
Après avoir appliqué l'attention à chaque tête séparément, cette méthode combine les résultats dans un seul tenseur de forme (Batch_size, seq_length, d_model). Cela prépare le résultat pour un traitement ultérieur.
Méthode avant:
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
# Ensure that the model dimension (d_model) is divisible by the number of heads
assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
# Initialize dimensions
self.d_model = d_model # Model's dimension
self.num_heads = num_heads # Number of attention heads
self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
# Linear layers for transforming inputs
self.W_q = nn.Linear(d_model, d_model) # Query transformation
self.W_k = nn.Linear(d_model, d_model) # Key transformation
self.W_v = nn.Linear(d_model, d_model) # Value transformation
self.W_o = nn.Linear(d_model, d_model) # Output transformation
def scaled_dot_product_attention(self, Q, K, V, mask=None):
# Calculate attention scores
attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
# Apply mask if provided (useful for preventing attention to certain parts like padding)
if mask is not None:
attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
# Softmax is applied to obtain attention probabilities
attn_probs = torch.softmax(attn_scores, dim=-1)
# Multiply by values to obtain the final output
output = torch.matmul(attn_probs, V)
return output
def split_heads(self, x):
# Reshape the input to have num_heads for multi-head attention
batch_size, seq_length, d_model = x.size()
return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)
def combine_heads(self, x):
# Combine the multiple heads back to original shape
batch_size, _, seq_length, d_k = x.size()
return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)
def forward(self, Q, K, V, mask=None):
# Apply linear transformations and split heads
Q = self.split_heads(self.W_q(Q))
K = self.split_heads(self.W_k(K))
V = self.split_heads(self.W_v(V))
# Perform scaled dot-product attention
attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
# Combine heads and apply output transformation
output = self.W_o(self.combine_heads(attn_output))
return outputLa méthode avant est l'endroit où le calcul réel se produit:
Réseaux d'alimentation en position de position
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, num_heads):Définition de classe:
def scaled_dot_product_attention(self, Q, K, V, mask=None):
Initialisation:
pip3 install torch torchvision torchaudio
Méthode avant:
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
En résumé, la classe PositionwiseFeedForward définit un réseau neuronal alimentaire en position de position qui se compose de deux couches linéaires avec une fonction d'activation RELU entre les deux. Dans le contexte des modèles de transformateurs, ce réseau Feed-Forward est appliqué à chaque position séparément et identique. Il aide à transformer les caractéristiques apprises par les mécanismes d'attention dans le transformateur, agissant comme une étape de traitement supplémentaire pour les sorties d'attention.
Le codage positionnel est utilisé pour injecter les informations de position de chaque jeton dans la séquence d'entrée. Il utilise les fonctions sinus et cosinus de différentes fréquences pour générer le codage positionnel.
import torch import torch.nn as nn import torch.optim as optim import torch.utils.data as data import math import copy
Définition de classe:
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
# Ensure that the model dimension (d_model) is divisible by the number of heads
assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
# Initialize dimensions
self.d_model = d_model # Model's dimension
self.num_heads = num_heads # Number of attention heads
self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
# Linear layers for transforming inputs
self.W_q = nn.Linear(d_model, d_model) # Query transformation
self.W_k = nn.Linear(d_model, d_model) # Key transformation
self.W_v = nn.Linear(d_model, d_model) # Value transformation
self.W_o = nn.Linear(d_model, d_model) # Output transformation
def scaled_dot_product_attention(self, Q, K, V, mask=None):
# Calculate attention scores
attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
# Apply mask if provided (useful for preventing attention to certain parts like padding)
if mask is not None:
attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
# Softmax is applied to obtain attention probabilities
attn_probs = torch.softmax(attn_scores, dim=-1)
# Multiply by values to obtain the final output
output = torch.matmul(attn_probs, V)
return output
def split_heads(self, x):
# Reshape the input to have num_heads for multi-head attention
batch_size, seq_length, d_model = x.size()
return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)
def combine_heads(self, x):
# Combine the multiple heads back to original shape
batch_size, _, seq_length, d_k = x.size()
return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)
def forward(self, Q, K, V, mask=None):
# Apply linear transformations and split heads
Q = self.split_heads(self.W_q(Q))
K = self.split_heads(self.W_k(K))
V = self.split_heads(self.W_v(V))
# Perform scaled dot-product attention
attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
# Combine heads and apply output transformation
output = self.W_o(self.combine_heads(attn_output))
return outputLa classe est définie comme une sous-classe de Nn.Module de Pytorch, ce qui lui permet d'être utilisé comme couche de pytorch standard.
Initialisation:
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, num_heads):Méthode avant:
def scaled_dot_product_attention(self, Q, K, V, mask=None):
La méthode avant ajoute simplement les encodages de position à l'entrée x.
Il utilise les premiers éléments X.Size (1) de PE pour garantir que les encodages de position correspondent à la longueur de séquence réelle de x.
Résumé
La classe PositionAncoding ajoute des informations sur la position des jetons dans la séquence. Étant donné que le modèle de transformateur manque de connaissance inhérente à l'ordre des jetons (en raison de son mécanisme d'auto-agencement), cette classe aide le modèle à considérer la position des jetons dans la séquence. Les fonctions sinusoïdales utilisées sont choisies pour permettre au modèle d'apprendre facilement à assister à des positions relatives, car ils produisent un codage unique et lisse pour chaque position dans la séquence.
Figure 2. La partie de l'encodeur du réseau transformateur (source: image du papier d'origine)
pip3 install torch torchvision torchaudio
Définition de classe:
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
La classe est définie comme une sous-classe du Nn.Module de Pytorch, ce qui signifie qu'il peut être utilisé comme bloc de construction pour les réseaux de neurones à Pytorch.
Initialisation:
import torch import torch.nn as nn import torch.optim as optim import torch.utils.data as data import math import copy
Paramètres:
Composants:
Méthode avant:
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
# Ensure that the model dimension (d_model) is divisible by the number of heads
assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
# Initialize dimensions
self.d_model = d_model # Model's dimension
self.num_heads = num_heads # Number of attention heads
self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
# Linear layers for transforming inputs
self.W_q = nn.Linear(d_model, d_model) # Query transformation
self.W_k = nn.Linear(d_model, d_model) # Key transformation
self.W_v = nn.Linear(d_model, d_model) # Value transformation
self.W_o = nn.Linear(d_model, d_model) # Output transformation
def scaled_dot_product_attention(self, Q, K, V, mask=None):
# Calculate attention scores
attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
# Apply mask if provided (useful for preventing attention to certain parts like padding)
if mask is not None:
attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
# Softmax is applied to obtain attention probabilities
attn_probs = torch.softmax(attn_scores, dim=-1)
# Multiply by values to obtain the final output
output = torch.matmul(attn_probs, V)
return output
def split_heads(self, x):
# Reshape the input to have num_heads for multi-head attention
batch_size, seq_length, d_model = x.size()
return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)
def combine_heads(self, x):
# Combine the multiple heads back to original shape
batch_size, _, seq_length, d_k = x.size()
return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)
def forward(self, Q, K, V, mask=None):
# Apply linear transformations and split heads
Q = self.split_heads(self.W_q(Q))
K = self.split_heads(self.W_k(K))
V = self.split_heads(self.W_v(V))
# Perform scaled dot-product attention
attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
# Combine heads and apply output transformation
output = self.W_o(self.combine_heads(attn_output))
return outputEntrée:
Étapes de traitement:
Résumé:
La classe d'encoderlayer définit une seule couche du codeur du transformateur. Il résume un mécanisme d'auto-atténuation à plusieurs têtes suivi d'un réseau neuronal de la position, avec des connexions résiduelles, une normalisation de la couche et un abandon appliquée, selon le cas. Ces composants permettent au codeur de capturer des relations complexes dans les données d'entrée et de les transformer en une représentation utile pour les tâches en aval. En règle générale, plusieurs couches d'encodeur sont empilées pour former la partie d'encodeur complète d'un modèle de transformateur.
pip3 install torch torchvision torchaudio
Définition de classe:
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
Initialisation:
import torch import torch.nn as nn import torch.optim as optim import torch.utils.data as data import math import copy
Paramètres :
Composants :
Forward Méthode :
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
# Ensure that the model dimension (d_model) is divisible by the number of heads
assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
# Initialize dimensions
self.d_model = d_model # Model's dimension
self.num_heads = num_heads # Number of attention heads
self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
# Linear layers for transforming inputs
self.W_q = nn.Linear(d_model, d_model) # Query transformation
self.W_k = nn.Linear(d_model, d_model) # Key transformation
self.W_v = nn.Linear(d_model, d_model) # Value transformation
self.W_o = nn.Linear(d_model, d_model) # Output transformation
def scaled_dot_product_attention(self, Q, K, V, mask=None):
# Calculate attention scores
attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
# Apply mask if provided (useful for preventing attention to certain parts like padding)
if mask is not None:
attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
# Softmax is applied to obtain attention probabilities
attn_probs = torch.softmax(attn_scores, dim=-1)
# Multiply by values to obtain the final output
output = torch.matmul(attn_probs, V)
return output
def split_heads(self, x):
# Reshape the input to have num_heads for multi-head attention
batch_size, seq_length, d_model = x.size()
return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)
def combine_heads(self, x):
# Combine the multiple heads back to original shape
batch_size, _, seq_length, d_k = x.size()
return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)
def forward(self, Q, K, V, mask=None):
# Apply linear transformations and split heads
Q = self.split_heads(self.W_q(Q))
K = self.split_heads(self.W_k(K))
V = self.split_heads(self.W_v(V))
# Perform scaled dot-product attention
attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
# Combine heads and apply output transformation
output = self.W_o(self.combine_heads(attn_output))
return outputentrée :
Étapes de traitement:
Résumé:
La classe DecoderLayer définit une seule couche du décodeur du transformateur. Il se compose d'un mécanisme d'auto-atténuation multiples, d'un mécanisme de transtention multiples (qui s'occupe de la sortie de l'encodeur), d'un réseau neuronal alimentaire en position de position et des connexions résiduelles correspondantes, de la normalisation des calques et des couches d'abandon. Cette combinaison permet au décodeur de générer des sorties significatives en fonction des représentations de l'encodeur, en tenant compte à la fois de la séquence cible et de la séquence source. Comme pour l'encodeur, plusieurs couches de décodeur sont généralement empilées pour former la partie du décodeur complète d'un modèle de transformateur.
Ensuite, les blocs d'encodeur et de décodeur sont réunis pour construire le modèle de transformateur complet.
Figure 4. Le réseau de transformateur (source: image du papier d'origine)
pip3 install torch torchvision torchaudio
Définition de classe:
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
Initialisation:
import torch import torch.nn as nn import torch.optim as optim import torch.utils.data as data import math import copy
Le constructeur prend les paramètres suivants:
et il définit les composants suivants:
Générer la méthode du masque:
pip3 install torch torchvision torchaudio
Cette méthode est utilisée pour créer des masques pour les séquences source et cible, garantissant que les jetons de rembourrage sont ignorés et que les futurs jetons ne sont pas visibles lors de l'entraînement pour la séquence cible.
Méthode avant:
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
Cette méthode définit la passe avant pour le transformateur, prenant des séquences source et cible et produisant les prévisions de sortie.
Sortie:
La sortie finale est un tenseur représentant les prédictions du modèle pour la séquence cible.
Résumé:
La classe de transformateur rassemble les différentes composantes d'un modèle de transformateur, y compris les intégres, le codage positionnel, les couches d'encodeur et les couches de décodeur. Il fournit une interface pratique pour la formation et l'inférence, encapsulant les complexités de l'attention multi-tête, des réseaux à partager et la normalisation des calques.
Cette implémentation suit l'architecture du transformateur standard, ce qui le rend adapté aux tâches de séquence à séquence comme la traduction automatique, la résumé de texte, etc.
Ces étapes séquentielles permettent au modèle du transformateur de traiter efficacement les séquences d'entrée et de produire des séquences de sortie correspondantes.Formation du modèle de transformateur Pytorch
pip3 install torch torchvision torchaudio
hyperparamètres:
Ces valeurs définissent l'architecture et le comportement du modèle de transformateur:
Création d'une instance de transformateur:
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
Cette ligne crée une instance de la classe de transformateur, l'initialisant avec les hyperparamètres donnés. L'instance aura l'architecture et le comportement défini par ces hyperparamètres.
Génération de données d'échantillons aléatoires:
Les lignes suivantes génèrent des séquences de source et cible aléatoires:
Résumé:
L'extrait de code montre comment initialiser un modèle de transformateur et générer des séquences de source et cible aléatoires qui peuvent être introduites dans le modèle. Les hyperparamètres choisis déterminent la structure et les propriétés spécifiques du transformateur. Cette configuration pourrait faire partie d'un script plus grand où le modèle est formé et évalué sur les tâches de séquence à séquence réelles, telles que la traduction machine ou la résumé de texte.
Ensuite, le modèle sera formé en utilisant les données d'échantillon susmentionnées. Cependant, dans un scénario du monde réel, un ensemble de données beaucoup plus important serait utilisé, qui serait généralement partitionné en ensembles distincts à des fins de formation et de validation.
import torch import torch.nn as nn import torch.optim as optim import torch.utils.data as data import math import copy
Fonction de perte et optimiseur:
Mode de formation du modèle:
Boucle de formation:
L'extrait de code forme le modèle pour 100 époques à l'aide d'une boucle de formation typique:
Résumé:
Cet extrait de code entraîne le modèle de transformateur sur des séquences source et cibles générées aléatoires pour 100 époques. Il utilise l'optimiseur ADAM et la fonction de perte de l'entropie croisée. La perte est imprimée pour chaque époque, vous permettant de suivre les progrès de la formation. Dans un scénario du monde réel, vous remplaceriez la source aléatoire et les séquences cibles par des données réelles de votre tâche, telles que la traduction automatique.
Après la formation du modèle, ses performances peuvent être évaluées sur un ensemble de données de validation ou un ensemble de données de test. Ce qui suit est un exemple de la façon dont cela pourrait être fait:
pip3 install torch torchvision torchaudio
Mode d'évaluation:
Générer des données de validation aléatoire:
Boucle de validation:
Résumé:
Cet extrait de code évalue le modèle de transformateur sur un ensemble de données de validation généré de manière aléatoire, calcule la perte de validation et l'imprime. Dans un scénario du monde réel, les données de validation aléatoires doivent être remplacées par des données de validation réelles de la tâche sur laquelle vous travaillez. La perte de validation peut vous donner une indication de la performance de votre modèle sur des données invisibles, ce qui est une mesure critique de la capacité de généralisation du modèle.
Pour plus de détails sur les transformateurs et les étreintes, notre tutoriel, une introduction à l'utilisation des transformateurs et des étreintes, est utile.
En conclusion, ce tutoriel a démontré comment construire un modèle de transformateur à l'aide de Pytorch, l'un des outils les plus polyvalents pour l'apprentissage en profondeur. Avec leur capacité de parallélisation et la capacité de capturer les dépendances à long terme dans les données, les transformateurs ont un immense potentiel dans divers domaines, en particulier les tâches NLP comme la traduction, la résumé et l'analyse des sentiments.
Pour ceux qui ont hâte d'approfondir leur compréhension des concepts et techniques avancés d'apprentissage en profondeur, envisagez d'explorer le cours avancé d'apprentissage en profondeur avec Keras sur DataCamp. Vous pouvez également lire sur la création d'un simple réseau de neurones avec Pytorch dans un tutoriel séparé.
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!
Méthodes de cryptage du stockage des données
Quel est le mot de passe du service mobile ?
nouvelles fonctionnalités de jdk8
méthode d'initialisation du tableau c
Que dois-je faire si la touche de raccourci de copie ne fonctionne pas ?
qu'est-ce que la plage Python
utilisation de Preventdefault()
Comment régler la sensibilité de la souris
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
