Est-il possible d'obtenir des résultats de test pour chaque itération de MLPClassifier?
J'aimerais examiner les courbes de perte pour les données d'entraînement et les données de test côte à côte. Actuellement, il semble facile d’obtenir la perte sur le jeu d’entraînement pour chaque itération en utilisant clf.loss_curve (voir ci-dessous).
from sklearn.neural_network import MLPClassifier
clf = MLPClassifier()
clf.fit(X,y)
clf.loss_curve_ # this seems to have loss for the training set
Cependant, je voudrais également tracer les performances sur un ensemble de données de test. Est-ce disponible?
Avec MLPClassifier(early_stopping=True), le critère d'arrêt change de la perte d'apprentissage au score de précision, calculé sur un ensemble de validation (dont la taille est contrôlée par le paramètre validation_fraction).
Le score de validation de chaque itération est stocké dans clf.validation_scores_.
Une autre possibilité consiste à utiliser warm_start=True avec max_iter=1 et à calculer manuellement toutes les quantités que vous souhaitez surveiller après chaque itération.
clf.loss_curve_ ne fait pas partie de API-docs (bien que utilisé dans certains exemples). La seule raison pour laquelle c'est le cas, c'est parce qu'il est utilisé en interne pour early-stopping .
Comme Tom le mentionne, il existe également une approche pour utiliser validation_scores_.
Indépendamment de cela, des configurations plus complexes peuvent nécessiter une formation plus manuelle, où vous pouvez contrôler quand, quoi et comment mesurer quelque chose.
Après avoir lu la réponse de Tom, il peut être judicieux de dire: si seuls des calculs inter-époques sont nécessaires, son approche consistant à combiner warm_start et max_iter enregistre du code (et utilise davantage le code d'origine de sklearn). Ce code ici pourrait aussi faire des calculs intra-époque (si nécessaire; comparer avec keras).
Exemple simple (prototype):
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_mldata
from sklearn.neural_network import MLPClassifier
np.random.seed(1)
""" Example based on sklearn's docs """
mnist = fetch_mldata("MNIST original")
# rescale the data, use the traditional train/test split
X, y = mnist.data / 255., mnist.target
X_train, X_test = X[:60000], X[60000:]
y_train, y_test = y[:60000], y[60000:]
mlp = MLPClassifier(hidden_layer_sizes=(50,), max_iter=10, alpha=1e-4,
solver='adam', verbose=0, tol=1e-8, random_state=1,
learning_rate_init=.01)
""" Home-made mini-batch learning
-> not to be used in out-of-core setting!
"""
N_TRAIN_SAMPLES = X_train.shape[0]
N_EPOCHS = 25
N_BATCH = 128
N_CLASSES = np.unique(y_train)
scores_train = []
scores_test = []
# Epoch
epoch = 0
while Epoch < N_EPOCHS:
print('Epoch: ', Epoch)
# SHUFFLING
random_perm = np.random.permutation(X_train.shape[0])
mini_batch_index = 0
while True:
# MINI-BATCH
indices = random_perm[mini_batch_index:mini_batch_index + N_BATCH]
mlp.partial_fit(X_train[indices], y_train[indices], classes=N_CLASSES)
mini_batch_index += N_BATCH
if mini_batch_index >= N_TRAIN_SAMPLES:
break
# SCORE TRAIN
scores_train.append(mlp.score(X_train, y_train))
# SCORE TEST
scores_test.append(mlp.score(X_test, y_test))
Epoch += 1
""" Plot """
fig, ax = plt.subplots(2, sharex=True, sharey=True)
ax[0].plot(scores_train)
ax[0].set_title('Train')
ax[1].plot(scores_test)
ax[1].set_title('Test')
fig.suptitle("Accuracy over epochs", fontsize=14)
plt.show()
Sortie:
Ou un peu plus compact:
plt.plot(scores_train, color='green', alpha=0.8, label='Train')
plt.plot(scores_test, color='Magenta', alpha=0.8, label='Test')
plt.title("Accuracy over epochs", fontsize=14)
plt.xlabel('Epochs')
plt.legend(loc='upper left')
plt.show()
Sortie:
J'utilise jupyter, c'est mon code:
clf = MLPClassifier(hidden_layer_sizes=(10,10,10))
clf.fit(train_X,train_Y)
plt.ylabel('cost')
plt.xlabel('iterations')
plt.title("Learning rate =" + str(0.001))
plt.plot(pose_clf.loss_curve_)
plt.show()
