Tutoriel PyTorch avec régression linéaire

PyTorch est un package scientifique basé sur Python qui remplace les ndarrays NumPy en tant que tenseurs qui tirent le meilleur parti des GPU. Un autre point positif du framework PyTorch est la vitesse et la flexibilité qu'il offre pendant le calcul. PyTorch est une alternative efficace pour travailler avec Tensors en utilisant Tensorflow que nous avons étudié précédemment.

PyTorch présente quelques gros avantages en tant que package de calcul, tels que :

Il est possible de construire des graphes de calcul au fur et à mesure. Cela signifie qu'il n'est pas nécessaire de connaître à l'avance les besoins en mémoire du graphe. Nous pouvons librement créer un réseau de neurones et l'évaluer pendant l'exécution.
API facile à Python qui est facilement intégrable
Soutenu par Facebook, donc le soutien de la communauté est très fort
Fournit une prise en charge multi-GPU nativement

PyTorch est principalement adopté par la communauté Data Science en raison de sa capacité à définir facilement les réseaux de neurones. Voyons ce package de calcul en action dans cette leçon.

Installation de PyTorch

Juste une remarque avant de commencer, vous pouvez utiliser un environnement virtuel pour cette leçon que nous pouvons faire avec la commande suivante :

python -m virtualenv pytorch
source pytorch/bin/activer

Une fois l'environnement virtuel actif, vous pouvez installer la bibliothèque PyTorch dans l'environnement virtuel afin que les exemples que nous créons ensuite puissent être exécutés :

pip installer pytorch

Nous utiliserons Anaconda et Jupyter dans cette leçon. Si vous souhaitez l'installer sur votre machine, regardez la leçon qui décrit "Comment installer Anaconda Python sur Ubuntu 18.04 LTS" et partagez vos commentaires si vous rencontrez des problèmes. Pour installer PyTorch avec Anaconda, utilisez la commande suivante dans le terminal d'Anaconda :

conda install -c pytorch pytorch

Nous voyons quelque chose comme ceci lorsque nous exécutons la commande ci-dessus :

Une fois que tous les packages nécessaires sont installés et terminés, nous pouvons commencer à utiliser la bibliothèque PyTorch avec l'instruction d'importation suivante :

torche d'importation

Commençons par les exemples de base de PyTorch maintenant que nous avons installé les packages de prérequis.

Premiers pas avec PyTorch

Comme nous savons que les réseaux de neurones peuvent être fondamentalement structurés car les tenseurs et PyTorch sont construits autour de tenseurs, les performances ont tendance à être considérablement améliorées. Nous allons commencer avec PyTorch en examinant d'abord le type de Tensors qu'il fournit. Pour commencer, importez les packages requis :

torche d'importation

Ensuite, nous pouvons définir un Tensor non initialisé avec une taille définie :

x = torche.vide(4, 4)
print("Type de tableau : ".format(x.type)) # type
print("Forme du tableau : ".format(x.forme)) # forme
imprimer(x)

Nous voyons quelque chose comme ceci lorsque nous exécutons le script ci-dessus :

Nous venons de créer un Tensor non initialisé avec une taille définie dans le script ci-dessus. Pour réitérer notre leçon Tensorflow, les tenseurs peuvent être qualifiés de tableau à n dimensions qui nous permet de représenter des données dans une dimension complexe.

Exécutons un autre exemple où nous initialisons un tenseur Torched avec des valeurs aléatoires :

random_tensor = torche.rand(5, 4)
print(random_tensor)

Lorsque nous exécutons le code ci-dessus, nous verrons un objet tenseur aléatoire imprimé :

Veuillez noter que la sortie du tenseur aléatoire ci-dessus peut être différente pour vous car, eh bien, elle est aléatoire !

Conversion entre NumPy et PyTorch

NumPy et PyTorch sont complètement compatibles les uns avec les autres. C'est pourquoi, il est facile de transformer des tableaux NumPy en tenseurs et vice-versa. Outre la facilité fournie par l'API, il est probablement plus facile de visualiser les tenseurs sous forme de tableaux NumPy au lieu de Tensors, ou appelez simplement cela mon amour pour NumPy!

Par exemple, nous allons importer NumPy dans notre script et définir un tableau aléatoire simple :

importer numpy en tant que np
tableau = np.Aléatoire.rand(4, 3)
tenseur_transformé = torche.from_numpy(tableau)
print("\n".format(transformé_tenseur))

Lorsque nous exécutons le code ci-dessus, nous verrons l'objet tenseur transformé imprimé :

Essayons maintenant de reconvertir ce tenseur en tableau NumPy :

numpy_arr = tenseur_transformé.numpy()
print(" \n".format(type(numpy_arr), numpy_arr))

Lorsque nous exécutons le code ci-dessus, nous verrons le tableau NumPy transformé imprimé :

Si nous regardons de près, même la précision de la conversion est maintenue lors de la conversion du tableau en un tenseur, puis de sa reconversion en un tableau NumPy.

Opérations tensorielles

Avant de commencer notre discussion sur les réseaux de neurones, nous devons connaître les opérations qui peuvent être effectuées sur les tenseurs lors de l'entraînement des réseaux de neurones. Nous utiliserons également largement le module NumPy.

Trancher un tenseur

Nous avons déjà regardé comment faire un nouveau Tensor, faisons-en un maintenant et tranche il:

vecteur = torche.tenseur([1, 2, 3, 4, 5, 6])
imprimer(vecteur[1:4])

L'extrait de code ci-dessus nous fournira le résultat suivant :

tenseur([2, 3, 4])

On peut ignorer le dernier index :

imprimer(vecteur[1:])

Et nous récupérerons également ce qui est attendu avec une liste Python :

tenseur([2, 3, 4, 5, 6])

Faire un tenseur flottant

Créons maintenant un Tensor flottant :

float_vector = torche.FloatTensor([1, 2, 3, 4, 5, 6])
print(float_vector)

L'extrait de code ci-dessus nous fournira le résultat suivant :

tenseur([1., 2., 3., 4., 5., 6.])

Le type de ce Tenseur sera :

print(float_vector.type)

Rend:

torche.float32

Opérations arithmétiques sur les tenseurs

Nous pouvons ajouter deux tenseurs comme n'importe quel élément mathématique, comme :

tenseur_1 = torche.tenseur([2, 3, 4])
tenseur_2 = torche.tenseur([3, 4, 5])
tenseur_1 + tenseur_2

L'extrait de code ci-dessus nous donnera :

Nous pouvons multiplier un tenseur avec un scalaire :

tenseur_1 * 5

Cela nous donnera :

Nous pouvons effectuer un produit scalaire entre deux tenseurs aussi :

d_product = torche.point(tenseur_1, tenseur_2)
d_produit

L'extrait de code ci-dessus nous fournira le résultat suivant :

Dans la prochaine section, nous examinerons la dimension supérieure des Tenseurs et des matrices.

Multiplication matricielle

Dans cette section, nous verrons comment définir des métriques comme des tenseurs et les multiplier, comme nous le faisions en mathématiques au lycée.

Nous allons définir une matrice pour commencer :

matrice = torche.tenseur([1, 3, 5, 6, 8, 0]).vue(2, 3)

Dans l'extrait de code ci-dessus, nous avons défini une matrice avec la fonction de tenseur, puis spécifié avec fonction d'affichage qu'il devrait être fait comme un tenseur à 2 dimensions avec 2 lignes et 3 colonnes. Nous pouvons fournir plus d'arguments à la vue fonction pour spécifier plus de dimensions. Notez simplement que :

nombre de lignes multiplié par nombre de colonnes = nombre d'éléments

Lorsque nous visualisons le tenseur bidimensionnel ci-dessus, nous verrons la matrice suivante :

On va définir une autre matrice identique avec une forme différente :

matrice_b = torche.tenseur([1, 3, 5, 6, 8, 0]).vue (3, 2)

Nous pouvons enfin effectuer la multiplication maintenant :

torche.matmul(matrice, matrice_b)

L'extrait de code ci-dessus nous fournira le résultat suivant :

Régression linéaire avec PyTorch

La régression linéaire est un algorithme d'apprentissage automatique basé sur des techniques d'apprentissage supervisé pour effectuer une analyse de régression sur une variable indépendante et dépendante. Déjà confus? Définissons la régression linéaire avec des mots simples.

La régression linéaire est une technique pour découvrir la relation entre deux variables et prédire combien de changement dans la variable indépendante provoque combien de changement dans la variable dépendante. Par exemple, un algorithme de régression linéaire peut être appliqué pour savoir de combien le prix augmente pour une maison lorsque sa superficie est augmentée d'une certaine valeur. Ou, quelle est la puissance d'une voiture en fonction du poids de son moteur. Le 2ème exemple peut sembler étrange mais vous pouvez toujours essayer des choses étranges et qui sait que vous êtes capable d'établir une relation entre ces paramètres avec la régression linéaire!

La technique de régression linéaire utilise généralement l'équation d'une ligne pour représenter la relation entre la variable dépendante (y) et la variable indépendante (x):

y = m * x + c

Dans l'équation ci-dessus :

m = pente de la courbe
c = biais (point qui coupe l'axe des y)

Maintenant que nous avons une équation représentant la relation de notre cas d'utilisation, nous allons essayer de configurer des exemples de données avec une visualisation de tracé. Voici les exemples de données pour les prix des logements et leurs tailles :

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
house_price_np = np.array(house_prices_array, dtype=np.float32)
house_price_np = house_price_np.remodeler (-1,1)
house_price_tensor = Variable (torche.from_numpy(house_price_np))
taille_maison = [ 7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.array(house_size, dtype=np.float32)
house_size_np = house_size_np.remodeler (-1, 1)
house_size_tensor = Variable (torche.from_numpy(house_size_np))
# permet de visualiser nos données
importer matplotlib.pyplot en tant que plt
plt.scatter(house_prices_array, house_size_np)
plt.xlabel("Prix de la maison $")
plt.ylabel("Tailles de la maison")
plt.title("Prix de la maison $ VS Taille de la maison")
plt

Notez que nous avons utilisé Matplotlib qui est une excellente bibliothèque de visualisation. En savoir plus à ce sujet dans le didacticiel Matplotlib. Nous verrons le graphique suivant une fois que nous aurons exécuté l'extrait de code ci-dessus :

Lorsque nous traçons une ligne à travers les points, ce n'est peut-être pas parfait mais c'est quand même suffisant pour le type de relation que les variables ont. Maintenant que nous avons collecté et visualisé nos données, nous voulons prédire quelle sera la taille de la maison si elle était vendue pour 650 000 $.

Le but de l'application de la régression linéaire est de trouver une ligne qui correspond à nos données avec un minimum d'erreur. Voici les étapes que nous allons effectuer pour appliquer l'algorithme de régression linéaire à nos données :

Construire une classe pour la régression linéaire
Définir le modèle à partir de cette classe de régression linéaire
Calculer la MSE (Erreur quadratique moyenne)
Effectuez une optimisation pour réduire l'erreur (SGD i.e. descente de gradient stochastique)
Effectuer une rétropropagation
Enfin, faites la prédiction

Commençons par appliquer les étapes ci-dessus avec des importations correctes :

torche d'importation
de torche.Variable d'importation automatique
torche d'importation.nn comme nn

Ensuite, nous pouvons définir notre classe de régression linéaire qui hérite du module de réseau de neurones PyTorch :

class LinearRegression(nn.Module):
def __init__(self,input_size,output_size):
# super fonction hérite de nn.Module pour que nous puissions accéder à tout depuis nn.Module
super (Régression Linéaire, soi).__init__()
# Fonction linéaire
soi.linéaire = nn.Linéaire (input_dim, output_dim)
def forward(self,x):
retourner soi-même.linéaire(x)

Maintenant que nous sommes prêts avec la classe, définissons notre modèle avec une taille d'entrée et de sortie de 1 :

input_dim = 1
output_dim = 1
model = LinearRegression(input_dim, output_dim)

Nous pouvons définir le MSE comme :

mse = nn.MSELoss()

Nous sommes prêts à définir l'optimisation qui peut être effectuée sur la prédiction du modèle pour de meilleures performances :

# Optimisation (trouver des paramètres qui minimisent l'erreur)
taux_apprentissage = 0.02
optimiseur = torche.optimal.SGD (modèle.paramètres(), lr=taux d'apprentissage)

Nous pouvons enfin faire un tracé pour la fonction de perte sur notre modèle :

liste_pertes = []
iteration_number = 1001
pour l'itération dans la plage (iteration_number):
# effectuer une optimisation avec un gradient zéro
optimiseur.zero_grad()
résultats = modèle(house_price_tensor)
perte = mse (résultats, house_size_tensor)
# calcule la dérivée en reculant
perte.en arrière()
# Mise à jour des paramètres
optimiseur.marcher()
# perte de magasin
liste_pertes.ajouter (perte.Les données)
# perte d'impression
if(itération % 50 == 0) :
print('époque , perte '.format (itération, perte.Les données))
plt.plot(range(iteration_number),loss_list)
plt.xlabel("Nombre d'itérations")
plt.ylabel("Perte")
plt

Nous avons effectué des optimisations à plusieurs reprises sur la fonction de perte et essayons de visualiser l'augmentation ou la diminution des pertes. Voici l'intrigue qui est la sortie:

On voit que plus le nombre d'itérations est élevé, la perte tend vers zéro. Cela signifie que nous sommes prêts à faire notre prédiction et à la tracer :

# prédire le prix de notre voiture
prédit = modèle(house_price_tensor).Les données.numpy()
plt.scatter(house_prices_array, house_size, label = "original data",color ="red")
plt.scatter(house_prices_array, predicted, label = "predicted data",color ="blue")
plt.Légende()
plt.xlabel("Prix de la maison $")
plt.ylabel("Taille de la maison")
plt.title("Valeurs d'origine vs valeurs prédites")
plt.spectacle()

Voici le tracé qui nous aidera à faire la prédiction :

Conclusion

Dans cette leçon, nous avons examiné un excellent package de calcul qui nous permet de faire des prédictions plus rapides et efficaces et bien plus encore. PyTorch est populaire en raison de la façon dont il nous permet de gérer les réseaux de neurones de manière fondamentale avec les Tensors.