[Introduction à Tensorflow] Comprendre correctement Tensorflow et essayer de créer un modèle

Cet article est une traduction de mon blog, Data Science Struggle.

Objectif

Obtenez une idée approximative de ce qu'est Tensorflow et créez un modèle simple.

Aperçu de Tensorflow

Jetons un bref coup d'œil à ce que Tensorflow a appris à se faire entendre à divers endroits et à sa position dans l'apprentissage automatique.

  1. Qu'est-ce que Tensorflow? Tout d'abord, Tensorflow peut être considéré comme un ordinateur *** qui effectue automatiquement des calculs pour déterminer les paramètres du réseau neuronal *** lors de son utilisation réelle. La *** calculatrice *** ici fait littéralement le calcul, comme donner une réponse 1 + 1.
  2. Quelle est votre position dans l'apprentissage automatique? Il existe environ trois méthodes utilisant l'apprentissage automatique. Le premier est un modèle dans lequel vous créez votre propre modèle dans chaque langue après avoir correctement compris les algorithmes et les mathématiques. Le second est un modèle qui crée un modèle en quelques lignes en utilisant sklearn pour python et chaque bibliothèque selon la méthode pour R. Le troisième est un modèle que vous créez vous-même à l'aide d'une bibliothèque de calculs adaptée à la création de modèles d'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.

Comment calculer Tensorflow

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.

Variables 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.

Classification par Tensorflow

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

[Introduction à Tensorflow] Comprendre correctement Tensorflow et essayer de créer un modèle
Faisons un noyau jupyter
Essayez TensorFlow RNN avec un modèle de base
[Introduction au modèle SEIR] Essayez d'ajuster les données COVID-19 ♬
Créez un chat bot et entraînez-vous à être populaire.
Essayez de créer un code de "décryptage" en Python
Essayez de créer un groupe de dièdre avec Python
J'ai créé un jeu ○ ✕ avec TensorFlow
WEB grattage avec python et essayez de créer un nuage de mots à partir des critiques
J'ai essayé de créer une API de reconnaissance d'image simple avec Fast API et Tensorflow
Essayez de créer un module Python en langage C
Faisons un outil de veille de commande avec python
Les débutants en apprentissage automatique essaient de créer un arbre de décision
Créer un discriminateur Sato Yohei en utilisant OpenCV et TensorFlow
J'ai essayé de faire quelque chose comme un chatbot avec le modèle Seq2Seq de TensorFlow
Recueillir les informations erronées de Toshiyuki Sakamoto "Faire et comprendre! Introduction à l'algorithme d'apprentissage d'ensemble"
Introduction à Private TensorFlow
Une super introduction à Linux
Essayez de comprendre Python soi
Essayez d'ouvrir une sous-fenêtre avec PyQt5 et Python
[Introduction au modèle de maladie infectieuse] J'ai essayé de m'adapter et de jouer
Une note sur TensorFlow Introduction
Essayez de modéliser une distribution multimodale à l'aide de l'algorithme EM
Essayez de sélectionner une langue
Essayez simplement de recevoir un webhook avec ngrok et Python
Une histoire sur le portage du code de "Essayez de comprendre comment fonctionne Linux" sur Rust
Création d'un modèle séquentiel Tensorflow avec une image originale ajoutée à MNIST
Introduction à Bayes non paramétrique 2 (processus de buffet indien et modèle de fonction latente)
Essayez de modifier une nouvelle image à l'aide du modèle StyleGAN2 entraîné
[Introduction à Systre] Echange et actions: comportement lors d'un crash ♬
Spigot (Paper) Introduction à la création d'un plug-in pour 2020 # 01 (Construction de l'environnement)
J'ai essayé de faire un processus d'exécution périodique avec Selenium et Python
Comment faire un test unitaire Part.1 Modèle de conception pour l'introduction
[Introduction] Je veux créer un robot Mastodon avec Python! 【Débutants】
Essayez de faire une stratégie de blackjack en renforçant l'apprentissage ((1) Implémentation du blackjack)
Essayer d'implémenter et de comprendre les arborescences de segments étape par étape (python)
Comment faire une traduction japonais-anglais
Essayez de dessiner une courbe de Bézier
[Introduction à Python3 Jour 1] Programmation et Python
Introduction à TensorFlow - Hello World Edition
Créer un outil de reconnaissance de visage à l'aide de TensorFlow
Comment créer un bot slack
Comment créer un robot - Avancé
Comment créer une fonction récursive
Comment convertir le modèle Tensorflow en Lite
[Blender] Comment créer un plug-in Blender
Une introduction légère à la détection d'objets
Comment créer un robot - Basic
Créer un itérateur de modèle avec PySide
Faisons une application qui affaiblit les nerfs avec Vue.js et Django-Rest-Framework [Partie 4] ~ Construction MySQL et migration de base de données avec Docker ~
Introduction et utilisation de la bouteille Python ・ Essayez de configurer un serveur Web simple avec une fonction de connexion
2.Faites un arbre de décision à partir de 0 avec Python et comprenez-le (2. Bases du programme Python)
[Introduction à Python] Quelle est la différence entre une liste et un taple?
Comment faire un modèle pour la détection d'objets avec YOLO en 3 heures
Essayez de déduire à l'aide d'un modèle de régression linéaire sur Android [PyTorch Mobile]
Essayez de créer un logiciel de capture aussi précis que possible avec python (2)
Essayez de créer foldl et foldr avec Python: lambda. Aussi mesure du temps
J'ai appris le grattage à l'aide de sélénium pour créer un modèle de prédiction de courses de chevaux.
J'ai trouvé un moyen de créer un modèle 3D à partir d'une photo.