Opérations sur les tenseurs TensorFlow

Les tenseurs constituent la structure de données fondamentale de TensorFlow ; on peut les comprendre comme une extension du concept de tableaux multidimensionnels.

En apprentissage automatique, presque toutes les données sont finalement représentées sous forme de tenseurs pour être traitées.

Caractéristiques de base des tenseurs

  1. Type de données (dtype): Chaque tenseur possède un type de données spécifique, tel que tf.float32, tf.int64, etc.
  2. Forme: Représente la taille de chaque dimension du tenseur, par exemple, (2,3) représente une matrice avec 2 lignes et 3 colonnes.
  3. Emplacement du périphérique: Indique si le tenseur est stocké sur CPU ou GPU.

Dimensions des tenseurs

  • Tenseur 0-dimensionnel : scalaire, par ex.,tf.constant(5)
  • Tenseur 1-dimensionnel : vecteur, par ex.,tf.constant([1,2,3])
  • Tenseur 2-dimensionnel : matrice, par ex.,tf.constant([[1,2],[3,4]])
  • Tenseur 3-dimensionnel et plus : tenseurs d'ordre supérieur, par ex.,tf.ones((2,3,4))représente deux matrices 3×4

Méthodes courantes pour créer des tenseurs

1. Création à partir de listes Python/tableaux NumPy

Exemple

import tensorflow as tf
import numpy as np

# Créer à partir d'une liste Python
tensor_from_list = tf.constant([[1, 2], [3, 4]])

# Créer à partir d'un tableau NumPy
numpy_array = np.array([[5, 6], [7, 8]])
tensor_from_numpy = tf.constant(numpy_array)

2. Création de tenseurs de valeurs spéciales

Exemple

# Tenseur de zéros
zeros = tf.zeros((2, 3))  # Matrice de zéros avec 2 lignes et 3 colonnes

# Tenseur de uns
ones = tf.ones((3, 2))    # Matrice de uns avec 3 lignes et 2 colonnes

# Matrice identité
eye = tf.eye(3)           # Matrice identité 3×3

# Remplir avec une valeur spécifique
filled = tf.fill((2, 2), 7)  # Matrice 2×2, tous les éléments sont 7

3. Création de tenseurs aléatoires

Exemple

# Nombres aléatoires uniformément distribués
uniform = tf.random.uniform((2, 2), minval=0, maxval=1)

# Nombres aléatoires suivant une loi normale
normal = tf.random.normal((3, 3), mean=0, stddev=1)

# Permutation aléatoire
shuffled = tf.random.shuffle(tf.constant([1, 2, 3, 4, 5]))

Opérations de base sur les tenseurs

1. Opérations mathématiques

Exemple

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

# Addition élément par élément
add = tf.add(a, b)        # Ou utilisez la surcharge d'opérateur a + b

# Multiplication élément par élément
mul = tf.multiply(a, b)   # Ou a * b

# Multiplication matricielle
matmul = tf.matmul(a, b)  # Ou a @ b

# Autres opérations mathématiques
sqrt = tf.sqrt(tf.cast(a, tf.float32))  # Racine carrée (nécessite une conversion en type float)

2. Opérations sur les formes

Exemple

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

# Obtenir la forme
shape = tensor.shape  # Renvoie (2, 3)

# Changer la forme (reshape)
reshaped = tf.reshape(tensor, (3, 2))  # Changer en 3 lignes et 2 colonnes

# Transposition
transposed = tf.transpose(tensor)  # Changer en 3 lignes et 2 colonnes

# Étendre les dimensions (expand_dims)
expanded = tf.expand_dims(tensor, axis=0)  # La forme passe de (2,3) à (1,2,3)

3. Indexation et découpage

Exemple

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

# Obtenir un seul élément
elem = tensor[1, 2]  # Obtenir l'élément à la ligne 2, colonne 3 (la valeur est 6)

# Opération de découpage
row = tensor[1, :]    # Obtenir tous les éléments de la 2e ligne [4,5,6]
col = tensor[:, 1]    # Obtenir tous les éléments de la 2e colonne [2,5,8]
sub = tensor[0:2, 1:] # Obtenir les lignes 1-2, colonnes 2-3 [[2,3],[5,6]]

Mécanisme de diffusion des tenseurs

La diffusion est un mécanisme important dans TensorFlow pour gérer les opérations sur des tenseurs de formes différentes. Elle étend automatiquement le plus petit tenseur pour correspondre à la forme du plus grand tenseur.

Règles de diffusion

  1. Comparez les dimensions en partant de la dernière dimension et en avançant.
  2. Deux dimensions sont compatibles si elles sont égales, ou si l'une d'elles vaut 1, ou si l'une d'elles n'existe pas.
  3. Effectuer une expansion en copiant le long des dimensions manquantes ou de taille 1.

Exemples de diffusion

Exemple

# Ajouter un vecteur (3,) et un scalaire ()
a = tf.constant([1, 2, 3])
b = tf.constant(2)
c = a + b  # Le résultat est [3,4,5]; b est diffusé vers [2,2,2]

# Ajouter une matrice (3,1) et un vecteur (3,)
d = tf.constant([[1], [2], [3]])
e = tf.constant([10, 20, 30])
f = d + e  # d est diffusé vers [[1,1,1],[2,2,2],[3,3,3]]
           # Le résultat est [[11,21,31],[12,22,32],[13,23,33]]

Opérations d'agrégation de tenseurs

Fonctions d'agrégation courantes

Exemple

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

# Somme
sum_all = tf.reduce_sum(tensor)        # Somme de tous les éléments → 21
sum_axis0 = tf.reduce_sum(tensor, 0)  # Somme selon la dimension 0 (lignes) → [5,7,9]
sum_axis1 = tf.reduce_sum(tensor, 1)  # Somme le long de la dimension 1 (colonnes) → [6,15]

# Calculer la moyenne
mean_all = tf.reduce_mean(tensor)      # Moyenne de tous les éléments → 3.5

# Maximum/Minimum
max_val = tf.reduce_max(tensor)        # Maximum → 6
min_val = tf.reduce_min(tensor)       # Minimum → 1

# Opérations logiques
any_true = tf.reduce_any(tensor > 4)   # Si au moins un élément est > 4 → True
all_true = tf.reduce_all(tensor > 0)   # Si tous les éléments sont > 0 → True

Travaux pratiques

Exercice 1 : Création et manipulation de tenseurs

Exemple

# 1. Créer une matrice aléatoire 3×3 avec des valeurs d'éléments comprises entre 0 et 10
random_matrix = tf.random.uniform((3, 3), minval=0, maxval=10, dtype=tf.int32)

# 2. Calculer la transposée de la matrice
transposed_matrix = tf.transpose(random_matrix)

# 3. Calculer le produit de la matrice et de sa transposée
product = tf.matmul(random_matrix, transposed_matrix)

# 4. Calculer la somme des éléments diagonaux de la matrice produit
diag_sum = tf.reduce_sum(tf.linalg.diag_part(product))

Exercice 2 : Application du mécanisme de diffusion

Exemple

# 1. Créer une matrice 4×1 et un vecteur 1×4
matrix = tf.constant([[1], [2], [3], [4]])
vector = tf.constant([10, 20, 30, 40])

# 2. Utiliser le mécanisme de diffusion pour calculer leur somme
broadcast_sum = matrix + vector

# 3. Vérifier la forme et les valeurs du résultat
print("Forme :", broadcast_sum.shape)  # Devrait être (4,4)
print("Résultat :", broadcast_sum.numpy())
Autres extensions