Une introduction à l'apprentissage automatique pour les développeurs de robots
introduction
2016 a été une année au cours de laquelle les bots ont attiré beaucoup d'attention. Ce fut également une année au cours de laquelle de nouvelles possibilités se sont révélées les unes après les autres grâce aux progrès technologiques remarquables liés à l'apprentissage automatique.
Si vous lisez cet article, vous souhaiterez probablement développer un bot qui utilise l'apprentissage automatique. "Mais je ne sais pas quoi faire" Cet article est destiné à ces lecteurs.
Comment utiliser et utiliser l'apprentissage automatique
Je pense qu'il existe deux utilisations principales de l'apprentissage automatique. L'un est "l'interaction entre l'utilisateur et le bot", et l'autre est le "service fourni à l'utilisateur".
Le premier vous permet d'interagir avec l'utilisateur par écriture naturelle. Il serait réaliste d'utiliser ici un service existant tel que Microsoft LUIS. Ce qui suit est un bon résumé des services disponibles autres que LUIS.
Résumé des API, bibliothèques et services de conversation pouvant être utilisés avec BOT
Ensuite, à propos de la partie «services fournis aux utilisateurs». Je pense que cela peut être divisé en deux.
Partie 1. Utilisez les services et les API généralement fournis
Si vous utilisez l'API, etc. présentée dans l'article ci-dessus, vous pourrez très facilement utiliser les derniers résultats de l'apprentissage automatique. Le point à noter est que si vous utilisez simplement l'API telle quelle, vous vous retrouverez avec des robots similaires.
Partie 2. Utiliser un cadre d'apprentissage automatique
L'autre consiste à écrire du code à l'aide d'un cadre d'apprentissage automatique. De plus, il s'agit d'une approche d'apprentissage utilisant vos propres données et ressources (telles que le GPU). Les obstacles vont se lever tout de suite, mais je pense que c'est une étape incontournable si vous souhaitez fournir des services très originaux.
Développons maintenant un robot qui offre un service unique utilisant l'apprentissage automatique!
Sélection du cadre
Avant de vous lancer dans l'implémentation, sélectionnez le cadre d'apprentissage automatique à utiliser cette fois.
Guide de randonnée du cadre d'apprentissage en profondeur
Le plus populaire est Tensorflow, mais son API de bas niveau (ne signifie-t-il pas de mauvaises performances?) Peut être un peu un défi pour les débutants. Cette fois, je voudrais sélectionner Keras. Comme il s'agit d'une API de haut niveau, elle présente l'avantage que la description est simple et facile à comprendre.
De plus, choisissez un framework qui implémente le bot.
Comme vous pouvez le voir dans l'article ci-dessus, la plupart des langages utilisés sont Python. D'autre part, Node.js est-il souvent utilisé pour implémenter des bots? La manière générale d'éliminer cette discordance est probablement de «mettre en œuvre chacun séparément et de l'utiliser via l'API», mais cette fois, j'aimerais écrire le bot en Python pour simplifier l'implémentation. Le framework utilisé est python-rtmbot.
Que devrais-je faire?
Si vous souhaitez développer un bot qui fournit votre propre service à l'aide de l'apprentissage automatique, vous devez effectuer très grossièrement les trois choses suivantes.
- Construisez un modèle d'apprentissage
- Préparez les données et entraînez le modèle
- Processus utilisant le modèle formé
La plupart des didacticiels du cadre d'apprentissage automatique n'en font qu'un ou deux ci-dessus.
Fondamentalement, il suffit de construire et de former le modèle une fois. Bien entendu, il est indispensable que la prédiction soit suffisamment précise. Après cela, le flux général consiste à écrire la structure du modèle et les résultats d'entraînement (paramètres) dans un fichier et à les lire au moment de l'exécution (= 3).
Construction de modèles, apprentissage
Comme mentionné ci-dessus, il existe de nombreux didacticiels et exemples pour créer et apprendre le modèle, nous allons donc utiliser cette fois les modèles existants.
Essayez le rappel Keras (sauvegarde du modèle, restauration / exportation TensorBoard / arrêt anticipé) Utilisez ceci pour créer un bot qui "renvoie la valeur de sin lorsqu'il est prononcé". Ce n'est pas pratique, mais cela devrait être un bon échantillon.
De plus, ce jeu de codes a été téléchargé sur Github (fullkawa / ml-bot-sample). Après cela, je n'expliquerai que les parties nécessaires d'ici.
Tout d'abord, "train.py", mais ce n'est qu'un résumé de la source de l'article de référence. Ce sera.
Le point est la 73e ligne
train.py
cp_cb = ModelCheckpoint(filepath = fpath, monitor='val_loss', verbose=1, save_best_only=True, mode='auto')
Et lignes 78-80
train.py
json_string = model.to_json()
#open(os.path.join(f_model,'./tensorlog/rnn_model.json'), 'w').write(json_string)
open(os.path.join('./tensorlog/rnn_model.json'), 'w').write(json_string)
est. Le premier écrit les résultats d'entraînement (paramètres) et le second écrit la structure du modèle dans un fichier. Voir l'article source pour ce que vous faites ailleurs.
Exécutez python train.py une fois avant de déplacer le bot.
112-233:ml-bot-sample y.furukawa$ python train.py
Using TensorFlow backend.
____________________________________________________________________________________________________
Layer (type) Output ShapeParam # Connected to
====================================================================================================
lstm_1 (LSTM)(None, 300) 362400lstm_input_1[0][0]
____________________________________________________________________________________________________
dense_1 (Dense)(None, 1) 301 lstm_1[0][0]
____________________________________________________________________________________________________
activation_1 (Activation)(None, 1) 0 dense_1[0][0]
====================================================================================================
Total params: 362701
____________________________________________________________________________________________________
Train on 3325 samples, validate on 176 samples
Epoch 1/10
3000/3325 [==========================>...] - ETA: 4s - loss: 0.2627 - acc: 0.0000e+00 Epoch 00000: val_loss improved from inf to 0.19250, saving model to ./tensorlog/weights.00-0.24-0.19.hdf5
3325/3325 [==============================] - 49s - loss: 0.2408 - acc: 3.0075e-04 - val_loss: 0.1925 - val_acc: 0.0000e+00
Epoch 2/10
3000/3325 [==========================>...] - ETA: 4s - loss: 0.0456 - acc: 3.3333e-04 Epoch 00001: val_loss improved from 0.19250 to 0.00085, saving model to ./tensorlog/weights.01-0.04-0.00.hdf5
3325/3325 [==============================] - 48s - loss: 0.0412 - acc: 3.0075e-04 - val_loss: 8.4748e-04 - val_acc: 0.0000e+00
Epoch 3/10
3000/3325 [==========================>...] - ETA: 4s - loss: 0.0015 - acc: 3.3333e-04 Epoch 00002: val_loss did not improve
3325/3325 [==============================] - 47s - loss: 0.0024 - acc: 3.0075e-04 - val_loss: 0.0228 - val_acc: 0.0000e+00
Epoch 4/10
3000/3325 [==========================>...] - ETA: 4s - loss: 0.0189 - acc: 3.3333e-04 Epoch 00003: val_loss did not improve
3325/3325 [==============================] - 46s - loss: 0.0177 - acc: 3.0075e-04 - val_loss: 0.0055 - val_acc: 0.0000e+00
Epoch 5/10
3000/3325 [==========================>...] - ETA: 4s - loss: 0.0089 - acc: 3.3333e-04 Epoch 00004: val_loss did not improve
3325/3325 [==============================] - 47s - loss: 0.0095 - acc: 3.0075e-04 - val_loss: 0.0163 - val_acc: 0.0000e+00
Epoch 00004: early stopping
Dans ce cas, la sortie "weights.01-0.04-0.00.hdf5" par Epock 2/10 est la plus précise (val_loss: 8.4748e-04 --val_acc: 0.0000e + 00), et c'est plutôt pire après cela. Je vais.
Implémentation du bot
Vient ensuite le programme bot. Ceci (plugins / sin.py) est le plat principal cette fois.
plugins/sin.py
model_json = open('tensorlog/rnn_model.json', 'r').read()
model = model_from_json(model_json)
Chargez la structure du modèle,
plugins/sin.py
files = glob.glob('tensorlog/weights.*.hdf5')
model.load_weights(files[-1])
Lisez le résultat d'apprentissage (paramètre). Le fichier avec le plus grand nombre = le paramètre appris le plus précis est en cours de lecture.
Avec ça seul
plugins/sin.py
predicted = self.model.predict(X, batch_size=1)
Vous pouvez obtenir la valeur du péché comme ceci. Avant ça
plugins/sin.py
X = np.zeros((1,100,1))
for i in range(0, 100):
X[0, i, 0] = i #Corrigé dans cet exemple
N'est pas une partie particulièrement importante, il suffit de préparer les données pour calculer la valeur de péché. Cependant, la nécessité de faire correspondre la taille du tableau est fastidieuse.
Résultat d'exécution
112-233:ml-bot-sample y.furukawa$ rtmbot
Using TensorFlow backend.
Model loaded.
Weights loaded from tensorlog/weights.01-0.04-0.00.hdf5
READY!
Cette fois, le nom du bot est "stag.feec". Je vais te parler.
J'ai pu rendre en toute sécurité la valeur du péché!
Recommended Posts