Proyecto de Redes Neuronales

Redes Neuronales Artificiales
Presentación Final: Reporte y Programa

Este es el reporte final para la materia de Redes Neuronales Artificiales, en la cual estuve trabajando en el proyecto de Reconocimiento de Personas Mediante Voz, en conjunto con mis compañeros Cecilia Urbina y Roberto Martínez.

El objetivo del proyecto fue crear un sistema funcional que permita identificar si un usuario es el correcto o no, mediante su voz. Esto dentro de un sistema que muestre una ventana y que de un texto que tendrá que ser leído por la persona que intenta autentificarse, el audio es captado y analizado, y crea una entrada de datos a la red neuronal la cual se encargara de decir en su salida si el usuario fue identificado o no, y mostrar el resultado finalmente mediante una ventana.

Trabajo grupal

En la siguiente captura se muestran los commits realizados en Octubre y Noviembre desde una semana después de haber presentado el examen de medio curso, y con esto podemos crear evidencia del trabajo realizado.

Historial de Commits | Secuencia de Commits

Estuvimos haciendo cambios en el código que ya teníamos hasta la mitad del curso, de ahí en adelante fueron cambios que tuvieron que ver con la separación del código en clases.

Entre las clases que creamos están la de la Neurona y la de la Red, en las cuales se definen la cantidad de neuronas a utilizar y donde se hace el proceso de generación del vector de pesos, así como el aprendizaje de la Neurona.

Entre los cambios que podemos resaltar, y que se puede evidenciar mediante los últimos commits tenemos:

• Separación del código en clases
• Análisis con PCA
• Creación de la clase interfaz
• Aprendizaje con dos neuronas
• Generación de un vector de pesos bueno
• Reconocimiento funcional

Código

El código completo y las partes en las que yo contribuí están en el repositorio, enseguida se encuentra la liga directa.

Liga al Repositorio

El siguiente es el código de la clase Neurona, donde estuve haciendo algunas modificaciones para que fuera útil para el programa que inicia el aprendizaje y el programa que verifica los usuarios que necesita recibir la salida generada por la neurona.

	#!/usr/bin/python
	# ITS - FIME - UANL
	# Proyecto de Redes Neuronales Artificiales:
	# > Identificar Personas Mediante Voz
	#
	# Integrantes:
	# > Ramon Esteban Gonzalez Barrera
	# > Roberto Carlos Martinez Moreno
	# > Sandra Cecilia Urbina Coronado
	import random
	from numpy import zeros, multiply, append
	from Tkinter import Tk, Canvas
	DEBUG = True
	VISUALIZAR = True
	APRENDE = True
	ALTO = 1
	BAJO = -1
	ACTIVO = 1
	INACTIVO = 0
	CANVAS = 700
	RADIO = 5
	class Neurona:
	def __init__(self, dimension, archivo_pesos):
	"""Crea las variables necesarias para trabajar."""
	self.dimension = dimension + 1
	if (archivo_pesos):
	self.W = self.obtener_pesos(archivo_pesos)
	else:
	self.W = self.generar_pesos()
	self.X = None
	self.t = None
	self.a = 0.01
	self.errores = 0
	def imprime_errores(self):
	print self.errores
	def obtener_pesos(self, archivo_pesos):
	"""Regresa el vector de pesos desde el archivo especificado."""
	if (DEBUG): print 'Se obtienen pesos del archivo:', archivo_pesos
	archivo = open(archivo_pesos, 'r')
	linea = archivo.readline()
	partes = linea.split()
	W = zeros(self.dimension)
	for i in range(self.dimension):
	W[i] = float(partes[i])
	archivo.close()
	return W
	def generar_pesos(self):
	"""Regresa un vector de pesos nuevo."""
	if (DEBUG): print 'Se genera un vector de pesos nuevo'
	W = zeros(self.dimension)
	for i in range(self.dimension):
	W[i] = random.uniform(BAJO, ALTO)
	return W
	def aprender(self, y):
	"""Modifica el vector de pesos 'W' con la regla de aprendizaje."""
	Wprima = zeros(self.dimension)
	for i in range(self.dimension):
	Wprima[i] = self.W[i] + (self.a * (self.t - y) * self.X[i])
	self.W = Wprima
	if (DEBUG): print 'Vector de pesos nuevo:', self.W
	def iniciar(self, vector_entradas, salida_esperada, ventana, linea_dibujar, col1, col2, salida_pesos):
	"""Regresa 'True' cuando fue necesaria la regla de aprendizaje."""
	self.X = vector_entradas
	self.t = salida_esperada
	multiplica_vectores = multiply(self.X, self.W)
	activacion = multiplica_vectores.sum()
	if (DEBUG): print 'Vector de entrada:', self.X
	if (DEBUG): print 'Vector de pesos usado:', self.W
	if (DEBUG): print 'Salida esperada:', self.t
	if (VISUALIZAR):
	px = (float(self.X[0])) * CANVAS
	py = (1 - (float(self.X[1]))) * CANVAS
	error = False
	if activacion >= 0:
	y = ACTIVO
	if (DEBUG): print 'Salida generada:', y
	if (VISUALIZAR): i = ventana.create_oval(px-RADIO, py-RADIO, px+RADIO, py+RADIO, fill=col1)
	if self.t != y:
	error = True
	if (VISUALIZAR): ventana.itemconfig(i, fill=col2, outline='green')
	if (APRENDE): self.aprender(y)
	else:
	y = INACTIVO
	if (DEBUG): print 'Salida generada:', y
	if (VISUALIZAR): i = ventana.create_oval(px-RADIO, py-RADIO, px+RADIO, py+RADIO, fill=col2)
	if self.t != y:
	error = True
	if (VISUALIZAR): ventana.itemconfig(i, fill=col1, outline='green')
	if (APRENDE): self.aprender(y)
	if error == True:
	self.errores += 1
	if (DEBUG): print '--------------------'
	if (VISUALIZAR and APRENDE):
	y1_linea = (1-(-(self.W[0] /self.W[1]) * 0 + (self.W[2] / self.W[1]))) * CANVAS
	y2_linea = (1-(-(self.W[0] /self.W[1]) * 1 + (self.W[2] / self.W[1]))) * CANVAS
	ventana.coords(linea_dibujar, 0, y1_linea, CANVAS, y2_linea)
	ventana.update()
	if (APRENDE):
	mejorados = open(salida_pesos, 'w')
	for i in range(self.dimension):
	mejorados.write('%f ' % self.W[i])
	mejorados.close()
	return y

view raw neurona.py hosted with ❤ by GitHub

Vídeo demostración

El siguiente vídeo muestra el funcionamiento de dos neuronas que separan cuatro clases, con datos generados con una versión más reciente el programa generador de vectores de entrada.

Presentación en equipo

Integrantes del equipo:

• Cecilia Urbina
• Ramón González
• Roberto Martínez