Ich verstehe Matrixberechnung und Statistik nicht gut und habe Numpy nie verwendet. Daher kann ich die TensorFlow-API nicht verstehen. ... Also ein Memo, um zu versuchen, die APIs, die Sie nicht verstehen, einzeln auszuführen und zu sehen, was sie tun. Ich habe kein Fachwissen, daher würde ich gerne von Ihnen hören. Referenz: Offizielle API-Referenz
Versuchen Sie Folgendes einzeln im interaktiven Modus von Python.
>>> import tensorflow as tf
>>> sess = tf.Session()
>>> sess.run(<Auszuführende API>)
API tf.size(input, name=None)
>>> sess.run(tf.size([0,1,2]))
3
>>> sess.run(tf.size([[0,1,2]]))
3
>>> sess.run(tf.size([[0,1,2],[4,5,6]]))
6
Es scheint die Anzahl der Elemente zurückzugeben.
tf.expand_dims(input, dim, name=None)
>>> sess.run(tf.expand_dims([0,1,2,3], 1))
array([[0],
[1],
[2],
[3]], dtype=int32)
>>> sess.run(tf.expand_dims([[0,1,2,3],[4,5,6,7]], 1))
array([[[0, 1, 2, 3]],
[[4, 5, 6, 7]]], dtype=int32)
>>> sess.run(tf.expand_dims([[0,1,2,3],[4,5,6,7]], 2))
array([[[0],
[1],
[2],
[3]],
[[4],
[5],
[6],
[7]]], dtype=int32)
Es scheint, dass die durch dim angegebene Dimension (Rang) zur Eingabe hinzugefügt wird. Wenn der Rang der Eingabe 1 ist und 1 für dim angegeben ist, ist der Rückgabewert Rang 2.
tf.range(start, limit=None, delta=1, name='range')
>>> sess.run(tf.range(5))
array([0, 1, 2, 3, 4], dtype=int32)
>>> sess.run(tf.range(1,5))
array([1, 2, 3, 4], dtype=int32)
Gibt das angegebene eindimensionale Array zurück (ausschließlich Tensor).
tf.concat(concat_dim, values, name='concat')
>>> sess.run(tf.concat(0, [[1,2,3], [10,20,30]]))
array([ 1, 2, 3, 10, 20, 30], dtype=int32)
>>> sess.run(tf.concat(1, [[[1,2,3],[4,5,6]], [[10,20,30],[40,50,60]]]))
array([[ 1, 2, 3, 10, 20, 30],
[ 4, 5, 6, 40, 50, 60]], dtype=int32)
Es scheint Tensoren zu verbinden, die in Werten angegeben sind. Die Tensoren, die die Verbindungsquelle darstellen, werden in Form von [\ <Tensor1 >, \ <Tensor2 >] angegeben.
tf.pack(values, name='pack')
>>> sess.run(tf.pack([1,2]))
array([1, 2], dtype=int32)
>>> sess.run(tf.pack([1,5]))
array([1, 5], dtype=int32)
>>> sess.run(tf.pack([1,5,10]))
array([ 1, 5, 10], dtype=int32)
Ich bin nicht sicher, aber der gleiche Tensor, der in Werten angegeben ist, wird zurückgegeben. Offizielle Referenz
tf.pack([x, y, z]) = np.asarray([x, y, z])
Es steht geschrieben, dass np.asarray () eine Funktion zu sein scheint, die einen Verweis auf das als Argument angegebene Array erstellt ...
>>> a = [0,1,2]
>>> b = sess.run(tf.pack(a))
>>> b
array([0, 1, 2], dtype=int32)
>>> b[0] = 5
>>> b
array([5, 1, 2], dtype=int32)
>>> a
[0, 1, 2]
Es scheint keine Referenz zu sein ...? ??
tf.sparse_to_dense(sparse_indices, output_shape, sparse_values, default_value=0, validate_indices=True, name=None)
>>> sess.run(tf.sparse_to_dense([0,1],[5], 1.0, 0.0))
array([ 1., 1., 0., 0., 0.], dtype=float32)
>>> sess.run(tf.sparse_to_dense([0,1],[3], 1.0, 0.0))
array([ 1., 1., 0.], dtype=float32)
>>> sess.run(tf.sparse_to_dense([0,2],[5], 1.0, 0.0))
array([ 1., 0., 1., 0., 0.], dtype=float32)
>>> sess.run(tf.sparse_to_dense([0,2],[5], 2.0, 0.0))
array([ 2., 0., 2., 0., 0.], dtype=float32)
>>> sess.run(tf.sparse_to_dense([0,2],[5], 2.0, 5.0))
array([ 2., 5., 2., 5., 5.], dtype=float32)
Unten finden Sie eine Beschreibung der offiziellen Referenz.
# If sparse_indices is scalar dense[i] = (i == sparse_indices ? sparse_values : >default_value)
# If sparse_indices is a vector, then for each i dense[sparse_indices[i]] = sparse_values[i]
# If sparse_indices is an n by d matrix, then for each i in [0, n) dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
>>> sess.run(tf.sparse_to_dense([3],[5], 0.1, 0.0))
array([ 0. , 0. , 0. , 0.1, 0. ], dtype=float32)
>>> sess.run(tf.sparse_to_dense([0],[5], 0.1, 0.0))
array([ 0.1, 0. , 0. , 0. , 0. ], dtype=float32)
Wenn sparse_indices skalar ist (Rang 0), ist der Indexteil des durch sparse_indices angegebenen numerischen Werts der Wert von sparse_values.
>>> sess.run(tf.sparse_to_dense([0,1],[5], [0.1,0.2], 0.0))
array([ 0.1, 0.2, 0. , 0. , 0. ], dtype=float32)
>>> sess.run(tf.sparse_to_dense([1,2],[5], [0.1,0.2], 0.0))
array([ 0. , 0.1, 0.2, 0. , 0. ], dtype=float32)
>>> sess.run(tf.sparse_to_dense([0,2],[5], [0.1,0.2], 0.0))
array([ 0.1, 0. , 0.2, 0. , 0. ], dtype=float32)
>>> sess.run(tf.sparse_to_dense([0,2],[5],0.1, 0.0))
array([ 0.1, 0. , 0.1, 0. , 0. ], dtype=float32)
Wenn sparse_indices = [0,2] und sparse_values [0.1,0.2] ist, dann ist output [0] = 0.1 und output [2] = 0.2. Schwer zu verstehen. Wenn sparse_values skalare Werte sind, sind die eingegebenen Werte dieselben. Es scheint, dass ein Fehler auftritt, wenn sparse_indices nicht in aufsteigender Reihenfolge ([1,0] usw.) ist oder wenn der gleiche Wert enthalten ist ([1,1] usw.).
>>> sess.run(tf.sparse_to_dense([[0,1],[0,2]],[5,5],0.1, 0.0))
array([[ 0. , 0.1, 0.1, 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]], dtype=float32)
... Nun, das ist es. Ich verstehe die Bedeutung dieser API nicht. .. ..
tf.nn.softmax(logits, name=None)
>>> sess.run(tf.nn.softmax([[0.0,1.0]]))
array([[ 0.26894143, 0.7310586 ]], dtype=float32)
>>> sess.run(tf.nn.softmax([[0.0,1.0],[0.0,1.0]]))
array([[ 0.26894143, 0.7310586 ],
[ 0.26894143, 0.7310586 ]], dtype=float32)
>>> sess.run(tf.nn.softmax([[1.0],[1.0]]))
array([[ 1.],
[ 1.]], dtype=float32)
>>> sess.run(tf.nn.softmax([[0.0,1.0,2.0]]))
array([[ 0.09003057, 0.24472848, 0.66524094]], dtype=float32)
>>> sess.run(tf.nn.softmax([[0.0,1.0,2.0,10.0]]))
array([[ 4.53770481e-05, 1.23347607e-04, 3.35293560e-04,
9.99495983e-01]], dtype=float32)
>>> sess.run(tf.nn.softmax([[0.0,1.0,2.0],[1.0,1.0,1.0]]))
array([[ 0.09003057, 0.24472848, 0.66524094],
[ 0.33333334, 0.33333334, 0.33333334]], dtype=float32)
Logs müssen Rang 2 sein und schweben. Gibt etwas zurück, das sich in einer Dimension summiert, um alle zu erstellen.
tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)
>>> sess.run(tf.nn.softmax_cross_entropy_with_logits([[1.0]],[[1.0]]))
array([ 0.], dtype=float32)
>>> sess.run(tf.nn.softmax_cross_entropy_with_logits([[1.0,0.0]],[[1.0,1.0]]))
array([ 1.62652326], dtype=float32)
>>> sess.run(tf.nn.softmax_cross_entropy_with_logits([[1.0]],[[2.0]]))
array([ 0.], dtype=float32)
>>> sess.run(tf.nn.softmax_cross_entropy_with_logits([[1.0,0.0],[0.0,2.0]],[[1.0,1.0],[0.0,1.0]]))
array([ 1.62652326, 0.12692805], dtype=float32)
>>> sess.run(tf.nn.softmax_cross_entropy_with_logits([[1.0,2.0]],[[3.0,4.0]]))
array([ 5.19283152], dtype=float32)
>>> sess.run(tf.nn.softmax_cross_entropy_with_logits([[1.0,2.0]],[[4.0,3.0]]))
array([ 6.19283152], dtype=float32)
Protokolle und Etiketten müssen float und Rang 2 sein. Es scheint gekreuzte Entropie zurückzugeben. Ich verstehe die Kreuzentropie nicht wirklich. Vielleicht kehrt es zurück "wie nah die beiden nach dem Softmaxing von Protokollen und Etiketten sind" ... nicht wahr?
tf.nn.in_top_k(predictions, targets, k, name=None)
>>> sess.run(tf.nn.in_top_k([[0,2,1]],[1],1))
array([ True], dtype=bool)
>>> sess.run(tf.nn.in_top_k([[3,2,1]],[1],1))
array([False], dtype=bool)
>>> sess.run(tf.nn.in_top_k([[3,2,1]],[0],1))
array([ True], dtype=bool)
>>> sess.run(tf.nn.in_top_k([[3,2,1]],[0],2))
array([ True], dtype=bool)
>>> sess.run(tf.nn.in_top_k([[3,2,1]],[1],2))
array([ True], dtype=bool)
>>> sess.run(tf.nn.in_top_k([[3,2,1]],[2],2))
array([False], dtype=bool)
>>> sess.run(tf.nn.in_top_k([[3,2,1],[1,3,5]],[1,0],2))
array([ True, False], dtype=bool)
Der Punkt ist: "Welches ist die größte Zahl?" Wenn Vorhersagen [[3,2,1]] und Ziele [0] sind, ist die größte die 0 "3", sodass die Antwort korrekt ist und der Rückgabewert True ist. Wenn die Ziele [1] oder [2] sind, ist dies falsch. k wird als "OK, wenn die Größe bis zum dritten ist" angegeben. Wenn k 2 ist, wird True zurückgegeben, auch wenn die Zahl die zweitgrößte ist. Wenn beispielsweise Vorhersagen [[3,2,1]] und k 2 sind, sind die Ziele mit [0](0. Zahl "3") oder [1](1. Zahl "2") wahr. werden.
Recommended Posts