Tutoriel pytorch

Pytorch est une bibliothèque d'Open-source de l'apprentissage automatique qui est utilisée pour Python. L'équipe de recherche sur l'intelligence artificielle de Facebook l'a initialement créée, servant de base pour le logiciel pyro d'Uber pour la programmation probabiliste. Il s'agit d'une boîte à outils mathématique qui permet de calculer les modèles basés sur des graphiques de contraste efficacement et automatiquement.

Puisqu'il est simple et adaptable, l'API Pytorch est populaire parmi les universitaires et les chercheurs, créant de nouveaux modèles et applications d'apprentissage en profondeur. En raison de l'utilisation généralisée, il existe déjà de nombreuses extensions pour les applications de niche, telles que le texte, la vision par ordinateur et les données audio, et les modèles pré-formés potentiellement prêts à l'emploi.

Caractéristiques

Les caractéristiques clés de Pytorch sont:

Facile à utiliser

Puisque Pytorch a une API intuitive et s'appuie sur Python, il est considéré comme relativement facile à utiliser. L'exécution du code est rendue simple par ce cadre.

Utilisation python

Ce module interagit de manière transparente avec le Python Data Science Stac et est considéré comme pythonique. En conséquence, il peut utiliser toutes les fonctionnalités et services que fournit l'environnement Python.

Graphiques informatiques

Pytorch offre un environnement efficace pour les graphiques de calcul dynamiques. Cela permet une modification de l'exécution par l'utilisateur.

Outils et bibliothèques

Une communauté dynamique de chercheurs et de créateurs a établi un réseau complet d'outils et de bibliothèques pour la diffusion de Pytorch et la promotion des progrès dans des domaines comme la vision informatique et l'apprentissage du renforcement.

Avantages du pytorch

• Il est facile à comprendre et simple à coder car il est basé sur Python
• Permet un débogage simple à l'aide d'outils Python bien appréciés
• Pytorch est simple à échelle et présente un excellent support sur les plates-formes cloud les plus populaires
• Concentre sa petite communauté sur les open source
• A la capacité d'exporter des modèles d'apprentissage dans le format commun de l'échange de réseau de neurones (ONNX)

Différence entre la torche et le pytorch

Torch (Torch7) est une bibliothèque d'apprentissage automatique gratuite et un cadre informatique scientifique basé sur le langage de programmation et généralement accessible à l'aide de l'interface LUA. Il n'est plus développé activement.

Pytorch est la bibliothèque basée sur une torche car elle est simple et adaptable. Dans Pytorch, «py» indique le python où la «torche» reflète sa bibliothèque de torch précédente.

Comment installer pytorch

N'oubliez pas que Python est installé, en particulier la version 3.7 ou plus, avant de configurer Pytorch. Python peut être installé à l'aide d'Anaconda. Après avoir configuré notre environnement Python, nous passerons à notre prochaine étape d'installation de Pytorch.

Tout d'abord, nous devons créer un environnement virtuel pour Conda dans lequel nous voulons installer tous nos packages et établir l'environnement.

$ conda création -n pytorch python = 3.7

Conda est un gestionnaire d'environnement qui vous aide à installer le package du programme d'apprentissage automatique. Si vous devez travailler avec une autre version de Python, alors vous n'avez pas à y passer. Conda le gérera automatiquement. Il vous suffit d'utiliser certaines commandes pour créer votre environnement en fonction de votre choix.

Où la création est un mot-clé pour dire au compilateur de créer un nouvel environnement pour Pytorch qui utilisera le «Python 3.Version 7 ”. Lorsque nos packages seront téléchargés avec succès, il vous demandera votre autorisation de les installer ou non.

Au fur et à mesure que votre environnement est créé avec succès, il affichera la sortie, comme indiqué dans l'extrait suivant:

Laissez-nous commencer avec l'installation de Pytorch:

Ouvrez le lien suivant et accédez au site Web de Pytorch. Accédez à l'onglet Démarrage et cliquez sur Démarrer localement.

https: // pytorch.org / get-started / localement /

Une zone comme celle de la figure en dessous sera vue. Le premier sélecteur sera Pytorch Build et sélectionnez Stable (1.12.1) à partir des options données. Maintenant, le deuxième champ sélecteur sera votre choix, et vous pouvez sélectionner le système d'exploitation conformément à vos exigences. Nous sélectionnerons Windows OS dans les options données car nous utilisons Windows pour effectuer nos tâches. Le troisième onglet sera le package. Nous choisirons conda parmi les options données. Si nous utilisons un autre package, alors nous sélectionnerons ce package.

Dans la deuxième dernière option, sélectionnez le nom de la langue que vous utilisez et, dans notre cas, ce sera Python afin que nous le sélectionnions dans les options données. Enfin, nous sélectionnerons le CPU parmi les options données car nous utilisons le CPU comme plate-forme informatique. Si nous utilisons une autre plate-forme comme Cuda, sélectionnez Cuda.

Après avoir sélectionné toutes les options dans les sélecteurs donnés ci-dessus, une commande sera affichée dans le champ ci-dessous. Copiez cette commande et exécutez cette commande dans votre invite de commande conda.

Dans la commande précédente, Conda sera chargée d'installer le Pytorch et d'autres bibliothèques, Torchvision et Torchaudio, où Torchvision est la bibliothèque de Python. Il a été conçu pour simplifier les tests et étudier dans le domaine de la vision par ordinateur. Il a des architectures de modèle, des transformations d'images communes et d'autres ensembles de données populaires pour la vision par ordinateur.

Torchaudio est également un ensemble de pytorch, et il a été conçu pour le traitement audio et du signal des ordinateurs. Il a également des ensembles de données populaires, des E / S et des transformations audio communes.

Lorsque tous nos packages seront téléchargés, il vous demandera votre autorisation de le poursuivre ou non.

Maintenant, passant à notre prochaine étape, activez nos packages Pytorch. Ce faisant, nous exécuterons la commande suivante dans l'invite de commande anaconda:

$ conda activer pytorch

Maintenant, l'activation de nos packages Pytorch en utilisant la commande mentionnée précédemment dans cette activation est le mot-clé utilisé pour demander à Conda d'activer la bibliothèque Pytorch que nous avons déjà installée.

Nous pouvons vérifier en démarrant Python que s'il est en cours d'exécution, il affichera la sortie suivante:

Après cela, nous devons y importer la torche; S'il affiche une erreur de module non trouvée, cela signifie que votre installation n'était pas correcte. Dans ce cas, l'installation était correcte, donc elle n'a affiché aucune erreur.

Maintenant, nous pouvons créer un tenseur de torche pour vérifier si cela fonctionne correctement pour le faire; Disons:

$ x = torche.Rand (3)
$ print (x)

Dans la commande précédente, nous avons créé une variable «x» et l'avons attribuée à la torche de valeur.Rand, où Rand indique une valeur aléatoire. Ensuite, nous avons affiché la sortie de la torche pour lui en utilisant la fonction d'impression et en le faisant passer notre variable «x». La capture d'écran suivante montre comment les valeurs du tenseur sont affichées:

Maintenant, en vérifiant la version de la torche, nous importons le flambeau, et en utilisant la fonction d'impression, nous passerons la valeur «Torch__version__» pour le vérifier.

$ Torche d'importation
$ print (torche.__version__)

Voici la sortie de la commande suivante, comme indiqué dans la figure précédente. Et maintenant, notre environnement Pytorch est installé avec succès pour notre usage.

Cycle de vie du modèle d'apprentissage en profondeur pytorch

Les projets impliquant l'apprentissage automatique ne sont pas simples; Ils impliquent un cycle continu d'amélioration des données, du modèle et de l'évaluation. Ce cycle est essentiel pour créer un modèle d'apprentissage automatique car il souligne l'utilisation de la simulation et des résultats pour améliorer votre ensemble de données.

Depuis plus de dix ans, l'apprentissage en profondeur est un sujet majeur et a contribué à l'accent accru du marché sur la ML. Le développement de nombreux outils pour aider à la production de modèles ML a provoqué l'expérience de l'industrie ML.

5 étapes majeures pour le cycle de vie du modèle d'apprentissage en profondeur sont:

1. Préparer des données
2. Définition modale
3. Formation du modal
4. Évaluation modale
5. Prédiction

Exemple 1

Dans cet exemple, nous utiliserons la bibliothèque TorchVision avec un ensemble de données «FashionMnist» préchargé à l'aide de la bibliothèque TorchVision de Pytorch, qui a des objets du monde réel.

Quand il s'agit de travailler avec des données, Pytorch utilise ses deux éléments principaux, qui sont la torche.utils.données.Dataloader et torche.utils.données.Ensemble de données, nous permettant d'utiliser vos données ou ensembles de données préchargés. Le chargeur de données s'enroule un itérable autour de l'ensemble de données pour faciliter l'acquisition des échantillons, que l'ensemble de données utilise pour stocker les échantillons et leurs étiquettes connexes.

Totensor est utilisé pour l'amélioration et la transformation de l'image, tandis que le package NN spécifie une collection de fonctions de perte pratiques qui sont généralement utilisées. L'ensemble de données FashionMnist fonctionne pour des images avec des éléments allant de 0 à 255. Vous pouvez également écrire des transformations personnalisées en fonction de vos besoins. Voyons le code de ce scénario dans l'image suivante:

Dans le code supérieur, nous avons attribué un ensemble de données de fashionmnist à notre formation_data. Cet ensemble de données affecté à Training_data se compose de nombreuses données de vision du monde réel, telles que Cifar et Coco. Nous utiliserons l'ensemble de données FashionMnist dans ce cas. Tous les ensembles de données TorchVision nécessitent deux paramètres. L'un est transformé, et l'autre est cible_transform. Ces deux paramètres modifient les étiquettes et les échantillons.

Les résultats indiqués dans la figure d'accompagnement apparaissent après l'exécution du code. Il commencera à télécharger l'ensemble de données à partir de la bibliothèque.

Maintenant, l'ensemble de données est téléchargé après l'exécution de notre code. Nous passerons l'ensemble de données en tant que paramètre à DatalOader. Cela nous aidera à l'échantillonnage, au mélange, au chargement des données du multiprocess et à un lot automatiquement. Dans notre cas, nous attribuons 64 à notre batch_size. En conséquence, nous définissons 64 tailles de lots. Chaque élément de DatalOader Itable pourra renvoyer une sortie d'un lot de 64 étiquettes et fonctionnalités.

Nous avons réglé le train pour être vrai car il définit le module. Le téléchargement est également défini sur le mode True, car nous devons télécharger l'ensemble de données pour former notre module à l'aide de cet ensemble de données. Nous avons transmis des données à notre paramètre racine car nous passerons les informations à notre module sous la forme de données que nous téléchargerons à partir du package totenseur.

Après avoir exécuté notre code, nous pouvons voir dans notre sortie qu'il a imprimé les formes de X et Y selon nos arguments passés. Il téléchargera les images.

Maintenant, évoluant vers la création modale, nous allons créer une classe nommée Neural Network qui héritera nn. Le module est un paramètre. Nous créerons une fonction nommée init; Dans cette fonction, nous définirons les couches du réseau. Ensuite, nous créerons une fonction avec le nom en avant car le nom clarifie son objectif. Nous indiquerons comment les données seront transférées via le réseau dans la fonction avant.

Linear est une classe de bibliothèque NN qui applique une transformation linéaire aux données que nous y transmettons. Nous passons 28 * 28 comme nombre de dimensions à la classe linéaire. RELU est une fonction sur les packages NN, qui gère les éléments négatifs en les remplaçant par 0. Pour accélérer l'ensemble du processus pour le réseau neuronal, nous utilisons les ressources de notre carte graphique si elles sont disponibles pour l'utilisation. Voyons le code de ce scénario dans l'image apposée suivante:

La fonction init est la méthode d'initialisation de Pytorch. Il est nécessaire de laisser Pytorch obtenir les répertoires contenant des bibliothèques. En cela, nous l'avons passé à l'auto-fonctionnement. Alors que dans la fonction avant, nous passons les tenseurs d'entrée comme paramètres, et la fonction avant renvoie les tenseurs de sortie en calculant vos tenseurs d'entrée. En cela, nous passons deux paramètres, «self» et «x», à la fonction avant. La fonction avant définit également comment votre module fonctionnera de l'entrée à la sortie.

Suivant cela, la sortie du code précédent apparaît dans la capture d'écran suivante:

Après le processus que nous avons effectué dans les étapes précédentes, nous entraînerons notre modèle. Nous devons utiliser un optimiseur et une fonction de perte pour accomplir cela. Une procédure de fonction de perte détermine l'écart entre la sortie actuelle d'un algorithme et la sortie prévue. Optimizer aide le système à sélectionner le meilleur choix parmi un ensemble d'options possibles qui sont faciles et n'exploitent pas les contraintes. Voyons le code de ce scénario dans l'image apposée ci-dessous:

Epoch est un paramètre qui spécifie le nombre de fois qu'un algorithme d'apprentissage exécutera l'ensemble de données que nous avons fourni pour la formation. Dans notre cas, nous l'avons réglé sur 5, ce qui signifie qu'il passera par notre ensemble de données 5 fois pendant l'entraînement.

Après avoir initialisé les époques, nous utiliserons une boucle pour une boucle, qui exécutera le nombre de fois «t» que nous avons déclaré dans les époques. Dans cette boucle, il exécutera la fonction formée 5 fois et l'exécutera. Une fois que toute l'exécution «For Loop» est terminée, elle imprimera le texte «fait».

L'extrait suivant affiche la sortie de la fonction formée des époques:

Exemple 2

Dans ce cas, la résolution du problème de l'ajustement y = sin (x) avec un polynôme de troisième ordre suffira.

Méthode 1

Le package Optim fourni par Pytorch sera utilisé dans cette technique. "Torche.Optim »est un package Pytorch responsable de la mise en œuvre de différentes techniques d'optimisation. La majorité des techniques fréquemment utilisées sont déjà mises en œuvre, et l'interface est suffisamment ouverte pour que la future intégration facile de plus complexes soit également possible. En modifiant manuellement les tenseurs contenant des paramètres apprenables avec torche.Pas de diplômé, les poids de nos modèles () sont mis à jour.

Nous utiliserons également le package NN pour déclarer notre modal, mais nous utiliserons RMSPOP pour optimiser le modèle car il fournit le package de torche fourni par Optim.

Passons à notre code pour créer un tenseur responsable de la maintenance des données pour les entrées et les sorties. Dans notre cas, nous avons créé deux variables, «A» et «B». Ensuite, nous définirons les tenseurs d'entrée nommés «var» et «myvar», qui sont des tenseurs d'entrée x ^, x ^ 2 et x ^ 3.

Après cela, nous déclarerons les fonctions modales et de perte en utilisant le package NN. Créez un optimiseur en utilisant le package Optim pour modifier les poids du modèle en notre nom. RMSProp sera utilisé dans ce cas; Le package Optim comprend de nombreuses autres techniques d'optimisation. La première entrée du constructeur RMSProp instruit l'optimiseur sur lesquels il doit être modifié. Créez un optimiseur en utilisant le package Optim pour modifier les poids du modèle en notre nom. RMSProp sera utilisé dans ce cas; Le package Optim comprend de nombreuses autres techniques d'optimisation. Le code de l'explication précédente se trouve dans l'écran Spyder suivant:

Ensuite, à l'étape suivante, nous calculerons le Y prévu en le faisant passer MyVar:

$ y_pred = modal (myvar)

Dans ce document, y_predicat est la variable à laquelle nous attribuons la fonction modale à laquelle la valeur «myvar» est transmise. La perte sera ensuite calculée et affichée. Cela est dû au fait que les gradients sont recueillis dynamiquement dans des tampons chaque fois.Backward () est invoqué.

perte.Backward () déterminera le gradient de perte en considération au modal. Lorsqu'une fonction de pas d'un optimiseur est invoquée, ses paramètres sont mis à jour. Les caractéristiques d'entrée des couches linéaires sont multipliées par la matrice de poids pour générer les fonctionnalités de sortie. Les caractéristiques d'entrée sont transmises à une couche linéaire comme un tenseur unidimensionnel qui a été démoli, et ils sont multipliés par la matrice de poids. À la fin du code, il affichera la sortie en conséquence sous la forme de l'équation.

Méthode 2

Dans la méthode suivante, nous utiliserons les packages Tensor et Autograd. Tout d'abord, importez nos bibliothèques de torche et de mathématiques pour ce programme, puis définissez nos variables «dtype». Ici, nous avons attribué la torche de valeur.flotter comme effectué dans l'exemple précédent et a défini le «périphérique» variable. Nous attribuons à nouveau la torche de valeur.dispositif («CPU») qui est utilisé pour définir la plate-forme à utiliser.

Pour maintenir les entrées et les sorties, créez des tenseurs. En supposant que cela nécessite Grad = False, la passe arrière n'a pas besoin de calculer les gradients sur ces tenseurs par défaut. Faire des poids en utilisant des tenseurs aléatoires. Nous avons besoin de quatre poids pour un polynôme de troisième ordre: y = a + b x + c x ^ 2 + d x ^ 3. Nous souhaitons calculer les gradients concernant ces tenseurs pendant la passe arrière, qui est indiquée par la valeur _grad = true.

Calculer et afficher la perte en utilisant. La perte devient un tenseur avec la perte de forme (1,). La valeur scalaire de la perte est renvoyée par item (). Le code de l'explication précédente se trouve dans l'écran Spyder suivant:

Dans ce cas, la passe arrière de notre réseau de neurones doit être gérée manuellement. Il n'est pas physiquement difficile pour le réseau simple à deux couches de le faire. Cependant, il peut rapidement devenir compliqué pour les grands réseaux complexes. Heureusement, nous pouvons utiliser la différenciation automatique pour mécaniser le processus d'une passe arrière dans les réseaux de neurones. La bibliothèque Autograd à Pytorch donne cette fonctionnalité très précisément; Lors de l'utilisation d'Autograd, la passe avant d'un réseau caractérisera un graphique de calcul. Le graphique aura des nœuds et des bords; Les tenseurs sont représentés à l'aide de nœuds et les bords représentent les méthodes qui renvoient les tenseurs de sortie en prenant les tenseurs d'entrée comme arguments.

La lecture de ce graphique aide à calculer facilement les gradients. Cela semble être une tâche difficile, mais en réalité, cette pratique est très simple et simple. Si «x» est un tenseur et que l'attribut «nécessite un diplômé» est défini sur true. Par conséquent, X est un tenseur qui aborde un nœud dans un graphique de calcul. X.Grad est un autre tenseur tenant une pente de «x» pour une valeur scalaire. Ici, nous démontrons en ajustement une onde sinusoïdale avec un polynôme du troisième ordre à l'aide de tenseurs de pytorch et Autograd. Maintenant, il n'est pas nécessaire que nous exécutons manuellement la pause arrière via le réseau.

Méthode 3

Dans cet exemple, nous utiliserons le module Numpy. Numpy est une bibliothèque Python pour le langage de programmation qui prend en charge des tableaux et matrices multidimensionnels substantiels. De plus, une quantité importante d'opérations mathématiques de haut niveau pour fonctionner sur ces tableaux. Numpy est une plate-forme générique pour calculer les opérations scientifiques; Cela n'implique pas l'apprentissage en profondeur ou les graphiques informatiques.

En utilisant des opérations Numpy, nous pouvons facilement adapter un polynôme du troisième ordre dans une fonction «péché». Pour ce faire, nous importerons d'abord les bibliothèques Numpy et Math. Les mathématiques sont le package utilisé pour importer des opérations mathématiques. Voyons le code de ce scénario dans l'image suivante:

Nous avons d'abord initialisé deux variables nommées «var1» et «var2» et avons attribué leurs fonctions. Ici, NP.La fonction Linspace est une méthode Python qui nous aide à créer des séquences numériques. Il nous aide à générer des vecteurs linéaires. C'est la même chose que le signe du côlon, mais la seule différence entre le signe du côlon et c'est qu'il nous fournit un contrôle direct sur le nombre de points. À cette fonction, nous avons passé trois paramètres qui sont «-math.pi »,« mathématiques.pi ", et" 200 ", dans lequel 200 sont la plage que le calcul sera effectué. Et la deuxième fonction que nous avons transmise à Var2 est «NP.sin (var1) », qui est utilisé pour calculer le sinus des valeurs qui seront stockées dans« var1 ».

Ensuite, nous avons initialisé quatre variables nommées «A», «B», «C» et «D» à ces variables, nous avons passé des valeurs aléatoires. Ensuite, nous avons initialisé une boucle pour laquelle nous avons passé la variable «t», indiquant l'heure et la plage à 200.

Après cela, définissez une autre variable, «var2_pred», à laquelle nous attribuerons l'opération mathématique pour calculer les agrégats, puis le passer à la variable nommée «perte». La perte sera responsable du calcul de la perte var «var2_pred».

Passant à l'étape suivante, où nous avons utilisé l'instruction IF, qui sera responsable du calcul du calcul de «T% 10 == 9», il prendra le mode de «T» avec la valeur 10 et l'incrément de 9. Il imprimera la perte de ces valeurs obtenues à partir de la déclaration IF précédente.

Après tous ces calculs où se termine la boucle FOR, il résumera toutes les valeurs, et la dernière opération d'impression sera calculée à la fin de la boucle FOR et sera affichée en conséquence, comme indiqué dans l'extrait ci-dessous:

Méthode 4

Dans ce morceau de code, nous utiliserons le package de tenseur. Un réseau numpy et un tenseur de pytorche sont théoriquement équivalents car un tenseur est un tableau multidimensionnel, et Pytorch propose une variété de méthodes pour travailler avec eux. Les tenseurs sont un outil informatique scientifique à usage général qui peut surveiller les gradients et les graphiques de calcul en arrière-plan. Les tenseurs Pytorch peuvent utiliser des GPU pour accélérer leurs opérations numériques, contrairement à Numpy. Un tenseur Pytorch peut être exécuté sur un GPU en quelques étapes faciles.

Dans ce morceau de code, nous avons importé deux bibliothèques, torche et mathématiques. Puisque nous utiliserons une torche dans ce code et les fonctionnalités mathématiques, nous avons défini une variable nommée «DTYPE». Nous avons attribué la torche de données.flotter parce que nous effectuons des opérations mathématiques qui renvoient les valeurs en points. Pour stocker des valeurs décimales, nous utilisons le flotteur de type de données.

Ensuite, nous avons déclaré une autre variable nommée «Device» avec l'attribution de la torche de valeur.Appareil («CPU») Parce que nous avons sélectionné CPU comme plate-forme dans l'installation de Pytorch. À l'avenir, nous avons initialisé deux variables nommées var1 "et" var2 "et leur avons attribué la même fonction que nous avons attribuée dans l'exemple précédent. Puis créant quatre variables qui sont «A», «B», «C» et «D» sont utilisées pour créer des tenseurs aléatoires. Chacun a sa forme unique; Nous avons également passé le périphérique de type de données et DType, qui sera initialisé au début de notre code. Ainsi, il utilisera les ressources de notre CPU et prendra des valeurs sous forme de décimales. Il est indiqué que nous avons l'intention de calculer les gradients sur de tels tenseurs pendant le passage inverse en déclarant qu'il nécessite un grad = vrai. Voyons le code de ce scénario dans l'image apposée suivante:

Ensuite, nous avons déclaré un apprentissage_rate = 1e-6. Le taux d'apprentissage est également un hyperparamètre utilisé pour la formation des réseaux de neurones. Il a une très petite valeur qui doit être supérieure à 0.0 et moins de 1.0, ce qui signifie que ce doit être une valeur positive. Le rythme de l'apprentissage augmente avec l'augmentation du taux d'apprentissage.

Après cela, nous ouvrirons une boucle qui sera exécutée 200 fois et effectuera des opérations mathématiques sur nos variables. Partout où T% 100 est égal à 99, la boucle imprimera le nombre de fois où il est exécuté et arrêté. Après cela, le résultat sera publié à la fin de notre itération, comme illustré dans la capture d'écran suivante:

Méthode 5

Dans cette méthode, nous créerons notre fonction Autograd à l'aide de sous-classes Pytorch. Chaque autograd principal est deux méthodes qui fonctionnent sur les tenseurs. La fonction avant prend les tenseurs d'entrée et en calcule les tenseurs de sortie. Dans Pytorch, nous pouvons sans aucun doute caractériser notre opérateur Autograd en décrivant une sous-classe.autograd.fonction et exécuter les approches en avant et en arrière.

Maintenant, les tenseurs de sortie sont achetés comme paramètres aux fonctions arrière avec certaines valeurs scalaires. Pytorch nous facilite pour définir notre opérateur Autograd en nous permettant de créer une sous-classe qui analyse le gradient des tenseurs d'entrée avec allusion aux mêmes valeurs scalaires. Maintenant, nous pouvons utiliser notre opérateur Autograd en initialisant un constructeur et en l'appelant une méthode. Ensuite, nous passerons le tenseur avec des données d'entrée en tant que paramètre à ce constructeur.

Dans l'exemple suivant, nous spécifions notre modal comme:

$ y = a + b p_3 (c + dx)
y = a + bp3 (c + dx)
au lieu de
y = a + bx + cx ^ 2 + dx ^ 3
y = a + bx + cx2 + dx3

Nous composons notre méthode Autograd personnalisée en traitant l'avant et vers l'arrière de P3 et en l'utilisant pour exécuter notre modèle. Le code de l'explication suivante se trouve sur l'écran Spyder.

En sous-classant la torche, nous pouvons implémenter nos fonctions Autograd uniques.autograd. Ainsi, le fonctionnement et la mise en pratique des passes avant et arrière qui utilisent des tenseurs. Nous obtenons un tenseur tenant l'entrée pendant la passe avant et livrons un tenseur contenant la sortie. Un objet de contexte appelé CTX peut être utilisé pour stocker des données pour une utilisation dans le calcul arrière.

Les tenseurs peuvent être créés pour stocker les entrées et les sorties. En supposant que cela nécessite Grad = False, la passe arrière n'a pas besoin de calculer les gradients sur ces tenseurs par défaut.

Faire des poids en utilisant des tenseurs aléatoires. Pour garantir la convergence, les poids de cet exemple doivent être introduits raisonnablement proches du résultat précis: y = a + b * p3 (c + d * x). Il est indiqué que nous avons l'intention de générer un gradient concernant ces mappages pendant une passe arrière par réglage qui nécessite un grad = true.

L'image suivante montre la sortie générée par le code précédent:

Méthode 6

Ici, nous utiliserons le module nn pour résoudre ce problème. Après avoir importé la torche et les mathématiques de nos bibliothèques souhaitées, nous déclarerons les tenseurs pour attribuer des entrées et des sorties. Cet exemple peut être considéré comme un réseau neuronal de couche linéaire car la sortie résultante est une fonction linéaire de (x, x2, x3). Voyons que le code de ce scénario est l'image apposée suivante:

Autons le tenseur (x, x2, x3). Depuis P a la forme (3) et x.Unsqueeze (-1) a une structure (200, 1), la sémantique en streaming sera utilisée pour produire un tenseur de forme dans cette situation (200, 3). Pour construire notre modèle comme une série de couches, utilisez le package NN. NN est un module qui applique d'autres modules séquentiellement pour obtenir sa sortie, appelée module séquentiel. Le module linéaire maintient les tenseurs internes pour son biais et son poids et utilise une fonction linéaire pour calculer la sortie de l'entrée. Pour calculer la passe arrière, utilisez Autograd.

un.diplômé, b.Grad suivra cet appel. Les tenseurs détenant le gradient d'une perte concernant les lettres A, B, C et D sont désignés comme C.diplômé et d.diplômé, respectivement. Nous avons utilisé une erreur quadratique moyenne (MSE) comme fonction de perte, qui est définie dans le package NN ainsi que d'autres fonctions de perte proéminentes.

Passe avant: en donnant le modèle X, calculez le y prévu. L'opérateur __Call__ est étendu par des objets de module, vous permettant de les appeler comme des fonctions. Ce faisant, vous fournissez au module un tenseur de données d'entrée, et il renvoie un tenseur de sortie attendue. Duplicate et imprimer la perte La fonction de perte fournit un tenseur qui contient la perte après avoir reçu les tenseurs de nous contenant les valeurs vraies et prévues de Y.

Calculez le gradient d'une perte concernant chaque paramètre de modèle apprenable pendant la passe arrière. En raison du stockage interne des caractéristiques de chaque module dans les tenseurs qui nécessite un ensemble de gradations sur true, cette fonction calculera les gradients pour tous les paramètres du modèle apprenables. Vous pouvez accéder au calque initial du modèle en sélectionnant le premier élément dans une liste.

Enfin, le résultat est affiché en utilisant la fonction d'impression lorsque toute l'itération est exécutée avec succès.

Méthode 7

Torche.Le module NN est généralement le principal bloc de construction de Pytorch. Tout d'abord, définissez un nn.Objet module, puis appelez sa fonction avant pour l'exécuter. Cette méthode de fonctionnement est orientée vers l'objet. Un réseau RELU entièrement connecté comprend une couche cachée formée à la prévision de X en réduisant la distance euclidienne carrée.

Dans ce cas, le modèle est défini comme une sous-classe de module spécifique. Vous devez définir votre modèle de cette manière à chaque fois que vous voulez qu'il soit plus complexe qu'une liste simple de tous les modules actuels existants. Le code de l'explication précédente se trouve dans l'écran Spyder suivant:

Puis calculez la passe arrière à l'aide d'Autograd. La méthode déterminerait le gradient de perte pour tous les tenseurs avec un grad nécessaire = vrai. UN.diplômé, b.Grad suivra cet appel. Les tenseurs détenant le gradient de la perte concernant les lettres A, B, C et D sont désignés comme C.diplômé et d.diplômé, respectivement. Nous pouvons également définir une fonction personnalisée dans Pytorch.

Après avoir créé la classe Polynomial3, nous déclarerons les tenseurs pour maintenir l'entrée et la sortie. Quatre arguments sont créés et attribués en tant que paramètres du membre dans la fonction. Lorsqu'il est utilisé avec des modules, la sous-classe de tenseurs connue sous le nom de paramètre a une propriété très unique. Lorsqu'il est attribué en tant qu'attributs de module, le paramètre est automatiquement inclus dans la liste des paramètres du module et apparaîtra dans la liste des paramètres du module, E.g., Dans Paramètres () iterator. La méthode paramètres () dans chaque nn.Le module récupère les variables d'entraînement du module. Ces variables doivent être explicitement définies.

La fonction avant nécessite un tenseur de données d'entrée et un tenseur de données de sortie. Nous pouvons appliquer des opérateurs arbitraires sur les tenseurs et les modules définis dans le constructeur. Construire un optimiseur et notre fonction de perte. Les paramètres entraînant des membres du modèle et sont spécifiés avec le flambeau.nn.Le paramètre dans le constructeur SGD serait inclus dans l'appel à modèle.paramètres(). Ensuite, dans la passe avant, calculez le y (y_pred) prévu et passez-le la variable «var».À la fin, les gradients zéro effectueront automatiquement la passe arrière et exécuteront les poids.

La descente de gradient stochastique (SGD) est un optimiseur qui appartient à la famille de descente de gradient et est une technique d'optimisation bien connue utilisée dans l'apprentissage en profondeur et l'apprentissage automatique. Le terme «stochastique» fait référence à un système couplé ou lié à une probabilité aléatoire dans l'optimiseur SGD.

En fin de compte, nous allons calculer la perte et l'imprimer en lui attribuant la fonction de critère responsable du calcul de la perte. Nous avons passé le y et le modal prévu que nous avons formé. Alors déclarant une instruction if qui calcule le mode par 10 des valeurs variables «t». Ensuite, il l'incrémentera de 9, et la valeur résultante de t est transmise à la fonction d'impression à laquelle la perte sera calculée.

À la fin du code, le résultat sera exécuté avec succès, comme le montre la figure suivante:

Conclusion

L'application de l'API Pytorch pour les activités typiques de création du modèle d'apprentissage en profondeur est l'objectif central du tutoriel. Les informations que vous avez étudiées dans cet article devraient faciliter la mise en place de tous les concepts de pytorch sophistiqués auxquels vous avez peut-être pensé et apprendre les modules pytorch de l'installation de base du pytorch sur Python à la formation complexe d'un modèle. Nous avons également discuté des différentes façons d'implémenter un seul exemple à l'aide de différents modules, Numpy, Tenseur de torche, torche et Autograd, en établissant une nouvelle fonction Autograd, une fonction OPTIM, des modules NN, ainsi que le module NN personnalisé. La plate-forme utilisée pour exécuter notre code est Spyder; Vous pouvez utiliser d'autres plateformes, telles que Conda, Jupiter et Linux.