USER
Machine Learning – Deep Learning – Optimization
<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS> 2022/2023
Exercice 1 : les fonctions d’activation
Dans cet exercice, vous allez explorer et comprendre l'impact des différentes fonctions d'activation sur la
performance d'un réseau de neurones. Vous allez travailler avec un jeu de données synthétique et construire
plusieurs modèles en utilisant différentes fonctions d'activation. Ensuite, vous comparerez leurs performances et
analyserez les résultats.
Objectifs de l'Exercice
1. Comprendre comment les fonctions d'activation influencent la performance d'un réseau de neurones.
2. Comparer les performances des modèles avec différentes fonctions d'activation.
3. Analyser les effets de ces fonctions d'activation sur l'apprentissage et la généralisation.
Jeu de Données
Vous utiliserez un jeu de données synthétique pour la classification, où les classes sont générées à partir de
distributions distinctes.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
# Génération des données
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
# Split en données d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Visualisation des données
plt.scatter(X_train[y_train == 0][:, 0], X_train[y_train == 0][:, 1], color='red', label='Classe 0')
plt.scatter(X_train[y_train == 1][:, 0], X_train[y_train == 1][:, 1], color='blue', label='Classe 1')
plt.title('Données Synthétiques pour la Classification')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.show()
Questions
1. Construire des Modèles avec Différentes Fonctions d'Activation
• Définir la couche de sortie qui répond le mieux au problème
• Définir les couches cachées
− Définir suffisamment de couches cachées afin de montrer la différence entre les différents
modèles
− Modèle 1 : avec la fonction sigmoid
− Modèle 2 : avec la fonction tanh
− Modèle 3 : avec la fonctionrelu
• Compiler les modèles en utilisant le même optimzer
2. Entraînement et Évaluation des Modèles
• Entrainer les modèles créés en utilisant le même learning rate, le même nombre d’epochs
3. Analyse et Comparaison des Résultats
• Comparer les résultats obtenus tout comparant la fonction loss et l’accuracy des modèles
− Graphiquement
− En affichant les résultats
4. Faire les conclusions qu’il fautASSISTANT
Pour résoudre cet exercice, nous allons suivre les étapes suivantes:
1. **Préparer le jeu de données et visualiser les points de données.**
2. **Construire et compiler des modèles de réseaux de neurones avec différentes fonctions d'activation.**
3. **Entraîner et évaluer les modèles.**
4. **Comparer les performances des modèles en termes de fonction de perte (loss) et d'exactitude (accuracy).**
Commençons par préparer le code.
### 1. Préparation du jeu de données
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# Génération des données
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
# Split en données d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Visualisation des données
plt.scatter(X_train[y_train == 0][:, 0], X_train[y_train == 0][:, 1], color='red', label='Classe 0')
plt.scatter(X_train[y_train == 1][:, 0], X_train[y_train == 1][:, 1], color='blue', label='Classe 1')
plt.title('Données Synthétiques pour la Classification')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.show()
```
### 2. Construire des Modèles avec Différentes Fonctions d'Activation
Nous allons définir trois modèles avec différentes fonctions d'activation pour les couches cachées: Sigmoid, Tanh et ReLU.
```python
# Fonctions utilitaires pour créer des modèles
def create_model(activation_function):
model = Sequential([
Dense(10, input_shape=(2,), activation=activation_function),
Dense(10, activation=activation_function),
Dense(1, activation='sigmoid') # Couche de sortie adaptée pour la classification binaire
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return model
# Création des modèles
model_sigmoid = create_model('sigmoid')
model_tanh = create_model('tanh')
model_relu = create_model('relu')
# Affichage du résumé de l'un des modèles
model_sigmoid.summary()
```
### 3. Entraînement et Évaluation des Modèles
Nous utilison `TensorFlow` pour entraîner les modèles avec les mêmes paramètres d'apprentissage.
```python
# Entraîner et évaluer les modèles
history_sigmoid = model_sigmoid.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test), verbose=0)
history_tanh = model_tanh.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test), verbose=0)
history_relu = model_relu.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test), verbose=0)
```
### 4. Analyse et Comparaison des Résultats
Pour comparer les résultats, nous allons tracer les courbes de perte et d'exactitude pour chaque modèle.
```python
# Fonction pour tracer les résultats
def plot_history(history, title):
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title(title)
plt.xlabel('Epochs')
plt.ylabel('Loss/Accuracy')
plt.legend()
plt.show()
# Tracer les résultats
plot_history(history_sigmoid, 'Modèle avec Sigmoid')
plot_history(history_tanh, 'Modèle avec Tanh')
plot_history(history_relu, 'Modèle avec ReLU')
# Affichage des résultats finaux
def print_final_results(model, X_test, y_test):
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f'Loss: {loss:.4f}, Accuracy: {accuracy:.4f}')
print("Résultats du modèle Sigmoid:")
print_final_results(model_sigmoid, X_test, y_test)
print("\nRésultats du modèle Tanh:")
print_final_results(model_tanh, X_test, y_test)
print("\nRésultats du modèle ReLU:")
print_final_results(model_relu, X_test, y_test)
```
### Conclusions
1. **Impact des fonctions d'activation sur la performance:**
- Les différentes fonctions d'activation ont un impact significatif sur la performance d'un réseau de neurones.
- La fonction Sigmoid peut souffrir de gradients qui se dissipent (problème de "vanishing gradients") ce qui peut rendre l'apprentissage plus lent.
- La fonction Tanh est souvent préférée à Sigmoid car elle est centrée sur zéro, mais peut encore souffrir des mêmes problèmes pour des activations extrêmes.
- La fonction ReLU est généralement plus efficace pour des réseaux profonds car elle ne sature pas pour les activations positives, permettant des mises à jour de gradients plus constantes.
2. **Comparaison des performances:**
- Nous constatons généralement que les modèles avec la fonction ReLU tendent à converger plus rapidement et obtenir de meilleures performances en termes d'exactitude sur les données de validation.
3. **Effets des fonctions d'activation:**
- ReLU permet de mieux capter les non-linéarités dans les données sans souffrir des problèmes de saturation.
- Lors de l'entraînement et de la généralisation, les modèles avec ReLU peuvent mieux évoluer et généraliser sur de nouveaux jeux de données.
### Code Complet
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# Génération des données
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
# Split en données d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Visualisation des données
plt.scatter(X_train[y_train == 0][:, 0], X_train[y_train == 0][:, 1], color='red', label='Classe 0')
plt.scatter(X_train[y_train == 1][:, 0], X_train[y_train == 1][:, 1], color='blue', label='Classe 1')
plt.title('Données Synthétiques pour la Classification')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.show()
# Fonctions utilitaires pour créer des modèles
def create_model(activation_function):
model = Sequential([
Dense(10, input_shape=(2,), activation=activation_function),
Dense(10, activation=activation_function),
Dense(1, activation='sigmoid') # Couche de sortie adaptée pour la classification binaire
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return model
# Création des modèles
model_sigmoid = create_model('sigmoid')
model_tanh = create_model('tanh')
model_relu = create_model('relu')
# Affichage du résumé du modèle sigmoid
model_sigmoid.summary()
# Entraîner et évaluer les modèles
history_sigmoid = model_sigmoid.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test), verbose=0)
history_tanh = model_tanh.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test), verbose=0)
history_relu = model_relu.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test), verbose=0)
# Fonction pour tracer les résultats
def plot_history(history, title):
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title(title)
plt.xlabel('Epochs')
plt.ylabel('Loss/Accuracy')
plt.legend()
plt.show()
# Tracer les résultats
plot_history(history_sigmoid, 'Modèle avec Sigmoid')
plot_history(history_tanh, 'Modèle avec Tanh')
plot_history(history_relu, 'Modèle avec ReLU')
# Affichage des résultats finaux
def print_final_results(model, X_test, y_test):
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f'Loss: {loss:.4f}, Accuracy: {accuracy:.4f}')
print("Résultats du modèle Sigmoid:")
print_final_results(model_sigmoid, X_test, y_test)
print("\nRésultats du modèle Tanh:")
print_final_results(model_tanh, X_test, y_test)
print("\nRésultats du modèle ReLU:")
print_final_results(model_relu, X_test, y_test)
```
Ce code vous permettra de comparer et analyser les effets de différentes fonctions d'activation sur le comportement et la performance d'un réseau de neurones.