J'ai décidé de démarrer TensorFlow. En tant que tutoriel, MNIST etc. a déjà une traduction japonaise du prédécesseur, j'ai donc décidé de traduire Getting Started With TensorFlow (https://www.tensorflow.org/get_started/get_started) (au 11 mars 2017) que je n'ai pas trouvé fait.

Veuillez signaler toute erreur.

Getting Started With TensorFlow

Avec ce guide, vous êtes prêt à programmer dans TensorFlow. Veuillez Installer TensorFlow avant d'utiliser ce guide. Pour tirer le meilleur parti de ce guide, vous devez connaître les éléments suivants:

--Comment programmer en Python

Ce que vous savez au moins un peu sur les tableaux ――Idéalement quelque chose sur l'apprentissage automatique. Si vous ne savez pas peu ou pas du tout, ce sera votre premier guide à lire.

TensorFlow fournit plusieurs API. L'API de niveau le plus bas (TensorFlow Core) vous offre un contrôle complet de la programmation. TensorFlow Core est recommandé aux chercheurs en apprentissage automatique et à tous ceux qui ont besoin d'un niveau de contrôle plus fin sur leurs modèles. Les API de niveau supérieur sont généralement plus faciles à apprendre et à utiliser que TensorFlow Core. De plus, ces API de haut niveau rendent les tâches répétitives plus faciles et plus cohérentes entre les différents utilisateurs. Les API de haut niveau telles que tf.contrib.learn aident à gérer les ensembles de données, les estimateurs, la formation et l'inférence. Certaines API de haut niveau de TensorFlow (leurs noms de méthode incluent «contrib») sont en cours de développement. Certaines méthodes contrib peuvent changer ou être obsolètes dans la prochaine version de TensorFlow.

Ce guide commence par TensorFlow Core. Ensuite, je vais vous montrer comment implémenter le même modèle dans tf.contrib.learn. Connaître les principes de TensorFlow Core fournit un très bon modèle mental de la façon dont les choses fonctionnent en interne lors de l'utilisation d'une API de haut niveau plus compacte.

Tensors L'unité centrale de données dans TensorFlow est un tenseur. Un tenseur est constitué d'un ensemble de valeurs primitives sous la forme d'un tableau de nombre arbitraire de dimensions.

3 # Tenseur de rang 0; Il s'agit d'un scalaire de forme []. [1., 2., 3.] # Tenseur de rang 1: il s'agit d'un vecteur de forme [3]. [[1., 2., 3.], [4., 5., 6.]] # Tenseur de rang 2, matrice de forme [2, 3]. [[[1., 2., 3.]], [[7., 8., 9.]]] # forme [2, 1, 3], tenseur de rang 3

TensorFlow Core tutorial Importer TensorFlow

La description standard d'une importation TensorFlow est ci-dessous: import tensorflow as tf

Cela permet à Python d'accéder à toutes les classes, méthodes et symboles TensorFlow. La plupart de ce document suppose que vous l'avez déjà fait.

Graphique de calcul

Vous pourriez penser que le programme TensorFlow Core se compose de deux sections distinctes.

Créez un graphique de calcul
Exécutez le graphique de calcul

** Computation Graph ** est une série d'opérations TensorFlow disposées sur un graphe multi-nœuds. (Un graphe de calcul est une série d'opérations TensorFlow disposées en un graphe de nœuds.) Construisons un graphe de calcul simple. Chaque nœud prend zéro ou plusieurs tenseurs en entrée et délivre un tenseur. Un type de nœud est une constante. Toutes les constantes TensorFlow ne prennent aucune entrée et sortent les valeurs qui y sont stockées. Vous pouvez créer deux tenseurs de fraction flottants node1 et node2 comme suit:

node1 = tf.constant(3.0, tf.float32)

node2 = tf.constant (4.0) # Implicitement tf.float32 print(node1, node2)

Le résultat de l'instruction d'impression finale ressemble à ceci Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

Notez que l'impression du nœud n'imprime pas les valeurs attendues «3.0» ou «4.0». Au lieu de cela, ce sont des nœuds qui produisent respectivement 3.0 et 4.0 lorsqu'ils sont évalués. Les graphiques de calcul doivent être calculés dans ** session ** afin d'évaluer correctement le nœud. Les sessions encapsulent le contrôle et l'état du runtime TensorFlow.

Le code suivant crée un objet Session, puis appelle sa méthode run pour exécuter suffisamment le graphe de calcul pour évaluer node1 et node2. Si vous exécutez le graphique de calcul dans une session comme ci-dessous:

sess = tf.Session()
print(sess.run([node1, node2]))

Vous pouvez voir les valeurs 3.0 et 4.0 attendues:

[3.0, 4.0]

Vous pouvez construire des calculs plus complexes en combinant le nœud Tensor avec des opérations (les opérations sont également des nœuds). Par exemple, vous pouvez ajouter deux nœuds constants pour créer un nouveau graphique comme indiqué ci-dessous:

node3 = tf.add(node1, node2)
print("node3: ", node3)
print("sess.run(node3): ",sess.run(node3))

Les deux dernières instructions d'impression s'impriment:

node3:  Tensor("Add_2:0", shape=(), dtype=float32)
sess.run(node3):  7.0

TensorFlow fournit un utilitaire appelé TensorBoard qui peut afficher des images de graphes de calcul. Voici une capture d'écran montrant comment TensorBoard visualise un graphique:

TensorBoard

A ce rythme, ce graphique n'est pas particulièrement intéressant car il produit toujours le même résultat. Les graphiques peuvent être paramétrés pour accepter une entrée externe, connue sous le nom de ** espaces réservés **. ** Les espaces réservés ** sont des prédictions pour la fourniture ultérieure de valeurs.

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b  # + provides a shortcut for tf.add(a, b)

Les trois lignes ci-dessus sont comme des fonctions ou des lambdas. Définissez deux paramètres d'entrée (a et b) puis leurs opérations. Ce graphique peut être évalué avec plusieurs entrées. En utilisant le paramètre feed_dict pour identifier le Tensor qui fournit des valeurs spécifiques pour ces espaces réservés.

print(sess.run(adder_node, {a: 3, b:4.5}))
print(sess.run(adder_node, {a: [1,3], b: [2, 4]}))

Le résultat de sortie est

7.5
[ 3.  7.]

Dans TensorBoard, le graphique ressemble à ceci:

TensorBoard_2

Vous pouvez créer des graphiques de calcul plus complexes en ajoutant d'autres opérations. Par exemple

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))

Le résultat de sortie est

22.5

Le graphique de calcul précédent ressemble à ceci sur TensorBoard:

TensorBoard_3

Dans l'apprentissage automatique, nous voulons généralement un modèle qui peut accepter des entrées ambiguës comme l'une des précédentes. Pour rendre le modèle entraînable, nous devons être en mesure de modifier le graphe afin d'obtenir une nouvelle sortie pour la même entrée. ** Les variables ** vous permettent d'ajouter des paramètres d'apprentissage à votre graphique. Ils se composent du type et de la valeur initiale:

W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b

La constante est initialisée lorsque vous appelez tf.constant et sa valeur ne change pas. En revanche, les variables ne sont pas initialisées lorsque vous appelez tf.Variable. Pour que le programme TensorFlow initialise toutes les variables, vous devez explicitement effectuer les opérations spéciales suivantes:

init = tf.global_variables_initializer()
sess.run(init)

Il est important de reconnaître que ʻinitest le handle du sous-graphe TensorFlow qui initialise toutes les variables globales. Ces variables ne sont initialisées que lorsque vous appelezsess.run`.

Puisque x est un espace réservé, vous pouvez évaluer linear_model pour plusieurs valeurs x en même temps:

print(sess.run(linear_model, {x:[1,2,3,4]}))

La sortie est

[ 0. 0.30000001 0.60000002 0.90000004]

Nous avons créé un modèle mais ne savons pas à quel point il est bon. Afin d'évaluer le modèle avec des données d'entraînement, nous avons besoin d'un espace réservé «y» qui fournit la valeur souhaitée, et nous devons écrire une fonction d'erreur.

La fonction d'erreur mesure la distance entre le modèle actuel et les données fournies. Nous utiliserons le modèle de perte standard pour la régression linéaire, qui est la somme des carrés des deltas entre le modèle actuel et les données fournies. linear_model-y crée un vecteur dans lequel chaque élément correspond au delta d'erreur d'un exemple. Appelez tf.square pour corriger ces erreurs. Ensuite, utilisez tf.reduce_sum pour additionner toutes les erreurs au carré pour créer un scalaire qui extrait les erreurs de tous les échantillons:

y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

La valeur d'erreur est

23.66

Cela peut être résolu en réaffectant manuellement les valeurs parfaites -1 et 1 pour «W» et «b». La variable est initialisée à la valeur fournie dans «tf.Variable», mais peut être modifiée par une opération comme «tf.assign». Par exemple, «W = -1» et «b = 1» sont les meilleurs paramètres pour notre modèle. Vous pouvez changer «W» et «b» comme suit:

fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

L'impression finale indique que l'erreur est nulle.

0.0

J'ai deviné les valeurs «parfaites» pour «W» et «b», mais le but de l'apprentissage automatique est de trouver automatiquement les paramètres de modèle corrects. Nous verrons comment y parvenir dans la section suivante.

tf.train API Une discussion complète sur l'apprentissage automatique dépasse le cadre de ce didacticiel. Cependant, TensorFlow fournit des ** optimiseurs ** qui modifient lentement chaque variable pour minimiser la fonction d'erreur. L'optimiseur le plus simple est la ** descente de gradient **. Il modifie chaque variable par l'ampleur du différentiel pour chaque variable dans la fonction d'erreur. En général, le calcul manuel des différentiels symboliques est fastidieux et sujet aux erreurs. En conséquence, TensorFlow peut calculer automatiquement le différentiel en donnant simplement une description du modèle à l'aide de la fonction tf.gradients. En termes simples, l'optimiseur le fait généralement pour vous. Par exemple

optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

sess.run(init) # reset values to incorrect defaults.
for i in range(1000):
  sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})

print(sess.run([W, b]))

Le dernier paramètre du modèle est: [array([-0.9999969], dtype=float32), array([ 0.99999082], dtype=float32)]

J'ai pu apprendre les machines! Cette régression linéaire simple ne nécessite pas beaucoup de code de base TensorFlow, mais plus de code est nécessaire pour fournir un modèle avec des modèles et des méthodes plus complexes. Par conséquent, TensorFlow fournit un niveau d'abstraction plus élevé pour les modèles, structures et fonctionnalités courants. Vous apprendrez à utiliser ces abstractions dans la section suivante.

Programme complet

La version complète du modèle de régression linéaire entraînable est présentée ci-dessous:

import numpy as np
import tensorflow as tf

#Model paramètres W = tf.Variable([.3], tf.float32) b = tf.Variable([-.3], tf.float32) #Modèle d'entrée et de sortie x = tf.placeholder(tf.float32) linear_model = W * x + b y = tf.placeholder(tf.float32) #Erreur loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares #Optimiseur optimizer = tf.train.GradientDescentOptimizer(0.01) train = optimizer.minimize(loss) #Données d'entraînement x_train = [1,2,3,4] y_train = [0,-1,-2,-3]

Boucle d'entraînement

init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
  sess.run(train, {x:x_train, y:y_train})

Évaluer l'exactitude de la formation

curr_W, curr_b, curr_loss  = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))

Lorsqu'il est exécuté, cela ressemble à ceci:

W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11

Ce programme plus complexe peut être visualisé avec TensorBoard

TensorBoard_4

tf.contrib.learn

tf.contrib.learn est une bibliothèque TensorFlow de haut niveau qui simplifie le comportement d'apprentissage automatique. Comprend:

Exécutez une boucle d'entraînement --Exécuter la boucle d'évaluation --Gérer les ensembles de données --Gérer l'alimentation

tf.contrib.learn définit de nombreux modèles courants.

Utilisation de base

Voyez comme un simple programme de régression linéaire peut être facile avec tf.contrib.learn:

import tensorflow as tf

#NumPy est souvent utilisé pour lire, manipuler et prétraiter les données. import numpy as np

Déclarez une liste de fonctionnalités. Pour le moment, je n'utilise qu'une seule fonctionnalité réelle. Plus compliqué et pratique

#Il existe de nombreux autres types de colonnes features = [tf.contrib.layers.real_valued_column("x", dimension=1)]

#Estimator est une interface pour la formation (ajustement) et l'évaluation (estimation).

Régression linéaire, régression logistique, classification linéaire, classification logistique,

Et comme de nombreux classificateurs et régressions de réseaux de neurones

#Il existe de nombreux types déjà définis.

Vous pouvez utiliser un estimateur de classification linéaire avec le code suivant.

estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)

#TensorFlow contient de nombreuses méthodes d'assistance pour le chargement et la configuration des ensembles de données.

Ici, nous utilisons `numpy_input_fn`.

Le nombre de lots (num_epochs) de données requises et

Donnez à la fonction la taille de chaque lot.

x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x}, y, batch_size=4,
                                          num_epochs=1000)

En appelant la méthode # fit et en donnant l'ensemble de données d'entraînement

Vous pouvez lancer 1000 étapes d'entraînement.

estimator.fit(input_fn=input_fn, steps=1000)

Ici, je vais évaluer la qualité de ce modèle. Dans un vrai exemple

Je voudrais tester un ensemble de données en utilisant une validation séparée pour éviter le surentraînement.

estimator.evaluate(input_fn=input_fn)

Lorsqu'il est exécuté, le résultat ressemble à ceci

{'global_step': 1000, 'loss': 1.9650059e-11}

Modèle personnalisé

tf.contrib.learn ne vous garde pas dans un modèle prédéfini. Supposons que vous souhaitiez créer un modèle personnalisé qui n'est pas intégré à TensorFlow. Vous pouvez conserver le jeu de données tf.contrib.learn et les abstractions de haut niveau telles que l'alimentation, l'entraînement, etc. À des fins d'illustration, je vais vous montrer comment créer votre propre modèle égal à LinearRegressor en utilisant une connaissance de niveau inférieur de l'API TensorFlow.

Utilisez tf.contrib.learn.Estimator pour définir un modèle personnalisé qui fonctionne avec tf.contrib.learn. En fait, tf.contrib.learn.LinearRegressor est une sous-classe de tf.contrib.learn.Estimator. Au lieu de sous-classer ʻEstimator, nous fournirons simplement ʻEstimator à la fonction model_fn, qui indique à tf.contrib.learn comment il évalue les prédictions, les nombres d'entraînement et les erreurs. .. Le code ressemble à ceci:

import numpy as np
import tensorflow as tf

Déclarez une liste de fonctionnalités. Pour le moment, je n'utilise qu'une seule fonctionnalité réelle

def model(features, labels, mode):

Construire un modèle linéaire pour prédire les valeurs

  W = tf.get_variable("W", [1], dtype=tf.float64)
  b = tf.get_variable("b", [1], dtype=tf.float64)
  y = W*features['x'] + b

Sous-graphique d'erreur

  loss = tf.reduce_sum(tf.square(y - labels))

Sous-graphique de formation

  global_step = tf.train.get_global_step()
  optimizer = tf.train.GradientDescentOptimizer(0.01)
  train = tf.group(optimizer.minimize(loss),
               tf.assign_add(global_step, 1))

#ModelFnOps pour une fonctionnalité appropriée (fonctionnalité)

Combinez les sous-graphiques que vous avez créés jusqu'à présent

  return tf.contrib.learn.ModelFnOps(
  mode=mode, predictions=y,
  loss=loss,
  train_op=train)

estimator = tf.contrib.learn.Estimator(model_fn=model)

#Définition de l'ensemble de données x = np.array([1., 2., 3., 4.]) y = np.array([0., -1., -2., -3.]) input_fn = tf.contrib.learn.io.numpy_input_fn({"x": x}, y, 4, num_epochs=1000)

Entraînement

estimator.fit(input_fn=input_fn, steps=1000)

#Evaluer le modèle print(estimator.evaluate(input_fn=input_fn, steps=10))

Le résultat de l'exécution sera le suivant

{'loss': 5.9819476e-11, 'global_step': 1000}

Notez que le contenu de la fonction personnalisée model () est très similaire à une boucle qui entraîne manuellement un modèle à partir d'une API de bas niveau.

L'étape suivante

J'ai une connaissance de base utile de TensorFlow. Nous avons préparé quelques tutoriels pour vous aider à en savoir plus. Si vous êtes un débutant en apprentissage automatique, MNIST pour les débutants, sinon Deep MNIST pour les experts Voir (/ get_started / mnist / pros).

Sauf indication contraire, le contenu de cette page est Licence Creative Commons Attribution 3.0 et le code est [Licence Apache 2.0](http: // www). Il est sous licence .apache.org / licenses / LICENSE-2.0). Voir Politiques du site pour plus d'informations. Java est une marque déposée d'Oracle et de ses filiales.

Dernière mise à jour le 8 mars 2017

Traduire Premiers pas avec TensorFlow