Introduction

Dans le domaine du Deep Learning, les tensors sont les structures de données fondamentales. Ce TP vous guidera à travers la manipulation de tensors et d'éléments essentiels dans trois frameworks populaires : TensorFlow, Keras et PyTorch. Nous allons résoudre les problèmes suivants :

• Comprendre la création, la manipulation et les opérations fondamentales sur les tensors.
• Identifier les différences de syntaxe et de bibliothèques entre les frameworks.
• Acquérir les compétences nécessaires pour choisir le framework le plus adapté à une tâche donnée.

Objectifs Pédagogiques

• Maîtriser la création et l'initialisation des tensors dans TensorFlow, Keras et PyTorch.
• Effectuer des opérations mathématiques et des transformations de base sur les tensors.
• Comprendre et manipuler les dimensions (shape) des tensors.
• Appréhender les différences de syntaxe et de bibliothèques entre les frameworks.
• Être capable de choisir un framework en fonction des besoins d'un projet.

Prérequis

• Python 3.7+
• Bibliothèques Python : NumPy

Installation

• TensorFlow: pip install tensorflow
• PyTorch: Suivez les instructions spécifiques à votre système sur pytorch.org. pip install torch torchvision torchaudio

Environnements de Développement

• Google Colab: (Recommandé pour ce TP)
  • Environnement cloud avec TensorFlow et PyTorch préinstallés.
  • Accès : colab.research.google.com
  • Création d'un nouvel environnement Colab : Simplement ouvrir un nouveau notebook.
• Anaconda (Local):
  • Gestionnaire d'environnement pour Python.
  • Installation et configuration :
    1. Téléchargez Anaconda : anaconda.com.
    2. Installez Anaconda.
    3. Créez un nouvel environnement : conda create --name mon_environnement python=3.8
    4. Activez l'environnement : conda activate mon_environnement
    5. Installez les bibliothèques : pip install tensorflow torch torchvision torchaudio

Étapes du TP

Étape 1: Création et Initialisation des Tensors

Cette section explore la création de tensors dans les trois frameworks. Les tensors peuvent être créés à partir de listes Python, de tableaux NumPy, ou initialisés avec des valeurs spécifiques (zéros, uns, valeurs aléatoires).

TensorFlow

import tensorflow as tf
import numpy as np

# Création à partir d'une liste Python
tensor_tf_list = tf.constant([1, 2, 3, 4, 5])
print(f"TensorFlow (List): {tensor_tf_list}")

# Création à partir d'un tableau NumPy
array_np = np.array([[1, 2], [3, 4]])
tensor_tf_np = tf.constant(array_np)
print(f"TensorFlow (NumPy): {tensor_tf_np}")

# Initialisation avec des valeurs spécifiques
zeros_tf = tf.zeros((2, 3))
ones_tf = tf.ones((3, 2))
random_tf = tf.random.normal((2, 2))

print(f"TensorFlow (Zeros): {zeros_tf}")
print(f"TensorFlow (Ones): {ones_tf}")
print(f"TensorFlow (Random Normal): {random_tf}")

Fonctions importantes (TensorFlow):

• tf.constant(value, dtype=None): Crée un tensor constant à partir d'une valeur (liste, NumPy array, etc.).
• tf.zeros(shape, dtype=tf.float32): Crée un tensor rempli de zéros avec la forme spécifiée.
• tf.ones(shape, dtype=tf.float32): Crée un tensor rempli d'uns avec la forme spécifiée.
• tf.random.normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32): Crée un tensor rempli de valeurs aléatoires suivant une distribution normale.

Keras

import tensorflow as tf
from tensorflow import keras
import numpy as np

# Keras utilise les tensors TensorFlow sous le capot
tensor_keras = tf.constant([6, 7, 8, 9, 10])
print(f"Keras (TensorFlow Tensor): {tensor_keras}")

# Variables Keras (utile pour les paramètres entraînables)
variable_keras = tf.Variable(tf.random.normal((2, 2)))
print(f"Keras Variable: {variable_keras}")

Fonctions importantes (Keras):

• tf.Variable(initial_value, trainable=True): Crée une variable (tensor mutable) qui peut être entraînée.

PyTorch

import torch
import numpy as np

# Création à partir d'une liste Python
tensor_torch_list = torch.tensor([1, 2, 3, 4, 5])
print(f"PyTorch (List): {tensor_torch_list}")

# Création à partir d'un tableau NumPy
array_np = np.array([[1, 2], [3, 4]])
tensor_torch_np = torch.tensor(array_np)
print(f"PyTorch (NumPy): {tensor_torch_np}")

# Initialisation avec des valeurs spécifiques
zeros_torch = torch.zeros((2, 3))
ones_torch = torch.ones((3, 2))
random_torch = torch.randn((2, 2))

print(f"PyTorch (Zeros): {zeros_torch}")
print(f"PyTorch (Ones): {ones_torch}")
print(f"PyTorch (Random Normal): {random_torch}")

Fonctions importantes (PyTorch):

• torch.tensor(data, dtype=None): Crée un tensor à partir de données (liste, NumPy array, etc.).
• torch.zeros(size, dtype=torch.float32): Crée un tensor rempli de zéros avec la taille spécifiée.
• torch.ones(size, dtype=torch.float32): Crée un tensor rempli d'uns avec la taille spécifiée.
• torch.randn(size, dtype=torch.float32): Crée un tensor rempli de valeurs aléatoires suivant une distribution normale.

Étape 2: Opérations sur les Tensors

Cette section couvre les opérations mathématiques de base sur les tensors, ainsi que le redimensionnement et la concaténation.

TensorFlow

import tensorflow as tf

tensor_a_tf = tf.constant([[1, 2], [3, 4]])
tensor_b_tf = tf.constant([[5, 6], [7, 8]])

# Addition et Multiplication
add_tf = tf.add(tensor_a_tf, tensor_b_tf)
multiply_tf = tf.multiply(tensor_a_tf, tensor_b_tf) #Element-wise multiplication

# Produit matriciel
matmul_tf = tf.matmul(tensor_a_tf, tensor_b_tf)

# Redimensionnement
reshape_tf = tf.reshape(tensor_a_tf, (4, 1))

# Concaténation
concat_tf = tf.concat([tensor_a_tf, tensor_b_tf], axis=0)  # Concaténation sur les lignes

print(f"TensorFlow (Addition): {add_tf}")
print(f"TensorFlow (Element-wise Multiplication): {multiply_tf}")
print(f"TensorFlow (Matmul): {matmul_tf}")
print(f"TensorFlow (Reshape): {reshape_tf}")
print(f"TensorFlow (Concatenation): {concat_tf}")

Keras

import tensorflow as tf
from tensorflow import keras

# Keras utilise les fonctions TensorFlow
tensor_a_keras = tf.constant([[1, 2], [3, 4]])
tensor_b_keras = tf.constant([[5, 6], [7, 8]])

add_keras = tf.add(tensor_a_keras, tensor_b_keras)
multiply_keras = tf.multiply(tensor_a_keras, tensor_b_keras) #Element-wise multiplication
matmul_keras = tf.matmul(tensor_a_keras, tensor_b_keras)
reshape_keras = tf.reshape(tensor_a_keras, (4, 1))
concat_keras = tf.concat([tensor_a_keras, tensor_b_keras], axis=0)

print(f"Keras (Addition): {add_keras}")
print(f"Keras (Element-wise Multiplication): {multiply_keras}")
print(f"Keras (Matmul): {matmul_keras}")
print(f"Keras (Reshape): {reshape_keras}")
print(f"Keras (Concatenation): {concat_keras}")

PyTorch

import torch

tensor_a_torch = torch.tensor([[1, 2], [3, 4]])
tensor_b_torch = torch.tensor([[5, 6], [7, 8]])

# Addition et Multiplication
add_torch = torch.add(tensor_a_torch, tensor_b_torch)
multiply_torch = torch.mul(tensor_a_torch, tensor_b_torch) #Element-wise multiplication

# Produit matriciel
matmul_torch = torch.matmul(tensor_a_torch, tensor_b_torch)

# Redimensionnement
reshape_torch = tensor_a_torch.reshape((4, 1))

# Concaténation
concat_torch = torch.cat([tensor_a_torch, tensor_b_torch], dim=0)  # Concaténation sur les lignes

print(f"PyTorch (Addition): {add_torch}")
print(f"PyTorch (Element-wise Multiplication): {multiply_torch}")
print(f"PyTorch (Matmul): {matmul_torch}")
print(f"PyTorch (Reshape): {reshape_torch}")
print(f"PyTorch (Concatenation): {concat_torch}")

Étape 3: Dimensions (Shape) des Tensors

La manipulation des dimensions (shape) est cruciale pour assurer la compatibilité entre les opérations. Cette section montre comment obtenir et modifier le shape d'un tensor.

TensorFlow

import tensorflow as tf

tensor_tf = tf.constant([[1, 2, 3], [4, 5, 6]])

# Obtenir le shape
shape_tf = tf.shape(tensor_tf)
print(f"TensorFlow (Shape): {shape_tf}")

# Redimensionner
reshaped_tf = tf.reshape(tensor_tf, (3, 2))
print(f"TensorFlow (Reshaped): {reshaped_tf}")

Keras

import tensorflow as tf
from tensorflow import keras

tensor_keras = tf.constant([[1, 2, 3], [4, 5, 6]])
shape_keras = tf.shape(tensor_keras)
print(f"Keras (Shape): {shape_keras}")

reshaped_keras = tf.reshape(tensor_keras, (3, 2))
print(f"Keras (Reshaped): {reshaped_keras}")

PyTorch

import torch

tensor_torch = torch.tensor([[1, 2, 3], [4, 5, 6]])

# Obtenir le shape
shape_torch = tensor_torch.shape
print(f"PyTorch (Shape): {shape_torch}")

# Redimensionner
reshaped_torch = tensor_torch.reshape((3, 2))
print(f"PyTorch (Reshaped): {reshaped_torch}")

Conclusion

Ce TP a couvert les bases de la manipulation des tensors dans TensorFlow, Keras et PyTorch. Vous avez appris à créer, initialiser, opérer et transformer des tensors. Les exercices vous ont permis de pratiquer ces compétences et d'appréhender les différences entre les frameworks. Ces fondations sont essentielles pour aborder des concepts plus avancés, comme les réseaux de neurones.

Exercices Supplémentaires

1. Implémentez une fonction qui normalise un tensor (met chaque valeur entre 0 et 1) dans chaque framework.
2. Créez une fonction qui calcule la transposée d'une matrice dans chaque framework.
3. Écrivez une fonction qui calcule la moyenne de tous les éléments d'un tensor dans chaque framework.

Voir aussi:

Pourquoi utiliser TensorFlow ou PyTorch plutôt que seulement Python pour le Deep Learning ?

Graphes de Calcul : Explication et Application en Apprentissage Profond