torche - documentation PyTorch 1.12 https://pytorch.org/docs/stable/torch.html

PyTorch est une bibliothèque de tenseurs optimisée pour l'apprentissage en profondeur à l'aide de GPU et de CPU.

Bibliothèques basées sur Pytorch : torchvision, torchaudio, pytorch-fast-transformer

1. Pytorche

1. Lecture des données

Utilisez la combinaison de la classe Dataset et DataLoader pour obtenir un itérateur de données. Pendant l'apprentissage ou la prédiction, l'itérateur de données peut produire les données requises pour chaque lot et effectuer des opérations de prétraitement et d'amélioration des données correspondantes sur les données.

Classe de jeu de données

En intégrant la classe Dataset pour personnaliser le format, la taille et d'autres attributs de l'ensemble de données, il peut être utilisé directement par la classe DataLoader plus tard, ce qui signifie que si vous utilisez un ensemble de données personnalisé ou un ensemble de données packagé officiel, son essence est héritée de la classe Dataset, et lors de l'héritage de la classe Dataset, au moins les méthodes suivantes doivent être réécrites :

__init__(): Constructeur, vous pouvez personnaliser la méthode de lecture des données et effectuer un prétraitement des données
__len__(): renvoie la taille du jeu de données
__getitem()__: Une certaine donnée dans l'ensemble de données d'index

import torch
from torch.utils.data import Dataset
 
class MyDataset(Dataset):
    # 构造函数
    def __init__(self, data_tensor, target_tensor):
        self.data_tensor = data_tensor
        self.target_tensor = target_tensor
 
    # 返回数据集大小
    def __len__(self):
        return self.data_tensor.size(0)
 
    # 返回索引的数据与标签
    def __getitem__(self, index):
        return self.data_tensor[index], self.target_tensor[index]

Classe de chargeur de données

Pendant le processus de formation, il peut ne pas être possible de charger toutes les données dans la mémoire en une seule fois, ni de les charger par un seul processus, de sorte que plusieurs processus et un chargement itératif sont nécessaires, et Dataloader est conçu sur cette base. est un itérateur . La façon la plus simple de l'utiliser est de passer un objet Dataset, qui générera un lot de données en fonction de la valeur du paramètre batch_size , ce qui peut économiser de la mémoire et réaliser des processus multiples, le brouillage des données et d'autres traitements . Paramètres entrants :

dataset: Type de jeu de données, jeu de données d'entrée, paramètre requis
batch_size: int type, combien d'échantillons y a-t-il dans chaque lot
shuffle: type booléen, au début de chaque époque, s'il faut remanier les données
num_workers: type int, le nombre de processus chargeant des données, 0 signifie que toutes les données seront chargées dans le processus principal

def main():
    # 生成数据
    data_tensor = torch.randn(10, 3)
    target_tensor = torch.randint(2, (10,))  # 标签是0或1
 
    # 将数据封装成Dataset
    my_dataset = MyDataset(data_tensor, target_tensor)
    tensor_dataloader = DataLoader(dataset=my_dataset, batch_size=2, shuffle=True, num_workers=0)
    for data, target in tensor_dataloader:
        print(data, target)
    print('One batch tensor data: ', iter(tensor_dataloader).next())
 
main()

2. Couche de couches

torch.nn.Embedding ( num_embeddings taille du dictionnaire d'intégration , embedding_dim taille du vecteur d'intégration)
torch.nn.LSTM (input_size, hidden_size, num_layers=1, bias=True, batch_first=False, dropout=0)：输入x,(h0,c0)，输出y,(h_n,c_n)
nn . CrossEntropyLoss ( poids =Aucun , size_average =Aucun , ignore_index =- 100 , reduce =Aucun , reduction ='mean' , label_smoothing=0.0 )

3. Fonctions utilitaires

torch.nn.utils.clip_grad_norm_ : ne résout que le problème d'explosion de gradient, pas le problème de disparition de gradient

4. Foire aux questions

# loss.backward() et optimiser.step()

loss.backward() : rétropropagez la perte de perte au test d'entrée ; cette étape calculera les valeurs de gradient de toutes les variables x $\petite \frac{d}{dx}perte$ et les accumulera pour $\petit x*grade$ la sauvegarde, c'est-à-dire que $\small x*grad=(x*grad)_{pre}+\frac{d}{dx}perte$ le gradient dans la formule $\small (x*grade)_{pre}$ fait référence au gradient accumulé dans le précédent époque.
optimiseur.step() : Utilisez l'optimiseur pour mettre à jour le paramètre x, en prenant comme exemple la descente de gradient stochastique SGD, la formule mise à jour est : , $\petit x = x - lr*(x*grad)$ lr signifie le taux d'apprentissage, et le signe moins signifie la mise à jour dans la direction opposée du gradient ;
optimiseur.zero_grad() : efface la valeur de gradient cumulée de l'optimiseur pour tous les paramètres x $\petit x*grade$ , généralement utilisée avant loss.backward(), c'est-à-dire clear $\small (x*grade)_{pre}$ .

# model.zero_grad() à optimiser.zero_grad()

La fonction de model.zero_grad() est de définir le gradient de tous les paramètres du modèle sur 0
La fonction de l'optimizer.zero_grad() est d'effacer le gradient de toutes les torches optimisées.Tensor
Lors de l'utilisation de l'optimiseur = optimise.Optimizer(net.parameters()) pour définir l'optimiseur, les param_groups dans l'optimiseur sont égaux aux parameters() dans le modèle. Pour le moment, les deux sont équivalents. D'après le code source du deux Il peut également être vu.
Lorsque plusieurs modèles utilisent le même optimiseur, les deux sont différents. Dans ce cas, la méthode de compensation du gradient doit être sélectionnée en fonction de la situation réelle.
Lorsqu'un modèle utilise plusieurs optimiseurs, les deux sont différents.À ce stade, la méthode de compensation du gradient doit être sélectionnée en fonction de la situation réelle.

# détacher() et données()

detach() renvoie un nouveau tenseur, qui est séparé du graphe de calcul actuel, mais pointe toujours vers l'emplacement de stockage de la variable d'origine. Son grad_fn=None et requirements_grad =False , le tenseur obtenu n'a jamais besoin de calculer son gradient, et ne pas de dégradé de dégradé, même si son requirements_grad est à nouveau défini sur true plus tard, il n'aura pas de dégradé de dégradé.

Remarque : Le tenseur renvoyé partage les mêmes données de mémoire que le tenseur d'origine. La modification de la fonction sur place sera répercutée sur les deux tenseurs en même temps (car ils partagent des données de mémoire), et cela peut provoquer des erreurs lors de l'appel de back() dessus.
La fonction data() a la même fonction que la fonction detach(), mais elle ne peut pas garantir la sécurité sur place.
Vérification de l'exactitude sur place : tous les tenseurs enregistreront les opérations sur place utilisées sur eux. Si pytorch détecte que le tenseur a été enregistré pour l'arrière dans une fonction, mais qu'il est ensuite modifié par des opérations sur place. Lorsque cela se produit, pytorch signalera une erreur lors du retour en arrière. Ce mécanisme garantit que si vous utilisez des opérations sur place, mais qu'aucune erreur n'est signalée pendant le processus en arrière, le calcul du gradient est correct.

# .article()

Ce qui est renvoyé est la valeur dans le tenseur et ne peut renvoyer qu'une seule valeur (scalaire), pas un vecteur. Convertit la valeur du tenseur en une valeur Python standard (float, int), il ne peut être utilisé que lorsque le tenseur ne contient qu'un seul élément

# torch.load(fichier de paramètres, map_location='cpu')

Si le modèle enregistré est formé sur le GPU et chargé sur le CPU, une erreur peut être signalée. Dans ce cas, map_location doit être utilisé pour remapper dynamiquement le stockage vers un périphérique facultatif.

# @torch.no_grad() 和 model.eval()

model.eval() , va (désactiver l'abandon et a une norme de lot), mais ses paramètres de modèle changeront toujours , le calcul du gradient ne sera pas affecté, le flux de calcul stockera et calculera toujours le gradient, et le poids correspondant de le modèle peut encore être mis à jour ultérieurement
La fonction de torch.no_grad() est d' arrêter le travail du module autograd , c'est-à-dire qu'il ne calculera pas et ne stockera pas automatiquement les dégradés, de sorte qu'il peut accélérer le processus de calcul et économiser de la mémoire vidéo

二、Vision de la torche

torchvision est une bibliothèque graphique de pytorch, qui sert le cadre d'apprentissage en profondeur PyTorch et est principalement utilisée pour créer des modèles de vision par ordinateur. Voici la composition de torchvision :

torchvision.datasets : Certaines fonctions de chargement de données et d'interfaces communes d'ensembles de données ;
torchvision.models : contient des structures de modèles couramment utilisées (y compris des modèles pré-formés), telles qu'AlexNet, VGG, ResNet, etc. ;
torchvision.transforms : transformations d'image courantes, telles que le recadrage, la rotation, etc. ;
torchvision.utils : Autres méthodes utiles.

import torchvision
from PIL import Image
import torchvision.transforms as transforms

torchvision.datasets

Le package d'ensembles de données de torchvision fournit une interface riche pour les ensembles de données d'images. Ce paquet lui-même ne contient pas le fichier de jeu de données lui-même. Sa méthode de travail consiste à télécharger le jeu de données du réseau dans le répertoire spécifié par l'utilisateur, puis à utiliser son chargeur pour le charger en mémoire. Enfin, cet ensemble de données chargé est renvoyé à l'utilisateur en tant qu'objet

import torchvision
 
mnist_dataset = torchvision.datasets.MNIST(root='./data',
                                           train=True,
                                           transform=None,
                                           target_transform=None,
                                           download=True)

torchvision.transforme

# 图像预处理步骤
transform = transforms.Compose([
    transforms.Resize(96), # 缩放到 96 * 96 大小
    transforms.ToTensor(), # 转化为Tensor
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # 归一化
])

torchvision.models

import torch
import torchvision.models as models

# 加载预训练模型
google_net = models.googlenet(pretrained=True)
resnet18 = models.resnet18()
alexnet = models.alexnet()
squeezenet = models.squeezenet1_0()
densenet = models.densenet_161()
 
# 提取分类层
fc_in_features = google_net.fc.in_features
print("fc_in_features:", fc_in_features)
 
# 查看分类层的输出参数
fc_out_features = google_net.fc.out_features
print("fc_out_features:", fc_out_features)
 
# 修改预训练模型的输出分类数
google_net.fc = torch.nn.Linear(fc_in_features, 10)

autres fonctions

# 将32张图片拼接在一个网格中
grid_tensor = torchvision.utils.make_grid(image_tensor, nrow=8, padding=2)
grid_image = transforms.ToPILImage()(grid_tensor)
display(grid_image)

三、Transformateurs rapides Pytorch

Transformateurs rapides pour PyTorch Aucun https://fast-transformers.github.io/

1. Couches de transformateurs

TransformerEncoderLayer (attention, d_model, n_heads, d_ff=None, dropout=0.1, activation='relu')

avant (x, attn_mask=Aucun, length_mask=Aucun)
La forme de x (N,L,E)

TransformerDecoderLayer (self_attention, cross_attention, d_model, d_ff=None, dropout=0.1, activation='relu')

avant (x, mémoire, x_mask=Aucun, x_length_mask=Aucun, memory_mask=Aucun, memory_length_mask=Aucun)
La forme de x (N, L, E), la forme de la mémoire (N, L', E), et la mémoire est la matrice de l'encodeur

2. Transformateurs récurrents

Semblable au RNN cyclique, un seul élément est traité à la fois

RecurrentTransformerEncoderLayer (attention, d_model, d_ff=None, dropout=0.1, activation='relu', event_dispatcher='')

avant (x, état=Aucun)
L' état est un objet python qui varie en fonction de l'implémentation de l'attention (par exemple, attention linéaire, attention complète)
L'état utilise des cartes de caractéristiques au lieu de softmax dans le calcul de l'auto-attention.

RecurrentTransformerDecoderLayer (self_attention, cross_attention, d_model, d_ff=None, dropout=0.1, activation='relu', event_dispatcher='')

Attention aux entrées précédentes et à une mémoire prétraitée.
avant (x, mémoire, memory_length_mask=Aucun, état=Aucun)
La forme de x (N, E), la forme de la mémoire (N, S, E), la mémoire est la matrice de l'encodeur

3. Constructeurs

        if is_training:
            # encoder (training)
            self.transformer_encoder = TransformerEncoderBuilder.from_kwargs(
                n_layers=self.n_layer,
                n_heads=self.n_head,
                query_dimensions=self.d_model//self.n_head,
                value_dimensions=self.d_model//self.n_head,
                feed_forward_dimensions=2048,
                activation='gelu',
                dropout=0.1,
                attention_type="causal-linear",
            ).get()
        else:
            # encoder (inference)
            print(' [o] using RNN backend.')
            self.transformer_encoder = RecurrentEncoderBuilder.from_kwargs(
                n_layers=self.n_layer,
                n_heads=self.n_head,
                query_dimensions=self.d_model//self.n_head,
                value_dimensions=self.d_model//self.n_head,
                feed_forward_dimensions=2048,
                activation='gelu',
                dropout=0.1,
                attention_type="causal-linear",
            ).get()

4. Masquage

FullMask (masque=Aucun, N=Aucun, M=Aucun, périphérique='cpu')
LengthMask (longueurs, max_len=None, device=None)
TriangularCausalMask (N, device="cpu")

5. Attention

Les références

Formation au modèle d'entraînement PyTorch (Torchvision) - N3ptune - 博客园

Démarrer avec PyTorch