Calcul des Normes de Tenseurs
Les normes sont des fonctions mathématiquse qui mesurent la "taille" ou la "magnitude" d'un vecteur ou, plus généralement, d'un tenseur. TensorFlow offre des outils pour calculer différentes normes, telles que la norme L2 (euclidienne) et la norme L1 (Manhattan), qui sont couramment utilisées en apprentissage profond.
import tensorflow as tf
import numpy as np
# Fonction utilitaire pour un affichage clair
def afficher(prefixe="", valeur=""):
print(prefixe, valeur, "\n")
# Démonstration du calcul de la norme L2 (euclidienne)
# Créons un tenseur 2D simple
un_tenseur = tf.constant([[2.0, 3.0], [4.0, 5.0]], dtype=tf.float32)
afficher("Tenseur d'entrée :", un_tenseur)
# Calcul automatique de la norme L2 avec tf.norm
norme_l2_automatique = tf.norm(un_tenseur)
afficher("Norme L2 (calculée par tf.norm) :", norme_l2_automatique)
# Vérification manuelle de la norme L2
# 1. Élever chaque élément au carré
elements_au_carre = tf.square(un_tenseur)
afficher("Éléments au carré :", elements_au_carre)
# 2. Sommer tous les carrés
somme_des_carres = tf.reduce_sum(elements_au_carre)
afficher("Somme des carrés des éléments :", somme_des_carres)
# 3. Prendre la racine carrée de la somme
racine_carree_somme = tf.sqrt(somme_des_carres)
afficher("Racine carrée de la somme des carrés :", racine_carree_somme)
# Les résultats des deux méthodes de calcul de la norme L2 sont identiques.
# Démonstration du calcul de la norme L1 (somme des valeurs absolues)
norme_l1_automatique = tf.norm(un_tenseur, ord=1)
afficher("Norme L1 (calculée par tf.norm) :", norme_l1_automatique)
# Vérification manuelle de la norme L1
somme_valeurs_absolues = tf.reduce_sum(tf.abs(un_tenseur))
afficher("Somme des valeurs absolues (vérification) :", somme_valeurs_absolues)
# Calcul de la norme L1 le long d'un axe spécifique (ici, axis=1 pour chaque ligne)
norme_l1_par_axe = tf.norm(un_tenseur, ord=1, axis=1)
afficher("Norme L1 par ligne (axis=1) :", norme_l1_par_axe)
Opérations d'Agrégasion : Min, Max et Moyenne
TensorFlow facilite l'exécution d'opérations d'agrégation telles que le calcul des valeurs minimales, maximales et moyennes. Ces opérations peuvent être appliquées à l'ensemble d'un tenseur ou le long d'un axe spécifié, offrant une grande flexibilité pour l'analyse de données.
# Création d'un tenseur 2D d'exemple
donnees_numeriques = tf.range(10, 22, dtype=tf.float32)
donnees_numeriques = tf.reshape(donnees_numeriques, (3, 4))
afficher("Tenseur de données :", donnees_numeriques)
# Recherche de la valeur minimale globale
valeur_min_globale = tf.reduce_min(donnees_numeriques)
afficher("Valeur minimale du tenseur :", valeur_min_globale)
# Recherche de la valeur maximale globale
valeur_max_globale = tf.reduce_max(donnees_numeriques)
afficher("Valeur maximale du tenseur :", valeur_max_globale)
# Calcul de la moyenne globale
moyenne_globale = tf.reduce_mean(donnees_numeriques)
afficher("Moyenne du tenseur :", moyenne_globale)
# Calcul des agrégats le long de l'axe 0 (par colonne)
min_par_colonne = tf.reduce_min(donnees_numeriques, axis=0)
afficher("Minimum par colonne (axis=0) :", min_par_colonne)
max_par_colonne = tf.reduce_max(donnees_numeriques, axis=0)
afficher("Maximum par colonne (axis=0) :", max_par_colonne)
moyenne_par_colonne = tf.reduce_mean(donnees_numeriques, axis=0)
afficher("Moyenne par colonne (axis=0) :", moyenne_par_colonne)
# Calcul des agrégats le long de l'axe 1 (par ligne)
min_par_ligne = tf.reduce_min(donnees_numeriques, axis=1)
afficher("Minimum par ligne (axis=1) :", min_par_ligne)
max_par_ligne = tf.reduce_max(donnees_numeriques, axis=1)
afficher("Maximum par ligne (axis=1) :", max_par_ligne)
moyenne_par_ligne = tf.reduce_mean(donnees_numeriques, axis=1)
afficher("Moyenne par ligne (axis=1) :", moyenne_par_ligne)
Identification des Indices : tf.argmax et tf.argmin
Les fonctions tf.argmax et tf.argmin sont essentielles pour l'apprentissage automatique, car elles permettent de trouver les indices des valeurs maximales ou minimales d'un tenseur. Ceci est particulièrement utile pour déterminer la classe prédite par un modèle de classification ou pour d'autres tâches nécessitant l'identification de positions spécifiques.
# Création d'un tenseur avec des valeurs aléatoires
matrice_pred_scores = tf.random.uniform((5, 10), minval=0, maxval=100, dtype=tf.int32)
afficher("Scores de prédiction (matrice) :", matrice_pred_scores)
# Obtention des indices des valeurs maximales le long de l'axe 1 (par ligne)
# Ceci simule l'obtention de la classe avec le score le plus élevé pour chaque échantillon.
indices_classes_max = tf.argmax(matrice_pred_scores, axis=1)
afficher("Indices des scores maximums par ligne (classes prédites) :", indices_classes_max)
# Obtention des indices des valeurs minimales le long de l'axe 1 (par ligne)
indices_min_valeurs = tf.argmin(matrice_pred_scores, axis=1)
afficher("Indices des scores minimums par ligne :", indices_min_valeurs)
Comparaison de Tenseurs et Filtrage Conditionnel
La capacité de comparer des tenseurs élément par élément et d'appliquer un filtrage conditionnel est fondamentale pour la manipulation des données. TensorFlow permet non seulement de réaliser ces comparaisons mais aussi d'extraire les éléments ou leurs indices basés sur les résultats.
# Génération de deux tenseurs avec des valeurs aléatoires pour la comparaison
t_a = tf.random.uniform((3, 6), minval=0, maxval=7, dtype=tf.int32)
t_b = tf.random.uniform((3, 6), minval=0, maxval=7, dtype=tf.int32)
afficher("Tenseur A :", t_a)
afficher("Tenseur B :", t_b)
# Comparaison élément par élément pour l'égalité (renvoie un tenseur booléen)
resultat_egalite = tf.equal(t_a, t_b) # Peut aussi s'écrire t_a == t_b
afficher("Résultat de la comparaison (A == B) :", resultat_egalite)
# Extraction des éléments du tenseur A où la condition A == B est vraie
elements_correspondants_a = t_a[resultat_egalite]
afficher("Éléments de A où A et B sont égaux :", elements_correspondants_a)
# Obtention des coordonnées (indices) où la condition A == B est vraie
indices_de_correspondance = tf.where(resultat_egalite)
afficher("Indices des positions où A et B sont égaux :", indices_de_correspondance)
Tri de Tenseurs Unidmiensionnels
Le tri est une opération de base pour organiser les données. TensorFlow propose des fonctions pour trier les valeurs d'un tenseur et pour obtenir les indices qui, si utilisés pour réorganiser le tenseur original, produiraient un tenseur trié.
# Création d'un vecteur 1D avec des valeurs mélangées
vecteur_initial = tf.random.shuffle(tf.range(15))
afficher("Vecteur initial non ordonné :", vecteur_initial)
# Tri des valeurs en ordre croissant
vecteur_tri_ascendant = tf.sort(vecteur_initial, direction="ASCENDING")
afficher("Vecteur trié (ascendant) :", vecteur_tri_ascendant)
# Tri des valeurs en ordre décroissant
vecteur_tri_descendant = tf.sort(vecteur_initial, direction="DESCENDING")
afficher("Vecteur trié (descendant) :", vecteur_tri_descendant)
# Obtention des indices de tri en ordre croissant des valeurs
indices_pour_tri_ascendant = tf.argsort(vecteur_initial, direction="ASCENDING")
afficher("Indices pour trier en ascendant :", indices_pour_tri_ascendant)
# Obtention des indices de tri en ordre décroissant des valeurs
indices_pour_tri_descendant = tf.argsort(vecteur_initial, direction="DESCENDING")
afficher("Indices pour trier en descendant :", indices_pour_tri_descendant)
# Reconstruire le tenseur trié en utilisant tf.gather et les indices
vecteur_reordonne_par_indices = tf.gather(vecteur_initial, indices_pour_tri_descendant)
afficher("Vecteur initial reordonné avec indices descendants :", vecteur_reordonne_par_indices)
Tri de Tenseurs Multidimensionnels
Pour les tenseurs ayant plusieurs dimensions (comme des matrices), le tri peut être effectué le long d'un axe spécifique. Cela permet de trier, par exemple, chaque ligne ou chaque colonne indépendamment, ce qui est très pratique pour la préparation ou l'analyse de jeux de données.
# Création d'un tenseur 2D aléatoire
matrice_multi = tf.random.uniform([5, 4], maxval=50, dtype=tf.int32)
afficher("Matrice 2D d'origine :", matrice_multi)
# Tri des valeurs de chaque ligne (axis=1) en ordre croissant
matrice_tri_par_lignes_asc = tf.sort(matrice_multi, axis=1, direction="ASCENDING")
afficher("Matrice triée par lignes (ascendant) :", matrice_tri_par_lignes_asc)
# Tri des valeurs de chaque ligne (axis=1) en ordre décroissant
matrice_tri_par_lignes_desc = tf.sort(matrice_multi, axis=1, direction="DESCENDING")
afficher("Matrice triée par lignes (descendant) :", matrice_tri_par_lignes_desc)
# Obtention des indices de tri pour chaque ligne (axis=1) en ordre croissant
indices_tri_lignes_asc = tf.argsort(matrice_multi, axis=1, direction="ASCENDING")
afficher("Indices de tri par lignes (ascendant) :", indices_tri_lignes_asc)
# Obtention des indices de tri pour chaque ligne (axis=1) en ordre décroissant
indices_tri_lignes_desc = tf.argsort(matrice_multi, axis=1, direction="DESCENDING")
afficher("Indices de tri par lignes (descendant) :", indices_tri_lignes_desc)
Extraction des Top K Éléments
La fonction tf.math.top_k est un outil puissant pour identifier et extraire les K plus grandes valeurs d'un tenseur le long d'un axe donné, ainsi que leurs indices correspondants. Ceci est fréquemment utilisé dans des scénarios où l'on doit sélectionner les prédictions les plus probables ou les caractéristiques les plus importantes.
# Création d'une matrice d'exemple, comme des scores de confiance pour différentes catégories
matrice_scores_confiance = tf.random.uniform([4, 8], minval=0, maxval=100, dtype=tf.int32)
afficher("Matrice de scores de confiance :", matrice_scores_confiance)
# Extraction des 3 scores les plus élevés (k=3) pour chaque ligne/catégorie
# `sorted=True` garantit que les valeurs retournées sont triées par ordre décroissant.
resultats_top_3 = tf.math.top_k(matrice_scores_confiance, k=3, sorted=True)
# Les valeurs des 3 scores les plus élevés
valeurs_principales = resultats_top_3.values
afficher("Les 3 plus grandes valeurs par ligne :", valeurs_principales)
# Les indices correspondants à ces 3 scores les plus élevés
indices_principaux = resultats_top_3.indices
afficher("Les indices des 3 plus grandes valeurs par ligne :", indices_principaux)