Modelo entrenado en Tensorflow, cómo llamarlo
Para usar TensorFlow, debes comprender TensorFlow:
Utiliza gráficos para representar tareas computacionales.
El gráfico se ejecuta dentro de un contexto llamado sesión.
Utilizar tensores para representar datos.
Conservar el estado mediante variables.
Utilizando feed and fetch, puedes asignar un valor u obtener datos de cualquier operación.
Descripción general
TensorFlow es un sistema de programación que utiliza gráficos para representar tareas computacionales. Los nodos del gráfico se denominan operaciones
(abreviatura de operaciones). Una operación toma 0 o más tensores, realiza un cálculo y produce 0 o más tensores. Cada tensor es una matriz multidimensional escrita.
Por ejemplo, puede representar un pequeño conjunto de imágenes como una matriz de cuatro dimensiones de números de punto flotante,
las cuatro dimensiones son [lote, alto, ancho, canales].
Los gráficos de TensorFlow describen cálculos. Para realizar cálculos, el gráfico debe iniciarse en una sesión.
Session distribuye operaciones de gráficos a dispositivos como CPU o GPU y proporciona métodos para realizar operaciones.
Estos métodos devolverán el tensor de resultados después de la ejecución. En Python, el tensor devuelto es un
objeto ndarray numpy; en C y C++, el tensor devuelto es una
instancia de tensorflow::Tensor.
Gráfico computacional
Los programas de TensorFlow generalmente se dividen en una fase de construcción y una fase de ejecución. Durante la fase de construcción, los pasos de ejecución de una operación
se describen en forma de gráfico.
Por ejemplo, es común crear un gráfico para representar y entrenar una red neuronal durante la fase de construcción y luego realizar de forma iterativa las operaciones de entrenamiento en el gráfico durante la fase de ejecución.
TensorFlow admite los lenguajes de programación C, C++ y Python.
TensorFlow admite los lenguajes de programación C, C++ y Python. Actualmente, la biblioteca Python de TensorFlow es más fácil de usar y proporciona muchas funciones auxiliares para simplificar la construcción de gráficos que aún no son compatibles con las bibliotecas C y C++.
Las bibliotecas de conversación son consistentes en los tres idiomas.
Creación de un gráfico
El primer paso para crear un gráfico es crear una operación fuente. Las operaciones de origen no requieren ninguna entrada, como constantes. La salida de la operación de origen se pasa a otras operaciones para realizar la operación.
En las bibliotecas de Python, el valor de retorno de un constructor de operaciones representa la salida de la operación construida, que se puede pasar como entrada a otros
constructores de operaciones.
La biblioteca TensorFlow Python tiene un gráfico predeterminado al que los constructores de operaciones pueden agregar nodos. Porque
este gráfico predeterminado es suficiente para muchos programas. Lea la documentación de gráficos
para aprender cómo administrar múltiples gráficos.
importar tensorflow como tf
# Crea una operación constante que genera una matriz de 1x2. Esta operación se agregará como un nodo al gráfico predeterminado
#.
#
# El valor de retorno del constructor representa el valor de retorno de la operación constante.
matrix1 = tf.constant([[3., 3.]])
# Crea otra operación constante, generando una matriz de 2x1.
matrix2 = tf.constant([[2.], [2.]])
# Tome "matrix1" y "matrix2" como entradas para crear una operación matmul de multiplicación de matrices .
# El valor de retorno "producto" representa el resultado de la multiplicación de matrices.
product = tf.matmul(matrix1, Matrix2)
El gráfico predeterminado ahora tiene tres nodos, dos operaciones constantes() y una operación matmul(). Para realizar realmente la multiplicación de matrices y obtener el resultado de la multiplicación de matrices
, debe iniciar gráficos en una sesión.
Inicio de gráficos en sesión
Un gráfico solo se puede iniciar después de que se complete la fase de construcción. El primer paso para iniciar un gráfico es crear un objeto de sesión. Si no se crean parámetros, el constructor de la sesión iniciará el gráfico predeterminado.
Para conocer la API de sesión completa, lea sobre la clase de sesión.
# Inicia los gráficos predeterminados.
sess = tf.Session()
# Llame al método "run()" de sess para realizar la operación de multiplicación de matrices y pase "producto" como parámetro del método.
## Como se mencionó anteriormente, "producto" representa el resultado de la operación de multiplicación de matrices. Pasarlo como parámetro a este método indica que queremos obtener el resultado de la operación de multiplicación de matrices. >
##
#
# Todo el proceso de ejecución está automatizado y la sesión es responsable de pasar toda la entrada requerida para la operación. Las operaciones generalmente se realizan al mismo tiempo.
#
# La llamada a la función "run(product) " desencadena la ejecución de tres operaciones en el gráfico (dos operaciones constantes y una operación de multiplicación de matrices).
#
## El valor de retorno "resultado" es un objeto `ndarray` numpy.
resultado = sess.run(producto)
imprimir resultado
# ==> [[ 12.]]
# Tarea Listo, cierra la sesión.
sess.close()
El objeto de sesión debe cerrarse después de su uso para liberar recursos. Además de llamar a cerrar explícitamente, también puedes usar un bloque "con"
para realizar automáticamente la operación de cierre.
con tf.Session() como sess:
resultado = sess.run([producto])
imprimir resultado
en En cuanto a la implementación, TensorFlow convierte las definiciones de gráficos en operaciones que se ejecutan de manera distribuida para aprovechar los recursos informáticos disponibles (como CPU
o GPU). En términos generales, no es necesario especificar explícitamente si se utiliza la CPU o la GPU; TensorFlow lo detecta automáticamente. Si se detecta una GPU, TensorFlow
intentará realizar la operación utilizando la primera GPU encontrada.
Si hay más de una GPU disponible en la máquina, de forma predeterminada todas menos la primera GPU se excluirán del cálculo. Para que TensorFlow
utilice estas GPU, debes asignarles operaciones explícitamente. La instrucción with.....Device se utiliza para especificar una CPU o GPU específica
Realice la operación:
con tf.Session() como sess:
con tf.device("/gpu:1"):
matrix1 = tf.constant([[3., 3. ]])
matrix2 = tf.constant ([[ 2.], [2.]])
producto = tf.matmul(matrix1, Matrix2)
...
El dispositivo está identificado por una cadena. Los dispositivos actualmente compatibles incluyen:
"/cpu:0": la CPU de la máquina.
"/gpu:0": Primera GPU de la máquina (si la tiene).
"/gpu:1": la segunda GPU de la máquina, y así sucesivamente.
Lea la sección "Uso de GPU" para obtener más información sobre el uso de GPU por parte de TensorFlow.
Uso interactivo
Los ejemplos de Python en la documentación usan sesiones para
iniciar el gráfico y llamar al método Session.run() para realizar operaciones.
Para facilitar su uso en entornos interactivos de Python como IPython, puede usar
InteractiveSession en lugar de la
clase Session y usar Tensor.eval()
y los métodos Operation.run() en lugar de
Session.run()
Session. Esto evita el uso de variables para guardar sesiones.
# Ingrese a una sesión interactiva de TensorFlow.
importar tensorflow como tf
sess = tf.InteractiveSession()
x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])
# Inicializa 'x' usando el método run() de la operación de inicialización
x.initializer.run()
# Agrega una suboperación de resta para restar 'a' de 'x'. Ejecute la operación de resta y genere el resultado
sub = tf.sub(x, a)
print sub.eval()
# ==> [ - 2. -1.]
Tensor
Los programas TensorFlow utilizan estructuras de datos tensoriales para representar todos los datos. En un gráfico computacional, los datos que se pasan entre operaciones son un tensor.
Puedes pensar en un tensor de TensorFlow como una matriz o lista de n dimensiones. Un tensor contiene un nivel de tipo estático y
una forma. Para comprender cómo TensorFlow maneja estos conceptos, consulte
Niveles, formas y tipos.
Variables
Variables para más detalles. El siguiente ejemplo muestra cómo implementar un contador simple usando variables. Consulte el capítulo
Variables para obtener más información.
#Crea una variable, inicializada al escalar 0.
state = tf.Variable(0, name="counter")
#Crea una operación, Su función es aumentar el estado en 1
one = tf.constant(1)
new_value = tf.add(state)
new_value = tf. agregar( estado)
Nuevo_valor = tf.add(estado)
Nuevo_valor = tf.add(estado)
Nuevo_valor = tf.add(estado)