Résumé des différentes opérations dans Tensorflow

introduction

Puisque Tensorflow gère des quantités appelées tenseurs, les méthodes Numpy, etc. ne peuvent pas être utilisées. Par conséquent, il est nécessaire d'utiliser la méthode fournie par Tensorflow.

Voici un résumé des quatre règles de base et des opérations matricielles. En particulier, il est comparé à diverses opérations définies en Python (+, -,/,//,% ).

Mise en garde

Environnement d'exploitation

Tensorflow 1.4.1

Quatre règles

Ajout tf.add

import tensorflow as tf

const1 = tf.constant(2)
const2 = tf.constant(3)
add_op = tf.add(const1, const2) # 2 + 3
with tf.Session() as sess:
    result = sess.run(add_op)
    print(result)
5

Correspond à l'ajout de Python 3 +.

Soustraire tf.subtract

import tensorflow as tf

const1 = tf.constant(2)
const2 = tf.constant(3)
subt_op = tf.subtract(const1, const2) # 2 - 3

with tf.Session() as sess:
    result = sess.run(subt_op)
    print(result)
-1

C'est la même chose que «-».

Division --Python2 ver -- tf.div


import tensorflow as tf

const1 = tf.constant(2)
const2 = tf.constant(3)
div2_op = tf.div(const1, const2) # 2 / 3 in Python2

with tf.Session() as sess:
    result = sess.run(div_op)
    print(result)
0

Correspond à la division / dans Python2. Le tf.divide suivant est recommandé dans Official.

Divide --Python3 ver -- tf.divide

import tensorflow as tf

const1 = tf.constant(2)
const2 = tf.constant(3)
div_op = tf.divide(const1, const2) # 2 / 3 in Python3

with tf.Session() as sess:
    result = sess.run(div_op)
    print(result)
0.666666666667

Équivalent à / en Python 3

Division entière tf.floordiv

import tensorflow as tf

const1 = tf.constant(2)
const2 = tf.constant(3)
fdiv_op = tf.floordiv(const1, const2) # 2 // 3

with tf.Session() as sess:
    result = sess.run(fdiv_op)
    print(result)
0

Correspond au «//» de Python3. (Tronquer après la virgule décimale)

Opération résiduelle tf.mod

import tensorflow as tf

const1 = tf.constant(2)
const2 = tf.constant(4)
mod_op = tf.mod(const1, const2) # 2 % 3 

with tf.Session() as sess:
    result = sess.run(mod_op)
    print(result)
2

Correspond au% de Python3.

Produit scalaire tf.scalar_mul

import tensorflow as tf

const1 = tf.constant(2) #Déclarer une constante(La valeur est 2)
const2 = tf.constant(3)
smul_op = tf.scalar_mul(const1, const2) # 2 * 3 

with tf.Session() as sess:
    result = sess.run(smul_op)
    print(result)
6

Le produit des constantes.

Produit extérieur vectoriel tf.cross

import tensorflow as tf

const1 = tf.constant([1, 2, 3])
const2 = tf.constant([4, 5, 6])
cross_op = tf.cross(const1, const2) # [1, 2, 3] x [4, 5, 6]

with tf.Session() as sess:
    result = sess.run(cross_op)
    print(result)
[-3  6 -3]

La définition du produit vectoriel (produit externe) sortira si vous google, donc je vais l'omettre ici.

Fonctionnement de la matrice

Matrice avec les 1 éléments tf.ones


import numpy as np
import tensorflow as tf

t = tf.ones([3, 2])

with tf.Session() as sess:
    print("tf.ones([3, 2]) = %s" % sess.run(t))    
tf.ones([3, 2]) = [[ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]]

tf.ones ([3,2]): Crée une matrice 3x2 avec tous les éléments 1

Matrice avec tous les 0 éléments tf.zeros


import numpy as np
import tensorflow as tf

t = tf.zeros([5])

with tf.Session() as sess:
    print("tf.zeros([5]) = %s" % sess.run(t))
tf.zeros([5]) = [ 0.  0.  0.  0.  0.]

tf.zeros ([5]): Crée une matrice 1x5 (vecteur avec 5 éléments) avec tous les éléments 0

Matrice avec des éléments aléatoires tf.random_uniform


import numpy as np
import tensorflow as tf

t = tf.random_uniform([1, 3])

with tf.Session() as sess:
    print("tf.random_uniform([1, 3]) = %s" % sess.run(t))
tf.random_uniform([1, 3]) = [[ 0.16699052  0.04628575  0.38685966]]

tf.random_uniform ([1,3]): Crée une matrice 1x3 (vecteur avec 3 éléments) avec des nombres générés aléatoirement de 0 à 1.

Affiche le nombre d'éléments dans la section spécifiée sous forme de liste tf.linspace


import numpy as np
import tensorflow as tf

t = tf.linspace(1.0, 7.0, 4)

with tf.Session() as sess:
    print("tf.linspace(1.0, 7.0, 4) = %s" % sess.run(t))
tf.linspace(1.0, 7.0, 4) = [ 1.  3.  5.  7.]

tf.linspace (1.0,7.0,4): Divisez 1.0 à 4.0 en quatre, générez des nombres dans l'ordre croissant et sortez sous forme de liste (vecteur).

Produit matriciel

import tensorflow as tf

const1 = tf.random_uniform([3,2])
const2 = tf.random_uniform([2,3])
mul_op = tf.matmul(const1, const2)

with tf.Session() as sess:
    print("const1: %s" % sess.run(const1))
    print("const2: %s" % sess.run(const2))
    print("tf.matmul(const1, const2) = %s" % sess.run(mul_op))
const1: [[ 0.22310185  0.76020801]
 [ 0.04765964  0.81115341]
 [ 0.15238702  0.24294829]]
const2: [[ 0.89871132  0.3882308   0.54530931]
 [ 0.60662949  0.27270687  0.20178115]]
tf.matmul(const1, const2) = [[ 0.55778277  0.5268842   0.72335124]
 [ 0.42495638  0.3350077   0.66840851]
 [ 0.45947441  0.2069075   0.99706292]]

Soit la matrice à considérer comme $ A_ {ij} $, $ B_ {ij} $. Soit A une matrice NxM et B une matrice KxL. A ce moment, pour exécuter le produit,

--M = K pour que tf.matmul (A, B) soit possible --L = N pour que tf.matmul (B, A) soit possible

Doit tenir. (Autrement dit, le nombre d'éléments dans la colonne de la première matrice et le nombre d'éléments dans la ligne de la deuxième matrice doivent correspondre.) Notez que si cela est négligé, des erreurs se produiront fréquemment. En particulier, vous pouvez utiliser tf.transpose pour transloquer la matrice, ou définir la translocation sur True avec l'option de tf.matmul. Veuillez vous référer au Document officiel pour cela.

Convertir la liste Numpy en tenseur tf.convert_to_tensor


import numpy as np
import tensorflow as tf

t = tf.convert_to_tensor(np.linspace(1, 7, 4))

with tf.Session() as sess:
    print("tf.convert_to_tensor( np.linspace(1, 7, 4) ) = %s" % sess.run(t))
tf.convert_to_tensor( np.linspace(1, 7, 4) ) = [ 1.  3.  5.  7.]

tf.convert_to_tensor: Convertit la liste Numpy générée en un tenseur.

Autre

Attribution de valeur


import tensorflow as tf

# see https://www.tensorflow.org/api_guides/python/state_ops
print("\n variables\n=====================")

w = tf.Variable(tf.zeros([3, 2])) #variable(queue)Déclaration de w. 初期値はゼロqueue

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    
    print("w = %s" % sess.run(w))
    sess.run(tf.assign(w, tf.ones([3, 2])))

    wn = sess.run(w)
    print("w = %s" % wn)
variable
=====================
w = [[ 0.  0.]
 [ 0.  0.]
 [ 0.  0.]]
w = [[ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]]

--tf.assign (w, tf.ones ([3, 2]): Assignez la variable w àtf.ones ([3,2])(matrice 3x2 avec les 1 éléments.

Cette opération n'est pas limitée aux matrices. (Également possible pour les variables scalaires)

Opération symbolique


import tensorflow as tf

print("\n variables symboliques\n=====================")

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
a_times_b1 = tf.multiply(a, b) #  multiplication of a and b
a_times_b2 = a * b

with tf.Session() as sess:
    # where "name" is the python symbol
    print("%f should equal 2.0" % sess.run(a_times_b1, feed_dict={a: 1, b: 2}))
    print("%f should equal 9.0" % sess.run(a_times_b1, feed_dict={a: 3, b: 3}))
    print("%f should equal 9.0" % sess.run(a_times_b2, feed_dict={a: 3, b: 3}))
Variable symbolique
=====================
2.000000 should equal 2.0
9.000000 should equal 9.0
9.000000 should equal 9.0

Au lieu de fixer une seule valeur, remplacez plusieurs valeurs plus tard en utilisant feed_dict.

Référence: Concept Tensorflow appris de la fabrication de pommes de terre

Diverses fonctions


import tensorflow as tf

print("\n fonction mathématique\n=====================")

x = tf.linspace(0., 4., 5)

with tf.Session() as sess:
    print("x = %s" % sess.run(x))
    print("(x+1)**2 - 2) = %s" % sess.run( (x+1)**2 - 2))
    print("sin(x) = %s" % sess.run( tf.sin(x) ))
    print("sum(x) = %s" % sess.run( tf.reduce_sum(x) ))
Fonction mathématique
=====================
x = [ 0.  1.  2.  3.  4.]
(x+1)**2 - 2) = [ -1.   2.   7.  14.  23.]
sin(x) = [ 0.          0.84147096  0.90929741  0.14112    -0.7568025 ]
sum(x) = 10.0

Voir la documentation officielle pour plus de détails

Prendre une liste comme variable

Ces fonctions peuvent être répertoriées sous forme de variables:

print("\Argument de vecteur à n(séquence,liste)Peut être pris.(Numpy-like)\n=====================")
tf.sin(3.)
tf.sin([1., 2., 3.])
tf.sin(tf.linspace(0., 10., 20))
tf.sin(np.linspace(0, 10, 20))  # equivalent
tf.sin(tf.ones(shape=(2, 3, 4)))  # 2x3x4 tensor

# Operators (+, -, /, *)
a = tf.zeros(shape=(2, 3))
b = tf.ones(shape=(2, 3))
c = tf.ones(shape=(3, 2))

with tf.Session() as sess:
    print('a + b: %s'% sess.run(a + b))  # same as tf.add(a, b)
    print('a - b: %s' % sess.run(a - b))  # same as tf.subtract(a, b)
    print('a * b: %s' % sess.run(a * b))  # same as tf.mul(a, b)
    print('a / b: %s' % sess.run(a / b))  # same as tf.division(a, b)
# a + c  # doesn't work; tensors need to be of same shape
Le vecteur comme argument(séquence,liste)Peut être pris.(Numpy-like)
=====================
a + b: [[ 1.  1.  1.]
 [ 1.  1.  1.]]
a - b: [[-1. -1. -1.]
 [-1. -1. -1.]]
a * b: [[ 0.  0.  0.]
 [ 0.  0.  0.]]
a / b: [[ 0.  0.  0.]
 [ 0.  0.  0.]]

À propos de l'exécution désireuse

Donnons un exemple d'exécution Eager comme exemple de certains des contenus traités ci-dessus.

Exemple 1: ajout

Quand je réécris le code d'addition,


import tensorflow as tf
import tensorflow.contrib.eager as tfe

tfe.enable_eager_execution()

const1 = tf.constant(2)
const2 = tf.constant(3)
add_op = tf.add(const1, const2) # 2 + 3
print(add_op)
# tf.Tensor(5, shape=(), dtype=int32)

Ce sera. Tout d'abord, assurez-vous d'écrire tfe.enable_eager_execution () au début du programme. (Lors de l'exécution sur Jupyter, s'il reste de la mémoire dans le noyau

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-2-a35e1dbe978d> in <module>()
      2 import tensorflow.contrib.eager as tfe
      3 
----> 4 tfe.enable_eager_execution()
      5 
      6 const1 = tf.constant(2)

/usr/local/lib/python3.6/site-packages/tensorflow/python/framework/ops.py in enable_eager_execution(config, device_policy)
   4892   else:
   4893     raise ValueError(
-> 4894         "tfe.enable_eager_execution has to be called at program startup.")
   4895 
   4896 

ValueError: tfe.enable_eager_execution has to be called at program startup.

(Exemple), il est donc essentiel de redémarrer le noyau. À propos, le type de résultat de sortie est

type(add_op)
# EagerTensor

Il est devenu. Si vous essayez d'ajouter «3» à cette valeur,


add_op + 3
# <tf.Tensor: id=5, shape=(), dtype=int32, numpy=8>

Et il est calculé correctement comme la valeur de numpy. Utilisez la méthode numpy () pour récupérer cette valeur. En d'autres termes

add_op2 = add_op + 3
print(add_op2.numpy())
# 8

Vous pouvez récupérer la valeur par. Le type de cette valeur est

type(add_op2)
# numpy.int32

Comme c'est le cas, un calcul normal à quatre règles est possible.

Exemple 2: Attribution de valeur

De la même manière, si vous réécrivez le code d'attribution de valeur


import tensorflow as tf
import tensorflow.contrib.eager as tfe

tfe.enable_eager_execution()

# see https://www.tensorflow.org/api_guides/python/state_ops
print("\n variables\n=====================")

w = tfe.Variable(tf.zeros([3, 2])) #variable(queue)Déclaration de w. 初期値はゼロqueue

tf.global_variables_initializer()

print("w = %s" % w)
tf.assign(w, tf.ones([3, 2]))

wn = w
print("w = %s" % wn)

#variable
# =====================
# w = <tf.Variable 'Variable:0' shape=(3, 2) dtype=float32, numpy=
# array([[0., 0.],
#        [0., 0.],
#        [0., 0.]], dtype=float32)>
# w = <tf.Variable 'Variable:0' shape=(3, 2) dtype=float32, numpy=
# array([[1., 1.],
#        [1., 1.],
#        [1., 1.]], dtype=float32)>

Ce sera. Notez que nous utilisons tfe.Variable lors de la déclaration des variables ici. (En passant, tf.Placeholder ne peut pas être utilisé lors de l'utilisation de l'exécution hâtive.) À part cela, il peut être réécrit de la même manière en supprimant toutes les instructions with. Comme avant pour récupérer la valeur

print(w.numpy()

# array([[1., 1.],
#       [1., 1.],
#       [1., 1.]], dtype=float32)

Vous pouvez récupérer la valeur en faisant (même chose pour wn). Comme nous l'avons fait dans l'exemple 1 ci-dessus, nous pouvons utiliser la méthode numpy () pour le récupérer en tant que tableau Numpy et appliquer les quatre règles de Numpy.

Recommended Posts

Résumé des différentes opérations dans Tensorflow
Résumé de diverses instructions for en Python
Résumé de Tensorflow / Keras
Résumé des opérations sur les chaînes
Résumé des opérations Excel utilisant OpenPyXL en Python
résumé lié à l'opération de fichier python
Résumé des opérations de liste Python3
Comprendre les images de diverses opérations matricielles utilisées dans Keras (Tensorflow) avec des exemples
Résumé des méthodes fréquemment utilisées chez les pandas
Résumé des commandes fréquemment utilisées dans matplotlib
Résumé des pierres d'achoppement lors de l'installation de CaboCha
Résumé des modules et des classes dans Python-TensorFlow2-
Résumé des méthodes intégrées, etc. de la liste Python
Résumé des opérations souvent effectuées avec asyncpg
Résumé des processus souvent effectués par Pandas 1 (CSV, opérations liées aux fichiers Excel)
Résumé des outils et bibliothèques OSS créés en 2016
Résumé de la façon d'importer des fichiers dans Python 3
Résumé de ce qui a été utilisé dans 100 coups de Pandas (# 1 ~ # 32)
Résumé des outils utilisés dans la ligne de commande vol.8
Résumé des outils utilisés dans la ligne de commande vol.5
Résumé des fonctions d'évaluation utilisées dans l'apprentissage automatique
[Python] Résumé des opérations sur les fichiers S3 avec boto3
Le format de point de contrôle de tf.train.Saver a changé dans TensorFlow v0.12
Résumé des méthodes de gestion des erreurs lors de l'installation de TensorFlow (2)
Opérations sur les fichiers en Python
Représentation numérique des jours dans différentes langues
Résumé des outils nécessaires pour analyser les données en Python
Diverses opérations de chaîne de caractères
Résumé des commandes Linux (UNIX) fournies avec Progate
Résumé de l'utilisation de pyenv
L'ancien openssl pose des problèmes dans diverses parties de python
Manipulation de fichiers avec Python
HMAC en plusieurs langues
Procédure d'exécution de TensorFlow dans le traitement par lots de Spacon ITO
Résumé de séparation de l'environnement de développement par chroot de divers Linux
Résumé des arguments Python
Résumé de la méthode d'essai
Récapitulatif du traitement de la date en Python (datetime et dateutil)
Divers traitements de Python
Résumé des modèles de prototypes d'introduction aux modèles de conception appris en langage Java
Résumé de base des opérations de données dans Python Pandas - Deuxième moitié: agrégation de données
Résumé des modèles singleton de l'introduction aux modèles de conception appris en langage Java
[Pour les débutants] Résumé de l'entrée standard en Python (avec explication)
Résumé des points d'achoppement à Django pour la première fois
J'ai mesuré différentes méthodes de communication inter-processus en multitraitement de python3
Chaos retour de la cartographie logistique par Petit RNN dans Tensorflow
Résumé de l'écriture des fichiers .proto utilisés dans gRPC
L'histoire de la rétrogradation de la version de tensorflow dans la démo de Mask R-CNN.
Quatre règles de python
Clipping et normalisation dans TensorFlow
Nouveautés de Python 3.10 (Résumé)
2017.3.6 ~ 3.12 Résumé de ce que nous avons fait
Expérience de réglage des données Tensorflow
Partiel en cas de problème
Diverses opérations de chaîne avec Python intégré
Différentes façons d'importer Mnist
Liste des nœuds dans les diagrammes