Contenu

Ceci est un mémo pour moi pendant que je lis Introduction aux applications de traitement du langage naturel en 15 étapes. Cette fois, au chapitre 4, étape 14, notez vos propres points.

Préparation

MacPC personnel: MacOS Mojave version 10.14.6 --docker version: Version 19.03.2 pour le client et le serveur

Aperçu des chapitres

Dans ce chapitre, nous cherchons à trouver les valeurs des paramètres appropriés (et non les paramètres à apprendre) qui devraient être données en externe au système d'apprentissage automatique.

Recherche Grille
Hyperopt --Distribution de probabilité

14.1 Hyper paramètres

Méta-paramètres en une étape définis par les concepteurs et les programmeurs avant l'apprentissage, et non les paramètres ajustés et acquis par l'apprentissage.

Extracteur de caractéristiques --Identifiant
NN --Type de couche --Nombre de couches --Nombre d'unités par couche
Présence / absence de chute et coefficient --Type d'optimiseur et divers arguments --Taux d'apprentissage
- etc...

14.2 Recherche de grille

C'est une méthode pour énumérer les paramètres à rechercher et les candidats pour chaque valeur, et essayer toutes les combinaisons pour trouver la meilleure. Scikit-learn fournit sklearn.model_selection.GridSearchCV.

--Utilisez la classe classifier avec l'API Scikit-learn

Pour Keras, utilisez le wrapper d'API scicit-leran
Les paramètres optimaux peuvent être obtenus avec <gridsearch instance> .best_params_.

#N'utilisez pas de pipeline

## train
vectorizer = TfidfVectorizer(tokenizer=tokenize, ngram_range=(1, 2))
train_vectors = vectorizer.fit_transform(train_texts)
parameters = {  # <1>
    'n_estimators': [10, 20, 30, 40, 50, 100, 200, 300, 400, 500],
    'max_features': ('sqrt', 'log2', None),
}
classifier = RandomForestClassifier()
gridsearch = GridSearchCV(classifier, parameters)
gridsearch.fit(train_vectors, train_labels)

## predict
test_vectors = vectorizer.transform(test_texts)
predictions = gridsearch.predict(test_vectors)


#Utiliser le pipeline

## train 
pipeline = Pipeline([
    ('vectorizer', TfidfVectorizer(tokenizer=tokenize, ngram_range=(1, 2))),
    ('classifier', RandomForestClassifier()),
])
parameters = {
    'vectorizer__ngram_range':[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)],
    'classifier__n_estimators':[10, 20, 30, 40, 50, 100, 200, 300, 400, 500],
    'classifier__max_features':('sqrt', 'log2', None),
}
gridsearch = GridSearchCV(pipeline, parameters)
gridsearch.fit(texts, labels)

## predict
gridsearch.predict(texts)

`GridSearchCV`


#verbeux: affiché car je ne connaissais pas l'état d'exécution de la recherche de grille(1)
# n_emplois: autant que possible(-1)Exécuter en parallèle
clf = GridSearchCV(pipeline, parameters, verbose=1, n_jobs=-1)

`Résultat d'exécution`


from dialogue_agent import DialogueAgent  # <1>
↓
from dialogue_agent_pipeline_gridsearch import DialogueAgent  # <1>

$ docker run -it -v $(pwd):/usr/src/app/ 15step:latest python evaluate_dialogue_agent.py
#Il a fallu environ 20 minutes pour terminer l'exécution
Fitting 3 folds for each of 180 candidates, totalling 540 fits

[Parallel(n_jobs=-1)]: Done  46 tasks      | elapsed:    5.4s
[Parallel(n_jobs=-1)]: Done 196 tasks      | elapsed:  2.2min
[Parallel(n_jobs=-1)]: Done 446 tasks      | elapsed:  5.5min
[Parallel(n_jobs=-1)]: Done 540 out of 540 | elapsed: 19.9min finished

0.7021276595744681
{'classifier__max_features': 'log2', 'classifier__n_estimators': 300, 'vectorizer__ngram_range': (1, 1)}

―― Au fur et à mesure que le nombre de paramètres à rechercher augmente, le temps nécessaire pour rechercher la recherche de grille devient exponentiellement long.

À l'intérieur de GridSearchCV # fit, l'évaluation des performances est effectuée chaque fois que vous essayez un ensemble de paramètres.
Validation croisée (le nombre de divisions par défaut est 3)
Méthode d'évaluation qui divise les données d'entraînement en K éléments, l'un d'entre eux étant les données de validation, et le reste est la formation et l'évaluation, et il est effectué K fois tout en modifiant les données de validation

14.3 Utilisation d'Hyperopt 14.4 Distribution de probabilité

Un outil pour rechercher des hyper paramètres plus efficacement que la recherche de grille. Donne l'espace des paramètres et la fonction objectif et renvoie les hyperparamètres optimaux.

--Parameter space: Paramètres à rechercher et candidats pour chaque valeur

Distribution uniforme: toutes les valeurs ont la même probabilité d'apparaître
Distribution aléatoire uniforme: La valeur logarithmique suit une distribution uniforme. De grandes valeurs peuvent être obtenues avec parcimonie et de petites valeurs peuvent être obtenues de manière dense. Il est souhaitable de rechercher le taux d'apprentissage à des intervalles logarithmiques. --Génération: lorsque vous spécifiez les limites inférieure et supérieure d'Hyperopt, spécifiez la valeur logarithmique. math.log (..) --Fonction objective: une fonction qui reçoit un ensemble de valeurs de paramètres et renvoie les valeurs.
Si vous voulez maximiser la précision, multipliez-la par moins pour la minimiser (minimiser le moins, c'est maximiser)
Les paramètres optimaux peuvent être obtenus à partir de la valeur de retour de <instance hyperopt> .fmin.

#Recherche de paramètres
vectorizer = TfidfVectorizer(tokenizer=tokenize, ngram_range=(1, 2))
train_vectors = vectorizer.fit_transform(train_texts)

##Fonction objective
def objective(args):
    classifier = RandomForestClassifier(n_estimators=int(args['n_estimators']),
                                        max_features=args['max_features'])
    classifier.fit(tr_vectors, tr_labels)
    val_predictions = classifier.predict(val_vectors)
    accuracy = accuracy_score(val_predictions, val_labels)
    return -accuracy

##Espace des paramètres
max_features_choices = ('sqrt', 'log2', None)
space = {
    'n_estimators': hp.quniform('n_estimators', 10, 500, 10),
    'max_features': hp.choice('max_features', max_features_choices),
}
best = fmin(objective, space, algo=tpe.suggest, max_evals=30)

# train
best_classifier = RandomForestClassifier(
    n_estimators=int(best['n_estimators']),
    max_features=max_features_choices[best['max_features']])
best_classifier.fit(train_vectors, train_labels)

# predict
test_vectors = vectorizer.transform(test_texts)
predictions = best_classifier.predict(test_vectors)

14.5 Application à Keras

Les détails sont omis car l'exécution ne se termine pas facilement.

--Session claire

Si vous construisez le modèle sur la mémoire plusieurs fois pendant la recherche, il consommera la mémoire du GPU, alors relâchez-le à chaque fois.
- if Keras.backend.backend() == 'tensorflow':
- ....Keras.backend.clear_session() --Paramètres --Si les éléments de recherche diffèrent selon les options, vous pouvez spécifier des éléments détaillés pour chaque élément de recherche en imbriquant l'espace de paramètres.
Exemple d'optimiseur --SGD: recherche du taux d'apprentissage et de l'élan --Adagrad; Recherche uniquement taux d'apprentissage

Évaluation

L'exécution ne progresse pas bien (car c'est un CPU, cela prend du temps, ne peut-il pas être exécuté avec un CPU?), Donc je le mettrai à jour plus tard si je peux me le permettre.

Essayez le livre "Introduction au développement d'applications de traitement du langage naturel en 15 étapes" --Chapitre 4 Etape 14 Mémo "Recherche Hyper Paramètre"