notes d'étude tensorflow (quatre) - Mise en route - Utilisation de base

Tutoriel Adresse: tensorflow communauté chinoise

utilisation de base

Utilisez tensorflow, vous devez comprendre tensorflow:

• La figure (graphique) pour représenter les tâches de calcul.
• Dans appelé  会话 (Session) contexte de contexte exécute () dans la.
• Utilisez tenseur représentation des données.
• En  变量 (Variable) maintenant l' état.
• Utilisation de l'alimentation et la récupération des opérations peut être assignée une (opération arbitraire) arbitraire ou pour obtenir des données de celui-ci.

vue d'ensemble

Tensorflow un système de programmation est utilisé pour représenter les tâches de calcul. Figure noeuds dans le graphe est appelé  op  (abréviation de l' opération). Op obtenir un 0 ou plus  Tensor, effectuer des calculs, produire 0 ou plus  Tensor. Chaque Tensor est un type de tableau à plusieurs dimensions. Par exemple, vous pouvez définir une image de groupe est représenté sous la forme d' un tableau à quatre dimensions de nombres à virgule flottante, ces quatre dimensions sont  [batch, height, width, channels].

A la figure tensorflow décrit le processus de calcul afin de calculer, la figure doit  会话 être démarré en.  会话 La distribution des op FIG tel qu'un processeur ou un GPU  设备 sur, tout en fournissant un procédé pour effectuer des op. Ces procédés effectués, la résultante Retour en tenseur de langage Python, le tenseur est retourné.  numpy ndarray  objets, en C et la langue C, le tenseur est retourné par tensorflow::Tensor exemple.

Figure computing

programmes tensorflow sont généralement organisés en une phase et une phase d'exécution de la construction .

• Pendant la phase de construction, étape op est décrit comme une figure.
• Dans la phase d'exécution, en utilisant l'exécution de la session figure op.

Par exemple, créez généralement un graphique dans la phase de construction pour représenter et former le réseau de neurones, puis exécuter à plusieurs reprises la formation figure op pendant la phase de mise en œuvre.

Tensorflow soutient C, C ++, langage de programmation Python. À l'heure actuelle, la bibliothèque Python tensorflow plus facile à utiliser, il offre un certain nombre de fonctions auxiliaires pour simplifier le travail de construction de diagrammes, ces fonctions ne sont pas pris en charge par les bibliothèques C et C ++.

session de la bibliothèque trilingues (bibliothèques de session) sont les mêmes.

schéma de construction

La figure première étape dans la construction est de créer une source op (op Source). Aucune source op d'entrée, par exemple  la 常量 (Constant)source est transmise à la sortie d'op op faire d' autres opérations.

bibliothèque python, constructeur op est configuré pour renvoyer une valeur représentant la sortie de op, la valeur de retour peut être transmis à d'autres op configuré en tant qu'entrée.

bibliothèque tensorflow Python a un graphique par défaut (par défaut graphique) , constructeur OP peut augmenter ses nœuds. Les graphiques par défaut pour de nombreux programmes ont été suffisants. Lire la  classe graphique  documentation pour apprendre comment gérer plusieurs carte.

import tensorflow as tf

# 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点
# 加到默认图中.
#
# 构造器的返回值代表该常量 op 的返回值.
matrix1 = tf.constant([[3., 3.]])

# 创建另外一个常量 op, 产生一个 2x1 矩阵.
matrix2 = tf.constant([[2.],[2.]])

# 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
# 返回值 'product' 代表矩阵乘法的结果.
product = tf.matmul(matrix1, matrix2)

La carte par défaut a maintenant trois noeuds, deux  constant() op et un matmul() op. Pour être vraiment le résultat de la multiplication de la matrice, et obtenir la multiplication de la matrice, vous devez commencer la session dans cette figure.

Dans une session figure.

Après l'achèvement de la phase de construction, pour commencer à dessiner. La première étape consiste à créer un graphique de démarrage  Session objets, si elle est créée sans aucun paramètre, la session démarre la carte du constructeur par défaut.

Pour l' API de session complète, s'il vous plaît lire la classe Session .

# 启动默认图.
sess = tf.Session()

# 调用 sess 的 'run()' 方法来执行矩阵乘法 op, 传入 'product' 作为该方法的参数. 
# 上面提到, 'product' 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回
# 矩阵乘法 op 的输出.
#
# 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.
# 
# 函数调用 'run(product)' 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.
#
# 返回值 'result' 是一个 numpy `ndarray` 对象.
result = sess.run(product)
print result
# ==> [[ 12.]]

# 任务完成, 关闭会话.
sess.close()

Session besoin d'objets pour être fermé après utilisation pour libérer les ressources. Outre un appel explicite à proximité, peut être utilisé « avec » bloc de code pour arrêter automatiquement l'opération.

with tf.Session() as sess:
  result = sess.run([product])
  print result

Dans la réalisation, tensorflow convertie en définition graphique distribuée opération d'exécution, pour tirer pleinement parti des ressources informatiques disponibles (par exemple, CPU ou GPU). En général, vous n'avez pas besoin de spécifier explicitement CPU ou GPU, tensorflow automatiquement détecté. Si détecté GPU, tensorflow utilisera le premier GPU pour trouver autant que possible d'effectuer l'opération.

Si plus d'un GPU est disponible sur la machine, d' autres GPU , sauf le premier défaut ne participe pas dans le calcul. Pour utiliser ces GPU tensorflow, vous devez exécuter op pour les explicitement attribués.  with...Device Déclaration est utilisé pour assign CPU spécifique ou GPU faire:

with tf.Session() as sess:
  with tf.device("/gpu:1"):
    matrix1 = tf.constant([[3., 3.]])
    matrix2 = tf.constant([[2.],[2.]])
    product = tf.matmul(matrix1, matrix2)
    ...

chaîne d'identification de l'appareil est dispositifs actuellement pris en charge comprennent:

• "/cpu:0": Machine CPU.
• "/gpu:0": Le premier GPU de la machine, le cas échéant.
• "/gpu:1": Deuxième GPU de la machine, et ainsi de suite.

Lire en utilisant le GPU section pour plus d' informations tensorflow utilisation GPU.

utilisation interactive

exemple de document Python à l' aide d' une session  Session pour commencer la carte, et invoque  Session.run() une méthode pour effectuer des opérations.

Pour faciliter l'utilisation, comme un  IPython  comme Python environnement interactif, il peut être utilisé  au InteractiveSession lieu de la  Session catégorie, l'utilisation  Tensor.eval() et  Operation.run() place des méthodes  Session.run(). Cela permet d' éviter l'utilisation d'une variable pour tenir la session.

# 进入一个交互式 TensorFlow 会话.
import tensorflow as tf
sess = tf.InteractiveSession()

x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])

# 使用初始化器 initializer op 的 run() 方法初始化 'x' 
x.initializer.run()

# 增加一个减法 subtract op, 从 'x' 减去 'a'. 运行减法 op, 输出结果 
sub = tf.subtract(x, a)
print sub.eval()
# ==> [-2. -1.]

Tensor

programme tenseur tensorflow utilisations structure de données pour représenter toutes les données pour calculer les chiffres, toutes les opérations de transfert de données entre le tenseur. Vous pouvez tensorflow tenseur considéré comme une matrice de dimension n ou d'une liste d'un rang tenseur contient un type statique, et une forme. tensorflow veulent apprendre comment faire face à ces concepts, voir  Rang, forme et type .

variable

Les variables  pour les détails. Plus de variables pour maintenir des informations d'état dans le processus de dessin exécuté. L'exemple suivant montre comment utiliser les variables pour obtenir un compteur simple. Voir la  variable  section pour plus de détails.

# 创建一个变量, 初始化为标量 0.
state = tf.Variable(0, name="counter")

# 创建一个 op, 其作用是使 state 增加 1

one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)

# 启动图后, 变量必须先经过`初始化` (init) op 初始化,
# 首先必须增加一个`初始化` op 到图中.
init_op = tf.initialize_all_variables()

# 启动图, 运行 op
with tf.Session() as sess:
  # 运行 'init' op
  sess.run(init_op)
  # 打印 'state' 的初始值
  print sess.run(state)
  # 运行 op, 更新 'state', 并打印 'state'
  for _ in range(3):
    sess.run(update)
    print sess.run(state)

# 输出:

# 0
# 1
# 2
# 3

Code  assign() opération fait partie de la carte d'expression représentée comme  add() opérant même. Alors , appelez  run() avant d' exécuter l'expression, il ne fonctionne pas réellement l'affectation.

Est-ce que généralement un paramètre de modèle statistique est représenté comme un ensemble de variables. Par exemple, vous pouvez droite un poids de réseau de neurones dans un tenseur Dans le processus de formation, par plusieurs reprises en cours d'exécution plan de formation, mettre à jour ce tenseur comme un stockage variable.

apporter

Pour récupérer le contenu de l'opération de sortie, vous pouvez utiliser  Session un objet  run() lorsque vous appelez exécute, en passant une partie du tenseur, tenseur vous aidera à récupérer les résultats. Dans l'exemple précédent, nous récupérons un seul nœud  state, mais vous pouvez aussi récupérer tenseur multiples:

input1 = tf.constant(3.0)
input2 = tf.constant(2.0)
input3 = tf.constant(5.0)
intermed = tf.add(input2, input3)
mul = tf.mul(input1, intermed)

with tf.Session():
  result = sess.run([mul, intermed])
  print result

# 输出:
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]

Tensor besoin d'obtenir plus de valeur et se réunir en un seul passage dans l'op (plutôt que un par un tenseur d'acquisition).

Alimentation

Les exemples ci-dessus est introduit dans le calcul de la figure du tenseur, sous la forme de constantes stockées ou des variables. Tensorflow fournit également un mécanisme d'alimentation, qui peut être l'un quelconque des chiffres de remplacement temporaire suivants dans tenseur peut soumettre un patch pour aspirer toute opération directement dans un tenseur.

alimentation en utilisant une valeur de tenseur de la sortie d'une opération de remplacement temporaire. Vous pouvez fournir des données d'alimentation en tant que  run() paramètre de l'appel. nourrir uniquement dans l'appel de ses méthodes se termine méthode efficace, l' alimentation disparaîtra. Le cas le plus d'usage courant est un peu spécial opération est désignée comme « feed » opération, la méthode de marquage consiste à utiliser tf.placeholder () crée un espace réservé pour ces opérations.

input1 = tf.placeholder(tf.types.float32)
input2 = tf.placeholder(tf.types.float32)
output = tf.mul(input1, input2)

with tf.Session() as sess:
  print sess.run([output], feed_dict={input1:[7.], input2:[2.]})

# 输出:
# [array([ 14.], dtype=float32)]

pour un exemple à plus grande échelle des aliments . Si aucune alimentation adéquate,  l' placeholder() opération produira une erreur.  MNIST cours d'alimentation entièrement connecté  ( code source ) donne un exemple d'utilisation d' une alimentation plus grande.