Skip to content
IgnitionAI IgnitionAI

Concepts de base de TensorFlow

Broadcasting

Le broadcasting est une technique utilisée dans les bibliothèques de calcul numérique comme NumPy et TensorFlow pour effectuer des opérations élémentaires sur des tableaux de différentes formes. Il permet de traiter des tableaux de tailles différentes sans avoir à les redimensionner explicitement.

Exemple de broadcasting avec NumPy

import numpy as np


# Créer deux tableaux de tailles différentes
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])


# Effectuer une opération élémentaire (addition)
c = a + b
print(c)  # Output: [5 7 9]


# Broadcasting avec un scalaire
d = a + 10
print(d)  # Output: [11 12 13]


# Broadcasting avec un tableau de dimension supérieure
e = np.array([[1, 2, 3], [4, 5, 6]])
f = np.array([10, 20, 30])
g = e + f
print(g)
# Output:
# [[11 22 33]
#  [14 25 36]]

Operator Overloading

Le surcharge d’opérateurs (operator overloading) est une technique de programmation qui permet de redéfinir le comportement des opérateurs pour les objets d’une classe. En Python, cela est souvent utilisé pour permettre des opérations arithmétiques et logiques sur des objets personnalisés.

Exemple de surcharge d’opérateurs en Python

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y


    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)


    def __str__(self):
        return f"Vector({self.x}, {self.y})"


# Créer des objets Vector
v1 = Vector(1, 2)
v2 = Vector(3, 4)


# Utiliser l'opérateur +
v3 = v1 + v2
print(v3)  # Output: Vector(4, 6)

Compatibilité avec NumPy

TensorFlow est conçu pour être compatible avec NumPy, ce qui permet une interopérabilité fluide entre les deux bibliothèques. Vous pouvez facilement convertir des tableaux NumPy en tenseurs TensorFlow et vice versa.

Exemple de compatibilité entre TensorFlow et NumPy

import tensorflow as tf
import numpy as np


# Créer un tableau NumPy
numpy_array = np.array([1, 2, 3, 4, 5])


# Convertir le tableau NumPy en tenseur TensorFlow
tensor = tf.convert_to_tensor(numpy_array)
print(tensor)  # Output: tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)


# Effectuer des opérations sur le tenseur TensorFlow
tensor_squared = tf.square(tensor)
print(tensor_squared)  # Output: tf.Tensor([ 1  4  9 16 25], shape=(5,), dtype=int32)


# Convertir le tenseur TensorFlow en tableau NumPy
numpy_array_squared = tensor_squared.numpy()
print(numpy_array_squared)  # Output: [ 1  4  9 16 25]

Résumé

  1. Broadcasting : Technique permettant d’effectuer des opérations élémentaires sur des tableaux de tailles différentes sans avoir à les redimensionner explicitement.
  2. Surcharge d’opérateurs : Technique permettant de redéfinir le comportement des opérateurs pour les objets d’une classe, souvent utilisée pour permettre des opérations arithmétiques et logiques sur des objets personnalisés.
  3. Compatibilité avec NumPy : TensorFlow est conçu pour être compatible avec NumPy, permettant une interopérabilité fluide entre les deux bibliothèques. Vous pouvez facilement convertir des tableaux NumPy en tenseurs TensorFlow et vice versa.

Ces concepts sont fondamentaux pour travailler efficacement avec des bibliothèques de calcul numérique et pour développer des applications de machine learning robustes et performantes.