Tenseurs dans TensorFlow

L'objet principal manipulé dans Tensorflow est le tenseur. Quels sont les tenseurs, quels sont les tenseurs, quelles sont leurs propriétés et comment les manipuler, lisez le guide de traduction de tensorflow.org.

TensorFlow, comme son nom l'indique, est une plate-forme pour définir et effectuer des calculs à l'aide de tenseurs. Un tenseur est une généralisation de vecteurs et de matrices à des dimensions supérieures. À l'intérieur de TensorFlow, les tenseurs sont représentés sous forme de tableaux à n dimensions de types de données de base.

Lors de l'écriture d'un programme TensorFlow, l'objet principal que vous manipulez et passez est tf.Tensor . Les programmes TensorFlow fonctionnent en créant d'abord un graphique des objets tf.Tensor et en décrivant en détail comment chaque tenseur est calculé en fonction des autres tenseurs disponibles, puis en exécutant des parties de ce graphique pour obtenir les résultats du calcul.

tf.Tensor a les options suivantes:

• type de données ( float32 , int32 ou string , par exemple)
• tailles (forme)

Tous les éléments tenseurs ont le même type de données, et il est toujours connu. Les dimensions (le nombre de mesures et la taille de chaque mesure) ne sont que partiellement connues. Le résultat de la plupart des opérations sont des tenseurs de tailles connues, si les dimensions en entrée sont également parfaitement connues, mais dans certains cas il n'est possible de connaître les dimensions du tenseur que lors de l'exécution du graphe.

Les principaux types de tenseurs sont les suivants:

• tf.Variable
• tf.constant
• tf.placeholder
• tf.SparseTensor

À l'exception de tf.Variable , la valeur du tenseur est inchangée, c'est-à-dire dans le cadre d'une exécution, un tenseur ne peut avoir qu'une seule valeur. Cependant, le calcul du même tenseur deux fois peut renvoyer des valeurs différentes; par exemple, le même tenseur peut être le résultat de la lecture de données à partir d'un disque ou de la génération d'un nombre aléatoire.

Grade

Le rang de l'objet tf.Tensor est le nombre de ses dimensions. Les synonymes d'un rang sont ordre , degré , dimension . Notez qu'un classement dans TensorFlow n'est pas le même qu'un classement matriciel en mathématiques. Comme le montre le tableau suivant, chaque rang dans Tensorflow correspond à une entité mathématique:

Rang 0

L'extrait de code suivant illustre la création de plusieurs variables de rang 0:

 mammal = tf.Variable("Elephant", tf.string) ignition = tf.Variable(451, tf.int16) floating = tf.Variable(3.14159265359, tf.float64) its_complicated = tf.Variable(12.3 - 4.85j, tf.complex64) 

Remarque: Une chaîne est considérée comme un seul objet dans TensorFlow, pas une séquence de caractères. Il est possible d'avoir des scalaires de chaîne, des vecteurs de ligne, etc.

Rang 1

Pour créer un objet tf.Tensor de rang 1, vous pouvez passer une liste d'éléments en tant que valeurs initiales. Par exemple:

 mystr = tf.Variable(["Hello"], tf.string) cool_numbers = tf.Variable([3.14159, 2.71828], tf.float32) first_primes = tf.Variable([2, 3, 5, 7, 11], tf.int32) its_very_complicated = tf.Variable([12.3 - 4.85j, 7.5 - 6.23j], tf.complex64) 

Rangs supérieurs

Le rang 2 de l'objet tf.Tensor comprend au moins une ligne et une colonne:

 mymat = tf.Variable([[7],[11]], tf.int16) myxor = tf.Variable([[False, True],[True, False]], tf.bool) linear_squares = tf.Variable([[4], [9], [16], [25]], tf.int32) squarish_squares = tf.Variable([ [4, 9], [16, 25] ], tf.int32) rank_of_squares = tf.rank(squarish_squares) mymatC = tf.Variable([[7],[11]], tf.int32) 

De même, les tenseurs de rang supérieur sont constitués de tableaux à n dimensions. Par exemple, lors du traitement d'images, de nombreux tenseurs de rang 4 sont utilisés, avec des dimensions correspondant au numéro d'exemple dans le paquet, la hauteur de l'image, la largeur de l'image et le canal de couleur.

 my_image = tf.zeros([10, 299, 299, 3]) #   x  x  x    

Obtention du tf.Tensor objet tf.Tensor

Pour déterminer le rang de l'objet tf.Tensor , appelez la méthode tf.rank . Par exemple, la méthode suivante détermine par programme le rang de tf.Tensor spécifié ci-dessus:

 r = tf.rank(my_image) #   , r   4. 

Liens vers les tranches tf.Tensor

Étant donné que tf.Tensor est un tableau de cellules à n dimensions, pour accéder à une seule cellule dans tf.Tensor vous devez spécifier n indices.

Pour les tenseurs de rang 0 (scalaires), les index ne sont pas nécessaires, car il ne s'agit déjà que d'un nombre.

Pour un tenseur de rang 1 (vecteur), le passage d'un seul index vous donnera accès au nombre:

 my_scalar = my_vector[2] 

Notez que l'index passé à [] peut lui-même être un scalaire tf.Tensor si vous souhaitez sélectionner dynamiquement un élément à partir d'un vecteur.

Pour les tenseurs de rang 2 ou supérieur, la situation est plus intéressante. Pour tf.Tensor rang 2, le passage de deux nombres renvoie comme prévu par un scalaire:

 my_scalar = my_matrix[1, 2] 

Cependant, le passage d'un seul nombre renvoie un sous-vecteur de la matrice comme suit:

 my_row_vector = my_matrix[2] my_column_vector = my_matrix[:, 3] 

Notation : dans la syntaxe, l'allocation de sous-tableau en python est utilisée comme «laisser cette dimension seule». Ceci est utile dans les tenseurs de haut rang, car il permet d'accéder aux sous-vecteurs, sous-matrices et même à d'autres sous-capteurs.

Les dimensions

Les dimensions du tenseur sont le nombre d'éléments dans chaque dimension. La documentation TensorFlow utilise trois conventions pour décrire la dimension d'un tenseur: rang, dimensions et nombre de dimensions. Le tableau suivant montre comment ils sont liés les uns aux autres:

Les tailles peuvent être représentées sous forme de listes Python / tuples d'entiers, ou en utilisant
tf.TensorShape .

Obtention de la taille de l'objet tf.Tensor

Il existe deux façons d'obtenir les dimensions du tf.Tensor . Lors de la construction d'un graphe, il est souvent utile de se demander ce que l'on sait déjà de la taille du tenseur. Cela peut être fait en lisant la propriété shape de l'objet tf.Tensor . Cette méthode renvoie un objet TensorShape , ce qui est un moyen pratique.
représentations de tailles partiellement définies (car lors de la construction d'un graphe, toutes les tailles ne peuvent pas être entièrement connues).

Vous pouvez également obtenir tf.Tensor qui représente les dimensions entièrement définies d'un autre tf.Tensor lors de l'exécution. Cela se fait en tf.shape opération tf.shape . De cette façon, vous pouvez créer un graphique qui manipule les tailles des tenseurs en construisant d'autres tenseurs en fonction des tailles dynamiques du tf.Tensor entrée.

Par exemple, vous pouvez créer un vecteur de zéros de la même taille que le nombre de colonnes d'une matrice donnée:

 zeros = tf.zeros(my_matrix.shape[1]) 

Redimensionner tf.Tensor

Le nombre d'éléments tenseurs est le produit de toutes ses mesures. Le nombre d'éléments scalaires est toujours 1 . Étant donné que de nombreuses tailles différentes peuvent donner le même nombre d'éléments, il est souvent pratique de redimensionner tf.Tensor sans changer ses éléments. Cela peut être fait en utilisant tf.reshape .

Les exemples suivants montrent comment redimensionner un tenseur:

 rank_three_tensor = tf.ones([3, 4, 5]) matrix = tf.reshape(rank_three_tensor, [6, 10]) #    #   6x10 matrixB = tf.reshape(matrix, [3, -1]) #     #  3x20. -1  reshape   #    . matrixAlt = tf.reshape(matrixB, [4, 3, -1]) #     #  4x3x5 # ,         #   .     #         #     . yet_another = tf.reshape(matrixAlt, [13, 2, -1]) # ERROR! 

Types de données

En plus de la dimension, les tenseurs ont un type de données. Un tf.Tensor particulier tf.Tensor peut pas avoir plus d'un type de données. Cependant, il est possible de sérialiser des structures de données arbitraires dans une string et de les stocker dans tf.Tensor .

Vous pouvez convertir tf.Tensor d'un type de données à un autre à l'aide de tf.cast :

 #         . float_tensor = tf.cast(tf.constant([1, 2, 3]), dtype=tf.float32) 

Pour afficher le type de données tf.Tensor , utilisez la propriété Tensor.dtype .

Lors de la création de tf.Tensor partir d'un objet python, vous pouvez éventuellement spécifier un type de données. Si vous ne le faites pas, TensorFlow sélectionnera un type de données pouvant représenter vos données. TensorFlow convertit les entiers Python en tf.int32 et les nombres à virgule flottante en tf.float32 . Dans d'autres cas, TensorFlow utilise les mêmes règles que numpy lors de la conversion de tableaux.

Évaluation du tenseur

Une fois un graphe de calcul créé, vous pouvez exécuter un calcul qui
va générer un tf.Tensor spécifique et extraire la valeur qui lui est affectée. Ceci est souvent utile pour le débogage, ainsi que pour travailler la plupart de TensorFlow.

La façon la plus simple d'évaluer Tensor est d'utiliser la méthode Tensor.eval . Par exemple:

 constant = tf.constant([1, 2, 3]) tensor = constant * constant print(tensor.eval()) 

La méthode eval ne fonctionne que lorsque la tf.Session par défaut tf.Session . Tensor.eval renvoie un tableau numpy avec le même contenu que le tenseur.

Parfois, il est impossible d'évaluer tf.Tensor sans contexte, car sa valeur peut dépendre d'informations dynamiques qui ne sont pas disponibles. Par exemple, les tenseurs dépendants de l' placeholder ne peuvent pas être évalués sans fournir une valeur pour l' placeholder .

 p = tf.placeholder(tf.float32) t = p + 1.0 t.eval() #   ,   placeholder   . t.eval(feed_dict={p:2.0}) #  ,     #   placeholder. 

Veuillez noter que vous pouvez utiliser n'importe quel tf.Tensor , pas seulement l'espace réservé.

D'autres conceptions de modèles peuvent rendre tf.Tensor plus difficile à évaluer. TensorFlow ne peut pas évaluer directement tf.Tensor défini à l'intérieur de fonctions ou dans des constructions de flux de contrôle. Si tf.Tensor dépend de la valeur de la file d'attente, le score tf.Tensor ne fonctionnera que lorsque quelque chose est placé dans la file d'attente; sinon, l'estimation du tenseur se figera. Lorsque vous travaillez avec des files d'attente, n'oubliez pas d'appeler tf.train.start_queue_runners avant d'évaluer un tf.Tensor .

Après vérification, la traduction apparaîtra également sur Tensorflow.org. Si vous souhaitez participer à la traduction de la documentation du site Tensorflow.org en russe, veuillez nous contacter à titre personnel ou commentaires. Toutes corrections ou commentaires sont appréciés.