Da Tensorflow eine als Tensor bezeichnete Größe verarbeitet, können Numpys Methoden usw. nicht verwendet werden. Daher muss die von Tensorflow bereitgestellte Methode verwendet werden.
Hier ist eine Zusammenfassung der vier grundlegenden Regeln und Matrixoperationen. Insbesondere wird es mit verschiedenen in Python definierten Operationen verglichen (+, -,/,//,% ).
Hinweis
Sesssion.run () ist Sie können jetzt ** Berechnungen durchführen, ohne dies tun zu müssen. Bitte beachten Sie den Hinweis dazu am Ende des Artikels.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
Entspricht der Python 3-Addition +.
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
Dies ist das gleiche wie -.
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
Entspricht der Division / in Python2. Das folgende "tf.divide" wird in Official empfohlen.
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
Entspricht / in 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
Entspricht dem // von Python3. (Nach dem Dezimalpunkt abschneiden)
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
Entspricht dem% von Python3.
tf.scalar_mulimport tensorflow as tf
const1 = tf.constant(2) #Deklarieren Sie eine Konstante(Wert ist 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
Das Produkt von Konstanten.
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]
Die Definition des Vektorprodukts (äußeres Produkt) wird bei Google veröffentlicht, daher werde ich sie hier weglassen.
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]): Erstellen Sie eine 3x2-Matrix mit allen Elementen 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]): Erstellen Sie eine 1x5-Matrix mit allen Elementen 0 (Vektor mit 5 Elementen)
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]): Erstellen Sie eine 1x3-Matrix (Vektor mit 3 Elementen) mit zufällig generierten Zahlen von 0 bis 1.
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): Teilen Sie 1.0 bis 4.0 in vier, generieren Sie Zahlen in aufsteigender Reihenfolge und geben Sie sie als Liste (Vektor) aus.
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]]
Die zu betrachtende Matrix sei $ A_ {ij} $, $ B_ {ij} $. Sei A eine NxM-Matrix und B eine KxL-Matrix. Zu diesem Zeitpunkt, um das Produkt durchzuführen,
Muss halten. (Das heißt, die Anzahl der Elemente in der Spalte der ersten Matrix und die Anzahl der Elemente in der Zeile der zweiten Matrix müssen übereinstimmen.) Beachten Sie, dass Fehler häufig auftreten, wenn dies vernachlässigt wird. Insbesondere können Sie "tf.transpose" verwenden, um die Matrix zu translozieren, oder die Translokation mit der Option "tf.matmul" auf "True" setzen. Weitere Informationen hierzu finden Sie in Offizielles Dokument.
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: Konvertiert die generierte Numpy-Liste in einen Tensor.
import tensorflow as tf
# see https://www.tensorflow.org/api_guides/python/state_ops
print("\n Variablen\n=====================")
w = tf.Variable(tf.zeros([3, 2])) #Variable(Warteschlange)Erklärung von w. 初期値はゼロWarteschlange
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]): Weisen Sie die Variable w tf.ones ([3,2]) `(3x2-Matrix mit allen 1 Elementen zu.
Diese Operation ist nicht auf Matrizen beschränkt. (Auch für skalare Variablen möglich)
import tensorflow as tf
print("\n symbolische Variablen\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}))
Symbolische Variable
=====================
2.000000 should equal 2.0
9.000000 should equal 9.0
9.000000 should equal 9.0
Anstatt nur einen Wert festzulegen, ersetzen Sie später mehrere Werte mit "feed_dict".
Referenz: Tensorflow-Konzept aus der Kartoffelherstellung
import tensorflow as tf
print("\n mathematische Funktion\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) ))
Mathematische Funktion
=====================
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
Einzelheiten finden Sie in der offiziellen Dokumentation
Diese Funktionen können als Variablen aufgelistet werden:
print("\Vektor zu n Argument(Reihenfolge,aufführen)Kann genommen werden.(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
Vektor als Argument(Reihenfolge,aufführen)Kann genommen werden.(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.]]
Lassen Sie uns ein Beispiel für die Eager-Ausführung als Beispiel für einige der oben behandelten Inhalte geben.
Wenn ich den Additionscode umschreibe,
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)
Es wird sein. Stellen Sie zunächst sicher, dass Sie zu Beginn des Programms "tfe.enable_eager_execution ()" schreiben. (Wenn auf Jupyter ausgeführt wird, ist noch Speicher im Kernel vorhanden
---------------------------------------------------------------------------
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.
(Beispiel), daher ist ein Neustart des Kernels unerlässlich. Die Art des Ausgabeergebnisses ist übrigens
type(add_op)
# EagerTensor
Es ist geworden. Wenn Sie versuchen, diesem Wert "3" hinzuzufügen,
add_op + 3
# <tf.Tensor: id=5, shape=(), dtype=int32, numpy=8>
Und es wird korrekt als Wert von numpy berechnet. Verwenden Sie die Methode numpy (), um diesen Wert abzurufen. Mit anderen Worten
add_op2 = add_op + 3
print(add_op2.numpy())
# 8
Sie können den Wert von abrufen. Der Typ dieses Wertes ist
type(add_op2)
# numpy.int32
Da dies der Fall ist, ist eine normale Berechnung mit vier Regeln möglich.
Auf die gleiche Weise, wenn Sie den Wertzuweisungscode neu schreiben
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 Variablen\n=====================")
w = tfe.Variable(tf.zeros([3, 2])) #Variable(Warteschlange)Erklärung von w. 初期値はゼロWarteschlange
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)>
Es wird sein. Beachten Sie, dass wir bei der Deklaration von Variablen hier tfe.Variable verwenden. (Abgesehen davon kann tf.Placeholder nicht verwendet werden, wenn eine eifrige Ausführung verwendet wird.) Ansonsten kann es auf die gleiche Weise umgeschrieben werden, indem alle "with" -Anweisungen entfernt werden. Wie zuvor, um den Wert abzurufen
print(w.numpy()
# array([[1., 1.],
# [1., 1.],
# [1., 1.]], dtype=float32)
Sie können den Wert abrufen, indem Sie (sowie wn) ausführen. Wie in Beispiel 1 oben können wir die Methode numpy () verwenden, um sie als Numpy-Array abzurufen und die vier Regeln von Numpy auszuführen.