ESCUELA DE ELECTRONICA Y TELECOMUNICACIONES

IMPLEMENTACIÓN HARDWARE EN UNA FPGA DE UNA

RED NEURONAL ARTIFICIAL PARA EL
RECONOCIMIENTO DE PATRONES DE VOZ ESPECÍFICOS

AUTORA:
Johana Elizabeth Briceño Sarmiento
Tesis previa a la obtención del
Título de Ingeniero en
Electrónica y
Telecomunicaciones

DIRECTOR:
Ing. Carlos Carrión

LOJA – ECUADOR

2008
 CERTIFICACIÓN

Loja, 3 Abril del 2008

Ing. Carlos Enrique Carrión B.
Director Académico del Proyecto
Unidad de Proyectos y Sistemas Informáticos

Dejo constancia de haber revisado y estar de acuerdo con el proyecto de fin de

carrera, titulado “IMPLEMENTACIÓN HARDWARE EN UNA FPGA DE UNA RED
NEURONAL ARTIFICIAL PARA EL RECONOCIMIENTO DE PATRONES DE VOZ
ESPECÍFICOS”.

Presentado por la señorita Johana Elizabeth Briceño Sarmiento.

Particular que comunico para fines legales pertinentes.

-----------------------------------
Ing. Carlos Carrión B.
DIRECTOR TESIS

Visto Bueno Dirección Escuela

F).....................................
Ing. Jorge Luis Jaramillo

Fecha: 3 Abril del 2008

 CESIÓN DE DERECHOS

Yo, Johana Elizabeth Briceño Sarmiento, declaro conocer y aceptar la disposición

del Art. 67 del Estatuto Orgánico de la Universidad Técnica Particular de Loja que
en su parte pertinente textualmente dice: “Forman parte del patrimonio de la
Universidad la propiedad intelectual de investigaciones, trabajos científicos o
técnicos y tesis de grado que se realicen a través, o con el apoyo financiero,
académico o institucional (operativo) de la Universidad.

F……………………
Johana Elizabeth Briceño Sarmiento
 DECLARACIÓN DE AUTORÍA

Los conceptos, interpretaciones e ideas en el presente proyecto son plasmados

bajo responsabilidad exclusiva de la autora.

Autora

F: ……………………………………
Johana Elizabeth Briceño Sarmiento
 INTRODUCCIÓN

En la mayoría de los sistemas computacionales se tiene la capacidad de

procesamiento de operaciones complejas, que normalmente el cerebro humano no
las realiza fácilmente, pero sabemos que estos sistemas no poseen nociones de
pensamiento ni toma de decisiones, y que hasta hace poco era algo prácticamente
imposible que las maquinas lo pudieran lograr, pero actualmente con el desarrollo
de redes neuronales artificiales se los trata de asemejar al comportamiento del
cerebro humano logrando desarrollar aplicaciones como reconocimiento de
imágenes, reconocimiento del habla y caracteres, control de robots, etc.

Debido al futuro prometedor de esta rama, se decidió involucrarse en el desarrollo

de redes neuronales artificiales (RNA) utilizando herramientas de diseño de
sistemas digitales como lo son MATLAB 7.1, System Generator 8.1, y Xilinx 8.1i
que luego nos permitirán implementarlas en hardware, utilizando dispositivos
reprogramables como lo son las FPGAs (Field Programmable Gate Array) de Xilinx;
que ofrecen una gran capacidad de procesamiento paralelo y manejo de datos en
tiempo real, que son características intrínsecas de las RNA. Para este propósito
contamos con dos tarjetas como lo son la FPGA Virtex II Pro y la Spartan III que su
utilización dependerá del tipo de aplicación y cantidad de recursos necesarios.

Inicialmente, se describirá brevemente, la historia, importancia y razones de

desarrollar RNA en hardware así como también las razones que determinan que las
FPGAs son la mejor opción para su implementación. Luego nos introduciremos en
el desarrollo de las diferentes funciones de transferencia a utilizarse en las RNA,
para después desarrollar la unidad neuronal que es la base para determinar redes
neuronales de mayor tamaño y complejidad.

Se determinó primeramente validar el funcionamiento de la neurona, desarrollando

un sistema reconocedor de dígitos del 0 al 9 de un display de 7 segmentos,
utilizando una RNA de una sola capa, verificando así el correcto funcionamiento de
la implementación, en una FPGA Spartan III, comprobando que es capaz de
reconocer todos los dígitos aunque estos ingresen incompletos a la red.

Después se procederá a diseñar el sistema reconocedor de comandos de voz

específicos; de ahí que, el proceso en sí consiste primeramente en realizar un
procesamiento de la señal de voz que comienza con la adquisición de la señal,
tratamiento y extracción de un número determinado de patrones característicos,
que servirán como entradas de la red, que será tipo perceptrón multicapa, para
luego realizar el entrenamiento de la red por medio del algoritmo backpropagation
con momentum para que reconozca dos palabras específicas, hasta obtener un
margen de error deseado; como resultado se obtiene una red neuronal capaz de
reconocer tanto los patrones con los que fue entrenada, como con nuevos patrones
presentados.
 OBJETIVO GENERAL Y OBJETIVOS ESPECÍFICOS

Objetivo General

Se pretende como objetivo general de grupo, ser pioneros en la implementación

hardware de sistemas RNA, permitiendo de esta manera abrir el nodo para las
investigaciones más elaboradas en el procesamiento digital de señales con técnicas
avanzadas, en el país y región. Permitiendo de esta manera crear una línea de
investigación, donde el principal aporte es pasar del concepto al sistema físico, el
cual permite abrir la posibilidad de obtener nuestras propias soluciones a problemas
propios y locales.

Objetivos Específicos

Desarrollar e implementar los principales componentes que conforman una red

neuronal artificial y utilizarlos en aplicaciones específicas de reconocimiento de
patrones.

Procesar la señal de voz para obtener un vector de observación formado por las
características principales de la señal.

Diseñar de un sistema de reconocimiento de voz, usando los sistemas FPGA y
recursos disponibles.

Simulación en software del sistema de reconocimiento de voz, utilizando, System
Generator 8.1, ISE 8.1i y MATLAB 7.1.

Desarrollo del algoritmo de backpropagation en System Generator, para la etapa
de entrenamiento de dos palabras especificas.
 DEDICATORIA

A mis padres:

Arturo Briceño y María Sarmiento

A mis hermanas:

Verónica, Talía y Tamara

 AGRADECIMIENTOS

Agradezco primeramente a Dios, que ha sido mi pilar fundamental, mi apoyo y mi

guía.

A mis padres por su amor, apoyo, confianza, esfuerzo, por enseñarme con su
ejemplo los más grandes valores y luchar por mis ideales; a mis hermanas por su
compañía y confianza.

A Christian, quien es parte importante de mi vida, por su comprensión, cariño y

confianza.

Al Ing. Carlos Carrión, director de tesis, y a los docentes de la Escuela de

Electrónica y Telecomunicaciones, por la formación recibida en los 5 años de
formación profesional.
 CONTENIDO

Declaración de Cesión de Derechos ........................................................................... I

Declaración de Autoría del Tema de Tesis ............................................................... II

Introducción ............................................................................................................... III

Objetivo General y Objetivos Específicos ................................................................ V

Dedicatoria................................................................................................................. VI

Agradecimientos ...................................................................................................... VII

Contenidos .............................................................................................................. VIII

Lista de Figuras .......................................................................................................... X

Lista de Tablas ........................................................................................................ XIII

Capítulo I: Aspectos Generales.................................................................................. 1

1.1 Introducción............................................................................................................. 1
1.2 Historia .................................................................................................................... 2
1.3 Paralelismo en Redes Neuronales .......................................................................... 2
1.4 Aritmética ................................................................................................................ 3

Capítulo II: Implementación de Redes Neuronales Artificiales ............................... 6

2.1 Introducción............................................................................................................. 6
2.2 Elementos de una Neurona Artificial........................................................................ 6
2.3 Funciones de Transferencia .................................................................................... 7
2.3.1 Función Hardlim .................................................................................................. 7
2.3.2 Función Hardlims ................................................................................................. 9
2.3.3 Función Sigmoidal ............................................................................................. 11
2.4 Unidad Neuronal ................................................................................................... 14
2.5 Red Neuronal para el Reconocimiento de dígitos de un Display de Siete
Segmentos .................................................................................................................. 15

Capítulo III: Reconocimiento de la Voz ................................................................... 23

3.1 Problemática ......................................................................................................... 23

3.2 Metodología .......................................................................................................... 23
3.3 Razones por la que las RNA son la Mejor Solución ............................................... 24

Capítulo IV: Diseño Sistema de Reconocimiento de Patrones de Voz .................. 26

4.1 Metodología .......................................................................................................... 26

4.2 Adquisición y Tratamiento de Muestras ................................................................ 26
4.2.1 Adquisición ......................................................................................................... 26
4.2.2 Tratamiento ........................................................................................................ 27
4.3 Extracción de Características de la Señal de Voz ................................................ 28
4.4 Arquitectura y Entrenamiento de la Red Neuronal Artificial ................................... 28
4.4.1 Arquitectura de la Red ........................................................................................ 29
4.4.2 Entrenamiento .................................................................................................... 30

Capítulo V: Implementación del Sistema de Reconocimiento de Voz .................. 34

5.1 Introducción........................................................................................................... 34
5.2 Obtención y Tratamiento de la Señal de Voz ....................................................... 34
5.2.1 Obtención de la Señal de Voz ............................................................................ 35
5.2.2 Obtención Señal Útil .......................................................................................... 36
5.3 Obtención Parámetros Característicos .................................................................. 37
5.4 RNA Propuesta para el Reconocedor de Patrones de Voz ................................... 39

Capítulo VI: Resultados ........................................................................................... 44

6.1 Recursos Obtenidos de la función Hardlim ............................................................ 44

6.2 Recursos y Resultados Obtenidos de la función sigmoid ..................................... 45
6.2.1 Funció Sigmoid ROM ........................................................................................ 45
6.2.2 Función Sigmoid Definida a Trozos ................................................................... 47
6.3 Simulación e Implementación Reconocedor de Dígitos 7 Segmentos ................... 52
6.3.1 Simulación ......................................................................................................... 52
6.3.2 Implementación .................................................................................................. 54
6.4 Resultados Extracción Parámetros Característicos .............................................. 58
6.5 Resultados Algoritmo Backpropagation ................................................................. 64

Capítulo VII: Conclusiones y Recomendaciones .................................................... 69

7.1 Conclusiones ......................................................................................................... 69

7.2 Recomendaciones ................................................................................................ 72

Referencias ................................................................................................................ 73
Anexos ....................................................................................................................... 74
 LISTA DE FIGURAS

Figura 1.1 Representación de Datos Punto Fijo Binaria Complemento a Dos ............... 4

Figura 2.2 Neurona ....................................................................................................... 7

Figura 2.3 Función Hardlim ........................................................................................... 7

Figura 2.4 Función Hardlim con M-Code ....................................................................... 8

Figura 2.5 Función Hardlim ........................................................................................... 9

Figura 2.6 Función Hardlims ......................................................................................... 9

Figura 2.7 Función Fardlims en System Generator ..................................................... 10

Figura 2.8 Resource Estimator F.Hardlims .................................................................. 10

Figura 2.9 Función Sigmoidal ...................................................................................... 11

Figura 2.10 Función Sigmoidal ROM en System Generator ........................................ 12

Figura 2.11 Configuración de la ROM ......................................................................... 12

Figura 2.12 Bloque Función Sigmoid por Función Definida a Trozos .......................... 13

Figura 2.13 Neurona Desarrollada en Sysgen ............................................................. 14

Figura 2.14 Esquema Completo de la Neurona en Sysgen ......................................... 14

Figura 2.15 Neurona de 4 Entradas y Función Hardlim ............................................... 15

Figura 2.16 RNA de 7 Entradas y 4 Neuronas............................................................ 16

Figura 2.17 Utilización Herramienta nntool de MATLAB para Cálculo de Pesos y

Bias ............................................................................................................................. 18

Figura 2.18 Error en Función del Número Épocas de Entrenamiento .......................... 19

Figura 2.19 Almacenamiento de Pesos ....................................................................... 20

Figura 2.20 Codificador BCD a 7 Segmentos .............................................................. 20

Figura 2.21 Controlador Display .................................................................................. 21

Figura 2.22 Lógica de Control Salidas RNA ................................................................ 21

Figura 2.23 Divisor de Frecuencia ............................................................................... 21

Figura 2.24 Sistema de Reconocimiento de Dígitos de 7 Segmentos ......................... 22

Figura 4.25 Procesos del Sistema ............................................................................... 26

Figura 4.26 Filtro de Primer Orden .............................................................................. 27

Figura 4.27 Arquitectura de la Red Elegida para el Sistema de Reconocimiento de

Voz .............................................................................................................................. 29

Figura 4.28 Espacio de generalización, A) para una velocidad de aprendizaje baja;

B) para una velocidad de aprendizaje alta, se pueden observar las oscilaciones; C)
para una velocidad de aprendizaje alta pero adicionándole termino de momento ....... 33

Figura 5.29 Interfaz GUI para Obtención de Señal de Voz .......................................... 35

Figura 5.30 Interfaz GUI para Extracción de Características LPC y FFT ..................... 38

Figura 5.31 RNA Propuesta para el Reconocimiento de Patrones de Voz .................. 40

Figura 5.32 Neuronas Capa Oculta y Capa de Salida ................................................. 41

Figura 5.33 Actualización Pesos Capa de Salida y Obtención de Fracción de Error

a Propagarse en la Capa Oculta ................................................................................. 42

Figura 5.34 Determinación en Cada Unidad de la Capa Oculta................................... 42

Figura 5.35 Actualización de los Pesos de la Capa Oculta .......................................... 43

Figura 5.36 RNA 3 Capas con Algoritmo Backpropagation ......................................... 43

Figura 6.37 Recursos Estimados F. Hardlim 1 ............................................................ 44

Figura 6.38 Recursos Estimados F. Hardlim 2 ............................................................ 44

Figura 6.39 Comparación de resultados bloque Sigmoid_ROM con Simulink ............. 45

Figura 6.40 Resultados Sigmoid_ROM vs Logsig ....................................................... 46

Figura 6.41 Recursos Estimados de Hardware para el Bloque Sigmoid_ROM ............ 47

Figura 6.42 Bloque F_sig por Función Definida a Trozos ............................................ 48

Figura 6.43 Resultado F_Sig vs Logsig ....................................................................... 49

Figura 6.44 Recursos Estimados de Hardware para el Bloque F_Sig ......................... 49

Figura 6.45 Comparación de resultados bloques Sig_ROM, F_Sig y Logsig ............... 50

Figura 6.46 Interfaz Gráfica de Usuario para Ingreso de Datos a la RNA .................... 53

Figura 6.47 Simulación del Sistema de Reconocimiento ............................................. 54

Figura 6.48 Co-Simulación del Sistema Reconocedor de Dígitos ................................ 56

Figura 6.49 Resultado en FPGA Spartan III para los Números 3 y 5 ........................... 56

Figura 6.50 Resultado para Ingreso de Dígitos Parcialmente Incompletos .................. 57

Figura 6.51 Resultado para Ingreso de Dígitos con Error ............................................ 57

Figura 6.52 Recursos Estimados de Hardware para el Sistema de Reconocimiento

de Dígitos .................................................................................................................... 58

Figura 6.53 Patrones Característicos FFT para la Palabra Luces................................ 59

Figura 6.54 Patrones Característicos FFT para la Palabra Aire ................................... 60

Figura 6.55 Patrones Característicos LPC para la Palabra Luces ............................... 61

Figura 6.56 Patrones Característicos LPC para la Palabra Aire .................................. 62

Figura 6.57 Patrones LPC para las Palabras Luces y Aire .......................................... 63

Figura 6.58 Patrones FFT para las Palabras Luces y Aire........................................... 64

Figura 6.59 Salida Deseada y Disminución del Error para = 0.8, =0.5 ................... 65

Figura 6.60 Salida de las Neuronas de Salida para = 0.8, =0.5 .............................. 65

Figura 6.61 Salida de la RNA con Backpropagation .................................................... 66

Figura 6.62 Salida Deseada y disminución del Error para = 1, =0.3 ....................... 67

Figura 6.63 Variación de los pesos Capa Oculta hasta Adaptarse .............................. 67
 LISTA DE TABLAS

Tabla 6.1 Resultado Resourse Estimator Función Hardlim 1 y 2 ................................ 45

Tabla 6.2 Resultado bloque Sigmoid_ROM y Logsig de Simulink .............................. 46

Tabla 6.3 Resultado bloque F_Sig y Logsig de Simulink ............................................ 48

Tabla 6.4 Comparación recursos de hardware función sigmoid ................................. 52

Tabla 6.5 Representación de dígitos en código BCD y siete segmentos .................... 54

Tabla 6.6 Resultado de la Simulación ........................................................................ 54

 CAPITULO I

ASPECTOS GENERALES

1.1 Introducción

La teoría y diseño de las redes neuronales artificiales han avanzado

significativamente durante los últimos 20 años [1]. Las redes neuronales artificiales
durante este periodo han desarrollado una gran importancia sobre todo en el
reconocimiento de patrones, razón por la que se las utilizará en la presente tesis.

En este sentido, se intenta aportar al tema de implementación en Hardware de

Redes Neuronales, ya que es relevante el desarrollarlas, debido a que poseen
muchas características que sobrepasan los sistemas computacionales clásicos,
teniéndose así características como:

Robustez y tolerancia a fallas.

Flexible y tienen capacidad de aprendizaje.

Manejan información difusa.

Paralelo, pequeño y compacto.

Una Red Neuronal Artificial (RNA) es un modelo de procesamiento de información

inspirado en el funcionamiento del sistema nervioso biológico, y de cómo el cerebro
procesa la información. Se compone de un gran número de elementos
interconectados llamados neuronas que trabajan en conjunto para resolver
problemas específicos.

La naturaleza no lineal de las redes neuronales, la habilidad de aprender tanto en

ambientes supervisados como no supervisados, así como la propiedad de
aproximación universal ha hecho a las redes neuronales un método satisfactorio
para resolver una gran variedad de problemas, como es el problema planteado para
esta tesis basado en el reconocimiento de patrones [1].
1.2 Historia

En los años 1980s y 1990s, se invirtió mucho esfuerzo tanto industrial como
académico en el diseño e implementación de neuroprocesadores1 en hardware,
pero la mayoría terminaron en fracasos, de hecho, el campo entero estaba
principalmente moribundo a fines de los años noventa.

La falta de éxito se le atribuyó al hecho de que el trabajo se baso, en su mayoría,

tempranamente sobre la tecnología ASIC, que no se desarrolló suficientemente o
competitivamente para justificar la adopción de esta gran potencia, puesto que los
arreglos de compuertas no fueron lo suficientemente grandes ni lo suficientemente
rápidos para desarrollar aplicaciones de redes neuronales complejas [2].
Por otro lado, la gran capacidad y desempeño de las FPGAs actuales son tales que
presentan una alternativa más realista para el desarrollo de aplicaciones basadas
en redes neuronales.

Hay mucho que ganar de la implementación de RNA en hardware, especialmente si

se aprovecha del paralelismo inherente, pero sin costos indebidos.

1.3 Paralelismo en Redes Neuronales [2]

Las redes neuronales presenta varios tipos de paralelismo, y un estudio cuidadoso

se requiere para determinar la estructura de hardware más conveniente así como la
mejor asignación de estructuras de redes neuronales hacia las estructuras de
hardware dadas. En general salvo las redes de un tamaño trivial, la implementación
full paralela en hardware es no factible un paralelismo virtual es necesario, y esto,
implica algún proceso secuencial.

Los tipos específicos de paralelismo son como siguen:

Paralelismo de Entrenamiento: Diferentes sesiones de entrenamiento pueden correr

en paralelo. En este nivel el paralelismo es usualmente medio, y puede ser casi
totalmente asignado hacia actuales FPGAs.

1
Neuroprocesadores: Dispositivo con capacidad de cálculo paralelo, diseñado para la implementación
de redes artificiales.
Paralelismo de Capa: En una red multicapa, diferentes capas pueden ser
procesadas en paralelo. El paralelismo en este nivel es típicamente bajo, y por
consiguiente el valor limitado, pero esto puede explotarse a través del pipelining2.

Paralelismo de Nodo: Este nivel, le corresponde a neuronas individuales, este es

quizás el nivel más importante de paralelismo, que totalmente se aprovecha, como
a los niveles más altos. Pero esto no es posible, desde el número de neuronas que
puede ser tan alto como en millones. No obstante, el paralelismo del nodo empareja
muy bien FPGAs, un FPGA típico básicamente consiste de un gran número de
‘células’ que pueden operar en paralelo.

Paralelismo de Pesos: El producto de las entradas y los pesos (XiWi) puede

totalmente ser calculado en paralelo y la suma de estos productos puede también
ser calculados con alto paralelismo.

Paralelismo de nivel de bit: En el nivel de aplicación hay una amplia variedad de

paralelismo está disponible, dependiendo del diseño de las unidades individuales
funcionales. Por ejemplo, serie de bits, paralela sucesiva, palabra paralela, etc.

Tres cosas son evidentes en el contexto de una implementación:

Primero, el paralelismo disponible a los diferentes niveles varia enormemente.

Segundo, los diferentes tipos de paralelismo pueden tratarse hacia otros,
dependiendo del el costo deseado: la razón de desempeño, donde para una FPGA
el costo puede ser medido en términos de número de CLBs, por ejemplo la
velocidad lenta de una sola unidad puede equilibrarse teniendo muchas unidades
operando concurrentemente. Y tercero no todos los tipos de paralelismo son
convenientes para implementaciones en FPGA, por ejemplo las requeridas
interconexiones pueden ser problemáticas, o la explotación del paralelismo a nivel
de bit puede reprimirse por el diseño del dispositivo o simplemente no es apropiado.

2
Pipelining: Es una técnica de implementación en la que se superpone la ejecución de varias
instrucciones y aprovecha el paralelismo entre instrucciones en una corriente secuencial de
instrucciones.
1.4 Aritmética

Hay muchos aspectos del cálculo aritmético que necesitan ser considerados en el
diseño de neuro-elementos; estos aspectos incluyen la representación de datos,
cálculos de productos internos, implementación de funciones de transferencia,
almacenamiento y actualización de pesos, y la naturaleza de algoritmos de
aprendizaje. Las entradas y salidas (In/Out), aunque no son un problema aritmético,
también es importante asegurar que las unidades aritméticas puedan ser
proporcionadas con entradas a la velocidad apropiada. [2]

De estos, los más importantes son el producto interno y las funciones de

transferencia que activan las neuronas. De hecho, esto último es muy importante y
de mucha complejidad, por lo que se debería tener muy en cuenta este punto.

Las funciones de activación, excepto la sigmoid que es compleja; se tiene la

facilidad de implementación de multiplicaciones y sumas, sin tener el suficiente
cuidado; la función de activación sigmoid será un factor limitante en el desempeño.

Representación de Datos: Las representaciones normales de las señales son

generalmente basadas en complemento a dos.

Una representación de una señal punto fijo binaria complemento a dos es [3]:

Figura. 1.1 Representación de datos punto fijo binaria complemento a dos [3]

Donde:
bi es el dígito binario (bits, ceros o unos).
Longitud de la palabra, en bits es dado por w.
El bit más significativo (MSB) es el de mas a la izquierda. Es representado por bw-
1.
El bit menos significativo (LSB) es el bit de más a la derecha. Representado por b0.
La longitud del fragmento, f es la distancia desde el LBS al punto binario.

Según estudios se tiene establecido 16 bits para pesos y 8 bits para la entrada de la
función de activación, como bastante bueno. [2]
Con este conocimiento, el aspecto crítico está entonces cuando, debido a las
consideraciones de desempeño (performance) o costo, debe de usarse la precisión
mas baja, esto basado en un análisis numérico cuidadoso.

Cálculo de sumas de productos: Un problema es el cómo obtener datos de entrada

y salida a la velocidad apropiada. Si la red es suficientemente grande, entonces la
mayoría de las entradas a las unidades aritméticas serán guardadas fuera del
dispositivo, y el número de pins del dispositivo, disponibles para entrada y salida
(In/Out) se vuelve un problema. En este caso, la organización de entradas y salidas
es critica.

7
Almacenamiento y actualización de pesos, entradas/salidas: Para este propósito,
la memoria RAM distribuida es muy pequeña para sostener la mayoría de los datos
a procesarse, por consiguiente se usa el bloque-RAM. Los valores de entrada son
guardados en un solo bloque y simultáneamente leídos fuera (como la RAM dual-
ported).

Para redes muy pequeñas, es más práctico usar RAM-Distribuidas, sobre todo para
almacenar los pesos. Para redes grandes, el bloque RAM no puede ser suficiente, y
los datos tienen que ser cargados periódicamente dentro y recuperados del
dispositivo FPGA.
 Capitulo II

IMPLEMENTACIÓN DE REDES NEURONALES

2.1 Introducción

Antes de desarrollar una Red Neuronal Artificial para una aplicación específica,
como en el caso de esta tesis, se desarrolla detalladamente la implementación de
todos los elementos que son parte de la RNA como es la unidad básica, que es
una neurona tipo perceptron, y las funciones de transferencia más importantes por
ser las más utilizadas, como lo son la hardlim3, hardlims4 y sigmoid5.

Para cada elemento es necesario, una vez desarrollado, comparar los resultados
obtenidos, para determinar su eficacia así como también es necesario determinar
los recursos que utilizarán en hardware para su implementación.

2.2 Elementos de una Neurona Artificial

Una red neuronal se encuentra formada por varias unidades neuronales, celdas,
unidades de procesamiento o neuronas que se interconectan entre si formando una
red. Esta unidad de procesamiento esta formada por:

Figura.2.2 Neurona

- Las entradas Xi, que son los datos o señales que ingresan a la neurona.

3
Hardlim: Función de transferencia lineal que limita la salida entre 0 y 1.
4
Hardlims: Función de transferencia lineal que limita la salida entre -1 y 1.
5
Sigmoid: función de transferencia no lineal que limita la salida entre 0 y 1.
 - Bias b, Entrada de tendencia definida como un número que indica a partir de
que valor del potencial la neurona produce una salida significativa. [7]
- Los pesos Wi, que son la intensidad de la sinapsis que conecta la entrada
con la neurona o entre dos neuronas.
Estos valores se multiplican con su respectiva entrada y si el peso es
positivo la conexión se le llama exitatoria y si es negativo se le llama
inhibidora [8]. Estos valores resultantes de las multiplicaciones son sumados
formando una señal resultante n.
N
n = ∑ Wi X i (2.1)
i =1

- La función de transferencia f, Es la que se le aplica a la señal resultante (n).

La función de transferencia nos entrega un valor de acuerdo a la función de
activación que se escoja. (Ver funciones de transferencia Anexo B).

y = f i (n i ) (2.2a)
n
y = f (∑ Wi X i + b) (2.2b)
i =1

y = f ( w11 X 11 + w12 X 12 + ...w1n X 1n + b) (2.2c)

2.3 Funciones de Transferencia

2.3.1 Función Hardlim

En la figura 2.3, se observa la función de transferencia hardlim, si el argumento de

la función es menor que cero, la salida de la red es cero, y la salida será uno si el
argumento es mayor o igual a cero [9]. Con esta función se crea neuronas que
clasifican los valores de entradas en dos clases diferentes.

1 si n ≥ 0
a=
0 si n < 0

Figura. 2.3 Función Hardlim (2.3)

Desarrollada en System Generator, la función hardlim es muy fácil y se la puede
desarrollar de dos maneras.
 La primera forma de desarrollar la función hardlim es a través del bloque M-
Code, el mismo que nos permite describir su funcionamiento en MATLAB
(archivo m-file), pero para la implementación en la FPGA, la herramienta
System Generator convierte el código m-file de MATLAB a código VHDL
para poder ser implementada. Fig.2.4.

Figura. 2.4 Función Hardlim con M-Code

Se necesita unas cuantas líneas de código para describir la función hardlim,

dentro del bloque M-Code, como se puede observar:

%Función de transferencia Hardlim, ecuiación (2.3)

function [FT] = Fhardlim(sums, bias)

sums1= sums + bias
if sums1 >= 0
ft1 = 1
else
ft1 = 0
end
FT=ft1;

Donde:
sums; valor de entrada, es la suma total de las entradas a la neurona por su
respectiva matriz de pesos.
bias; valor de entrada, ganancia b de la neurona, que se suma al valor de
las entradas multiplicadas por los pesos, formando la salida n.
 n = w1,1 p1 + w1, 2 p 2 + ... + w1, R p R + b (2.4)

FT; Valor de salida, se describe según la expresión III.2.

FT = f ( w1,1 p1 + w1, 2 p 2 + ... + w1, R p R + b) (2.5)
 La segunda forma de desarrollar la función hardlim es utilizando los bloques
proporcionados por Sysgen. De igual manera se lo realiza fácilmente, según
la ecuación (2.3), con unos cuantos bloques: un sumador, un comparador y
dos constantes.

Figura. 2.5 Función Hardlim

Ahora la elección entre las dos formas de implementar la función hardlim depende
mucho de la cantidad de recursos que estos requieren para su implementación en
hardware ya que los resultados obtenidos en ambas formas son correctos según la
ecuación 2.3. Para esto se utiliza la herramienta Resourse Estimator, que estima
rápidamente los recursos requeridos por la FPGA para implementar el modelo. Los
resultados se encuentran en el capitulo VI.

2.3.2 Función Hardlims

La función hardlims es una modificación de la función hardlim en la que los valores

de salida son uno 1 y -1 a diferencia de la hardlim que es 0 y 1.

 1 si n ≥ 0
a=
− 1 si n < 0

Figura. 2.6 Función Hardlims (2.6)

El desarrollo en System Generator de la función hardlims es realizada con el bloque
M-Code, figura 2.7, cuyas líneas de código son:
%Función de transferencia Hardlims

function [FT] = Fhardlims(sums, bias)

sums1= sums + bias
if sums1 >= 0
ft1 = 1
else
ft1 = -1
end
FT = xfix({xlSigned, 3, 0},ft1);

FIGURA. 2.7 FUNCIÓN HARDLIMS EN SYSTEM GENERATOR

En la figura 2.8 se observa la cantidad de recursos necesarios para la

implementación de la función hardlims.

Figura. 2.8 Resource Estimator F.Hardlims

2.3.3 Función Sigmoidal

Esta función toma los valores de entrada, los cuales pueden oscilar entre más y
menos infinito, y restringe la salida a valores entre cero y uno [9], figura 2.9, según
la expresión:

1
a=
1 + e −n

Figura. 2.9 Función Sigmoidal (2.7)

Muchas de las mejores técnicas desarrolladas en análisis numérico para determinar

la función sigmoid y que, exitosamente se las utiliza en software, no son eficaces ni
fáciles de desarrollar en hardware puesto que se utiliza funciones exponenciales.

Para realizar funciones no lineales en este trabajo se procede de 2 maneras, las

funciones se desarrollan en forma de tablas almacenadas en bloques ROM, donde
se inicializan usando los comandos de funciones de transferencias que nos
proporciona el Neural Network Toolbox y por medio de aproximaciones lineales.

Bloques ROM: Las ventajas de utilizar los bloques de memoria ROM es que, se
evita el desperdicio de localidades porque éstas dependen del número de bits de la
entrada y este valor funciona como un apuntador a la localidad de memoria donde
se encuentre el valor almacenado. Entre las desventajas se tiene, que apunta a
valores discretos y entre sus intervalos existe un margen de error, y como la
memoria ROM acepta a su entrada solo valores sin signo y punto binario igual a
cero, no se puede obtener representaciones de la función para valores negativos y
como las localidades de memoria dependen del número de bits de entrada, para
datos de entrada que se requiere, por ejemplo, 16 bits de resolución se necesitaría
128 Kbytes de memoria lo que requiere mayores recursos de hardware. El número
de bytes se lo obtiene con la expresión (n/8)2n, donde n es el número de bits de
entrada [2].
 Figura. 2.10 Función Sigmoidal_ROM en System Generator

En la figura 2.10, se observa la memoria ROM que trabaja como función de

transferencia no lineal, sigmoidal, al inicializar en el campo Initial value vector con
el comando logsig. Adicionalmente utilizamos el bloque Convert para asegurar el
número de bits que debe ingresar en la ROM. Ver figura 2.10 - figura 2.11.

Figura. 2.11 Configuración Bloque ROM

Función lineal piecewise (a trozos): Otra manera de desarrollar la función sigmoid

en Sysgen es utilizando aproximaciones lineales piecewise donde una función f(x)
es dada en diferentes subconjuntos de su dominio.
Para esto se determinó la ecuación (2.8)6, basada en aproximaciones de la
ecuación (2.7), expresando así una función lineal a trozos.

6
Autor
 0 si x < −2
0.1572 si − 2 ≤ x < −1

 0.3340 si − 1 ≤ x < 0

1 / 2 si x = 0

f ( x) = 0.5734 si 0 < x ≤ 0.8 (2.8)
0.7356 si 0.8 < x < 1.5

0.8779 si 1.5 ≤ x ≤ 2.5
0.9509 si 2.5 < x ≤ 3.5

1 si 3.5 < x

En la figura 2.12 se observa el desarrollo de la ecuación (2.8) en Sysgen en la que

se a utilizado bloques lógicos, relacionales, un concatenador y un bloque M-Code
para la elección del resultado dependiendo de su entrada que es la salida del
concatenador. (Ver código en anexo A).

Figura. 2.12 Bloque Función Sigmoid por función definida a trozos

2.4 Unidad Neuronal

Aquí se procede a desarrollar la neurona artificial en Sysgen, utilizando bloques

multiplicadores, sumadores y la función de transferencia con que deseamos que
trabaje la neurona. En la figura 2.13 se observa una neurona de dos entradas y que
utiliza la función hardlim, formado por un bloque M-Code.

Figura. 2.13 Neurona desarrollada en Sysgen

En la figura 2.14 se presenta la neurona completa en la que previamente se han

almacenado los pesos en los bloques constant, y se tiene dos gateway que son los
puertos de entrada de la neurona y que transforman los valores de punto flotante a
punto fijo.

Figura. 2.14 Esquema completo de la neurona en Sysgen

Según se requiera mayor número de entradas, se agregan multiplicadores en

paralelo y en igual forma se agregan sumadores en cascada. Como se lo puede
apreciar en la figura 2.15 en la que se tiene una neurona de 4 entradas.
 Figura. 2.15 Neurona de 4 Entradas y Función Hardlim

Una vez que se tiene la neurona, de entradas y función de transferencia deseada,

se puede desarrollar una RNA utilizándola tantas veces como el diseño lo requiera.

2.5 Red Neuronal para el Reconocimiento de Dígitos de un Display de Siete

Segmentos.

Para validar la neurona que se ha desarrollado, a continuación se describe la

implementación de una Red Neuronal Artificial para el reconocimiento de dígitos de
un display de siete segmentos, en una FPGA Spartan III XC3S200.

El sistema consiste en introducir un dígito, del 0 al 9, en una RNA, utilizando 7

switches de la SPARTAN III, que serán los 7 segmentos del display. La RNA tendrá
que reconocer los dígitos, siendo capaz de determinar el número ingresado a pesar
de que el número este parcialmente incompleto.

La RNA a utilizarse consta de 7 entradas, que son los 7 segmentos de display, tiene
una capa y consta de 4 neuronas tipo perceptron para obtener las 4 salidas
necesarias de la red que muestran el dígito resultante en código BCD y podrá ser
visualizado por medio de 4 leds. Además de poder observar el resultado en código
BCD se utiliza un decodificador de BCD a 7 segmentos para también poder
visualizar el resultado de la red en uno de los display de la tarjeta. El tipo de función
de transferencia utilizado es la función hardlim puesto que las salidas deseadas
pueden ser cero o pueden ser uno.

Figura. 2.16 RNA de 7 entradas y 4 neuronas

En la figura 2.16, se observa la RNA, en la que cada neurona posee 7 entradas y

obtenemos un valor de salida, las entradas se deben de multiplicar por sus
respectivos pesos los mismos que se encuentran almacenados como constantes ya
que han sido previamente calculados utilizando las expresiones 2.2.
La salida (y) de cada neurona es comparada con la salida deseada o target (t) para
encontrar el error que nos permita ajustar los nuevos pesos de la red. Para
determinar los nuevos valores de pesos se tiene:

e=t− y (2.9)

Wnuevo = Wanterior + (t − a) X (2.10)

Por lo tanto:

Si e = 1 , entonces Wnuevo = Wanterior + X

Si e = −1 , entonces Wnuevo = Wanterior − X

Si e = 0 , entonces Wnuevo = Wanterior

Así mismo se procede a encontrar los nuevos valores de los bias (b) o ganancias.

bnuevo = banterior + e (2.11)

Para el entrenamiento de la RNA para reconocer los 10 dígitos se determina

primeramente, la matriz de entrada (X) y la matriz de target (t) o salidas deseadas
como sigue:

 0 1 0 0 1 0 0 0 0 0
 0 0 0 0 0 1 1 0 0 0

 0 0 1 0 0 0 0 0 0 0
 
X = 0 1 0 0 1 0 0 1 0 0  ; Matriz de Entrada
 0 1 0 1 1 1 0 1 0 1
 
 0 1 1 1 0 0 0 1 0 0
 1 1 0 0 0 0 0 1 0 0 


 0 0 0 0 0 0 0 0 1 1
 0 0 0 0 1 1 1 1 0 0 
t= ; Matriz salidas deseadas
 0 0 1 1 0 0 1 1 0 0
 
 0 1 0 1 0 1 0 1 0 1
Utilizando las ecuaciones (2.2), (2.9), (2.10) y (2.11) se ejecuta el entrenamiento de
la red para encontrar la matriz de pesos y bias adecuados para que la RNA
reconozca los dígitos deseados.

Para el cálculo se utilizó la herramienta nntool de MATLAB en la que podemos

ingresar la matriz de entradas y la matriz de salidas deseadas, escoger el tipo de
entrenamiento, que será learnp, que utiliza las ecuaciones ya descritas para este
caso, y construir la red neuronal que se requiere, que es una red de una capa y 4
neuronas tipo perceptron con función hardlim. Ver figura 2.17.

Figura. 2.17 Utilización herramienta nntool de MATLAB para cálculo de pesos y

bias
Al pulsar el botón train, se realizan los cálculos de los nuevos valores de pesos y
bias, que inicialmente tenían valor de cero, y obtenemos las siguientes matrices:

- 1 - 2 -1 -1 0 - 2 - 2 
- 2 4 0 7 0 - 2 3 
W = ; Matriz de Pesos
- 1 1 1 0 -1 2 0 
 
- 1 1 -1 0 2 1 0 

 1
- 2 
b =   ; Matriz de bias
- 1 
 
- 2 

Para encontrar los valores de pesos y bias, se necesitó 16 epochs o épocas de

entrenamiento hasta llegar a un error de cero, tal como lo podemos visualizar en la
figura 2.18.

Figura. 2.18 Error en función del número de épocas de entrenamiento

Una vez obtenidos los valores de pesos y bias, para los que la RNA reconocerá los
dígitos, los valores son almacenados en bloques constant de Sysgen (figura 2.19),
para luego realizar la simulación de la red ingresando 7 valores (binarios), que
serían los 7 segmentos del display, y que la red reconocerá presentando los
resultados en código BCD.

Figura. 2.19 Almacenamiento de pesos

Como se dijo además de la RNA, el sistema esta formado por otros elementos
como son:
- Un decodificador de BCD a 7 segmentos, para visualizar la salida de la red
en un display, en adición a la visualización del resultado en los 4 leds.
Consta de un bloque M-Code (Ver código en Anexo C) y un bloque de
concatenación de 7 entradas. Ver figura 2.20.

Figura. 2.20 Codificador BCD a 7 Segmentos

- Un bloque de control; que controla los datos que se visualizarán en el
display, ya que se desea visualizar tanto la entrada como la salida de la red
y para ello se utiliza un bloque divisor de frecuencia que permita
multiplexar los cuatro displays disponibles en la tarjeta Spartan III. Figura
2.21

Figura. 2.21 Controlador display

En las figuras 2.22 y 2.23 se observa el desarrollo de los bloques de control

y divisor de frecuencia, respectivamente. Inicialmente la frecuencia con la
que trabaja la FPGA Spartan III XC3S200, es de 50 MHZ y a través del
divisor de frecuencia se obtiene una frecuencia en el orden de los KHZ, lo
suficiente para multiplexar la entrada a la RNA como la salida, así como
también el ánodo del display que deseamos utilizar para mostrar el
resultado.

Figura. 2.22 Lógica de control salidas RNA

Figura. 2.23 Divisor de Frecuencia

Se completa el sistema de reconocimiento de dígitos de siete segmentos, con todos
los elementos necesarios ya descritos. Figura 2.24. Los resultados de simulación e
implementación se encuentran en el capitulo VI.

Figura. 2.24 Sistema de reconocimiento de dígitos de 7 segmentos

 Capítulo III

Reconocimiento De La Voz

3.1 Problemática [10]

La voz se define en cuanto a su tono, resonancia e intensidad. El tono óptimo o

más adecuado para el habla, al igual que su rango de variación, depende de cada
individuo y está determinado por la anatomía de las cuerdas vocales.

La voz hablada se ubica entre 100Hz y 160Hz para el hombre y para la mujer entre
200Hz y 320Hz; pero las consonantes introducen armónicos cuyas frecuencias van
hasta 5000Hz.

Se tiene cuatro factores que determinan la complejidad del Reconocimiento del

habla:

El Locutor
o Una persona no pronuncia siempre de la misma forma, difieren en la
forma de hablar.

La Gramática
o Hay un gran número de palabras diferentes que debe reconocer el
sistema. Mientras mayor es el número de palabras más difícil es el
reconocedor.

El Entorno físico
o No es lo mismo un sistema que funciona en un ambiente poco
ruidoso, o el que tiene que funcionar en un coche o en una fabrica.

3.2 Metodología

Los principales problemas del reconocimiento de voz son: el reconocimiento del tipo
de voz y los distintos significados de las palabras. Por lo que en esta investigación,
se procedió a tratar de especificar soluciones usando una red neuronal artificial
perceptron multicapa con propagación hacia atrás.

Este tipo de redes conocidas también como Backpropagation son las más usadas
para el reconocimiento de patrones y como la voz tiene patrones, es muy posible
que esta sea uno de los elementos apropiados para encontrar una solución
correcta.
La red tipo perceptrón es una de las redes más sencillas pero de las más utilizadas,
tiene la característica de tener un aprendizaje supervisado, tener funciones de
transferencia tipo hardlim, hardlims, sigmoidal y de tener una topología feedforward
de una o más capas. La función sigmoidal es la función de activación más
penetrante y biológicamente creíble [2], y muy utilizada en el desarrollo de redes
Backpropagation.

Una operación aritmética importante que se requiere para redes neuronales es el

cómputo de las funciones de activación. La estructura de la FPGA limita de cierto
modo que estas funciones se lleven a cabo a un costo razonable, como ya lo vimos
en el capitulo anterior, pero esto se equiparará en las actuales FPGAs con altas
velocidades de implementación y mayores recursos que estas ofrecen. [11]

El entrenamiento de estas redes, se basa en la presentación sucesiva y de forma

repetida, de pares de vectores en las capas de entrada y salida (vectores entrada y
salida deseada). La red crea un modelo a base de ajustar sus pesos en función de
los vectores de entrenamiento, usando el procedimiento de gradient-descent, a
través de la minimización de la función de error, usualmente el error cuadrado entre
la señal de la salida deseada y la salida de la red neuronal. Así para cada vector de
entrada la red producirá un valor de salida más similar al vector de salida esperado.
[12]

3.3 Razones por la que las RNA son la mejor solución

Normalmente las máquinas de cómputo son capaces de realizar millones de

operaciones por segundo, pero no son capaces de entender el significado de las
formas visuales o de distinguir entre distintas clases de objetos.

Estos sistemas son secuenciales y son exitosos en la resolución de problemas

matemáticos, en la creación, manipulación y mantenimiento de bases de datos, en
comunicaciones electrónicas, en el procesamiento de textos, gráficos y auto
edición, siendo eficientes y fáciles de usar, pero no poseen la capacidad de
interpretar lo que les rodea.
Debido a este problema de los sistemas de cómputos secuenciales, desarrollados
por Von Neuman, se ha desarrollado nuevos sistemas de procesamiento de
información como las Redes Neuronales Artificiales (RNA) [2], permitiendo así
solucionar problemas como lo hace normalmente el cerebro humano.

Las redes neuronales artificiales son modelos computacionales que son inspirados,
por los principios de cómputo, realizados por las redes neuronales biológicas del
cerebro. Estas redes neuronales poseen características que sobrepasan algunas
limitaciones en los sistemas computacionales clásicos [9].

Procesamiento en el cerebro es principalmente paralelo y distribuido

La información es guardada en conexiones, distribuida sobre la red y
procesada en una gran cantidad de neuronas en paralelo.

El cerebro es adaptable desde el nacimiento hasta su muerte.

Tienen la habilidad de aprender reglas describiendo datos de
entrenamientos y de información anteriormente aprendida, respondiendo a
nuevos modelos.

La pérdida de unas neuronas o conexiones no afecta significativamente la
conducta de la red, cuando la información procesada involucra una gran
cantidad de neuronas y conexiones.

Flexible, se ajusta a nuevos ambientes por aprendizaje.

Maneja información difusa.

Las RNA no ejecutan instrucciones, responden en paralelo a las entradas de la red.

El resultado no es almacenado en una posición de memoria, el resultado es el
estado de la red para el cual se logró equilibrio. El conocimiento de una red
neuronal no se almacena en instrucciones, el poder de la red está en su topología y
en los valores de las conexiones (pesos) entre neuronas. [9]

Una gran mayoría de redes neuronales aún se implementan en software sobre

maquinas secuenciales. Aunque esto no es una severa limitación, hay mucho que
ganar de la implementación de redes neuronales en hardware, sobre todo si se
aprovecha del paralelismo de las redes neuronales pero sin elevar costos.

Como se puede captar las RNA poseen características que hacen de estas la mejor
opción y las aplicaciones que se han podido desarrollar utilizando las RNA son
diversas, pero para nuestro propósito son ideales para el reconocimiento de
patrones, como lo son la de la voz.
 Capitulo IV

Diseño Sistema de Reconocimiento de Patrones de Voz

4.1 Metodología

El sistema de reconocimiento de voz, se lo puede separar en tres partes o etapas

bien definidas como son: etapa de adquisición y tratamiento de la señal de voz,
etapa de extracción de características y por última etapa, la red neuronal, a la que
se le presentará como entradas, un vector con un número determinado de
características extraídas en la etapa previa. Figura 4.25.

Figura. 4.25 Procesos del Sistema

4.2 Adquisición y tratamiento de muestras

Primeramente se debe contar con un número determinado de señales de voz

(patrones), de las palabras que se desea reconocer, obtenidos por medio del
micrófono para ser muestreados y luego procesados para obtener una la señal de
voz útil y sin niveles de DC aplicando las técnicas de pre-procesamiento. Luego se
prosigue a la extracción de las características de la señal de voz cuyos valores
formarán el vector de entrada de la red neuronal.

4.2.1 Adquisición

Para la adquisición de datos se debe tomar en cuenta los siguientes parámetros:

Frecuencia de Muestreo: Se debe de tener en cuenta primeramente la

frecuencia de muestreo a la que trabaja la tarjeta de sonido del PC [13], esto
dependiendo de las frecuencias de voz máxima (Fw) que se quiere trabajar y la
frecuencia de Nyquist (Fn).
Fn=2*Fw, Fn>Fw (4.12)
 Tiempo de Muestreo: (Tm) Este parámetro es el tiempo de duración que se
quiere tomar de la señal, depende de la longitud de las palabras que se quieren
que el sistema reconozca [13]. Se debe tener en cuenta que la señal queda
representada por un vector de valores reales de longitud (L):

L = ( Fm * Tm ) (4.13)

4.2.2 Tratamiento

Para el tratamiento de la señal se tiene en cuenta los siguientes puntos:

Preénfasis: Es la eliminación del nivel DC de la señal, a truncamientos y para

aplanarla espectralmente. El propósito es suavizar el espectro y reducir las
inestabilidades de cálculo asociadas con las operaciones aritméticas de
precisión finita y para compensar la caída de -6 dB que experimenta la señal al
pasar a través del tracto vocal [13]. Para eliminar el nivel DC se pasa la señal
digitalizada de voz a través de un filtro de primer orden cuya función de
transferencia es:

H ( z ) = 1 − az −1 ; Donde a=0,95 (4.14)

La ecuación diferencia será:

∧
f ( n ) = f ( n ) − a * f ( n − 1) ; Donde a=0,95 (4.15)

Figura. 4.26 Filtro de primer orden

Extracción señal útil: La señal útil se obtiene utilizando dos métodos, por
detección de extremos y por comparación de la amplitud de inicio y final de la
señal dado un valor de umbral.
4.3 Extracción de características de la Señal de Voz

En esta etapa se tiene como entradas las señales de voz tratadas, es decir, señales
estables y suaves. A estas señales se les extrae un conjunto de características o
parámetros, propios de la señal, con lo que se genera matrices de entrada y
también matrices de salidas o targets, las cuales sirven para el posterior
entrenamiento de la red neuronal, minimizando el numero de nodos de entrada de
las red neuronal, lo cual reduce la arquitectura de la red logrando unos tiempos de
entrenamiento menores.

Inicialmente antes de extraer los parámetros, la señal se divide en tramas y a cada

trama se le reduce el efecto de discontinuidad al mínimo, por lo tanto se aplica
ventaneo; para el proyecto se utiliza la ventana de hamming, que es el tipo de
ventaneo más utilizado para el análisis de la voz [13]. La ventana hamming se
define como:

0.54-0.46*cos 2π t
( ) → si -T ≤ t ≤ T 
w (t ) =  T 2 2  (4.16)
0 → para el resto de la señal 

Después de aplicar la ventana de haming, se realiza la extracción de las

características que pueden ser de dos tipos diferentes: parámetros LCP (Linear
Predicting Code) y parámetros FFT (Fast Fourier Transform).

A medida que se van generando los valores de los parámetros por cada frame, de
cada señal analizada, son guardados en una matriz (características), al final de
dicho proceso se tendrá: características(n), donde (n) es el número de
características máximas de un patrón que representa el número de nodos de
entrada de la red. Además se debe generar una matriz (Out) de valores de salida o
targets especificados por el usuario para cada palabra que se quiere que el sistema
reconozca, estos representan el valor de salida en cada nodo de las redes
neuronales, esto que en el entrenamiento se debe presentar un valor de entrada
asociado a un valor de salida deseado.
4.4 Arquitectura y Entrenamiento de la Red Neuronal

Para el entrenamiento, primeramente se establece una topología de red neuronal,

perceptron multicapa, con tres capas, debido a la relativa facilidad con la cual
pueden ser adaptadas a diferentes tipos de problemas, y además se utiliza como
algoritmo de entrenamiento el backpropagation con momentum.

4.3.1 Arquitectura de la Red Neuronal

Se debe tener en cuenta que la capacidad de generalización de la red está

relacionada con la cantidad de neuronas de la capa oculta; A mayor cantidad de
neuronas en la capa oculta, la red puede variar más rápido en respuesta a los
cambios de la entrada. [14]

Se debe establecer el número de nodos en la capa intermedia de forma práctica,

para completar la arquitectura de la red neuronal, la cual tiene tres capas, una capa
de entrada cuyo numero de nodos se establece al igual que los nodos de la capa de
salida, y la capa intermedia con numero de nodos establecidos por el usuario, ver
figura 4.27

Figura. 4.27 Arquitectura de la Red Elegida para el Sistema de Reconocimiento de

Voz

En este tipo de red perceptron multicapa, el problema está en su entrenamiento

debido a la dificultad de modificar correctamente los pesos de la capa oculta. Para
que la red pueda aprender algo, se implementó el algoritmo de BackPropagation,
que como su nombre lo indica tiene la función de ir propagando los errores
producidos en la capa de salida hacia las capas de atrás.

4.3.2 Entrenamiento

Para el entrenamiento de la RNA de tres capas se utiliza el algoritmo de

entrenamiento backpropagation con momentun que se describe como sigue [9]:

El conjunto de pares de patrones de entrada y salidas deseadas es.

{ x1 , x2 ,..., xn } − {t1 , t2 ,..., tq } (4.17)

Según la formula anterior, q es el número de patrones de salida, y n es el número

de patrones de entrada. La salida de cada unidad en la primera capa e intermedias
esta dada por la formula [9].

(V.18)
Donde:
es el peso que interconecta la unidad i de la entrada con la unidad j de la
siguiente capa.
m es el número de unidades de la capa z
z es el número de la capa actual
es la función de transferencia de la capa actual
es la salida de la unidad i de la capa anterior, en caso de ser la primera
capa este seria el patrón de entrada.

La salida de la red en la capa de salida es:

(4.19)
Ahora se verifica la salida de la última capa con la salida deseada para verificar el
error en cada unidad.
(4.20)
El error en i-esimo patrón se define como la sumatoria de los errores en cada
unidad de salida [9].

(4.21)

Estos pasos se repiten para cada patrón del conjunto propuesto. Al final se toma el
error cuadrático de entrenamiento, normalizado que es [9].

(4.22)

Este error generado por la red neuronal se observa como un espacio n–

dimensional, donde n es el número de pesos de la red. Ahora lo que se quiere es
llegar lo más rápido posible hacia el mínimo absoluto de este espacio, la manera de
lograrlo es seguir la dirección contraria del gradiente de la función del error [9].

Como en las capas ocultas no existe una salida deseada que comparar con la
salida de cada unidad se debe traer una parte del error de la capa de salida hacia
las capas ocultas, ahora los términos del error en la capa de salida son [9].

 q

ϕ sj = ( d j − y j ) .θ ' s  ∑ w zji .viz −1 
 i =1  (4.23)

Los términos de error para cada unidad en las capas ocultas son.

 m
 q
ϕ zj = θ ' z  ∑ w zji .viz −1  .∑ ϕ sj .w zji
 i =1  j =1
(4.24)

Después se procede a actualizar los pesos de la red, primero para la capa de

salida, por medio de.

(4.25)
Donde la variable α se define como velocidad de aprendizaje, y su valor varia
entre 0 y 1. Ahora para las capas ocultas la actualización será [9].

(4.26)

La derivada de la función de transferencia (θ’) se puede definir como:

Si

Si

Si

(4.27)

Es recomendable ir despacio con la velocidad del gradiente, pues si va muy rápido

se corre el riesgo de oscilar indefinidamente sin llegar al mínimo de error buscado, y
si va muy lento se puede caer en todos los mínimos locales con el riesgo de no
poder salir de alguno de ellos [9]. Ahora esta velocidad se controla con la variable
.

Por lo general se escogen valores altos de para aumentar la velocidad de

convergencia de la red, pero se tiende a caer en una oscilación infinita por no existir
una amortiguación a velocidad excesiva. Un método de evitar esa oscilación es
introducir una nueva variable llamada momentum γ [9], que lo que hace es
modificar el término del peso anterior en el cálculo del nuevo.

(4.28)
Figura. 4.28. Espacio de generalización, A) para una velocidad de aprendizaje baja;
B) para una velocidad de aprendizaje alta, se pueden observar las oscilaciones; C)
para una velocidad de aprendizaje alta pero adicionándole termino de momento [13]

La gráfica 4.28 muestra el comportamiento del momentum. El valor del momentum

esta entre 0 y 1, y entre menor sea el valor del momentum la oscilación tiende a
disminuir.

Básicamente lo que se debe realizar en el entrenamiento de la red neuronal es [14]:

• Aplicar un vector de entrada y calcular su salida mediante el algoritmo
FeedForward, ecuaciones 2.2
• Calcular el error mediante el algoritmo BackPropagation
• Determinar en qué dirección (+ o -) debe cambiarse los pesos para reducir
el error.
• Determinar la cantidad en que es preciso cambiar cada peso.
• Corregir los pesos de las conexiones.
• Repetir los pasos anteriores para todos los patrones hasta reducir el error a
un valor elegido. Dado que el aprendizaje es supervisado, para los nodos de
salida se conoce la respuesta esperada a cada entrada.

Después de que las redes neuronales se encuentren entrenadas, es decir, que el

entrenamiento haya alcanzado el error mínimo propuesto o haya terminado el
número de épocas especificadas, se podrá dar pasó a la segunda etapa del
proyecto: etapa de reconocimiento o ejecución de la red neuronal artificial.
 Capitulo V

IMPLEMENTACIÓN SISTEMA RECONOCEDOR DE VOZ

5.1 Introducción

El desarrollo del sistema esta divido en dos partes, es decir, la primera parte que es
la extracción de características, se desarrolló en MATLAB 7.1, debido a que
desarrollarla en Sysgen, implica un mayor tiempo de realización y por otro lado no
es el objeto de estudio de esta tesis, y la segunda parte que es la RNA que sí está
desarrollada con la herramienta de diseño de hardware Sysgen 8.

Primero describiremos la obtención de características de la señal de voz, que se

desea que la red reconozca, la misma que puede ser elegida entre los tipos de
parámetros LCP (Linear Predicting Code) y FFT (Fast Fourier Transform). La
extracción de características es desarrollada en MATLAB utilizando la Interfaz
Gráfica de Usuario (GUI), proporcionando un entorno vistoso al usuario.

Una vez que se ha obtenido un vector con los valores de los parámetros
característicos de la señal, este es exportado a workspace de MATLAB, para luego
ser leídos desde la plataforma Sytem Generator, que es la segunda parte del
sistema y en la que se implementa la red neuronal artificial en hardware, utilizando
una FPGA.

5.2 Obtención y Tratamiento de la Señal de Voz

La obtención de la voz se realiza por medio de un micrófono, su tratamiento y

obtención de características se encuentra desarrollada en MATLAB y presentada
mediante Interfaz Gráfica de Usuario (GUI) como se puede observar en la figura
5.29.
 Figura. 5.29 Interfaz GUI para Obtención de Señal de Voz

Se observa que existen dos conjuntos de opciones, el primero para la obtención de

la señal, reproducción y limpieza de la pantalla, donde se graficará la señal que se
ingresó mediante el micrófono. El segundo conjunto tiene 2 opciones para recortar
la señal de voz cada uno con un método distintito.

Una vez obtenida la grabación de la señal de voz útil, la que será tratada, ésta es
muestreada y a través de un filtro de primer orden, descrito en la ecuación 4.15
indicado en el capitulo 4.2.2, se elimina el nivel de DC suavizando el espectro e
inestabilidades en la manipulación de la señal para luego ser enventanada
utilizando el tipo de ventana hamming, y de cada trama obtenida extraer las
características.

5.2.1 Obtención de la Señal de Voz

Se tiene en cuenta primeramente la frecuencia de muestreo que depende del la

tarjeta de audio instalada, que es de 11025 Hz. Luego se define un tiempo de
grabación el mismo que determina el tiempo para obtener la señal de voz que se la
ha definido de 0.5 segundos. Entonces para la obtención de la señal de voz se
tiene:
AIVoice = analoginput('winsound'); % Obtención a través tarjeta de
sonido
chan = addchannel(AIVoice,1);
duration = 0.5; %Duración de la grabación
set(AIVoice,'SampleRate',11025) % Frecuencia de Muestreo
ActualRate = get(AIVoice,'SampleRate');

.
.
.
start(AIVoice)
[d1,t1] = getdata(AIVoice);
wavwrite([d1,t1],11025,'grabacion')%Guarda en archivo .wav la señal

(Código completo, ver Anexo D)

5.2.2 Señal Útil

Como se indicó se puede escoger entre dos métodos para obtener la señal útil.
El primer método, de umbral, es por medio de definir un nivel bajo que será
comparado con cada muestra de la señal y si supera este umbral se determina el
inicio de la palabra; de igual forma para determinar el final, se define un nivel que al
ser superado indica el final de la palabra. Este valor se determina de forma práctica.

Antes de determinar la parte útil de la señal se utiliza un filtro de bajo orden

(preénfasis). Si X es la señal grabada y Lo la longitud de la señal se tiene:

Preénfasis:

% Aplicando ecuación (1.18)

X(2:length(X))=X(2:length(X))-0.95*X(1:length(X)-1);
X(1) = 0;

Para el inicio:
for i=500:1:Lo
if abs(X(i))> 0.0003
inicio=i;
break;
end
end

Para el final:

for i=1:1: Lo -100

if abs(X(Lo -i+1))> 0.00009
final= Lo -i-100;
 break;
end
end
Obteniéndose un vector de salida:

Result=[];
j=1;
for i=inicio:1:final
Result(j)=X(i);
j=j+1;
end

(Código completo, ver Anexo E)

En el segundo método, cruces por cero, determina un número de cruces por cero
mínimos, una amplitud mínima de comienzo de la señal y una amplitud mínima de
final de la señal. Teniendo estos valores así:

AmplitudMinInic = 0.0003; % Amplitud mínima al comienzo de

señal
AmplitudMinFin = 0.00009; % Amplitud mínima al final de señal
MinCrucesCero = 4; % Cruces por cero mínimo
TamTrama = 330; % Tamaño de trama analizado
InicTrama = 4; % Número de trama de inicio de la
señal
FinTrama = 5; % Número de trama de final de la
señal

Aquí se utiliza un filtro de orden bajo, donde sutil es la señal de voz obtenida de la
grabación.

sutil(2:length(sutil)) = sutil(2:length(sutil)) - 0.95 *

sutil(1:length(sutil)-1); % aplicando ecuación (4.15)

Lo que hace un detector de extremos es monitorear la evolución de la energía en

una serie de tramas o frames, sobreponiéndolas unas con otras, esperando que la
energía supere ciertos límites o umbrales. Entonces primeramente se determina el
número de cruces por cero de la señal, se realiza una comparación de valores de
amplitud y se decide el inicio y final de la señal. (Código completo, ver Anexo F)

5.3 Obtención Parámetros Característicos

Para extraer los parámetros característicos se puede escoger entre LCP (Linear
Predicting Code) y FFT (Fast Fourier Transform), como se puede observar en la
figura 5.30.
 Figura. 5.30 Interfaz GUI para Extracción de Características LPC y FFT

El objetivo de extraer de la señal de voz, un número determinado de parámetros es

que en realidad se realiza una codificación de voz que es la conversión de la señal
de voz a una representación digital. Debido a que la señal es analógica, la
codificación de voz conlleva un proceso básico de muestreo y cuantificación para
conseguir una representación digital [15].
Los codificadores de voz explotan las propiedades tanto temporales como
frecuenciales de la señal de voz y del sistema auditivo humano.
Se tiene dos tipos de parámetros LCP (Linear Predicting Code) y FFT (Fast Fourier
Transform).

Para obtener los parámetros LPC, se determina inicialmente determinados valores,

donde Patron es la señal de voz de la que se desea obtener los parámetros
característicos: (Código completo, ver Anexo G)

TamTrama = 332; % Tamaño de trama, 30ms

Overlap = 221; % Incremento de trama
ValoresLpc = 15; % Número de valores LPC
NumMuestras = length(Patron);
NumTramas = floor(((NumMuestras - TamTrama) / Overlap) + 1);
Para obtener los parámetros FFT, de igual forma se determina inicialmente
determinados valores, donde Y1 es la señal de voz de la que se desea obtener los
parámetros característicos: (Código completo, ver Anexo H)

TamTrama = 332; % Tamaño de Trama, 30ms

Overlap = 221; % Incremento de trama
NumMuestras = length(Y1); % Número de Tramas
NumTramas = floor(((NumMuestras - TamTrama) / Overlap) + 1);

5.4 RNA Propuesta para el Reconocedor de Patrones de Voz

La segunda parte del sistema reconocedor de voz, es el desarrollo de la Red

Neuronal en System Generator, programa que nos permite posteriormente
implementarla en la FPGA.

Como ya se dijo, la topología de la RNA es una red de 3 capas, cuyos nodos de

entrada es igual al número de patrones característicos de la señal; los nodos de la
capa oculta o intermedia varían según los resultados deseados en la red, si son los
deseados o no, estos pueden ir incrementando para resolver regiones más
complejas, dependiendo de las palabras que se desea reconocer y del grado de
complejidad en diferenciación; el número de nodos en la capa de salida es igual al
número de palabras a reconocer.
El número de nodos de la capa de entrada y oculta fueron determinados en un
inicio como se explica a continuación y se irá modificando basándonos en los
resultados. Se decidió en un inicio determinar una arquitectura de red de 20 nodos
de entrada, 8 nodos en capa oculta y 2 nodos capa de salida que serian las
palabras a reconocer. En la figura 5.31 se observa la red propuesta desarrollada
utilizando System Generator.
 Figura. 5.31 RNA propuesta para el Reconocimiento de Patrones de Voz

La neurona a utilizarse en la capa oculta y capa de salida es como se observa en la

figura 5.32. La neurona de la capa oculta consta de 20 entradas y la de la salida
utiliza 8 neuronas que serian las salidas de las ocho neuronas de la capa oculta,
cada neurona posee un bloque de almacenamiento de pesos, para lo se utiliza
memorias FIFO cuyos datos serán utilizados para el cálculo de los nuevos pesos y
luego enviados nuevamente a las FIFOs para ser leídos y ser utilizados por la red
durante el entrenamiento con el algoritmo de backpropagation con momentum.
 Figura. 5.32 Neuronas Capa Oculta y Capa de Salida

La RNA propuesta, en la figura 5.31, es solo la realización del algoritmo

FeedFordward utilizando la ecuación 4.18-4.19; se complementa con dos bloques
más para la realización del algoritmo backpropagation con momentum de acuerdo a
las fórmulas descritas en la sección 4.4.2.

Obtenida la señal de salida de toda la red, este valor es comparado con la señal de
salida deseada utilizando la ecuación 4.20, teniéndose este valor de error se
procede a encontrar el error de cada unidad en la capa de salida con la ecuación
4.23 y este error es llevado a cada unidad de la capa oculta para encontrar el error
esta capa según la ecuación 4.24. Una vez que se tiene los errores en cada capa
se procede actualizar los pesos de cada capa utilizando las formulas 4.25-4.28.
Figura 5.33.
Figura. 5.33 Actualización Pesos Capa de Salida y Obtención de Fracción
de Error a Propagarse en la Capa Oculta.

Figura. 5.34 Determinación en Cada Unidad de la Capa Oculta

Figura. 5.35 Actualización de los Pesos de la Capa Oculta

Figura. 5.36 RNA 3 Capas con Algoritmo Backpropagation

Capitulo VI
 RESULTADOS

6.1 Recursos Obtenidos de la Función Hardlim

Para el bloque hardlim 1 se obtiene los siguientes recursos de hardware como se

observa en la figura 6.37 y para el bloque hardlim 2 en la figura 6.38.
Utilizando esta herramienta tenemos:

Figura. 6.37 Recursos Estimados F. Hardlim 1

Figura. 6.38 Recursos Estimados F. Hardlim 2

Observando los resultados del bloque Resource Estimator se puede concluir que la
función hardlim 1 que utiliza el bloque M-Code, necesita menos recursos de
hardware, que la función hardlim 2 que utiliza comparador y sumador.

De acuerdo al resultado es preferible utilizar la función de transferencia hardlim1,

con el bloque M-Code, ya que obtenemos los resultados deseados y menos
recursos de hardware. Tabla 6.1

Tabla 6.1 Resultado Resourse Estimator Función Hardlim 1 y 2

Función de
Transferencia Slices LUTs IOBs

Hardlim1 1 1 5

Hardlim2 5 8 5

6.2 Recursos y Resultados Obtenidos de la Función Sigmoid

6.2.1 Función Sigmoid ROM

Obtenidos los resultados de la función Sigmoid, a través del bloque ROM, y a través
del bloque logsig de Simulink (figura 6.39), que representa la ecuación (2.7), se
puede observar de los resultados que existe un margen de error en determinados
puntos (Fig. 6.40) y además no se puede representar valores negativos como ya se
dijo anteriormente.

Figura. 6.39 Comparación de resultados bloque Sigmoid_ROM con Simulink

En la tabla 6.2 y figura 6.40, se observa los resultados del funcionamiento de la

función sigmoidal al entregarle determinados valores, los mismos que se
compararán con los valores deseados de la función, para lo cual se utiliza el bloque
logsig de Simulink.
 Tabla 6.2 Resultado bloque Sigmoid_ROM y Logsig de Simulink
Entrada punto Entrada punto fijo a Salida
flotante F_sig Sig_ROM Salida Simulink
-5,0 -5,0000 0,5000 0,006693
-4,0 -4,0000 0,5000 0,017990
-3,0 -3,0000 0,5000 0,047430
-2,0 -2,0000 0,5000 0,119200
-1,8 -1,8130 0,5000 0,140300
-1,5 -1,5000 0,5000 0,182400
-1,3 -1,3130 0,5000 0,212100
-1,0 -1,0000 0,5000 0,268900
-0,8 -0,8125 0,5000 0,307400
-0,5 -0,5000 0,5000 0,377500
-0,3 -0,3125 0,5000 0,422500
0,0 0,0000 0,5000 0,500000
0,3 0,3125 0,5000 0,577500
0,5 0,5000 0,7344 0,622500
0,8 0,8125 0,7344 0,692600
1,0 1,0000 0,7344 0,731100
1,3 1,3130 0,7344 0,787900
1,5 1,5000 0,8750 0,817600
1,8 1,8130 0,8750 0,859700
2,0 2,0000 0,8750 0,880800
2,3 2,3130 0,8750 0,909900
2,5 2,5000 0,9531 0,924100
2,8 2,8130 0,9531 0,943300
3,0 3,0000 0,9531 0,952600
3,3 3,3130 0,9531 0,964900
3,5 3,5000 0,9844 0,970700
3,8 3,8130 0,9844 0,978400
4,0 4,0000 0,9844 0,982000
4,5 4,5000 1,0000 0,989000
5,0 5,0000 1,0000 0,993300
6,0 6,0000 1,0000 0,997500

logsig & Sig_ROM

1,2

0,8

logsig
0,6
Sig_ROM

0,4

0,2

0
-6 -4 -2 0 2 4 6 8

Figura. 6.40 Resultados Sigmoid_ROM vs Logsig

En la figura 6.41 se tiene el resultado de la herramienta Resource Estimator para el
bloque Sigmoid_ROM para una entrada de 8 bits y punto binario 4. Resultado que
debe tomarse muy en cuenta al momento de elegir entre un bloque u otro porque
como ya se ha dicho, los recursos de hardware son limitados y de estos depende
mucho su elección, sin dejar de lado la exactitud con lo que se requiere obtener
resultados.

Figura. 6.41 Recursos Estimados de Hardware para el Bloque Sigmoid_ROM

6.2.2 Función Sigmoid Definida a Trozos

El resultado de la función sigmoid utilizando éste método, se puede observar en la

tabla 6.3, los mismos que se visualizan el la figura 6.43 comparados con los
resultados obtenidos del bloque logsig de Simulink (Fig. 6.42). A este bloque se lo
denomina F_Sig.

De los resultados, se tiene, que los datos de salida tienen cierto margen de error
con los valores de salida deseados ya que los resultados son una aproximación. El
número de bits de entrada también afecta, aumentando los recursos de hardware;
pero se tiene resultados aproximados para valores negativos de entrada lo que no
se obtiene por medio del bloque ROM.
 Figura. 6.42 Bloque F_sig, por función definida a trozos

Tabla 6.3 Resultado bloque F_Sig y Logsig de Simulink

Entrada punto Entrada punto fijo a Salida bloque
flotante F_sig F_Sig Salida Simulink
-5,0 -5,0000 0,0000 0,006693
-4,0 -4,0000 0,0000 0,017990
-3,0 -3,0000 0,0000 0,047430
-2,0 -2,0000 0,1563 0,119200
-1,8 -1,8010 0,1563 0,141800
-1,5 -1,5000 0,1563 0,182400
-1,3 -1,3010 0,1563 0,214000
-1,0 -1,0000 0,3281 0,268900
-0,8 -0,8008 0,3281 0,309900
-0,5 -0,5000 0,3281 0,377500
-0,3 -0,3008 0,3281 0,425400
0,0 0,0000 0,5000 0,500000
0,3 0,3008 0,5625 0,574600
0,5 0,5000 0,5625 0,622500
0,8 0,8008 0,7344 0,690100
1,0 1,0000 0,7344 0,731100
1,3 1,3010 0,7344 0,786000
1,5 1,5000 0,8750 0,817600
1,8 1,8010 0,8750 0,858200
2,0 2,0000 0,8750 0,880800
2,3 2,3010 0,8750 0,908900
2,5 2,5000 0,8750 0,924100
2,8 2,8010 0,9375 0,942700
3,0 3,0000 0,9375 0,952600
3,3 3,3010 0,9375 0,964500
3,5 3,5000 0,9375 0,970700
3,8 3,8010 1,0000 0,978100
4,0 4,0000 1,0000 0,982000
4,5 4,5000 1,0000 0,989000
5,0 5,0000 1,0000 0,993300
6,0 6,0000 1,0000 0,997500
 F_Sig & Logsig
1,2
1
0,8
Sa lid a Sig m o id 0,6
Logs ig
0,4 F_Sig
0,2
0
-6 -4 -2 -0,2 0 2 4 6

Valore s de e ntrada X

Figura. 6.43 Resultado F_Sig vs Logsig

En la figura 6.44 se tiene el resultado de la herramienta Resource Estimator para el

bloque F_Sig para una entrada de 8 bits y punto binario 4.

Figura. 6.44 Recursos Estimados de Hardware para el Bloque F_Sig

Obtenidos los resultados de los dos bloques realizados para la función sigmoid es
importante comparar los resultados y la cantidad de recursos que se necesitan para
implementarlos en hardware (figura 6.45), ya que la exactitud, el funcionamiento y
el coste son muy importantes. De éste análisis se puede elegir entre los dos
bloques dependiendo del tipo de requerimientos que se deseé tener al momento de
diseñar una RNA.
 Sig_ROM & F_Sig & Logsig

1,2

0,8
Salida Sigmoid
0,6 Sig_ROM
F_Sig
0,4 Logsig

0,2

0
-6 -4 -2 0 2 4 6 8
-0,2
Valores de entrada X

Figura. 6.45 Comparación de resultados bloques Sig_ROM, F_Sig y Logsig

De los resultados de las funciones sigmoid desarrolladas, se permite, encontrando

el coeficiente de correlación y el error medio cuadrático (RMSE), comparar el
ajuste entre los datos deseados de la función y los extraídos.

El coeficiente de Correlación7 (R2), es una medida relativa que indica el grado de

ajuste a una línea entre los datos observados y simulados [16]. Se calcula
mediante la expresión:

∑ (H
2
 1
(i ) − µ C )( H D (i ) − µ D ) 
2
 N
i =1
C

R = 
 σ C ×σ D 
  (6.29)
Donde:
HC son los datos que se desea obtener
HD son los datos calculados
σC es la desviación estándar de los valores observados en campo
σD es la desviación estándar de los valores extraídos de la función definida a trozos
µC es la media de los valores deseados de la función
µD la media de de los valores extraídos de la función definida a trozos
N es número total de observaciones (entradas a la función).

Para calcular este valor, para las dos funciones se tiene primeramente las
desviaciones estándar y la media de cada función.

7
Un valor de R² igual a 1 nos indica una tendencia lineal perfecta entre los datos. Es adimensional.
Para la función Sigmoid ROM:
σC= 0.354099464
σD= 0.214760108
µC= 0.618639129
µD= 0.73236129

Para la función F_Sig:

σC= 0.353694745
σD= 0.358758131
µC= 0.618564935
µD= 0.609380645

De ahí tenemos que para un total de 31 datos observados (N) el valor de

correlación es:

Para la función Sigmoid_ROM:

∑ (H
2
 1
(i ) − µC )( H D (i) − µ D ) 
2  N
i =1
C

R =  = 0.82
 σ C ×σ D 
 

Para la función F_Sig:

∑ (H
2
 1
(i ) − µC )( H D (i) − µ D ) 
2  N
i =1
C

R =  = 0.93
 σ C ×σ D 
 

De estos resultados, se tiene que para la función sigmoid, desarrollada utilizando la

función definida a trozos, la correlación se aproxima mas a 1, que la función
desarrollada utilizando memorias ROMs. Por consiguiente se tiene que se obtienen
mejores resultados para el bloque F_Sig con un coeficiente de correlación de 0.93.

Por otro lado se encuentra el error cuadrático medio (RMSE8), que permite
comparar el ajuste entre los datos deseados (función sigmoid de simulink) y los
extraídos (funciones Sigmoid_ROM y F_Sig) [16].

8
Valores de RMSE iguales a 0 son óptimos ya que los errores no existirían y la relación sería perfecta,
pueden darse cualquier valor positivo
 N

∑ (H
i =1
C (i ) − H D (i)) 2
RMSE =
N (6.30)

Para la función Sigmoid _ROM:

∑ (H
i =1
C (i ) − H D (i )) 2
RMSE = = 0.20
N

Para la función F_Sig:

∑ (H
i =1
C (i ) − H D (i )) 2
RMSE = = 0.04
N

De estos resultados, se tiene que para la función sigmoid, desarrollada utilizando la

función definida a trozos, el RMSE se aproxima más a 0, que la función
desarrollada utilizando memorias ROMs. Por consiguiente se obtiene un error muy
reducido de 0.04 para el bloque F_Sig, logrando generar mejores resultados.

Como ya se dijo, además de comparar resultados es muy importante determinar la

cantidad de recursos, que el diseño desarrollado utiliza en hardware. De la tabla 6.4
se concluye fácilmente que para una entrada de 8 bits, punto binario 4, el bloque
F_Sig necesita mas recursos de hardware que la función Sig_ROM pero a
diferencia de ésta, el bloque F_Sig, como se comprobó, obtiene mejores resultados
en un margen de error bajo.

Tabla6.4 Comparación recursos de hardware función sigmoid

Función de Transferencia Slices FFs LUTs IOBs
Sigmoid Sig_ROM 23 12 45 20
Sigmoid F_Sig 69 15 125 16
6.3 Simulación e Implementación Reconocedor Dígitos 7 Segmentos

6.3.1 Simulación

Para la simulación se desarrolló una interfaz GUI (Interfaz Gráfica de Usuario) para
escoger el número de entrada a la RNA, teniendo dos opciones para hacerlo, ya
sea haciendo clic en el botón del dígito que se deseé que la RNA reconozca o
ingresando en cada editor de texto, los siete valores binarios que conforman el
display como se observa en la interfaz GUI de la figura 6.46.

Figura. 6.46 Interfaz gráfica de usuario para ingreso de datos a la RNA

Una vez ingresado el digito que se desea que la RNA reconozca, por medio del
botón Ir a Red, se abre inmediatamente el diseño de la red en Sysgen para iniciar la
simulación, figura 6.47. De la simulación se tiene la siguiente la tabla de resultados
Tabla 6.6 para los dígitos ingresados correctamente y para los que están
parcialmente incompletos. Como referencia se presenta la tabla 6.5 donde se
observa la representación de los dígitos en siete segmentos y código BCD. El
resultado de la simulación es obtenido en 2 segundos, pero este tiempo es
superado en la implementación como se comprueba más adelante.
 Figura. 6.47 Simulación del sistema de reconocimiento.

Tabla 6.5 Representación de dígitos en código BCD y siete segmentos [17]

Reprecentación décimal Siete Segmentos BCD
0 0000001' 0000'
1 1001111' 0001'
2 0010010' 0010'
3 0000110' 0011'
4 1001100' 0100'
5 0100100' 0101'
6 0100000' 0110'
7 0001111' 0111'
8 0000000' 1000'
9 0000100' 1001'

Tabla 6.6 Resultado de la Simulación

Ingreso Salida de la RNA
Siete Segmentos Siete Segmentos BCD
0000001 '0000001 0000
1001111 1001111 0001
0010010 0010010 0010
0000110 0000110 0011
1001100 1001100 0100
0100100 0100100 0101
0100000 0100000 0110
0001111 0001111 0111
0000000 0000000 1000
0000100 0000100 1001
1000001 0000001 0000
1100001 0000001 0000
1010010 0010010 0010
1110010 0010010 0010
0010110 0000110 0011
0010111 0000110 0011
1001101 1001100 0100
1001000 1001100 0100
0101100 0100100 0101
1101100 0100100 0101
0110000 0100000 0110
0101111 0001111 0111
0010000 0000000 1000
6.3.2 Implementación

Realizada la simulación y habiendo comprobado su funcionamiento el siguiente

paso es implementarlo en la tarjeta Spartan III XC3S200. Para esto primeramente
generamos un bloque de co-simualción utilizando el bloque System Generator, que
todo modelo de Simulink debe contenerlo al usar el toolbox de Xilinx, porque este
provee el control del sistema y parámetros de simulación, y además invoca el
generador de código que luego es utilizado en la herramienta ISE 8.1i para la
programación de la tarjeta.

Para generar el bloque de co-simulación, en el bloque System Generator

determinamos las opciones siguientes:

- Compilation: Hardware Co-Simulation => SP3. (Parámetros tarjeta Spartan

III).
- Part: Automáticamente al elegir SP3 en compilación se determina las partes
de la FPGA, se tiene: Spartan3 xc3s200-4ft256
- Target Directory: Se especifica el directorio donde se ubicara los archivos
generados como resultado de la compilación.
- Hardware Description Language: Especifica el lenguaje de descripción de
hardware (HDL) que se usará para la compilación del diseño, pueden ser
VHDL y Verilog; se escogerá VHDL.
- Simulink System Period: Define el periodo del sistema en simulink, en
unidades de segundo.

Una vez definidos los parámetros del bloque System Generator generamos la
compilación del modelo realizado. Al cabo de unos minutos, se ha generado el
bloque de co-simulación, el cual lo conectamos a las respectivas entradas y salidas
para luego simular el modelo. Al simular el modelo ya con el bloque co-simulator, la
tarjeta debe estar debidamente conectada al PC y encendida, para que, al realizar
la simulación el modelo se compile dentro de la FPGA Spartan III y comprobar que
el funcionamiento en la FPGA sea el mismo que en la simulación de Sysgen. Figura
6.48.
 Figura. 6.48 Co-Simulación del Sistema Reconocedor de Dígitos

Al co-simular el modelo sin problema y habiendo comprobado que ingresando los

valores de la tabla 6.6, obtenemos los mismos resultados, se procede, por medio de
la herramienta ISE 8.1i, a generar el archivo PROM, que será descargado en la
FPGA [18]. Una vez ya descargado el programa en la Spartan III tenemos el
sistema completo, de reconocimiento de dígitos de siete segmentos utilizando RNA,
sobre una FPGA. En la asignación de pines de la tarjeta se estableció que las siete
entradas a la red neuronal artificial serán siete switch de la tarjeta, que al ir
dándoles valores de uno lógico o cero lógico se podrán visualizar en un display,
mientras que en otro display observamos el resultado de la red para dicha entrada.

Figura. 6.49 Resultado en FPGA Spartan III para los números 3 y 5

 Figura. 6.50 Resultado para ingreso de dígitos parcialmente incompletos

Figura. 6.51 Resultado para ingreso de dígitos con error

Implementado en hardware, la red neuronal artificial, funciona correctamente como

lo esperado en la simulación, ver figuras 6.49 – 6.51. Debido al paralelismo que
ofrece la FPGA, la ejecución del modelo se realiza a gran velocidad, 2
nanosegundos, pudiendo tener resultados inmediatos al ingreso de los valores de
entrada. Los recursos estimados de hardware, que utiliza el sistema, se observan
en la figura 6.52
 Figura. 6.52 Recursos estimados de hardware para el sistema de reconocimiento
de dígitos

6.4 Resultados Extracción Parámetros Característicos

El vector de entrada, que ingresa a la Red Neuronal, esta conformado por algunos
valores llamados parámetros característicos, que pueden ser del tipo LPC o FFT.
En la etapa de entrenamiento, se determina con que tipo de parámetro se obtiene
mejores resultados basándonos en obtener el menor tiempo de aprendizaje para
llegar al un valor mínimo de error deseado.

Lo que se desea es que la red sea entrenada para reconocer dos palabras
específicas, siendo estas: Luces y Abrir. Para éstas dos palabras se tomaron varios
patrones. Podemos observar en las figuras 6.53 a la 6.56, los parámetros
característicos obtenidos en el sistema, para 4 patrones, utilizando los dos
métodos que determinan la señal útil, así como la utilización de los dos métodos de
obtención de parámetros característicos. Donde corte1 es utilizando el método de
umbral, y corte2 utilizando el método de cruces por cero, para obtener la señal útil.
Figura. 6.53 Patrones Característicos FFT para la palabra Luces
Figura. 6.54 Patrones Característicos FFT para la palabra Aire
Figura. 6.55 Patrones Característicos LPC para la palabra Luces
Figura. 6.56 Patrones Característicos LPC para la palabra Aire
Si comparamos las gráficas de las dos palabras a reconocer, se puede observar a
simple inspección, la complejidad de reconocimiento que debe tener la red neuronal
para poder clasificar los parámetros característicos. Al usar parámetros LPC se
tiene mayor complejidad de separación lo que significa mayor complejidad de
reconocimiento de la red, mientras que con los parámetros FFT se tiene un mapa
menos complejo de separación entre regiones, que al momento del entrenamiento
se traduce en menos épocas de entrenamiento alcanzando la salida deseada con
un error muy reducido. Figuras 6.57 – 6.58.

Figura. 6.57 Patrones LPC para las palabras Luces y Aire

 Figura. 6.58 Patrones FFT para las palabras Luces y Aire

6.5 Resultados algoritmo Backpropagation

Una vez desarrollado el algoritmo backpropagation en System Generator se

procede a verificar el funcionamiento para lo que ingresamos un vector de unos a la
entrada de la red, la que tendrá que llegar a un error de cero al compararse con la
salida deseada que será [0 1] para las dos neuronas de salida.
Figura. 6.59 Salida Deseada y disminución del Error para = 0.8, =0.5.

Figura. 6.60 Salida de las Neuronas de Salida para = 0.8, =0.5.

Para un valor de (velocidad de aprendizaje)=0.8, y (constante de momentum) =
0.3, observamos, según la figura 6.59-6.60, que no llegamos a un valor de error y
salida deseado ya que se produce una oscilación debido a que la velocidad de
gradiente va muy rápido y no se tiene un valor de pequeño que amortigüe la
oscilación.

De acuerdo a los resultados obtenidos de las figuras 6.59-6-60, se prosiguió a

encontrar los valores correctos para que la red llegue a la salida y error deseado sin
llegar a tener oscilaciones, para lo que se tiene valor de alfa igual a 1, mientras que
para la constante de momentum ( ) se tiene el valor de 0.3. Con estos valores se
tiene que en poco tiempo la red llega a disminuir el error con lo que se llega a
obtener la salida deseada para la neurona de salida. Ver figuras 6.61-6.62.

Figura. 6.61 Salida de la RNA con Backpropagation

 Figura. 6.62 Salida Deseada y disminución del Error para = 1, =0.3.

De acuerdo a los resultados hemos desarrollado el algoritmo backpropagation

con momentum y hemos demostrado que los valores de los pesos van variando
para adaptar a la red a una salida desea según sea su entrada.

Figura. 6.63 Variación de los algunos pesos de capa oculta hasta adaptarse.
El siguiente paso es comprobar si para los patrones de entrada, obtenidos
mediante la extracción de características, la red logra adaptar sus pesos para
que encuentre la salida deseada según el patrón ingresado. Si no se logra por
medio de la red propuesta se debe crear una nueva que implicaría en ir
aumentando el número de neuronas ocultas de la red. A medida que se va
aumentando el número de neuronas de la capa oculta, se encuentra con el
problema de las numerosas conexiones entre neuronas y el consumo de más
recursos hardware que son limitados.
 Capitulo VII

CONCLUSIONES Y RECOMENDACIONES

7.1 Conclusiones

• A partir de este trabajo se logró abrir camino para futuras investigaciones en

el campo de las redes neuronales artificiales implementadas en hardware,
utilizando tarjetas FPGAs, en el país y región. Creándose una línea de
investigación, cuyo principal aporte es obtener aplicaciones RNA, que antes
se podía tener a nivel de software ahora obtenerlas a nivel hardware,
permitiéndonos una gran variedad de posibilidades para obtener soluciones
factibles a problemas ingenieriles.

• Se logró implementar dos aplicaciones de redes neuronales en las tarjetas:

Spartan III para reconocimiento de dígitos de siete segmentos, y Virtex II Pro
para la RNA con algoritmo de backpropagation con momentum. Teniéndose
que se aprovechó de las características que las FPGAs nos ofrecen como
son: la flexibilidad, alta velocidad, hardware re-configurable, procesamiento
en paralelo, entre otras, que permitieron obtener un buen desempeño de las
redes.

• Se desarrolló tres funciones de transferencia que son la hardlim, hardlims y

sigmoid, utilizando para cada una, dos formas diferentes de desarrollarlas
en System Generator, lo que nos permitió comparar los resultados de
funcionamiento y de cantidad de recursos necesarios para ser
implementados en hardware, de esta forma escoger la que consuma menos
recursos, ya que los recursos de la FPGA son limitados, pero sin renunciar a
obtener los resultados deseados.

• La elección del bloque más conveniente para la función hardlim depende

solo de la cantidad de recursos que requieren para su implementación en
hardware, puesto que los resultados obtenidos en ambas formas son
correctos con lo que basándonos en la tabla 6.1 se concluye que la función
 hardlim, desarrollada por medio del bloque M-Code, es la más apropiada
para la implementación.

• La función sigmoid, desarrollada utilizando la función definida a trozos en

comparación al resultado del bloque logsig de simulink, tiene un coeficiente
de correlación de 0.93 y un error medio cuadrático de 0.04, que la función
desarrollada utilizando memorias ROMs que genera un coeficiente de
correlación de 0.82 y un error medio cuadrático de 0.2 Por consiguiente se
obtienen mejores resultados para la función sigmoid definida a trozos que
ofrece una alta correlación y un error muy bajo.

• De las dos implementaciones para la función sigmoid, según la tabla 6.4 y

figura 6.45, se tiene que, la desarrollada con la memoria ROM consume
menos recursos de hardware pero genera un mayor margen de error que la
función definida a trozos, que consume mayor recursos y obtiene mejores
resultados. Ya que la exactitud de resultados y coste, en términos de
hardware, son importantes, la elección depende de los requerimientos de
diseño de la RNA.

• Se desarrolló la unidad básica de una red neuronal, como lo es la neurona,

misma que se desarrolló con un alto grado de paralelismo, lo que permitió
obtener en general una RNA con verdaderas características de
procesamiento en paralelo, logrando obtener resultados en menor tiempo de
ejecución que las que se pueden obtener con sistemas computacionales
clásicos.

• Se aprovechó plenamente el paralelismo que ofrece la FPGA, como se

puede apreciar en los resultados de la implementación del sistema
reconocedor de dígitos de siete segmentos. Los resultados (mostrados en el
display), se obtuvieron en un tiempo de 2 nanosegundos, siendo inmediatos
al ingreso de los valores de entrada (7 switchs de la Spartan III), a diferencia
de la simulación que los resultados los obtenemos en 2 segundos, tiempo
que es superado en la implementación.

• A través del procesamiento digital de señales y las redes neuronales

artificiales, se logra generar un sistema de aprendizaje y reconocimiento de
 patrones a través de algunos procesos básicos, como son: adquisición de la
voz, procesamiento, extracción de parámetros característicos y
entrenamiento de redes neuronales.

• Se logró extraer de la señal de voz un número determinado de

características, las más comunes en esta clase de aplicaciones, como lo
son: el Linear Predicting Code (LPC) y el Fast Fourier Transform (FFT), con
estos parámetros representar cada señal de voz para lograr un bajo costo
de ejecución del algoritmo de entrenamiento, para optimizar la red neuronal
artificial.

• Los parámetros característicos LPC obtenidos de las dos palabras luces y

aire ofrecen regiones de separación poco definidas, confusas, tal como se
observa en la figura 6.57, lo que dificulta un buen reconocimiento de la red
y sería necesario una red neuronal compleja, lo que no es conveniente. Por
otro lado los parámetros FFT ofrecen regiones de separación mas definidos,
como se observa en la figura 6.58, permitiéndonos tener una red neuronal
menos compleja y con mejores resultados al momento del entrenamiento es
decir menos épocas de entrenamiento y un error reducido.

• De acuerdo a los resultados obtenidos en la sección 6.5, se desarrolló el

algoritmo backpropagation con momentum y se demostró que los valores de
los pesos van variando para adaptar la red hasta obtener una salida desea
según sea su entrada.

• La FPGA a utilizarse depende de la cantidad de recursos hardware que

requiere la RNA a implementarse, lo que la Spartan III XC3S200 es
totalmente excelente para implementar el reconocedor de dígitos que no
requiere demasiados recursos.

• La utilización de FPGAs para el desarrollo de RNA es muy adecuado,

debido al procesamiento en paralelo que ofrecen, ya que ésta es una
característica intrínseca de las RNA. La gran limitación de desarrollar RNA
en FPGAs es el limitado número de compuertas lógicas (recursos hardware)
pero debido al desarrollo actual de FPGAs, con mayor cantidad de recursos,
esto puede no ser un problema.
 • Los resultados obtenidos en este proyecto de tesis, crean gran motivación
para que otras personas se interesen y se adentren en el área de la
implementación en hardware de redes neuronales artificiales. Logrando
desarrollar numerosas aplicaciones de gran interés en ámbito científico,
como comercial.

7.2 Recomendaciones

• El sistema de reconocimiento de voz parte de la adquisición de los patrones

característicos con los cuales se entrenan las redes neuronales. En este
trabajo se extrajo características LPC y FFT, pero sería interesante proponer
un método de extracción de características con mayor margen de
diferenciación para la etapa de entrenamiento, para así poder establecer
una arquitectura de redes neuronales de menor complejidad y épocas de
entrenamiento.

• La etapa previa a la red neuronal, que es la obtención del vector de patrones

característicos de la señal de voz, en este trabajo fue realizada en Matlab; lo
que sería muy interesante e importante desarrollar esta etapa en System
Generator para una total implementación del sistema.

• El campo de las redes neuronales es muy extenso y se pueden desarrollar

numerosas aplicaciones de redes neuronales implementadas en FPGAs,
como por ejemplo: en el procesamiento de imágenes, control de movimiento
de motores para silla de ruedas, sistemas de acceso controlado por voz,
activación de dispositivos por voz, etc.

• Una limitante de la utilización de dispositivos hardware, como la FPGA, es

que poseen un número determinado de recursos y debido a las requeridas y
numerosas interconexiones, que requieren las redes neuronales, que son
problemáticas, el procesamiento totalmente paralelo no es factible salvo
para redes no muy complejas, y eso implicaría desarrollar un nuevo modelo
de neurona que tenga algún proceso secuencial y la velocidad reducida de
una sola unidad se puede equilibrarse teniendo muchas unidades
trabajando en paralelo.
• El proyecto en general, que se describe en este trabajo aún no esta
finalizado en su totalidad, y por consiguiente, no se han realizado las
pruebas necesarias de la arquitectura propuesta de la RNA con
backpropagation pero se pudo experimentar a través de su desarrollo. Se
dedicó tiempo y esfuerzo a la definición y prueba de cada uno de los
componentes básicos, tanto a nivel teórico como en su implementación y
simulación lógica.
 REFERENCIAS

[1] Yu Hen Hu (University of Wisconsin), Jenq-Neng Hwang (University of

Washington), Handbook of NEURAL NETWORK SIGNAL PROCESSING

[2] AMOS R. OMONDI (Flinders University Adelaide, Australia), JAGATH C.

RAJAPAKSE (Nanyang Tecnological University, Singapore), FPGA
Implementations of Neural Networks

[3] Introduction to Fixed-Point Arithmetic, Help of MATLAB

[4] Cavallero, Rodolfo Antonio Gutiérrez, Francisco Guillermo, Introducción a las

FPGA.

[5] Miguel Morales Sandoval, FPGAs: Aplicaciones, Tendencias y Demos

[6] http://es.wikipedia.org/wiki/ASIC

[7] Francisco José Palacios Burgos, Redes Neuronales con GNU/Linux,

http://softwarelibre.unsa.edu.ar/docs/descarga/2003/curso/htmls/redes_neuronales

[8] Bonifacio Martín del Brío, Alfredo Sanz Molina. “Redes Neuronales y Sistemas
Difusos”, RA-MA, 2002

[9] Universidad Tecnológica de Pereira, Tutorial de Redes Neuronales,

http://ohm.utp.edu.co/neuronales.htm

[10] Héctor F Gómez A., Inteligencia Artificial: Procesamiento de Lenguaje Natural,

UTPL.

[11] Martin Pearson, Ian Gilhespy, Kevin Gurney, Chris Melhuish, Benjamin
Mitchinson, Mokhtar Nibouche, Anthony Pipe, A Real-Time FPGA based Biologically
Plausible Neural Network Processor, University of the West of England.

[12] Diego Milone, Perceptrón multicapa, departamento de Informática FICH-UNL

[13] F. Alejandro Graciano Benítez Carlos F. Lancheros Zapata, Sistema de

Reconocimiento de Palabras para Activación de Comandos en MATLAB Aplicando
Procesamiento Digital de Señales y Redes Neuronales, Pontificia Universidad
Javeriana, 2004.

[14] http://weblidi.info.unlp.edu.ar/catedras/neuronales/04_Backprop.ppt.

[15] Eduardo Solano, Codificación de Voz y Audio, Octubre 2002.

http://dihana.cps.unizar.es/investigacion/voz/coderframe.html

[16] Oñate-Valdivieso, Fernando (2007), Extracción de modelos de elevación digital

a partir de imágenes aster para la determinación de características morfométricas
de cuencas hidrográficas, Trabajo De Investigación Tutelado, Universidad de Alcalá

[17] David G. MArtinez, Jessica Alcalá, VHDL el Arte de Programar Sistemas

Digitales, Editorial Continental, 2002.

[18] Programación FPGA Spartan III refiérase a: http://www.xilinx.com/

 ANEXO A. CÓDIGO F_SIG, BLOQUE M-CODE

%Donde X es la entrada del bloque M-Code y representa la salida de

la concatenación.
%Donde f es la salida representada en formato xlSigned de 8 bits
punto binario 6.

function [f] = F_sig(X)

if X == 256
f = xfix({xlSigned, 8, 6},1);

elseif X == 128

f = xfix({xlSigned, 8, 6},0.9509);

elseif X== 64

f = xfix({xlSigned, 8, 6},0.8779);

elseif X == 32

f = xfix({xlSigned, 8, 6},0.7356);

elseif X == 16

f = xfix({xlSigned, 8, 6},0.5756);

elseif X == 8

f = xfix({xlSigned, 8, 6},0.5);

elseif X == 4

f = xfix({xlSigned, 8, 6},0.334);

elseif X == 2

f = xfix({xlSigned, 8, 6},0.1572);

else
f = xfix({xlSigned, 8, 6},0);

end
ANEXO B. FUNCIONES DE TRANSFERENCIA
 ANEXO C. DECODIFICADOR A 7 SEGMENTOS

function [d0,d1,d2,d3,d4,d5,d6] = deco(A)

if A == 0
d0 = 0;
d1 = 0;
d2 = 0;
d3 = 0;
d4 = 0;
d5 = 0;
d6 = 1;

elseif A == 1

d0 = 1;
d1 = 0;
d2 = 0;
d3 = 1;
d4 = 1;
d5 = 1;
d6 = 1;

elseif A== 2

d0 = 0;
d1 = 0;
d2 = 1;
d3 = 0;
d4 = 0;
d5 = 1;
d6 = 0;

elseif A == 3

d0 = 0;
d1 = 0;
d2 = 0;
d3 = 0;
d4 = 1;
d5 = 1;
d6 = 0;

elseif A == 4

d0 = 1;
d1 = 0;
d2 = 0;
d3 = 1;
d4 = 1;
d5 = 0;
d6 = 0;

elseif A == 5
d0 = 0;
d1 = 1;
d2 = 0;
d3 = 0;
d4 = 1;
 d5 = 0;
d6 = 0;

elseif A == 6

d0 = 0;
d1 = 1;
d2 = 0;
d3 = 0;
d4 = 0;
d5 = 0;
d6 = 0;

elseif A == 7

d0 = 0;
d1 = 0;
d2 = 0;
d3 = 1;
d4 = 1;
d5 = 1;
d6 = 0;

elseif A == 8

d0 = 0;
d1 = 0;
d2 = 0;
d3 = 0;
d4 = 0;
d5 = 0;
d6 = 0;

elseif A == 9

d0 = 0;
d1 = 0;
d2 = 0;
d3 = 0;
d4 = 1;
d5 = 0;
d6 = 0;

else
d0 = 0;
d1 = 0;
d2 = 0;
d3 = 0;
d4 = 0;
d5 = 0;
d6 = 0;

end
 ANEXO D. CÓDIGO PARA GRABAR LA VOZ POR MICRÓFONO

axes(handles.fig)
plot(0)
AIVoice = analoginput('winsound');%ingreso voz por micrófono
chan = addchannel(AIVoice,1);
duration = 0.5; %tiempo de duración de la grabación
set(AIVoice,'SampleRate',11025) %tasa de muestreo
ActualRate = get(AIVoice,'SampleRate');
set(AIVoice,'Timeout',5)
set(AIVoice,'SamplesPerTrigger',ActualRate*duration)
set(AIVoice,'TriggerChannel',chan)
set(AIVoice,'TriggerType','Software')
set(AIVoice,'TriggerCondition','Rising')
set(AIVoice,'TriggerConditionValue',0.2)
set(AIVoice,'TriggerRepeat',1)
start(AIVoice)
[d1,t1] = getdata(AIVoice);
wavwrite([d1,t1],11025,'grabacion') %Guarda en archivo .wav la señal
axes(handles.fig)
plot(t1,d1), grid on, hold on %Gráfica la señal de voz ingresada
axis([t1(1)-0.05 t1(end)+0.05 -0.8 0.8])
xlabel('Time
(sec.)','Fontname','Arial','Fontsize',10,'Fontangle','Italic','Fontw
eight','Bold','color',[1 1 1])
title('Señal de
Voz','Fontname','Arial','Fontsize',12,'Fontangle','Italic','Fontweig
ht','Bold','color',[1 1 1])
delete(AIVoice)
clear AIVoice
 ANEXO E. CÓDIGO PARA OBTENER SEÑAL ÚTIL MÉTODO UMBRAL

X=wavread('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\grabacion.wav');
Lo=length(X);
for i=1000:1:Lo
if abs(X(i))>0.009
inicio=i;
break;
end
end
for i=1:1:Lo-100
if abs(X(Lo-i+1))>0.008
final=Lo-i-100;
break;
end
end
Result=[];
j=1;
for i=inicio:1:final
Result(j)=X(i);
j=j+1;
end

axes(handles.axes9)
plot(0)
plot(Result), grid on, hold on
title('señal
útil','Fontname','Arial','Fontsize',12,'Fontangle','Italic','Fontwei
ght','Bold','color',[1 1 1])
wavwrite(Result,'Vector')
 ANEXO F. CÓDIGO PARA OBTENER SEÑAL ÚTIL
MÉTODO CRUCES POR CERO

sutil=wavread('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\grabacion.wa
v');

AmplitudMinInic = 0.000002; % Amplitud mínima al comienzo de

señal
AmplitudMinFin = 0.0005; % Amplitud mínima al final de señal
MinCrucesCero = 4; % Cruces por cero mínimo
TamTrama = 90; % Tamaño de trama analizado
InicTrama = 4; % Número de trama de inicio de la
señal
FinTrama = 5; % Número de trama de final de la
señal
%*******************************************************************
**
InAux = 1;
InicEstado = 0;
NumTrama = floor(length(sutil)/TamTrama);
FinAux = NumTrama;
%*******************************************************************
**
% f(n) = f(n) - 0.95*f(n - 1) -> Filtro de bajo orden para
eliminación del nivel DC
sutil(2:length(sutil)) = sutil(2:length(sutil)) - 0.95 *
sutil(1:length(sutil)-1);
%*******************************************************************
**for i = 1 : NumTrama - 1
InicVal = (i - 1) * TamTrama + 1;
FinalVal = InicVal + TamTrama - 1;
sutilAux(1 : TamTrama) = sutil(InicVal : FinalVal);
CC(i) = CrucesCero(sutilAux);
AP(i) = Amplitud(sutilAux);
end
for i = 1 : NumTrama - 1
if InicEstado == 0
if AP(i) > AmplitudMinInic
if CC(i) > MinCrucesCero
ContInic = 0;
for j = 1 : InicTrama
if AP(i + j) > AmplitudMinInic
if CC(i + j) > MinCrucesCero
ContInic = ContInic + 1;
end
end
end
if ContInic == InicTrama
InAux = i;
InicEstado = 1;
end
 end
end
else
if AP(i) > AmplitudMinFin
if CC(i) > MinCrucesCero
FinAux = i;
end
end
end
end
InicTrama = InAux;
FinTrama = FinAux;
ValueInic = (InicTrama - 1) * TamTrama + 1;
ValueFin = FinTrama * TamTrama;
Result(1 : ValueFin - ValueInic + 1) = sutil(ValueInic : ValueFin);
Result = Result / max(abs(Result));

axes(handles.axes9)
plot(0)
plot(Result), grid on, hold on
title('señal útil', 'Fontname','Arial', 'Fontsize',12, 'Fontangle',
'Italic','Fontweight','Bold','color',[1 1 1])
wavwrite(Result,'Vector')

%*******************************************************************
*
%*******************************************************************
*
function ContCC = CrucesCero(sutilAux)

% Contador de cruces por cero

ContCC = 0;
SignVal = -1;
for i = 1 : length(sutilAux)
SignVal2 = sign(100 * sutilAux(i));
if (-1 * SignVal) == SignVal2
ContCC = ContCC + 1;
SignVal = SignVal2;
end
end
ContCC = ContCC;

%*******************************************************************
*
%*******************************************************************
*
function ContAP = Amplitud(sutilAux)
% Sumatoria del valor absoluto del vector sutilAux

sutilAux = abs(sutilAux);
sutilAux = sutilAux.*sutilAux;
ContAP = sum(sutilAux)/length(sutilAux);
 ANEXO G. CÓDIGO PARA EXTRAER PARÁMETROS LPC

run ('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\GUI2.m')
axes(handles.axes1)
cla
Patron=wavread('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\Vector.wav'
);
% ************************************
TamTrama = 500; % Tamaño de trama
Overlap = 330; % Incremento de trama
ValoresLpc = 15; % Número de valores LPC
NumMuestras = length(Patron);
NumTramas = floor(((NumMuestras - TamTrama) / Overlap) + 1);
Begin = 0;
i = 1;
%*************************************
if NumTramas < 2
Patron = [];
for i = 1 : 1000
Patron(i) = 0;
end
NumTramas = 4;
end
for ContNumF = 1 : NumTramas
for n = 1 : TamTrama
FramePattern(i) = Patron(n + Begin)*(0.54 -
0.46*cos(6.2832*n/TamTrama));
i = i + 1;
n + Begin;
end
Begin = Begin + Overlap;
i = 1;
FramePattern = FramePattern + 0.00001;
LPCval = [];
LPCval = lpc(FramePattern, ValoresLpc);
for t = 2 : ValoresLpc + 1
LPCvalAux(t - 1) = LPCval(1, t);
end
LPCvalAux = abs(LPCvalAux)/max(abs(LPCvalAux));
VecResult(ContNumF) = sqrt(sum(LPCvalAux)/length(LPCvalAux));
end

caracteristicas = VecResult';
set(handles.listbox1,'String',caracteristicas);
savefile = 'caracteristicas.mat';
save(savefile, 'caracteristicas');
set(handles.listbox1,'String',caracteristicas)
axes(handles.axes1)
plot(caracteristicas),grid on, hold on
title('Caracteristicas LPC','Fontname','Arial','Fontsize',12)
 ANEXO H. CÓDIGO PARA EXTRAER PARÁMETROS FFT

run ('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\GUI2.m')
axes(handles.axes1)
cla
Y1 = wavread('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\Vector.wav');
%*******************************************************************
**
TamTrama = 500; % Tamaño de Trama
Overlap = 330; % Incremento de trama
NumMuestras = length(Y1); % Número de Tramas
NumTramas = floor(((NumMuestras - TamTrama) / Overlap) + 1);
Begin = 0;
i = 1;
%*******************************************************************
**
k = 1;
for ContNumF = 1 : NumTramas
TramaPatron = [];
for n = 1 : TamTrama
TramaPatron(i) = Y1(n + Begin)*(0.54-0.46*cos(6.2832*n/TamTrama));
%Enventanado HAMMING
i = i + 1;
n + Begin;
end
Begin = Begin + Overlap;
i = 1;
Y = fft(TramaPatron,1024);
Y(1)=[];
kk=abs(Y);
power = abs(Y(1:floor(length(Y)/2))).^2;
nyquist = 11025/2;
freq = (1:length(Y)/2)/(length(Y)/2)*nyquist;
for xi = 1 : length(freq)
if freq(xi) < 100 | freq(xi) > 5000
power(xi) = 0;
end
end
[Amp, Pos] = max(power);
vecF(k) = freq(Pos)/nyquist;
k = k + 1;
end
caracteristicas = vecF';
set(handles.listbox1,'String',caracteristicas);
axes(handles.axes1)
plot(0)
plot(caracteristicas), grid on, hold on
title('Caracteristicas
FFT','Fontname','Arial','Fontsize',12,'Fontangle','Italic','Fontweig
ht','Bold','color',[1 1 1])
savefile = 'caracteristicas.mat';
save(savefile, 'caracteristicas')
 1

Implementación de Funciones de
Transferencia y Neurona Perceptron en
FPGAs (Febrero 2008)
Johana E. Briceño S, jebricenox@gmail.com

Escuela de Electrónica y Telecomunicaciones

Universidad Técnica Particular de Loja

dependiendo de la función a implementarse, todas sobre la

Resumen— herramienta System Generator.

II. NEURONA ARTIFICIAL Y FUNCIONES DE TRANSFERENCIA

Se desarrolla los elementos que son parte de una Red Neuronal
Artificial: la neurona y sus funciones de transferencia más
importantes: hardlim, hardlims y sigmoid. Para ello se utilizó A. Neurona Artificial
herramientas de diseño de sistemas digitales y lógica
programable como lo son MATLAB 7.1, System Generator 8.1, y Una red neuronal se encuentra formada por varias unidades
Xilinx 8.1i, que luego nos permitieron su implementación en la neuronales, celdas, unidades de procesamiento o neuronas que
FPGA Spartan III de Xilinx, aprovechando la capacidad de se interconectan entre si formando una red. Esta unidad de
procesamiento paralelo de la tarjeta, que es una característica procesamiento esta formada por:
intrínseca de las RNA.
Para cada elemento es necesario comparar los resultados
obtenidos, para determinar su eficacia, así como también es
necesario determinar los recursos que utiliza en hardware para
su implementación.

Palabras Claves— Redes neuronales, Field programmable gate

arrays, lógica programable.

I. INTRODUCCIÓN Fig.1 Neurona

L a teoría y diseño de las redes neuronales artificiales han

avanzado significativamente durante los últimos 20 años [1].
En este sentido, se aporta al tema de implementación en
Hardware de Redes Neuronales, ya que es relevante
desarrollarlas, debido a que poseen muchas características que
sobrepasan los sistemas computacionales clásicos, lográndose
aplicaciones como: reconocimiento de imágenes,
reconocimiento del habla y caracteres, control de robots, etc.
Nos dedicaremos al desarrollo y análisis de las funciones de
transferencia mas utilizadas en las RNA, como lo son las
funciones hardlim, hardlims y sigmoid, para después
desarrollar la unidad neuronal que es la base para determinar
redes neuronales de mayor tamaño y complejidad. En este
trabajo se utiliza código sintetizable de MATLAB, memorias
ROM, bloques comparadores y aproximaciones lineales,
- Las entradas Xi, que son los datos o señales que
ingresan a la neurona.
- Bias b, Entrada de tendencia, definida como un
número que indica a partir de que valor del potencial
la neurona produce una salida significativa. [2]
Los pesos Wi, que son la intensidad de la sinapsis que
-
conecta la entrada con la neurona o entre dos
neuronas.
Estos valores se multiplican con su respectiva
entrada y si el peso es positivo la conexión se le llama
exitatoria y si es negativo se le llama inhibidora [3].
Estos valores resultantes de las multiplicaciones mas
el bias, son sumados formando una señal resultante n.
N
n = ∑ Wi X i + b (1)
i =1
 2

- La función de transferencia f, que se le aplica a la

señal resultante (n). La función de transferencia nos
entrega un valor de acuerdo a la función de
activación que se escoja.

y = f i ( ni ) (2a)
n
y = f ( ∑ Wi X i + b )
i =1 (2b)
Fig. 3 Función Hardlim con M-Code
y = f ( w11 X 11 + w12 X 12 + ...w1n X 1n + b)
(2b)
Se necesita unas cuantas líneas de código para describir la
función hardlim1, dentro del bloque M-Code, como se puede
B. Funciones de Transferencia observar:
Las funciones de transferencia f, determinan la salida total
de la neurona, la que puede ser una función lineal o no lineal function [FT] = Fhardlim(sums, bias)
de n, y es escogida dependiendo del tipo de problema a sums1= sums + bias
resolverse con la RNA. if sums1 >= 0
En la figura 2, se observa las funciones de transferencia ft1 = 1
diseñadas y luego implementadas en la FPGA, de lo que else
depende de un análisis tanto de la precisión de resultados ft1 = 0
como de los recursos de hardware que consumirían. end
FT = xfix({xlSigned, 2, 0},ft1);

Donde:
sums; valor de entrada, es la suma total de las entradas a la
neurona multiplicada por su respectiva matriz de pesos.
bias; valor de entrada, ganancia b de la neurona.
FT; Valor de salida, se describe según la expresión III.2b, y
se le definió formato tipo Xilinx fixed-point (xfix), valor
signed fixed-point (xlSigned) con 2 bits y puno binario 0.

La segunda forma de desarrollar la función hardlim, que

llamaremos hardlim2, es utilizando sumadores, comparadores
Fig. 2 Funciones de Transferencia y constantes. Como se observa en la figura 4.

III. DISEÑO
A. Diseño Funciones de Transferencia

Function Hardlim

Desarrollar en System Generator, la función hardlim es muy

fácil y se la puede ser de dos maneras.
La primera forma de desarrollar la función hardlim es a
través del bloque M-Code de System Generator, el mismo que
nos permite describir su funcionamiento en MATLAB
(archivo m-file), para luego ser sintetizado en código VHDL Fig. 4 Función Hardlim2
para la implementación en la FPGA, a este bloque le
llamaremos hardlim1. Ver figura 3. La elección entre las dos formas de implementar la función
hardlim depende solamente de la cantidad de recursos que
estos requieren para su implementación en hardware ya que
los resultados obtenidos en ambas formas son correctos. Para
esto se utiliza la herramienta Resourse Estimator, que estima
rápidamente los recursos requeridos por la FPGA para
 3

implementar el modelo. número de bits de la entrada y este valor funciona como un

apuntador a la localidad de memoria donde se encuentre el
Para los bloques hardlim se tiene en la tabla I los recursos valor almacenado. Entre las desventajas se tiene, que apunta a
de hardware necesarios para su implementación. valores enteros y para valores decimales existe un margen de
error, además como la memoria ROM acepta a su entrada solo
Tabla I Resultado Resourse Estimator Hardlim 1 y 2 valores sin signo y punto binario igual a cero, no se puede
obtener representaciones de la función para valores negativos.
Función de
Transferencia Slices LUTs IOBs

Hardlim1 1 1 5

Hardlim2 5 8 5

Según los resultados del bloque Resource Estimator se Fig. 5 Función Sigmoidal con memoria ROM
concluye que la función hardlim1, que utiliza el bloque M-
Code, necesita menos recursos de hardware, que la función
hardlim2 que utiliza un comparador y un sumador. De acuerdo En la figura 5, se observa la función de transferencia
a este resultado es conveniente utilizar la función de sigmoid mediante tablas almacenadas en la memoria ROM, al
transferencia hardlim1, con el bloque M-Code, ya que inicializarla con el comando logsig de Matlab.
obtenemos los resultados deseados con menos recursos de Adicionalmente se utiliza el bloque Convert para asegurar el
hardware. número de bits que debe ingresar en la ROM. A este bloque le
Para la función hardlims se tiene las dos formas de llamaremos Sig_ROM.
implementación que se presentó para la función hardlim. Y de La segunda forma de desarrollarla es por medio de
acuerdo a los recursos de hardware obtenidos, es más aproximaciones lineales pice-wise, para aproximar la función
conveniente la función hardlims utilizando el bloque M-Code sigmoid a una serie de funciones lineales, donde una función
de Sysgen, cuyo código se describe como: f(x) es dada en diferentes subconjuntos de su dominio. Para
esto se determinó la ecuación (3)1, expresando así una función
function [FT] = Fhardlims(sums, bias) lineal a trozos (pice-wise).
sums1= sums + bias
if sums1 >= 0 0 si x < −2
ft1 = 1 0.1572 si − 2 ≤ x < −1
else 
ft1 = -1  0.3340 si −1 ≤ x < 0

end 1 / 2 si x=0 (3)
FT = xfix({xlSigned, 2, 0},ft1); 
f ( x) = 0.5734 si 0 < x ≤ 0.8
0.7356 si 0.8 < x < 1.5

Función Sigmoid 0.8779 si 1.5 ≤ x ≤ 2.5

0.9509 si 2.5 < x ≤ 3.5
1
Muchas de las mejores técnicas desarrolladas en análisis si 3.5 < x
numérico para determinar la función sigmoid y que,
exitosamente se las utiliza en software, no son eficaces ni Desarrollada la función 3 en SysGen, es como se observa en
fáciles de desarrollar en hardware puesto que utilizan la figura 6, donde se utilizó comparadores, un concatenador y
funciones exponenciales que son funciones no lineales y su un bloque M-Code en el que se describe la lógica, que nos
implementación es muy costosa, [4] de lo que se tiene que permite obtener el valor de la función. A este bloque le
tener cuidado puesto que los recursos de la FPGA son llamaremos F_Sig.
limitados.
Para realizar funciones no lineales como la sigmoid, en este
trabajo se procede de 2 maneras. Primeramente las funciones
se desarrollan en forma de tablas almacenadas en bloques
ROM, donde se inicializan usando los comandos de funciones
de transferencias que nos proporciona el Neural Network
Toolbox de Matlab, en la cual valores de entrada toman el
valor de la función solo para valores enteros, que pueden ser
guardados en la tabla; para valores no enteros (ejemplo: 1.5,
0.8) se aproxima al valor más cercano. Usando ROMs se evita
el desperdicio de localidades porque éstas dependen del 1
Autor
 4

resultados para valores negativos de entrada, razón por la que

se tiene menor margen de error.
De éste análisis se puede elegir entre los dos bloques
dependiendo del tipo de requerimientos que se deseé tener al
momento de diseñar una RNA.

B. Diseño Neurona Perceptron

Aquí se procede a desarrollar la neurona artificial en

Sysgen, utilizando bloques multiplicadores, sumadores y la
función de transferencia con que deseamos que trabaje la
neurona. En la figura 8 se observa una neurona de dos
entradas y que utiliza la función hardlim, formado por un
bloque M-Code.

Fig. 6 Función Sigmoid por función definida a trozos

Obtenidos los resultados de los dos bloques realizados para

la función sigmoid es importante comparar los resultados y la
cantidad de recursos que se necesitan para implementarlos en
Fig. 8 Neurona desarrollada en Sysgen
hardware, ya que la exactitud, el funcionamiento y el coste son
muy importantes. Se tiene en la figura 7, la comparación de En la figura 9 se presenta la neurona completa en la que
resultados obtenidos de los dos diseños y en la tabla II los previamente se han almacenado los pesos en los bloques
recursos de hardware necesarios para su implementación. constant, y se tiene dos Gateway in que son los puertos de
entrada de la neurona y que transforman los valores de punto
Tabla II Comparación de recursos de la función sigmoid
flotante a punto fijo y un Gateway out que es el puerto de
Función de salida y transforma el valor en punto fijo a punto flotante.
Transferencia Slices FFs LUTs IOBs

Sigmoid Sig_ROM 23 12 45 20

Sigmoid F_Sig 69 15 125 16

Sig_ROM & F_Sig & Logsig

1,2

0,8
Fig. 9 Esquema completo de la neurona en Sysgen
S a l id a S ig m o i d

0,6 Sig_ROM
F_Sig
Según se requiera mayor número de entradas, se agregan
0,4 Logsig multiplicadores en paralelo y en igual forma se agregan
0,2
sumadores en cascada. Una vez que se tiene la neurona, de
entradas y función de transferencia deseada, se puede
0
-6 -4 -2 0 2 4 6 8
desarrollar una RNA utilizándola tantas veces como el diseño
-0,2 lo requiera.
Valores de entrada X

Fig. 7 Comparación de resultados bloques Sig_ROM, F_Sig
y Logsig
De la tabla II se concluye fácilmente que para una entrada
de 8 bits, punto binario 4, el bloque F_Sig necesita más
recursos de hardware que la función Sig_ROM, pero a
diferencia de ésta, el bloque F_Sig, según la figura 7, obtiene
IV. IMPLEMENTACIÓN
Para comprobar el correcto funcionamiento de la neurona y
de la función de transferencia, se implementará las funciones
AND y XOR.
La función AND es un problema linealmente separable,
como se constata en la figura 10, que se resuelve con una
 5

neurona perceptrón con función de transferencia hardlim como

se observa en la figura11.
Vectors to be Classified
1.5

1
P(2)

0.5

-0.5 Fig. 12 Simulación Neurona Perceptron que funciona como

-0.5 0 0.5 1 1.5
P(1) compuerta AND
Fig. 10 Separación de regiones función AND
Habiendo comprobado que el perceptron funciona
Para encontrar el valor de los pesos y del bias de la neurona correctamente como función AND, se implementa el modelo
perceptron, para que funcione como AND se utilizó la en la FPGA Spartan III. Las dos entradas a la neurona son
herramienta nntool de Matlab en la que: asignadas a dos switchs de la tarjeta y la salida podemos
visualizarla en uno de los leds, como se observa en la figuras
13 y 14.
1 0 1 0

 ; Matriz de entrada
1 1 0 0

t = [1 0 0 0]; Salidas deseada

W = [2 1]; Matriz de pesos

b = [-3]; bias

Fig. 13 Salida de cero para la entrada (1, 0)

Fig. 14 Salida de uno para la entrada (1, 1)

La segunda función, XOR, es un problema que no es

Fig. 11 Perceptron que funciona como AND
El resultado de la simulación es como se observa en la
figura 12, en la que el resultado de la neurona es uno, solo
cuando ambas entradas son uno, caso contrario es cero.
linealmente separable, como lo representa la figura 15, por lo
que la solución a este problema de clasificación se encuentra
si se descompone el espacio en tres regiones; una región
pertenecería a una de las clases de salida y las otras dos
pertenecen a la segunda clase, así que en lugar de utilizar
únicamente una neurona de salida se utilizan dos, con esto se
obtienen dos rectas que delimitan tres zonas; para poder elegir
entre una zona u otra de las tres, es necesario otra capa con la
tercera neurona cuyas entradas serán las salidas de las
neuronas anteriores.
 6

Fig. 15 Regiones de la función XOR

Las dos zonas o regiones que contienen los puntos (0,1) y

(1,0) se asocian a una salida activa de la red y la zona central
se asocia a la salida nula, por tanto se ha de utilizar una red de Fig. 17 Simulación red neuronal funcionando como XOR
tres neuronas con función hardlim, distribuidas en dos capas
para solucionar este problema, como se visualiza en la figura
16. Los valores de pesos y bia para que la red sea una función Comprobado que la red funciona correctamente como
XOR son: función XOR, se implementa el modelo en la FPGA Spartan
III. Las dos entradas a la neurona son asignadas a dos switchs
Neurona 1: w11= -0.8 w12= -1.2 de la tarjeta y la salida podemos visualizarla en uno de los
Neurona 2: w21= 1.5 w22= 1 leds. Los resultados se observan en la figura 18.
Neurona 3: w31= 0.8 w32= 1.2
Bias neurona 1: b1= 1.5
Bias neurona 2: b2= -1
Bias neurona 3: b3= -1.5

Fig. 16 Red neuronal que funciona como función XOR

El resultado de la simulación es como se observa en la

figura 17, en la que el resultado de la neurona es uno cuando
las entradas son (1,0) y (0,1), y cuando se tiene (1,1) y (0,0) la
salida es cero.
Fig. 18 Resultado implementación función XOR
 7

V. CONCLUSIONES
Se desarrolló tres funciones de transferencia que son la
hardlim, hardlims y sigmoid, utilizando para cada una, dos
formas diferentes de desarrollarlas en System Generator, lo
que nos permitió comparar los resultados de funcionamiento y
de cantidad de recursos necesarios para ser implementados en
hardware, de esta forma escoger la que consuma menos
recursos, ya que los recursos de la FPGA son limitados, pero
sin renunciar a obtener los resultados deseados.
La elección del bloque más conveniente para la función
hardlim depende solo de la cantidad de recursos que requieren
para su implementación en hardware, puesto que los
resultados obtenidos en ambas formas son correctos con lo que
basándonos en la tabla VII.3 se concluye que la función
hardlim, desarrollada por medio del bloque M-Code, es la más
apropiada para la implementación.
La función hardlim y hardlims consumen menos recursos
hardware que las funciones no lineales.
De las dos implementaciones para la función sigmoid, se
tiene que, la desarrollada con la memoria ROM consume
menos recursos de hardware pero genera un mayor margen de
error que la función definida a trozos, que consume mayor
recursos y obtiene mejores resultados. Ya que la exactitud de
resultados y coste, en términos de hardware, son importantes,
la elección depende de los requerimientos de diseño de la
RNA.
Se desarrolló la unidad básica de una red neuronal, como lo
es la neurona perceptron, misma que se desarrolló con un alto
grado de paralelismo, lo que permitió obtener en general una
RNA con verdaderas características de procesamiento en
paralelo, logrando obtener resultados en menor tiempo de
ejecución que las que se pueden obtener con sistemas
computacionales clásicos.

REFERENCES
[1] Yu Hen Hu (University of Wisconsin), Jenq-Neng Hwang (University
of Washington), Handbook of NEURAL NETWORK SIGNAL
PROCESSING
[2] Francisco José Palacios Burgos, Redes Neuronales con GNU/Linux,
http://softwarelibre.unsa.edu.ar/docs/descarga/2003/curso/htmls/redes_n
euronales
[3] Bonifacio Martín del Brío, Alfredo Sanz Molina. “Redes Neuronales y
Sistemas Difusos”, RA-MA, 2002
[4] AMOS R. OMONDI (Flinders University Adelaide, Australia),
JAGATH C. RAJAPAKSE (Nanyang Tecnological University,
Singapore), FPGA Implementations of Neural Networks

Revisado por:
Ing. Héctor F. Gómez A., Ingeniero en Sistemas Informáticos
y Computación, Especialista en Sistemas de Información
Geográfica, Universidad Técnica Particular de Loja.