TensorFlow es una biblioteca open source desarrollada por Google que nos permite realizar cálculos numéricos usando diagramas de flujo de datos. Los nodos del gráfico representan operaciones matemáticas, mientras que los bordes del gráfico representan los arreglos de datos multidimensionales (tensores) comunicados entre ellos. Esta arquitectura flexible le permite realizar los cálculos en más de un CPU o GPU utilizando la misma API.
Los diagramas de flujo de datos describen cálculos matemáticos con un gráfico de direcciones de nodos y bordes. Los nodos normalmente implementan operaciones matemáticas, pero también pueden representar los puntos para alimentarse de datos, devolver resultados, o leer / escribir variables persistentes. Los bordes describen las relaciones de entrada / salida entre los nodos. Estos bordes están representados por los arreglos de datos multidimensionales o tensores. El flujo de los tensores a través del gráfico es de donde TensorFlow recibe su nombre. Los nodos se asignan a los dispositivos computacionales y se ejecutan de forma asincronica y en paralelo una vez que todos los tensores en los bordes de entrada están disponibles.
# importamos librerias
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import seaborn as sns
%matplotlib inline
# Creación de Constantes
# El valor que retorna el constructor es el valor de la constante.
# creamos constantes a=2 y b=3
a = tf.constant(2)
b = tf.constant(3)
# Todo en TensorFlow ocurre dentro de una Sesión
# creamos la sesion y realizamos algunas operaciones con las constantes
# y lanzamos la sesión
with tf.Session() as sess:
print("Suma de las constantes: {}".format(sess.run(a+b)))
print("Multiplicación de las constantes: {}".format(sess.run(a*b)))
print("Constante elevada al cubo: {}".format(sess.run(a**3)))
Suma de las constantes: 5 Multiplicación de las constantes: 6 Constante elevada al cubo: 8
# Utilizando variables simbólicas en los grafos
# El valor que devuelve el constructor representa el la salida de la
# variable (la entrada de la variable se define en la sesion)
# Creamos dos variables de tipo integer
a = tf.placeholder(tf.int16)
b = tf.placeholder(tf.int16)
# Defininimos algunas operaciones con estas variables
suma = tf.add(a, b)
mult = tf.mul(a, b)
# Iniciamos la sesion
with tf.Session() as sess:
# ejecutamos las operaciones con cualquier imput que quisiésemos
print("suma con variables: {}".format(sess.run(suma,
feed_dict={a: 4, b: 5})))
print("Multiplicación con variables: {}".format(sess.run(mult,
feed_dict={a: 4, b: 5})))
suma con variables: 9 Multiplicación con variables: 20
# Creamos las matrices como constantes
# matrices de 3x3
matriz1 = tf.constant([[1, 3, 2],
[1, 0, 0],
[1, 2, 2]])
matriz2 = tf.constant([[1, 0, 5],
[7, 5, 0],
[2, 1, 1]])
# suma de matrices
suma = tf.add(matriz1, matriz2)
# producto de matrices
mult = tf.matmul(matriz1, matriz2)
# lanzamos la sesion
with tf.Session() as sess:
print("Suma de matrices: \n{}".format(sess.run(suma)))
print("Producto de matrices: \n{}".format(sess.run(mult)))
Suma de matrices: [[2 3 7] [8 5 0] [3 3 3]] Producto de matrices: [[26 17 7] [ 1 0 5] [19 12 7]]
# importando el dataset
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
Extracting MNIST_data/train-images-idx3-ubyte.gz Extracting MNIST_data/train-labels-idx1-ubyte.gz Extracting MNIST_data/t10k-images-idx3-ubyte.gz Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
# forma del dataset 55000 imagenes
mnist.train.images.shape
(55000, 784)
# cada imagen es un array de 28x28 con cada pixel
# definido como escala de grises.
digito1 = mnist.train.images[0].reshape((28, 28))
# visualizando el primer digito
plt.imshow(digito1, cmap = cm.Greys)
plt.show()
# valor correcto
mnist.train.labels[0].nonzero()[0][0]
7
# 2da imagen como escala de grises
sns.heatmap(mnist.train.images[1].reshape((28, 28)), linewidth=0,
xticklabels=False, yticklabels=False)
plt.show()
# valor correcto
mnist.train.labels[1].nonzero()[0][0]
3
# visualizando imagenes de 5 en 5
def visualizar_imagenes(dataset, cant_img):
img_linea = 5
lineas = int(cant_img / img_linea)
imagenes = []
for i in range(lineas):
datos = []
for img in dataset[img_linea* i:img_linea* (i+1)]:
datos.append(img.reshape((28,28)))
imgs = np.hstack(datos)
imagenes.append(imgs)
data = np.vstack(imagenes)
plt.imshow(data, cmap = cm.Greys )
plt.show()
# visualizando los primeros 30 dígitos
plt.figure(figsize=(8, 8))
visualizar_imagenes(mnist.train.images, 30)
Un peceptron multicapa es una de las redes neuronales más simples.
# Parametros
learning_rate = 0.001
training_epochs = 15
batch_size = 100
display_step = 1
model_path = "/home/raul/python/notebooks/perceptron.ckpt"
logs_path = "/home/raul/python/notebooks/tensorflow_logs/perceptron"
# Parametros de la red
n_hidden_1 = 256 # 1ra capa de atributos
n_hidden_2 = 256 # 1ra capa de atributos
n_input = 784 # datos de MNIST(forma img: 28*28)
n_classes = 10 # Total de clases a clasificar (0-9 digitos)
# input para los grafos
x = tf.placeholder("float", [None, n_input], name='DatosEntrada')
y = tf.placeholder("float", [None, n_classes], name='Clases')
# Creamos el modelo
def multilayer_perceptron(x, weights, biases):
# Función de activación de la capa escondida
layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
layer_1 = tf.nn.relu(layer_1)
# Función de activación de la capa escondida
layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
layer_2 = tf.nn.relu(layer_2)
# Salida con activación lineal
out_layer = tf.matmul(layer_2, weights['out']) + biases['out']
return out_layer
# Definimos los pesos y sesgo de cada capa.
weights = {
'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes]))
}
biases = {
'b1': tf.Variable(tf.random_normal([n_hidden_1])),
'b2': tf.Variable(tf.random_normal([n_hidden_2])),
'out': tf.Variable(tf.random_normal([n_classes]))
}
with tf.name_scope('Modelo'):
# Construimos el modelo
pred = multilayer_perceptron(x, weights, biases)
with tf.name_scope('Costo'):
# Definimos las funciones de optimización
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
with tf.name_scope('optimizador'):
# optimización
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
with tf.name_scope('Precision'):
# Evaluar el modelo
correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
# Calcular la precisión
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# Inicializamos todas las variables
init = tf.initialize_all_variables()
# Crear sumarización para controlar el costo
tf.scalar_summary("Costo", cost)
# Crear sumarización para controlar la precisión
tf.scalar_summary("Precision", accuracy)
# Juntar los resumenes en una sola operación
merged_summary_op = tf.merge_all_summaries()
# Para guardar el modelo
saver = tf.train.Saver()
# Lanzamos la sesión
with tf.Session() as sess:
sess.run(init)
# op to write logs to Tensorboard
summary_writer = tf.train.SummaryWriter(
logs_path, graph=tf.get_default_graph())
# Entrenamiento
for epoch in range(training_epochs):
avg_cost = 0.
total_batch = int(mnist.train.num_examples/batch_size)
for i in range(total_batch):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Optimización por backprop y funcion de costo
_, c, summary = sess.run([optimizer, cost, merged_summary_op],
feed_dict={x: batch_x, y: batch_y})
# escribir logs en cada iteracion
summary_writer.add_summary(summary, epoch * total_batch + i)
# perdida promedio
avg_cost += c / total_batch
# imprimir información de entrenamiento
if epoch % display_step == 0:
print("Iteración: {0: 04d} costo = {1:.9f}".format(epoch+1,
avg_cost))
print("Optimización Terminada!\n")
print("Precisión: {0:.2f}".format(accuracy.eval({x: mnist.test.images,
y: mnist.test.labels})))
# guardar el modelo, luego lo podemos cargar con saver.restore
save_path = saver.save(sess, model_path)
print("Modelo guardado en archivo: {}".format(save_path))
print("Ejecutar el comando:\n",
"--> tensorboard --logdir=/home/raul/python/notebooks/tensorflow_logs ",
"\nLuego abir http://0.0.0.0:6006/ en el navegador")
Iteración: 001 costo = 154.608782424 Iteración: 002 costo = 39.210747598 Iteración: 003 costo = 24.637626623 Iteración: 004 costo = 17.070282675 Iteración: 005 costo = 12.371249576 Iteración: 006 costo = 9.227733847 Iteración: 007 costo = 6.931624266 Iteración: 008 costo = 5.172826406 Iteración: 009 costo = 3.764516824 Iteración: 010 costo = 2.755332070 Iteración: 011 costo = 2.159830156 Iteración: 012 costo = 1.559957338 Iteración: 013 costo = 1.147375912 Iteración: 014 costo = 0.837389279 Iteración: 015 costo = 0.794107030 Optimización Terminada! Precisión: 0.94 Modelo guardado en archivo: /home/raul/python/notebooks/perceptron.ckpt Ejecutar el comando: --> tensorboard --logdir=/home/raul/python/notebooks/tensorflow_logs Luego abir http://0.0.0.0:6006/ en el navegador
# Parametros
learning_rate = 0.001
training_iters = 200000
batch_size = 128
display_step = 10
model_path = "/home/raul/python/notebooks/red_conv.ckpt"
logs_path = "/home/raul/python/notebooks/tensorflow_logs/red_conv"
# Parametros de la red
n_input = 784 # datos de MNIST (forma img: 28*28)
n_classes = 10 # Total de clases a clasificar (0-9 digitos)
dropout = 0.75 # descarte, probabilidad para mantener las unidades
# input para los grafos
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])
keep_prob = tf.placeholder(tf.float32) # para descarte
# Creando funciones auxiliares y el modelo
def conv2d(x, W, b, strides=1):
# Conv2D con sesgo y activación relu.
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
return tf.nn.relu(x)
def maxpool2d(x, k=2):
# MaxPool2D
return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')
# Creando la rede
def conv_net(x, weights, biases, dropout):
# cambiando la forma de la imagen
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# capa de convulción 1
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling
conv1 = maxpool2d(conv1, k=2)
# capa de convulción 2
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling
conv2 = maxpool2d(conv2, k=2)
# capa de conexiones
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# aplicando el descarte
fc1 = tf.nn.dropout(fc1, dropout)
# Salida, predicción de la clase.
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
return out
# Definimos los pesos y sesgo de cada capa.
weights = {
# 5x5 conv, 1 entrada, 32 salidas
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 entradas, 64 salidas
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# totalmente conectada, 7*7*64 entradas, 1024 salidas
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 entradas, 10 salidas (prediccion)
'out': tf.Variable(tf.random_normal([1024, n_classes]))
}
biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([n_classes]))
}
# Construcción del modelo
pred = conv_net(x, weights, biases, keep_prob)
# definiendo las funciones de optimización
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Evaluando el modelo
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# Inicializando las variables
init = tf.initialize_all_variables()
# Para guardar el modelo
saver = tf.train.Saver()
# Lanzando la sesion
with tf.Session() as sess:
sess.run(init)
step = 1
# mantener entrenando hasta alcanzar el maximo de iteraciones
while step * batch_size < training_iters:
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(optimizer, feed_dict={x: batch_x, y: batch_y,
keep_prob: dropout})
if step % display_step == 0:
# Calcular la perdida y la precisión del lote
loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x,
y: batch_y,
keep_prob: 1.})
print("Iteración {0:}, perdida = {1:.6f}, Precisión = {2:.5f}"
.format(str(step*batch_size), loss, acc))
step += 1
print("Optimización terminada!")
# Calcular la precisión sobre el dateset de evaluación.
print("Testing Accuracy: {0: .2f}".format(
sess.run(accuracy, feed_dict={x: mnist.test.images[:256],
y: mnist.test.labels[:256],
keep_prob: 1.})))
# guardar el modelo, luego lo podemos cargar con saver.restore
save_path = saver.save(sess, model_path)
print("Modelo guardado en archivo: {}".format(save_path))
Iteración 1280, perdida = 15986.394531, Precisión = 0.39844 Iteración 2560, perdida = 6756.264160, Precisión = 0.64062 Iteración 3840, perdida = 6450.935547, Precisión = 0.68750 Iteración 5120, perdida = 4994.737305, Precisión = 0.79688 Iteración 6400, perdida = 5018.012207, Precisión = 0.75781 Iteración 7680, perdida = 3136.468994, Precisión = 0.83594 Iteración 8960, perdida = 2392.415039, Precisión = 0.86719 Iteración 10240, perdida = 2178.939453, Precisión = 0.85938 Iteración 11520, perdida = 2877.402344, Precisión = 0.85156 Iteración 12800, perdida = 1862.621338, Precisión = 0.85938 Iteración 14080, perdida = 2310.815430, Precisión = 0.89062 Iteración 15360, perdida = 1362.903687, Precisión = 0.90625 Iteración 16640, perdida = 1552.097534, Precisión = 0.92969 Iteración 17920, perdida = 1975.235474, Precisión = 0.91406 Iteración 19200, perdida = 1421.253784, Precisión = 0.96094 Iteración 20480, perdida = 890.894653, Precisión = 0.93750 Iteración 21760, perdida = 2912.382324, Precisión = 0.87500 Iteración 23040, perdida = 1152.538208, Precisión = 0.92969 Iteración 24320, perdida = 906.505371, Precisión = 0.92969 Iteración 25600, perdida = 690.674683, Precisión = 0.96094 Iteración 26880, perdida = 1855.817627, Precisión = 0.90625 Iteración 28160, perdida = 1120.228760, Precisión = 0.92969 Iteración 29440, perdida = 1528.879639, Precisión = 0.91406 Iteración 30720, perdida = 1286.648560, Precisión = 0.92188 Iteración 32000, perdida = 583.858826, Precisión = 0.92969 Iteración 33280, perdida = 977.640320, Precisión = 0.91406 Iteración 34560, perdida = 557.723267, Precisión = 0.94531 Iteración 35840, perdida = 947.495361, Precisión = 0.93750 Iteración 37120, perdida = 134.786316, Precisión = 0.97656 Iteración 38400, perdida = 616.427002, Precisión = 0.96094 Iteración 39680, perdida = 1603.583374, Precisión = 0.90625 Iteración 40960, perdida = 949.720215, Precisión = 0.93750 Iteración 42240, perdida = 137.855408, Precisión = 0.96875 Iteración 43520, perdida = 612.963684, Precisión = 0.95312 Iteración 44800, perdida = 793.080994, Precisión = 0.93750 Iteración 46080, perdida = 400.291870, Precisión = 0.96875 Iteración 47360, perdida = 1150.624634, Precisión = 0.93750 Iteración 48640, perdida = 258.709290, Precisión = 0.97656 Iteración 49920, perdida = 2207.816406, Precisión = 0.91406 Iteración 51200, perdida = 400.266846, Precisión = 0.95312 Iteración 52480, perdida = 613.738770, Precisión = 0.93750 Iteración 53760, perdida = 618.174377, Precisión = 0.92188 Iteración 55040, perdida = 512.429932, Precisión = 0.95312 Iteración 56320, perdida = 1215.754028, Precisión = 0.89062 Iteración 57600, perdida = 612.911743, Precisión = 0.95312 Iteración 58880, perdida = 385.637512, Precisión = 0.96094 Iteración 60160, perdida = 517.072632, Precisión = 0.92969 Iteración 61440, perdida = 436.352966, Precisión = 0.92969 Iteración 62720, perdida = 1290.541992, Precisión = 0.93750 Iteración 64000, perdida = 328.226868, Precisión = 0.96875 Iteración 65280, perdida = 606.013489, Precisión = 0.95312 Iteración 66560, perdida = 1042.394531, Precisión = 0.92969 Iteración 67840, perdida = 160.461609, Precisión = 0.97656 Iteración 69120, perdida = 231.197266, Precisión = 0.97656 Iteración 70400, perdida = 535.258850, Precisión = 0.94531 Iteración 71680, perdida = 971.498901, Precisión = 0.92188 Iteración 72960, perdida = 542.642090, Precisión = 0.94531 Iteración 74240, perdida = 578.589294, Precisión = 0.96094 Iteración 75520, perdida = 339.135193, Precisión = 0.95312 Iteración 76800, perdida = 505.489319, Precisión = 0.96094 Iteración 78080, perdida = 347.828766, Precisión = 0.94531 Iteración 79360, perdida = 907.295898, Precisión = 0.92188 Iteración 80640, perdida = 450.875153, Precisión = 0.96875 Iteración 81920, perdida = 153.763977, Precisión = 0.97656 Iteración 83200, perdida = 645.537537, Precisión = 0.92188 Iteración 84480, perdida = 666.158875, Precisión = 0.94531 Iteración 85760, perdida = 427.193176, Precisión = 0.96094 Iteración 87040, perdida = 507.789551, Precisión = 0.93750 Iteración 88320, perdida = 298.031189, Precisión = 0.95312 Iteración 89600, perdida = 162.407578, Precisión = 0.96094 Iteración 90880, perdida = 348.540009, Precisión = 0.93750 Iteración 92160, perdida = 1396.949463, Precisión = 0.88281 Iteración 93440, perdida = 336.582031, Precisión = 0.96094 Iteración 94720, perdida = 542.623047, Precisión = 0.93750 Iteración 96000, perdida = 402.476440, Precisión = 0.95312 Iteración 97280, perdida = 287.080688, Precisión = 0.94531 Iteración 98560, perdida = 135.359390, Precisión = 0.97656 Iteración 99840, perdida = 150.416168, Precisión = 0.98438 Iteración 101120, perdida = 342.992798, Precisión = 0.94531 Iteración 102400, perdida = 231.865524, Precisión = 0.97656 Iteración 103680, perdida = 669.114685, Precisión = 0.95312 Iteración 104960, perdida = 558.278931, Precisión = 0.89844 Iteración 106240, perdida = 368.404968, Precisión = 0.94531 Iteración 107520, perdida = 112.701668, Precisión = 0.98438 Iteración 108800, perdida = 116.765099, Precisión = 0.98438 Iteración 110080, perdida = 165.073608, Precisión = 0.96094 Iteración 111360, perdida = 187.182037, Precisión = 0.96875 Iteración 112640, perdida = 215.461563, Precisión = 0.97656 Iteración 113920, perdida = 569.885376, Precisión = 0.94531 Iteración 115200, perdida = 185.075653, Precisión = 0.96875 Iteración 116480, perdida = 134.897095, Precisión = 0.97656 Iteración 117760, perdida = 248.993500, Precisión = 0.95312 Iteración 119040, perdida = 428.411987, Precisión = 0.94531 Iteración 120320, perdida = 223.545090, Precisión = 0.97656 Iteración 121600, perdida = 203.086914, Precisión = 0.95312 Iteración 122880, perdida = 177.018967, Precisión = 0.97656 Iteración 124160, perdida = 382.593323, Precisión = 0.96094 Iteración 125440, perdida = 218.252426, Precisión = 0.98438 Iteración 126720, perdida = 213.570358, Precisión = 0.96094 Iteración 128000, perdida = 121.002808, Precisión = 0.95312 Iteración 129280, perdida = 190.202850, Precisión = 0.96094 Iteración 130560, perdida = 197.318115, Precisión = 0.96875 Iteración 131840, perdida = 278.134430, Precisión = 0.95312 Iteración 133120, perdida = 157.393845, Precisión = 0.97656 Iteración 134400, perdida = 1013.938354, Precisión = 0.91406 Iteración 135680, perdida = 319.466187, Precisión = 0.97656 Iteración 136960, perdida = 214.150253, Precisión = 0.96094 Iteración 138240, perdida = 168.319016, Precisión = 0.98438 Iteración 139520, perdida = 146.133636, Precisión = 0.97656 Iteración 140800, perdida = 0.000000, Precisión = 1.00000 Iteración 142080, perdida = 163.648758, Precisión = 0.96875 Iteración 143360, perdida = 155.861252, Precisión = 0.96875 Iteración 144640, perdida = 514.966431, Precisión = 0.92969 Iteración 145920, perdida = 122.524651, Precisión = 0.96875 Iteración 147200, perdida = 629.005371, Precisión = 0.96094 Iteración 148480, perdida = 133.938232, Precisión = 0.97656 Iteración 149760, perdida = 152.338928, Precisión = 0.96875 Iteración 151040, perdida = 233.781708, Precisión = 0.95312 Iteración 152320, perdida = 249.449448, Precisión = 0.96875 Iteración 153600, perdida = 247.225983, Precisión = 0.96094 Iteración 154880, perdida = 10.728134, Precisión = 0.99219 Iteración 156160, perdida = 248.826996, Precisión = 0.98438 Iteración 157440, perdida = 20.018723, Precisión = 0.98438 Iteración 158720, perdida = 78.384727, Precisión = 0.96875 Iteración 160000, perdida = 468.122406, Precisión = 0.95312 Iteración 161280, perdida = 155.663757, Precisión = 0.96875 Iteración 162560, perdida = 150.710541, Precisión = 0.96094 Iteración 163840, perdida = 242.338455, Precisión = 0.97656 Iteración 165120, perdida = 31.185051, Precisión = 0.98438 Iteración 166400, perdida = 110.294464, Precisión = 0.98438 Iteración 167680, perdida = 182.647125, Precisión = 0.96094 Iteración 168960, perdida = 113.131668, Precisión = 0.97656 Iteración 170240, perdida = 276.484894, Precisión = 0.98438 Iteración 171520, perdida = 127.653786, Precisión = 0.96875 Iteración 172800, perdida = 134.319214, Precisión = 0.97656 Iteración 174080, perdida = 231.960983, Precisión = 0.96875 Iteración 175360, perdida = 210.773346, Precisión = 0.97656 Iteración 176640, perdida = 135.835693, Precisión = 0.97656 Iteración 177920, perdida = 177.216400, Precisión = 0.98438 Iteración 179200, perdida = 4.674934, Precisión = 0.98438 Iteración 180480, perdida = 67.045883, Precisión = 0.98438 Iteración 181760, perdida = 382.801605, Precisión = 0.95312 Iteración 183040, perdida = 30.982941, Precisión = 0.98438 Iteración 184320, perdida = 178.160370, Precisión = 0.97656 Iteración 185600, perdida = 9.528229, Precisión = 0.99219 Iteración 186880, perdida = 24.242599, Precisión = 0.99219 Iteración 188160, perdida = 57.838909, Precisión = 0.97656 Iteración 189440, perdida = 264.432556, Precisión = 0.96875 Iteración 190720, perdida = 238.160339, Precisión = 0.95312 Iteración 192000, perdida = 383.306152, Precisión = 0.96875 Iteración 193280, perdida = 199.790680, Precisión = 0.96094 Iteración 194560, perdida = 242.887024, Precisión = 0.96094 Iteración 195840, perdida = 203.611725, Precisión = 0.96875 Iteración 197120, perdida = 305.651733, Precisión = 0.94531 Iteración 198400, perdida = 29.270210, Precisión = 0.98438 Iteración 199680, perdida = 87.948402, Precisión = 0.98438 Optimización terminada! Testing Accuracy: 0.99 Modelo guardado en archivo: /home/raul/python/notebooks/red_conv.ckpt
La regresión softmax es una generalización del clásico modelo de regresión logística para los casos en que tenemos que clasificar más de dos clases. Con TensorFlow se puede implementar de forma muy sencilla.
# definimos la variable simbólica para para realizar los computos
x = tf.placeholder(tf.float32, [None, 784])
# definimos dos variables para los parámetros y los iniciamos con ceros
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
# definimos el modelo de regresion multinominal.
y = tf.nn.softmax(tf.matmul(x, W) + b)
# definimos una variable simbólica para los resultados.
y_ = tf.placeholder(tf.float32, [None, 10])
# aplicamos entropia cruzada
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y),
reduction_indices=[1]))
# definimos el proceso de entrenamiento aplicando el algoritmo de
# gradiente descendiente optimizando al mínimo la entropia cruzada
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
# iniciamos todas las variables
init = tf.initialize_all_variables()
# lanzamos la sesion
with tf.Session() as sess:
sess.run(init)
# entrenamos el modelo
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
# evaluamos el modelo
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# imprimimos precision
print("Precisión: {0: .2f}".format(sess.run(accuracy,
feed_dict={x: mnist.test.images, y_: mnist.test.labels})))
Precisión: 0.92