Je ne comprends pas bien le calcul matriciel et les statistiques, et je n'ai jamais utilisé numpy. Je ne comprends donc pas l'API TensorFlow. ... Donc, une note pour essayer d'exécuter les API que vous ne comprenez pas une par une et voir ce qu'elles font. Je n'ai aucune expertise, alors j'aimerais avoir de vos nouvelles. Référence: Référence officielle de l'API
Essayez ce qui suit un par un en mode interactif de Python.
>>> import tensorflow as tf
>>> sess = tf.Session()
>>> sess.run(<API à exécuter>)
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
Il semble renvoyer le nombre d'éléments.
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)
Il semble que la dimension (Rank) spécifiée par dim soit ajoutée à l'entrée. Si le rang de l'entrée est 1 et 1 est spécifié pour dim, la valeur de retour sera Rank2.
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)
Renvoie le tableau unidimensionnel spécifié (strictement 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)
Il semble relier des Tensors donnés en valeurs. Les Tensors qui sont la source de la connexion sont donnés sous la forme [\ <Tensor1 >, \ <Tensor2 >].
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)
Je ne suis pas sûr, mais le même Tensor donné dans les valeurs est renvoyé. Référence officielle
tf.pack([x, y, z]) = np.asarray([x, y, z])
Il est écrit que np.asarray () semble être une fonction qui crée une référence au tableau donné en argument ...
>>> 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]
Cela ne semble pas être une référence ...? ??
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)
Voici une description de la référence officielle.
# 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)
Lorsque sparse_indices est scalaire (rang 0), la partie index de la valeur numérique donnée par sparse_indices est la valeur de 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)
Si sparse_indices = [0,2] et sparse_values est [0,1,0,2], alors la sortie [0] = 0,1 et la sortie [2] = 0,2. Difficile à comprendre. Si sparse_values sont des valeurs scalaires, les valeurs entrées sont les mêmes. Il semble qu'une erreur se produira si sparse_indices n'est pas dans l'ordre croissant (comme [1,0]) ou si la même valeur est incluse (comme [1,1]).
>>> 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)
... Eh bien, c'est ce que c'est. Je ne comprends pas la signification de cette API. .. ..
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)
les logits doivent être de rang 2 et flottants. Renvoie quelque chose qui s'additionne dans une dimension pour en créer toutes.
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)
les journaux et les étiquettes doivent être flottants et de rang 2. Il semble retourner l'entropie croisée. Je ne comprends pas vraiment ce qu'est l'entropie croisée. Peut-être que ça revient "à quel point les deux sont proches après le softmaxing des journaux et des étiquettes" ...
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)
Le point est, "Quel est le plus grand nombre?" Si les prédictions sont [[3,2,1]] et les cibles sont [0], le plus grand est le 0e "3", donc la réponse est correcte et la valeur de retour est True. Si les cibles sont [1] ou [2], ce sera faux. k est spécifié comme "OK si la taille est jusqu'à la troisième". Si k vaut 2, True est renvoyé même si le nombre est le deuxième plus grand. Par exemple, si les prédictions sont [[3,2,1]] et k est 2, les cibles sont vraies avec [0](0e nombre "3") ou [1](1er nombre "2"). devenir.
Recommended Posts