Conceptos básicos de TensorFlow: tensor, forma, tipo, sesiones y amp; Operadores

Tabla de contenido:

Anonim

¿Qué es un tensor?

El nombre de Tensorflow se deriva directamente de su marco principal: 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 arreglo.

Un tensor puede originarse a partir de los datos de entrada o el resultado de un cálculo. En TensorFlow, todas las operaciones se realizan dentro de un gráfico. El gráfico es un conjunto de cálculos que se realizan sucesivamente. Cada operación se denomina nodo operativo y están conectados entre sí.

El gráfico describe las operaciones y las conexiones entre los nodos. Sin embargo, no muestra los valores. El borde de los nodos es el tensor, es decir, una forma de poblar la 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 de operación a través del tensor y el resultado de esta operación / cálculo creará un nuevo tensor que a su vez se usará en una nueva operación. Todas estas operaciones se pueden visualizar en el gráfico.

En este tutorial, aprenderá los conceptos básicos de TensorFlow como-

  • ¿Qué es un tensor?
  • Representación de un tensor
  • Tipos de tensor
  • Crea un tensor de dimensión n
  • Forma de tensor
  • Tipo de datos
  • Operador de creación
  • Algunos operadores útiles de TensorFlow
  • Variables
  • Marcador de posición
  • Sesión
  • Grafico

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 2x3 con valores de 1 a 6, escribimos:

Representación de un tensor

TensorFlow representa esta matriz como:

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

Si creamos una matriz tridimensional con valores de 1 a 8, tenemos:

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. 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 operación que harás con TensorFlow implica la manipulación de un tensor. Hay cuatro tipos de tensor principales que puede crear:

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

En este tutorial, aprenderá a crear un tf.constant y un tf.Variable.

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

Para usuarios de MacOS:

source activate hello-tf 

Para usuarios de Windows:

activate hello-tf 

Una vez que haya hecho eso, estará listo para importar tensorflow

# Import tfimport tensorflow as tf 

Crea un tensor de dimensión n

Comienzas 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 el siguiente código

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

Producción

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

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

Producción

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

Cada tensor se muestra con el nombre del tensor. Cada objeto de tensor se define con atributos de tensor como una etiqueta única (nombre), una dimensión (forma) y tipos de datos de TensorFlow (dtype).

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

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

Producción

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

Se puede crear un tensor de dimensión 1 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) 

Producción

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 de tensor, debe cerrar los corchetes después de cada fila. Verifique el ejemplo de la forma del tensor de Keras a continuación

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

Producción

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

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

Se construye una matriz con 3 dimensiones agregando otro nivel con los corchetes.

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

Producción

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

La matriz se parece a la imagen dos.

Forma de tensor

Cuando imprime tensor, TensorFlow adivina la forma. Sin embargo, puede obtener la forma del tensor con la propiedad de forma TensorFlow.

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

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

Producción

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

La matriz tiene 3 filas y 2 columnas.

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

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

Producción

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

La propiedad también funciona para matrix. Aquí, crea una matriz de 10x10 rellena con 1

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

Producción

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 es una dimensión de 3x2. Puede crear un tensor con 3 filas llenas de uno con el siguiente código:

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

Producción

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

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

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

Producción

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

Finalmente, puede crear una matriz 3x2 con solo uno

print(tf.ones(m_shape.shape)) 

Producción

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 solo puede tener un tipo de datos a la vez. Un tensor solo puede tener un tipo de datos. Puede devolver el tipo con la propiedad dtype.

print(m_shape.dtype) 

Producción

 

En algunas ocasiones, 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 en entero usando el método cast.

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

Producción


 

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 lo convertirá en una cadena.

Operador de creación

Algunos operadores útiles de TensorFlow

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

TensorFlow contiene todas las operaciones básicas. Puede comenzar con uno simple. Usarás el método TensorFlow para calcular el cuadrado de un número. Esta operación es sencilla porque solo 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)) 

Producción

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 de la operación. En la siguiente sección, aprenderá cómo funciona TensorFlow para ejecutar las operaciones.

A continuación se muestra una lista de las operaciones más utilizadas. La idea es la misma. Cada operación requiere uno o más argumentos.

  • tf.add (a, b)
  • tf.substract (a, b)
  • tf.multiply (a, b)
  • tf.div (a, b)
  • tf.pow (a, b)
  • tf.exp (a)
  • tf.sqrt (a)

Ejemplo

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

Producción

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 : ambos tensores deben tener la misma forma. Puede ejecutar una multiplicación sobre los dos tensores.

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

Producción

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

Variables

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

Para crear una variable, puede usar 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. OptionalIf 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. Tu nombras la variable var

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

Producción

(1, 2) 

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

Los valores iniciales de este tensor son cero. Por ejemplo, cuando entrena un modelo, necesita 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) 

Producción

(1, 2) 

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

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

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

Producción

(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á solo 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 real del tensor.

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. Optionaldata_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")print(data_placeholder_a) 

Producción

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

Sesión

TensorFlow funciona en torno a 3 componentes principales:

  • Grafico
  • Tensor
  • Sesión
Componentes Descripción

Grafico

El gráfico es fundamental en TensorFlow. Todas las operaciones matemáticas (ops) se realizan dentro de un gráfico. Puede imaginar un gráfico como un proyecto en el que se realizan todas las operaciones. Los nodos representan estas operaciones, pueden absorber o crear nuevos tensores.

Tensor

Un tensor representa los datos que progresan entre operaciones. Anteriormente viste 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á la operación desde el gráfico. Para alimentar el gráfico con los valores de un tensor, debe abrir una sesión. Dentro de una sesión, debe ejecutar un operador para crear una salida.

Los gráficos y las sesiones son independientes. Puede ejecutar una sesión y obtener los valores para usarlos más tarde en otros cálculos.

En el siguiente ejemplo, podrá:

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

Paso 1) Creas dos tensores xey

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

Paso 2) Creas el operador multiplicando xey

## Create operatormultiply = 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, debe cerrar la sesión.

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

Producción

[8] 

Explicación del código

  • tf.Session (): abre una sesión. Todas las operaciones fluirán dentro de las sesiones
  • ejecutar (multiplicar): ejecuta la 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 xey.

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) 

Producción

[8] 

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

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

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

Producción

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. El objeto tf.global_variables_initializer () necesita ser llamado para inicializar los valores de una variable. Este objeto inicializará explícitamente todas las variables. Esto es útil antes de entrenar a un modelo.

Puede verificar los valores de las variables que creó antes. Tenga en cuenta que debe usar ejecutar 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)) 

Producción

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

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

Por ejemplo, tomará el poder de 2 del marcador de posición data_placeholder_a.

import numpy as nppower_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 as np: importar la biblioteca numpy 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

Producción

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

Grafico

TensorFlow depende de un enfoque genial para renderizar la 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 operaciones individuales. La fórmula matemática o el algoritmo se componen de una serie de operaciones sucesivas. Un gráfico es una forma conveniente de visualizar cómo se coordinan los cálculos.

El gráfico muestra un nodo y un borde . El nodo es la representación de una 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 operaciones individuales.

La estructura del gráfico conecta las operaciones (es decir, los nodos) y cómo se alimentan esas operaciones. Tenga en cuenta que el gráfico no muestra el resultado de las operaciones, solo ayuda a visualizar la conexión entre las operaciones individuales.

Veamos un ejemplo.

Imagina que quieres evaluar la siguiente función:

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

Ejemplo de gráfico de TensorFlow

Se puede ver fácilmente el camino que seguirán los tensores para llegar al destino final.

Por ejemplo, puede ver que la operación agregar no se puede realizar antes y. El gráfico explica que:

  1. calcular y:
  2. sumar 1) juntos
  3. agregar a 2)
  4. agregar 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: Construye el operador

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 la gráfica, puedes ver este parámetro en el tensor llamado constante.

También construimos un tensor constante para la potencia en el operador 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.

A partir del gráfico, puede comprender qué pasará con los tensores y cómo puede 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 variableswith tf.Session() as sess:init.run() # Initialize x and yfunction_result = f.eval()print(function_result) 

Producción

[66] 

Resumen

TensorFlow funciona en torno a:

  • Gráfico : entorno computacional que contiene las operaciones y tensores
  • Tensores : representa los datos (o valor) que fluirán en el gráfico. Es el borde en el gráfico.
  • Sesiones : Permitir la ejecución de las operaciones

Crea un tensor constante

constante objeto

D0

tf.constant (1, tf.int16)

D1

tf.constant ([1,3,5], tf.int16)

D2

tf.constant ([[1, 2], [3, 4]], tf.int16)

D3

tf.constant ([[[1, 2], [3, 4], [5, 6]]], tf.int16)

Crea un operador

Crea un operador Objeto

a + b

tf.add (a, b)

a * b

tf.multiply (a, b)

Crea 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, initializer = [[1, 2], [3, 4]])

Abrir una sesión

Sesión objeto

Crea una sesión

tf.Session ()

Ejecutar una sesión

tf.Session.run ()

Evaluar un tensor

nombre_variable.eval ()

Cerrar una sesión

sess.close ()

Sesión por bloque

con tf.Session () como sess: