PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE...

PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE

PARQUEADEROS EN UN CENTRO COMERCIAL

CAMILO SNEIDER GARCIA VELANDIA

JAIRO ALBERTO HUERTAS ACEVEDO

Universidad Distrital Francisco José de Caldas

Facultad tecnológica, Ingeniería en control

Bogotá, Colombia

2018

PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE


CAMILO SNEIDER GARCIA VELANDIA

JAIRO ALBERTO HUERTAS ACEVEDO

Monografía presentada como requisito parcial para optar al título de:

Ingeniero en control

Director:

ING. FRANK NIXON GIRALDO RAMOS

Línea de Investigación:

Procesamiento de señales, Instrumentación electrónica

Universidad Distrital Francisco José de Caldas

Facultad tecnológica, Ingeniería en control

Bogotá, Colombia

2018

A nuestros padres y a todas las personas que

con su apoyo y solidaridad abrieron las

posibilidades de llegar a realizar este trabajo

Agradecimientos

Agradecemos enormemente al director de este proyecto el Ingeniero Frank Nixon Giraldo

Ramos, por la dedicación y apoyo que ha brindado a este trabajo, por el respeto a las

sugerencias e ideas y por la dirección y el rigor que ha facilitado a las mismas. Gracias

por la confianza ofrecida por el camino en esta facultad.

Un trabajo de investigación es siempre fruto de ideas, proyectos y esfuerzos previos, por

esto agradecemos al Ingeniero Rafael Alberto Fino Sandoval por su amabilidad para

facilitarnos su tiempo y sus ideas, por su orientación y atención a las consultas y por la

revisión cuidadosa que ha realizado y sus valiosas sugerencias.

Gracias a nuestras familias, a nuestros padres, hermanos y amigos, que siempre nos han

prestado un gran apoyo moral y humano, necesarios en los momentos difíciles de este

trabajo y esta profesión. Sin su apoyo este trabajo nunca se habría escrito y, por eso,

este trabajo es también el suyo.

Resumen y Abstract IX

Resumen

En esta monografía se consigna la información, del proceso de investigación, desarrollo

y resultados que se obtuvieron. El fin de la investigación fue crear una alternativa de

solución a la problemática que consiste en que actualmente algunos de los

parqueaderos que prestan el servicio, en centros comerciales, no asignan una plaza de

parqueo específica a los automóviles, dejando que la ubicación de estos automóviles,

quede libre a la decisión de cada usuario; otros parqueaderos no tienen en cuenta la

totalidad de automóviles que se encuentran en su interior lo que puede determinar si

este llego a su máxima capacidad, o no. Estas prácticas puede llegar a generar

congestión vehicular dentro del parqueadero, poca comodidad para los usuarios, y no se

genera una rotación adecuada en cuanto al uso de todas las plazas de parqueo con las

que cuenta el parqueadero. Teniendo en cuenta la problemática expuesta anteriormente

se propuso como una alternativa de solución, el diseño de un sistema prototipo que

permite gestionar la ocupación de parqueaderos por medio de una red neuronal artificial

(RNA), este sistema prototipo permite dar solución a los problemas descritos, y cumple

con el objetivo de la gestión de las plazas de parqueo. El sistema informa por medio de

una interfaz gráfica de usuario, las zonas de parqueo libres existentes, también asigna

óptimamente la ubicación de parqueo y genera una dirección web en donde se muestra

una guía de ruta que permite llegar al parqueadero libre asignado.

Palabras clave: Scikit Learn, red neuronal artificial, aprendizaje supervisado,

procesamiento digital de imágenes, plano de ruta.

X PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE


Abstract

In this monograph the information is recorded, of the research process, development and

results obtained. The purpose of the research is to create an alternative solution to the

problem that is that at present some of the parks that provide the service, in shopping

centers, do not There is a parking space specific to cars, leaving the location of these

cars, be free to the decision of each user; Other parking lots do not take into account the

totality of the cars that are inside, which can determine if this reaches its maximum

capacity, or not. These practices can generate traffic congestion within the parking lot,

little comfort for users, and no adequate rotation is generated in terms of the use of all

parking spaces with parking accounts. Taking into account the problems described

above, a prototype system was proposed as a solution alternative, which allows

managing the occupation of parking spaces by means of an artificial neural network

(RNA). This prototype system allows solving the problems described, and meets the

objective of the management of parking spaces. The system informs by means of a

graphical user interface, the existing free parking areas, also assigned in an optimal way

the parking location and generates a web address where a route guide is shown that

allows to reach the assigned free parking.

Keywords: Scikit Learn, artificial neural network, supervised learning, digital image

processing, route plan.

Contenido XI

Contenido

Pág.

Resumen ......................................................................................................................... IX

Lista de figuras ............................................................................................................. XIII

Lista de Símbolos y abreviaturas ............................................................................... XVI

Introducción .................................................................................................................... 1

1 Delimitación del ejercicio de investigación ............................................................ 5 1.1 Problema ......................................................................................................... 5 1.2 Justificación ..................................................................................................... 5 1.3 Objetivos.......................................................................................................... 6

1.3.1 General ................................................................................................. 6 1.3.2 Específicos ............................................................................................ 6

2 Marco de referencia ................................................................................................. 9 2.1 Evaluación de un sistema de estacionamiento autónomo basado en una red neural BP ................................................................................................................... 9 2.2 Aplicación de arquitecturas modernas de redes neuronales profundas ......... 10

3 Marco teórico .......................................................................................................... 13 3.1 Redes neuronales artificiales ......................................................................... 13

3.1.1 La neurona artificial ............................................................................. 13 3.1.2 El Perceptrón ...................................................................................... 14 3.1.3 Tipos de aprendizaje ........................................................................... 16

3.2 Procesamiento digital de imágenes ............................................................... 17 3.3 Sustracción de fondo ..................................................................................... 19 3.4 Scikit learn ..................................................................................................... 19 3.5 MLPClassifier ................................................................................................ 20 3.6 MLPRegressor ............................................................................................... 20 3.7 BernoulliRBM ................................................................................................. 21 3.8 Máquina de Boltzmann .................................................................................. 21 3.9 Raspberry pi .................................................................................................. 21

4 Ejecución de proyecto ........................................................................................... 23 4.1 Metodología ................................................................................................... 25 4.2 Características del prototipo .......................................................................... 26 4.3 Metodología para tratamiento de imágenes ................................................... 28 4.4 Pruebas de imagen ........................................................................................ 30 4.5 Descripción de la red neuronal ...................................................................... 40

XII PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE


4.5.1 Primera regla .......................................................................................46 4.5.2 Segunda regla .....................................................................................46 4.5.3 Tercera regla .......................................................................................47 4.5.4 Cuarta regla .........................................................................................48

4.6 Desarrollo del código ......................................................................................48 4.7 Funcionamiento de la red local .......................................................................57

5 Resultados ..............................................................................................................63 5.1 Pruebas de usuario ........................................................................................63 5.2 Cumplimiento de las reglas ............................................................................66 5.3 Comparación de aprendizaje de redes neuronales .........................................71

5.3.1 Método MLPClassifier ..........................................................................71 5.3.2 Método MLPRegressor ........................................................................76

6 Conclusiones y recomendaciones ........................................................................79 6.1 Conclusiones ..................................................................................................79 6.2 Recomendaciones ..........................................................................................80

Bibliografía .....................................................................................................................81

Contenido XIII

Lista de figuras

Pág.

Figura 2-1: La topología del modelo de red neuronal de BP. ................................... 10

Figura 2-2: Ejemplo de imagen procesada .............................................................. 11

Figura 2-3: Resultados experimentales .................................................................... 12

Figura 3-1: Esquema de neurona artificial ............................................................... 13

Figura 3-2: Perceptrón de dos capas. ............................................................................ 15

Figura 4-1: Diagrama de bloques general del sistema ................................................... 23

Figura 4-2: Dimensiones de la estructura en madera del prototipo ................................ 26

Figura 4-3: Dimensiones del parqueadero diseñado para el prototipo ........................... 27

Figura 4-4: Metodología usada para el tratamiento de imágenes .................................. 28

Figura 4-5: Diagrama de flujo tratamiento de imágenes ................................................ 29

Figura 4-6: Algoritmo para iniciar prueba de imagen ..................................................... 30

Figura 4-7: Algoritmo del ciclo while utilizado para captura de imágenes ...................... 31

Figura 4-8: Línea de código para realizar resta de imágenes ........................................ 31

Figura 4-9: Primera comparacion entra la imagen actual y el resultado de la resta ....... 32

Figura 4-10: Segunda comparacion entra la imagen actual y la imagen re reconocimiento

....................................................................................................................................... 32

Figura 4-11: Algoritmo de la máscara para identificar cambios en la imagen ................ 32

Figura 4-12: Algoritmo utilizando cv2.mpments (resm) .................................................. 33

Figura 4-13: Línea de código para identificación de contorno ........................................ 33

Figura 4-14: Definición de los vectores matapx y matapy. ............................................. 33

Figura 4-15: Vista grafica de la delimitación de los vectores matapx y matapy .............. 34

Figura 4-16: Esquina del rectángulo del cual se toman las coordenadas ...................... 34

Figura 4-17: Prueba de comparación y detección en sus diferentes capaz ................... 35

Figura 4-18: Algoritmo con GPI0.Input(5) para detectar acción en el pulsador .............. 35

Figura 4-19: Algoritmo con la función Draw_sal() .......................................................... 36

Figura 4-20: Asignación de parqueadero en conteo de número par. ............................. 37

Figura 4-21: Asignación de parqueadero en conteo de número par. ............................. 37

Figura 4-22: Asignación de parqueadero en conteo de número impar. .......................... 38

Figura 4-23: Creación de los círculos de entrada y de centro de plaza de parqueo ....... 38

Figura 4-24: Creación de las líneas de guía en la ruta para parquear ........................... 38

Figura 4-25: Creación del mapa para las diferentes páginas web.................................. 39

Figura 4-26: Condiciones programadas de la página web ............................................. 39

Figura 4-27: Ejemplo de funcionamiento de la página web. ........................................... 40

Figura 4-28: Estructura básica de la red neuronal ......................................................... 42

XIV PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE


Figura 4-29: Estructura de la red neuronal ..................................................................... 42

Figura 4-30: Diagrama de flujo proceso de aprendizaje ................................................. 43

Figura 4-31: Esquema básico de las plazas de parqueo ................................................ 44

Figura 4-32: Esquema de las plazas de parqueo numeradas ......................................... 44

Figura 4-33: Matrices para el control de las plazas de parqueo ..................................... 45

Figura 4-34: Ejemplo de la primera regla, plaza de parqueo ocupada (rojo) y libre (verde)

....................................................................................................................................... 46

Figura 4-35: Ejemplo de la segunda regla, plaza de parqueo ocupada (rojo) y libre

(verde) ............................................................................................................................ 47

Figura 4-36: Ejemplo de la tercera regla, plaza de parqueo ocupada (rojo) y libre (verde)

....................................................................................................................................... 47

Figura 4-37: Ejemplo de la cuarta regla, plaza de parqueo ocupada (rojo) y libre (verde)

....................................................................................................................................... 48

Figura 4-38: Algoritmo utilizando Def search_section2() ................................................ 49

Figura 4-39: Algoritmo utilizando Def Vacio () ................................................................ 50

Figura 4-40: Algoritmo utilizando Def Tiempo() .............................................................. 50

Figura 4-41: Algoritmo utilizando Topos() ....................................................................... 51

Figura 4-42: Algoritmo utilizando Search_position() ....................................................... 52

Figura 4-43: Segmento de código regla dos ................................................................... 52

Figura 4-44: Segmento de código regla tres .................................................................. 53

Figura 4-45: Algoritmo utilizando Sear_section1() .......................................................... 53

Figura 4-46: Algoritmo utilizando Def learn() .................................................................. 54

Figura 4-47: Algoritmo utilizando Def Prediccion() ......................................................... 55

Figura 4-48: Algoritmo utilizando Def forlearn() .............................................................. 56

Figura 4-49: Algoritmo para la creación de códigos QR y la edición de la imagen en la

página web ..................................................................................................................... 57

Figura 4-50: Publicación de codigo QR y alfanumérico .................................................. 57

Figura 4-51: Estructura de la red local utilizada .............................................................. 58

Figura 4-52: Configuración de la dirección IP del computador para crear red local ........ 59

Figura 4-53: Página de prueba index.html ...................................................................... 60

Figura 4-54: Código de la página web utilizada .............................................................. 60

Figura 5-1: Código alfanumérico y QR mostrados en pantalla ....................................... 63

Figura 5-2: Referencia de autos en el parqueadero ....................................................... 64

Figura 5-3: Escaneo de código QR ................................................................................ 64

Figura 5-4: Lectura de la dirección de página ................................................................ 65

Figura 5-5: Dirección de página web en el navegador .................................................... 65

Figura 5-6: Visualización del plano de ruta en la página ................................................ 66

Figura 5-7: Imagen actual del parqueadero (regla 1)...................................................... 67

Figura 5-8: Asignación realizada (regla 1) ...................................................................... 67

Figura 5-9: Imagen actual del parqueadero (regla 2)...................................................... 68

Figura 5-10: Asignación realizada (regla 2) .................................................................... 68

Figura 5-11: Imagen actual del parqueadero (regla 3) .................................................... 69

Figura 5-12: Asignación realizada (regla 3) .................................................................... 69

Contenido XV

Figura 5-13: Imagen actual del parqueadero (regla 4) ................................................... 70

Figura 5-14: Asignación realizada (regla 4) ................................................................... 70

Figura 5-15: Conversión de vector binario, a numero decimal ....................................... 71

Figura 5-16: Porcentaje de aciertos vs porcentaje de error (100 capas) ........................ 72

Figura 5-17: Porcentaje de aciertos vs porcentaje de error (90 capas) .......................... 72

Figura 5-18: Porcentaje de aciertos vs porcentaje de error (80capas) ........................... 73






Figura 5-24: Porcentaje de aciertos vs porcentaje de error (100 capas) ........................ 76

Figura 5-25: Porcentaje de aciertos vs porcentaje de error (100 capas), segunda prueba

....................................................................................................................................... 77

Contenido XVI

Lista de Símbolos y abreviaturas

Símbolos con letras latinas Símbolo Término Unidad SI Definición

A Área m2 ∬

Símbolos con letras griegas Símbolo Término Unidad SI Definición

α Factor de superficie

(wF,waf)(ABET)

η mittlere 1 Ecuación 3.6

Subíndices Subíndice Término

E Experimental

Superíndices Superíndice Término

T Exponente, potencia

Abreviaturas Abreviatura Término

BP Back Propagation

Introducción

En la actualidad existen diferentes soluciones electrónicas o de software, para el

creciente negocio de los parqueaderos, estas alternativas de solución van desde

aplicaciones para dispositivos celulares tales como Cellular Parking System, My park o

NIDOO, entre otras, que sirven para la reserva de lugares de parqueo o cálculo de

tarifas; las alternativas de solución llegan hasta parqueaderos automatizados tales como

Parkeo, un parqueadero con una plataforma totalmente robotizada que presta el servicio

en Bogotá, está diseñado con tecnología que ya ha sido implementada en muchos

parqueaderos alrededor del mundo; las soluciones que son implementadas varían

dependiendo de la zona y el tipo de clientes que se tienen, y lo máximo que estos

pueden pagar por el servicio.

Por esto se parte de la idea de crear una alternativa de solución que sea económica y útil

tanto para los dueños de parqueadero, como para los usuarios de los mismos, y por lo

tanto esta alternativa genere interés y se pueda acoplar en los parqueaderos presentes

en la ciudad que cumplan con requerimientos de luminosidad e infraestructura; se inicia

por identificar los principales problemas o necesidades que se presume puedan tener

tanto los usuarios, como los dueños de los parqueaderos, de los problemas identificados

se seleccionan los que se creen más importantes o frecuentes para trabajar en la

solución de estos.

Identificamos que la gestión de la mayoría de aspectos de un parqueadero en un centro

comercial, son el eje fundamental para su buen funcionamiento, siendo uno de los

aspectos más importantes, la gestión de ocupación de las plazas de parqueo; ya que

cuando funciona correctamente, se ven beneficiados tanto el que ofrece el servicio como

también al usuario final; los eventos que pueden generar que por el contrario, se vean

afectados son: ya sea porque se genera congestión vehicular, atascamiento dentro del

parqueadero, o porque a ciertas horas la demanda de plazas de parqueo es alta y es

difícil para los usuarios encontrar espacios para estacionar rápidamente, y puede

2 Introducción

suceder que tengan que dar vueltas antes de encontrar una plaza de parqueo; se pueden

presentar uno, varios o todos los eventos anteriores.

Los usuarios eventualmente podrían querer parquear todos en el mismo lugar, ya sea

porque quedan más cerca a la puerta o al supermercado, esto genera que cuando hacen

sus compras y se disponen a guardarlas en el automóvil, no encuentran espacio para

abrir las puertas correctamente y termina generando inconvenientes entre dueños de

automóviles o congestión vehicular; con respecto al que ofrece el servicio de

parqueadero, tiene como resultado que unas plazas tienen más desgaste en su

superficie que otras, y le generan una necesidad de mantenimiento más frecuente, y por

lo tanto más gasto de dinero.

También se llega al caso de que los que ofrecen el servicio de parqueadero se ven en la

necesidad de contratar una persona que esté pendiente de todos los aspectos del

parqueadero, hasta de verificar visualmente si quedan plazas de parqueo disponibles,

porque no tienen una herramienta electrónica, que se vuelve necesaria para realizar un

monitoreo constante y automático.

Algunas empresas se dedican a la automatización de parqueaderos, estas empresas

tales como Signal Park, Park Help o circontrol tienen soluciones electrónicas, que

contemplan la utilización de un sensor por plaza de parqueo, estas soluciones permiten

sensar la totalidad de las plazas de parqueo, es decir que si un parqueadero cuenta con

100 plazas de parqueo necesitara la misma cantidad de sensores, además de todo el

cableado que estos sensores necesitarán, resultan entonces sistemas con gran cantidad

sensores; como solución a esto se propuso utilizar una cámara de video como reemplazo

de sensores, ya que por medio del procesamiento de sus imágenes se obtendrá

información que permite verificar múltiples plazas con una única cámara, lo que reduce la

cantidad de sensores necesarios para realizar el monitoreo.

Como se quiere plantear una solución generalizada que pueda ser usada en diferentes

parqueaderos, inicialmente el sistema fue montado en un prototipo a escala que permite

realizar pruebas de funcionamiento, esto permite simular condiciones de luminosidad y

de la forma en que están distribuidas las plazas de parqueo, estas condiciones podrían

Introducción 3

encontrarse en los parqueaderos reales, por lo tanto el sistema debe ser adaptable,

simplemente modificando sus parámetros.

Este prototipo también tiene la capacidad de simular como seria todo el proceso desde

que un automóvil entra, y hasta que sale, es decir como es la interacción entre el sistema

y el usuario, y verificar su correcto funcionamiento; para la solución además no se utiliza

más que un minicomputador de bajo costo, una cámara de video, un pulsador, y una

pantalla, esto hace que el sistema sea económico. El prototipo solo está pensado para

parqueaderos cerrados, donde la luz no cambie considerablemente con el paso del

tiempo.

Uno de los aspectos más importantes del sistema es la utilización de una red neuronal

para la toma de decisiones con respecto a la gestión, ya que esta permite, programar

diferentes parámetros para cada parqueadero según sea el caso y la necesidad del

momento, con esto la gestión del parqueadero tiene la opción de ser flexible; en este

caso se diseñó un plano de parqueadero y se establecieron los parámetros de la red

más acordes a la estructura de distribución de las plazas de parqueo.

1 Delimitación del ejercicio de investigación

1.1 Problema

Algunos parqueaderos que prestan el servicio, en cualquier tipo de centro comercial, no

asignan una ubicación de parqueo específica a los automóviles, dejando que la ubicación

de estos automóviles, quede libre a la decisión de cada usuario; otros parqueaderos no

tienen en cuenta el número de automóviles que se encuentran en su interior lo que puede

determinar si este llego a su máxima capacidad, o no. Estas prácticas puede llegar a

generar congestión dentro del parqueadero, poca comodidad para los usuarios ya que

los vehículos se ubican muy cerca unos de otros y no dejan espacio suficiente para la

apertura de puertas y el ingreso de mercancía, tampoco se genera una rotación

adecuada en cuanto al uso de todas las plazas de parqueo con las que cuenta el

parqueadero.

1.2 Justificación

Con este sistema se espera beneficiar a usuarios directos es decir a todas las personas o

empresas que tengan como actividad económica el prestar el servicio de parqueadero,

así como también las personas que son usuarias de estos parqueaderos y en general se

beneficiaran de manera indirecta toda la comunidad que tenga que ver de una u otra

forma con el funcionamiento de estos parqueaderos. Logrando con la gestión de los

parqueaderos una mejor experiencia y comodidad a la hora de usar el servicio, la

organización también permitirá mejorar aspectos como el tiempo de entrada y de

parqueo.

La gestión automática de los parqueaderos generara un ahorro de tiempo y dinero. La

gran mayoría de los sistemas para parqueaderos que se encuentran actualmente en el

mercado tienen un alto costo, por lo que su compra e implementación desde el punto de

vista del desarrollo tecnológico no es viable, además de que el proyecto se desarrolla con

6 PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE


equipos de bajo costo, se cambia la configuración de múltiples sensores a una de un

único sensor y el programa es diseñado en software libre, las personas o empresas

interesadas preferirán implementar un sistema que ofrezca una solución de bajo costo y

que brinde seguridad.

Este sistema tendrá como avance el uso de la tecnología de una Raspberry pi 2,

ampliando el rango de posibilidades y permitiendo ahora la toma de datos del sistema por

medio de una cámara de video, lo que facilita un monitoreo constate. Esto lo hace un

sistema efectivo y de menor costo, superando así los aspectos más importantes de la

mayoría de los sistemas actuales existentes.

También, si se tiene en cuenta que actualmente existe una tendencia cada vez más

fuerte al cambio por implementaciones en plataformas de software libre, se tiene una

gran ventaja, y con la implementación de una red neuronal artificial, se espera que el

sistema tenga una mejor capacidad en la toma de decisiones en cada momento en el que

se requiera. Por tanto, se espera que este sistema tenga muchas implementaciones a

corto y mediano plazo.

1.3 Objetivos

1.3.1 General

Diseñar un sistema prototipo para gestión de ocupación de parqueaderos por medio de

una red neuronal artificial.

1.3.2 Específicos

Detectar cuando un usuario oprima el pulsador de solicitud de parqueo y

publicarle en pantalla un código alfanumérico, que representa la plaza de parqueo

asignada.

Generar y publicar en pantalla un código QR para cada usuario, este código

contiene una dirección web, en la cual se visualiza un plano de vista superior del

parqueadero, y una ruta desde la entrada hasta la plaza asignada.

Identificar por medio de la cámara de video, si cada plaza de parqueo se

encuentra disponible u ocupada.

Capítulo 1 7

Asignar una plaza de parqueo a cada usuario, por medio de una red neuronal

artificial (RNA) diseñada en Python utilizando la herramienta Sckit learn.

2 Marco de referencia

2.1 Evaluación de un sistema de estacionamiento autónomo basado en una red neural BP

El sistema de aparcamiento autónomo es un sistema inteligente que puede aparcar un

coche en una plaza de aparcamiento. Recientemente, más y más estudios prestan

atención en este sistema. Sin embargo, la investigación sobre la evaluación del sistema

de estacionamiento autónomo en estos estudios no es suficiente. Debido a que la

mayoría de los métodos de evaluación del sistema de vehículos inteligentes se basan en

el grado de realización de tareas, la evaluación del sistema de estacionamiento

autónomo no puede mostrar su nivel real inteligente. (Du, Zhao, Gao, & Wang, 2017)

Con el fin de garantizar la viabilidad y exactitud de la evaluación del sistema de

estacionamiento autónomo, se propone un método de evaluación eficaz basado en la red

neuronal de BP. El método de evaluación se establece sobre la base del sistema de

evaluación del sistema de estacionamiento autónomo, utilizando el modelo de evaluación

de la red neuronal de BP. Utilizando muestras recogidas del sistema de estacionamiento

autónomo en vehículos inteligentes, el modelo es entrenado por el software MATLAB y el

modelo de evaluación es probado por muestras. Se tuvo como resultado que los valores

de simulación son muy cercanos a los esperados, lo que significa la viabilidad y exactitud

del modelo de evaluación. (Du et al., 2017)



Figura 2-1: La topología del modelo de red neuronal de BP.

(Du et al., 2017)

Donde d1 es la distancia más corta del vehículo desde la acera, N1 el número de

conmutadores de avance / retroceso, N2 el número de paradas, N3 el número de

dirección, D es la distancia total del proceso de estacionamiento, t el tiempo total del

proceso de estacionamiento, d2 la distancia desde el centro del vehículo al centro del

espacio de estacionamiento y Q el ángulo entre el eje longitudinal del vehículo y el

espacio de estacionamiento, S simplemente es la salida de la red neuronal.

2.2 Aplicación de arquitecturas modernas de redes neuronales profundas

Al clasificar imágenes, es importante seleccionar un método para extraer características

de una imagen que puede ser una tarea bastante difícil. Recientemente, el aprendizaje

profundo de redes neuronales ha mostrado buenos resultados en la extracción de

características automáticas para una clasificación posterior, por esto se evalúa la

capacidad de utilizar una red neuronal de convolución moderna GoogLeNet para la

extracción automática y la clasificación de imágenes adicionales. La tarea de clasificación

se revisa en el contexto de un problema de determinación de lugares de estacionamiento

vacantes. La red neuronal ha mostrado un resultado comparable con el resultado de la

clasificación en las características seleccionadas manualmente, pero más sostenible para

las transformaciones de imagen. (Mityakov, Varankin, & Tatarinov, 2017)

Capítulo 1 11

En la tarea de clasificación de imágenes, lleva mucho tiempo preparar el conjunto de

datos para el entrenamiento. En este caso, este conjunto de datos es un conjunto de

imágenes relacionadas con una de dos clases: "lugar vacante" o "lugar ocupado". Las

imágenes se anotaron manualmente utilizando la herramienta LabelImg. En la figura se

muestra una imagen procesada. Debido a que las imágenes en nuestra tarea son

estáticas, se realizó una modificación significativa de la herramienta utilizada. Su

modificación nos permitió no anotar cada imagen individualmente, sino cambiar solo los

estados de los lugares anotados y, por lo tanto, ahorrar tiempo para la preparación del

conjunto de datos de capacitación. Entonces la anotación de 2167 imágenes tomó

aproximadamente 2 horas. Como resultado, se creó el conjunto de datos de capacitación

que contiene 1726 imágenes con la clase "ocupada" y 441 imágenes con la clase

"vacante". (Mityakov, Varankin, & Tatarinov, 2017)

Figura 2-2: Ejemplo de imagen procesada

(Mityakov et al., 2017)



Figura 2-3: Resultados experimentales

Utilizando la red neuronal GoogLeNet, se logra obtener una calidad de reconocimiento

comparable con el método elegido manualmente. Las características de red neuronal

seleccionadas automáticamente son resistentes a la transformación de la imagen de

origen, a diferencia de las características de HOG se encontró. Debido a la rápida mejora

de los marcos para el desarrollo y capacitación de redes neuronales en procesadores

gráficos y la disponibilidad pública de los últimos desarrollos en esta área, el uso de

redes neuronales se vuelve disponible para resolver problemas de diversa complejidad y

presupuesto. Así que en este trabajo, la capacitación de la red neuronal en el conjunto de

entrenamiento compuesto por 2167 imágenes tomó aproximadamente 12 minutos en una

computadora con la tarjeta de video de la familia nvidia gtx 1070. (Mityakov, Varankin, &

Tatarinov, 2017)

3 Marco teórico

3.1 Redes neuronales artificiales

3.1.1 La neurona artificial

La neurona artificial es una unidad procesadora con cuatro elementos funcionales:

Figura 3-1: Esquema de neurona artificial

(Lara, n.d.)

El elemento receptor, a donde llegan una o varias señales de entrada xi, que

generalmente provienen de otras neuronas y que son atenuadas o amplificadas cada una

de ellas con arreglo a un factor de peso wi que constituye la conectividad entre la

neurona fuente de donde provienen y la neurona de destino en cuestión. (Lara, n.d.)

El elemento sumador, que efectúa la suma algebraica ponderada de las señales de

entrada, ponderándolas de acuerdo con su peso, aplicando la siguiente expresión:

( ) (3.1)



El elemento de función activadora, que aplica una función no lineal de umbral (que

frecuentemente es una función escalón o una curva logística) a la salida del sumador

para decidir si la neurona se activa, disparando una salida o no. (Lara, n.d.)

El elemento de salida que es el que produce la señal, de acuerdo con el elemento

anterior, que constituye la salida de la neurona. Este modelo neuronal es el utilizado en

casi todas las Redes Neuronales artificiales, variando únicamente el tipo de función

activadora. A continuación se presentarán los modelos más simples de Redes

Neuronales artificiales. (Lara, n.d.)

3.1.2 El Perceptrón

Desarrollado por Rosenblatt (1958), consiste en una neurona procesadora, con sus

elementos de entrada, sumador, activador y de salida. A la cual llegan señales de

entrada xi, i = 1, 2,..., n cada una con una a través de una línea con conductividad o peso

asociado wi. El elemento sumador efectúa entonces una suma ponderada de las

entradas, en tanto que el activador emplea una función escalón de umbral: si la suma

ponderada es mayor o igual a un valor de umbral U, da una salida y de tal manera que:

(3.2)

(3.3)

La red neuronal más simple construida con perceptrones tiene dos capas: una capa

receptora de entrada, en la que la salida de cada neurona reproduce simplemente su

entrada y una capa de salida formada por perceptrones como los descritos, totalmente

conectados con la capa de entrada, a través de líneas de comunicación con

conductividades o pesos ajustables. (Lara, n.d.)

Así, cada neurona de entrada está conectada con cada neurona de salida a través de

una línea de comunicación con una conductividad o peso ajustable. La ley de aprendizaje

del perceptrón ajusta estos pesos, de manera que se obtenga con mayor probabilidad la

salida deseable correspondiente a un cierto conjunto de entradas. (Lara, n.d.)

Capítulo 1 15

Figura 3-2: Perceptrón de dos capas.

(Lara, n.d.)

El perceptrón es entrenado presentándole un conjunto de patrones de entrenamiento en

forma repetida. Cada patrón de entrenamiento es una pareja formada por un vector de

entrada x y su vector de salida y deseable. La dimensión del vector de entrada es igual al

número de neuronas de la capa de entrada, en tanto que la dimensión del vector de

salida es igual al número de neuronas de la capa de salida. (Lara, n.d.)

Al presentarle el vector de entrada al perceptrón, sus neuronas de entrada lo asumen.

Las salidas de la red se comparan con el vector de salida y la diferencia obtenida se

utiliza para reajustar los valores de los pesos w de las interconexiones. Este reajuste se

hace de modo que sea más probable que la red dé la respuesta apropiada la siguiente

vez. El entrenamiento prosigue hasta que todas las respuestas de la red se aproximan en

forma aceptable a las deseadas. (Lara, n.d.)

Para el reajuste de los pesos, existen diferentes reglas propuestas posteriormente por

diferentes autores, basadas en la Regla Delta de Widrow y Hoff (1960). En una de las

más sencillas, el nuevo peso w1 es igual al peso anterior w0 más una cantidad

proporcional a la diferencia entre la salida deseada t y la salida real y:

( ) (3.4)

Donde h es una constante de proporcionalidad menor que la unidad que se llama razón

de aprendizaje. (Lara, n.d.)



Si el vector de entradas es de ceros y unos, hay una fórmula derivada en la que la razón

de aprendizaje se multiplica por la entrada correspondiente x. De este modo, el peso se

modifica solo cuando la entrada vale 1, es decir, cuando está activa. Así, la fórmula

anterior queda en la forma:

( ) (3.5)

De acuerdo con estas fórmulas, el nuevo peso es mayor que el anterior, si la salida

deseada es mayor que la actual y menor en el caso contrario. (Lara, n.d.)

Antes de comenzar el entrenamiento, los pesos se fijan aleatoriamente. Durante el

entrenamiento, los patrones de entrenamiento se presentan a la red una y otra vez (a

veces cientos y hasta miles de veces), hasta que los pesos ya no se modifican. En este

caso se dice que la red ha convergido, en cuyo caso o ha aprendido con éxito o se

declara incapaz de aprender todas las respuestas correctas. (Lara, n.d.)

Las limitantes más grandes del perceptrón es que, aunque pueden construirse Redes

Neuronales de varias capas con él, no permite más que una sola capa de pesos

adaptativos. (Lara, n.d.)

3.1.3 Tipos de aprendizaje

Se ha mencionado ya que una de las características fundamentales de las Redes

Neuronales es su adaptabilidad y su susceptibilidad de aprendizaje, a través de la

modificación de los pesos de las interconexiones entre las diferentes neuronas. (Lara,

n.d.)

Hay dos formas fundamentales de aprendizaje:

Aprendizaje supervisado, que requiere la presencia de un tutor externo y una serie de

patrones de aprendizaje. El tutor conoce el vector de respuesta correcto ante cada

vector de entradas y, con la respuesta real de la red, genera un vector de error, que

retroalimenta a ésta. La red, con base en el vector de error, actualiza los pesos de sus

interconexiones de manera que el error tienda a desaparecer. Con un número

suficiente de sesiones de entrenamiento, la red converge, produciendo las respuestas

Capítulo 1 17

deseadas. Este tipo de aprendizaje es el aplicado tanto en el Perceptrón, como en la

Adaline.

Aprendizaje no supervisado, que utiliza datos de entrenamiento no etiquetados

previamente y no necesita tutor externo. Los datos son presentados simplemente a la

red, que de acuerdo con ellos configura cúmulos internos que comprimen los datos de

entrada en cierto número de categorías de clasificación. Este tipo de aprendizaje es el

aplicado en las Redes de Kohonen. (Lara, n.d.)

3.2 Procesamiento digital de imágenes

El Procesamiento de Imágenes (PI) es una subcategoría del tratamiento digital de

señales. Es la ciencia de manipulación de imágenes usando computadores para realizar

procedimientos específicos según las aplicaciones y requerimientos del usuario, tales

como: filtrado, recorte, segmentación, compresión y reconocimiento. Es un área del

conocimiento que tiene atención de investigadores y escolares para desarrollar y mejorar

algoritmos para aplicaciones en: robótica, comunicaciones, sensores remotos,

biomedicina, automatización industrial, sistemas de inspección, navegación, mediciones

ópticas, entre otras. (Jiménez, Pelayo, & Ramírez, 2015)

Las prácticas de laboratorio son actividades pedagógicas, y en el estudio del PI éstas se

realizan mediante el uso de algún software especializado. Algunos software comerciales

de procesamiento de imágenes como: Photoshop, CorelDraw, Ulead Photoimpact, entre

muchos otros, realizan procedimientos internos que no permiten el entendimiento de

algoritmos, la lógica o el método del proceso, presentando cajas negras que no admiten

su manipulación. Después de su uso, los estudiantes se vuelven expertos en la

herramienta mas no en el procesamiento de imágenes, que por supuesto podría ser

adecuado para diseñadores digitales, pero no para ingenieros electrónicos, ni de

sistemas.(Jiménez et al., 2015)

Se han realizado esfuerzos por el desarrollo de herramientas didácticas para la

enseñanza del tratamiento digital de imágenes y existen paquetes comerciales para

aplicación de laboratorios de PI, como por ejemplo MATLAB y Khoros, con desventajas

similares a las herramientas de manipulación de imágenes comerciales, adicionando el

elevado costo de licencias para su instalación. Existen también plataformas no

comerciales independientes desarrolladas en C o Java, ambientes para el análisis de



imágenes tales como IPLab, colecciones de rutinas y clases sin ambientes y también

gran cantidad de applets interactivos independientes en internet que permiten

comprender algoritmos relacionados con el tema. Varias universidades han

implementado cursos virtuales para trabajar bajo herramientas E-Learning con los

estudiantes interesados en PI, en donde se ha logrado hacer que el aprendiz reciba

instrucciones acerca de la edición de imágenes y tener la opción de manipularlas en

línea. (Jiménez et al., 2015)

Para poder comprender claramente los conceptos y algoritmos del PI deben tener como

prerrequisito el conocimiento de: algebra lineal, análisis multivariado y del procesamiento

de señales, siendo estos conceptos muchas veces abstractos. Por esta razón es

necesaria la práctica e interactividad con las herramientas de software para lograr efectos

positivos en la comprensión de conceptos, ya que la enseñanza y aprendizaje de los

fundamentos de PI se logra si la atención está en la representación visual de los

algoritmos y el trabajo experimental. La visualización en PI puede considerarse como un

factor de impulso cognitivo mientras la descripción plana textual requiere un poco de

imaginación y habilidades interpretativas, con un resultado pedagógico positivo al

visualizar herramientas para la demostración de aspectos básicos del procesamiento de

imágenes. Muchas aplicaciones tales como: juegos de video, graficas por computador,

pos-procesamiento de imágenes y video, estimación y compensación de movimiento, son

implementados mediante soluciones de software en procesadores de propósito general.

(Jiménez et al., 2015)

Para que la aplicación en software sea útil en el aprendizaje del PI debe ser fácil de

aprender, las tareas de PI deben poder implementarse en pequeños programas y las

complejas usando sub-tareas, los programas deben correr lo más rápido posible, la

visualización de las imágenes debe ser simple y rápida, y debe ser posible visualizar el

progreso del procesamiento en cada una de sus etapas. En esencia, se busca utilizar

una herramienta de software que permita a la vez aprender a utilizar un lenguaje de

programación mientras se aplican los conceptos teóricos, para lo cual se pueden

desarrollar aplicaciones en MATLAB, C++, C, Java, Visual Basic, Python, entre otros.

(Jiménez et al., 2015)

Capítulo 1 19

Se ha planteado el uso de Python el cual permite desarrollar aplicaciones de alta calidad

en la producción de software, con aplicabilidad en la investigación y el diseño de

proyectos de nivel avanzado. Python es un lenguaje de programación de alto nivel,

interpretado y multipropósito, cuyo creador es Guido Van Rossum. En los últimos años su

utilización ha aumentado y es uno de los lenguajes de programación más empleados

para el desarrollo de software. Python puede ser utilizado en diversas plataformas y

sistemas operativos, entre los que se puede destacar: Windows, Mac OS X, Linux o

Raspbian, el cual es el sistema operativo utilizado en este proyecto. Pero, además,

Python también puede funcionar en smartphones y sistemas embebidos, por todas estas

razones se decidió utilizar esta herramienta en el prototipo. (Jiménez et al., 2015)

3.3 Sustracción de fondo

El método utilizado para discriminar el fondo de los objetos, se realiza a nivel de pixel.

Para esto, para cada pixel se almacenan N muestras de frames anteriores al actual

elegidos aleatoriamente, y se determina que son fondo aquellos que son

estadísticamente invariante en el tiempo. En la práctica se define N como 20. Para cada

muestra, puede guardarse tanto la información de color (por ej. en el espacio de colores

RGB) como su valor en tono de grises, dependiendo de la imagen de entrada con la que

se cuenta. Como consecuencia de la detección o salida realizada por cada imagen o

cuadro del video, se debe realizar un proceso de actualización del modelo que permita

adaptar gradualmente la representación a los diferentes cambios que ocurren a lo largo

de una secuencia. Esta actualización se realiza una vez realizada la sustracción de fondo

en el cuadro actual y consiste en agregar en el modelo aquellos pixeles pertenecientes al

fondo. Así mismo, aquellos clasificados como parte del movimiento se asegura que no se

inserten en el modelo, ya que puede alterar significativamente los resultados en la

detección.(Gervasoni, D’amato, & Barbuzza, 2014)

3.4 Scikit learn

Sirve para realizar el proceso de aprendizaje automático de máquina o de una red

neuronal el cual se trata de aprender algunas propiedades de un conjunto de datos y

aplicarlos a nuevos datos. Esta es la razón por la cual una práctica común en el

aprendizaje automático para evaluar un algoritmo es dividir los datos disponibles en dos



conjuntos, uno que llamamos el conjunto de entrenamiento en el que aprendemos

propiedades de datos y otro que llamamos el conjunto de pruebas en el que probamos

estas propiedades, esta herramienta la encontramos disponible en Python, y permite

utilizar una red neuronal preestablecida y entrenarla según los parámetros que se

deseen. (scikit-learn developers & Developers, 2017)

En general, un problema de aprendizaje considera un conjunto de n muestras de datos y

luego trata de predecir propiedades de datos desconocidos. Si cada muestra es más de

un número único y, por ejemplo, una entrada multidimensional (también conocida como

datos multivariables), se dice que tiene varios atributos o características. (scikit-learn

developers & Developers, 2017)

3.5 MLPClassifier

Herramienta de Scikit learn. MLPClassifieradmite la clasificación de clases múltiples

aplicando Softmax como la función de salida. Además, el modelo admite la clasificación

de etiquetas múltiples en la que una muestra puede pertenecer a más de una clase. Para

cada clase, la salida sin procesar pasa a través de la función logística. Los valores

mayores o iguales a 0.5 se redondean a 1, de lo contrario a 0. Para un resultado predicho

de una muestra, los índices donde el valor es 1 representan las clases asignadas de esa

muestra.(scikit-learn developers & Developers, 2017)

3.6 MLPRegressor

Herramienta de Scikit learn. La clase MLPRegressor implementa un perceptrón multicapa

(MLP) que entrena usando backpropagation sin función de activación en la capa de

salida, que también puede verse como el uso de la función de identidad como función de

activación. Por lo tanto, utiliza el error cuadrado como la función de pérdida y el resultado

es un conjunto de valores continuos. MLPRegressor también admite la regresión de

salida múltiple, en la cual una muestra puede tener más de un objetivo. (scikit-learn

developers & Developers, 2017)

Capítulo 1 21

3.7 BernoulliRBM

Herramienta de Scikit learn. En el BernoulliRBM, todas las unidades son unidades

estocásticas binarias. Esto significa que los datos de entrada deben ser binarios o tener

valores reales entre 0 y 1, lo que significa la probabilidad de que la unidad visible se

encienda o apague. Este es un buen modelo para el reconocimiento de caracteres,

donde el interés está en qué píxeles están activos y cuáles no. Para las imágenes de

escenas naturales, ya no se ajusta debido al fondo, la profundidad y la tendencia de los

píxeles vecinos a tomar los mismos valores. (scikit-learn developers & Developers, 2017)

3.8 Máquina de Boltzmann

La máquina de Boltzmann es una máquina estocástica constituida por unidades de

proceso (neuronas) estocásticas con conexiones sinápticas simétricas entre las mismas.

Dichas unidades de proceso son de dos tipos funcionales: visibles u ocultas. Las

unidades visibles sirven de interfaz entre la red y el entorno en el que opera (recogen la

información suministrada). Durante la fase de entrenamiento se ajustan los estados de

todas las unidades visibles a estados específicos establecidos por los patrones de

entrenamiento (entorno en el que opera) pueden ser, a su vez, de entrada o de salida

mientras que las unidades ocultas siempre operan libremente y se utilizan para explicar

restricciones subyacentes contenidas en los patrones de entrada.(Algoritmo, n.d.)

3.9 Raspberry pi

En el centro de todas las placas Raspberry Pi se encuentra un semiconductor cuadrado,

más comúnmente conocido como circuito integrado o chip. Este es el módulo system-on-

chip (SoC) Broadcom BCM2835, el encargado de proporcionarle a la RasPi sus

capacidades de procesamiento de propósito general, de renderización de gráficos y de

entrada/salida. Apilado sobre este chip se encuentra otro semiconductor, este es el

encargado de proveer la memoria a la RasPi para el almacenamiento temporal de datos

mientras sus programas se encuentran en ejecución. Este tipo de memoria es conocida

como memoria RAM (memoria de acceso aleatorio), ya que la computadora puede leer o

escribir en cualquier parte de la memoria y en cualquier momento. La RAM es volátil, lo

que significa que cualquier cosa almacenada en esta memoria se eliminará cuando la

RasPi pierda su energía o sea desenchufada.(Upton & Halfacree, 2013)



Por la parte de arriba y de abajo del SoC se encuentran las salidas de video de la RasPi.

El conector plata (abajo) es un puerto HDMI (High Definition Multimedia Interface), es del

mismo tipo de conector que se puede encontrar en los reproductores de video y muchos

decodificadores de cable y satélite. Cuando es conectado a un televisor o monitor

moderno, el puerto HDMI proporciona video en alta resolución y audio digital. El conector

amarillo (arriba) es un puerto de video compuesto y está diseñado para conectarse a

televisores antiguos que no cuentan con conexión HDMI. La calidad del video es más

baja que la que está disponible a través del HDMI y no transmite audio; en cambio, el

audio es suministra como una señal analógica a través del conector de audio de 3.5mm a

la derecha del conector del video compuesto. (Upton & Halfacree, 2013)

En la esquina inferior de la placa está la toma de alimentación de la RasPi. Esta es una

toma micro-USB, la misma que está presente en la mayoría de los modernos teléfonos

inteligentes (smartphones) y tablets. La conexión de un cable micro-USB a un adaptador

de energía adecuado encenderá a la Raspberry Pi; a diferencia de una PC o laptop, la

RasPi no cuenta con un botón de encendido y arranca inmediatamente cuando el cable

de la alimentación es conectado. (Upton & Halfacree, 2013)

En la parte inferior de la placa Raspberry Pi, a mano izquierda, se encuentra una ranura

para tarjetas SD. Una tarjeta de memoria SD (Secure Digital) proporciona el

almacenamiento para el sistema operativo, los programas, datos y otros archivos, y no es

volátil; a diferencia de la RAM volátil, la memoria SD conservará su información incluso

cuando la energía se pierda. (Upton & Halfacree, 2013)

El borde a mano derecha de la RasPi tendrá diferentes conectores dependiendo de qué

modelo de Raspberry Pi tenga, el Modelo A o el Modelo B. Arriba de éstos se encuentran

una serie de LEDs (Light Emitting Diodes). Los dos primeros LEDs que están etiquetados

con ACT y PWR proporcionan una notificación de actividad y de energía

respectivamente, y están presentes en todas las placas. La Raspberry pi 2 tiene: Una

CPU ARM Cortex-A7 de cuatro núcleos a 900 MHz y 1GB de RAM. (Upton & Halfacree,

2013)

4 Ejecución de proyecto

La descripción general del proyecto consiste en que se envía un pulso de voltaje a un

minicomputador de placa única (Raspberry pi 2), en el momento que se presiona un

pulsador, y así el sistema detecta cuando un usuario solicita un parqueadero, por otro

lado una cámara de video, toma imágenes y las envía constantemente al minicomputador

el cual basado en una red neuronal artificial le asigna un código alfanumérico y un código

QR al usuario que solicita parquear. Este código QR contiene una dirección de página

web en la que se ve un plano de vista superior del parqueadero, y una ruta desde la

posición inicial hasta la plaza asignada. Un diagrama de bloques general del sistema es

el siguiente:

Figura 4-1: Diagrama de bloques general del sistema

Imágenes digitales



Cuando un usuario quiere solicitar una plaza de parqueo oprime el pulsador, en ese

momento se envía un pulso de voltaje al minicomputador.

Como se comentó anteriormente la mayoría de parqueaderos tienen sensores en cada

plaza de parqueo para detectar si esta se encuentra libre u ocupada, en este caso

decidimos utilizar un único sensor, se trata de una cámara de video, la cual nos aporta

algunas ventajas como son: poco cableado, y recolección de mayor cantidad de

información, lo que permite tener más estrategias para la identificación de automóviles,

también se identificaron algunas desventajas como son: la calibración de la cámara con

respecto a la posición del parqueadero o la sensibilidad a los cambios de luz, ya que al

ser un solo sensor ,al momento de un fallo o cambio brusco no hay forma de saber si la

información recibida es verdadera o falsa. La cámara tiene como función transmitir

imágenes de las plazas de parqueo constantemente al minicomputador,

El minicomputador, es el dispositivo central del sistema, este dispositivo se escogió ya

que cumplía con los requerimientos necesarios para la implementación en el sistema los

cuales eran: la capacidad de soportar y poder ejecutar sin problema Python y su

respectivo procesamiento de imágenes, el procesamiento de datos de la red neuronal,

todo esto sin llegar a bloquearse o exceder su capacidad operativa, también, se buscaba

que el dispositivo tuviera puertos periféricos como puertos GPIO, puertos USB, puerto

Ethernet, y puertos para salida de video; se encontró además que el dispositivo era

económico, por lo que se evidencio que era la solución que mejor se acoplaba a este

proyecto.

El minicomputador tiene como función el procesamiento de los datos entrantes desde la

cámara de video, ejecutando un algoritmo de reconocimiento, encargado de procesar las

imágenes e identificar las plazas libres y ocupadas, con esta información se ejecuta una

red neuronal artificial, que a su salida entregara una plaza específica para parqueo. Las

otras funciones del dispositivo son: generar los códigos para el usuario y enviarlos para

ser publicados en un monitor, así como también almacenar la información que se

muestra en una página web.

Una vez el procesamiento de las imágenes se ha realizado, se genera un código QR que

es mostrado al usuario en un monitor, este código QR es leído por medio de un celular

que posea el usuario, la información contenida en el código es la dirección de un página

Capítulo 1 25

web, a la cual el usuario podrá ingresar conectándose a la red local del centro comercial,

en la página web se encuentra publicado un plano de vista superior del parqueadero, que

contiene una ruta que indica el camino desde la posición inicial del usuario, hasta la plaza

asignada, esta página se genera con la finalidad de dar una guía al usuario en la

búsqueda de la plaza de parqueo asignada.

4.1 Metodología

Se realizó el proceso de recopilación de información sobre conceptos fundamentales a

tener en cuenta y de proyectos similares o fuentes bibliográficas que aportaran al

contenido del proyecto, y se presentan en el marco teórico y de referencia, para así

poder estimar la alternativa de solución que más beneficios adicionaba a los objetivos

propuestos.

Se definió la forma de realización del algoritmo, necesario tanto para la configuración del

controlador como para la interpretación de los datos recibidos del sistema, marcando una

ruta de acción específica para el desarrollo del algoritmo y su correlación con la

publicación en el monitor y la página web. Así mismo Con la información recolectada se

hizo una evaluación de los requerimientos tanto físicos como tecnológicos de cada una

de las etapas, determinando así las posibilidades o limitaciones físicas que presentaban.

Una vez se realizó la adquisición de datos, la ejecución de los códigos, y la publicación

en los diferentes medios, se realizaron las pruebas necesarias de funcionamiento en

conjunto, es decir el acoplamiento de las diferente partes del código o de las diferentes

tareas de dichos códigos; a continuación se realizaron las correcciones a las que había

lugar y las modificaciones de la visualización de las operaciones realizadas.

Cuando todo estuvo debidamente diseñado, montado y acoplado se realizaron pruebas

de funcionamiento al sistema, y con esto se obtuvieron los datos necesarios para evaluar

el comportamiento y verificar si el sistema funcionaba de manera correcta. El análisis

realizado con los resultados de dichas pruebas arrojo que efectivamente el sistema

funciona de forma correcta, y se puede concluir que se cumplieron los objetivos

propuestos y se obtuvieron los resultados esperados.



4.2 Características del prototipo

Para efectos de estabilidad en la captura de imágenes, y para facilidad y protección de

los dispositivos, se creó una estructura en madera que sirve de soporte para todos los

componentes del proyecto, esta estructura y sus dimensiones se muestran a

continuación:

Figura 4-2: Dimensiones de la estructura en madera del prototipo

Capítulo 1 27

La distribución del parqueadero diseñada para el prototipo, se encuentra instalada en la

base de la estructura, muestra la de las zonas de parqueo y las flechas que representan

el sentido de circulación que deben tener los autos, es utilizada para realizar las pruebas

de funcionamiento del sistema, y tiene las siguientes dimensiones:

Figura 4-3: Dimensiones del parqueadero diseñado para el prototipo

En el interior del prototipo se necesitan condiciones de luz controlada, por esto se realizó

la instalación de dos leds de luz blanca, cada uno de 10w, esto con el fin de que las

imágenes se vean claras, y que la luz en el interior no varié durante el funcionamiento,

en lo posible, es importante impedir que no entre luz externa.

El prototipo cuenta con un pulsador para la asignación de plazas de parqueo. Este

pulsador está conectado directamente al minicomputador, estos dos elementos junto con

la cámara digital, fueron acoplados en la estructura manera fija, para minimizar los

riesgos por caída y para volver las capturas de la cámara estables ya que a menos

movimiento de la cámara la captura de las imágenes será mejor, también se fijó la

cámara a una distancia focal fija de 50 cm, para que su enfoque no varié.



4.3 Metodología para tratamiento de imágenes

El propósito fue diseñar un sistema capaz de identificar los elementos y características

de una escena o imagen del parqueadero usado en el prototipo, y de esta forma lograr

extraer información simbólica a partir del reconocimiento de objetos y estructuras

presentes en la imagen. Para lograrlo se llevan a cabo cuatro actividades principales:

Figura 4-4: Metodología usada para el tratamiento de imágenes

Se usan técnicas de procesamiento de imágenes en Python y herramientas como

OpenCv, que están estrechamente relacionadas con la visión artificial, se utilizan para

facilitar la localización y detección de áreas de interés en las imágenes.

Capítulo 1 29

El diagrama de flujo que explica el algoritmo que se utilizó en el tratamiento de imágenes

es el siguiente:

Figura 4-5: Diagrama de flujo tratamiento de imágenes



4.4 Pruebas de imagen

Para realizar estas pruebas se utilizó una cámara digital con las siguientes

características: tiene una conexión al minicomputador por medio de USB, alcanza una

tasa de unos 15 a 30 fotogramas por segundo, y tiene la posibilidad de utilizarse en las

siguientes resoluciones (320x240) y (640x480).

Para este proyecto se decidió trabajar con la resolución de (320x240) ya que tiene menos

cantidad de pixeles y por lo tanto el procesamiento de cada imagen se hace más rápido,

así mismo si el procesamiento se realizara con la resolución de (640x480) se obtendrían

más información en cada imagen pero el procesamiento demoraría más, para efectos de

este prototipo la imagen con resolución de (320x240) resulto con la suficiente

información, por lo tanto se eligió.

Para el uso de la cámara de video se utiliza la librería open.cv de Python, que se encarga

del procesamiento de las imágenes.

Figura 4-6: Algoritmo para iniciar prueba de imagen

Primero se inicializa la cámara física con la línea cap = cv2.videoCapture

Después se le asigna una resolución de 320 x 240, se escoge esta resolución para

facilitar el procesamiento de la imagen, y optimizar los recursos de procesamiento en el

minicomputador.

Se comienza un ciclo while infinito, donde en cada ciclo se capturara una imagen, que

será analizada para detectar los vehículos y las plazas de parqueo.

Capítulo 1 31

Figura 4-7: Algoritmo del ciclo while utilizado para captura de imágenes

Se captura una imagen por medio de la cámara, utilizando la línea cap.read(). Esta

imagen se convierte del formato RGB al Formato HSV para facilitar su procesamiento ya

que se pasa la imagen de un formato de colores a un formato de contraste, esto facilita la

identificación de objetos sin importar su color.

Grisimg es la conversión de la imagen de HSV a blanco y negro.

Frame2 es la imagen de referencia, ya que para detectar los automóviles que entren al

parqueadero, se hace por medio del método de sustracción de fondo, donde se toma una

imagen de referencia (frame2) que corresponde al parqueadero vacío. Esta imagen de

referencia se resta con cada imagen actual para notar los cambios en esta y así detectar

si ha cambiado algo, lo cual puede ser un vehículo que ocupe una plaza de parqueo.

Esta imagen de referencia se toma una sola vez, esto se hace por medio de la variable

bol, ya que al entrar en el if, está cambia de valor y no se vuelve a cumplir la condición de

bol == 0.

Después de tomar la imagen actual, se hace la resta entre esta y la imagen de referencia

por medio de la línea cv2.absdiff.

Figura 4-8: Línea de código para realizar resta de imágenes

Si las imágenes son iguales el resultado (cam) es una imagen totalmente negra.



Figura 4-9: Primera comparacion entra la imagen actual y el resultado de la resta

Si las imágenes son diferentes, en el resultado (cam) se nota la parte que es diferente.

Figura 4-10: Segunda comparacion entra la imagen actual y la imagen re reconocimiento

Figura 4-11: Algoritmo de la máscara para identificar cambios en la imagen

Capítulo 1 33

Seguidamente a la imagen en blanco y negro se le aplica una máscara y se le hace una

dilatación para identificar de manera precisa y concreta los cambios entre la imagen de

referencia y la imagen actual.

En la imagen dilata, guardada en (resm), y se aprecian los objetos que se detectaron por

medio de la diferenciación de la imagen actual y la imagen de referencia.

Con cv2.mpments (resm) obtenemos información sobre los objetos marcados en la

imagen dilatada guardada en (resm) donde m00 corresponde al área de los objetos

encontrados.

Figura 4-12: Algoritmo utilizando cv2.mpments (resm)

Si el área del objeto es mayor a 50 se da la instrucción de hallar sus contornos con

cv2.findContours, y después se halla el contorno externo de los objetos.

Figura 4-13: Línea de código para identificación de contorno

Se crean los vectores matapx y matapy, que limitan el área de cada una de las plazas de

parqueo, esto se crea para tener identificadas la totalidad del área de dichas plazas.

Figura 4-14: Definición de los vectores matapx y matapy.



Figura 4-15: Vista grafica de la delimitación de los vectores matapx y matapy

Después de hallar el contorno de los objetos diferentes entre las imágenes, se halla un

rectángulo que encierra al objeto por completo, por medio de la línea cv2.boundingRect

que retorna x, y, w, h.

Figura 4-16: Esquina del rectángulo del cual se toman las coordenadas

Donde x y y representan las coordenadas en pixeles de la esquina superior izquierda, y

w y h son el alto y el ancho en pixeles del rectángulo.

Capítulo 1 35

Figura 4-17: Prueba de comparación y detección en sus diferentes capaz

Después de esto se hace un barrido por todas las plazas de parqueo, por medio de los

vectores matapx y matapy, si en una de estas se encuentra un objeto, se dibuja en rojo

sobre la pantalla, y se guarda su estado como ocupada, de lo contrario se dibuja en

pantalla esta plaza de parqueo en amarillo y su estado pasa a ser desocupado.

Después de 50 ciclos sin cambios en la imagen de resta, se toman los valores de estado

de cada plaza de parqueo y se transfieren estos datos a la matriz parb.

Figura 4-18: Algoritmo con GPI0.Input(5) para detectar acción en el pulsador



Con la utilización de la línea GPI0.Input(5) se pone el sistema a la espera de que el

usuario oprima un botón de petición que está conectado al pin 5 del minicomputador, con

el cual se le asignara un puesto en el parqueadero por medio de la función ppedir().

La función Draw_sal() se encarga de dibujar la entrada al parqueadero y la ruta a seguir

a la plaza de parqueo asignada, usando las funciones cv2.circle y cv2.line

Después de esto se crea un código QR que contiene la dirección IP del servidor y el

alojamiento de la página html, donde se publica un gráfico que muestra las indicaciones

para llegar a la plaza de parqueo.

Figura 4-19: Algoritmo con la función Draw_sal()

Se determina la plaza de parqueo asignada al usuario por medio de xxx y yyy, que son

las coordenadas de la plaza de parqueo en la matriz parn, que corresponde a la matriz

de nombres de las plazas de parqueo.

A continuación se presenta un diagrama de flujo en donde se describe el algoritmo

utilizado para mostrar la ruta que debe seguir el usuario.

Capítulo 1 37

Figura 4-20: Asignación de parqueadero en conteo de número par.

Figura 4-21: Asignación de parqueadero en conteo de número par.



Figura 4-22: Asignación de parqueadero en conteo de número impar.

Después de realizar esta acción se determina si la columna en donde está ubicada la

plaza de parqueo asignada es par o impar, al ser par se llega a la plaza de parqueo por

la izquierda y al ser impar se llega por la derecha.

Figura 4-23: Creación de los círculos de entrada y de centro de plaza de parqueo

Se crean dos círculos, uno en la entrada del parqueadero y otra en el centro de la plaza

de parqueo, para identificar el punto en donde encuentra el vehículo y el punto de destino

al tiene que llegar

Figura 4-24: Creación de las líneas de guía en la ruta para parquear

Se dibujan 3 líneas, una línea horizontal desde el centro de la entrada hasta el centro de

la calle entes las columnas, una línea vertical desde el centro de la calle hasta la plaza de

parqueo y una línea horizontal desde la calle hasta el centro de la plaza de parqueo.

Capítulo 1 39

Se crean 8 páginas web, que pueden ser utilizadas por diferentes usuarios a la vez.

Después de un tiempo se refrescan y reutilizan estas páginas web para los nuevos

usuarios que van llegando.

Figura 4-25: Creación del mapa para las diferentes páginas web.

Figura 4-26: Condiciones programadas de la página web

Finalmente se carga todo en la página web previamente diseñada y que muestra el plano

de vista superior, y las indicaciones, que a la vez, se va actualizando según el usuario

que lo solicite, a continuación se muestra un ejemplo del funcionamiento de esta página:



Figura 4-27: Ejemplo de funcionamiento de la página web.

4.5 Descripción de la red neuronal

La primera tarea que se realizó, antes de elegir qué tipo de red neuronal se iba a utilizar,

fue la elección de las herramientas informáticas que permitían la creación de algoritmos y

el entrenamiento o aprendizaje de máquina, también llamado machine learning, al

realizar esta tarea se encontró la herramienta Scikit learn, una biblioteca de aprendizaje

de software libre para Python, que ofrece múltiples posibilidades de uso como son la

creación de diferentes tipos de redes neuronales con algunos de los siguientes métodos:

BernoulliRBM, MLPregressor, MLPClassifier,.

BernoulliRBM está basado en una máquina de Boltzmann con capas visibles y ocultas,

está diseñada para aprendizaje no supervisado, de forma que aprende características

lineales no supervisadas en un modelo probabilístico. El modelo hace suposiciones con

respeto a la disposición de entradas y asume que las entradas son valores binarios entre

cero y uno.

Mlpregressor es un perceptron multicapa que se entrena usando back propagation sin

función de activación de la capa de salida, que también puede verse como el uso de la

Capítulo 1 41

función de identidad, como función de activación. Por lo tanto, utilizando el error

cuadrado como la función de perdida y el resultado conjunto de valores continuos.

MLPClassifier está basada en un perceptron de múltiples capas ajustables, es un

algoritmo de aprendizaje supervisado, que aprende una función mediante el

entrenamiento en un conjunto de datos, puede aprender un aproximado de función no

lineal para la clasificación o la regresión. Las ventajas de un perceptron multicapa son: la

capacidad para aprender modelos no lineales y la capacidad para aprender modelos en

tiempo real. Las desventajas son que las capas ocultas tiene una función de pérdida no

convexa donde existe más de un mínimo local, por lo tanto, diferentes inicializaciones de

peso aleatorio, pueden llevar a una precisión de validación diferente.

MLPClassifier fue el tipo de red neuronal que se utilizó en este proyecto, ya que tiene un

modelo de aprendizaje supervisado, lo cual era necesario en este prototipo, porque para

hacer una red neuronal que tenga aprendizaje automático se deberían hacer pruebas en

un proceso donde los autos entren y salgan del parqueadero de forma que la red

aprendería sin supervisión esto podría generar resultados variables o salidas indeseadas,

en nuestro caso se eligió una red supervisada, para poder ingresarle la salida deseada y

que con esto la red aprendiera. MLPClassifier se entrena usando un algoritmo de back

propagation que ya viene incorporado en Scikit learn. Después del entrenamiento el

sistema tiene la capacidad de predecir salidas ante nuevas entradas.

Para realizar el entrenamiento de la red neuronal se definen unas salidas deseadas, con

las que el algoritmo de aprendizaje compara si la salida que tiene en cada iteración es

igual a la deseada, así se ajustan los pesos en cada neurona de forma que al final del

entrenamiento la red no tenga errores y prediga la plaza de parqueo sin equivocación.

Después del entrenamiento la estructura de la red neuronal básicamente es la siguiente.



Figura 4-28: Estructura básica de la red neuronal

La red neuronal tiene una entrada a en donde se le indica cuales plazas de parqueo

están ocupadas y cuales están libres, con esta información, la red hace una comparación

con los datos aprendidos duran el entrenamiento, y genera una salida, que representa

una plaza de parqueo especifica.

Figura 4-29: Estructura de la red neuronal

Capítulo 1 43

Donde la entradas (X1I a X9I) representan la entrada de cada columna que se quiera

evaluar, ya que cada una de estas columnas cuenta con 9 plazas de parqueo; las salidas

(X1O a X9O) representan los estados de cada plaza de parqueo, cambiando una de esas

salidas a la vez, la salida que cambia es la que finalmente se asigna como plaza de

parqueo al usuario. Las capas ocultas pueden ser variables y se programan directamente

en código, si este parámetro no se especifica, Scikit learn tomara por defecto una red

neuronal de 100 capas ocultas

A continuación se presenta un diagrama de flujo en donde se puede apreciar el proceso

de aprendizaje de la red neuronal:

Figura 4-30: Diagrama de flujo proceso de aprendizaje



510 representa el número de veces, al cual le corresponde un 111111110 en binario la

respuesta de ese vector es 511 que es 111111111 en binario o sea 9 unos en binario,

por eso el for va hasta 510 para enseñarle a la red todas las posiciones desde la

000000000 hasta la 111111110 que corresponde de 0 a 510 en decimal.

Para efectos prácticos se escogió un parqueadero de 8 columnas, cada una con 9 plazas

de parqueo, con este modelo fue entrenada la red neuronal.

Figura 4-31: Esquema básico de las plazas de parqueo

Figura 4-32: Esquema de las plazas de parqueo numeradas

Para realizar el control de las plazas de parqueo en el código se crearon 3 matrices, así:

Capítulo 1 45

Figura 4-33: Matrices para el control de las plazas de parqueo

Dónde parb es la matriz que representa los estados actuales de las plazas de parqueo.

Por lo tanto se conforma de 8 columnas y 9 filas.

Los estados se representan por medio de 3 valores posibles:

0: significa que la plaza de parqueo está vacía, y disponible para ser ocupada.

1: significa que la plaza de parqueo se encuentra ocupada

2: significa que la plaza de parqueo ya fue solicitada y está en modo en espera para

ser ocupada por un nuevo vehículo.

Parac es la matriz que corresponde al estado actual del parqueadero, es decir a las

imágenes captadas por la cámara en cada momento, Por lo tanto se conforma de 8

columnas y 9 filas.

Para esta matriz:



0: significa que la plaza de parqueo está vacía, y disponible para ser ocupada.

1: significa que la plaza de parqueo se encuentra ocupada.

Parn, es una matriz que guarda el nombre de cada plaza de parqueo. Y también tiene de

8 columnas y 9 filas.

Para el entrenamiento de la red neuronal se dispuso de una serie de condiciones y reglas

que permiten la organización del parqueadero.

4.5.1 Primera regla

Si el parqueadero cuenta con espacio suficiente, se deja un espacio vacío entre auto y

auto de la misma columna. Esto se hace para que a los usuarios se les facilite la apertura

de las puertas laterales, y subir paquetes o mover carritos de mercado.

Figura 4-34: Ejemplo de la primera regla, plaza de parqueo ocupada (rojo) y libre (verde)

Donde el color rojo representa el espacio ocupado y el verde el espacio que ocupara el

auto que ingrese al parqueadero

4.5.2 Segunda regla

Si no es posible cumplir con la primera condición, se dejara un espacio vacío cada dos

autos.

Capítulo 1 47

Figura 4-35: Ejemplo de la segunda regla, plaza de parqueo ocupada (rojo) y libre

(verde)

4.5.3 Tercera regla

Si no es posible cumplir ninguna de las anteriores condiciones se le asignara el primer

espacio vacío en la columna con menos autos.

Se evidencio que para enseñarle a la red neuronal se recomienda usar valores de

entrada que varíen entre 0 y 1, para disminuir el tiempo de aprendizaje de la red neuronal

y el tiempo de procesamiento, se convierte la matriz de 8 X 9 en un vector de 1 x 9, que

representa cada columna del parqueadero. Antes de seleccionar la plaza de parqueo que

será asignada al usuario, se determina cual columna es la que tiene menos autos, en el

caso de haber varias con el mismo número de autos se elige la columna más cercana a

la entrada.

Figura 4-36: Ejemplo de la tercera regla, plaza de parqueo ocupada (rojo) y libre (verde)



4.5.4 Cuarta regla

Si hay plazas de parqueo disponibles pero el pasillo para ingresar hasta las plazas está

bloqueado, se busca una ruta por un pasillo diferente, y si todas los pasillos se

encuentran ocupados, se da un tiempo de máximo un minuto para esperar si algún

pasillo se desocupa ya que podrían ser autos en movimiento que hasta ahora se dirigen

a parquear.

Figura 4-37: Ejemplo de la cuarta regla, plaza de parqueo ocupada (rojo) y libre (verde)

4.6 Desarrollo del código

Se utiliza Def search_section2() para crear un algoritmo que permite buscar la columna

con menos autos

Capítulo 1 49

Figura 4-38: Algoritmo utilizando Def search_section2()

Donde Tmaxx es el número de columnas del parqueadero y Tmaxy es el número de filas

del parqueadero

Se hace un barrido por medio de los ciclos for, por cada columna contando el número de

plazas de parqueo que en la matriz parb se encuentren en 0, es decir las plazas de

parqueo vacías y disponibles para parquear, si la plaza de parqueo se encuentra vacía

pero en espera a que llegue un vehículo se asume para este caso como ocupada.

Conta: es un vector q almacena el número de plazas de parqueo disponibles en cada

columna.

Maxx: representa el número más grande que tenga conta

Con el último for se haya, cual columna tiene la mayor cantidad de plazas de parqueo

vacías.

La función Def Vacio () determina si el parqueadero está lleno, en el caso de no tener

ninguna plaza de parqueo disponible retorna 1 que representa que el parqueadero está

lleno.



Figura 4-39: Algoritmo utilizando Def Vacio ()

Se hace un barrido con los ciclos for en la matriz parb, al encontrar el primer espacio

vacío se interrumpe el ciclo ya que indica que por lo menos se tiene un espacio vacío.

En este caso las plazas de parqueo en modo espera se cuentan como plazas de parqueo

ocupadas. Esto se hace con el fin de evitar asignar dos carros a la misma plaza de

parqueo al mismo tiempo.

La función Def Tiempo() determina que plazas de parque se encuentran en modo espera,

después determina que tiempo llevan esperando cada una, si este tiempo supera los 5

minutos, se cancela su solicitud y pasa a estar en modo vacío.

Figura 4-40: Algoritmo utilizando Def Tiempo()

Capítulo 1 51

Donde Matime es una matriz que almacena la hora en que se asignó cada plaza de

parqueo a un usuario

Tiac es el tiempo actual.

Tmaxe es el tiempo máximo de espera. Si este tiempo es superado, la plaza de parqueo

pasa a estar vacía, es decir pasa de valer 2 en la matriz parb a valer 0

Con los ciclos for se determina que plazas de parqueo están en modo espera, es decir

que las plazas de parqueo que valgan 2 en la matriz parb.

La función Topos() determina la diferencia entre dos vectores, xx y yy. Esta diferencia

representa la plaza de parqueo que se le asigna al usuario

Figura 4-41: Algoritmo utilizando Topos()

j: es el número de la columna con la mayor cantidad de plazas de parqueo vacías.

Poss es el nombre de la plaza de parqueo asignada al usuario.

La función Search_position() recibe un vector con que representa la columna con mayor

cantidad de plazas de parqueo vacías.



Figura 4-42: Algoritmo utilizando Search_position()

El anterior segmento de código corresponde a buscar que se cumpla la primera condición

del sistema, es decir dejar una plaza de parqueo vacía entre los autos.

El siguiente segmento del código se encarga de la segunda condición para el sistema, en

caso de que la primera no pueda ser cumplida. Corresponde a dejar una plaza de

parqueo vacía cada dos autos o plazas de parqueo ocupadas.

Figura 4-43: Segmento de código regla dos

El siguiente segmento de código se encarga de la 3 condición del sistema, en caso de

que no se pueda cumplir la condición 1 o 2. Esta es ocupar la plaza de parqueo

disponible. En caso de que tampoco se pueda cumplir esta condición se determina que le

parqueadero está lleno.

Capítulo 1 53

Figura 4-44: Segmento de código regla tres

Mb: representa si se cumplió cualquier condición, si es 0 significa que no se cumplió, y si

es 1 significa que si se cumplió, por lo tanto todo se detiene.

La función Sear_section1() determina que plazas de parqueo superaron el tiempo de

espera y si el parqueadero cuenta con plazas de parqueo disponibles, por medio de las

funciones tiempo y vacío, después si el parqueadero cuenta con plazas de parqueo

vacías, se determina con la función search_section2 la columna con más plazas de

parqueo disponibles.

Figura 4-45: Algoritmo utilizando Sear_section1()



Donde Pos y secac: representan el número de la columna del parqueadero con el mayor

número de plazas de parqueo vacías y disponibles.

Mi: contiene el valor de todas las plazas de parqueo de la columna pos. Donde 0

representa las plazas de parqueo vacías, y 1 las plazas de parqueo ocupadas o en

espera.

Mif: representa el valor de todas las plazas de parqueo de la columna pos, más la

posición asignada al nuevo usuario.

Por medio del primer ciclo for se le asigna a los vectores mi y mif el valor de la columna

pos de la matriz parb.

Con la función search_position() se le asigna la plaza de parqueo al usuario y se guarda

su valor en el vector mif.

Con el segundo for se transfiere el nuevo valor del vector mif a la matriz parb donde se le

asigna el estado de espera a la plaza de parqueo asignada y en la matriz matime se

guarda la hora en que se solicitó la plaza de parqueo.

Después se publica el nombre de la plaza de parqueo por medio de la función topos.

Con la función Def learn() se tiene que:

Figura 4-46: Algoritmo utilizando Def learn()

Capítulo 1 55

Xi: es un valor de entrada que se desea q aprenda la red neuronal

Yi: es un valor de salida que se desea q aprenda la red neuronal.

Data_x: son los todos valores de entrada que se ingresaron para ser aprendidos por la

red neuronal

Data_y: son los todos valores de salida que se ingresaron para ser aprendidos por la red

neuronal

Esta función por medio de model.partial_fit(data_x,data_y) le enseña a la red neuronal un

valor de entrada con su respectiva salida.

La función Def Prediccion() requiere un valor de entrada, y se le pide a la red neuronal

que analice este valor y haga una predicción sobre este valor, la red neuronal retorna un

vector con el mismo tamaño que el vector de entrada, también este vector contiene

valores en porcentajes comprendidos entre 1 y 0, con el ciclo for se determina si este

porcentaje equivale a un 1 o a un 0.

Figura 4-47: Algoritmo utilizando Def Prediccion()

La función Def forlearn() hace para entrenar a la red neuronal



Figura 4-48: Algoritmo utilizando Def forlearn()

Por medio de un ciclo while se hacen muchas iteraciones, necesarias para que la red

neuronal tenga muchos datos de los cuales aprender.

Por medio de la función ramm se crea un vector de 1 x 9 con valores aleatorios que

varían entre 1 o 0, después con la función search_position se busca la plaza de parqueo

asignada para el vector mx, que fue generado de manera aleatoria. Después se le

enseña a la red neuronal el vector aleatorio con su respuesta hallada con la función

search_position, y con en el vector mx3 se guarda un vector proporcionado por la red

neuronal que corresponde a la respuesta dada por esta al vector aleatorio, si este vector

es igual a la respuesta dada por la función search_position se aumenta en uno la variable

cont, de lo contrario, si es diferente el vector de predicción de la red neuronal y el vector

de respuesta dado por la función search_section, la variable cont se iguala a cero.

Cuando la variable cont es igual o mayor a 500 se detiene todo, ya que significa que las

ultimas 500 interacciones la red neuronal respondió de la manera adecuada.

Para escribir en la página web se utiliza servi que es equivalente a servidor, y está en la

dirección IP que tenga el servidor, es decir si el minicomputador tiene comunicación, en

Capítulo 1 57

este caso la IP del computador ya que este es el que comparte internet al

minicomputador.

Figura 4-49: Algoritmo para la creación de códigos QR y la edición de la imagen en la

página web

Figura 4-50: Publicación de codigo QR y alfanumérico

4.7 Funcionamiento de la red local

El procesamiento del código se realiza en la Raspberry pi 2 por medio de Python, sin

embargo, fue necesario crear un servidor local, el cual permite al usuario conectarse por

medio de wifi al contenido de los códigos, que son publicados desde la Raspberry pi 2,

después de realizar dicho procesamiento. El servidor local es el puente de comunicación

creado para hacer que el contenido del plano de vista superior, y las indicaciones, se



visualicen en un dispositivo que posea el usuario, el cual tenga la posibilidad de

conectarse a internet. Las conexiones utilizadas se ven representadas gráficamente en el

siguiente esquema:

Figura 4-51: Estructura de la red local utilizada

Inicialmente la unidad lógica es configurada como servidor instalando Apache2 Debian

(LAMP) directamente sobre Raspbian, esta acción configura la Raspberry como servidor

local, permitiendo entrar al contenido de la página directamente con la dirección IP o

desde el local host.

Capítulo 1 59

Figura 4-52: Configuración de la dirección IP del computador para crear red local

Al realizar la instalación del LAMP, se busca la carpeta raíz del sistema, dentro de ella se

encuentra la carpeta “vav”, y como la instalación fue correcta dentro de esta se encuentra

una carpeta configurada por Apache2 Debian, llamada “www”, que contiene a la carpeta

“html” que es donde se alojaran las páginas web que se quieren compartir. La página

llamada index.html es la página creada por defecto y sirve para hacer las pruebas de

funcionamiento o de conexión del servidor.



Figura 4-53: Página de prueba index.html

A continuación de esto se crea la página web que sirve para publicar los planos de vista

superior, con sus respectivas rutas, el siguiente es el código de dicha página:

Figura 4-54: Código de la página web utilizada

Cuando se tuvo funcional la página web, junto con el código de procesamiento de la

señal, se procedió a realizar la conexión de la red local, que es una comunicación por

Ethernet entre la unidad lógica y el computador.

Capítulo 1 61

Este computador a su vez está conectado a la red wifi compartida por un celular o

modem, del que también tienen conexión los celulares de los usuarios, quedando todo

dentro de la misma red local del centro comercial y de esta forma accediendo libremente

al plano de vista superior, y sus indicaciones, simplemente teniendo la dirección correcta

que también es entregada por el sistema.

5 Resultados

Para la documentación de resultados se hicieron diferentes pruebas que evidencian el

proceso de entrenamiento de la red neuronal, la comprobación de que se cumplen todos

los regalas enseñadas a la red y también una prueba de todo el sistema, y los pasos que

haría un usuario al utilizarlo

5.1 Pruebas de usuario

Para realizar las pruebas de usuario, se comienza, desde el principio del proceso, es

decir desde que un usuario llega a la entrada del parqueadero, hasta que se le muestra

la ruta que debe seguir en la página web, es un proceso que se hace paso a paso,

entonces, lo primero que se debe hacer cuando un usuario llega al parqueadero, es

oprimir el pulsador, en una pantalla vera lo que se muestra a continuación:

Figura 5-1: Código alfanumérico y QR mostrados en pantalla



Para tener una referencia de los autos que están dentro del parqueadero se toma una

imagen, que los identifique, la cual se muestra a continuación:

Figura 5-2: Referencia de autos en el parqueadero

La imagen anterior es solo de referencia, lo que quiere decir que los usuarios no verán

esta imagen; a continuación el usuario debe escanear con su celular el código QR, como

se ve a continuación:

Figura 5-3: Escaneo de código QR

El código QR contiene una dirección de una página en la red local, lo siguiente que vera

el usuario después de realizar el escaneo, es la lectura, así como se muestra a

continuación:

Capítulo 1 65

Figura 5-4: Lectura de la dirección de página

A continuación se copia el contenido y se pega en el buscador, así:

Figura 5-5: Dirección de página web en el navegador



Finalmente el usuario vera la página web, en la que se muestra un mapa que le indica la

ruta que debe seguir para llegar a la plaza de parqueo asignada.

Figura 5-6: Visualización del plano de ruta en la página

5.2 Cumplimiento de las reglas

En cuanto al cumplimiento de las reglas se realizaron pruebas, evaluando lo que se

debe cumplir en cada una de ellas, se toma como referencia que el tiempo que se

demora la red neuronal en predecir cualquiera de estas reglas es 0.001423 s

La primera regla es la que primero evalua el sistema, si no es posible, entonces evaluara

la segunda y asi sucesivamente. En condiciones de no utilizacion de la red neuronal el

procesamiento de la regla se realizara en 3.09944152832e-05 segundos.

La primera regla consiste en que la asignacion de zona para parqueo sea dejando un

espacio entre vehiculos como se muestra a continuacion:

Capítulo 1 67

Figura 5-7: Imagen actual del parqueadero (regla 1)

Figura 5-8: Asignación realizada (regla 1)

En condiciones de no utilizacion de la red neuronal el procesamiento de la regla se

realizara en 4.10079956055e-05 segundos

La segunda regla consiste en que la asignacion de zona para parqueo sea dejando un

espacio entre vehiculos, cada dos vehiculos, como se muestra a continuacion:







La tercera regla consiste en que la asignacion de zona para parqueo sea asignando las

unicas plazas que queden disponibles, como se muestra a continuacion:

Capítulo 1 69





La cuarta regla consiste en que la asignacion de zona para parqueo sea asignando las

unicas plazas que queden disponibles, en donde no se encuentre el pasillo bloqueado,

como se muestra a continuacion:

Capítulo 1 71

5.3 Comparación de aprendizaje de redes neuronales

El aprendizaje de la red neuronal se realizó guiadamente, calculando a base de prueba y

error, el cual era la cantidad de iteraciones necesarias para que el sistema aprendiera

todas las reglas programadas y respondiera con la respuesta acertada cada vez, hasta

llegar a un nivel de seguridad del 100%.

5.3.1 Método MLPClassifier

A continuación se muestran las gráficas del comportamiento en el aprendizaje de la red

neuronal, modificando el número de capas de la red en cada intento, se puede ver la

diferencia en cuanto al número de iteraciones necesarias, para que la red aprenda con

un error del 0%, y el tiempo de aprendizaje que tiene. En conclusión se establece un

vector deseado, y después la red neuronal aprende a predecirlo.

Se convierte todo el vector binario a un número decimal, de la siguiente manera:

Figura 5-15: Conversión de vector binario, a numero decimal

El cálculo del error se hace de la siguiente manera: se tienen dos vectores, uno de

entrada y otro deseado, se resta el valor de entrada del valor deseado y se divide entre el

valor deseado.

El siguiente entrenamiento fue realizado con una red neuronal de 100 capas ocultas,

teniendo como resultado, el aprendizaje en un tiempo de 183 segundos, y un total de

12581 muestras



Figura 5-16: Porcentaje de aciertos vs porcentaje de error (100 capas)



14114 muestras


Capítulo 1 73



15136 muestras

Figura 5-18: Porcentaje de aciertos vs porcentaje de error (80capas)



20757 muestras






20757 muestras




16592 muestras


Capítulo 1 75



24334 muestras




26768 muestras




El mejor comportamiento se evidenció con el aprendizaje de 100 capas ya que tuvo un

tiempo de aprendizaje menor que los demás, y con un menor número de iteraciones.

5.3.2 Método MLPRegressor


teniendo como resultado, el no aprendizaje en un tiempo de 95 segundos, y un total de

12581 muestras


Se realizó otro entrenamiento con una red neuronal utilizando la misma cantidad de

capas, un total de 100 capas ocultas, teniendo como resultado, que por más tiempo que

se deje aprendiendo el sistema, no logra disminuir el erro a cero, por lo tanto este método

de entrenamiento de red neuronal, se deja descartado y se utiliza el MLPClassifier, ya

que se comportó de la forma esperada en las diferentes pruebas realizadas.

Capítulo 1 77

Figura 5-25: Porcentaje de aciertos vs porcentaje de error (100 capas), segunda prueba

6 Conclusiones y recomendaciones

6.1 Conclusiones

A partir de la realización de este proyecto se pudieron obtener resultados, que

demuestran que se diseñó un prototipo capaz de realizar la gestión de ocupación de los

parqueaderos por medio de una red neuronal artificial, creada en Python por medio de la

herramienta Scikit learn. Esta red de tipo perceptron fue entrenada con dos métodos

diferentes usando un algoritmo de back propagation y se muestra la diferencia entre

ellos, se puede identificar cual fue el que arrojo mejor resultado. El sistema es capaz de

asignar plazas de parqueo específicas a cada usuario, siguiendo cuatro reglas que la red

neuronal ha aprendido previamente, por medio del entrenamiento.

Cuando ocurre un accionamiento del pulsador el sistema publica en una pantalla un

código alfanumérico, que representa la plaza de parqueo asignada .También se publica

en la pantalla un código QR, el código contiene una dirección web, en la cual se visualiza

un plano de visa superior del parqueadero y una ruta desde la entrada hasta la plaza

asignada,

La implementación del código QR es una ayuda en el ingreso a la página web ya que el

celular toma la dirección web automáticamente y el usuario no tiene que hacer el tedioso

procedimiento de digitarla, con esto, no se afecta el comportamiento normal de como

opera el parqueadero, sino que se agrega un beneficio, y el usuario tiene la posibilidad

de usarlo o no, sin afectar de ninguna forma el estacionamiento normalmente, la decisión

está en el administrador del parqueadero si quiere que las reglas sean opcionales u

obligatorias .

Por medio de la cámara digital de video se identifica si cada plaza de parqueo se

encuentra libre u ocupada, esto se logra por medio del procesamiento digital de las

imágenes, usando la técnica de sustracción de fondo, así como diferente herramientas

que permiten el procesamiento de imágenes en Python, esto también permite la



identificación de bloqueo en los pasillos, para un cálculo acertado de la ruta que se

muestra al usuario.

6.2 Recomendaciones

Para el aprendizaje de la red neuronal se recomienda usar valores de entrada que varíen

entre 0 y 1, así como intentar optimizar de la mejor forma el código, los algoritmos y las

reglas que aprende la red neuronal, todas estas recomendaciones en conjunto se verán

reflejadas en una disminución del tiempo de aprendizaje de la red neuronal y del tiempo

de procesamiento de todo el sistema.

En investigaciones o desarrollos futuros se recomienda usar una cámara de video con

mayor resolución, ya que tendrá más cantidad de datos disponibles para el

procesamiento y análisis de la sección que se desee, esta recomendación es útil siempre

y cuando la unidad procesadora también sea aumentada en capacidad de

procesamiento, el sistema adquirirá mejores prestaciones, como por ejemplo, más

exactitud, y una capacidad mayor de monitoreo en cuanto a plazas de parqueo se refiere.

Bibliografía

Algoritmo, E. (n.d.). Máquinas Estocásticas

___________________________________________________________________

___.

Du, F., Zhao, Y., Gao, L., & Wang, W. (2017). Evaluation of the autonomous parking

system based on bp neural network. Proceedings - 9th International Conference on

Intelligent Human-Machine Systems and Cybernetics, IHMSC 2017, 2, 324–327.

https://doi.org/10.1109/IHMSC.2017.185

Gervasoni, L., D’amato, J. P., & Barbuzza, R. (2014). Aplicación de un método de

sustracción de fondo a partir de imágenes de vídeo-vigilancia. XLIII Jornadas

Argentinas de Informática E Investigación Operativa (43JAIIO)-XV Argentine

Symposium on Technology (AST)(Buenos Aires, 2014), 25–36. Retrieved from

http://43jaiio.sadio.org.ar/proceedings/AST/Paper3_AST_Gervasoni.pdf

Jiménez, A. F., Pelayo, M. C., & Ramírez, Á. (2015). Enseñanza del Procesamiento de

Imágenes en Ingeniería usando Python. Vaep-Rita, 3(4), 179–186.

Lara, F. (n.d.). Fundamentos De Redes Neuronales Artificiales. Unam. Retrieved from

http://conceptos.sociales.unam.mx/conceptos_final/598trabajo.pdf

Mityakov, A. V., Varankin, V. K., & Tatarinov, Y. S. (2017). Application of modern

architectures of deep neural networks for solving practical problems. Proceedings of

2017 20th IEEE International Conference on Soft Computing and Measurements,

SCM 2017, 389–390. https://doi.org/10.1109/SCM.2017.7970594

scikit-learn developers, & Developers, S. (2017). Scikit-Learn User Guide.

Upton, E., & Halfacree, G. (2013). Raspberry Pi User Guide, 314. Retrieved from



http://books.google.at/books?id=YJo3AgAAQBAJ

Valipour, S., Siam, M., Stroulia, E., & Jagersand, M. (2017). Parking-stall vacancy

indicator system, based on deep convolutional neural networks. 2016 IEEE 3rd

World Forum on Internet of Things, WF-IoT 2016, 655–660.

https://doi.org/10.1109/WF-IoT.2016.7845408

PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE...

Documents

Transcript of PROTOTIPO DE SISTEMA PARA LA GESTIÓN DE OCUPACIÓN DE...