Qu'est-ce qu'un tenseur dans TensorFlow ? Forme, type et Operajeudi

Qu'est-ce qu'un tenseur ?

Le nom du blog TensorFlow Il est directement dérivé de son objet fondamental : le tenseur. Dans TensorFlow, chaque calcul fait intervenir des tenseurs. Un tenseur est un vecteur ou une matrice à n dimensions qui représente tous les types de données. Toutes les valeurs d'un tenseur ont un type de données identique et une forme connue (ou partiellement connue), cette forme correspondant à la dimensionnalité de la matrice ou du tableau.

Un tenseur peut provenir des données d'entrée ou du résultat d'un calcul. Dans TensorFlow, toutes les opérations sont effectuées au sein d'un graphe. Ce graphe représente l'ensemble des calculs qui s'exécutent successivement. Chaque opération est appelée un nœud d'opération, et les nœuds sont interconnectés.

Le graphique illustre les opérations et les connexions entre les nœuds. Cependant, il n'affiche pas les valeurs. L'arête entre les nœuds représente le tenseur, c'est-à-dire un moyen d'alimenter l'opération avec des données.

En apprentissage automatique, les modèles sont alimentés par une liste d'objets appelés vecteurs de caractéristiques. Un vecteur de caractéristiques peut être de n'importe quel type de données et constitue généralement l'entrée principale qui alimente un tenseur. Ces valeurs transitent par le tenseur vers un nœud d'opération, et le résultat de cette opération crée un nouveau tenseur, qui est à son tour utilisé dans une nouvelle opération. Toutes ces opérations sont visibles dans le graphe.

Représentation d'un tenseur

Dans TensorFlow, un tenseur est un ensemble de vecteurs de caractéristiques (c'est-à-dire un tableau) de n dimensions. Par exemple, si nous avons une matrice 2×3 avec des valeurs de 1 à 6, nous l'écrivons comme la matrice ci-dessous :

TensorFlow représente cette matrice comme :

[[1, 2, 3], 
   [4, 5, 6]]

Si l'on crée une matrice tridimensionnelle avec des valeurs allant de 1 à 8, les mêmes données sont représentées par une boîte à deux faces superposées :

TensorFlow représente cette matrice comme :

[ [[1, 2],  
       [[3, 4],  
       [[5, 6],  
       [[7,8] ]

Remarque : Un tenseur peut être représenté par un scalaire ou avoir une forme à plus de trois dimensions. Il est simplement plus difficile de visualiser les dimensions supérieures.

Types de tenseur

Dans TensorFlow, tous les calculs transitent par un ou plusieurs tenseurs. Un tf.Tensor est un objet possédant trois propriétés :

• Une étiquette unique (nom)
• Une dimension (forme)
• Un type de données (dtype)

Chaque opération effectuée avec TensorFlow implique la manipulation d'un tenseur. Il existe quatre principaux types de tenseurs que vous pouvez créer :

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

Dans ce tutoriel, vous apprendrez comment créer un tf.constant , l’aspect économique tf.Variable.

Un point important à retenir avant d'exécuter le code : ce tutoriel suit l'API TensorFlow 1.x d'origine, où un graphe est d'abord construit puis exécuté ultérieurement au sein d'une session. TensorFlow 2 s'exécute par défaut de manière immédiate ; par conséquent, plusieurs symboles ci-dessous ont été déplacés ou supprimés. Ils restent néanmoins tous accessibles via… tf.compat.v1 l'espace de noms, et le tableau associe chaque nom à son équivalent moderne.

Avant de suivre le tutoriel, assurez-vous d'activer l'environnement conda sur lequel TensorFlow est installé. Cet environnement se nomme hello-tf.

Pour macOS utilisateurs:

source activate hello-tf

Pour Windows utilisateurs:

activate hello-tf

Une fois cela fait, vous êtes prêt à importer TensorFlow.

# Import tf
import tensorflow as tf

Créer un tenseur de n-dimension

Vous commencez par la création d'un tenseur à une dimension, à savoir un scalaire.

Pour créer un tenseur, vous pouvez utiliser tf.constant() comme illustré dans l'exemple de forme de tenseur TensorFlow ci-dessous :

tf.constant(value, dtype, name = "")
arguments

- `value`: Value of n dimension to define the tensor. Optional
- `dtype`: Define the type of data:    
    - `tf.string`: String variable    
    - `tf.float32`: Float variable    
    - `tf.int16`: Integer variable
- "name": Name of the tensor. Optional. By default, `Const_1:0`

Pour créer un tenseur de dimension 0, exécutez le code suivant.

## rank 0
# Default name
r1 = tf.constant(1, tf.int16) 
print(r1)			

Sortie

Tensor("Const:0", shape=(), dtype=int16)

Les trois parties de cette sortie correspondent aux trois propriétés du tenseur, comme le montre clairement la version annotée ci-dessous.

Vous pouvez également donner au tenseur un nom personnalisé avec le name argument.

# Named my_scalar
r2 = tf.constant(1, tf.int16, name = "my_scalar") 
print(r2)

Sortie

Tensor("my_scalar:0", shape=(), dtype=int16)

Chaque tenseur est affiché par son nom. Chaque objet tenseur est défini par des attributs tels qu'une étiquette unique (nom), une dimension (forme) et un type de données TensorFlow (dtype).

Vous pouvez définir un tenseur avec des valeurs décimales ou avec une chaîne en changeant le type de données.

# Decimal
r1_decimal = tf.constant(1.12345, tf.float32)
print(r1_decimal)
# String
r1_string = tf.constant("Guru99", tf.string)
print(r1_string)

Sortie

Tensor("Const_1:0", shape=(), dtype=float32)
Tensor("Const_2:0", shape=(), dtype=string)

Un tenseur de dimension 1 peut être créé comme suit :

## Rank 1
r1_vector = tf.constant([1,3,5], tf.int16)
print(r1_vector)
r2_boolean = tf.constant([True, True, False], tf.bool)
print(r2_boolean)

Sortie

Tensor("Const_3:0", shape=(3,), dtype=int16)
Tensor("Const_4:0", shape=(3,), dtype=bool)

Vous pouvez constater que la forme TensorFlow est composée d'une seule colonne.

Pour créer un tableau de tenseurs à deux dimensions, vous devez fermer les crochets après chaque ligne. Consultez l'exemple de forme de tenseur ci-dessous.

## Rank 2
r2_matrix = tf.constant([ [1, 2],
                          [3, 4] ],tf.int16)
print(r2_matrix)

Sortie

Tensor("Const_5:0", shape=(2, 2), dtype=int16)

La matrice comporte 2 lignes et 2 colonnes remplies des valeurs 1, 2, 3 et 4.

On construit une matrice à 3 dimensions en ajoutant un niveau supplémentaire de parenthèses.

## Rank 3
r3_matrix = tf.constant([ [[1, 2],
                           [3, 4], 
                           [5, 6]] ], tf.int16)
print(r3_matrix)

Sortie

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16)

Le résultat correspond au diagramme tridimensionnel présenté précédemment dans ce tutoriel.

Forme du tenseur

Lorsque vous affichez un tenseur, TensorFlow en déduit la forme. Cependant, vous pouvez lire directement cette forme avec TensorFlow. shape propriété.

Ci-dessous, vous construisez une matrice remplie des nombres de 10 à 15 et vous vérifiez la forme de m_shape.

# Shape of tensor
m_shape = tf.constant([ [10, 11],
                        [12, 13],
                        [14, 15] ]                      
                     ) 
m_shape.shape

Sortie

TensorShape([Dimension(3), Dimension(2)])

La matrice comporte 3 lignes et 2 colonnes.

TensorFlow dispose de commandes utiles pour créer un vecteur ou une matrice remplie de 0 ou 1. Par exemple, si vous souhaitez créer un tenseur 1D avec une forme spécifique de 10, rempli de 0, vous pouvez exécuter le code ci-dessous :

# Create a vector of 0
print(tf.zeros(10))

Sortie

Tensor("zeros:0", shape=(10,), dtype=float32)

Cette propriété s'applique également aux matrices. Ici, vous créez une matrice 10×10 remplie de 1.

# Create a vector of 1
print(tf.ones([10, 10]))

Sortie

Tensor("ones:0", shape=(10, 10), dtype=float32)

Vous pouvez utiliser la forme d'une matrice donnée pour créer un vecteur de uns. La matrice m_shape Il possède des dimensions de 3×2, donc le code suivant crée un tenseur avec 3 lignes remplies de 1 :

# Create a vector of ones with the same number of rows as m_shape
print(tf.ones(m_shape.shape[0]))

Sortie

Tensor("ones_1:0", shape=(3,), dtype=float32)

Si vous passez la valeur 1 entre parenthèses, vous construisez un vecteur de 1 égal au nombre de colonnes de la matrice. m_shape.

# Create a vector of ones with the same number of column as m_shape
print(tf.ones(m_shape.shape[1]))

Sortie

Tensor("ones_2:0", shape=(2,), dtype=float32)

Enfin, vous pouvez créer une matrice 3×2 entièrement remplie de 1.

print(tf.ones(m_shape.shape))

Sortie

Tensor("ones_3:0", shape=(3, 2), dtype=float32)

Type de données

La deuxième propriété d'un tenseur est son type de données. Un tenseur ne peut contenir qu'un seul type de données à la fois, et vous pouvez lire ce type avec… dtype propriété.

print(m_shape.dtype)

Sortie

<dtype: &#x27;int32'>

Dans certains cas, vous souhaitez modifier le type de données. Avec TensorFlow, c'est possible grâce à… tf.cast méthode.

Exemple

Ci-dessous, un tenseur flottant est converti en entier avec le cast méthode.

# Change type of data
type_float = tf.constant(3.123456789, tf.float32)
type_int = tf.cast(type_float, dtype=tf.int32)
print(type_float.dtype)
print(type_int.dtype)

Sortie

<dtype: &#x27;float32'>
<dtype: &#x27;int32'>

TensorFlow choisit automatiquement le type de données lorsque l'argument n'est pas spécifié lors de la création du tenseur. TensorFlow devine le type de données le plus probable : si vous fournissez du texte, par exemple, il s'agit d'une chaîne de caractères.

Nos Boissons Operator

Quelques fonctionnalités utiles de TensorFlow Operajeudi

Vous savez créer un tenseur avec TensorFlow. Il est temps d'apprendre à effectuer des opérations mathématiques.

TensorFlow contient toutes les opérations de base. Vous pouvez commencer par une opération simple et utiliser une méthode TensorFlow pour calculer la racine carrée d'un nombre. Cette opération est simple car un seul argument est nécessaire pour construire le tenseur.

La racine carrée d'un nombre est construite avec tf.sqrt(x), avec x comme nombre à virgule flottante.

x = tf.constant([2.0], dtype = tf.float32)
print(tf.sqrt(x))

Sortie

Tensor("Sqrt:0", shape=(1,), dtype=float32)

Remarque : La sortie a renvoyé un objet tenseur et non la racine carrée de 2. Dans cet exemple, vous affichez la définition du tenseur et non le résultat de l’opération. La section « Session » ci-dessous explique comment TensorFlow exécute les opérations.

Voici une liste des opérations les plus courantes. Le principe est le même : chaque opération nécessite un ou plusieurs arguments.

• tf.add(a, b)
• tf.subtract(a, b)
• tf.multiply(a, b)
• tf.divide(a, b)
• tf.pow(a, b)
• tf.exp(a)
• tf.sqrt(a)

Exemple

# Add
tensor_a = tf.constant([[1,2]], dtype = tf.int32)
tensor_b = tf.constant([[3, 4]], dtype = tf.int32)

tensor_add = tf.add(tensor_a, tensor_b)
print(tensor_add)

Sortie

Tensor("Add:0", shape=(1, 2), dtype=int32)

Code Explication

Créez deux tenseurs :

• un tenseur avec 1 et 2
• un tenseur avec 3 et 4

Vous additionnez les deux tenseurs.

Notez que les deux tenseurs doivent avoir la même forme. Vous pouvez également effectuer une multiplication sur les deux tenseurs.

# Multiply
tensor_multiply = tf.multiply(tensor_a, tensor_b)
print(tensor_multiply)

Sortie

Tensor("Mul:0", shape=(1, 2), dtype=int32)

Variables

Jusqu'à présent, vous n'avez créé que des tenseurs constants, ce qui est d'une utilité limitée. Les données arrivent toujours avec des valeurs différentes ; pour les représenter, vous pouvez utiliser la classe Variable. Une variable représente un nœud dont les valeurs évoluent au fil du temps.

Pour créer une variable, vous pouvez utiliser le tf.get_variable() méthode.

tf.get_variable(name = "", values, dtype, initializer)
argument
- `name = ""`: Name of the variable
- `values`: Dimension of the tensor
- `dtype`: Type of data. Optional
- `initializer`: How to initialize the tensor. Optional
If initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.

Par exemple, le code ci-dessous crée une variable bidimensionnelle avec deux valeurs aléatoires. Par défaut, TensorFlow renvoie une valeur aléatoire. Vous nommez la variable var.

# Create a Variable
## Create 2 Randomized values
var = tf.get_variable("var", [1, 2])
print(var.shape)

Sortie

(1, 2)

Dans cet exemple, vous créez une variable avec une ligne et deux colonnes, vous passez donc [1, 2] comme dimension de la variable.

Les valeurs initiales d'un tenseur peuvent également être nulles. Lors de l'entraînement d'un modèle, par exemple, il est nécessaire de définir des valeurs initiales avant de calculer le poids des caractéristiques. Ci-dessous, ces valeurs initiales sont initialisées à zéro.

var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32,  initializer=tf.zeros_initializer)
print(var_init_1.shape)

Sortie

(1, 2)

Vous pouvez également affecter les valeurs d'un tenseur constant à une variable. Vous créez un tenseur constant avec la méthode tf.constant() et utilisez ce tenseur pour initialiser la variable.

Les premières valeurs de la variable sont 10, 20, 30 et 40. Le nouveau tenseur a une forme de 2×2.

# Create a 2x2 matrix
tensor_const = tf.constant([[10, 20],
[30, 40]])
# Initialize the first value of the tensor equals to tensor_const
var_init_2 = tf.get_variable("var_init_2", dtype=tf.int32,  initializer=tensor_const)
print(var_init_2.shape)

Sortie

(2, 2)

placeholder

Un espace réservé sert à alimenter le tenseur. Il initialise les données qui seront stockées dans les tenseurs. Pour fournir un espace réservé, vous utilisez… feed_dict argument, et l'espace réservé n'est fourni qu'au sein d'une session.

Dans l'exemple suivant, vous verrez comment créer un espace réservé avec la méthode tf.placeholderDans la section Session, vous apprendrez à alimenter un espace réservé avec une valeur de tenseur réelle.

La syntaxe est:

tf.placeholder(dtype,shape=None,name=None )
arguments:
- `dtype`: Type of data
- `shape`: dimension of the placeholder. Optional. By default, shape of the data
- `name`: Name of the placeholder. Optional			
data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")
print(data_placeholder_a)

Sortie

Tensor("data_placeholder_a:0", dtype=float32)

Session

TensorFlow fonctionne autour de 3 composants principaux :

• Graphique
• tenseur
• Session

Les graphiques et les sessions sont indépendants. Vous pouvez exécuter une session et conserver les valeurs pour des calculs ultérieurs.

Dans l'exemple ci-dessous, vous allez :

• Créer deux tenseurs
• Créer une opération
• Ouvrir une session
• Imprimer le résultat

Étape 1) Vous créez deux tenseurs x et y

## Create, run  and evaluate a session
x = tf.constant([2])
y = tf.constant([4])

Étape 2) Vous créez l'opérateur en multipliant x et y

## Create operator
multiply = tf.multiply(x, y)

Étape 3) Vous ouvrez une session. Tous les calculs s'effectuent au sein de cette session, et une fois terminé, vous devez la fermer.

## Create a session to run the code
sess = tf.Session()
result_1 = sess.run(multiply)
print(result_1)
sess.close()

Sortie

[8]

Code explication

• tf.Session()Ouvrez une session. Toutes les opérations s'effectuent au sein de cette session.
• run(multiply): exécuter l'opération créée à l'étape 2
• print(result_1)Enfin, vous pouvez imprimer le résultat.
• close(): Clôturer la session

Le résultat montre 8, qui est la multiplication de x et y.

Une autre façon de créer une session consiste à l'intégrer dans un bloc. L'avantage est que la session se ferme automatiquement.

with tf.Session() as sess:
    result_2 = multiply.eval()
print(result_2)

Sortie

[8]

Dans le cadre d'une session, vous pouvez utiliser eval() méthode d'exécution de l'opération. Elle est équivalente à run() et rend le code plus lisible.

Vous pouvez créer une session et voir les valeurs à l'intérieur des tenseurs que vous avez créés jusqu'à présent.

## Check the tensors created before
sess = tf.Session()
print(sess.run(r1))
print(sess.run(r2_matrix))
print(sess.run(r3_matrix))

Sortie

1
[[1 2] 
 [3 4]]
[[[1 2]  
  [3 4]  
  [5 6]]]

Les variables sont vides par défaut, même après la création du tenseur. Vous devez initialiser une variable avant de pouvoir l'utiliser. L'objet tf.global_variables_initializer() Cette fonction est appelée pour initialiser simultanément les valeurs de chaque variable, ce qui est utile avant d'entraîner un modèle.

Vous pouvez vérifier les valeurs des variables que vous avez créées précédemment. Notez que vous devez utiliser la fonction `run` pour évaluer le tenseur.

sess.run(tf.global_variables_initializer())
print(sess.run(var))
print(sess.run(var_init_1))
print(sess.run(var_init_2))

Sortie

[[-0.05356491  0.75867283]]
[[0 0]]
[[10 20] 
 [30 40]]

Vous pouvez utiliser l'espace réservé que vous avez créé précédemment et l'alimenter avec une valeur réelle. Vous devez transmettre les données à feed_dict argument.

Par exemple, vous prendrez la puissance 2 de l'espace réservé data_placeholder_a.

import numpy as np
power_a = tf.pow(data_placeholder_a, 2)
with tf.Session() as sess:
    data = np.random.rand(1, 10)
    print(sess.run(power_a, feed_dict={data_placeholder_a: data}))  # Will succeed.

Code Explication

• import numpy as np: Importer le NumPy bibliothèque pour créer les données
• tf.pow(data_placeholder_a, 2): Créer les opérations
• np.random.rand(1, 10): Créer un tableau de données aléatoires
• feed_dict={data_placeholder_a: data}: Alimentez le champ réservé avec des données

Sortie

[[0.05478134 0.27213147 0.8803037  0.0398424  0.21172127 0.01444725  0.02584014 0.3763949  0.66022706 0.7565559 ]]

Graphique

TensorFlow représente chaque opération par un schéma de flux de données. Le graphe de flux de données a été conçu pour mettre en évidence les dépendances de données entre les différentes opérations. Une formule mathématique ou un algorithme est composé d'une série d'opérations successives, et un graphe permet de visualiser facilement la coordination de ces calculs.

Le graphe présente des nœuds et des arêtes. Un nœud représente une opération, c'est-à-dire l'unité de calcul. Une arête représente un tenseur : elle peut produire un nouveau tenseur ou consommer les données d'entrée, selon les dépendances entre les différentes opérations.

La structure du graphe relie les opérations (c'est-à-dire les nœuds) entre elles et montre comment chacune est alimentée. Notez que le graphe n'affiche pas le résultat des opérations ; il sert uniquement à visualiser les liens entre elles.

Prenons un exemple. Imaginez que vous souhaitiez évaluer la fonction suivante :

TensorFlow construit un graphe pour exécuter la fonction. Ce graphe ressemble à ceci :

Vous pouvez facilement voir le chemin que prendront les tenseurs pour atteindre la destination finale.

Par exemple, le add Le nœud ne peut pas s'exécuter avant les deux Mul et Pow ont produit leurs résultats. Le graphique montre que TensorFlow va :

1. calculer x·z dans le Mul nœud et x² dans le Pow nœud
2. additionnez ces deux résultats dans le add nœud
3. ajouter z à cette somme dans le add_1 nœud
4. ajouter la constante 5 dans le add_2 nœud

x = tf.get_variable("x", dtype=tf.int32,  initializer=tf.constant([5]))
z = tf.get_variable("z", dtype=tf.int32,  initializer=tf.constant([6]))
c = tf.constant([5], name =	"constant")
square = tf.constant([2], name =	"square")
f = tf.multiply(x, z) + tf.pow(x, square) + z + c

Code Explication

• x : initialise une variable appelée x avec une valeur constante de 5
• z : Initialiser une variable appelée z avec une valeur constante de 6
• c : Initialiser un tenseur constant appelé c avec une valeur constante de 5
• carré : initialise un tenseur constant appelé carré avec une valeur constante de 2
• f : Construire l'opérateur

Dans cet exemple, les valeurs des variables sont fixées. Le tenseur constant c est le paramètre constant de la fonction f et prend la valeur 5 ; sur le graphique, ce paramètre est visible dans le tenseur appelé constante.

Un tenseur constant a également été créé pour la puissance de l'opérateur tf.pow()Ce n'est pas indispensable, mais cela signifie que l'exposant apparaît sur le graphique sous la forme d'un cercle appelé carré.

À partir du graphique, vous pouvez suivre ce qui arrive aux tenseurs et pourquoi la fonction renvoie 66 : 5 × 6 plus 5² plus 6 plus 5 égale 66.

Le code ci-dessous évalue la fonction à l'intérieur d'une session.

init = tf.global_variables_initializer() # prepare to initialize all variables
with tf.Session() as sess:
    init.run() # Initialize x and y
    function_result = f.eval()
print(function_result)

Sortie

[66]

Guide de référence rapide des bases de TensorFlow

Les quatre tableaux ci-dessous répertorient toutes les commandes utilisées dans ce tutoriel afin que vous puissiez en rechercher une sans avoir à parcourir à nouveau les exemples.

Créer un tenseur constant

Créer un opérateur

Créer un tenseur variable

Ouvrir une session

FAQ