Debuter avec TensorFlow

Pourquoi TensorFlow ?

TensorFlow est un framework d'apprentissage automatique créé par Google qui permet aux développeurs et scientifiques de données de construire et entraîner des modèles de machine learning. Ce framework offre une grande flexibilité et des outils puissants pour travailler avec des données complexes et des modèles sophistiqués.

Un cas d'utilisation concret est la reconnaissance faciale, un domaine qui nécessite des algorithmes avancés pour identifier les visages dans des images ou des vidéos. TensorFlow permet aux développeurs de créer ces algorithmes et de les entraîner sur de grandes quantités de données faciales pour améliorer leur précision.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Un environnement d'édition intégrée (IDE) comme PyCharm ou Visual Studio Code.
• Python 3.6 ou ultérieur installé sur votre machine.
• pip pour installer les bibliothèques Python nécessaires.

Installez ces dépendances en utilisant pip :

pip install numpy tensorflow matplotlib pandas scikit-learn

Concepts fondamentaux

Tensor

Un tensor est la structure de données de base dans TensorFlow. Il peut être considéré comme un tableau multidimensionnel avec des éléments du même type.

import tensorflow as tf

## Créer un tensor 1D (vecteur)
vector = tf.constant([1, 2, 3])

## Créer un tensor 2D (matrice)
matrix = tf.constant([[1, 2], [3, 4]])

print(vector)
print(matrix)

Variable

Une variable est une sorte de tensor qui peut être modifiée au cours du temps.

import tensorflow as tf

## Créer une variable
v = tf.Variable([1.0, 2.0, 3.0])

## Modifier la variable
with tf.GradientTape() as tape:
    loss = v[0]**2 + v[1]**2 + v[2]**2

grad = tape.gradient(loss, v)
print(grad)

Opération

Une opération est une transformation qui prend un ou plusieurs tensors en entrée et produit un ou plusieurs tensors en sortie.

import tensorflow as tf

## Créer deux tensors
a = tf.constant([1, 2])
b = tf.constant([3, 4])

## Effectuer une addition
c = tf.add(a, b)

print(c)

Session

En version ancienne de TensorFlow, une session était nécessaire pour exécuter les opérations. Cependant, dans la version 2.x, cela n'est plus le cas.

import tensorflow as tf

## Créer un tensor
a = tf.constant([1, 2])

## Exécuter l'opération sans session (TensorFlow 2.x)
result = a.numpy()
print(result)

Mise en pratique : projet fil rouge

Nous allons construire un simple gestionnaire de tâches en utilisant TensorFlow. Ce mini-projet comprendra les fonctionnalités suivantes :

1. Ajouter une nouvelle tâche
2. Afficher la liste des tâches
3. Marquer une tâche comme terminée

Étape 1 : Configuration initiale

Créez un nouveau fichier task_manager.py et ajoutez les importations nécessaires.

import tensorflow as tf
from typing import List, Tuple

## Définir le chemin du fichier de sauvegarde des tâches
SAVE_FILE = 'tasks.tfrecord'

Étape 2 : Création d'un modèle pour stocker les tâches

Nous allons utiliser un tf.data.Dataset pour stocker et gérer les tâches.

## Définir la structure de données des tâches
task_schema = {
    'description': tf.io.FixedLenFeature([], tf.string),
    'completed': tf.io.FixedLenFeature([], tf.int64)
}

## Fonction pour parser un exemple
def parse_task(example_proto):
    return tf.io.parse_single_example(example_proto, task_schema)

## Fonction pour créer un exemple à partir d'un dictionnaire
def create_task_example(task_dict):
    return tf.train.Example(features=tf.train.Features(feature={
        'description': tf.train.Feature(bytes_list=tf.train.BytesList(value=[task_dict['description'].encode('utf-8')])),
        'completed': tf.train.Feature(int64_list=tf.train.Int64List(value=[int(task_dict['completed'])]))
    }))

Étape 3 : Fonction pour ajouter une tâche

def add_task(description: str) -> None:
    # Créer un exemple de tâche
    task_example = create_task_example({'description': description, 'completed': False})
    
    # Sérialiser l'exemple en binaire
    serialized_example = task_example.SerializeToString()
    
    # Écrire l'exemple dans le fichier TFRecord
    with tf.io.TFRecordWriter(SAVE_FILE) as writer:
        writer.write(serialized_example)

Étape 4 : Fonction pour afficher la liste des tâches

def list_tasks() -> List[Tuple[str, bool]]:
    tasks = []
    
    # Lire le fichier TFRecord
    dataset = tf.data.TFRecordDataset(SAVE_FILE)
    dataset = dataset.map(parse_task)
    
    for task in dataset:
        description = task['description'].numpy().decode('utf-8')
        completed = bool(task['completed'])
        tasks.append((description, completed))
    
    return tasks

Étape 5 : Fonction pour marquer une tâche comme terminée

def mark_task_completed(description: str) -> None:
    # Lire le fichier TFRecord
    dataset = tf.data.TFRecordDataset(SAVE_FILE)
    dataset = dataset.map(parse_task).batch(1000)
    
    # Créer un nouveau fichier pour stocker les tâches modifiées
    new_save_file = 'tasks_modified.tfrecord'
    
    with tf.io.TFRecordWriter(new_save_file) as writer:
        for task in dataset:
            if task['description'].numpy().decode('utf-8') == description:
                modified_task = create_task_example({'description': description, 'completed': True})
                writer.write(modified_task.SerializeToString())
            else:
                writer.write(task.SerializeToString())
    
    # Renommer le nouveau fichier pour remplacer l'ancien
    import os
    os.remove(SAVE_FILE)
    os.rename(new_save_file, SAVE_FILE)

Étape 6 : Test du gestionnaire de tâches

if __name__ == "__main__":
    # Ajouter des tâches
    add_task("Faire les courses")
    add_task("Nettoyer la maison")
    
    # Afficher la liste des tâches
    tasks = list_tasks()
    for task in tasks:
        print(f"{task[0]} - {'Terminée' if task[1] else 'Non terminée'}")
    
    # Marquer une tâche comme terminée
    mark_task_completed("Faire les courses")
    
    # Afficher la liste des tâches à nouveau
    tasks = list_tasks()
    for task in tasks:
        print(f"{task[0]} - {'Terminée' if task[1] else 'Non terminée'}")

Erreurs frequentes et debugging

Erreur 1 : AttributeError: module 'tensorflow' has no attribute 'Variable'

## ❌ Mauvais
v = tf.Variable([1.0, 2.0, 3.0])

## ✅ Correct
from tensorflow import Variable
v = Variable([1.0, 2.0, 3.0])

Erreur 2 : InvalidArgumentError: Incompatible shapes: [2] vs. [3]

## ❌ Mauvais
a = tf.constant([1, 2])
b = tf.constant([3, 4, 5])

c = a + b

## ✅ Correct
b = b[:2]
c = a + b

Erreur 3 : FileNotFoundError: [Errno 2] No such file or directory: 'tasks.tfrecord'

## ❌ Mauvais
with tf.io.TFRecordWriter(SAVE_FILE) as writer:
    writer.write(serialized_example)

## ✅ Correct
import os
if not os.path.exists(SAVE_FILE):
    with tf.io.TFRecordWriter(SAVE_FILE) as writer:
        writer.write(serialized_example)

Pour aller plus loin

1. Modèles de machine learning : Apprenez à créer et entraîner des modèles de machine learning avec TensorFlow.
2. TensorFlow Datasets : Utilisez TensorFlow Datasets pour charger et préparer efficacement des données.
3. TensorFlow Hub : Explorez le modèle pré-entraîné TensorFlow Hub pour accélérer votre développement.

Défi pratique : Créer un simple classifieur d'images utilisant TensorFlow et les modèles pré-entraînés sur le jeu de données MNIST.

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

## Charger les données MNIST
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

## Prétraiter les données
train_images = train_images / 255.0
test_images = test_images / 255.0

## Créer le modèle
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10)
])

## Compiler le modèle
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

## Entraîner le modèle
model.fit(train_images, train_labels, epochs=5)

## Évaluer le modèle
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

Ce tutoriel vous a permis de découvrir les concepts fondamentaux de TensorFlow et de mettre en pratique ces connaissances grâce à un mini-projet réel. Vous êtes maintenant prêt à explorer davantage ce framework puissant pour le développement d'applications de machine learning.