Exemple TensorFlow - Projet de classification de texte
La classification de texte est une tâche fondamentale en traitement du langage naturel (NLP), qui consiste à classer automatiquement des documents textuels en une ou plusieurs catégories prédéfinies. Dans les applications pratiques, la classification de texte est largement utilisée pour :
- Détection de spam
- Analyse de sentiment
- Classification d'actualités
- Classification des conversations de service client
- Classification des avis sur les produits
La mise en œuvre de la classification de texte avec TensorFlow implique généralement les étapes suivantes :
- Préparation et prétraitement des données
- Vectorisation de texte
- Construction du modèle
- Entraînement du modèle
- Évaluation du modèle
- Déploiement de modèles
Préparation de l’environnement
Avant de commencer le projet, assurez-vous que les bibliothèques Python suivantes sont installées :
!pip install tensorflow !pip install numpy !pip install pandas !pip install matplotlib
Importer les bibliothèques nécessaires :
Exemple
from tensorflow.keras import layers
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
Vérifier la version de TensorFlow :
Exemple
# Exemple de sortie : 2.8.0
Préparation du jeu de données
Nous allons utiliser le jeu de données de critiques de films IMDB, un jeu de données classique de classification binaire contenant 50,000 critiques de films étiquetées comme positives (1) ou négatives (0).
Charger le jeu de données
Exemple
imdb = tf.keras.datasets.imdb
# Conserver uniquement les 10,000 mots les plus fréquents
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)
Exploration des données
Afficher le format des données :
Exemple
# Sortie : Échantillons d'entraînement : 25000, Échantillons de test : 25000
# Afficher la première critique
print(train_data[0])
# Sortie : [1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, ...]
Prétraitement des données
Convertir les séquences d'entiers en encodage multi-hot :
Exemple
results = np.zeros((len(sequences), dimension))
for i, sequence in enumerate(sequences):
results[i, sequence] = 1.
return results
x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)
# Convertir les étiquettes en nombres à virgule flottante
y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')
Construire le modèle
Architecture du modèle
Nous allons construire un réseau de neurones simple entièrement connecté :
Exemple
layers.Dense(16, activation='relu', input_shape=(10000,)),
layers.Dense(16, activation='relu'),
layers.Dense(1, activation='sigmoid')
])
Compilation du modèle
Exemple
loss='binary_crossentropy',
metrics=['accuracy'])
Description du paramètre :
optimizer: Optimiseur, contrôle le processus d'apprentissageloss: Fonction de perte, mesure la différence entre les prédictions du modèle et les étiquettes réellesmetrics: Métrique d'évaluation, surveille les étapes d'entraînement et de test
Entraîner le modèle
Créer un ensemble de validation
Exemple
partial_x_train = x_train[10000:]
y_val = y_train[:10000]
partial_y_train = y_train[10000:]
Processus d'entraînement
Exemple
partial_y_train,
époques=20,
batch_size=512,
validation_data=(x_val, y_val))
Visualiser les résultats d'entraînement
Exemple
# Tracer la perte d'entraînement et la perte de validation
plt.plot(history_dict['loss'], 'bo', label='Perte d'entraînement')
plt.plot(history_dict['val_loss'], 'b', label='Perte de validation')
plt.title('Perte d'entraînement et de validation')
plt.xlabel('Époques')
plt.ylabel('Perte')
plt.legend()
plt.show()
# Tracer la précision d'entraînement et de validation
plt.plot(history_dict['accuracy'], 'bo', label='Précision d'entraînement')
plt.plot(history_dict['val_accuracy'], 'b', label='Précision de validation')
plt.title('Précision d'entraînement et de validation')
plt.xlabel('Époques')
plt.ylabel('Précision')
plt.legend()
plt.show()
Évaluation et prédiction du modèle
Évaluer les performances de l'ensemble de test
Exemple
print(results)
# Exemple de sortie : [0.3245, 0.8732] représente la perte et la précision
Faire des prédictions
Exemple
print(predictions[0]) # Probabilité de prédiction du premier échantillon de test
Suggestions d'optimisation du modèle
Ajuster l'architecture du réseau:
- Augmenter ou diminuer le nombre de couches cachées
- Essayer différents nombres de neurones
- Utiliser différentes fonctions d'activation
Techniques de régularisation:
- Ajouter des couches Dropout pour éviter le surapprentissage
- Utiliser la régularisation L1/L2
Sélection de l'optimiseur:
- Essayez d'autres optimiseurs tels que Adam, SGD, etc.
- Ajustez le taux d'apprentissage
Améliorations du prétraitement du texte:
- Utilisez des plongements de mots au lieu de l'encodage multi-hot
- Essayez des vecteurs de mots pré-entraînés (tels que Word2Vec, GloVe)
Exemple de code complet
Exemple
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt
# Charger les données
imdb = tf.keras.datasets.imdb
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)
# Prétraitement des données
def vectorize_sequences(sequences, dimension=10000):
results = np.zeros((len(sequences), dimension))
for i, sequence in enumerate(sequences):
results[i, sequence] = 1.
return results
x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)
y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')
# Construire le modèle
model = tf.keras.Sequential([
layers.Dense(16, activation='relu', input_shape=(10000,)),
layers.Dense(16, activation='relu'),
layers.Dense(1, activation='sigmoid')
])
# Compiler le modèle
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
# Entraîner le modèle
history = model.fit(x_train, y_train,
époques=4,
batch_size=512,
validation_data=(x_test, y_test))
# Évaluer le modèle
results = model.evaluate(x_test, y_test)
print("Perte et précision du test:", results)
# Faire des prédictions
predictions = model.predict(x_test)
print("Probabilité de prédiction du premier avis:", predictions[0])