APLICACIÓN DE REDES NEURONALES ARTIFICIALES PARA LA DETECCION DE OBSTÁCULOS POR MEDIO DE UN ROBOT

UNIVERSIDAD TÉCNICA DE ORURO
FACULTAD NACIONAL DE INGENIERÍA
INGENIERÍA INFORMÁTICA
PROYECTO FINAL
SEMINARIO DE INTELIGENCIA ARTIFICIAL
APLICACIÓN DE REDES
NEURONALES ARTIFICIALES
PARA LA DETECCION DE
OBSTÁCULOS POR MEDIO DE
UN ROBOT
AUTOR:
SAUL MAMANI MAMANI
Oruro – Bolivia

I
RESUMEN
La presente monografía trata sobre la implementación de una red neuronal artificial del tipo
perceptrón que sea capaz de proporcionar información eficiente a un robot simulado para
realizar las acciones necesarias y eficientes ante la aparición de obstáculos.
Con la ayuda de la inteligencia artificial y las redes neuronales artificiales, se muestra una
alternativa diferente a las soluciones tradicionales que se utilizan para resolver este tipo de
problemas.
En el capítulo 1 se identifican los problemas, se definen el objetivo general y los objetivos
específicos que guían el desarrollo del proyecto.
El capítulo 2 describe la base teórica fundamental para respaldar el desarrollo y los resultados
del proyecto.
El capítulo 3 define los métodos, la metodología y las herramientas necesarias que se
necesitan para alcanzar los objetivos del proyecto. Además, se definen los alcances y los
límites.
En el capítulo 4 se desarrolla el proyecto, se definen las entradas y las salidas, se implementa
y entrena la red neuronal en un lenguaje de programación, se simula por software el
comportamiento del robot, y se compara la solución propuesta con otros métodos
tradicionales o empíricos.
En el capítulo 5 se describen las conclusiones alcanzadas y se realizan algunas
recomendaciones.

II
ÍNDICE GENERAL
RESUMEN..............................................................................................................................I
ÍNDICE DE FIGURAS ......................................................................................................... V
ÍNDICE DE TABLAS........................................................................................................ VII
CAPITULO I IDENTIFICACIÓN DEL PROBLEMA ...................................................1
1.1 INTRODUCCIÓN...................................................................................................1
1.2 PLANTEAMIENTO DEL PROBLEMA ................................................................3
1.3 PREGUNTAS DE INVESTIGACIÓN ...................................................................3
1.4 OBJETIVOS ............................................................................................................4
1.4.1 OBJETIVO GENERAL ...................................................................................4
1.4.2 OBJETIVOS ESPECÍFICOS ...........................................................................4
1.5 JUSTIFICACIÓN ....................................................................................................4
1.5.1 SOCIAL............................................................................................................4
1.5.2 TÉCNICA.........................................................................................................5
1.5.3 ADMINISTRATIVA .......................................................................................5
CAPITULO II MARCO TEÓRICO CONCEPTUAL ......................................................6
2.1 ELEMENTOS BÁSICOS........................................................................................6
2.2 INTRODUCCIÓN A LA NEUROFISIOLOGÍA....................................................7
2.3 NEURONA CEREBRAL VS NEURONA ARTIFICIAL. .....................................8
2.4 MODELO Y PARTES DE UNA RED NEURONAL ARTIFICIAL. ....................8
2.5 FUNCIONES DE TRANSFERENCIA...................................................................9
2.5.1 FUNCIÓN DE TRANSFERENCIA ESCALÓN O HARDLIM. ....................9
2.5.2 FUNCIÓN DE TRANSFERENCIA LINEAL O PURELIM.........................10
2.5.3 FUNCIÓN DE TRANSFERENCIA SIGMOIDEAL O LOGSIG.................10

III
2.6 TOPOLOGÍA DE UNA RED................................................................................11
2.7 CONEXIÓN ENTRE CAPAS...............................................................................12
2.8 EL PERCEPTRÓN................................................................................................14
2.8.1 ESTRUCTURA DE LA RED. .......................................................................15
2.8.2 REGLA DE APRENDIZAJE.........................................................................15
2.8.3 ALGORITMO DE ENTRENAMIENTO.......................................................18
2.8.4 LIMITACIONES DEL PERCEPTRÓN. .......................................................19
2.9 EL PERCEPTRÓN MULTICAPA........................................................................20
2.10 ALGORITMICA GENERAL ............................................................................22
2.10.1 COMPLEJIDAD ALGORITMICA ...............................................................22
2.10.2 MEDIDAS DEL COMPORTAMIENTO ASINTÓTICO .............................24
2.10.3 JERARQUÍA DE ÓRDENES. .......................................................................24
2.11 ANÁLISIS DE ALGORITMOS........................................................................25
2.11.1 COSTES EN TIEMPO Y EN ESPACIO. ......................................................25
CAPITULO III MARCO METODOLÓGICO.................................................................27
3.1 METODOS Y TÉCNICAS UTILIZADAS...........................................................27
3.1.1 METODOLOGÍA PARA EL DESARROLLO DE RNA..............................27
3.1.2 MÉTODO DEL ANÁLISIS DE ALGORITMOS..........................................27
3.2 FASES DEL PROCESO DE INVESTIGACION .................................................28
3.3 DESARROLLO DEL TRABAJO .........................................................................28
3.4 CRITERIOS DE ANÁLISIS .................................................................................29
3.5 ALCANCES Y LIMITACIONES.........................................................................29
CAPITULO IV MARCO PROPOSITIVO .......................................................................30

IV
3.6 FASE DE APRENDIZAJE....................................................................................30
3.6.1 DEFINICIÓN DEL PROBLEMA..................................................................30
3.6.2 RECOLECCIÓN DE DATOS. ......................................................................31
3.6.3 DISEÑO DE PRE Y POST PROCESAMIENTO..........................................37
3.6.4 DISEÑO DE LA RED....................................................................................40
3.6.5 ENTRENAMIENTO DE LA RED. ...............................................................42
3.7 FASE DE PRUEBAS. ...........................................................................................46
3.7.1 IMPLEMENTACIÓN DE LA RED NEURONAL EN UN ROBOT............46
3.8 ANÁLISIS DEL TIEMPO DE EJECUCIÓN. ......................................................49
3.9 COMPARACIÓN CON OTROS MÉTODOS......................................................52
3.9.1 IMPLEMENTACIÓN CON UN MÉTODO TRADICIONAL. ....................52
3.9.2 ANÁLISIS DEL TIEMPO DE EJECUCIÓN. ...............................................55
3.9.3 COMPARACIÓN DE LOS MÉTODOS. ......................................................56
CAPITULO V CONCLUSIONES Y RECOMENDACIONES......................................58
5.1 CONCLUSIONES.................................................................................................58
5.2 RECOMENDACIONES........................................................................................58
BIBLIOGRAFÍA..................................................................................................................59
ANEXO A ............................................................................................................................60
ANEXO B ..............................................................................................................................1
ANEXO C ..............................................................................................................................2

V
ÍNDICE DE FIGURAS
Figura 1. Áreas de inteligencia artificial ................................................................................1
Figura 2. Estructura de una Neurona Biológica .....................................................................6
Figura 3. De la neurona biológica a la neurona artificial .......................................................8
Figura 4. Neurona de una sola entrada ...................................................................................8
Figura 5. Función de transferencia Escalón (hardlim) ...........................................................9
Figura 6. Función de transferencia Escalón (hardlims)........................................................10
Figura 7. Función de transferencia Lineal............................................................................10
Figura 8. Función de transferencia sigmoideal.....................................................................11
Figura 9. Neurona con múltiples entradas............................................................................11
Figura 10. Capa de S neuronas.............................................................................................13
Figura 11. Capa neuronal de tres capas ................................................................................13
Figura 12. Perceptrón según Miscky Paper..........................................................................14
Figura 13. Perceptrón ...........................................................................................................15
Figura 14. Función XOR ......................................................................................................16
Figura 15. Perceptrón aplicado a la Función OR..................................................................17
Figura 16. Recta Solución para la Función OR y la función AND ......................................18
Figura 17. Compuerta XOR .................................................................................................19
Figura 18. Perceptrón multicapa..........................................................................................20
Figura 19. Perceptrón para la Compuerta XOR ..................................................................21
Figura 20. Distintas formas de las regiones generadas por un Perceptrón multicapa .........21
Figura 21. Tiempos y notación empleada............................................................................23

VI
Figura 22. Gráfica de las complejidades algorítmicas.........................................................24
Figura 23. Fases de la metodología .....................................................................................28
Figura 24. Diseño del robot.................................................................................................30
Figura 25. Diseño del mundo 1 ...........................................................................................32
Figura 26. Diseño del mundo 2 ...........................................................................................36
Figura 27. Desigualdades que garantizan que el problema es linealmente separable .........38
Figura 28. Función de transferencia Escalón (hardlims).....................................................40
Figura 29. Red Neuronal Tipo Perceptrón para el robot ......................................................40
Figura 30. Interfaz principal de la red neuronal ...................................................................41
Figura 31. Interfaz de simulador para el entrenamiento de la Red Neuronal.......................42
Figura 32. Interfaz antes del entrenamiento de la red neuronal............................................44
Figura 33. Interfaz de la red neuronal entrenada..................................................................45
Figura 34. Interfaz de las pruebas de la red neuronal...........................................................45
Figura 35. Interfaz del robot recorriendo el mundo 2...........................................................48
Figura 36. Interfaz del robot recorriendo el mundo 1...........................................................49
Figura 37. Comportamiento del tiempo de ejecución de la RNA ........................................52
Figura 38. Comportamiento del tiempo de ejecución del método tradicional......................56
Figura 39. Gráfica del tiempo de ejecución para ambos métodos........................................57

VII
ÍNDICE DE TABLAS
Tabla 1. Lecturas de los sensores y las acciones de los motores..........................................31
Tabla 2. Comportamiento del robot – Mundo 1...................................................................35
Tabla 3. Comportamiento del robot – Mundo 2...................................................................37
Tabla 4. Tabla que representa el comportamiento del robot para el Mundo 1.....................43
Tabla 5. Pesos y ganancias aleatorias iniciales.....................................................................43
Tabla 6. Pesos y ganancias finales........................................................................................45
Tabla 7. Simulación de la red para las nuevas combinaciones.............................................46

1
CAPITULO I IDENTIFICACIÓN DEL PROBLEMA
1.1 INTRODUCCIÓN
De un tiempo a esta parte los investigadores vienen volcando sus esfuerzos en el estudio de
la Inteligencia Artificial y los Sistemas Paralelos.
La inteligencia artificial inicia en 1950, Norbert Wiener postula que todo comportamiento
inteligente es el resultado de mecanismos de retroalimentación. En 1956 gracias a John MacCarthy
se acuña el término de Inteligencia Artificial.
Áreas de la IA1
:
Figura 1. Áreas de inteligencia artificial
Fuente: (Martinez, 1995)
Los Sistemas Paralelos estudia como una computadora puede ejecutar varias operaciones en forma
simultánea, o sea, al mismo tiempo, generalmente utiliza más de un procesador.
Las investigaciones sobre la IA y los Sistemas Paralelos llevan a un nuevo concepto que son las
Redes Neuronales Artificiales.
Resulta irónico pensar que maquinas computacionales capaces de realizar 100 millones de
operaciones en coma flotante por segundo, no sean capaces de interpretar el mundo. Esto ha hecho
que numerosos investigadores desde 1956 centren su atención en nuevos sistemas de tratamiento
1
IA: Acrónimo de Inteligencia Artificial

2
de información que permitan solucionar problemas cotidianos tal y como lo hace el cerebro
humano.
Este órgano biológico contiene características deseables para cualquier sistema de procesamiento
digital: Es robusto y tolerante a fallas, es flexible, maneja información difusa, es altamente paralelo,
es pequeño y consume poca energía.
“Basados en la eficiencia de los procesos llevados a cabo por el cerebro e inspirados en su
funcionamiento, varios investigadores han desarrollado las Redes Neuronales Artificiales, que
emulan el comportamiento de las redes neuronales biológicas, además, estos sistemas no requieren
que la tarea a ejecutar se programe, ellos aprenden de la experiencia. No ejecutan instrucciones,
sino, responden en paralelo a las entradas que se les presenta”. (Acosta Buitrago María Isabel,
2000)
Las Redes Neuronales Artificiales es una teoría que está aún en proceso de estudio, su verdadera
potencialidad no se ha alcanzado todavía, pero se han desarrollado numerosas aplicaciones con
gran éxito en diferentes campos.
Existen muchos proyectos e investigaciones que se ha realizado utilizando Redes Neuronales
Artificiales enfocándose principalmente en dar alternativas novedosas y eficientes a problemas
complejos en el campo de la economía, medicina, ciencia e ingeniería, etc. en los cuales los
métodos tradiciones no han entregado resultados muy convincentes.
Las Aplicaciones más exitosas de la RNA son:
 Reconocimiento de patrones
 Procesamiento de imágenes y vos
 Juguetes
 Planeamiento
 Predicción
 Control y Optimización
 Filtrado de señales
 Diagnóstico de Enfermedades
 Odontología
 Juegos

3
 Entre otros
La presente investigación se trata de buscar una red neuronal para resolver el problema de la
detección de obstáculos de forma eficiente, y aplicarlo a un robot con cuatro sensores y dos
motores.
1.2 PLANTEAMIENTO DEL PROBLEMA
La detección de obstáculos por medio de mecanismos automatizados conlleva varios
problemas, entre las cuales se puede mencionar:
 El tiempo de ejecución para determinar las acciones que debe tomar un robot frente a un
obstáculo es muy costoso, esto provoca que la reacción del robot sea generalmente lenta y
deficiente.
 Los recursos para administrar todos los obstáculos que debe atravesar el robot son muy
costosos, provocando problemas de almacenamiento.
 Las soluciones empíricas conocidas no son eficientes, por lo que nos obliga a buscar
soluciones más óptimas para resolver el problema.
 Existen muchas soluciones que la inteligencia artificial nos proporciona para resolver este
problema, la principal dificultad es encontrar el método más eficiente que logre optimizar
recursos, como el tiempo de ejecución y almacenamiento de memoria.
 La implementación y las pruebas para este tipo de proyectos en entornos reales son
económicamente elevados, por lo que buscamos alternativas económicas, como la
simulación.
1.3 PREGUNTAS DE INVESTIGACIÓN
Por todo lo expuesto, se plantea la siguiente pregunta de investigación:
¿Qué red neuronal artificial proporciona información eficiente a un robot para realizar acciones
necesarias ante la aparición de obstáculos?

4
1.4 OBJETIVOS
1.4.1 OBJETIVO GENERAL
Implementar una red neuronal artificial del tipo Perceptrón utilizando el método de
aprendizaje supervisado, de tal forma, que sea capaz de proporcionar información eficiente
a un robot para realizar las acciones necesarias ante la aparición de obstáculos.
1.4.2 OBJETIVOS ESPECÍFICOS
Se definen los objetivos específicos que ayudan a cumplir el objetivo general:
 Analizar todos los tipos de obstáculos, para definir a las acciones necesarias que el robot
tiene que realizar ante la aparición de éstos.
 Diseñar una red neuronal del tipo Perceptrón, para determinar el modelo, las partes, la
topología y la función de transferencia.
 Implementar un programa para simular el entrenamiento de una red neuronal tipo
Perceptrón utilizando un algoritmo de aprendizaje supervisado.
 Probar la red neuronal ya implementada en un robot simulado, para verificar su
funcionamiento.
 Comparar el método usando redes neuronales artificiales con los métodos tradicionales,
para determinar cuál de los dos métodos es el más eficiente.
1.5 JUSTIFICACIÓN
1.5.1 SOCIAL
El motivo que llevó a realizar esta investigación es la aplicación de una red neuronal artificial
a un problema común, como es la detección de obstáculos que realiza un mecanismo
automatizado.
El proyecto se justifica socialmente por que pretende mostrar alternativas eficientes a
problemas tecnológicos comunes con que se enfrenta la sociedad; como una aspiradora
automática, vehículos exploradores, automóviles autónomos sin tripulación, drones, etc.

5
1.5.2 TÉCNICA
El proyecto se justifica técnicamente porque se estudiarán e implementarán redes neuronales
artificiales. La aplicación de esta rama de la ingeniería informática proporciona soluciones
eficientes a problemas cuya resolución a priori significarían un gran esfuerzo en tiempo y
almacenamiento.
1.5.3 ADMINISTRATIVA
Sin duda alguna los trabajos automatizados y las soluciones eficientes tienen incidencia en
el área administrativa de una empresa, ya que podrían reducir significativamente los costes
y maximizar los beneficios.

6
CAPITULO II MARCO TEÓRICO CONCEPTUAL
2.1 ELEMENTOS BÁSICOS.
El cerebro Humano consta aproximadamente de 1011
neuronas y aproximadamente 104
conexiones por elemento, estos elementos son llamados neuronas los cuales tienen tres
componentes importantes:
 Las Dendritas. Reciben la información proveniente de otras células.
 La Soma. Cuerpo de la célula que recolecta y combina la información.
 El Axón. Lleva la señal desde el cuerpo de la célula hacia otras neuronas.
 La Sinapsis. Es la conexión de un axón con la dendrita de otra neurona.
Figura 2. Estructura de una Neurona Biológica
Fuente: (Machadines, 2020)

7
“Toda célula nerviosa posee un aparato de recepción, constituido por el cuerpo de la célula y las
expansiones protoplasmáticas(dendritas), un aparato de transmisión, el axón y un aparato de
emisión la arborización terminal” (Catarjet, 1902)
Algunas de las estructuras neuronales son determinadas en el nacimiento, otra parte se desarrolla a
través del aprendizaje, proceso en que nuevas conexiones neuronales son realizadas y otras se
pierden.
2.2 INTRODUCCIÓN A LA NEUROFISIOLOGÍA.
Las estructuras neuronales continúan cambiando durante toda la vida, estos cambios
consisten en el esfuerzo o debilitamiento de las uniones sinápticas, así el proceso de recordar el
rostro de un amigo consiste en alterar varias sinapsis.
Todas las neuronas conducen información de forma similar, esta viaja a lo largo del axón en breves
impulsos eléctricos denominados potenciales de acción, estas alcanzan una amplitud máxima de
unos 100mv y duran 1ms, son el resultado del desplazamiento a través de la membrana celular de
iones de sodio dotados de carga positiva, que pasan desde el fluido extra celular hasta el citoplasma
intracelular.
La membrana en reposo mantiene un gradiente de potencial eléctrico de -70mv, los iones de sodio
no atraviesan con facilidad la membrana en reposo por lo que la permeabilidad del sodio aumenta
alcanzando un potencial crítico llamado umbral, es decir, el interior de la célula se torna positivo
con respecto al exterior al cabo de 1ms, la permeabilidad del sodio decae y el potencial de la
membrana retorna a -70ms su valor en reposo.
Los potenciales de acción, son señales de baja frecuencia conducidas en forma muy lenta (100
metros por segundo la velocidad máxima), estos no pueden saltar de una célula a otra, necesitan de
un transmisor químico (neurotransmisor) que es liberado en la sinapsis.
Cuando el axón está cerca de sus células destino, se divide en ramificaciones formando sinapsis
con las dendritas de otras células. Los fenómenos que ocurren en la sinapsis son de naturales
químicos, pero tienen efectos eléctricos laterales que se pueden medir. (Catarjet, 1902)

8
Hay dos aspectos similares entre las neuronas biológicas y las artificiales. Primero, los bloques de
construcción de ambas redes son sencillos elementos computacionales altamente interconectados.
Segundo, las conexiones entre neuronas determinan la función de la red. (Martinez, 1995)
2.3 NEURONA CEREBRAL VS NEURONA ARTIFICIAL.
Los primeros en describir al cerebro humano como un elemento computacional fueron Mc
Culloch & Pitts en 1943.
En la figura 3, se muestra la similitud de una neurona cerebral y una artificial.
Figura 3. De la neurona biológica a la neurona artificial
Fuente: (Acosta Buitrago María Isabel, 2000)
2.4 MODELO Y PARTES DE UNA RED NEURONAL ARTIFICIAL.
El modelo y las partes de una red neuronal artificial se componen de:
Figura 4. Neurona de una sola entrada

9
Donde:
 P: Son las entradas de la red. (dendritas)
 W: Son los pesos de la neurona (sinapsis)
 b: Es la ganancia que refuerza salida (umbral)
 n: Es la salida neta de la red (potencial de acción)
 f: Es la función de trasferencia que puede ser lineal y no lineal
(neurotransmisor)
2.5 FUNCIONES DE TRANSFERENCIA
2.5.1 FUNCIÓN DE TRANSFERENCIA ESCALÓN O HARDLIM.
Acerca la salida de la red a cero, si el argumento de la función es menor que cero y a uno si
es mayor o igual a cero, de esta forma clasifica las salidas en dos categorías, característica
que le permite ser empleada en una red tipo perceptrón.
Figura 5. Función de transferencia Escalón (hardlim)
Podemos modificar la función para una mejor convergencia del resultado un rango de salida
de 1 y -1, esta función es llamada también hardlims.

10
Figura 6. Función de transferencia Escalón (hardlims)
2.5.2 FUNCIÓN DE TRANSFERENCIA LINEAL O PURELIM.
La salida es igual a su entrada, utilizadas en las redes tipo adaline.
Figura 7. Función de transferencia Lineal
2.5.3 FUNCIÓN DE TRANSFERENCIA SIGMOIDEAL O LOGSIG.
Esta función es usada en redes multicapa, como la red Backpropagation.

11
Figura 8. Función de transferencia sigmoideal
2.6 TOPOLOGÍA DE UNA RED.
Normalmente una neurona tiene más de una entrada (R entradas), los valores de las entradas
p1,p2,...,pR son multiplicadas por su pesos w11,w12,...,w1R pertenecientes a la matriz de pesos W.
Figura 9. Neurona con múltiples entradas
Donde:
La cual es la salida neta de la red, esta expresión se puede escribir en forma matricial de la siguiente
forma.
n = w11p1 + w12p2 + ... + w1RpR + b
n = 


R
i
b
pi
Wji
1
)
*
(

12
La Matriz de pesos W para el caso de una sola neurona tiene una sola fila.
La salida total de red viene dada por la siguiente ecuación:
2.7 CONEXIÓN ENTRE CAPAS.
Dentro una red neuronal, los elementos de procesamiento se encuentran agrupadas por capas,
siendo estas una colección de neuronas que de acuerdo a su ubicación dentro de la red estas reciben
diferentes nombres.
 Capa de entrada. Recibe las señales de entrada de la red, algunos autores no lo consideran
a esta como una capa.
 Capas ocultas. Estas capas son aquellas que no tienen contacto con el medio exterior, sus
elementos pueden tener diferentes conexiones y son estas las que determinan la topología
de la red.
 Capa de salida. Transmite la respuesta al mundo exterior.
A continuación mostramos una red de una sola capa con S neuronas, donde cada una de las R
entradas están conectadas a cada una de las neuronas, ahora, nuestra matriz de pesos W tiene S
filas.
n = Wp + b
a = f(n)

13
Figura 10. Capa de S neuronas
Ahora, si se Sconsidera una red con más de una capa, o red multicapa, cada capa tendrá su propia
matriz de pesos W, su propio vector de ganancias b, un vector de salidas/entradas netas n y un
vector de salidas s, a continuación, se muestra una red de tres capas, con R entradas, las salidas de
la 1ra capa es la entrada de la capa 2da y 3ra respectivamente.
Figura 11. Capa neuronal de tres capas

14
2.8 EL PERCEPTRÓN.
En 1943 Warren McCulloch y Walter Pitts, desarrollaron la primera red neuronal, al principio
se encontró una gran similitud con los sistemas biológicos y se creyó que este modelo podría
computar cualquier función aritmética lógica.
La red del tipo Perceptrón fue inventada por el psicólogo Frank Rosenblatt en el año 1957, el creía
que la conectividad existente en las neuronas biológicas tiene un elevado porcentaje de
aleatoriedad. Rosenblatt opinaba que la herramienta más apropiada para el estudio de las redes
neuronales era la teoría de la probabilidad, lo que lo llevó a la teoría de la separabilidad lineal.
En 1969 Marvin Misky y Seymour Paper publicaron su libro “Perceptrons: An introduction to
Computational Geometry”, para muchos esta publicación significo el final de las redes neuronales,
en esta publicación se presentaron las capacidades y limitaciones del Perceptrón, donde, la mayor
desventaja de este tipo de redes era su incapacidad para resolver problemas que no sean linealmente
separables.
Su idea de Perceptrón aparece en la figura siguiente:
Figura 12. Perceptrón según Miscky Paper
Se observa que fue añadida una función umbral o función de transferencia.
A pesar de su limitación, el Perceptrón es hoy en día una red muy importante, ya que en base a esta
red se desarrollaron otros modelos de redes neuronales.

15
2.8.1 ESTRUCTURA DE LA RED.
Figura 13. Perceptrón
Esta única neurona realiza la suma ponderada de las entradas multiplicadas por sus pesos,
le suma la función umbral para luego pasar el resultado a una función de transferencia.
La función de transferencia empleada por el Perceptrón es la función escalón (harlim) con
salidas de 0 y 1, o la función hardlims con salidas de -1 y 1. El uso de estas funciones
dependen del valor esperado de la salida de la red.
Se le presenta a la red neuronal Perceptrón un mapa con las regiones de decisión creadas en
un espacio multidimensional, este, separa esta región por un hiperplano cuya ecuación está
determinada por los pesos de la red y el umbral de la función de activación de la neurona.
Los pesos se fijan utilizando diferentes algoritmos de entrenamiento.
El Perceptrón al contar con una única capa de entrada y otra de salida con una única neurona
tiene una capacidad de representación bastante limitada. Este modelo solo es capaz de
resolver problemas que sean linealmente separables. Y es así que la incapacidad del
Perceptrón se puede observar claramente al representar la función lógico matemático XOR.
2.8.2 REGLA DE APRENDIZAJE.
El Perceptrón utiliza un aprendizaje Supervisado, es decir, el entrenador del sistema conoce
la respuesta correcta, y el sistema determina los pesos de tal forma que, dado un valor de

16
entrada, pueda producir el valor de salida deseado. Las salidas de la red a se compara con el
valor esperado t.
Donde:
𝑎 = 𝑓 (∑ 𝑤𝑖𝑝𝑖
𝑖
) = 𝑒𝑠𝑐𝑎𝑙𝑜𝑛 (∑ 𝑤𝑖𝑝𝑖
𝑖
)
El funcionamiento de la red es determinado por los valores de los pesos, los cuales se ajustan
utilizando diferentes algoritmos de entrenamiento.
Este tipo de entrenamiento tiene una analogía con un niño que aprende nuevas lecciones con
la ayuda de su maestro.
Como ejemplo, se resolverá el problema de la función OR. Se tiene cuatro patrones de entrada
y se conoce sus valores de salida esperados.
Figura 14. Función XOR
Las entradas a la red son valores binarios, y la salida está determinada por:
𝑎 = 𝑒𝑠𝑐𝑎𝑙𝑜𝑛 (∑ 𝑤𝑖𝑝𝑖
𝑖
) = 𝑒𝑠𝑐𝑎𝑙𝑜𝑛(𝑤1𝑝1 + 𝑤2𝑝2)

17
Utiliza la función de transferencia Escalón (hardlim), esto quiere decir que, si a es mayor o
igual a O la salida de la red será igual a 1, en caso contrario será igual a O.
Como se puede observar la a función de salida o de transferencia es la expresión de una recta
donde los pesos 𝑤1 y 𝑤2 son las variables y 𝑝1 y 𝑝2 son las constantes. En el proceso de
aprendizaje se irán variando los pesos de tal forma que se encuentre una recta que divida el
plano en dos espacios que separe las dos clases de los valores de entrada.
El Perceptrón y la gráfica con la recta que separa las clases de entradas de la función Or se
muestra en la siguiente figura.
Figura 15. Perceptrón aplicado a la Función OR
Como puede verse la recta separa las dos clases de entradas, lo que hace a la función OR
una función linealmente separable, también podemos observar que las rectas que se irán
formando con el proceso de aprendizaje siempre van a pasar por el origen de coordenadas.
En muchas funciones se requiere que la recta no pase siempre por el origen, pues no lograría
separar las clases (como es el caso de la función AND), por lo que es necesario introducirle
un término independiente que desplace la recta ampliando el número de soluciones, a este
término se le conoce con el nombre de ganancia ‘b’, dando una solución a la función AND
y amplía el número de soluciones para la función OR.

18
Figura 16. Recta Solución para la Función OR y la función AND
Entonces, ahora la salida de la neurona será:
𝑎 = 𝑒𝑠𝑐𝑎𝑙𝑜𝑛 (∑ 𝑤𝑖𝑝𝑖
𝑖
+ 𝑏) = 𝑒𝑠𝑐𝑎𝑙𝑜𝑛(𝑤1𝑝1 + 𝑤2𝑝2 + 𝑏)
2.8.3 ALGORITMO DE ENTRENAMIENTO.
1) Se asigna valores aleatorios a los pesos 𝑤𝑖 y a la ganancia 𝑏.
2) Se le presenta a la red el primer patrón de entrada aún no considerado, junto con
el valor esperado de salida.
3) Se calcula la salida neta de la red.
𝑛 = (𝑤1𝑝1 + 𝑤2𝑝2 + 𝑏) = (∑ 𝑤𝑖𝑝𝑖 + 𝑏
𝑖
)
4) Se aplica la función de transferencia a la salida neta n. el cual puede ser escalón
(hardlim) o hardlims.
𝑎 = 𝑓(𝑛) = 𝑒𝑠𝑐𝑎𝑙𝑜𝑛(𝑛)
5) Se calcula el error correspondiente, que va a ser la diferencia entre la salida
proporcionada por la red a y la salida esperada t.
𝑒 = 𝑡 − 𝑎

19
6) Si el error es distinto de O, entonces debemos modificar los pesos y el valor de
la ganancia.
𝑤𝑛𝑢𝑒𝑣𝑜
= 𝑤𝑎𝑛𝑡𝑒𝑟𝑖𝑜𝑟
+ 𝑒𝑝
Y
𝑏𝑛𝑢𝑒𝑣𝑜
= 𝑏𝑎𝑛𝑡𝑒𝑟𝑖𝑜𝑟
+ 𝑒
7) Se vuelve al paso 2, hasta que los errores para cada patrón de entrada sean
iguales a O.
2.8.4 LIMITACIONES DEL PERCEPTRÓN.
La red de tipo Perceptrón solo puede resolver problemas que sean linealmente separables,
problemas cuyas salidas estén en dos categorías diferentes y que su espacio de entradas pueda
estar dividido en estas dos regiones por medio de un hiperplano.
Las funciones AND y OR son linealmente separables, pero no así la función XOR, porque
no se puede separar por medio de una recta las dos categorías de salidas.
Figura 17. Compuerta XOR

20
Como se puede ver no hay una recta que separe correctamente los patrones de una clase de
la otra, el problema de la compuerta XOR no es linealmente separable, por lo tanto, una red
de tipo Perceptrón no puede resolverlo2
.
El proceso para determinar si un problema es linealmente separable, se realiza sin
problemas de forma gráfica si los patrones de entrada generan un espacio de dos
dimensiones, sin embargo, esta visualización se dificulta si el espacio de patrones de entrada
son tres dimensiones y es imposible observar con dimensiones de entrada superiores; en
este caso se recurre a ecuaciones de desigualdad que permitan comprobar la separabilidad
lineal de los patrones.
2.9 EL PERCEPTRÓN MULTICAPA.
Estructura del Perceptrón multicapa es la siguiente:
Figura 18. Perceptrón multicapa
Esta red permite establecer regiones de decisión muchos más complejas que las de dos semiplanos,
como lo hace le Perceptrón de un solo nivel.
2
Debido a esta limitación y su amplia publicación en el libro de Minsky y Paper el estudio de las RNA se estancó
durante 20 años.

21
La solución para el problema de la compuerta XOR se puede realizar usando un Perceptrón de dos
capas, con dos salidas que nos permitiría descomponer el espacio de decisión en tres categorías.
Para elegir una zona de las otras de las tres se necesita otra capa con una neurona cuyas entradas
serán las salidas de las otras.
Figura 19. Perceptrón para la Compuerta XOR
Las capacidades del Perceptrón multicapa con dos y tres capas y con una única neurona en la capa
de salida se muestra en la siguiente figura.
Figura 20. Distintas formas de las regiones generadas por un Perceptrón multicapa

22
2.10 ALGORITMICA GENERAL
La algorítmica estudia los algoritmos, sus propiedades y su eficiencia. El algorítmica tiene
como objetivo el desarrollo de métodos y técnicas para el diseño de algoritmos y estructuras de
datos (EDs) eficientes y su análisis, así como el desarrollo de algoritmos y EDs que resuelvan
problemas concretos. Tras un breve repaso de conceptos y técnicas algorítmicas básicas ya
conocidas, se estudian nuevas técnicas de diseño algorítmico como el método voraz (greedy
method), la programación dinámica, los flujos sobre redes, la programación lineal y la
aleatorización. Cada una de las técnicas de diseño y análisis estudiadas se ilustra con ejemplos
concretos, muchos de ellos algoritmos y EDs de gran trascendencia práctica como el algoritmo de
Dijkstra para el cálculo de caminos mínimos en un grafo, el algoritmo de cálculo de la distancia de
edición entre dos strings, el test de primalidad de Rabin o el algoritmo de Ford-Fulkerson para
encontrar el flujo óptimo sobre una red. (jvalvarez)
2.10.1 COMPLEJIDAD ALGORITMICA
La complejidad algorítmica representa la cantidad de recursos (temporales) que necesita un
algoritmo para resolver un problema y por tanto permite determinar la eficiencia de dicho
algoritmo.
Los criterios que se van a emplear para evaluar la complejidad algorítmica no proporcionan
medidas absolutas sino medidas relativas al tamaño del problema. (jvalvarez)
 El tiempo empleado por el algoritmo se mide en pasos.
 El coste depende del tamaño de los datos.
 A la hora de evaluar el coste se debe de tener en consideración tres posibles casos:
 El coste esperado o promedio
 El coste mejor
 El coste peor
 Si el tamaño de los datos es grande lo que importa es el comportamiento asintótico de
la eficiencia.
El tiempo requerido por un algoritmo es función del tamaño de los datos. Por esta razón la
complejidad temporal se expresa de la siguiente forma:

23
𝑇(𝑛) = 𝑓(𝑛)
Dependiendo del problema, el tamaño del dato representa cosas diferentes:
 el número en sí
 el número de dígitos o elementos que lo compone.
Otra característica importante es que no todos los datos, dentro de un problema, poseen la
misma importancia de cara a la complejidad algorítmica.
 Tmax(n): Representa la complejidad temporal en el peor de los casos.
 Tmin(n): Representa la complejidad en el mejor de los casos posibles.
 Tmed(n): Expresa la complejidad temporal en el caso promedio. Para su cálculo se
suponen que todas las entradas son equiprobables.
Tiempos empleados para el cálculo de algoritmos con distintos ordenes, considerando que el
computador en cuestión ejecuta 1 Millón de operaciones por segundo (1MHz).
Figura 21. Tiempos y notación empleada
Fuente: (jvalvarez)

24
Figura 22. Gráfica de las complejidades algorítmicas
Fuente: (jvalvarez)
2.10.2 MEDIDAS DEL COMPORTAMIENTO ASINTÓTICO
El orden de la función T(n) expresa el comportamiento dominante para los datos de gran
tamaño.
Para poder determinar y expresar correctamente el comportamiento asintótico es conveniente
disponer de una adecuada notación. A continuación, se presentan las notaciones:
 O Mayúscula (Orden del peor de los casos)
 Ω Mayúscula (Orden del Mejor de los casos)
 Θ Mayúscula (Orden del Caso promedio)
2.10.3 JERARQUÍA DE ÓRDENES.
Los comportamientos asintóticos de más frecuente aparición se pueden ordenar de menor a
mayor crecimiento de la siguiente forma:
1<<< n<<< n 2<< n 3<<.....<< 2 n<<n!

25
2.11 ANÁLISIS DE ALGORITMOS
El análisis de algoritmos es una parte importante de la Teoría de complejidad computacional,
que provee estimaciones teóricas para los recursos que necesita cualquier algoritmo que resuelva
un problema computacional dado. Estas estimaciones resultan ser bastante útiles en la búsqueda de
algoritmos eficientes.
A la hora de realizar un análisis teórico de algoritmos es común calcular su complejidad en un
sentido asintótico, es decir, para un tamaño de entrada suficientemente grande. La cota superior
asintótica, y las notaciones omegas (cota inferior) y theta (caso promedio) se usan con esa finalidad.
Por ejemplo, la búsqueda binaria decimos que se ejecuta en una cantidad de pasos proporcional a
un logaritmo, en O(log(n)), coloquialmente "en tiempo logarítmico". Normalmente las
estimaciones asintóticas se utilizan porque diferentes implementaciones del mismo algoritmo no
tienen por qué tener la misma eficiencia. No obstante, la eficiencia de dos implementaciones
"razonables" cualesquiera de un algoritmo dado están relacionadas por una constante multiplicativa
llamada constante oculta. (Wikipedia, 2021)
El análisis de algoritmos tiene los siguientes objetivos:
 Estudiar el rendimiento de los algoritmos en base al consumo de recursos (tiempo de
ejecución y espacio en memoria)
 Comparar algoritmos
 Enfoque basado en el tiempo
2.11.1 COSTES EN TIEMPO Y EN ESPACIO.
La característica básica que debe tener un algoritmo es que sea correcto, es decir, que
produzca el resultado deseado en tiempo finito. Adicionalmente puede interesarnos que sea
claro, que esté bien estructurado, que sea fácil de usar, que sea fácil de implementar y que
sea eficiente.
Entendemos por eficiencia de un algoritmo la cantidad de recursos de cómputo que requiere;
es decir, cuál es su tiempo de ejecución y qué cantidad de memoria utiliza.

26
A la cantidad de tiempo que requiere la ejecución de un cierto algoritmo se le suele llamar
coste en tiempo mientras que a la cantidad de memoria que requiere se le suele llamar coste
en espacio. (Duch, 2007)

27
CAPITULO III MARCO METODOLÓGICO
3.1 METODOS Y TÉCNICAS UTILIZADAS.
3.1.1 METODOLOGÍA PARA EL DESARROLLO DE RNA.
La metodología representa un conjunto ordenado de guías que permiten inferir la manera de
hacer frente a una situación. Para esto se emplean los modelos, que son una abstracción del
comportamiento de un sistema.
Debido al proceso de investigación de Redes Neuronales Artificiales, se ha definido una
manera particular de enfocar los proyectos de este tipo. Llamada; Forma general de
resolución:
Existen dos fases en toda aplicación de las Redes Neuronales.
 Fase de aprendizaje o entrenamiento
 Fase de pruebas
En la fase de entrenamiento, se usa un conjunto de datos o patrones de entrenamiento para
determinar los pesos que definen el modelo neuronal. Una vez entrenado este modelo, se
usará la llamada fase de pruebas o funcionamiento directo, en la que se procesan los patrones
de prueba que constituyen la entrada habitual de la red, analizándose de esta manera el
funcionamiento definitivo de la red.
3.1.2 MÉTODO DEL ANÁLISIS DE ALGORITMOS.
Otro método que se va a utilizar es el análisis de algoritmos. El análisis de algoritmos es una
parte importante de la Teoría de complejidad computacional, que provee estimaciones
teóricas para los recursos que necesita cualquier algoritmo que resuelva un problema
computacional dado. Estas estimaciones resultan ser bastante útiles en la búsqueda de
algoritmos eficientes.
 Escribir un programa
 Incluye instrucciones para medir el tiempo de ejecución
 Ejecuta el programa con entradas de diferentes tamaños

28
 Representa gráficamente los resultados
3.2 FASES DEL PROCESO DE INVESTIGACION
La metodología para la resolución de las redes neuronales artificiales es la siguiente:
Figura 23. Fases de la metodología
3.3 DESARROLLO DEL TRABAJO
El trabajo de investigación se va a desarrollar aplicando la ciencia de la inteligencia artificial
y las redes neuronales artificiales.
La red neuronal implementada se va a probar en un robot simulado, con cuatro sensores y dos
motores que sirven para detectar obstáculos y actuar en base a ello.

29
3.4 CRITERIOS DE ANÁLISIS
El análisis de los resultados se realiza con el método de la algorítmica general y el análisis
de algoritmos. Se van a comparar las soluciones aplicadas al robot, con un método empírico y una
red neuronal, para determinar qué solución es la más eficiente.
3.5 ALCANCES Y LIMITACIONES
Como alcance de la investigación se implementa una red neuronal artificial del tipo
perceptrón, entrenado y probado en un robot detector de obstáculos con cuatro sensores y dos
motores.
El proyecto se limita a la realización de pruebas en ambientes y obstáculos controlados, además el
robot es simulado por software. Para tal efecto, no se va a construir un robot a nivel hardware con
Arduino, lego, etc.

30
CAPITULO IV MARCO PROPOSITIVO
El proyecto se desarrolla en base a las fases de la metodología identificada.
3.6 FASE DE APRENDIZAJE.
3.6.1 DEFINICIÓN DEL PROBLEMA.
Se tiene un robot que tiene que detectar obstáculo de forma eficiente y actuar en
consecuencia. Por lo tanto, se diseña un robot que cuenta con cuatro sensores de proximidad
(S1, S2, S3, S4) ubicados en la parte de adelante, a los costados y atrás que permanentemente
están detectando si hay obstáculos que se encuentren a una distancia menor o mayor a la
preestablecida. Con esta información se decide si dar marcha adelante o dar marcha atrás en
cada uno de los motores que posee nuestro robot (M1, M2), que, además, estos motores están
ubicados en cada una de sus llantas traseras.
De este modo nuestro robot sabe qué hacer cuando se encuentre frente a un obstáculo.
Figura 24. Diseño del robot
Fuente: Elaboración propia

31
3.6.2 RECOLECCIÓN DE DATOS.
Este robot posee cuatro sensores y dos motores, por los tanto, podrían darse 16 posibles
combinaciones (24
= 16), para cada combinación los motores deberán dar marcha hacia
adelante o hacia atrás.
Cuando un sensor detecta un obstáculo en una distancia menor a la preestablecida este se
activa en 1 y cuando no lo detecta se pone en -1, dependiendo de estas lecturas los motores
podrían dar marcha adelante 1, o marcha atrás -1.
Ejemplo, si las lecturas de los sensores son:
Tabla 1. Lecturas de los sensores y las acciones de los motores
S1 S2 S3 S4 M1 M2
1 -1 -1 -1 -1 1
Esto quiere decir que el sensor uno S1, ha detectado un obstáculo, entonces, el motor uno se
apaga o da marcha atrás y el motor dos da marcha adelante logando un giro a la izquierda, de
este modo se logra esquivar el obstáculo.
A continuación, se muestran dos mundos que servirán de entradas para nuestra Red Neuronal.
El robot deberá recorrer y esquivar los obstáculos que se le presenten a lo largo de su
recorrido hasta salir del mundo.
a) Mundo 1.

32
Figura 25. Diseño del mundo 1
Para recolectar los datos del mundo 1, se identifican los siguientes patrones:
Patrón 1.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 -1 -1 -1 -1 -1

33
Patrón 2.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
1 -1 -1 -1 -1 1
Patrón 3.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 -1 1 -1 1 1
Patrón 4.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
1 -1 1 -1 -1 1

34
Patrón 5.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 -1 1 1 1 1
Patrón 6.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
1 1 -1 -1 1 -1
Patrón 7.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 1 -1 1 1 1

35
Patrón 8.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 1 -1 -1 1 1
Patrón 9.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
La tabla que describe el comportamiento del robot para el mundo 1, se muestra en la siguiente
tabla.
Tabla 2. Comportamiento del robot – Mundo 1
S1 S2 S3 S4 M1 M2
-1 -1 -1 -1 -1 -1
1 -1 -1 -1 -1 1
-1 -1 1 -1 1 1
1 -1 1 -1 -1 1
-1 -1 1 1 1 1

36
No se registraron todas las posibles
situaciones en que se encontraría
nuestro robot, sino solo las más
importantes, esto, para demostrar el poder
de generalización que tiene una red
neuronal ante situaciones nunca antes encontradas.
La forma en que se determinaron los valores de la tabla se detalla en el anexo A (ver Anexo
A).
b) Mundo 2.
Figura 26. Diseño del mundo 2
La tabla que describe el comportamiento del robot para el mundo 2, se muestra en la
siguiente tabla.
Se tomará en cuenta este mundo y esta tabla como referencia para el entrenamiento de la
red neuronal.
1 1 -1 -1 1 -1
-1 1 -1 1 1 1
-1 1 -1 -1 1 1
-1 1 1 -1 1 1

37
Tabla 3. Comportamiento del robot – Mundo 2
3.6.3 DISEÑO DE PRE Y POST PROCESAMIENTO.
La red neuronal debe ser diseñada con una única ley de aprendizaje, un solo esquema de
interconexión y una estructura que cubra los requerimientos del problema. .
El tiempo de respuesta y aprendizaje de la red debe ser el mínimo requerido.
a) Justificación del modelo.
Este tipo de problemas generalmente es resuelto suministrándole al robot una base de datos
(la Tabla del comportamiento del robot), en este caso se necesitaría almacenar en la memoria
del robot las respuestas para ambos motores ante las 16 posibles combinaciones cuando se
lean los sensores.
Este método tiene serios inconvenientes ya que cuando el número de variables de entrada y
el número de salidas es mucho mayor, la cantidad de datos para especificar cada posible
situación crece indefinidamente (2n
), debido a esto se necesitarán dispositivos con gran
capacidad de almacenamiento.
S1 S2 S3 S4 M1 M2
-1 -1 -1 -1 1 1
1 -1 -1 -1 1 -1
-1 1 1 -1 1 1
-1 1 -1 -1 1 1
1 1 -1 -1 1 -1
-1 1 -1 1 1 1
1 -1 1 -1 -1 1
-1 -1 1 1 1 1
1 1 1 -1 1 -1

38
En contraste una red neuronal puede entrenarse con un número representativo de patrones y
aprender el comportamiento del sistema utilizando dispositivos de menor capacidad de
almacenamiento y costo.
Una red neuronal tipo Perceptrón puede ser entrenada con cualquier dimensión de patrones
con datos binarios, por esta razón se eligió este tipo de Red Neuronal para resolver nuestro
problema.
Para que el problema pueda ser resuelto por una red del tipo Perceptrón se debe comprobar
que los patrones de entrenamiento son linealmente separables.
En este caso cada patrón de cuatro dimensiones generará dos desigualdades, una para cada
salida, para que sean linealmente separables estas desigualdades no deben contradecirse,
sino, se deberá buscar otro tipo de solución.
La salida de la red está dada por la siguiente ecuación.
𝑛 = 𝑊𝑝 + 𝑏
Aplicando esta ecuación a cada patrón de entrenamiento del Mapa 2 Figura 26. Diseño del
mundo 2, se tiene:
𝑃1 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 < 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 < 0
𝑃2 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 ≥ 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 < 0
𝑃3 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 ≥ 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
𝑃4 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 ≥ 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
𝑃5 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 ≥ 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 < 0
𝑃6 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 ≥ 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
𝑃7 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 < 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
𝑃8 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 ≥ 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
𝑃9 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 < 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
𝑃10 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 ≥ 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
𝑃11 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 < 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
𝑃12 {
𝑊11 + 𝑊12+𝑊13 + 𝑊14 + 𝑏1 ≥ 0
𝑊21 + 𝑊22+𝑊23 + 𝑊24 + 𝑏2 ≥ 0
Figura 27. Desigualdades que garantizan que el problema es linealmente separable

39
Las ecuaciones satisfacen plenamente las desigualdades, de forma que puede ser resuelta por
una red del tipo Perceptrón.
Cabe mencionar que solo se verifica la separabilidad lineal para el Mundo 2, esto con el fin
de mostrar el poder de generalización de una Red Neuronal tipo Perceptrón ante situaciones
nunca antes vistas.
b) Estructura lógica.
 Número de entradas:
Se cuenta con cuatro sensores de proximidad, por lo tanto, la red neuronal tendrá cuatro
entradas (S1, S2, S3 y S4).
 Número de salidas:
Para cada patrón de entrada se tiene dos salidas que corresponden a los dos motores de
nuestro robot (M1, M2).
 Numero de capas:
La red neuronal será diseñada con una capa de entrada, una capa oculta y una capa de
salida.
 Número de neuronas:
Se creará una red de cuatro entradas con una neurona tipo Perceptrón para cada salida,
teniendo así una salida bidimensional. O sea, se va a trabajar con dos neuronas artificiales.
c) Funciones y elementos matemáticos
 Función de Transferencia:
Debido a la naturaleza bipolar de la salida y de la entrada de la red se consideró que la
función de transferencia apropiada es la función Escalón (hardlims).

40
Figura 28. Función de transferencia Escalón (hardlims)
d) Gráfica del modelo
Un diagrama gráfico del diseño de la red neuronal se presenta a continuación.
Figura 29. Red Neuronal Tipo Perceptrón para el robot
3.6.4 DISEÑO DE LA RED.
En este punto se muestra la regla y el algoritmo de aprendizaje que va a utilizar nuestra red,
además, de la implementación del simulador para el entrenamiento de la Red Neuronal
Artificial.

41
a) Algoritmo de entrenamiento:
El Perceptrón utiliza un aprendizaje Supervisado, es decir, se conoce la respuesta correcta
antes del entrenamiento, y el sistema determina los pesos de tal forma que, dado un valor de
entrada, pueda producir el valor de salida deseado. [Ver ALGORITMO DE
ENTRENAMIENTO.
El algoritmo de entrenamiento que utiliza nuestra red neuronal tipo Perceptrón podemos
verlo en [Ver algoritmo Anexo B].
b) Implementación del Simulador:
El simulador fue implementado, siguiendo el algoritmo de entrenamiento supervisado, con
el lenguaje de programación C# 4.0 bajo la plataforma .NET [Ver código Anexo C]
Básicamente consta de una Clase llamada PercepRobot que tiene los siguientes eventos:
 public void robot(int[,] x): Llenamos la tabla con el mapa 2
 public int fscalon(double n): La función de transferencia
 public double WP_b(int[,] P, double[,] W, double[] b, int fp, int fw, int
fb): La salida neta de la red (n).
 public void newPesos(int[,] P, double[,] W, int error, int fp, int fw):
La modificación de los pesos.
También cuenta con una clase principal llamada frmRobot donde el evento que nos interesa
es: btnPasoPaso_Click() que realiza en entrenamiento de la red paso a paso [Ver código
Anexo C].
Figura 30. Interfaz principal de la red neuronal

42
Figura 31. Interfaz de simulador para el entrenamiento de la Red Neuronal
3.6.5 ENTRENAMIENTO DE LA RED.
Para el entrenamiento de nuestra Red Neuronal, utilizamos el simulador desarrollado en el
punto anterior.
Se le presenta los 12 patrones correspondiente al Mundo 2, los cuales dependiendo de las
lecturas de los sensores se le dirá al robot que hacer específicamente y luego se probará la
red con los casos restantes para comprobar la capacidad de generalización de una Red
Neuronal Artificial ante un patrón nunca antes visto. (Se probará la generalización para el
Mundo 1).
Los estados de las lecturas de los sensores y de operación de los motores se designaron con
1 y -1, puesto que la convergencia del proceso de entrenamiento es más rápida, que usando
1 y 0.

43
Entonces, para el entrenamiento: Como tenemos dos neuronas con cuatro entradas,
tendremos la matriz Wij de 2x4 que representa los pesos de la red, y el vector bi de 1x2 que
representa las ganancias de cada neurona.
Siguiendo el proceso del algoritmo de entrenamiento de una Red Neuronal del tipo
Perceptrón [Ver Anexo B], realizamos el entrenamiento, utilizando el Simulador.
Tabla 4. Tabla que representa el comportamiento del robot para el Mundo 1
a) Entrenamiento de la red:
Se asignan valores aleatorios a los pesos y a la ganancia.
Tabla 5. Pesos y ganancias aleatorias iniciales
S1 S2 S3 S4 M1 M2
-1 -1 -1 -1 1 1
1 -1 -1 -1 1 -1
-1 1 1 -1 1 1
-1 1 -1 -1 1 1
1 1 -1 -1 1 -1
-1 1 -1 1 1 1
1 -1 1 -1 -1 1
-1 -1 1 1 1 1
1 1 1 -1 1 -1
-1 -1 1 -1 1 1
1 1 -1 1 1 -1
-1 1 1 1 1 1
Wij S1 S2 S3 S4
M1 0.967 0.365 0.445 -0.796
M2 -0.143 -0.601 0.155 -0.179
bi b
M1 1
M2 1

44
 Se le presenta el primer patrón de entrada y su salida esperada
 Se calcula la salida neta de la red
 Se aplica la función de transferencia escalón (harlims)
 Se calcula el error
Figura 32. Interfaz antes del entrenamiento de la red neuronal
Luego del proceso de entrenamiento, los pesos finales de la red que satisfacen todos los
patrones de entrada y salida son:

45
Figura 33. Interfaz de la red neuronal entrenada
Tabla 6. Pesos y ganancias finales
Wij S1 S2 S3 S4
M1 -3.03 4.36 -3.55 -0.79
M2 -6.14 -2.60 2.15 -2.17
La red fue simulada para la totalidad de combinaciones posibles de entrada para comprobar
que no exista error en el aprendizaje de los patrones de entrenamiento y para observar su
capacidad de generalización en los casos restantes.
Figura 34. Interfaz de las pruebas de la red neuronal
La respuesta de la red a todos los patrones de entrenamiento fue exitosa.
Bi b
M1 9
M2 3

46
La red fue entrenada para las posibles situaciones restantes obteniéndose los siguientes
resultados.
Tabla 7. Simulación de la red para las nuevas combinaciones
Las combinaciones que no hacían parte del set de entrenamiento, al ser presentadas a la Red
Neuronal, fueron aproximadas al patrón con menor distancia euclidiana.
3.7 FASE DE PRUEBAS.
En este punto se realiza las pruebas de la Red Neuronal ya entrenada en el robot simulado
creado a nivel software en 3D.
3.7.1 IMPLEMENTACIÓN DE LA RED NEURONAL EN UN ROBOT.
Para este fin se utilizó el lenguaje de programación C/C++ bajo Cbuilder 5.0 y el componente
grafico TOpenGL.
El programa consta básicamente de Tres funciones:
void TfrmPrincipal::leer_sensor()
{
//sensor de adelante S1
Sensor[S1] = (MapaAct[zz+2][xx] == 1)?1:-1;
//sensor izquierdo S2
Sensor[S2] = (MapaAct[zz][xx+2] == 1)?1:-1;
//sensor derecho S3
Sensor[S3] = (MapaAct[zz][xx-2] == 1)?1:-1;
//sensor de atraz S4
Sensor[S4] = (MapaAct[zz-2][xx] == 1)?1:-1;
}
Esta función lee los sensores a cada paso que da el robot. Si a una distancia determinada
existe un obstáculo el sensor marca 1, en caso contrario el sensor marca -1
S1 S2 S3 S4 M1 M2
1 1 1 1 1 -1
1 -1 1 1 -1 -1
-1 -1 -1 1 1 1
1 -1 1 1 -1 -1
Figura 4.1.5.3. Simulación de la red para las nuevas combinaciones

47
void TfrmPrincipal::perceptron()
{
float wp = 0;
float PesoNeto;
//Para el motor_1
wp=W[0][0]*Sensor[0]+W[0][1]*Sensor[1]+W[0][2]*Sensor[2]+W[0][3]*Sensor[3];
PesoNeto = wp + b[0];
//aplicando la funcion escalon
M1 =(PesoNeto >= 0)?1:-1;
//Para el Motor_ 2
wp = 0;
M2 = (PesoNeto >= 0)?1:-1;
}
Esta función es la que implementa la Red Neuronal Artificial del tipo Perceptrón ya entrenada
en el robot, indicándole a cada instante la acción debe tomar cada uno de sus motores.
Recordemos que si el motor da marcha hacia adelante se pone en 1, sino se pone en -1.
void TfrmPrincipal::girar(){
if(M1 == -1 && M2 == -1){
switch(S1)
{
case 0:zz++;break;
case 1:xx--;break;
case 2:xx++;break;
case 3:zz--;break;
}
}
else{
if(M1 == 1 && M2 == -1) { //giro a la derecha
//rotando los sensores junto con el robot
e++;if(e>3)e = 0;
f++;if(f>3)f = 0;
g++;if(g>3)g = 0;
h++;if(h>3)h = 0;
S1 = MS[e];S2 = MS[f];S3 = MS[g];S4 = MS[h];
}
else{
if(M1 == -1 && M2 == 1) { //giro a la izquierda
e--;if(e<0)e = 3;
f--;if(f<0)f = 3;
g--;if(g<0)g = 3;
h--;if(h<0)h = 3;
}
if(M1 == 1 && M2 == 1){
switch(S1){
case 0:zz++;break;

48
case 1:xx--;;break;
case 2:xx++;break;
case 3:zz--;break;
}
}
}
}
}
Dependiendo el estado del motor, el robot deberá ir adelante o atrás, girar a la izquierda o a
la derecha, etc. Esta función es la que se encarga de todos estos giros.
La interfaz implementada nos permite elegir entre que mapas o mundos queremos recorrer,
recordemos que se definieron dos tipos de mundos, además nos permite verificar el estado
de los sensores y la acción de los motores.
Figura 35. Interfaz del robot recorriendo el mundo 2

49
Figura 36. Interfaz del robot recorriendo el mundo 1
Se pudo observar que el robot recorrió satisfactoriamente ambos mundos, considerando, que
solo se lo entrenó para el mundo 2.
Para realizar el recorrido del mundo 1 la RNA tuvo que generalizar su comportamiento,
demostrando así el poder de generalización de una Red Neuronal Artificial ante situaciones
nunca antes vista.
3.8 ANÁLISIS DEL TIEMPO DE EJECUCIÓN.
En este punto se realiza el análisis del tiempo de ejecución de las funciones que intervienen
en la implementación de la Red Neuronal Artificial en el Robot, utilizando el método de análisis
por conteo de instrucciones para el peor de los casos.
Este análisis lo realizamos con el fin de comparar el método de las Redes Neuronales con otros
métodos tradicionales.

50
{
//sensor derecho S3
}
𝑇1(𝑛) = 5 + 5 + 5 + 5 = 20
𝑇1(𝑛) = 𝑶(𝟏) 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒
5
5
5
5
Operaciones
elementales
void TfrmPrincipal::perceptron()
{
float wp;
float PesoNeto;
//Para el motor_1
wp = 0;
M1 =(PesoNeto >= 0)?1:-1;
//Para el Motor_ 2
wp = 0;
M2 = (PesoNeto >= 0)?1:-1;
}
𝑇2(𝑛) = 1 + 20 + 3 + 2 + 1 + 20 + 3 + 2 = 52
1
20
3
2
1
20
3
2
Operaciones
elementales

51
La función que llama a las anteriores funciones es la siguiente:
El tiempo de ejecución de la red neuronal del tipo perceptrón es de orden constante, esto quiere
decir que es totalmente eficiente, ya que, la complejidad no crece con respecto al tiempo.
void TfrmPrincipal::girar()
{
if(M1 == -1 && M2 == -1)
{
switch(S1)
{
case 0:zz++;break;
case 1:xx--;break;
case 2:xx++;break;
case 3:zz--;break;
}
}
else
{
if(M1 == 1 && M2 == -1) //giro a la derecha
{
e++;if(e>3)e = 0;
f++;if(f>3)f = 0;
g++;if(g>3)g = 0;
h++;if(h>3)h = 0;
}
else
{
if(M1 == -1 && M2 == 1) //giro a la izquierda
{
e--;if(e<0)e = 3;
f--;if(f<0)f = 3;
g--;if(g<0)g = 3;
h--;if(h<0)h = 3;
}
else
{
switch(S1)
{
case 0:zz++;break;
case 1:xx--;break;
case 2:xx++;break;
case 3:zz--;break;
}
}
}
}
}
𝑇3(𝑛) = 3 + 4 + 4 + 4 + 4 + 8 = 27
3
1
4
4
4
4
3
4
4
4
4
8
3
4
4
4
4
8
1
4
4
4
4
void __fastcall TfrmPrincipal::Timer1Timer(TObject *Sender)
{
leer_sensor();
perceptron();
girar();
}
𝑇(𝑛) = 𝑇1(𝑛) + 𝑇2(𝑛) + 𝑇3(𝑛) = max⁡
{20 ,52 ,27} = 52
T1(n)
T2(n)
T3(n)
𝑇(𝑛) = 𝑶(𝟏) 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒

52
Figura 37. Comportamiento del tiempo de ejecución de la RNA
3.9 COMPARACIÓN CON OTROS MÉTODOS.
Ya hemos visto el comportamiento del robot y el tiempo de ejecución que requiere este para
detectar obstáculos utilizando una RNA del tipo Perceptrón, no nos serviría de mucho si no
mostramos la eficiencia de este método frente a otros propuestos.
En este punto vamos a implementar el comportamiento del robot con un método tradicional.
3.9.1 IMPLEMENTACIÓN CON UN MÉTODO TRADICIONAL.
Este tipo de problemas generalmente es resulto suministrándole al robot una base de datos
(la Tabla del comportamiento del robot), en este caso se necesitaría almacenar en la memoria
del robot las respuestas para ambos motores ante las 16 posibles combinaciones cuando se
lean los sensores.
Para implementar con este método, necesariamente se necesita la tabla del comportamiento
del robot almacenada en su memoria.

53
int MatrizComp[16][6] = {
{-1, -1, -1, -1, 1, 1},
{ 1, -1, -1, -1, 1, -1},
{-1, 1, 1, -1, 1, 1},
{-1, 1, -1, -1, 1, 1},
{ 1, 1, -1, -1, 1, -1},
{-1, 1, -1, 1, 1, 1},
{ 1, -1, 1, -1,-1, 1},
{-1, -1, 1, 1, 1, 1},
{ 1, 1, 1, -1, 1, -1},
{-1, -1, 1, -1, 1, 1},
{ 1, 1, -1, 1, 1, -1},
{-1, 1, 1, 1, 1, 1},
{ 1, 1, 1, 1, 1, -1},
{-1, -1, -1, 1, 1, 1},
{ 1, -1, -1, 1, 1, -1},
{ 1, -1, 1, 1,-1, -1}
};
Al igual que le método de la RNA, necesitamos de 3 funciones principales.
Esta función lee los sensores a cada paso que da el robot. Si a una distancia determinada
existe un obstáculo el sensor marca 1, sino marca -1.
{
//sensor derecho S3
}
void TfrmPrincipal::busqueda()
{
//realizando la busqueda en la matriz de comportamiento del robot
for(int i = 0; i<n; i++)
{
if(Sensor[0] == MatrizComp[i][0] && Sensor[1] == MatrizComp[i][1]
&& Sensor[2] == MatrizComp[i][2]&& Sensor[3] == MatrizComp[i][3])
{
M1 = MatrizComp[i][4];
}
}
}

54
Esta función es la que hace la búsqueda en la base de datos (tabla de comportamiento) e
indicarle a cada instante la acción debe tomar cada uno de sus motores.
Recordemos que si el motor da marcha hacia adelante se pone en 1, sino se pone en -1.
Dependiendo el estado del motor, el robot deberá ir adelante o atrás, girar a la izquierda o a
la derecha, etc. Esta función es la que se encarga de todos estos giros.
Este método tiene serios inconvenientes ya que cuando el número de variables de entrada y
el número de salidas es mucho mayor, la cantidad de datos para especificar cada posible
void TfrmPrincipal::girar()
{
if(M1 == -1 && M2 == -1)
{
switch(S1)
{
case 0:zz++;break;
case 1:xx--;break;
case 2:xx++;break;
case 3:zz--;break;
}
}
else
{
if(M1 == 1 && M2 == -1) //giro a la derecha
{
e++;if(e>3)e = 0;
f++;if(f>3)f = 0;
g++;if(g>3)g = 0;
h++;if(h>3)h = 0;
}
else
{
if(M1 == -1 && M2 == 1) //giro a la izquierda
{
e--;if(e<0)e = 3;
f--;if(f<0)f = 3;
g--;if(g<0)g = 3;
h--;if(h<0)h = 3;
}
if(M1 == 1 && M2 == 1)
{
switch(S1)
{
case 0:zz++;break;
case 1:xx--;;break;
case 2:xx++;break;
case 3:zz--;break;
}
}
}
}
}

55
situación crece indefinidamente (2n
), debido a esto se necesitarán dispositivos con gran
capacidad de almacenamiento.
3.9.2 ANÁLISIS DEL TIEMPO DE EJECUCIÓN.
Como podemos notar, la única diferencia de este método con el da la RNA, es la función de
búsqueda.
Realizaremos el análisis de Tiempo de Ejecución para esta función, nuevamente, con conteo
de instrucciones.
La función que llama a las anteriores funciones es la siguiente:
void TfrmPrincipal::busqueda()
{
//realizando la busqueda en la matriz de comportamiento del robot
for(int i = 0; i<n; i++)
{
if(Sensor[0] == MatrizComp[i][0] && Sensor[1] == MatrizComp[i][1]
&& Sensor[2] == MatrizComp[i][2]&& Sensor[3] == MatrizComp[i][3])
{
}
}
}
𝑇4(𝑛) = ∑(3 + 18) + 3 + 1 = 21𝑛 + 4
𝑛
𝑖=1
𝑇4(𝑛) = 𝑶(𝒏) 𝑙𝑖𝑛𝑒𝑎𝑙
3
18
3
3
Operaciones
elementales
void __fastcall TfrmPrincipal::Timer1Timer(TObject *Sender)
{
leer_sensor();
busqueda();
girar();
}
𝑇(𝑛) = 𝑇1(𝑛) + 𝑇4(𝑛) + 𝑇3(𝑛) = max⁡
{20 ,21𝑛 + 4 ,27} = 21𝑛 + 4
T1(n)
T4(n)
T3(n)
𝑇(𝑛) = 𝑶(𝒏) 𝑙𝑖𝑛𝑒𝑎𝑙

56
Figura 38. Comportamiento del tiempo de ejecución del método tradicional
3.9.3 COMPARACIÓN DE LOS MÉTODOS.
Como podemos notar; ambos métodos realizan el mismo trabajo de forma satisfactoria, sin
embargo, uno de ellos es más eficiente que el otro en tiempo de ejecución y espacio de
memoria utilizado.
Esta diferencia lo podemos demostrar con el análisis de tiempo de ejecución para cada una
de las implementaciones de los métodos.
Para comparar los tiempos de ejecución de ambos métodos recurrimos a la notación asintótica
de la algoritmia, utilizando la regla de los límites.
lim
𝑛→∞
𝑇𝑟𝑛𝑎(𝑛)
𝑇𝑚𝑡(𝑛)
→ lim
𝑛→∞
52
21𝑛 + 4
= lim
𝑛→∞
0
21
= 0
Entonces:
𝑇𝑟𝑛𝑎(𝑛) ∈ 𝑶(𝑇𝑚𝑡(𝒏)) → 𝑻𝒓𝒏𝒂(𝒏) 𝒆𝒔 𝒎𝒂𝒔 𝒆𝒇𝒊𝒄𝒊𝒆𝒏𝒕𝒆 𝒒𝒖𝒆 𝑻𝒎𝒕(𝒏)
𝑇𝑟𝑛𝑎 (𝑛) = 𝟓𝟐
𝑇𝑟𝑛𝑎 (𝑛) = 𝑶(𝟏) 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒
𝑇𝑚𝑡 (𝑛) = 21𝑛 + 4
𝑇𝑚𝑡 (𝑛) = 𝑶(𝒏) 𝑙𝑖𝑛𝑒𝑎𝑙
Tiempo de Ejecución utilizando RNA Tiempo de Ejecución utilizando Matriz de Búsqueda

57
De esta forma queda demostrado que el Tiempo de Ejecución del método de las RNA es más
eficiente que la del método tradicional de la matriz de búsqueda. Podemos verlo también de
forma gráfica.
Figura 39. Gráfica del tiempo de ejecución para ambos métodos
Tmt(n) crece a medida que lo hace n, lo que lo hace menos eficiente porque a media que se
vayan aumentando el número de sensores y motores, el tiempo de ejecución también
aumentará, no sucede lo mismo con Trna(n), ya que esta siempre se mantiene constante.
Además, para el método tradicional de búsqueda tenemos que almacenar la matriz de
comportamiento, esto conlleva a que tengamos que utilizar dispositivos con gran capacidad
de almacenamiento. En contraste, una red neuronal puede ser entrenada con un número
representativo de patrones y aprender el comportamiento del sistema utilizando dispositivos
de menor capacidad de almacenamiento y costo.

58
CAPITULO V CONCLUSIONES Y RECOMENDACIONES
5.1 CONCLUSIONES
El presente proyecto realizado ha logrado alcanzar los objetivos propuestos, ya que, el
programa implementado ha logrado entrenar la red neuronal, tal que este entrenamiento ha
conseguido proveer información a nuestro robot para que sea capaz de detectar obstáculos de forma
eficiente, tal como se propuso en el objetivo general.
Una Red Neuronal del tipo Perceptrón de una sola capa es una buena solución a problemas que
sean linealmente separables, si no son linealmente separables se tiene la alternativa de usar una red
del tipo Perceptrón multicapa capaz de solucionar el problema de la separabilidad lineal caso
contrario se debería cambiar definitivamente de red.
La capacidad de generalización de una red neuronal artificial, es muy importante ya que nos
permite generalizar el comportamiento del sistema, y, de esta forma ahorrar tiempo de cómputo en
el entrenamiento de la red, ya que solo lo entrenamos con un número representativo de patrones.
En el caso del robot se pudo constatar que la red fue entrenada para el mundo 2 y generalizó su
comportamiento para el recorrer el mundo 1.
El método de las redes neuronales artificiales sin duda es totalmente eficiente, ya que su tiempo de
ejecución constante le hace altamente paralelo otorgándole al robot un grado de inteligencia
impresionante (como la del cerebro de un ser humano), en comparación al método tradicional de
búsqueda cuyo tiempo de ejecución va creciendo indefinidamente.
5.2 RECOMENDACIONES
Se recomienda implementar y probar la red neuronal artificial entrenada del tipo perceptrón,
en un robot físico construido con Lego, Arduino o componentes electrónicos propios, para darle
mayor relevancia y credibilidad a la monografía.

59
BIBLIOGRAFÍA
Acosta Buitrago María Isabel, Z. M. (2000). Tutorial sobre Redes Neuronales Artificiales
aplicadas en ingeniería. Pereira: Universidad Tecnológica de Pereira.
Catarjet, L. T.–A. (1902). Tratado de anatomía humana. Francia: Salvat Editores S.A.
Duch, A. (2007). Análisis de Algoritmos. Barcelona.
jvalvarez. (s.f.). Universidad de Valladolid. Obtenido de
https://www2.infor.uva.es/~jvalvarez/docencia/tema5.pdf
Machadines. (2020). Sección: Ciencias Naturales. Obtenido de
https://www.machadin.es/imagen/12700
Martinez, H. J. (1995). Redes Neuronales, aplicaciones. Addison Wesley.
Wikipedia. (03 de 23 de 2021). Análisis de algoritmos. Obtenido de
https://es.wikipedia.org/wiki/An%C3%A1lisis_de_algoritmos

60
ANEXO A
Recolección de Datos para el Mundo 1 y Mundo 2 en forma detallada.
Patrones del mundo 1:
Patrón 1.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 -1 -1 -1 -1 -1
Patrón 2.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
1 -1 -1 -1 -1 1
Patrón 3.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 -1 1 -1 1 1
Patrón 4.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
1 -1 1 -1 -1 1

61
Patrón 5.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 -1 1 1 1 1
Patrón 6.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
1 1 -1 -1 1 -1
Patrón 7.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 1 -1 1 1 1
Patrón 8.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 1 -1 -1 1 1

62
Patrón 9.
S1
S2 S3
S4
S1 S2 S3 S4 M1 M2
-1 1 1 -1 1 1
S1 S2 S3 S4 M1 M2
-1 -1 -1 -1 -1 -1
1 -1 -1 -1 -1 1
-1 -1 1 -1 1 1
1 -1 1 -1 -1 1
-1 -1 1 1 1 1
1 1 -1 -1 1 -1
-1 1 -1 1 1 1
-1 1 -1 -1 1 1
-1 1 1 -1 1 1

Mundo 2: Se siguió la misma lógica que el mundo 1
ANEXO B
Algoritmo de Entrenamiento de la red tipo Perceptrón: Adecuado al proyecto
1. Se asigna valores aleatorios a los pesos 𝑤𝑖 y a la ganancia 𝑏.
2. Se le presenta a la red el primer patrón de entrada aún no considerado, junto con el valor
esperado de salida.
3. Se calcula la salida neta de la red.
𝑛 = (∑ 𝑤𝑖𝑠𝑖 + 𝑏
𝑖
)
S1 S2 S3 S4 M1 M2
-1 -1 -1 -1 1 1
1 -1 -1 -1 1 -1
-1 1 1 -1 1 1
-1 1 -1 -1 1 1
1 1 -1 -1 1 -1
-1 1 -1 1 1 1
1 -1 1 -1 -1 1
-1 -1 1 1 1 1
1 1 1 -1 1 -1
-1 -1 1 -1 1 1
1 1 -1 1 1 -1
-1 1 1 1 1 1

4. Se aplica la función de transferencia a la salida neta n. el cual puede ser escalón (hardlim)
o hardlims.
𝑀 = 𝑓(𝑛) = 𝑒𝑠𝑐𝑎𝑙𝑜𝑛(𝑛)
5. Se calcula el error correspondiente, que va a ser la diferencia entre la salida
proporcionada por la red M y la salida esperada t.
𝑒 = 𝑡 − 𝑀
6. Si el error es distinto de O, entonces debemos modificar los pesos y el valor de la
ganancia.
𝑤𝑛𝑢𝑒𝑣𝑜
= 𝑤𝑎𝑛𝑡𝑒𝑟𝑖𝑜𝑟
+ 𝑒𝑠
Y
𝑏𝑛𝑢𝑒𝑣𝑜
= 𝑏𝑎𝑛𝑡𝑒𝑟𝑖𝑜𝑟
+ 𝑒
7. Se vuelve al paso 2, hasta que los errores para cada patrón de entrada sean iguales a O.
Nota: El entrenamiento de las neuronas se lo realiza de forma individual, una
independientemente de la otra, es decir cada neurona tendrá que seguir el algoritmo de forma
separada.
ANEXO C
Código Fuente Clase Perceptrón: Desarrollado con el lenguaje de programación C# 4.0 y
visual estudio 2017
using System;
using System.Collections.Generic;
using System.Text;
namespace RNA_2
{
class PercepRobot
{
const int NSEN = 4;
public void robot(int[,] x)
{

x[0, 0] = -1; x[0, 1] = -1; x[0, 2] = -1; x[0, 3] = -1; x[0, 4] = 1; x[0, 5] = 1;
x[1, 0] = 1; x[1, 1] = -1; x[1, 2] = -1; x[1, 3] = -1; x[1, 4] = 1; x[1, 5] = -1;
x[2, 0] = -1; x[2, 1] = 1; x[2, 2] = 1; x[2, 3] = -1; x[2, 4] = 1; x[2, 5] = 1;
x[3, 0] = -1; x[3, 1] = 1; x[3, 2] = -1; x[3, 3] = -1; x[3, 4] = 1; x[3, 5] = 1;
x[4, 0] = 1; x[4, 1] = 1; x[4, 2] = -1; x[4, 3] = -1; x[4, 4] = 1; x[4, 5] = -1;
x[5, 0] = -1; x[5, 1] = 1; x[5, 2] = -1; x[5, 3] = 1; x[5, 4] = 1; x[5, 5] = 1;
x[6, 0] = 1; x[6, 1] = -1; x[6, 2] = 1; x[6, 3] = -1; x[6, 4] = -1; x[6, 5] = 1;
x[7, 0] = -1; x[7, 1] = -1; x[7, 2] = 1; x[7, 3] = 1; x[7, 4] = 1; x[7, 5] = 1;
x[8, 0] = 1; x[8, 1] = 1; x[8, 2] = 1; x[8, 3] = -1; x[8, 4] = 1; x[8, 5] = -1;
x[9, 0] = -1; x[9, 1] = -1; x[9, 2] = 1; x[9, 3] = -1; x[9, 4] = 1; x[9, 5] = 1;
x[10, 0] = 1; x[10, 1] = 1; x[10, 2] =-1; x[10, 3] = 1; x[10, 4] = 1; x[10, 5] =-1;
x[11, 0] =-1; x[11, 1] = 1; x[11, 2] = 1; x[11, 3] = 1; x[11, 4] = 1; x[11, 5] = 1;
}
public int fscalon(double n)
{
int a;
if (n >= 0)
a = 1;
else
a = -1;
return a;
}
public double WP_b(int[,] P, double[,] W, double[] b, int fp, int fw, int fb)
{
double wp = 0;
for (int i = 0; i < NSEN; i++)
{
wp = wp + (W[fw, i] * P[fp, i]);
}
return wp + b[fb];
}
public void newPesos(int[,] P, double[,] W, int error, int fp, int fw)
{
for (int i = 0; i < NSEN; i++)
W[fw, i] = W[fw, i] + (error * P[fp, i]);
}
}
}
//evento que realiza el entrenamiento de la red
private void btnPasoPaso_Click(object sender, EventArgs e)
{
//entrenamiento de la red
//-------------------------------------------------------------------
//para la primera neurona;
a1 = p.WP_b(M, W, B, pat, 0, 0);
y1 = p.fscalon(a1);
e1 = M[pat, 4] - y1; //error para la salida deseada del motor 1
if (e1 != 0)
{
estado1 = 0; //controlamos el aprendizaje de la red
p.newPesos(M, W, e1, pat, 0); //nuevos pesos
B[0] = B[0] + e1; //actualizamos la ganancia 1
}
else
{
estado1++;
if (estado1 >= NPAT) //controlando el aprendizaje de la red

estado1++;
}
//para la segunda neurona;
a2 = p.WP_b(M, W, B, pat, 1, 1);
y2 = p.fscalon(a2);
e2 = M[pat, 5] - y2; //error para la salida del motor 2
if (e2 != 0)
{
estado2 = 0;
p.newPesos(M, W, e2, pat, 1);
B[1] = B[1] + e2; //actualizamos la ganancia 2
}
else
{
estado2++;
if (estado2 >= NPAT)
estado2++;
}
//para verificar si la red ya ha aprendido
if (estado1 >= 16 && estado2 >= 16)
MessageBox.Show("LA RED YA HA APRENDIDO");
//--------------------------------------------------------------------
//asignando valores a la interfaz
//---------------------------------------------------------------------
a1_ent.Text = a1.ToString(); a2_ent.Text = a2.ToString();
y1_ent.Text = y1.ToString(); y2_ent.Text = y2.ToString();
Error_ent_1.Text = e1.ToString(); Error_ent_2.Text = e2.ToString();
Pat1.Text = M[pat, 0].ToString(); Pat2.Text = M[pat, 1].ToString(); Pat3.Text =
M[pat, 2].ToString(); Pat4.Text = M[pat, 3].ToString();
b1_ent.Text = B[0].ToString(); b2_ent.Text = B[1].ToString();
w11_ent.Text = W[0, 0].ToString(); w12_ent.Text = W[0, 1].ToString(); w13_ent.Text
= W[0, 2].ToString(); w14_ent.Text = W[0, 3].ToString();
w21_ent.Text = W[1, 0].ToString(); w22_ent.Text = W[1, 1].ToString();
w23_ent.Text = W[1, 2].ToString(); w24_ent.Text = W[1, 3].ToString();
//---------------------------------------------------------------------
pat = pat + 1;
if (pat >= NPAT)
pat = 0;
}

APLICACIÓN DE REDES NEURONALES ARTIFICIALES PARA LA DETECCION DE OBSTÁCULOS POR MEDIO DE UN ROBOT

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie APLICACIÓN DE REDES NEURONALES ARTIFICIALES PARA LA DETECCION DE OBSTÁCULOS POR MEDIO DE UN ROBOT

Ähnlich wie APLICACIÓN DE REDES NEURONALES ARTIFICIALES PARA LA DETECCION DE OBSTÁCULOS POR MEDIO DE UN ROBOT (20)

Mehr von Saul Mamani

Mehr von Saul Mamani (16)

Kürzlich hochgeladen

Kürzlich hochgeladen (10)

APLICACIÓN DE REDES NEURONALES ARTIFICIALES PARA LA DETECCION DE OBSTÁCULOS POR MEDIO DE UN ROBOT