Exercice 3.1 : Classification de Sentiment avec Augmentation du Nombre de Neurones

Exercice 3.1 : Classification de Sentiment avec Augmentation du Nombre de Neurones#

Objectif : Créer un modèle simple de classification de texte pour classer les critiques de films en positives ou négatives. Commencez avec un petit nombre de neurones et augmentez progressivement ce nombre pour observer les effets sur la performance.

Données : Utilisez un sous-ensemble du jeu de données de critiques de films IMDB.

Étapes :

  1. Commencez par une couche Embedding, suivie d’une couche Dense avec 16 neurones.

  2. Entraînez le modèle et enregistrez la précision.

  3. Augmentez progressivement le nombre de neurones dans la couche Dense (par exemple, de 16 à 64 puis à 128) et observez comment la précision et le temps d’entraînement sont affectés.

  4. Tracez les résultats pour la précision et la perte, y compris pour les tests de validation.

Complétez le code ci-dessous.

import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
import matplotlib.pyplot as plt

# Load and preprocess the data
vocab_size = 10000  # Only consider the top 10k words
max_length = 256    # Pad/truncate all reviews to be 256 words

# Load IMDB data
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)

# Pad sequences to the same length
x_train = pad_sequences(x_train, maxlen=max_length)
x_test = pad_sequences(x_test, maxlen=max_length)

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz
17464789/17464789 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

def build_model(dense_neurons):
    model = tf.keras.Sequential([
        layers.Embedding(input_dim=vocab_size, output_dim=64, input_length=max_length),
        layers.GlobalAveragePooling1D(),
        layers.Dense(dense_neurons, activation='relu'),
        layers.Dense(1, activation='sigmoid')
    ])

    model.compile(optimizer='adam',
                  loss='binary_crossentropy',
                  metrics=['accuracy'])
    return model

neuron_counts = [16, 64, 128]  # Different sizes for the Dense layer
results = {}

for neurons in neuron_counts:
    print(f"\nTraining model with {neurons} neurons in the Dense layer")
    model = build_model(dense_neurons=neurons)

    # Train the model
    history = model.fit(
        x_train, y_train,
        epochs=5,
        batch_size=512,
        validation_split=0.2,
        verbose=2
    )

    # Evaluate the model
    loss, accuracy = model.evaluate(x_test, y_test, verbose=2)
    results[neurons] = {'accuracy': accuracy, 'loss': loss}

Exercice 3.2 : Classification d’Images Fine-grained avec Augmentation du Nombre de Neurones#

Objectif : Créer un modèle de classification d’images de base pour classer des images de fleurs (oxford_flowers102 - le Oxford 102 Flower Dataset). Commencez avec un petit nombre de neurones et augmentez-les progressivement pour observer les effets sur la performance.

Données : Utilisez le Oxford 102 Flower Dataset, qui contient des images de 102 catégories de fleurs.

Étapes :

  1. Commencez avec des couches Conv2D et MaxPooling2D pour l’extraction des caractéristiques des images.

  2. Ajoutez une couche Flatten pour convertir les cartes de caractéristiques 2D en un vecteur 1D.

  3. Ajoutez une couche Dense avec un petit nombre de neurones (par exemple, 32), suivie d’une couche de sortie.

  4. Entraînez le modèle et enregistrez la précision.

  5. Augmentez progressivement le nombre de neurones dans la couche Dense (par exemple, de 32 à 128 puis à 256) pour observer les changements dans la précision et le temps d’entraînement.

Complétez le code ci-dessous.

import tensorflow as tf
import tensorflow_datasets as tfds
from tensorflow.keras import layers, models
import matplotlib.pyplot as plt

# Load the Oxford 102 Flower Dataset
dataset, info = tfds.load('oxford_flowers102', with_info=True, as_supervised=True)

# Split the dataset into training and testing
train_dataset = dataset['train']
test_dataset = dataset['test']

# Set image parameters
image_size = (150, 150)  # Resize images to this size
batch_size = 32

# Data preprocessing function to resize images and normalize pixel values
def preprocess_image(image, label):
    image = tf.image.resize(image, image_size)
    image = image / 255.0  # Normalize pixel values to [0, 1]
    return image, label

# Apply preprocessing to the train and test datasets
train_dataset = train_dataset.map(preprocess_image).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE)
test_dataset = test_dataset.map(preprocess_image).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE)

Exercice 3.3 : Étudier l’Influence de la Taille des Lots sur la Performance du Modèle#

Objectif : Cet exercice démontre comment différentes tailles de lots affectent la performance d’un modèle de réseau neuronal, y compris sa vitesse d’entraînement, sa perte, sa précision et sa capacité de généralisation.

Jeu de données : Fashion MNIST — un jeu de données contenant des images en niveaux de gris de 10 types de vêtements différents, avec 60 000 images d’entraînement et 10 000 images de test.

Étapes :#

1. Charger le Jeu de Données#

  • Utilisez tensorflow.keras.datasets.fashion_mnist pour charger le jeu de données.

  • Prétraitez les données en normalisant les valeurs des pixels dans l’intervalle [0, 1].

2. Définir l’Architecture du Modèle#

  • Construisez un modèle simple de réseau neuronal convolutionnel (CNN) ou de réseau neuronal complètement connecté (FCNN).

  • Le modèle doit inclure :

    • Une couche d’entrée (pour gérer les images 28x28).

    • Une ou plusieurs couches cachées (par exemple, Dense, Conv2D).

    • Une couche de sortie avec 10 unités (une pour chaque catégorie de vêtement).

  • Utilisez l’activation softmax pour la couche de sortie, car il s’agit d’un problème de classification multiclasse.

3. Varier la Taille des Lots#

  • Expérimentez avec différentes tailles de lots (par exemple, 16, 32, 64, 128, 256).

  • Pour chaque taille de lot :

    • Entraînez le modèle pendant un nombre fixe d’époques (par exemple, 10 époques).

    • Enregistrez la perte d’entraînement, la perte de validation et la précision.

4. Entraîner le Modèle#

  • Entraînez le modèle pour chaque taille de lot et mesurez les éléments suivants :

    • Temps d’entraînement : Combien de temps il faut pour terminer une époque.

    • Perte d’entraînement et de validation : Suivez l’évolution de la perte pendant l’entraînement.

    • Précision : Suivez les performances du modèle sur les données d’entraînement et de validation.

5. Analyser les Résultats#

  • Comparez les éléments suivants :

    • Temps d’entraînement : Les tailles de lots plus grandes peuvent conduire à un entraînement plus rapide, mais elles pourraient aussi entraîner des rendements décroissants en termes de performance du modèle.

    • Perte et précision : Observez comment la taille du lot affecte la convergence de la fonction de perte et la précision sur les ensembles de données d’entraînement et de validation.

    • Surapprentissage : Vérifiez si des tailles de lots plus petites mènent à une meilleure généralisation (perte de validation plus faible) ou si des tailles de lots plus grandes entraînent un surapprentissage.

6. Tracer les Résultats#

  • Tracez des graphiques comparant la perte d’entraînement, la perte de validation et la précision pour différentes tailles de lots.

  • Tracez le temps d’entraînement pour différentes tailles de lots.

import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import fashion_mnist

# Load and preprocess the dataset
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
train_images, test_images = train_images / 255.0, test_images / 255.0

# Reshape the images to (28, 28, 1) to match the input shape expected by CNNs
train_images = train_images.reshape(-1, 28, 28, 1)
test_images = test_images.reshape(-1, 28, 28, 1)

Exercice 3.4 : Classification des Émotions avec le Jeu de Données CREMA-D#

Objectif : Créer un modèle pour classifier les émotions à partir de clips audio de discours humain. Cet exercice se concentre sur l’identification des émotions telles que la colère, la joie, la tristesse et les tons neutres, en utilisant un prétraitement audio de base et un réseau neuronal convolutionnel.

Jeu de données : CREMA-D (Crowd-sourced Emotional Multimodal Actors Dataset) contient des clips audio d’acteurs exprimant six émotions : colère, dégoût, peur, joie, neutre et tristesse. Bien qu’il ne soit pas directement disponible dans tensorflow_datasets, il est suffisamment petit pour être prétraité et chargé efficacement dans TensorFlow.

Étapes :#

1. Chargement et Prétraitement des Données#

  • Charger le Jeu de Données :

    • Téléchargez le jeu de données CREMA-D depuis sa source officielle.

    • Organisez les fichiers audio et les étiquettes d’émotions correspondantes.

  • Traitement Audio :

    • Convertissez les formes d’onde audio en spectrogrammes ou en mel-spectrogrammes pour chaque clip audio.

    • Normalisez les spectrogrammes et ajustez-les pour qu’ils aient une longueur constante, par exemple, 2 secondes.

2. Construire un Modèle Simple de Classification des Émotions#

  • Couches Convolutionnelles :

    • Commencez par une couche Conv2D pour apprendre les motifs spatiaux dans le spectrogramme.

    • Ajoutez des couches Conv2D supplémentaires et des couches MaxPooling2D pour capturer des caractéristiques de niveau supérieur.

  • Couches Flatten et Dense :

    • Aplatissez la sortie finale et faites-la passer à travers une ou deux couches Dense pour la classification.

    • Utilisez une activation softmax dans la couche Dense finale avec six unités de sortie, une pour chaque classe d’émotion.

  • Compiler et Entraîner :

    • Utilisez l’entropie croisée catégorielle comme fonction de perte et un optimiseur comme Adam.

    • Entraînez le modèle sur l’ensemble d’entraînement, en utilisant un ensemble de validation pour ajuster les performances.

3. Évaluation du Modèle#

  • Précision :

    • Évaluez la précision du modèle sur l’ensemble de test.

  • Matrice de Confusion :

    • Générez une matrice de confusion pour analyser quelles émotions sont bien classées et lesquelles sont fréquemment mal classées.

!git clone https://github.com/CheyneyComputerScience/CREMA-D.git

import os
import tensorflow as tf
import numpy as np
import librosa
from sklearn.model_selection import train_test_split
from tensorflow.keras import layers, models

# Define path to CREMA-D dataset (update path accordingly)
DATA_PATH = '/content/CREMA-D/AudioWAV'
LABELS = {'ANG': 0, 'DIS': 1, 'FEA': 2, 'HAP': 3, 'NEU': 4, 'SAD': 5}

def preprocess_audio(file_path, max_length=2.5, sr=16000):
    audio, _ = librosa.load(file_path, sr=sr)
    # Calculate the desired length in samples
    target_length = int(sr * max_length)
    # Adjust the audio to the desired length
    audio = librosa.util.fix_length(audio, size=target_length)
    # Convert audio to a mel-spectrogram
    spectrogram = librosa.feature.melspectrogram(y=audio, sr=sr)
    spectrogram_db = librosa.power_to_db(spectrogram, ref=np.max)
    return spectrogram_db

# Load and preprocess data
def load_data(data_path, labels):
    data, targets = [], []
    for file_name in os.listdir(data_path):
        if file_name.endswith('.wav'):
            file_path = os.path.join(data_path, file_name)
            label_str = file_name.split('_')[2]  # e.g., "ANG", "DIS"
            if label_str in labels:
                spectrogram = preprocess_audio(file_path)
                data.append(spectrogram)
                targets.append(labels[label_str])
    return np.array(data), np.array(targets)

# Load data
X, y = load_data(DATA_PATH, LABELS)
X = X[..., np.newaxis]  # Add channel dimension for Conv2D

# Split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)