B1
Quelle est la principale différence entre le ML supervisé et non supervisé ?
Comment évalue-t-on la performance d'un modèle de ML supervisé ?
On peut utiliser des métriques comme l'exactitude (accuracy), la précision (precision), le rappel (recall) ou le score F1.
Quel algorithme de ML supervisé purement utilisé pour la classification ? Donne moi le code python associé.
La régression logistique.
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
Quel algorithme de ML non supervisé est utilisé pour la réduction de dimension ? Donne le code python.
L'analyse en composantes principales (PCA).
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
Implémentez une régression linéaire simple, et logistique en utilisant scikit-learn
from sklearn.linear_model import LinearRegression
model = LinearRegression()
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
Soit le code suivant:
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(10, activation='softmax'))
C'est quoi l'algorithme utiliser? Explique le code.
CNN.
model = Sequential() : Crée une instance de modèle séquentiel, qui est une pile linéaire de couches.
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1))) : Ajoute une couche de convolution avec 32 filtres de taille 3x3, une fonction d'activation ReLU et une forme d'entrée de (28, 28, pour les images en niveaux de gris de 28x28 pixels.
model.add(MaxPooling2D((2, 2))) : Ajoute une couche de pooling de taille 2x2 pour réduire la dimensionnalité de la sortie de la couche précédente.
model.add(Flatten()) : Aplatit les données en une seule dimension pour les passer à une couche dense.
model.add(Dense(10, activation='softmax')) : Ajoute une couche dense avec 10 neurones (correspondant aux 10 classes de chiffres de 0 à 9) et une fonction d'activation softmax pour obtenir des probabilités pour chaque classe.
Implémentez KNN en utilisant scikit-learn.
Soit le code suivant:
from sklearn.svm import SVC
model = SVC()
Explique
from sklearn.neighbors import KNeighborsClassifier
model = KNeighborsClassifier()
Modèle de classification avec SVM
Implémentez K-Means en utilisant scikit-learn. En précisons le nombre de groupe en 3
from sklearn.cluster import KMeans
model = KMeans(n_clusters=3)
Citez les algorithmes de ML et DL
Clustering – kNN – regroupement hiérarchique – RNN – régression linéaire - CNN- LSTM – Autoencodeurs
Selon le protocole d’apprentissage automatique spécifier si c'est: dataset, modèle, ou Prédiction de l'ensemble des points:
dataset:
Modèle:
Prédiciton:
Avec Python:
- Créez un modèle SVM linéaire.
- Créez un modèle SVM non linéaire avec un noyau RBF.
- Créez un modèle SVM avec un noyau polynomial.
c'est quoi la différence entre les trois types?
from sklearn.svm import SVC
model_linear = SVC(kernel='linear')
model_rbf = SVC(kernel='rbf')
model_poly = SVC(kernel='poly')
Le noyau linéaire sépare les données avec une ligne droite, le noyau RBF avec des cercles ou des sphères, et le noyau polynomial avec des courbes ou des surfaces courbes.
Quelles sont les étapes principales dans la réalisation d'un modèle de ML ? Donne le code pour un des algorithme précisons chaque étape que vous avez mentionner.
Les étapes principales sont la collecte et la préparation des données, le choix du modèle, l'apprentissage du modèle, l'évaluation du modèle et le déploiement du modèle.
Pourquoi est-il important de diviser les données en ensembles d'entraînement et de test ?Comment en python en peut faire cette séparation?
Pour évaluer la capacité du modèle à généraliser sur de nouvelles données et à éviter le surajustement.
Créer un Modèle de classification de KNN. A la fin évaluer le modèle.
from sklearn.neighbors import KNeighborsClassifier
model = KNeighborsClassifier(n_neighbors=3)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = model.score(X_test, y_test)
Comment choisir le meilleur K dans KNN?
k_values = list(range(1, 10, 2))
cv_scores = []
for k in k_values:
knn = KNeighborsClassifier(n_neighbors=k)
scores = cross_val_score(knn, X_train, y_train, cv=5,scoring='accuracy')
cv_scores.append(scores.mean())
best_k = k_values[np.argmax(cv_scores)]
print("\nMeilleur k pour le modèle :", best_k)
Comment savoir les meilleurs paramètres dans le KNN?
from sklearn.model_selection import GridSearchCV
grid_param = {
'n_neighbors': np.arange(1, 10),
'metric': ['euclidean', 'manhattan', 'minkowski',
'chebyshev']}
grid = GridSearchCV(KNeighborsClassifier(), grid_param, cv=5)
grid.fit(trainDataAll, trainLabelsAll)
grid.best_params_
Comment choisir le meilleur noyau et les meilleurs hyperparamètres pour un modèle SVM ?
En utilisant la validation croisée pour évaluer les performances avec différents noyaux (linear, rbf, etc.) et différents hyperparamètres, puis en sélectionnant celui qui donne les meilleurs résultats.
N.B
La validation croisée est une technique d'évaluation de la performance des modèles qui consiste à diviser les données en ensembles d'entraînement et de test, puis à répéter cette opération plusieurs fois pour obtenir une estimation plus fiable de la performance du modèle.
Qu'est-ce que le deep learning ? citez l'ensemble des algorithmes vu.
Le deep learning est une branche de l'intelligence artificielle qui utilise des réseaux de neurones artificiels profonds pour modéliser et résoudre des problèmes complexes d'apprentissage automatique. CNN, RNN, LSTM, Autoencoders.
Quelles sont les principales bibliothèques Python utilisées pour le deep learning ?
Les principales bibliothèques Python pour le deep learning sont TensorFlow, Keras, PyTorch et scikit-learn.
Que fait la ligne Flatten(input_shape=(28, 28)) dans le modèle ?
permet de convertir les images 2D de 28x28 pixels en un vecteur 1D de 784 pixels. Cela permet de passer d'une représentation matricielle des images à une représentation sous forme de vecteur, plus adaptée pour l'entrée dans les couches denses du réseau de neurones.
Quelle est la signification des paramètres epochs et batch_size dans la méthode fit ?
Le paramètre epochs dans la méthode fit spécifie le nombre d'itérations complètes sur l'ensemble de données d'entraînement. Le paramètre batch_size spécifie le nombre d'échantillons à utiliser pour chaque mise à jour des poids du réseau. Un batch_size plus grand peut accélérer l'entraînement mais nécessite plus de mémoire.
Avec dataset MNIST créer un MLP.
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import to_categorical
# Charger les données MNIST
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Normaliser les valeurs des pixels entre 0 et 1
x_train, x_test = x_train / 255.0, x_test / 255.0
# Convertir les labels en one-hot encoding
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
# Créer le modèle MLP
model = Sequential([
Flatten(input_shape=(28, 28)), # Convertir l'image 2D en un vecteur 1D
Dense(128, activation='relu'), # Couche cachée avec 128 neurones et fonction d'activation ReLU
Dense(64, activation='relu'), # Couche cachée avec 64 neurones et fonction d'activation ReLU
Dense(10, activation='softmax') # Couche de sortie avec 10 neurones pour les 10 classes et fonction d'activation softmax
])
# Compiler le modèle
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
# Entraîner le modèle
model.fit(x_train, y_train, epochs=5, batch_size=32, validation_data=(x_test, y_test))
# Évaluer le modèle sur l'ensemble de test
loss, accuracy = model.evaluate(x_test, y_test)
print(f"Loss: {loss}, Accuracy: {accuracy}")
Qu'est-ce que l'overfitting (surapprentissage) et comment peut-on le prévenir ? Explique le/les technique(s) pour remédier au surapprentissage.
L'overfitting se produit lorsque le modèle s'adapte trop bien aux données d'entraînement et ne généralise pas bien aux nouvelles données. Pour prévenir l'overfitting, on peut utiliser des techniques telles que la régularisation, le dropout et l'augmentation des données.
accuracy,la matrice de confusion, recall(la proportion de prédictions positives correctes parmi toutes les prédictions positives), score F1.
from sklearn.metrics import classification_report
report = classification_report(y_true, y_pred)
Quelle est la principale différence entre un réseau de neurones récurrents (RNN) et un réseau de neurones récurrents à mémoire à court terme (LSTM) ?
La principale différence réside dans leur capacité à traiter les dépendances à long terme dans les séquences de données. Les LSTM sont conçus pour mieux gérer le problème du gradient qui disparaît ou explose dans les RNN traditionnels, en introduisant des portes (gate) qui contrôlent le flux d'informations dans la cellule LSTM, permettant ainsi de conserver et d'oublier des informations sur de longues périodes de temps.