Trabajo Final de Semestre

Trabajo Final
INGENÍERIA DE SISTEMAS
Universidad Cooperativa de
Colombia
Red Neuronal Artificial en Python
Felipe Merchán Díaz

Julián David Mayoral Azuero
Profesor: HERNAN AVILA PUENTES
Bogotá D.C, 2020-2

Objetivos
Crearemos una red neuronal artificial en Python con Keras y Tensorflow para comprender su uso.
Implementaremos la compuerta XOR e intentaré comparar las ventajas del aprendizaje
automático frente a la programación tradicional.
Crear una red neuronal que nos dará los pasos para las conexiones que utilizaremos en un coche
robot
Requerimientos necesarios:
- Un ambiente de desarrollo Python.

- Manejo de compuertas XOR.
- Saber que es una red neuronal.
- Manejo y aprendizaje de Keras.
- Anaconda
Red neuronal artificial
Las redes neuronales artificiales (también conocidas como sistemas conexionistas) son un
modelo computacional vagamente inspirado en el comportamiento observado en su
homólogo biológico1. Consiste en un conjunto de unidades, llamadas neuronas artificiales,
conectadas entre sí para transmitirse señales. La información de entrada atraviesa la red
neuronal (donde se somete a diversas operaciones) produciendo unos valores de salida.
Una red neuronal artificial es un grupo interconectado de nodos similar a la vasta red de
neuronas en un cerebro biológico. Cada nodo circular representa una neurona artificial y
cada flecha representa una conexión desde la salida de una neurona a la entrada de otra.
¿Cómo funcionan las redes neuronales?
Como se ha mencionado el funcionamiento de las redes se asemeja al del cerebro

humano. Las redes reciben una serie de valores de entrada y cada una de estas entradas
llega a un nodo llamado neurona. Las neuronas de la red están a su vez agrupadas en
capas que forman la red neuronal. Cada una de las neuronas de la red posee a su vez un
peso, un valor numérico, con el que modifica la entrada recibida. Los nuevos valores
obtenidos salen de las neuronas y continúan su camino por la red. Este funcionamiento
puede observarse de forma esquemática en la siguiente imagen.
Puerta XOR
La puerta XOR, compuerta XOR u OR exclusiva es una puerta lógica digital que implementa
el o exclusivo; es decir, una salida verdadera (1/HIGH) resulta si una, y solo una de las
entradas a la puerta es verdadera. Si ambas entradas son falsas (0/LOW) o ambas son
verdaderas, resulta en una salida falsa. La XOR representa la función de la desigualdad, es
decir, la salida es verdadera si las entradas no son iguales, de otro modo el resultado es
falso. Una manera de recordar XOR es "uno o el otro, pero no ambos".
Símbolo
FUNCIÓN BOOLEANA
La ecuación característica que describe el comportamiento de la puerta XOR es:
Python
es un lenguaje de programación interpretado cuya filosofía hace hincapié en la legibilidad

de su código.2 Se trata de un lenguaje de programación multiparadigma, ya que soporta
orientación a objetos, programación imperativa y, en menor medida, programación
funcional. Es un lenguaje interpretado, dinámico y multiplataforma.
Keras
es una biblioteca de Redes Neuronales de Código Abierto escrita en Python. Es capaz de

ejecutarse sobre TensorFlow, Microsoft Cognitive Toolkit o Theano.1
Está especialmente diseñada para posibilitar la experimentación en más o menos poco
tiempo con redes de Aprendizaje Profundo. Sus fuertes se centran en ser amigable para el
usuario, modular y extensible.
Inicialmente fue desarrollada como parte de los esfuerzos de investigación del proyecto
ONEIROS (Open-ended Neuro-Electronic Intelligent Robot Operating System).
Además del soporte para las redes neuronales estándar, Keras ofrece soporte para las
Redes Neuronales Convolucionales y para las Redes Neuronales Recurrentes.
Anaconda
Anaconda es una distribución libre y abierta1 de los lenguajes Python y R, utilizada en
ciencia de datos, y aprendizaje automático (machine learning). Esto incluye procesamiento
de grandes volúmenes de información, análisis predictivo y cómputos científicos. Está
orientado a simplificar el despliegue y administración de los paquetes de software.2
Las diferentes versiones de los paquetes se administran mediante el sistema de gestión de

paquetes conda, el cual lo hace bastante sencillo de instalar, correr, y actualizar software
de ciencia de datos y aprendizaje automático como ser Scikit-team, TensorFlow y SciPy.3
La distribución Anaconda es utilizada por 6 millones de usuarios e incluye más de 250

paquetes de ciencia de datos válidos para Windows, Linux y MacOS.
Pasos
Crearemos una red neuronal simple, con 3 capas, neuronas con valores de entrada/salida -1 a
1
Primero importamos las clases que utilizaremos:
import numpy as np
def sigmoid(x):
return 1.0/(1.0 + np.exp(-x))
def sigmoid_derivada(x):
return sigmoid(x)*(1.0-sigmoid(x))
def tanh(x):
return np.tanh(x)
def tanh_derivada(x):
return 1.0 - x**2
class NeuralNetwork:
def __init__(self, layers, activation='tanh'):

if activation == 'sigmoid':
self.activation = sigmoid
self.activation_prime = sigmoid_derivada
elif activation == 'tanh':
self.activation = tanh
self.activation_prime = tanh_derivada
inicializo los pasos:

self.weights = []
self.deltas = []
las capas = [2,3,2] entre los rangos de pasos varia entre (-1,1) asignamos valores aleatorios
a capa de entrada:
for i in range(1, len(layers) - 1):
r = 2*np.random.random((layers[i-1] + 1, layers[i] + 1)) -1
self.weights.append(r)
asignamos aleatorios a capa de salida:
r = 2*np.random.random( (layers[i] + 1, layers[i+1])) - 1

self.weights.append(r)
def fit(self, X, y, learning_rate=0.2, epochs=100000):
agregamos columna de una a las entradas x con esto agregamos la unidad de bias a la
capa de entrada:
ones = np.atleast_2d(np.ones(X.shape[0]))
X = np.concatenate((ones.T, X), axis=1)
for k in range(epochs):
i = np.random.randint(X.shape[0])
a = [X[i]]
for l in range(len(self.weights)):
dot_value = np.dot(a[l], self.weights[l])
activation = self.activation(dot_value)
a.append(activation)
calculamos la diferencia en la capa de salida y el valor que obtenemos:

error = y[i] - a[-1]
deltas = [error * self.activation_prime(a[-1])]
empezamos en el segundo layer hasta el último (una capa anterior a la salida):

for l in range(len(a) - 2, 0, -1):
deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_prime(a[l]))
self.deltas.append(deltas)
invertimos [level3(output)- >level2(hidden)] => [level2(hidden)- >level3(output)]
deltas.reverse()
backpropagation (método de cálculo del gradiente utilizado en algoritmos de aprendizaje

supervisado utilizados para entrenar redes neuronales artificiales.)
multiplicar los delta de salida con las activaciones de entrada. Para obtener el gradiente
de los pasos. Actualizar los pasos restándole un porcentaje de el gradiente.
for i in range(len(self.weights)):
layer = np.atleast_2d(a[i])
delta = np.atleast_2d(deltas[i])
self.weights[i] += learning_rate * layer.T.dot(delta)
if k % 10000 == 0: print('epochs:', k)
def predict(self, x):

ones = np.atleast_2d(np.ones(x.shape[0]))
a = np.concatenate((np.ones(1).T, np.array(x)), axis=0)
for l in range(0, len(self.weights)):
a = self.activation(np.dot(a, self.weights[l]))
return a
def print_weights(self):
print("LISTADO PESOS DE CONEXIONES")
for i in range(len(self.weights)):
print(self.weights[i])
def get_deltas(self):
return self.deltas
Luego se creó el primer red emulado a la función XOR.

Función XOR
nn = NeuralNetwork([2,2,1])
X = np.array([[0, 0],
[0, 1],
[1, 0],
[1, 1]])
y = np.array([0, 1, 1, 0])
nn.fit(X, y,epochs=2000)
for e in X:
print("Entrdas:",e,"Salidas:",nn.predict(e))
creación de la red neuronal que nos dará los pasos para las conexiones que se puedan
utilizar.
Función del coche para evitar obstáculos.
X = np.array([[0, 0], sin obstáculo
[0, 1], sin obstáculos
[0, -1], sin obstáculos
[0.5, 1], obstáculo detectado a derecha
[0.5, -1], obstáculo a la izquierda
[1,1], demasiado cerca a derecha
[1,-1]]) demasiado cerca a la izquierda
y = np.array([[0,1], avanzar
[0,1], avanzar
[0,1], avanzar
[-1,1], giro a la izquierda
[1,1], giro a la derecha
[0,-1], retroceder
[0,-1]]) retroceder
nn.fit(X, y, learning_rate=0.03,epochs=15001)
index=0
for e in X:
print("X:",e,"y:",y[index],"Network:",nn.predict(e))
index=index+1
nn.print_weights()
Vamos a graficar la función de coste
Aquí evidenciamos como el gradiente desciende y disminuye el error a medida que pasan
las interacciones de aprendizaje.
import matplotlib.pyplot as plt
deltas = nn.get_deltas()
valores=[]
index=0
for arreglo in deltas:
valores.append(arreglo[1][0] + arreglo[1][1])
index=index+1
plt.plot(range(len(valores)), valores, color='b')

plt.ylim([0, 1])
plt.ylabel('Cost')
plt.xlabel('Epochs')
plt.tight_layout()
plt.show()
Bibliografía
https://es.wikipedia.org/wiki/Red_neuronal_artificial
https://www.atriainnovation.com/que-son-las-redes-neuronales-y-sus-funciones/
https://es.wikipedia.org/wiki/Puerta_XOR
https://sites.google.com/site/ovaselectronica/CONTENIDOS/compuerta-XOR
https://uniwebsidad.com/libros/python
https://unipython.com/cursos/curso-python-desde-0/
https://blogs.imf-formacion.com/blog/tecnologia/claves-usar-python-principiantes-
201911/

Trabajo Final de Semestre

Cargado por

Copyright:

Formatos disponibles

Trabajo Final de Semestre

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Trabajo Final de Semestre

Cargado por

Copyright:

Formatos disponibles

Trabajo Final

Red Neuronal Artificial en Python

Felipe Merchán Díaz

Profesor: HERNAN AVILA PUENTES

Bogotá D.C, 2020-2

- Un ambiente de desarrollo Python.

¿Cómo funcionan las redes neuronales?

Como se ha mencionado el funcionamiento de las redes se asemeja al del cerebro

es un lenguaje de programación interpretado cuya filosofía hace hincapié en la legibilidad

es una biblioteca de Redes Neuronales de Código Abierto escrita en Python. Es capaz de

Las diferentes versiones de los paquetes se administran mediante el sistema de gestión de

La distribución Anaconda es utilizada por 6 millones de usuarios e incluye más de 250

def __init__(self, layers, activation='tanh'):

inicializo los pasos:

asignamos aleatorios a capa de salida:

r = 2*np.random.random( (layers[i] + 1, layers[i+1])) - 1

def fit(self, X, y, learning_rate=0.2, epochs=100000):

calculamos la diferencia en la capa de salida y el valor que obtenemos:

empezamos en el segundo layer hasta el último (una capa anterior a la salida):

invertimos [level3(output)- >level2(hidden)] => [level2(hidden)- >level3(output)]

backpropagation (método de cálculo del gradiente utilizado en algoritmos de aprendizaje

def predict(self, x):

Luego se creó el primer red emulado a la función XOR.

import matplotlib.pyplot as plt

plt.plot(range(len(valores)), valores, color='b')

También podría gustarte

def init(self, layers, activation='tanh'):