Cómo llamar al modelo entrenado por tensorflow
Uso básico
Para usar TensorFlow, debes comprender TensorFlow:
Usa gráficos para representar tareas informáticas.
Antes de ser un gráfico de ejecución en un contexto llamado sesión.
Usa tensor para representar datos.
Mantiene el estado a través de variables.
Usa feed y fetch para asignar valores u obtener datos de operaciones arbitrarias.
Descripción general
TensorFlow es un sistema de programación que utiliza gráficos para representar tareas informáticas. En la figura, el nodo se llama op
(abreviatura de. operación). Una operación obtiene 0 o más tensores, realiza cálculos y
produce 0 o más tensores. Cada tensor es una matriz multidimensional escrita.
Por ejemplo, puede hacerlo. representan 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].
Un gráfico de TensorFlow describe el proceso de cálculo Para realizar cálculos, el gráfico debe iniciarse en una sesión.
La sesión distribuye las operaciones del gráfico a CPU como O en dispositivos como GPU, y también proporciona métodos para. ejecutando op.
Después de ejecutar estos métodos, se devolverá el tensor generado. En el lenguaje Python, el tensor devuelto es
objeto ndarray numpy en los lenguajes C y C; El tensor devuelto es
tensorflow::Instancia de tensor.
Gráfico computacional
Los programas de TensorFlow generalmente se organizan en la fase de construcción y una fase de ejecución en la fase de construcción. , los pasos de ejecución de la operación
se describen como un gráfico. En la fase de ejecución, las sesiones se utilizan para ejecutar las operaciones en el gráfico de ejecución.
Por ejemplo, normalmente se utiliza un gráfico. creado para representar y entrenar la red neuronal durante la fase de construcción, y luego las operaciones de entrenamiento en el gráfico se ejecutan repetidamente durante la fase de ejecución.
TensorFlow admite los lenguajes de programación C, C y Python. Actualmente, TensorFlow. La biblioteca Python es más fácil de usar.
Proporciona una gran cantidad de funciones auxiliares para simplificar el trabajo de creación de gráficos. Estas funciones aún no son compatibles con las bibliotecas C y C.
Las bibliotecas de sesión en tres idiomas) son consistentes.
Creación de un gráfico
El primer paso para crear un gráfico es crear una operación fuente. La operación fuente no requiere ninguna entrada, como por ejemplo. como constantes. La salida de la operación fuente se pasa a otras operaciones para su operación.
En la biblioteca de Python, el valor de retorno del constructor de la operación representa la salida de la operación construida. Estos valores de retorno pueden. se pasará a otras operaciones
constructor de operaciones como entrada.
La biblioteca TensorFlow Python tiene un gráfico predeterminado para el cual el constructor de operaciones puede agregar nodos. Este gráfico predeterminado es útil para
muchos programas. Se dice que es suficiente. Lea la documentación de la clase Graph
para aprender a administrar múltiples gráficos.
importar tensorfl.
ow como tf
# Crea una operación constante, produciendo una matriz de 1x2. Esta operación se agrega como un nodo
# al gráfico predeterminado.
#<. /p>
# 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.]])
# Crea una multiplicación de matrices matmul op, toma 'matrix1' y 'matrix2' como entrada.
# El valor de retorno 'producto' representa el resultado de la multiplicación de matrices.
product = tf.matmul(matrix1, matriz2)
El gráfico predeterminado ahora tiene tres nodos, dos operaciones constantes () y una operación matmul(). Para realizar realmente la operación de multiplicación de matrices y obtener el resultado de la multiplicación de matrices, debe hacer esto. El gráfico debe iniciarse en una sesión.
Iniciar el gráfico en una sesión
El gráfico solo se puede iniciar después de que se complete la fase de construcción. El primer paso para iniciar el gráfico es. cree un objeto de sesión. Si no hay ningún parámetro de creación,
el constructor de la sesión iniciará el gráfico predeterminado.
Para obtener la API de sesión completa, lea la clase de sesión.
# Iniciar el gráfico predeterminado.
sess = tf.Session()
# Llame al método 'run()' de sess para realizar la operación de multiplicación de matrices, pasando 'producto' como parámetro del método.
# Como se mencionó anteriormente, 'producto' representa la salida de la operación de multiplicación de matrices. Pasarlo indica el método que queremos recuperar.
# La salida 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 todas las entradas requeridas por la operación. La operación generalmente se ejecuta 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) .
#
# Retorno El valor 'resultado' es un objeto numpy `ndarray`.
resultado = sess.run(product)
imprimir resultado
# ==gt; [[ 12.]]
# Una vez completada la tarea, cierre la sesión.
sess. close()
El objeto Session debe cerrarse después de su uso para liberar recursos. Excepto que además de llamar explícitamente a close, también puedes usar el bloque de código "with"
para hacerlo automáticamente. completar la acción de cierre.
con tf.Session() como sess:
resultado = sess.run([producto])
imprimir resultado
En la implementación, TensorFlow convierte las definiciones de gráficos en operaciones de ejecución distribuida para hacer un uso completo de los recursos informáticos disponibles (como CPU
Generalmente no es necesario especificar explícitamente si se usa CPU). o GPU, TensorFlow puede detectarla automáticamente. Si se detecta una GPU, TensorFlow
hará todo lo posible para utilizar la encontrada.
La primera GPU que realiza la operación.
Si hay más de una GPU disponible en la máquina, las otras GPU excepto la primera no participarán en el cálculo de forma predeterminada para permitir TensorFlow.
p>
Para usar estas GPU, debe asignarles explícitamente la operación para su ejecución. La instrucción with...Device se usa para asignar una CPU o GPU específica para realizar la operación:
with. tf.Session() como sesión:
con tf.device("/gpu:1"):
matriz1 = tf.constant([[3., 3.]] )
matriz2 = tf.constant([[2.], [2.]])
producto = tf.matmul(matriz1, matriz2)
...
El dispositivo se identifica mediante una cadena. Los dispositivos actualmente compatibles incluyen:
"/cpu:0": la CPU de la máquina.
"/ gpu:0" : La primera GPU de la máquina, si la hay.
"/gpu:1": La segunda GPU de la máquina, y así sucesivamente.
Lea el capítulo sobre el uso de GPU, obtenga más información sobre el uso de TensorFlow GPU.
Uso interactivo
El ejemplo de Python en la documentación utiliza una sesión para
iniciar el gráfico y llamar al Session. El método run() realiza la operación.
Para facilitar el uso de entornos interactivos de Python como IPython, puede utilizar
InteractiveSession en lugar de
y Operation.run() en su lugar
Session.run(). Esto evita el uso de una variable para mantener la sesión.
p>
# Ingrese a una sesión interactiva de TensorFlow.
importe tensorflow como tf
sess = tf.InteractiveSession()
x = tf.Variable( [1.0, 2.0] )
a = tf.constant([3.0, 3.0])
# Utilice el método run() de la operación inicializadora para inicializar 'x'
x .initializer.run()
# Agregue una suboperación de resta, reste 'a' de 'x' Ejecute la operación de resta y genere el resultado
. sub = tf.sub(x , a)
imprimir sub.eval()
# ==gt [-2.]
Tensor
Los programas TensorFlow utilizan estructuras de datos tensoriales para representar todos los datos. En el gráfico de cálculo, los datos pasados entre operaciones son tensores.
Puedes pensar en el tensor de TensorFlow como un tensor de n dimensiones. matriz o lista A Un tensor contiene un rango de tipo estático y
una forma. Para comprender cómo TensorFlow maneja estos conceptos, consulte
Rango, forma y tipo.
p>
Variables
Variables para obtener más detalles.
Las variables mantienen la información de estado durante la ejecución del gráfico. El siguiente ejemplo demuestra cómo usar variables para implementar un contador simple. p>
Consulte el capítulo Variables para obtener más detalles.
# Cree una variable, inicializada a escalar 0.
state = tf.Variable(0, name="counter " )
# Crea una operación, cuya función es aumentar el estado en 1
one = tf.constant(1)
new_value = tf.add(state , one)
update = tf.assign(state, new_value)
# Después de iniciar el gráfico, las variables primero deben inicializarse mediante `initialization` (init) op,
# Primero, debes agregar una operación de `inicialización` al gráfico.
init_op = tf.initialize_all_variables()
# Inicie el gráfico y ejecute la operación
con tf.Session() como sess:
# Ejecutar 'init' op
sess.run(init_op)
# Imprimir el valor inicial de 'estado'
print sess.run(estado)
# Ejecute la operación, actualice 'estado' e imprima 'estado'
para _ en rango(3):
sess.run(actualización)
imprimir sess.run(estado)
# Salida:
# 0
# 1
# 2
# 3
La operación asignar() en el código es parte de la expresión representada en la figura, al igual que la operación add() Lo mismo. Entonces, antes de llamar a run()
antes de ejecutar la expresión, en realidad no realizará la operación de asignación.
Por lo general, Los parámetros en un modelo estadístico se representan como un conjunto de variables. Por ejemplo, puede almacenar los pesos de una red neuronal como una variable en un tensor.
Durante el proceso de entrenamiento, el tensor se actualiza repetidamente. ejecutando el gráfico de entrenamiento.
Fetch
Para recuperar el contenido de salida de la operación, puede pasar algunos tensores al llamar al gráfico de ejecución usando run() del objeto Session .
Estos tensores le ayudarán a recuperar los resultados. En el ejemplo anterior, solo recuperamos un único estado de nodo, pero también puede recuperar varios
tensor:
.entrada1 = tf.constant(3.0)
p>entrada2 = tf.constant(2.0)
entrada3 = tf.constant(5.0)
intermed = tf.add(input2, input3)
mul = tf.mul(input1, intermed)
con tf.Session() como sess:
resultado = sess.run([mul, intermed])
imprimir resultado
t
# Salida:
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]
Los múltiples valores de tensor que deben obtenerse se obtienen juntos en una operación de la operación (en lugar de obtener los tensores uno por uno).
Alimentación
El ejemplo anterior introduce el tensor en el gráfico de cálculo y lo almacena en forma de constantes o variables. TensorFlow también proporciona un mecanismo de alimentación, que
puede reemplazar temporalmente un tensor en cualquier operación en el gráfico. Puede enviar un parche a cualquier operación en el gráfico e insertar directamente un tensor.
feed reemplaza temporalmente la salida de una operación con un valor de tensor. puede proporcionar datos del feed como parámetros de la llamada run().
El feed solo es válido dentro del método que lo llama. Cuando el método finaliza, el feed desaparecerá. El caso de uso más común es especificar. algunas operaciones especiales como operaciones de "alimentación".
La forma de marcar es usar tf.placeholder() para crear marcadores de posición para estas operaciones.
input1 = tf.placeholder(tf. float32)
entrada2 = tf.placeholder(tf.float32)
salida = tf.mul(input1, input2)
con tf.Session() como sess:
print sess.run([salida], feed_dict={entrada1:[7.], entrada2:[2.]})
# Salida:
# [array([ 14. ], dtype=float32)]
para ver un ejemplo de feeds a mayor escala.
Si el feed no se proporciona correctamente, el marcador de posición () generará un error.
Tutorial de feed totalmente conectado de MNIST
(código fuente)
Da un ejemplo del uso de feeds a mayor escala.