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
Sesssion.run () est Vous pouvez maintenant effectuer ** des calculs sans avoir à le faire. Veuillez vous référer à la note à ce sujet ajoutée à la fin de l'article.Tensorflow 1.4.1
tf.addimport 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 +.
tf.subtractimport 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 «-».
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.
tf.divideimport 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
tf.floordivimport 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)
tf.modimport 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.
tf.scalar_mulimport 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.
tf.crossimport 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.
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
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
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.
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).
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.
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.
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)
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
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
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.]]
Donnons un exemple d'exécution Eager comme exemple de certains des contenus traités ci-dessus.
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.
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.