Conceptos básicos de TensorFlow: tensor, forma, tipo, sesiones y Operatoros

¿Qué es un tensor?

El nombre de Tensorflow se deriva directamente de su marco central: Tensor. En Tensorflow, todos los cálculos involucran tensores. Un tensor es un vector o matriz de n dimensiones que representa todo tipo de datos. Todos los valores de un tensor contienen tipos de datos idénticos con una forma conocida (o parcialmente conocida). La forma de los datos es la dimensionalidad de la matriz o matriz.

Un tensor puede originarse a partir de los datos de entrada o del resultado de un cálculo. En TensorFlow, todos los operaLas operaciones se llevan a cabo dentro de un gráfico. El gráfico es un conjunto de cálculos que se realizan sucesivamente. Cada operación se llama nodo de operación y están conectados entre sí.

El gráfico describe las operaciones y conexiones entre los nodos. Sin embargo, no muestra los valores. El borde de los nodos es el tensor, es decir, una forma de poblar el operación con datos.

En Machine Learning, los modelos se alimentan con una lista de objetos llamados vectores de características. Un vector de características puede ser de cualquier tipo de datos. El vector de características suele ser la entrada principal para completar un tensor. Estos valores fluirán hacia un nodo op a través del tensor y el resultado de esto operaLa operación/cálculo creará un nuevo tensor que a su vez se utilizará en un nuevo operación. Todos estos operaLas ciones se pueden ver en el gráfico.

Representación de un tensor

En TensorFlow, un tensor es una colección de vectores de características (es decir, una matriz) de n dimensiones. Por ejemplo, si tenemos una matriz de 2×3 con valores del 1 al 6, escribimos:

Representación de un tensor
Representación de un tensor

TensorFlow representa esta matriz como:

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

Si creamos una matriz tridimensional con valores del 1 al 8, tenemos:

Representación de un tensor

TensorFlow representa esta matriz como:

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

Nota: Un tensor se puede representar con un escalar o puede tener una forma de más de tres dimensiones. Simplemente es más complicado visualizar un nivel de dimensión superior.

Tipos de tensor

En TensorFlow, todos los cálculos pasan por uno o más tensores. Un tf.tensor es un objeto con tres propiedades:

  • Una etiqueta única (nombre)
  • Una dimensión (forma)
  • Un tipo de datos (dtype)

Cada operaLa operación que harás con TensorFlow implica la manipulación de un tensor. Hay cuatro tipos principales de tensor que puedes crear:

  • tf.Variable
  • tf.constante
  • tf.marcador de posición
  • tf.SparseTensor

En este tutorial, aprenderá cómo crear un tf.constant y un tf.Variable.

Antes de continuar con el tutorial, asegúrese de activar el entorno conda con TensorFlow. Llamamos a este entorno hola-tf.

MacOS usuario:

source activate hello-tf

Windows usuario:

activate hello-tf

Una vez hecho esto, estará listo para importar tensorflow.

# Import tf
import tensorflow as tf

Crea un tensor de dimensión n

Se comienza con la creación de un tensor con una dimensión, es decir, un escalar.

Para crear un tensor, puede usar tf.constant() como se muestra en el siguiente ejemplo de forma de tensor de TensorFlow:

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`

Para crear un tensor de dimensión 0, ejecute lo siguientewing código

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

Salida

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

Crear un tensor de n-dimensión

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

Salida

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

Cada tensor se muestrayed por el nombre del tensor. Cada objeto tensorial se define con atributos tensoriales como una etiqueta única (nombre), una dimensión (forma) y tipos de datos de TensorFlow (tipo d).

Puedes definir un tensor con valores decimales o con una cadena cambiando el tipo de datos.

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

Salida

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

Un tensor de dimensión 1 se puede crear de la siguiente manera:

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

Salida

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

Puede notar que la forma de TensorFlow solo se compone de 1 columna.

Para crear una matriz de 2 dimensiones tensoriales, debe cerrar el brackets después de cada fila. Consulte el ejemplo de forma del tensor de Keras a continuación

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

Salida

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

La matriz tiene 2 filas y 2 columnas llenas de valores 1, 2, 3, 4.

Una matriz con 3 dimensiones se construye agregando otro nivel con el brackets.

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

Salida

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

La matriz se parece a la imagen dos.

Forma del tensor

Cuando imprimes tensor, TensorFlow adivina la forma. Sin embargo, puedes obtener la forma del tensor con la propiedad de forma de TensorFlow.

A continuación, construyes una matriz llena con un número del 10 al 15 y verificas la forma de m_shape

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

Salida

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

La matriz tiene 3 filas y 2 columnas.

TensorFlow tiene comandos útiles para crear un vector o una matriz llena de 0 o 1. Por ejemplo, si desea crear un tensor 1-D con una forma específica de 10, llena de 0, puede ejecutar el siguiente código:

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

Salida

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

La propiedad también funciona para Matrix. Aquí, creas una matriz de 10 × 10 llena de 1

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

Salida

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

Puedes usar la forma de una matriz dada para hacer un vector de unos. La matriz m_shape tiene dimensiones de 3 × 2. Puedes crear un tensor con 3 filas llenas de unas con el siguientewing código:

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

Salida

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

Si pasa el valor 1 entre corchetes, puede construir un vector de unos igual al número de columnas en la matriz m_shape.

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

Salida

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

Finalmente, puedes crear una matriz de 3×2 con solo uno.

print(tf.ones(m_shape.shape))

Salida

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

Tipo de datos

La segunda propiedad de un tensor es el tipo de datos. Un tensor sólo puede tener un tipo de datos a la vez. Un tensor sólo puede tener un tipo de datos. Puede devolver el tipo con la propiedad dtype.

print(m_shape.dtype)

Salida

<dtype: 'int32'>

En algunas ocasiones se desea cambiar el tipo de datos. En TensorFlow, es posible con el método tf.cast.

Ejemplo

A continuación, un tensor flotante se convierte a un número entero utilizando el método de conversión.

# 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)

Salida

<dtype: 'float32'>
<dtype: 'int32'>

TensorFlow elige el tipo de datos automáticamente cuando el argumento no se especifica durante la creación del tensor. TensorFlow adivinará cuáles son los tipos de datos más probables. Por ejemplo, si pasa un texto, adivinará que es una cadena y la convertirá en una cadena.

Creamos operator

Algunos TensorFlow útiles operatoros

Sabes cómo crear un tensor con TensorFlow. Es hora de aprender a realizar matemáticas. operaiones

TensorFlow contiene todos los elementos básicos. operaciones. Puedes comenzar con uno simple. Utilizará el método TensorFlow para calcular el cuadrado de un número. Este operaLa explicación es sencilla porque sólo se requiere un argumento para construir el tensor.

El cuadrado de un número se construye con tf.sqrt(x) con x como número flotante.

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

Salida

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

Nota: La salida devolvió un objeto tensor y no el resultado del cuadrado de 2. En el ejemplo, imprime la definición del tensor y no la evaluación real del operación. En la siguiente sección, aprenderá cómo funciona TensorFlow para ejecutar el operaiones

Following es una lista de uso común operaciones. La idea es la misma. Cada operaLa ción requiere uno o más argumentos.

  • tf.add(a, b)
  • tf.sustract(a, b)
  • tf.multiplicar(a, b)
  • tf.div(a,b)
  • tf.pow(a,b)
  • tf.exp(a)
  • tf.sqrt(a)

Ejemplo

# 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)

Salida

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

Explicación del código

Crea dos tensores:

  • un tensor con 1 y 2
  • un tensor con 3 y 4

Sumas ambos tensores.

Aviso: que ambos tensores deben tener la misma forma. Puedes ejecutar una multiplicación sobre los dos tensores.

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

Salida

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

Variables

Hasta ahora, sólo has creado tensores constantes. No es de gran utilidad. Los datos siempre llegan con valores diferentes, para capturar esto, puedes usar la clase Variable. Representará un nodo donde los valores siempre cambian.

Para crear una variable, puede utilizar el método tf.get_variable()

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.

Por ejemplo, el siguiente código crea una variable bidimensional con dos valores aleatorios. De forma predeterminada, TensorFlow devuelve un valor aleatorio. Le pones el nombre var a la variable

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

Salida

(1, 2)

En el segundo ejemplo, crea una variable con una fila y dos columnas. Necesitas usar [1,2] para crear la dimensión de la variable.

Los valores iniciales de este tensor son cero. Por ejemplo, cuando entrenas un modelo, necesitas tener valores iniciales para calcular el peso de las características. A continuación, establece estos valores iniciales en cero.

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

Salida

(1, 2)

Puedes pasar los valores de un tensor constante en una variable. Creas un tensor constante con el método tf.constant(). Utiliza este tensor para inicializar la variable.

Los primeros valores de la variable son 10, 20, 30 y 40. El nuevo tensor tendrá forma de 2×2.

# Create a 2x2 matrixtensor_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)

Salida

(2, 2)

marcador de posición

Un marcador de posición tiene el propósito de alimentar el tensor. El marcador de posición se utiliza para inicializar los datos para que fluyan dentro de los tensores. Para proporcionar un marcador de posición, debe utilizar el método feed_dict. El marcador de posición se alimentará sólo dentro de una sesión.

En el siguiente ejemplo, verá cómo crear un marcador de posición con el método tf.placeholder. En la próxima sesión, aprenderá a alimentar un marcador de posición con el valor tensor real.

La sintaxis es:

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)

Salida

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

Sesión

TensorFlow funciona en torno a 3 componentes principales:

  • Gráfico
  • tensor
  • Sesión
Componentes descritption
Gráfico El gráfico es fundamental en TensorFlow. todas las matematicas operaLas operaciones (ops) se realizan dentro de un gráfico. Puedes imaginar un gráfico como un proyecto donde cada operaLas operaciones están hechas. Los nodos representan estas operaciones, pueden absorber o crear nuevos tensores.
tensor Un tensor representa los datos que progresan entre operaciones. Ya viste anteriormente cómo inicializar un tensor. La diferencia entre una constante y una variable es que los valores iniciales de una variable cambiarán con el tiempo.
Sesión Una sesión ejecutará el operación del gráfico. Para alimentar el gráfico con los valores de un tensor, es necesario abrir una sesión. Dentro de una sesión, debes ejecutar un operator para crear una salida.

Los gráficos y las sesiones son independientes. Puede ejecutar una sesión y obtener los valores para usar. later para cálculos adicionales.

En el siguiente ejemplo, podrá:

  • Crea dos tensores
  • Crear una operadesarrollo
  • Abrir una sesión
  • Imprime el resultado

Paso 1) Creas dos tensores x e y

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

Paso 2) Tu creas el operator multiplicando x e y

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

Paso 3) Abres una sesión. Todos los cálculos se realizarán dentro de la sesión. Cuando haya terminado, deberá cerrar la sesión.

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

Salida

[8]

Explicación del código

  • tf.Session(): abre una sesión. Todos operaLas ciones fluirán dentro de las sesiones.
  • ejecutar (multiplicar): ejecutar el operación creada en el paso 2.
  • print(result_1): Finalmente, puedes imprimir el resultado
  • close(): Cierra la sesión

El resultado muestra 8, que es la multiplicación de x e y.

Otra forma de crear una sesión es dentro de un bloque. La ventaja es que cierra automáticamente la sesión.

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

Salida

[8]

En el contexto de la sesión, puede utilizar el método eval() para ejecutar el operación. Es equivalente a ejecutar(). Hace que el código sea más readable.

Puede crear una sesión y ver los valores dentro de los tensores que creó hasta ahora.

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

Salida

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

Las variables están vacías de forma predeterminada, incluso después de crear un tensor. Debe inicializar la variable si desea utilizarla. Es necesario llamar al objeto tf.global_variables_initializer() para inicializar los valores de una variable. Este objeto inicializará explícitamente todas las variables. Esto es útil antes de entrenar un modelo.

Puede verificar los valores de las variables que creó antes. Tenga en cuenta que necesita usar run para evaluar el tensor

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

Salida

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

Puede utilizar el marcador de posición que creó antes y alimentarlo con el valor real. Debes pasar los datos al método feed_dict.

Por ejemplo, tomarás la potencia de 2 del marcador de posición 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.

Explicación del código

  • importar numpy como np: Importar biblioteca numerosa para crear los datos
  • tf.pow(data_placeholder_a, 2): crea las operaciones
  • np.random.rand(1, 10): crea una matriz aleatoria de datos
  • feed_dict={data_placeholder_a: data}: alimenta el marcador de posición con datos

Salida

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

Gráfico

TensorFlow depende de un enfoque genial para renderizar el operación. Todos los cálculos se representan con un esquema de flujo de datos. El gráfico de flujo de datos se ha desarrollado para ver las dependencias de datos entre individuos operación. Las fórmulas o algoritmos matemáticos están formados por una serie de sucesivos operaciones. Un gráfico es una forma conveniente de visualizar cómo se coordinan los cálculos.

El gráfico muestra un nodo y una Edge. El nodo es la representación de un operación, es decir, la unidad de cálculo. El borde es el tensor, puede producir un nuevo tensor o consumir los datos de entrada. Depende de las dependencias entre individuos. operación.

La estructura del gráfico conecta entre sí los operaciones (es decir, los nodos) y cómo se operación son alimentos. Tenga en cuenta que el gráfico no muestra la salida del operaciones, sólo ayuda a visualizar la conexión entre individuos operaiones

Veamos un ejemplo.

Imagina que quieres evaluar el seguimiento.wing función:

Gráfico

TensorFlow creará un gráfico para ejecutar la función. El gráfico se ve así:

Ejemplo de gráfico de TensorFlow

Ejemplo de gráfico de TensorFlow

Puedes ver fácilmente el camino que tomarán los tensores para llegar al destino final.

Por ejemplo, puedes ver el operaLa adición de información no se puede realizar antes y . El gráfico explica que:

  1. calcular y:
  2. sumar 1) juntos
  3. añadir a 2)
  4. añadir 3) a
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

Explicación del código

  • x: inicializa una variable llamada x con un valor constante de 5
  • z: inicializa una variable llamada z con un valor constante de 6
  • c: Inicializa un tensor constante llamado c con un valor constante de 5
  • cuadrado: inicializa un tensor constante llamado cuadrado con un valor constante de 2
  • f: Construir el operator

En este ejemplo, elegimos mantener fijos los valores de las variables. También creamos un tensor constante llamado c que es el parámetro constante en la función f. Toma un valor fijo de 5. En el gráfico puedes ver este parámetro en el tensor llamado constante.

También construimos un tensor constante para la potencia en el operator tf.pow(). No es necesario. Lo hicimos para que puedas ver el nombre del tensor en el gráfico. Es el círculo llamado cuadrado.

En el gráfico, puedes entender qué sucederá con los tensores y cómo pueden devolver una salida de 66.

El siguiente código evalúa la función en una sesión.

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)

Salida

[66]

Resumen

TensorFlow funciona alrededor de:

  • Gráfico: Entorno computacional que contiene el operaciones y tensores
  • Tensores: Representa los datos (o valor) que fluirán en el gráfico. Es el borde en el gráfico.
  • Talleres: Permitir la ejecución del operaSupuestos de Alcance

Crea un tensor constante

constante objeto
D0 tf.constante(1, tf.int16)
D1 tf.constante([1,3,5], tf.int16)
D2 tf.constante([ [1, 2], [3, 4] ],tf.int16)
D3 tf.constant([ [[1, 2],[3, 4], [5, 6]] ], tf.int16)

Crear una operator

Crear una operator Objeto
a + b tf.add(a, b)
a * b tf.multiplicar(a, b)

Crear un tensor variable

Crea una variable objeto
valor aleatorio tf.get_variable(“var”, [1, 2])
primer valor inicializado tf.get_variable(“var_init_2”, dtype=tf.int32, inicializador=[ [1, 2], [3, 4] ])

Abrir una sesión

Sesión objeto
Crear una sesión tf.Session ()
Ejecutar una sesión tf.Session.run()
Evaluar un tensor nombre_variable.eval()
Cerrar una sesión sess.cerrar()
Sesión por bloque con tf.Session() como sesión: