TensorFlow es una librería de código abierto desarrollado por Google para cálculo numérico, usando como forma de programación grafos de flujo de datos. Los nodos en el grafo representan operaciones matemáticas, mientras que las conexiones o links del grafo representan los conjuntos de datos multidimensionales (tensores). KERAS La estructura de datos central de Keras es un modelo, una forma de organizar capas. El tipo de modelo más simple es el Sequentia, una pila lineal de capas. Para arquitecturas más complejas, debe utilizar la API funcional de Keras , que permite crear gráficos de capas arbitrarios.

1. INFORME
Integrantes:
Richard Roberto Poma Condori
Douglas Alarcon Calle
Jose Luis Choque Vasante
Carrera: Ing. Sistemas Materia:
Inteligencia Artificial Códigos:
11667-8
3676-3
11488-6
Fecha: 1ro de Junio de 2019

2. LIBRERIAS PYTHON ‘TENSORFLOW & KERAS
INTRODUCCION.-
KERAS
Primero veamos su significa y el origen de la palabra y su origen mitológico: Keras
(κέρας) significa cuerno en griego. Es una referencia a una imagen literaria de la
literatura griega y latina antigua, encontrada por primera vez en la Odisea, donde los
espíritus de los sueños (Oneiroi, singular Oneiros) se dividen entre aquellos que
engañan a los hombres con visiones falsas, que llegan a la Tierra a través de una puerta de marfil. ,
y aquellos que anuncien un futuro que llegará a pasar, que lleguen por una
puerta de cuerno. Es un juego en las palabras κέρας (cuerno) / κραίνω (cumplir), y
ἐλέφας (marfil) / ἐλεφαίρομαι (engañar).
Keras es una API de redes neuronales de alto nivel, escrita en Python y capaz de ejecutarse sobre
TensorFlow , CNTK o Theano . Fue desarrollado con un enfoque en permitir la experimentación
rápida. Poder pasar de la idea al resultado con el menor retraso posible es clave para hacer una
buena investigación.
Keras es una biblioteca de aprendizaje profundo que:
• Permite una creación de prototipos fácil y rápida (a través de la facilidad de uso, la modularidad
y la extensibilidad).
• Admite redes convolucionales y redes recurrentes, así como combinaciones de las dos.
• Funciona a la perfección en CPU y GPU.
Keras es compatible con: Python 2.7-3.6 .
Principios rectores
• La facilidad de uso. Keras es una API diseñada para seres humanos, no máquinas. Pone la
experiencia del usuario al frente y al centro. Keras sigue las mejores prácticas para reducir la
carga cognitiva: ofrece API consistentes y simples, minimiza el número de acciones de usuario
requeridas para los casos de uso comunes y proporciona comentarios claros y procesables en
caso de error del usuario.
• Modularidad. Un modelo se entiende como una secuencia o un gráfico de módulos
independientes, totalmente configurables, que se pueden conectar con la menor cantidad de
restricciones posible. En particular, las capas neuronales, las funciones de costo, los

3. optimizadores, los esquemas de inicialización, las funciones de activación y los esquemas de
regularización son módulos independientes que puede combinar para crear nuevos modelos.
• Fácil extensibilidad. Los nuevos módulos son fáciles de agregar (como nuevas clases y
funciones), y los módulos existentes brindan amplios ejemplos. Poder crear fácilmente
nuevos módulos permite una expresividad total, lo que hace que Keras sea adecuado para la
investigación avanzada.
• Trabajar con Python. No hay archivos de configuración de modelos separados en un formato
declarativo. Los modelos se describen en el código Python, que es compacto, más fácil de
depurar y permite la extensibilidad.
TENSORFLOW
TensorFlow es una librería de código abierto desarrollado por Google para cálculo numérico,
usando como forma de programación grafos de flujo de datos. Los nodos en el grafo representan
operaciones matemáticas, mientras que las conexiones o links del grafo representan los conjuntos
de datos multidimensionales (tensores).
Con esta librería somos capaces, entre otras operaciones, de construir y entrenar redes
neuronales para detectar correlaciones y descifrar patrones, análogos al aprendizaje y
razonamiento usados por los humanos. Actualmente se utiliza
Tensorflow tanto en la investigación como para la producción de productos de Google,
remplazando el rol de su predecesor de código cerrado, DistBelief.
TensorFlow es el sistema de aprendizaje automático de segunda generación de Google Brain,
liberado como software de código abierto el 9 de noviembre del 2015. Mientras la
implementación de referencia se ejecuta en dispositivos aislados, TensorFlow puede correr en
múltiple CPUs y GPUs (con extensiones opcionales de CUDA para informática de propósito general
en unidades de procesamiento gráfico). TensorFlow está disponible en Linux de 64 bits, macOS, y
plataformas móviles que incluyen Android e iOS.
Los cómputos de TensorFlow están expresados como stateful dataflow graphs. El nombre
TensorFlow deriva de las operaciones que las redes neuronales realizan sobre arrays
multidimensionales de datos. Estos arrays multidimensionales son referidos como "tensores"
ANALISIS DE LAS LIBRERIAS.-
KERAS
La estructura de datos central de Keras es un modelo, una forma de organizar capas. El tipo de
modelo más simple es el Sequentia, una pila lineal de capas. Para arquitecturas

4. más complejas, debe utilizar la API funcional de Keras , que permite crear gráficos de
capas arbitrarios.
Aquí está el Sequentialmodelo:
from keras.models import Sequential model
= Sequential()
Apilar capas es tan fácil como .add():
from keras.layers import Dense model.add(Dense(units=64,
activation='relu', input_dim=100)) model.add(Dense(units=10,
activation='softmax'))
Una vez que su modelo se vea bien, configure su proceso de aprendizaje con
.compile():
model.compile(loss='categorical_crossentropy',
optimizer='sgd', metrics=['accuracy'])
Si lo necesita, puede configurar más su optimizador. Un principio básico de Keras es
hacer que las cosas sean razonablemente simples, al tiempo que permite que el
usuario tenga el control total cuando lo necesite (el control definitivo es la fácil
extensión del código fuente).

5. El ejemplo que seguiremos para ello es desarrollar una aplicación que reconozca los
dígitos escrito a mano.
Comenzaremos por implementar el modelo más sencillo posible. En este caso,
haremos una regresión lineal como primer modelo para el reconocimiento de los
dígitos tratados como imágenes.
Primero procederemos a cargar un conjunto de imágenes de los dígitos escrito a mano
del conjunto de
datos matemático
de regresión lineal
en TensorFlow.
Nota: Algunas
nociones
MNIST , luego procederemos a definir y optimizar un
modelo
sobre Python y alguna comprensión básica
sobre
básicas
Machine
Learning
ayudan a una
mejor
comprensión.

6. Primero
cargaremos
algunas librería
%matplotlib inline
import matplotlib.pyplot as plt
import tensorflow as tf import
numpy as np
from sklearn.metrics import confusion_matrix
Descargamos los Datos (Load Data)
El conjunto de datos MNIST es de aproximadamente 12 MB y se descargará
automáticamente si no se encuentra en la ruta dada.
# Load Data.....
from tensorflow.examples.tutorials.mnist import input_data data
= input_data.read_data_sets("data/MNIST/", one_hot=True)
Extracting data/MNIST/train-images-idx3-ubyte.gz
Extracting data/MNIST/train-labels-idx1-ubyte.gz
Extracting data/MNIST/t10k-images-idx3-ubyte.gz
Extracting data/MNIST/t10k-labels-idx1-ubyte.gz
Verificamos los datos
print("Size of:")
print("- Training-set:tt{}".format(len(data.train.labels)))
print("- Test-set:tt{}".format(len(data.test.labels)))
print("- Validation-set:t{}".format(len(data.validation.labels)))
Size of:
One-Hot Encoding
• Training-set: 55000
• Test-set: 10000
• Validation-set: 5000
Como se observa, ahora tenemos tres sub conjunto de datos, uno de entrenamiento,
uno de test y otro de validación.

7. El conjunto de datos se ha cargado con la codificación denominada One-Hot. Esto
significa que las etiquetas se han convertido de un solo número a un vector cuya
longitud es igual a la cantidad de clases posibles. Todos los elementos del vector son
cero excepto el elemento i ésimo que toma el valor uno; y significa que la clase es i.
Por ejemplo, las etiquetas codificadas de One-Hot para las primeras 5 imágenes en el
conjunto de prueba son:
data.test.labels[0:5, :]
se obtiene:
array([[ 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
[ 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
[ 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]])
Como se observa, tenemos cinco vectores donde cada componete tiene valores cero
excepto en la posición de la componete que identifica la clase, cuyo valor es 1.
Como necesitamos las clases como números únicos para las comparaciones y medidas
de rendimiento, procedemos a convertir estos vectores codificados como One-Hot a un
solo número tomando el índice del elemento más alto. Tenga en cuenta que la palabra
'clase' es una palabra clave utilizada en Python, por lo que necesitamos usar el nombre
'cls' en su lugar.
Para codificar estos vectores a números:
data.test.cls = np.array([label.argmax() for label in data.test.labels])
Ahora podemos ver la clase para las primeras cinco imágenes en el conjunto de pruebas.
print (data.test.cls[0:5])
se obtiene
array([7, 2, 1, 0, 4, 1])
Comparemos estos con los vectores codificados One-Hot de arriba. Por ejemplo, la
clase

8. para la primera imagen es 7, que corresponde a un vector codificado One-Hot donde
todos los elementos son cero excepto el elemento con índice 7.
El siguiente paso es definir algunas variables que se usaran en el código. Estas
variables y sus valores constantes nos permitirá tener un código más limpio y fácil de
leer.
Las definimos de la siguiente manera:
# We know that MNIST images are 28 pixels in each dimension.
img_size = 28
# Images are stored in one-dimensional arrays of this length.
img_size_flat = img_size * img_size
# Tuple with height and width of images used to reshape arrays.
img_shape = (img_size, img_size)
# Number of classes, one class for each of 10 digits.
num_classes = 10
Ahora crearemos una función que es utilizada para trazar 9 imágenes en una cuadrícula
de 3x3 y escribir las clases verdaderas y predichas debajo de cada imagen.
def plot_images(images, cls_true, cls_pred=None):
assert len(images) == len(cls_true) == 9
# Create figure with 3x3 sub-plots.
fig, axes = plt.subplots(3, 3) fig.subplots_adjust(hspace=0.5, wspace=0.5)
for i, ax in enumerate(axes.flat):
# Plot image.
ax.imshow(images[i].reshape(img_shape), cmap='binary')

9. # Show true and predicted classes.
if cls_pred is None:
xlabel = "True: {0}".format(cls_true[i]) else:
xlabel = "True: {0}, Pred: {1}".format(cls_true[i], cls_pred[i])
ax.set_xlabel(xlabel)
# Remove ticks from the plot.
ax.set_xticks([])
ax.set_yticks([])
Dibujemos algunas imágenes para ver si los datos son correctos
# Get the first images from the test-set.
images = data.test.images[0:9]
# Get the true classes for those images.
cls_true = data.test.cls[0:9]
# Plot the images and labels using our helper-function above.
plot_images(images=images, cls_true=cls_true)

10. El propósito de usar la librería de TensorFlow es generar un grafo computacional que
se
puede ejecutar de manera mucho más eficiente. TensorFlow puede ser más eficiente
que NumPy (en algunos casos), puesto que TensorFlow conoce todo el grafo de cálculo
y su flujo de datos que debe ejecutarse, mientras que NumPy solo conoce el cálculo de
la operación matemática que se este ejecutando en un determinado momento.
TensorFlow también puede calcular automáticamente los gradientes que se necesitan
para optimizar las variables del grafo a fin de que el modelo funcione mejor. Esto se
debe a que el grafo es una combinación de expresiones matemáticas simples, por lo
que el gradiente de todo el grafo se puede calcular utilizando la regla de cadena para
el cálculo de las derivadas al optimizar la función de coste.
Un grafo de TensorFlow de manera general consta de las siguientes partes:
• Las variables de marcador de posición (Placeholder variables) utilizadas para cambiar las entradas
(datos) al grafo (links entre los nodos).
• Las variables del modelo.
• El modelo, que es esencialmente una función matemática que calcula los resultados dada la
entrada en las variables del marcador de posición (Placeholder variables) y las variables del modelo
(recuerde que desde el punto de vista de TensorFlow las operaciones matemáticas son tratadas
como nodos del grafo).
• Una medida de costo que se puede usar para guiar la optimización de las variables.
• Un método de optimización que actualiza las variables del modelo.
Además, el grafo TensorFlow también puede contener varias declaraciones de depuración, por
ejemplo para que los datos de registro se muestren utilizando TnesorBoard, que no se trata en
este tutorial.
Las variables de marcador de posición (Placeholder variables) sirven de entrada al grafo, y que
podemos cambiar a medida que ejecutamos operaciones sobre el grafo.
Creando nuestro modelo

11. Pasemos a definir las variables de marcador de posición para las imágenes de entrada (Placeholder
variables) , a la que llamaremos x. Hacer esto nos permite cambiar las imágenes que se ingresan al
grafo de TensorFlow.
El tipo de dato que se introducen en el grafo, son vectores o matrices multidimensionales
(denotados tensores). Estos tensores son arrays multidimencionales , cuya forma es [None,
img_size_flat], donde None significa que el tensor puede contener un número arbitrario de
imágenes, siendo cada imagen un vector de longitud img_size_flat. definimos:
x =
tf.placeholder(tf.float32, [None, img_size_flat])
,
y_true = tf.placeholder(tf.float32, [None, num_classes])
,
y_true_cls = tf.placeholder(tf.int64, [None])
Modelo
Como hemos indicado anteriormente, en éste ejemplo vamos a emplear un simple modelo matemático de
regresión lineal, es decir, que vamos a definir una función lineal
donde se multiplica las imágenes en la variable de marcador de posición x x por
unavariable w w que llamaremos pesos y luego agrega un sesgos (b
b b.
A continuación, definimos la variable de marcador de posición para las etiquetas
verdaderas asociadas con las imágenes que se ingresaron en la variable de marcador de
posición x. La forma de esta variable de marcador de posición es [None, num_classes] lo
que significa que puede contener una cantidad arbitraria de etiquetas y cada etiqueta
es un vector de longitud de num_classes, que es 10 en nuestro caso.
Finalmente, tenemos la variable de marcador de posición para la clase verdadera de
cada imagen en la variable de marcador de posición x. Estos son enteros y la
dimensionalidad de esta variable de marcador de posición se pre-define como [None]
lo que significa que la variable marcador de posición es un vector unidimensional de
longitud arbitraria.

12. llamaremos
Por tanto:
ias)
que
x
tiene
la
l og i s t = wx + b logist=wx+b
El resultado es una matriz de forma [num_images, num_classes] , dado que x
forma [num_images, img_size_flat] y la matriz de pesos w w tienen la
forma es
un a
[img_size_flat, num_classes] , por lo que la multiplicación de éstas dos matrices
matriz con cuya forma es [num_images,
num_classes]
. Luego el vector de
sesgos
b
b
se agrega a cada fila de esa matriz resultante.
Nota hemos usado el nombre l og it s
logits para respetar la terminología típica de
TensorFlow,
pero se
puede
llamar a la
variable de
otra
manera.
Esta
operación
en
TensorFlow
la definimos
de la
siguiente
manera:
• Primero declaramos la variable w w (tensor de pesos) y lo inicializamos con cero:
w = tf.Variable(tf.zeros([img_size_flat, num_classes]))
• Luego declaramos la variable b b (tensor de sesgo) y lo inicializamos con cero:
b = tf.Variable(tf.zeros([ num_classes]))
• Definimos nuestro modelo lineal:

13. logits = tf.matmul(x, w) + b
En la definición del
modelo
función nos
devuelve el valor de
multiplicar el tensor
l og it slogits, hemos usado la función tf.matmul. Esta
x x por el tensor w w.
El modelo logits es una
matriz con filas
num_images y columnas
enésim
a es enésima
sea de la
difíciles de
que, para
es sumen
uno, así el
valor de cada
element
num_classes , donde el
de la
que los
fila de la o
de
elemento de la
fila probabilidad
de que la
imagen de
entrada Sin
embargo, estas
entonces sería
matriz
l
i ienésima y la columna j j
mod
o
una estimación
estimaciones
son un
normalizar
los valores
de logits
todos sus
valor
i
i
poco
tal
y el
resultad
o se
almacen
a en una
nueva
variable
j j
enésima
clase.
tar,
dado
que cada
números
que se
obtienen
pueden ser
muy
pequeños o
muy
grandes. El
siguiente
paso
la matriz
esté
restringido
entre cero
y uno. Con
TensorFlow
, esto se
calcula
utilizando
la
interpr
e
función
llamada
softma
x
y_pre
d
.
y_pred = tf.nn.softmax(logits)
Finalmente la clase predicha puede calcularse a partir de la matriz y_pred tomando
el
índice del elemento más grande en cada fila.
y_pred_cls = tf.argmax(y_pred, dimension=1)
og it s

14. Función de Coste y Optimización
Como hemos indicado anteriormente, el modelo de clasificación y reconocimiento de
los dígitos escrito a mano que hemos implementado, es
un modelo matemático de regresión lineal logits=wx+b.
La calidad de predicción del
modelo va depender de los valores óptimos de
las variables w (tensor de pesos) y b (tensor de sesgos) data una
entrada x (tensor de imágenes). Por tanto, optimizar nuestro clasificador para
la tarea del reconocimiento de los dígito consiste en hacer un ajuste de nuestro modelo
de tal forma que podamos encontrar los valores
l og it s = wx + b
b
w
x
óptimos en el tensor w w
y
b b. Este proceso de óptim ización en éstas variables
es lo
que se conoce como el proceso de entrenamiento o aprendizaje del modelo.
Para mejorar el modelo al clasificar las imágenes de entrada, de alguna mane ra
debemos encontrar un método para cambiar el valor de las variables para las
ponderaciones
( w w) y los sesgos (
funciona
actualmente
modelo y_pred
con el re
de coste se
pueden defi
entropía
cruzada
b
b) . Para hacer esto, primero necesitamos saber qué tan
bien e l modelo al comparar el resultado predicho del sul
tado deseado y_true . La función de rendimiento que mide
el
or entre la salida real del sistema que se pretende
modelar y la salida del núcleo estimador (el modelo) , es lo
que se conoce como función de coste. Diferentes
funciones nir.
ross-entropy) es una medida de rendimiento utilizada en
la
err
La (c
clasificación. La entropía cruzada es una función continua que siempre es positiva y si
la
salida predicha del modelo coincide exactamente con la salida dese ada, entonces la
entropía cruzada es igual a cero. Por lo tanto, el objetiv o de la optimización es
minimizar la entropía cruzada para que se acerque lo más posible a cero cambiando los
pesos w w y
los sesgos
TensorFlow
tiene una funci
se usan los
valores de lo
calcula el
b bdel modelo.
ón incorporada para calcular la entropía cruzada. Note
que
s l og it s logits puesta que esta función del
tensorFlow

15. softmax
internamente.
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits,labels=y_true)
Una vez que hemos calculado la entropía cruzada para cada una de las clasificaciones
de
imágenes, tenemos una medida de qué tan bien se comporta el modelo en cada imagen
individualmente. Pero para usar la entropía cruzada para guiar la optimización de las
variables del modelo, necesitamos tener un solo valor escalar, así que simplemente
tomamos el promedio de la entropía cruzada para todas las clasificaciones de
imágenes.
Para esto:
cost = tf.reduce_mean(cross_entropy)
Método de optimización
Ahora que ya tenemos una medida de costo que debe minimizarse, podemos crear un
optimizador. En este caso usaremos uno de los
métodos maś utilizado conocido como Gradient
Descent (para más detalles revisar ), donde el tamaño
de paso para el ajuste de las varuable lo prefijamos en en 0.5.
Tenga en cuenta que la optimización no se realiza en este momento. De hecho, nada
se calcula en absoluto, simplemente agregamos el objeto optimizador al gráfico
TensorFlow para su posterior ejecución.
lecture 4, lecture 5 y lecture 6
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.5).minimize(cost)
Medidas de desempeño
Necesitamos algunas medidas de rendimiento más para mostrar el progreso al usuario.
Creamos una un vector de booleanos, dónde donde verificamos si la clase predicha es
igual a la clase verdadera de cada imagen.
correct_prediction = tf.equal(y_pred_cls, y_true_cls)
Esto calcula la
precisión (
de mod
accuracy ) de la clasificación y
transforma los booleanos a flotas, o que False se
convierte en 0 y True se convierte en 1. Luego
calculamos el
promedio de estos números.
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
Ejecutar TensorFlow

16. Una vez especificados todos los elementos de nuestro modelo, podemos ya crear el
grafo. Para ello tenemos que crear una sesión para ejecutar luego el grafo:
session = tf.Session()
Inicializar variables: Las variables para pesos y sesgos deben inicializarse antes de
comenzar a optimizarlas.
Creamos una función para realizar varias iteraciones de optimización para
mejorar gradualmente los pesos w y los sesgos b del modelo. En cada
iteración, se selecciona un nuevo lote de datos del conjunto de
entrenamiento y luego TensorFlow ejecuta el optimizador utilizando esas muestras
de entrenamiento. Fijamos eso lote de imágenes em 100 (batch_size = 100 ).
b
w
# bacth of images
batch_size = 100
def
optimize(num_iterations):
for i in
range(num_iterations):
# Get a batch of training examples.
# x_batch now holds a batch of images and
# y_true_batch are the true labels for those images.
x_batch, y_true_batch = data.train.next_batch(batch_size)
# Put the batch into a dict with the proper names
# for placeholder variables in the TensorFlow graph.
# Note that the placeholder for y_true_cls is not set # because it is
not used during training. feed_dict_train = {x: x_batch,
y_true: y_true_batch}
# Run the optimizer using this batch of training data.

17. # TensorFlow assigns the variables in feed_dict_train # to the placeholder
variables and then runs the optimizer.
session.run(optimizer, feed_dict=feed_dict_train)
Helper-funciones para mostrar el rendimiento
Vamos a crear un conjunto de funciones que nos ayudaran a monitorizar el
rendimiento de nuestro clasificador. Primero creamos un diccionario con los datos
del conjunto de
prueba que se utilizarán como entrada al grafo de TensorFlow.
feed_dict_test = {x: data.test.images,
y_true: data.test.labels, y_true_cls:
data.test.cls}
Función para imprimir la precisión (accuracy) de clasificación en el conjunto de prueba.
def print_accuracy():
# Use TensorFlow to compute the accuracy.
acc = session.run(accuracy, feed_dict=feed_dict_test)
# Print the accuracy.
print("Accuracy on test-set: {0:.1%}".format(acc))
Función para imprimir y trazar la matriz de confusión usandoscikit-
learn
.
def print_confusion_matrix():
# Get the true classifications for the test-set.
cls_true = data.test.cls
# Get the predicted classifications for the test-set.
cls_pred = session.run(y_pred_cls, feed_dict=feed_dict_test)
# Get the confusion matrix using sklearn.
cm = confusion_matrix(y_true=cls_true,

18. y_pred=cls_pred)
# Print the confusion matrix as text.
print(cm)
# Plot the confusion matrix as an image.
plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
# Make various adjustments to the plot.
plt.tight_layout()
plt.colorbar()
tick_marks = np.arange(num_classes)
plt.xticks(tick_marks,
range(num_classes))
plt.yticks(tick_marks,
range(num_classes))
plt.xlabel('Predicted') plt.ylabel('True')
Función para trazar los pesos del modelo. Se trazan 10 imágenes, una para cada
dígito
en el que el modelo está entrenado para reconocerlo.
def plot_weights():
# Get the values for the weights from the TensorFlow variable.
wi = session.run(w)
# Get the lowest and highest values for the weights.
# This is used to correct the colour intensity across
# the images so they can be compared with each
other.

19. w_min = np.min(wi)
w_max = np.max(wi)
# Create figure with 3x4 sub-plots,
# where the last 2 sub-plots are
unused.
fig, axes = plt.subplots(3, 4)
fig.subplots_adjust(hspace=0.3, wspace=0.3)
for i, ax in enumerate(axes.flat):
# Only use the weights for the first 10 sub-
plots. if i<10:
# Get the weights for the i'th digit and reshape it.
# Note that w.shape == (img_size_flat, 10)
image = wi[:, i].reshape(img_shape)
# Set the label for the sub-plot.
ax.set_xlabel("Weights: {0}".format(i))
# Plot the image.
ax.imshow(image, vmin=w_min, vmax=w_max,
cmap='seismic')
# Remove ticks from each sub-plot.
ax.set_xticks([])
ax.set_yticks([])
Rendimiento antes de cualquier optimización

20. Ahora que ya temos todo lo necesario, vamos a ejecutar el clasificador y hacer
alguans pruebas de rendimiento.
Como ya hemos inicializado las variables, lo primero que vamos a mirar es ver el
nivel de precision que éste tiene antes de ejecutar cualquier optimización.
ejecutemos la funcion accuracy que hemos creado:
print_accuracy()
optemos
Accuracy on test-set: 9.8%
Vamos a usar la función de optimización que hemos creado a una interación:
optimize(num_iterations=1) print_accuracy()
Resultado:
Accuracy on test-set: 40.9%
Como se aprecia después de una única iteración de optimización, el modelo ha
incrementado su precisión en el conjunto de prueba a 40.7%. Esto significa que clasifica
incorrectamente las imágenes aproximadamente 6 de cada 10 veces.
Los pesos del tensor w también pueden trazarse como se muestra a continuación.
Los pesos positivos toman los tonos rojos y los pesos negativos los tonos azules. Estos
pesos pueden entenderse intuitivamente como filtros de imagen. usemos la funcion
plot_weights()
w
plot_weights()

21. Por ejemplo, los pesos utilizados para determinar si una imagen muestra un dígito
cero tienen una reacción positiva (roja) como la imagen de un círculo y tienen una
reacción negativa (azul) a las imágenes con contenido en el centro del círculo.
De manera similar, los pesos utilizados para determinar si un a imagen muestra el
dígito 1, éste reacciona positivamente (rojo) a una línea vertical en el centro de la
imagen, y reacciona negativamente (azul) a las imágenes con el contenido que rodea
esa línea.
En estas imágenes, los pesos en su mayoría se parecen a los dígitos que se supone
deben reconocer. Esto se debe a que solo se ha realizado una iteración de
optimización, por lo que los pesos solo se entrenan en 100 imágenes. Después de
entrenar en miles de imágenes, los pesos se vuelven más difíciles de interpr etar
porque tienen que reconocer muchas variaciones de cómo se pueden escribir los
dígitos.
Redimiento después de 10 iteraciones
# We have already performed 1 iteration.
optimize(num_iterations=9)
print_accuracy()
resultado:
Accuracy on test-set: 78.2%
Los pesos

22. plot_weights()
Rendimiento después de 1000 iteraciones de optimización
# We have already performed 1000
iteration.
optimize(num_iterations=999)
print_accuracy() plot_weights()
optenemos:
Accuracy on test-set: 92.1%
pesos
Después de 1000 iteraciones de optimización, el modelo solo clasifica erróneamente
una de cada diez imágenes. Este modelo simple no puede alcanzar un rendimiento
mucho mejor y, por lo tanto, se necesitan modelos más complejos. En los
subsiguientes tutoriales crearemos un medelo más complejo usando redes
neuronales que nos ayudará mejorar el rendimiento del nuestro clasificador.

23. Finalmente para tener una visión global de los errores cometidos por nuestro
clasificador, vamos a analizar la matriz de confusión (confusion matrix) . Usamos
nuestyra función print_confusion_matrix(
)
.
print_confusion_matrix()
[[ 961 0 0 3 0 7 3 4 2 0]
[ 0 1097 2 4 0 2 4 2 24 0]
[ 12 8 898 23 5 4 12 12 49 9]
[ 2 0 10 927 0 28 2 9 24
8] [ 2 1 2 2 895 0 13 4 10
53]
[ 10 1 1 37 6 774 17 4 36 6]
[ 13 3 4 2 8 19 902 3 4 0]
[ 3 6 21 12 5 1 0 936 2 42]
[ 6 3 6 18 8 26 10 5 883 9]
[ 11 5 0 7 17 11 0 16 9 933]]

24. Ahora que hemos terminado de usar TensorFlow, cerramos la sesión para liberar
sus recursos.
session.close()
Proyecto Codificación
###LSTM
##Construya un modelo que predice los precios de las acciones de una compañía ##basándose en
los precios de los días anteriores
import numpy as np # para Algebra Lineal import pandas as pd # procesamiento
de archivos , CSV file I/O leer_csv) from keras.models import Sequential from
keras.layers import LSTM,Dense from sklearn.preprocessing import MinMaxScaler
import matplotlib.pyplot as plt
# In[2]:
df = pd.read_csv('all_stocks_5yr.csv')
# In[3]:
df.head()
# In[4]:
df.tail()
# In[5]:
companies = df.Name.unique() companies

25. # # get closing values of ZTS
# In[6]:
z = df.loc[df['Name'] == 'ZTS']
z.info()
# In[7]:
z.head()
# In[8]:
# Creando una matriz con precios de cierre.
trainingd = z.iloc[:, 4:5].values
# # Normalizing the Values
# In[9]:
from sklearn.preprocessing import MinMaxScaler sc =
MinMaxScaler() training_set_scaled =
sc.fit_transform(trainingd)
# # x_train almacena los valores de los precios de cierre de los últimos 45 días (o como se especifica
en la fecha y hora) días
# # y_train almacena los valores de precios de cierre de la actualidad.
# In[10]:

26. x_train = [] y_train = []
timestamp = 45
length = len(trainingd) for i in
range(timestamp, length):
x_train.append(training_set_scaled[i-timestamp:i, 0]) y_train.append(training_set_scaled[i, 0])
x_train = np.array(x_train) y_train =
np.array(y_train)
# In[11]:
print (x_train[0]) print
('n') print (y_train[0])
# # Preparacion de Datos
# In[12]:
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1)) x_train.shape
# In[13]:
from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout
# In[14]:
model = Sequential() #Definir el modelo de Keras.

27. model.add(LSTM(units = 120, return_sequences = True, input_shape = (x_train.shape[1], 1))) #120
neuronas en la capa oculta
##return_sequences = True hace que la capa LSTM devuelva el historial completo, incluidas
las salidas en todo momento model.add(Dropout(0.2))
model.add(LSTM(units = 120, return_sequences = True)) model.add(Dropout(0.2))
model.add(LSTM(units = 120, return_sequences = True)) model.add(Dropout(0.2))
model.add(LSTM(units = 120, return_sequences = False)) model.add(Dropout(0.2))
model.add(Dense(units = 1)) #salida model.compile(optimizer = 'adam',
loss = 'mean_squared_error')
# In[16]:
model.fit(x_train, y_train, epochs = 25, batch_size = 32)
# In[15]:
test_set = df.loc[df['Name'] == 'BA'] # cambiar CBS a cualquier compañía de la lista test_set =
test_set.loc[:, test_set.columns == 'close']
# In[26]:
#Los precios de las acciones reales en y_test a partir del día 45 ya que los 45 días anteriores se
utilizan para predecir el valor actual.
y_test = test_set.iloc[timestamp:, 0:].values

28. # In[28]:
#almacenar todos los valores en una variable para generar una matriz de entrada para nuestro
modelo
closing_price = test_set.iloc[:, 0:].values closing_price_scaled =
sc.transform(closing_price)
# In[30]:
# El modelo predecirá los valores en x_test.
x_test =[] length = len(test_set)
for i in range(timestamp, length):
x_test.append(closing_price_scaled[i-timestamp:i, 0])
x_test = np.array(x_test) x_test.shape
# In[31]:
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1)) x_test.shape
# In[32]:
#predeciendo los valores del precio de las acciones y_pred =
model.predict(x_test) predicted_price =
sc.inverse_transform(y_pred)
# In[36]:

29. # resultado del ploteo plt.plot(y_test, color = 'blue', label = 'Precio real de las acciones (Actual
stock price)')
plt.plot(predicted_price, color = 'red', label = 'Precio de Stock previsto (predicted Stock Price)')
plt.title('Predicción del precio de las acciones (Stock Price Prediction)') plt.xlabel('Tiempo')
plt.ylabel('Precio de mercado (Stock Price)') plt.legend() plt.show()
# In[ ]:
Resultado Procesado
Using TensorFlow backend.
<class 'pandas.core.frame.DataFrame'> Int64Index: 1259
entries, 617781 to 619039
Data columns (total 7 columns):
date 1259 non-null object open 1259
non-null float64 high 1259 non-null float64
low 1259 non-null float64 close 1259
non-null float64 volume 1259 non-null int64
Name 1259 non-null object dtypes:
float64(4), int64(1), object(2)
memory usage: 78.7+ KB
[0.08995937 0.09402205 0.10330818 0.09963242 0.09421552 0.10795125
0.10524279 0.08357516 0.08047978 0.08106017 0.07100019 0.07041981
0.07583672 0.09769781 0.11994583 0.11510931 0.11394854 0.10543625
0.11917199 0.11007932 0.11182047 0.10485587 0.10833817 0.12071967
0.09750435 0.08589669 0.08512285 0.09885858 0.09808474 0.0913136
0.07854517 0.07951248 0.08396208 0.09673051 0.08106017 0.08028632
0.0798994 0.06655059 0.06887212 0.08744438 0.09750435 0.09189398
0.09208744 0.09344167 0.07428903]

30. 0.0930547494679822
WARNING:tensorflow:From C:ProgramDataAnaconda3libsite-
packagestensorflowpythonframeworkop_def_library.py:263: colocate_with (from
tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Colocations handled automatically by placer.
WARNING:tensorflow:From
C:ProgramDataAnaconda3libsitepackageskerasbackendtensorflow_backend.py:3445: calling
dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed
in a future version.
Instructions for updating:
Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.
WARNING:tensorflow:From
C:ProgramDataAnaconda3libsitepackagestensorflowpythonopsmath_ops.py:3066:
to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future
version.
Instructions for updating:
Use tf.cast instead.
Epoch 1/25
2019-06-03 00:42:19.661532: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU
supports instructions that this TensorFlow binary was not compiled to use: AVX
2019-06-03 00:42:19.847533: I
tensorflow/core/common_runtime/gpu/gpu_device.cc:1433] Found device 0 with properties:
name: GeForce GT 610 major: 2 minor: 1 memoryClockRate(GHz): 1.62 pciBusID:
0000:01:00.0 totalMemory: 2.00GiB freeMemory: 1.29GiB
2019-06-03 00:42:19.847533: I
tensorflow/core/common_runtime/gpu/gpu_device.cc:1483] Ignoring visible gpu device (device:
0, name: GeForce GT 610, pci bus id: 0000:01:00.0, compute capability:
2.1) with Cuda compute capability 2.1. The minimum required Cuda capability is 3.0.
2019-06-03 00:42:19.847533: I
tensorflow/core/common_runtime/gpu/gpu_device.cc:984] Device interconnect StreamExecutor
with strength 1 edge matrix:
2019-06-03 00:42:19.847533: I

31. tensorflow/core/common_runtime/gpu/gpu_device.cc:990] 0
2019-06-03 00:42:19.847533: I
tensorflow/core/common_runtime/gpu/gpu_device.cc:1003] 0: N
32/1214 [..............................] - ETA: 2:01 - loss: 0.2116
64/1214 [>.............................] - ETA: 1:02 - loss: 0.1753
96/1214 [=>............................] - ETA: 42s - loss: 0.1403
128/1214 [==>...........................] - ETA: 32s - loss: 0.1100
160/1214 [==>...........................] - ETA: 26s - loss: 0.0979
192/1214 [===>..........................] - ETA: 22s - loss: 0.0853
224/1214 [====>.........................] - ETA: 19s - loss: 0.0745
256/1214 [=====>........................] - ETA: 17s - loss: 0.0670
288/1214 [======>.......................] - ETA: 15s - loss: 0.0621
320/1214 [======>.......................] - ETA: 14s - loss: 0.0578
352/1214 [=======>......................] - ETA: 12s - loss: 0.0542
384/1214 [========>.....................] - ETA: 11s - loss: 0.0512
416/1214 [=========>....................] - ETA: 10s - loss: 0.0478
448/1214 [==========>...................] - ETA: 10s - loss: 0.0450
480/1214 [==========>...................] - ETA: 9s - loss: 0.0427 512/1214
[===========>..................] - ETA: 8s - loss: 0.0408
544/1214 [============>.................] - ETA: 8s - loss: 0.0389
576/1214 [=============>................] - ETA: 7s - loss: 0.0370
608/1214 [==============>...............] - ETA: 6s - loss: 0.0354
640/1214 [==============>...............] - ETA: 6s - loss: 0.0341
672/1214 [===============>..............] - ETA: 5s - loss: 0.0329
704/1214 [================>.............] - ETA: 5s - loss: 0.0318
736/1214 [=================>............] - ETA: 5s - loss: 0.0305
768/1214 [=================>............] - ETA: 4s - loss: 0.0294

32. 800/1214 [==================>...........] - ETA: 4s - loss: 0.0284
832/1214 [===================>..........] - ETA: 3s - loss: 0.0276
864/1214 [====================>.........] - ETA: 3s - loss: 0.0268
896/1214 [=====================>........] - ETA: 3s - loss: 0.0259
928/1214 [=====================>........] - ETA: 2s - loss: 0.0251
960/1214 [======================>.......] - ETA: 2s - loss: 0.0245
992/1214 [=======================>......] - ETA: 2s - loss: 0.0240
1024/1214 [========================>.....] - ETA: 1s - loss: 0.0234
1056/1214 [=========================>....] - ETA: 1s - loss: 0.0227
1088/1214 [=========================>....] - ETA: 1s - loss: 0.0221 1120/1214
[==========================>...] - ETA: 0s - loss: 0.0215
.
.
.
.
.
.
.
. .
384/1214 [========>.....................] - ETA: 5s - loss: 0.0014
416/1214 [=========>....................] - ETA: 5s - loss: 0.0014
448/1214 [==========>...................] - ETA: 5s - loss: 0.0013
480/1214 [==========>...................] - ETA: 4s - loss: 0.0013
512/1214 [===========>..................] - ETA: 4s - loss: 0.0014
544/1214 [============>.................] - ETA: 4s - loss: 0.0014
576/1214 [=============>................] - ETA: 4s - loss: 0.0013
608/1214 [==============>...............] - ETA: 3s - loss: 0.0013

33. 640/1214 [==============>...............] - ETA: 3s - loss: 0.0013
672/1214 [===============>..............] - ETA: 3s - loss: 0.0013
704/1214 [================>.............] - ETA: 3s - loss: 0.0013
736/1214 [=================>............] - ETA: 3s - loss: 0.0013
768/1214 [=================>............] - ETA: 2s - loss: 0.0013
800/1214 [==================>...........] - ETA: 2s - loss: 0.0013
832/1214 [===================>..........] - ETA: 2s - loss: 0.0013
864/1214 [====================>.........] - ETA: 2s - loss: 0.0013
896/1214 [=====================>........] - ETA: 2s - loss: 0.0013
928/1214 [=====================>........] - ETA: 1s - loss: 0.0013
960/1214 [======================>.......] - ETA: 1s - loss: 0.0013 992/1214
[=======================>......] - ETA: 1s - loss: 0.0012
1024/1214 [========================>.....] - ETA: 1s - loss: 0.0012
1056/1214 [=========================>....] - ETA: 0s - loss: 0.0013
1088/1214 [=========================>....] - ETA: 0s - loss: 0.0013
1120/1214 [==========================>...] - ETA: 0s - loss: 0.0012
1152/1214 [===========================>..] - ETA: 0s - loss: 0.0012
1184/1214 [============================>.] - ETA: 0s - loss: 0.0012
1214/1214 [==============================] - 8s 6ms/step - loss: 0.0012

34. CONCLUCION.-
Para la elaboración de este trabajo se emplearon diferentes métodos de Investigación,
fundamentalmente teóricos, entre los que se destacan el Histórico lógico y el análisis y la
síntesis.
Con esto podemos seguir a la información especialmente a la comunidad donde hay muchas
personas, informáticos o no de titulación, interesadas en dar sus primeros pasos en el mundo de
la programación en un ambiente de software libre, pues Python con sus librerías constituye, sin
lugar a dudas, una de las mejores variantes.
BIBLIOGRAFÍA
[1]. Downey, A.B. (2008).
How to Think Like a Computer Scientist
. Learning with Python, Green Tea Press.
[2]. Finlay, J. (2006). PyGTK 2.0 Tutorial, Version 2.5.
[documento en línea]. http://www.pygtk.org/pygtk2tutorial/index.html
http://mundogeek.net/tutorial-python/

35. CODIGO FUENTE DE KERAS Y TENSORFLOW (PYTHON)
##Construya un modelo que predice los precios de las acciones de una compañía
##basándose en los precios de los días anteriores
import numpy as np # para Algebra Lineal
import pandas as pd # procesamiento de archivos , CSV file I/O leer_csv)
from keras.models import Sequential
from keras.layers import LSTM,Dense
from sklearn.preprocessing import MinMaxScaler
import matplotlib.pyplot as plt
df = pd.read_csv('all_stocks_5yr.csv')
df.head()
df.tail()
companies = df.Name.unique()
companies
# # get closing values of ZTS
z = df.loc[df['Name'] == 'ZTS']
z.info()
z.head()
# Creando una matriz con precios de cierre.
trainingd = z.iloc[:, 4:5].values
# # Normalizing the Values

36. from sklearn.preprocessing import MinMaxScaler
sc = MinMaxScaler()
training_set_scaled = sc.fit_transform(trainingd)
# # x_train almacena los valores de los precios de cierre de los últimos 45
días (o como se especifica en la fecha y hora) días
# # y_train almacena los valores de precios de cierre de la actualidad.
x_train = []
y_train = []
timestamp = 45
length = len(trainingd)
for i in range(timestamp, length):
x_train.append(training_set_scaled[i-timestamp:i, 0])
y_train.append(training_set_scaled[i, 0])
x_train = np.array(x_train)
y_train = np.array(y_train)
print (x_train[0])
print ('n')
print (y_train[0])
# # Preparacion de Datos
# In[35]:
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
x_train.shape
from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout
model = Sequential() #Definir el modelo de Keras.
model.add(LSTM(units = 120, return_sequences = True, input_shape =
(x_train.shape[1], 1))) #120 neuronas en la capa oculta
##return_sequences = True hace que la capa LSTM devuelva el historial completo,
incluidas las salidas en todo momento
model.add(Dropout(0.2))
model.add(LSTM(units = 120, return_sequences = True))

37. model.add(Dropout(0.2))
model.add(LSTM(units = 120, return_sequences = True))
model.add(Dropout(0.2))
model.add(LSTM(units = 120, return_sequences = False))
model.add(Dropout(0.2))
model.add(Dense(units = 1)) #salida
model.compile(optimizer = 'adam', loss = 'mean_squared_error')
model.fit(x_train, y_train, epochs = 25, batch_size = 32)
test_set = df.loc[df['Name'] == 'BA'] # cambiar CBS a cualquier compañía de la
lista
test_set = test_set.loc[:, test_set.columns == 'close']
#Los precios de las acciones reales en y_test a partir del día 45 ya que los 45
días anteriores se utilizan para predecir el valor actual.
y_test = test_set.iloc[timestamp:, 0:].values
#almacenar todos los valores en una variable para generar una matriz de entrada
para nuestro modelo
closing_price = test_set.iloc[:, 0:].values
closing_price_scaled = sc.transform(closing_price)
# El modelo predecirá los valores en x_test.
x_test =[]
length = len(test_set)
for i in range(timestamp, length):
x_test.append(closing_price_scaled[i-timestamp:i, 0])
x_test = np.array(x_test)
x_test.shape
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
x_test.shape

38. #predeciendo los valores del precio de las acciones
y_pred = model.predict(x_test)
predicted_price = sc.inverse_transform(y_pred)
# resultado del ploteo
plt.plot(y_test, color = 'blue', label = 'Precio real de las acciones (Actual
stock price)')
plt.plot(predicted_price, color = 'red', label = 'Precio de Stock previsto
(predicted Stock Price)')
plt.title('Predicción del precio de las acciones (Stock Price Prediction)')
plt.xlabel('Tiempo')
plt.ylabel('Precio de mercado (Stock Price)')
plt.legend()
plt.show()
# In[ ]: