Cet article est une traduction de mon blog, Data Science Struggle.
Obtenez une idée approximative de ce qu'est Tensorflow et créez un modèle simple.
Jetons un bref coup d'œil à ce que Tensorflow a appris à se faire entendre à divers endroits et à sa position dans l'apprentissage automatique.
*** Tensorflow est le troisième. *** ***
Ici, la situation réelle concernant les trois ci-dessus est brièvement décrite. Si vous avez réellement appris les mathématiques de l'apprentissage automatique, j'aimerais créer un modèle une fois sans dépendre de la bibliothèque, etc. pour la confirmation des mathématiques et du mécanisme et une réécriture plus flexible. Cependant, il est souvent impossible de créer tous les modèles de cette manière pour chaque situation et le réaménagement des roues est un gaspillage. Par conséquent, en réalité, vous apprendrez à utiliser la bibliothèque pour l'apprentissage automatique et à gérer le problème. La plupart des bibliothèques sont très utiles et vous pouvez atteindre votre objectif en quelques lignes seulement si vous souhaitez simplement modéliser. Cependant, il peut y avoir des situations où une telle bibliothèque est difficile à gérer. Les réseaux neuronaux en sont un exemple. Non seulement le nombre de couches intermédiaires, mais aussi la méthode de jonction et d'interruption des données, tout peut être fait tant que certaines règles sont respectées. Il est difficile d'utiliser une bibliothèque d'apprentissage automatique pour créer de telles choses, mais il y a tellement de choses à craindre pour tout faire vous-même.
Les bibliothèques de calcul pour l'apprentissage automatique, telles que Tensorflow, résolvent la situation ci-dessus. En premier lieu, ce n'est pas une bibliothèque d'apprentissage automatique qui crée un modèle sur une seule ligne. *** Une bibliothèque qui aide les utilisateurs à créer leurs propres modèles ***. En d'autres termes, il est différent d'une bibliothèque d'apprentissage automatique qui peut être utilisée sans connaître du tout le mécanisme, et il est difficile de l'utiliser sans au moins savoir comment créer un modèle.
En fait, voyons comment Tensorflow est une bibliothèque qui effectue les calculs. Tout d'abord, spécifiquement, le calcul suivant est effectué par Tensorflow.
5 + 3
Lorsque cela est résolu par Tensorflow, cela devient comme ça.
add.py
import tensorflow as tf
a = tf.constant(5)
b = tf.constant(3)
added = tf.add(a, b)
with tf.Session() as sess:
print sess.run(added)
Ici, si vous essayez d'imprimer ajouté normalement,
Tensor("Add_1:0", shape=(), dtype=int32)
Est sortie. S'il est interprété correctement, ajouté n'est pas un nombre concret, mais une forme de calcul qui est la somme de a et b, et le calcul réel est effectué lorsqu'il est exécuté dans la session. Il y aura. Ces *** informations de formulaire *** sont appelées *** graph *** dans Tensorflow.
Nous avons vu une méthode de calcul Tensorflow simple ci-dessus, mais il y a encore une chose à craindre. C'est une variable. Puisqu'il s'agit d'une bibliothèque de calculs utilisée dans l'apprentissage automatique, il est essentiel de gérer plusieurs dimensions à la fois, et comme mentionné ci-dessus, après avoir créé *** graphique ***, effectuez un calcul réel par exécution. Il est pratique de pouvoir spécifier ultérieurement la valeur à donner à la variable. En fait, Tensorflow a cette fonctionnalité. En résumé, *** Tensorflow a plusieurs dimensions, constantes et variables temporaires qui acceptent les affectations plus tard ***. Les variables peuvent être définies comme suit.
#constant
a = tf.constant(3)
#variable
b = tf.Variable(0)
#Espace réservé
c = tf.placeholder(tf.float32)
Plus précisément, si vous essayez de calculer à l'aide d'espaces réservés
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
added = tf.add(a, b)
with tf.Session() as sess:
print sess.run(added, feed_dict = {a: 3.0, b: 5.0})
Dans l'exemple ci-dessus, jusqu'à ajouté est un graphique, et une valeur spécifique est donnée par feed_dict dans la phase d'exécution pour effectuer le calcul.
Classifions en fait les données d'iris en utilisant tensorflow. À partir de ce moment, toute la phase sera divisée en deux parties: *** création de dessin de conception *** et *** construction ***.
*** La création d'un dessin de conception *** fait partie du type de modèle et de graphique à créer.
*** Construire *** fait référence à la définition des paramètres dans le dessin de conception en entrant des données dans le dessin de conception ci-dessus.
Voici un exemple de code de la classification de l'iris.
De plus, dans les données
https://dl.dropboxusercontent.com/u/432512/20120210/data/iris.txt
Utilisez celui téléchargé depuis.
get_data.py
import pandas as pd
import tensorflow as tf
from sklearn import cross_validation
data = pd.read_csv('https://dl.dropboxusercontent.com/u/432512/20120210/data/iris.txt', sep = "\t")
data = data.ix[:,1:]
train_data, test_data, train_target, test_target = cross_validation.train_test_split(data.ix[:,['Sepal.Length', 'Sepal.Width', 'Petal.Length', 'Petal.Width']], data.ix[:,['Species']], test_size = 0.4, random_state = 0)
Avec le code ci-dessus, les données d'iris sont acquises et divisées en données d'entraînement et données de test. À l'avenir, nous créerons un modèle en utilisant les données appariées de train_data et train_target. La réponse lorsque train_data est donné est train_target. Bien sûr, comme il est divisé en train et test, cela doit être fait avec des données de test, mais cette fois, il est omis. À partir de là, nous allons créer un dessin de conception et construire en fonction de celui-ci.
classify.py
#Dessin de conception
#Paramètres d'espace réservé
X = tf.placeholder(tf.float32, shape = [None, 4])
Y = tf.placeholder(tf.float32, shape = [None, 3])
#Paramétrage
W = tf.Variable(tf.random_normal([4, 3], stddev=0.35))
#Fonction d'activation
y_ = tf.nn.softmax(tf.matmul(X, W))
#Construire
#Fonction de perte
cross_entropy = -tf.reduce_sum(Y * tf.log(y_))
#Apprentissage
optimizer = tf.train.GradientDescentOptimizer(0.001)
train = optimizer.minimize(cross_entropy)
#Courir
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
for i in range(1000):
x = train_data
y = pd.get_dummies(train_target)
print(sess.run(W))
sess.run(train, feed_dict = {X: x, Y: y})
test = sess.run(W)
Regardons chacun d'eux. Commencez par créer un dessin de conception. Lorsque la matrice des variables explicatives est X, la matrice des variables expliquées est Y et le poids est W, ce dessin de conception peut être exprimé comme suit. Le terme de biais n'est pas utilisé cette fois.
X = [None, 4]\\
W = [4, 3]\\
Y = [None, 3]\\
[None, 4] \times [4, 3] = [None, 3]\\
[Aucun, 3] dans l'équation ci-dessus correspond à Y. En fait, passez au code.
placeholder.py
#Paramètres d'espace réservé
X = tf.placeholder(tf.float32, shape = [None, 4])
Y = tf.placeholder(tf.float32, shape = [None, 3])
Définissez un espace réservé. X et Y définis ici pointent respectivement vers la variable explicative et la variable expliquée dans les données, et les données seront saisies dans la partie après ***. Les données sur l'iris ont quatre variables explicatives et trois classes à classer. De plus, étant donné que le nombre à donner lors de l'alimentation des données (le nombre de lignes dans la base de données) est inconnu, mettez None ici.
parameter.py
#Paramétrage
W = tf.Variable(tf.random_normal([4, 3], stddev=0.35))
Définissez la partie paramètre, c'est-à-dire le poids. Dans la partie construction, ce paramètre W sera mis à jour et confirmé par la saisie de données. Dans les parties tf.random_normal et stddev, les nombres aléatoires qui suivent la distribution spécifiée sont donnés comme valeurs initiales. Il y a plusieurs façons de les donner, vous devriez donc les regarder.
activate.py
#Fonction d'activation
y_ = tf.nn.softmax(tf.matmul(X, W))
Déterminez la fonction d'activation. Il est nécessaire de sélectionner une fonction appropriée en fonction de la forme de la sortie, qu'il s'agisse d'une couche intermédiaire ou d'une couche de sortie, etc. Dans ce cas, ce y_ est la sortie finale de l'entrée.
Au-delà, il y a la partie construction. Tensorflow fait bien les calculs délicats, mais vous devez comprendre la composition de ce que vous faites. Si la composition de la pièce de construction est décrite de manière appropriée, cela signifie que *** une fonction de perte est définie et les paramètres sont mis à jour afin que la perte devienne plus petite ***. La précision de la prédiction dépend de la valeur du paramètre W défini ci-dessus. Modifiez les paramètres pour que la prédiction soit aussi précise que possible. À ce moment-là, au lieu de se concentrer sur *** la précision ***, nous nous sommes concentrés sur *** le peu d'erreurs *** et avons mis à jour les paramètres afin qu'il y ait moins d'erreurs. Cela signifie y aller.
lost.py
#Fonction de perte
cross_entropy = -tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_, Y)
Cette fonction de perte fait partie de *** le peu d'erreurs mentionnées ci-dessus ***. La fonction de perte diffère selon que le modèle à créer est une classification ou une régression. Cela doit être étudié car Tensorflow a plusieurs fonctions de perte.
train.py
#Apprentissage
optimizer = tf.train.GradientDescentOptimizer(0.001)
train = optimizer.minimize(cross_entropy)
L'optimiseur définit comment mettre à jour réellement les paramètres en fonction des données. En train, la fonction de perte est réduite (mise à jour des paramètres) en fonction de la méthode de mise à jour spécifiée par l'optimiseur.
execute.py
#Courir
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(1000):
x = train_data
y = pd.get_dummies(train_target)
print(sess.run(W))
sess.run(train, feed_dict = {X: x, Y: y})
Faites une construction en béton ici. Cette fois, je l'ai sauté et j'ai lu toutes les données 1000 fois comme une seule unité. Dans la partie de sess.run (), des données concrètes sont données à la partie placeholder par feed_dict. Cela recherche les paramètres qui minimisent localement la fonction de perte et met à jour W. En réalité, il arrive souvent que le degré de perte soit noté.
Recommended Posts