En el siguiente documento veremos la implementación de un laboratorio de

reconocimiento de imágenes realizado con el lenguaje de programación

Python junto con un conjunto de librerías como lo son keras, tensorflow,
entre otros.

Conceptos básicos para tener en cuenta:

¿Qué es una Imagen?: Una imagen de píxeles es una estructura de datos
que representa una rejilla rectangular de píxeles o puntos de color,
denominada matriz, que se puede visualizar en un monitor, papel o cualquier
otro dispositivo de visualización.
¿Qué son las redes neuronales convolucionales?: Las redes
convolucionales son un tipo de arquitectura de modelación que se emplea en
las redes neuronales artificiales donde las neuronas corresponden a campos
receptivos muy similares a las neuronas de un cerebro humano.
Existen varios tipos de redes neuronales, en particular vamos a hablar de las
CNN (Convolutional Neural Network), el objetivo principal de este tipo de
neuronas es aprender a caracterizar en un orden superior utilizando la
operación de convolución. Dado que este tipo de neuronas pueden aprender
a relacionar entradas y salidas (donde las entradas son una imagen) en la
convolución, y cada pixel es una salida de combinación lineal de los pixeles
de entrada.

INPUT = entrada, FEATURE LEARNING = aprendizaje de funciones,

CLASSFICATION = clasificación
En la imagen anterior se puede visualizar la operación de convolución
aplicada a la imagen en este caso del carro.

1
 PRÁCTICA DE RECONOCIMIENTO DE IMÁGENES
A continuación, se van a dar unas recomendaciones previas para poder
realizar esta práctica, los principales requerimientos son:
1. Se necesita tener instalado Python 3.6 o posterior, instalar la
aplicación de Anaconda–Navigator la cual tiene implementada la
aplicación de Notebook-Jupyter para comenzar a implementar la
práctica.
2. Abrir la aplicación de Anaconda-Navigator como se muestra en la
siguiente imagen y escoger el entorno de desarrollo:

3. Ejecutar la aplicación de Jupyter:

4.

2
Nota: El siguiente banco de imágenes que nos proporciona Google fue
utilizado para realizar la práctica de reconocimiento de imágenes, a este
banco de imágenes se le realizaron unas modificaciones de tamaño en
dimensiones para poder ejecutar el laboratorio:
Previamente se tuvo que tener descargado el directorio de Imágenes para
poder continuar con la práctica.

NOTA:
Al ejecutar la aplicación de Jupyter tener presente lo siguiente:
1. Crear una nueva carpeta nueva la cual contendrá las practicas a
realizar, dentro de esta carpeta crear una nueva con la respectiva
descripción por cada practica mediante la siguiente forma:

3
 Verificamos las carpetas creadas y su respectivo nombre.
Rename: Sirve para cambiar el nombre de la carpeta

2. Crear un nuevo proyecto de Python de la siguiente forma:

3. Cambiar el nombre al archivo Python con extensión ( .ipynb) de la

siguiente manera:

4
Nos saldrá la siguiente ventana, y se le asigna el respectivo nombre:

4. Cada punto del Código se recomienda colocarlo en una respectiva

celda, dándole clic en el botón + que está ubicado en la parte superior
izquierda.

NOTA: Siempre que haga falta instalar alguna librería o componente para la
práctica, se utiliza la siguiente instancia en el Jupyter-Notebook, para instalar
estas librerías simplemente se tiene que quitar el #, una vez ya instaladas la
librería se vuelve a colocar el # para que no se vuelva a ejecutar la línea de
comando:

#!pip install numpy

#!pip install matplotlib !pip install numpy
#!pip install sklearn !pip install matplotlib
#!pip install keras !pip install sklearn
!pip install keras

5
Quedaría de la siguiente manera:
Esto se hace siempre y cuando se necesite instalar algún componente que
haga falta, el # al comienzo del ejemplo de cada línea de comando sirve para
comentar la línea de código y esta no afecte la ejecución.

La otra forma de instalar una librería es por consola, esto se hace de la

siguiente manera como se muestra en las siguientes imágenes:

conda install ‘nombre’

6
 COMIENZO DE LA PRÁCTICA
Para dar inicio a la práctica, se hará una secuencia de pasos que se deben
de realizar de forma ordenada como se muestra en el documento.
Dato para tener presente: Una vez se descarguen las imágenes, se deben
descomprimir en la carpeta de trabajo de la práctica, quedaría de la siguiente
manera:
Entorno de Jupyter:

Directorio de Archivos del equipo de computador de trabajo:

7
A continuación, se muestra el código de la práctica para realizar la
implementación del reconocimiento de las imágenes.
NOTA: Tener presente los pasos para poder realizar la práctica.

PASO 1) Importación de las librerías.

En informática, una biblioteca o librería es un conjunto de implementaciones
funcionales, codificadas en un lenguaje de programación, que ofrece una
interfaz bien definida para la funcionalidad que se invoca. Se importan las
siguientes librerías con las cuales se va a trabajar en la siguiente práctica.

import numpy as np
import os
import re
import sys
import shutil
from PIL import Image
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import keras
from keras.utils import to_categorical
from keras.models import Sequential,Input,Model
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.layers.normalization import BatchNormalization
from keras.layers.advanced_activations import LeakyReLU

Se debe ver de la siguiente forma:

8
PASO 2) Cargar las imágenes de directorio

dirname = os.path.join(os.getcwd(), 'flower_photos_fix')

imgpath = dirname + os.sep
images = []
directories = []
dircount = []
prevRoot=''
cant=0
#dirs = os.listdir( dirname )
print("leyendo imagenes de ",imgpath)

for root, dirnames, filenames in os.walk(imgpath):

for filename in filenames:
if re.search("\.(jpg|jpeg|png|bmp|tiff)$", filename):
cant=cant+1
filepath = os.path.join(root, filename)
image = plt.imread(filepath)
images.append(image)
b = "Leyendo..." + str(cant)
print (b, end="\r")
if prevRoot !=root:
print(root, cant)
prevRoot=root
directories.append(root)
dircount.append(cant)
cant=0
dircount.append(cant)
dircount = dircount[1:]
dircount[0]=dircount[0]+1
print('Directorios leidos:',len(directories))
print("Imagenes en cada directorio", dircount)
print('suma Total de imagenes en subdirs:',sum(dircount))

“flower_photos_fix”.

Nota: Antes de comenzar con el paso # 2 tenemos que verificar que la

carpeta que contiene el banco de imágenes, se encuentre dentro del mismo
directorio donde se está desarrollando la práctica.

9
Se debe ver de la siguiente manera:

Este sería el resultado de la ejecución:

Se debe tener presente que antes de cargar las imágenes, estas ya deben
de estar descomprimidas en el directorio, en este caso el directorio que
contiene las imágenes tiene como nombre “flower_photos_fix” que contiene 5
subdirectorios, cada uno con un tipo de flor diferente.

10
PASO 3) Creación de etiquetas y clases.
Se crean las etiquetas (labels) para cada tipo de flor, donde se le dan valores
del 0 al 4, que significa cada posición. Esto se realiza para poder usar el
algoritmo e indicar cuando se cargue una imagen de las flores en la red, con
base a esta información, se espera que la entrada y la salida correspondan a

labels=[]
indice=0
for cantidad in dircount:
for i in range(cantidad):
labels.append(indice)
indice=indice+1
print("Cantidad etiquetas creadas: ",len(labels))

deportes=[]
indice=0
for directorio in directories:
name = directorio.split(os.sep)
print(indice , name[len(name)-1])
deportes.append(name[len(name)-1])
indice=indice+1

y = np.array(labels)
X = np.array(images, dtype=np.uint8) #convierto de lista a numpy

# Find the unique numbers from the train labels

classes = np.unique(y)
nClasses = len(classes)
print('Total number of outputs : ', nClasses)
print('Output classes : ', classes)

cada tipo de flor.

11
Se debe de ver de la siguiente forma:

Este sería el resultado de la ejecución:

12
PASO 4) Creación de sets de entrenamiento y test, validación
y preprocesamiento.
La forma de las imágenes que se trabajan son de formato 21x28 por 3
(tamaño de la imagen), donde el 3 corresponde a RGB (red, green, blue)
esto significa a los canales de colores que tiene cada imagen:
train_X,test_X,train_Y,test_Y = train_test_split(X,y,test_size=0.2)
print('Training data shape : ', train_X.shape, train_Y.shape)
print('Testing data shape : ', test_X.shape, test_Y.shape)

train_X = train_X.astype('float32')
test_X = test_X.astype('float32')
train_X = train_X / 255.
test_X = test_X / 255.

# Change the labels from categorical to one-hot encoding

train_Y_one_hot = to_categorical(train_Y)
test_Y_one_hot = to_categorical(test_Y)

# Display the change for category label using one-hot encoding

print('Original label:', train_Y[0])
print('After conversion to one-hot:', train_Y_one_hot[0])

train_X,valid_X,train_label,valid_label = train_test_split(train_X, train_Y_one_hot,

test_size=0.2, random_state=13)

print(train_X.shape,valid_X.shape,train_label.shape,valid_label.shape)

13
 Se debe de ver de la siguiente forma:
Este sería el resultado de la ejecución:

PASO 5) Creación de la Convolutional Neural Network (CNN).

INIT_LR = 1e-3
epochs = 6
batch_size = 64

sport_model = Sequential()
sport_model.add(Conv2D(32, kernel_size=(3,
3),activation='linear',padding='same',input_shape=(21,28,3)))
sport_model.add(LeakyReLU(alpha=0.1))
sport_model.add(MaxPooling2D((2, 2),padding='same'))
sport_model.add(Dropout(0.5))

sport_model.add(Flatten())
sport_model.add(Dense(32, activation='linear'))
sport_model.add(LeakyReLU(alpha=0.1))
sport_model.add(Dropout(0.5))
sport_model.add(Dense(nClasses, activation='softmax'))

sport_model.summary()

sport_model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adagrad(lr=INIT_LR, decay=INIT_LR / 100),metrics=['accuracy'])

14
Se debe de ver de la siguiente forma:

Este sería el resultado de la ejecución:

15
 PASO 6) Entrenamiento de la CNN

sport_train_dropout = sport_model.fit(train_X, train_label,

batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(valid_X, valid_label))

# guardamos la red, para reutilizarla en el futuro, sin tener que volver a entrenar
sport_model.save("sports_mnist.h5py")

Se debe de ver de la siguiente forma:

Este seria el resultado de la ejecución:

16
PASO 7) Mostrar los resultados obtenidos del entrenamiento.

test_eval = sport_model.evaluate(test_X, test_Y_one_hot, verbose=1)

print('Test loss:', test_eval[0])

print('Test accuracy:', test_eval[1])

Se debe de ver de la siguiente manera:

Este sería el resultado de la ejecución:

Conclusión:
Se creo una red Neuronal ‘Novedosa’, que aplica filtros a las imágenes y es
capaz de distinguir distinto tipo de flores con un tamaño de 21x28 píxeles a
color, con un tiempo determinado de entrenamiento.

17
 Bibliografía
 https://www.definicionabc.com/tecnologia/imagen.php#:~:text=Cuando
%20hablamos%20de%20Inform%C3%A1tica%2C%20el,general
%20llamado%20%22imagen%20ISO%22.F
 https://es.wikipedia.org/wiki/Red_neuronal_convolucional

18