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 neuroprocesadores
1
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 pipelining
2
.

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 (X
i
W
i
) 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.

Almacenamiento y actualización de pesos, entradas/salidas:
7
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 hardlim
3
, hardlims
4
y sigmoid
5
.

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 X
i
, 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 W
i
, 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.

i i
N
i
X W n

=
=
1
(2.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).



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

=
(2.2b)
) ... (
1 1 12 12 11 11
b X w X w X w f y
n n
+ + + = (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.


Figura. 2.3 Función Hardlim (2.3)

¹
´
¦
<

=
0 0
0 1
n si
n si
a




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.




b p w p w p w n
R R
+ + + + =
, 1 2 2 , 1 1 1 , 1
... (2.4)
FT; Valor de salida, se describe según la expresión III.2.
) ... (
, 1 2 2 , 1 1 1 , 1
b p w p w p w f FT
R R
+ + + + = (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.

Figura. 2.6 Función Hardlims (2.6)
¹
´
¦
< −

=
0 1
0 1
n si
n si
a




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:


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)2
n
, donde n es el número de bits de
entrada [2].
n
e
a

+
=
1
1






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




¦
¦
¦
¦
¦
¦
¹
¦
¦
¦
¦
¦
¦
´
¦
<
≤ <
≤ ≤
< <
≤ <
=
< ≤ −
− < ≤ −
− <
=
x si
x si
x si
x si
x si
x si
x si
x si
x si
x f
5 . 3 1
5 . 3 5 . 2 9509 . 0
5 . 2 5 . 1 8779 . 0
5 . 1 8 . 0 7356 . 0
8 . 0 0 5734 . 0
0 2 / 1
0 1 3340 . 0
1 2 1572 . 0
2 0
) (
(2.8)

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:

y t e − = (2.9)
X a t W W
anterior nuevo
) ( − + =
(2.10)
Por lo tanto:
Si 1 = e , entonces
X W W
anterior nuevo
+ =

Si 1 − = e , entonces
X W W
anterior nuevo
− =

Si 0 = e , entonces
anterior nuevo
W W =


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

e b b
anterior nuevo
+ = (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 0 1 0 0 0 0 0 1 1
0 0 1 0 0 0 1 1 1 0
1 0 1 0 1 1 1 0 1 0
0 0 1 0 0 1 0 0 1 0
0 0 0 0 0 0 0 1 0 0
0 0 0 1 1 0 0 0 0 0
0 0 0 0 0 1 0 0 1 0
X ; Matriz de Entrada

=
1 0 1 0 1 0 1 0 1 0
0 0 1 1 0 0 1 1 0 0
0 0 1 1 1 1 0 0 0 0
1 1 0 0 0 0 0 0 0 0
t ; Matriz salidas deseadas





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:

=
0 1 2 0 1 - 1 1 -
0 2 1 - 0 1 1 1 -
3 2 - 0 7 0 4 2 -
2 - 2 - 0 1 - 1 - 2 - 1 -
W ; Matriz de Pesos

=
2 -
1 -
2 -
1
b ; Matriz de bias

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).
F
n
=2*F
w
, F
n
>F
w
(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):

( ) *
m m
L F T = (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:

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

= − (4.14)

La ecuación diferencia será:

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

= − − (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:

( )
( )
2 -T
0.54-0.46*cos si
2 2
0 para el resto de la señal
t T
t
T
w t
π ¦ ¹
→ ≤ ≤
¦ ¦
=
´ `
→ ¦ ¦
¹ )
(4.16)

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.

{ } { }
1 2 1 2
, ,..., , ,...,
n q
x x x t t t − (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].

( )
' 1
1
. .
q
s s z z
j j j ji i
i
d y w v ϕ θ

=
| |
= −
|
\ ¹

(4.23)

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

' 1
1 1
. . .
q m
z z z z s z
j ji i j ji
i j
w v w ϕ θ ϕ

= =
| |
=
|
\ ¹
∑ ∑
(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
flotante
Entrada punto fijo a
F_sig
Salida
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
0
0,2
0,4
0,6
0,8
1
1,2
-6 -4 -2 0 2 4 6 8
logsig
Sig_ROM

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
flotante
Entrada punto fijo a
F_sig
Salida bloque
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
-0,2
0
0,2
0,4
0,6
0,8
1
1,2
-6 -4 -2 0 2 4 6
Valores de entrada X
S
a
l
i
d
a

S
i
g
m
o
i
d
Logsig
F_Sig

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
-0,2
0
0,2
0,4
0,6
0,8
1
1,2
-6 -4 -2 0 2 4 6 8
Valores de entrada X
S
a
l
i
d
a

S
i
g
m
o
i
d
Sig_ROM
F_Sig
Logsig

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ón
7
(R
2
), 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:
2
1
1
2
) ) ( )( ) ( (
|
|
|
¹
|

\
|
×
− −
=

=
D C
i
D D C C N
i H i H
R
σ σ
µ µ
(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:

82 . 0
) ) ( )( ) ( (
2
1
1
2
=
|
|
|
¹
|

\
|
×
− −
=

=
D C
i
D D C C N
i H i H
R
σ σ
µ µ


Para la función F_Sig:


93 . 0
) ) ( )( ) ( (
2
1
1
2
=
|
|
|
¹
|

\
|
×
− −
=

=
D C
i
D D C C N
i H i H
R
σ σ
µ µ



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 (RMSE
8
), 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
i H i H
RMSE
N
i
D C ∑
=

=
1
2
)) ( ) ( (
(6.30)

Para la función Sigmoid _ROM:


20 . 0
)) ( ) ( (
1
2
=

=

=
N
i H i H
RMSE
N
i
D C


Para la función F_Sig:

04 . 0
)) ( ) ( (
1
2
=

=

=
N
i H i H
RMSE
N
i
D C



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

Resumen—


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ó
herramientas de diseño de sistemas digitales y lógica
programable como lo son MATLAB 7.1, System Generator 8.1, y
Xilinx 8.1i, que luego nos permitieron su implementación en la
FPGA Spartan III de Xilinx, aprovechando la capacidad de
procesamiento paralelo de la tarjeta, que es una característica
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

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,


dependiendo de la función a implementarse, todas sobre la
herramienta System Generator.
II. NEURONA ARTIFICIAL Y FUNCIONES DE TRANSFERENCIA

A. 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:


Fig.1 Neurona

- Las entradas X
i
, 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 W
i
, 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.
b X W n
i i
N
i
+ =

=1
(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
L
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.

) (
i i
n f y =
(2a)
) (
1
b X W f y
n
i
i i
+ =

=
(2b)


) ... (
1 1 12 12 11 11
b X w X w X w f y
n n
+ + + =
(2b)

B. Funciones de Transferencia
Las funciones de transferencia f, determinan la salida total
de la neurona, la que puede ser una función lineal o no lineal
de n, y es escogida dependiendo del tipo de problema a
resolverse con la RNA.
En la figura 2, se observa las funciones de transferencia
diseñadas y luego implementadas en la FPGA, de lo que
depende de un análisis tanto de la precisión de resultados
como de los recursos de hardware que consumirían.



Fig. 2 Funciones de Transferencia
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
para la implementación en la FPGA, a este bloque le
llamaremos hardlim1. Ver figura 3.


Fig. 3 Función Hardlim con M-Code

Se necesita unas cuantas líneas de código para describir la
función hardlim1, dentro del bloque M-Code, como se puede
observar:

function [FT] = Fhardlim(sums, bias)
sums1= sums + bias
if sums1 >= 0
ft1 = 1
else
ft1 = 0
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
y constantes. Como se observa en la figura 4.


Fig. 4 Función Hardlim2

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.

Para los bloques hardlim se tiene en la tabla I los recursos
de hardware necesarios para su implementación.

Tabla I Resultado Resourse Estimator Hardlim 1 y 2
Función de
Transferencia Slices LUTs IOBs
Hardlim1 1 1 5
Hardlim2 5 8 5

Según los resultados del bloque Resource Estimator se
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
a este resultado es conveniente utilizar la función de
transferencia hardlim1, con el bloque M-Code, ya que
obtenemos los resultados deseados con menos recursos de
hardware.
Para la función hardlims se tiene las dos formas de
implementación que se presentó para la función hardlim. Y de
acuerdo a los recursos de hardware obtenidos, es más
conveniente la función hardlims utilizando el bloque M-Code
de Sysgen, cuyo código se describe como:

function [FT] = Fhardlims(sums, bias)
sums1= sums + bias
if sums1 >= 0
ft1 = 1
else
ft1 = -1
end
FT = xfix({xlSigned, 2, 0},ft1);


Función Sigmoid

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 utilizan
funciones exponenciales que son funciones no lineales y su
implementación es muy costosa, [4] de lo que se tiene que
tener cuidado puesto que los recursos de la FPGA son
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
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 enteros y para valores decimales existe un margen de
error, además 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.


Fig. 5 Función Sigmoidal con memoria ROM


En la figura 5, se observa la función de transferencia
sigmoid mediante tablas almacenadas en la memoria ROM, al
inicializarla con el comando logsig de Matlab.
Adicionalmente se utiliza el bloque Convert para asegurar el
número de bits que debe ingresar en la ROM. A este bloque le
llamaremos Sig_ROM.
La segunda forma de desarrollarla es por medio de
aproximaciones lineales pice-wise, para aproximar la función
sigmoid a una serie de funciones lineales, donde una función
f(x) es dada en diferentes subconjuntos de su dominio. Para
esto se determinó la ecuación (3)
1
, expresando así una función
lineal a trozos (pice-wise).
















<
≤ <
≤ ≤
< <
≤ <
=
< ≤ −
− < ≤ −
− <
=
x si
x si
x si
x si
x si
x si
x si
x si
x si
x f
5 . 3 1
5 . 3 5 . 2 9509 . 0
5 . 2 5 . 1 8779 . 0
5 . 1 8 . 0 7356 . 0
8 . 0 0 5734 . 0
0 2 / 1
0 1 3340 . 0
1 2 1572 . 0
2 0
) (
(3)
Desarrollada la función 3 en SysGen, es como se observa en
la figura 6, donde se utilizó comparadores, un concatenador y
un bloque M-Code en el que se describe la lógica, que nos
permite obtener el valor de la función. A este bloque le
llamaremos F_Sig.

1
Autor
4

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
hardware, ya que la exactitud, el funcionamiento y el coste son
muy importantes. Se tiene en la figura 7, la comparación de
resultados obtenidos de los dos diseños y en la tabla II los
recursos de hardware necesarios para su implementación.

Tabla II Comparación de recursos de la 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


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
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. 8 Neurona desarrollada en Sysgen

En la figura 9 se presenta la neurona completa en la que
previamente se han almacenado los pesos en los bloques
constant, y se tiene dos Gateway in que son los puertos de
entrada de la neurona y que transforman los valores de punto
flotante a punto fijo y un Gateway out que es el puerto de
salida y transforma el valor en punto fijo a punto flotante.



Fig. 9 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. 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.
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
Sig_ROM & F_Sig & Logsig
-0,2
0
0,2
0,4
0,6
0,8
1
1,2
-6 -4 -2 0 2 4 6 8
Valores de entrada X
S
a
l
i
d
a

S
i
g
m
o
i
d
Sig_ROM
F_Sig
Logsig
5
neurona perceptrón con función de transferencia hardlim como
se observa en la figura11.

Fig. 10 Separación de regiones función AND

Para encontrar el valor de los pesos y del bias de la neurona
perceptron, para que funcione como AND se utilizó la
herramienta nntool de Matlab en la que:


ܲ ൌ ቂ
1 0 1 0
1 1 0 0
ቃ; Matriz de entrada

t = [1 0 0 0]; Salidas deseada

W = [2 1]; Matriz de pesos

b = [-3]; bias



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.


Fig. 12 Simulación Neurona Perceptron que funciona como
compuerta AND

Habiendo comprobado que el perceptron funciona
correctamente como función AND, se implementa el modelo
en la FPGA Spartan III. Las dos entradas a la neurona son
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.


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
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.
-0.5 0 0.5 1 1.5
-0.5
0
0.5
1
1.5
Vectors to be Classified
P(1)
P
(
2
)
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
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
XOR son:

Neurona 1: w11= -0.8 w12= -1.2
Neurona 2: w21= 1.5 w22= 1
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. 17 Simulación red neuronal funcionando como XOR


Comprobado que la red funciona correctamente como
función XOR, se implementa el modelo en la FPGA Spartan
III. Las dos entradas a la neurona son asignadas a dos switchs
de la tarjeta y la salida podemos visualizarla en uno de los
leds. Los resultados se observan en la figura 18.



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.


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

interpretaciones e ideas en el presente proyecto son plasmados bajo responsabilidad exclusiva de la autora.DECLARACIÓN DE AUTORÍA Los conceptos. Autora F: …………………………………… Johana Elizabeth Briceño Sarmiento .

Debido al futuro prometedor de esta rama. System Generator 8. verificando así el correcto funcionamiento de la implementación. el proceso en sí consiste primeramente en realizar un .INTRODUCCIÓN En la mayoría de los sistemas computacionales se tiene la capacidad de procesamiento de operaciones complejas. pero sabemos que estos sistemas no poseen nociones de pensamiento ni toma de decisiones. que son características intrínsecas de las RNA. Después se procederá a diseñar el sistema reconocedor de comandos de voz específicos. de ahí que. control de robots.1. 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. en una FPGA Spartan III. utilizando dispositivos reprogramables como lo son las FPGAs (Field Programmable Gate Array) de Xilinx. reconocimiento del habla y caracteres. 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. que normalmente el cerebro humano no las realiza fácilmente. que ofrecen una gran capacidad de procesamiento paralelo y manejo de datos en tiempo real. se decidió involucrarse en el desarrollo de redes neuronales artificiales (RNA) utilizando herramientas de diseño de sistemas digitales como lo son MATLAB 7. comprobando que es capaz de reconocer todos los dígitos aunque estos ingresen incompletos a la red.1i que luego nos permitirán implementarlas en hardware.1. utilizando una RNA de una sola capa. para después desarrollar la unidad neuronal que es la base para determinar redes neuronales de mayor tamaño y complejidad. se describirá brevemente. Luego nos introduciremos en el desarrollo de las diferentes funciones de transferencia a utilizarse en las RNA. la historia. 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. 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. y que hasta hace poco era algo prácticamente imposible que las maquinas lo pudieran lograr. etc. Inicialmente. y Xilinx 8.

procesamiento de la señal de voz que comienza con la adquisición de la señal. que será tipo perceptrón multicapa. que servirán como entradas de la red. 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. para luego realizar el entrenamiento de la red por medio del algoritmo backpropagation con momentum para que reconozca dos palabras específicas. como con nuevos patrones presentados. . tratamiento y extracción de un número determinado de patrones característicos.

1. Diseñar de un sistema de reconocimiento de voz. en el país y región. para la etapa de entrenamiento de dos palabras especificas. Desarrollo del algoritmo de backpropagation en System Generator. el cual permite abrir la posibilidad de obtener nuestras propias soluciones a problemas propios y locales. Procesar la señal de voz para obtener un vector de observación formado por las características principales de la señal. Simulación en software del sistema de reconocimiento de voz.1i y MATLAB 7.OBJETIVO GENERAL Y OBJETIVOS ESPECÍFICOS Objetivo General Se pretende como objetivo general de grupo. Permitiendo de esta manera crear una línea de investigación. donde el principal aporte es pasar del concepto al sistema físico.1. . usando los sistemas FPGA y recursos disponibles. ser pioneros en la implementación hardware de sistemas RNA. 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. utilizando. permitiendo de esta manera abrir el nodo para las investigaciones más elaboradas en el procesamiento digital de señales con técnicas avanzadas. ISE 8. System Generator 8.

DEDICATORIA A mis padres: Arturo Briceño y María Sarmiento A mis hermanas: Verónica. Talía y Tamara .

Carlos Carrión. por su comprensión. cariño y confianza. mi apoyo y mi guía. A mis padres por su amor.AGRADECIMIENTOS Agradezco primeramente a Dios. quien es parte importante de mi vida. por la formación recibida en los 5 años de formación profesional. a mis hermanas por su compañía y confianza. confianza. que ha sido mi pilar fundamental. y a los docentes de la Escuela de Electrónica y Telecomunicaciones. esfuerzo. Al Ing. A Christian. por enseñarme con su ejemplo los más grandes valores y luchar por mis ideales. director de tesis. . apoyo.

........... 26 4................................................. 26 4.........................................2 Historia .................3 Función Sigmoidal ......................................................................... 24 Capítulo IV: Diseño Sistema de Reconocimiento de Patrones de Voz .................. II Introducción .....................1 Introducción.......................... 27 .................................................................................................................... VII Contenidos ................................................................................................ VIII Lista de Figuras ......................................................... 7 2....1 Introducción...................1 Función Hardlim ............................................................................................................................. 6 2..................................................2 Tratamiento ........................................................................ 11 2........................................... 1 1........... 6 2....2.....................2 Metodología ......................................................................................................................................................................... 23 3.....2 Elementos de una Neurona Artificial.........1 Problemática ............. 23 3.3.......................................1 Metodología ........................................................................................................................... 7 2....... 15 Capítulo III: Reconocimiento de la Voz .....................................2............................................... 2 1. 26 4....................................................... 23 3................5 Red Neuronal para el Reconocimiento de dígitos de un Display de Siete Segmentos ............... 6 2................................. I Declaración de Autoría del Tema de Tesis .3....................................... X Lista de Tablas ........................................................................................................................................................1 Adquisición ..............4 Aritmética .......................................................................................................................2 Adquisición y Tratamiento de Muestras ........................................................... 2 1............................................ 3 Capítulo II: Implementación de Redes Neuronales Artificiales ........................................................................................................................................................................................... 14 2.......................................................................................4 Unidad Neuronal .....................3 Funciones de Transferencia ................................3...............................................................................................................................................................................3 Paralelismo en Redes Neuronales ..................... VI Agradecimientos .........2 Función Hardlims ..... XIII Capítulo I: Aspectos Generales............. V Dedicatoria............................................................................................................................................................................................ III Objetivo General y Objetivos Específicos ....... 9 2................................................................. 1 1................................................................................... 26 4..............................................................CONTENIDO Declaración de Cesión de Derechos ................................................3 Razones por la que las RNA son la Mejor Solución ..........

.. 39 Capítulo VI: Resultados .......... 52 6..........3................................ 29 4....................................3 Simulación e Implementación Reconocedor de Dígitos 7 Segmentos .................. 74 ........................................................................................................................................................4 RNA Propuesta para el Reconocedor de Patrones de Voz ...............................................................................................2......................... 34 5.........2 Función Sigmoid Definida a Trozos ...................................................................................................................................1 Recursos Obtenidos de la función Hardlim ..............................................................1 Simulación ....2 Recursos y Resultados Obtenidos de la función sigmoid .........2 Obtención y Tratamiento de la Señal de Voz ......................................................... 44 6....................................................4 Resultados Extracción Parámetros Característicos ....................4...................................................... 72 Referencias .................................................2 Implementación ........................... 73 Anexos ............ 69 7............................................... 34 5................................................... 28 4..1 Obtención de la Señal de Voz ..............3 Extracción de Características de la Señal de Voz ....................1 Conclusiones ...................................................................................................3...............2 Recomendaciones .................1 Arquitectura de la Red .......................................... 52 6...............................................1 Introducción......................... 64 Capítulo VII: Conclusiones y Recomendaciones .................................................................................................................... 28 4........... 30 Capítulo V: Implementación del Sistema de Reconocimiento de Voz .......... 45 6........... 34 5...........................................................2.....................2 Entrenamiento . 45 6..................... 69 7........... 58 6.............4...4.................................................4 Arquitectura y Entrenamiento de la Red Neuronal Artificial .................................2..................................................................................1 Funció Sigmoid ROM .......... 37 5...........2...........................................3 Obtención Parámetros Característicos ................. 47 6........................ 36 5.................. 54 6............2 Obtención Señal Útil ................... 44 6....................................................... 35 5...........5 Resultados Algoritmo Backpropagation ..

...........................................................1 Representación de Datos Punto Fijo Binaria Complemento a Dos .22 Lógica de Control Salidas RNA ......5 Función Hardlim ..............................21 Controlador Display .24 Sistema de Reconocimiento de Dígitos de 7 Segmentos .... 20 Figura 2............. 13 Figura 2....17 Utilización Herramienta nntool de MATLAB para Cálculo de Pesos y Bias ...............................................23 Divisor de Frecuencia ..............13 Neurona Desarrollada en Sysgen .................................. 12 Figura 2........15 Neurona de 4 Entradas y Función Hardlim ................ 21 Figura 2............................................................. 19 Figura 2..............................3 Función Hardlim . 21 Figura 2....................... 11 Figura 2.........Hardlims .........4 Función Hardlim con M-Code ....................18 Error en Función del Número Épocas de Entrenamiento ........................................................ 14 Figura 2...16 RNA de 7 Entradas y 4 Neuronas..19 Almacenamiento de Pesos ................................................................................................................................................................................ 18 Figura 2.... 12 Figura 2..................................................8 Resource Estimator F...............................................................................10 Función Sigmoidal ROM en System Generator ........... 16 Figura 2....... 14 Figura 2.................... 8 Figura 2.. 4 Figura 2....LISTA DE FIGURAS Figura 1............................................................ 9 Figura 2...................... 22 ....... 10 Figura 2......14 Esquema Completo de la Neurona en Sysgen ........................................................11 Configuración de la ROM .................................................... 9 Figura 2........9 Función Sigmoidal ............................................................ 21 Figura 2.................................................................12 Bloque Función Sigmoid por Función Definida a Trozos .....................................20 Codificador BCD a 7 Segmentos ..............................................................................................7 Función Fardlims en System Generator ........................................... 20 Figura 2............. 7 Figura 2.................................................................................................................... 7 Figura 2......................... 15 Figura 2..... 10 Figura 2................2 Neurona .................................................6 Función Hardlims ...................................

.................. 42 Figura 5........................... 40 Figura 5................................ 47 Figura 6..................................42 Bloque F_sig por Función Definida a Trozos ........................................ B) para una velocidad de aprendizaje alta......31 RNA Propuesta para el Reconocimiento de Patrones de Voz .........................................................30 Interfaz GUI para Extracción de Características LPC y FFT ....... 49 Figura 6........................Figura 4....................... Hardlim 2 ........ 33 Figura 5.. 46 Figura 6...........................................................47 Simulación del Sistema de Reconocimiento ................ 50 Figura 6.......48 Co-Simulación del Sistema Reconocedor de Dígitos ... C) para una velocidad de aprendizaje alta pero adicionándole termino de momento ................... 44 Figura 6....................................................................29 Interfaz GUI para Obtención de Señal de Voz .34 Determinación en Cada Unidad de la Capa Oculta.............. 43 Figura 5...................... 26 Figura 4...........................27 Arquitectura de la Red Elegida para el Sistema de Reconocimiento de Voz .........32 Neuronas Capa Oculta y Capa de Salida ............................. 49 Figura 6...........................41 Recursos Estimados de Hardware para el Bloque Sigmoid_ROM .............. 29 Figura 4....... 56 .............36 RNA 3 Capas con Algoritmo Backpropagation .....................39 Comparación de resultados bloque Sigmoid_ROM con Simulink .... 38 Figura 5.............. F_Sig y Logsig ...................... 44 Figura 6..40 Resultados Sigmoid_ROM vs Logsig ...... 54 Figura 6.................................................. Hardlim 1 ...37 Recursos Estimados F.... 35 Figura 5............26 Filtro de Primer Orden .43 Resultado F_Sig vs Logsig .......................33 Actualización Pesos Capa de Salida y Obtención de Fracción de Error a Propagarse en la Capa Oculta ............................................... 45 Figura 6...................28 Espacio de generalización.................44 Recursos Estimados de Hardware para el Bloque F_Sig ..................................... A) para una velocidad de aprendizaje baja............25 Procesos del Sistema ........ 43 Figura 6...................38 Recursos Estimados F...........................................................46 Interfaz Gráfica de Usuario para Ingreso de Datos a la RNA ............ 42 Figura 5................................................................. 48 Figura 6.... 27 Figura 4..35 Actualización de los Pesos de la Capa Oculta .45 Comparación de resultados bloques Sig_ROM........... 53 Figura 6... se pueden observar las oscilaciones...... 41 Figura 5......

...................................................50 Resultado para Ingreso de Dígitos Parcialmente Incompletos ................................................52 Recursos Estimados de Hardware para el Sistema de Reconocimiento de Dígitos ............... 57 Figura 6....................60 Salida de las Neuronas de Salida para = 0.....Figura 6...........58 Patrones FFT para las Palabras Luces y Aire.........49 Resultado en FPGA Spartan III para los Números 3 y 5 ..59 Salida Deseada y Disminución del Error para Figura 6................... 62 Figura 6.. 67 Figura 6...... 67 .. 56 Figura 6........... 61 Figura 6...............56 Patrones Característicos LPC para la Palabra Aire ................ =0..............................8............................... 59 Figura 6. 65 Figura 6.. 60 Figura 6.........63 Variación de los pesos Capa Oculta hasta Adaptarse .............................55 Patrones Característicos LPC para la Palabra Luces ........... =0........62 Salida Deseada y disminución del Error para = 1...........5 ................... 64 Figura 6.............. 63 Figura 6.53 Patrones Característicos FFT para la Palabra Luces.............................. 66 Figura 6.....................8.........61 Salida de la RNA con Backpropagation .................. = 0....... 58 Figura 6.....57 Patrones LPC para las Palabras Luces y Aire ...................3 ................. 65 =0..........51 Resultado para Ingreso de Dígitos con Error ................................................ 57 Figura 6.....5 ......54 Patrones Característicos FFT para la Palabra Aire .......

........... 54 Tabla 6.................................6 Resultado de la Simulación .............1 Resultado Resourse Estimator Función Hardlim 1 y 2 .............. 46 Tabla 6.5 Representación de dígitos en código BCD y siete segmentos ................. 48 Tabla 6........................................................ 52 Tabla 6.... 54 ................2 Resultado bloque Sigmoid_ROM y Logsig de Simulink ...........................3 Resultado bloque F_Sig y Logsig de Simulink .......LISTA DE TABLAS Tabla 6.......4 Comparación recursos de hardware función sigmoid .................. 45 Tabla 6..............

Las redes neuronales artificiales durante este periodo han desarrollado una gran importancia sobre todo en el reconocimiento de patrones. Paralelo. teniéndose así características como: Robustez y tolerancia a fallas. como es el problema planteado para esta tesis basado en el reconocimiento de patrones [1]. pequeño y compacto. Se compone de un gran número de elementos interconectados llamados neuronas que trabajan en conjunto para resolver problemas específicos. ya que es relevante el desarrollarlas. Una Red Neuronal Artificial (RNA) es un modelo de procesamiento de información inspirado en el funcionamiento del sistema nervioso biológico. Flexible y tienen capacidad de aprendizaje. 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.CAPITULO I ASPECTOS GENERALES 1. En este sentido. la habilidad de aprender tanto en ambientes supervisados como no supervisados. . razón por la que se las utilizará en la presente tesis. La naturaleza no lineal de las redes neuronales. debido a que poseen muchas características que sobrepasan los sistemas computacionales clásicos. Manejan información difusa. se intenta aportar al tema de implementación en Hardware de Redes Neuronales. y de cómo el cerebro procesa la información.1 Introducción La teoría y diseño de las redes neuronales artificiales han avanzado significativamente durante los últimos 20 años [1].

En general salvo las redes de un tamaño trivial. especialmente si se aprovecha del paralelismo inherente. y esto. implica algún proceso secuencial.1. Por otro lado. Hay mucho que ganar de la implementación de RNA en hardware. La falta de éxito se le atribuyó al hecho de que el trabajo se baso. En este nivel el paralelismo es usualmente medio. que no se desarrolló suficientemente o competitivamente para justificar la adopción de esta gran potencia. . 1 Neuroprocesadores: Dispositivo con capacidad de cálculo paralelo. la implementación full paralela en hardware es no factible un paralelismo virtual es necesario. pero la mayoría terminaron en fracasos. y puede ser casi totalmente asignado hacia actuales FPGAs. pero sin costos indebidos. diseñado para la implementación de redes artificiales. el campo entero estaba principalmente moribundo a fines de los años noventa. puesto que los arreglos de compuertas no fueron lo suficientemente grandes ni lo suficientemente rápidos para desarrollar aplicaciones de redes neuronales complejas [2]. 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. se invirtió mucho esfuerzo tanto industrial como académico en el diseño e implementación de neuroprocesadores1 en hardware. Los tipos específicos de paralelismo son como siguen: Paralelismo de Entrenamiento: Diferentes sesiones de entrenamiento pueden correr en paralelo. tempranamente sobre la tecnología ASIC.3 Paralelismo en Redes Neuronales [2] Las redes neuronales presenta varios tipos de paralelismo. 1. de hecho. en su mayoría.2 Historia En los años 1980s y 1990s. 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.

dependiendo del el costo deseado: la razón de desempeño. le corresponde a neuronas individuales. dependiendo del diseño de las unidades individuales funcionales. como a los niveles más altos. No obstante. Por ejemplo. donde para una FPGA el costo puede ser medido en términos de número de CLBs. El paralelismo en este nivel es típicamente bajo. diferentes capas pueden ser procesadas en paralelo. por ejemplo la velocidad lenta de una sola unidad puede equilibrarse teniendo muchas unidades operando concurrentemente. por ejemplo las requeridas interconexiones pueden ser problemáticas. desde el número de neuronas que puede ser tan alto como en millones.Paralelismo de Capa: En una red multicapa. 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. este es quizás el nivel más importante de paralelismo. Pero esto no es posible. Segundo. pero esto puede explotarse a través del pipelining2. que totalmente se aprovecha. Paralelismo de Nodo: Este nivel. los diferentes tipos de paralelismo pueden tratarse hacia otros. Y tercero no todos los tipos de paralelismo son convenientes para implementaciones en FPGA. palabra paralela. 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. etc. el paralelismo disponible a los diferentes niveles varia enormemente. o la explotación del paralelismo a nivel de bit puede reprimirse por el diseño del dispositivo o simplemente no es apropiado. y por consiguiente el valor limitado. Paralelismo de nivel de bit: En el nivel de aplicación hay una amplia variedad de paralelismo está disponible. el paralelismo del nodo empareja muy bien FPGAs. paralela sucesiva. serie de bits. Tres cosas son evidentes en el contexto de una implementación: Primero.

excepto la sigmoid que es compleja. implementación de funciones de transferencia. El bit más significativo (MSB) es el de mas a la izquierda. ceros o unos). De hecho.1. [2] De estos. la función de activación sigmoid será un factor limitante en el desempeño. Las funciones de activación. se tiene la facilidad de implementación de multiplicaciones y sumas. por lo que se debería tener muy en cuenta este punto. Es representado por bw1. Una representación de una señal punto fijo binaria complemento a dos es [3]: Figura. 1. cálculos de productos internos. los más importantes son el producto interno y las funciones de transferencia que activan las neuronas. y la naturaleza de algoritmos de aprendizaje. sin tener el suficiente cuidado. almacenamiento y actualización de pesos. Longitud de la palabra. Las entradas y salidas (In/Out). . en bits es dado por w. Representación de Datos: Las representaciones normales de las señales son generalmente basadas en complemento a dos. aunque no son un problema aritmético.4 Aritmética Hay muchos aspectos del cálculo aritmético que necesitan ser considerados en el diseño de neuro-elementos.1 Representación de datos punto fijo binaria complemento a dos [3] Donde: bi es el dígito binario (bits. también es importante asegurar que las unidades aritméticas puedan ser proporcionadas con entradas a la velocidad apropiada. esto último es muy importante y de mucha complejidad. estos aspectos incluyen la representación de datos.

es más práctico usar RAM-Distribuidas. el bloque RAM no puede ser suficiente. Para redes grandes. debe de usarse la precisión mas baja. Si la red es suficientemente grande. La longitud del fragmento. por consiguiente se usa el bloque-RAM. la memoria RAM distribuida es muy pequeña para sostener la mayoría de los datos a procesarse. sobre todo para almacenar los pesos.El bit menos significativo (LSB) es el bit de más a la derecha. entradas/salidas: 7 Para este propósito. y los datos tienen que ser cargados periódicamente dentro y recuperados del dispositivo FPGA. debido a las consideraciones de desempeño (performance) o costo. f es la distancia desde el LBS al punto binario. y el número de pins del dispositivo. . Almacenamiento y actualización de pesos. como bastante bueno. Cálculo de sumas de productos: Un problema es el cómo obtener datos de entrada y salida a la velocidad apropiada. En este caso. Según estudios se tiene establecido 16 bits para pesos y 8 bits para la entrada de la función de activación. Para redes muy pequeñas. la organización de entradas y salidas es critica. Los valores de entrada son guardados en un solo bloque y simultáneamente leídos fuera (como la RAM dualported). [2] Con este conocimiento. Representado por b0. esto basado en un análisis numérico cuidadoso. disponibles para entrada y salida (In/Out) se vuelve un problema. el aspecto crítico está entonces cuando. entonces la mayoría de las entradas a las unidades aritméticas serán guardadas fuera del dispositivo.

3 4 Hardlim: Función de transferencia lineal que limita la salida entre 0 y 1.Capitulo II IMPLEMENTACIÓN DE REDES NEURONALES 2. 5 Sigmoid: función de transferencia no lineal que limita la salida entre 0 y 1. Hardlims: Función de transferencia lineal que limita la salida entre -1 y 1. Para cada elemento es necesario.1 Introducción Antes de desarrollar una Red Neuronal Artificial para una aplicación específica. se desarrolla detalladamente la implementación de todos los elementos que son parte de la RNA como es la unidad básica. como lo son la hardlim3. para determinar su eficacia así como también es necesario determinar los recursos que utilizarán en hardware para su implementación.2 Neurona Las entradas Xi.2 Elementos de una Neurona Artificial Una red neuronal se encuentra formada por varias unidades neuronales. unidades de procesamiento o neuronas que se interconectan entre si formando una red. que es una neurona tipo perceptron.2. una vez desarrollado. 2. comparar los resultados obtenidos. Esta unidad de procesamiento esta formada por: Figura. como en el caso de esta tesis. que son los datos o señales que ingresan a la neurona. . hardlims4 y sigmoid5. y las funciones de transferencia más importantes por ser las más utilizadas. celdas.

3 Funciones de Transferencia 2. Entrada de tendencia definida como un número que indica a partir de que valor del potencial la neurona produce una salida significativa. 2.2c) 2.3 Función Hardlim (2.- Bias b. la salida de la red es cero. 1 si n ≥ 0 a= 0 si n < 0 Figura. (Ver funciones de transferencia Anexo B). Estos valores resultantes de las multiplicaciones son sumados formando una señal resultante n. Con esta función se crea neuronas que clasifican los valores de entradas en dos clases diferentes.1) i =1 N - La función de transferencia f. [7] Los pesos Wi.. - n = ∑ Wi X i (2. Es la que se le aplica a la señal resultante (n).. 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].1 Función Hardlim En la figura 2. y la salida será uno si el argumento es mayor o igual a cero [9].2a) (2. si el argumento de la función es menor que cero.3) . y = f i (n i ) y = f (∑ Wi X i + b) i =1 n (2.2b) y = f ( w11 X 11 + w12 X 12 + .3. La función de transferencia nos entrega un valor de acuerdo a la función de activación que se escoja.w1n X 1n + b) (2. se observa la función de transferencia hardlim. que son la intensidad de la sinapsis que conecta la entrada con la neurona o entre dos neuronas.3.

Figura. formando la salida n. es la suma total de las entradas a la neurona por su respectiva matriz de pesos. como se puede observar: %Función de transferencia Hardlim. bias.Desarrollada en System Generator.2. valor de entrada. Donde: sums. La primera forma de desarrollar la función hardlim es a través del bloque MCode. . 2. que se suma al valor de las entradas multiplicadas por los pesos. ganancia b de la neurona. el mismo que nos permite describir su funcionamiento en MATLAB (archivo m-file).4.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. la función hardlim es muy fácil y se la puede desarrollar de dos maneras. ecuiación (2. la herramienta System Generator convierte el código m-file de MATLAB a código VHDL para poder ser implementada. bias) sums1= sums + bias if sums1 >= 0 ft1 = 1 else ft1 = 0 end FT=ft1. Fig. valor de entrada.3) function [FT] = Fhardlim(sums. pero para la implementación en la FPGA.

Para esto se utiliza la herramienta Resourse Estimator.4) FT.6 Función Hardlims (2.1 p1 + w1. FT = f ( w1.n = w1.3. 2.3). Los resultados se encuentran en el capitulo VI.2.  1 si n ≥ 0 a= − 1 si n < 0 Figura. R p R + b (2. + w1. 2 p 2 + . R p R + b) (2.6) .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. De igual manera se lo realiza fácilmente.1 p1 + w1.. Figura. se describe según la expresión III. con unos cuantos bloques: un sumador..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. 2. 2. un comparador y dos constantes. + w1. que estima rápidamente los recursos requeridos por la FPGA para implementar el modelo. según la ecuación (2.5) La segunda forma de desarrollar la función hardlim es utilizando los bloques proporcionados por Sysgen.3. Valor de salida.. 2 p 2 + ..

Figura.ft1).Hardlims . cuyas líneas de código son: %Función de transferencia Hardlims function [FT] = Fhardlims(sums. 0}. 2. 2. FIGURA. bias) sums1= sums + bias if sums1 >= 0 ft1 = 1 else ft1 = -1 end FT = xfix({xlSigned. 3.8 se observa la cantidad de recursos necesarios para la implementación de la función hardlims.7 FUNCIÓN HARDLIMS EN SYSTEM GENERATOR En la figura 2.8 Resource Estimator F.7.El desarrollo en System Generator de la función hardlims es realizada con el bloque M-Code. figura 2.

los cuales pueden oscilar entre más y menos infinito. que apunta a valores discretos y entre sus intervalos existe un margen de error. y restringe la salida a valores entre cero y uno [9].9 Función Sigmoidal Muchas de las mejores técnicas desarrolladas en análisis numérico para determinar la función sigmoid y que. por ejemplo. y como la memoria ROM acepta a su entrada solo valores sin signo y punto binario igual a cero. 2. 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. 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. Bloques ROM: Las ventajas de utilizar los bloques de memoria ROM es que.3. figura 2. .7) Figura. 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. exitosamente se las utiliza en software.3 Función Sigmoidal Esta función toma los valores de entrada. donde se inicializan usando los comandos de funciones de transferencias que nos proporciona el Neural Network Toolbox y por medio de aproximaciones lineales. según la expresión: a= 1 1 + e −n (2.2.9. Para realizar funciones no lineales en este trabajo se procede de 2 maneras. para datos de entrada que se requiere. Entre las desventajas se tiene. no son eficaces ni fáciles de desarrollar en hardware puesto que se utiliza funciones exponenciales. las funciones se desarrollan en forma de tablas almacenadas en bloques ROM. donde n es el número de bits de entrada [2].

Figura. sigmoidal.10 . Ver figura 2.8)6. se observa la memoria ROM que trabaja como función de transferencia no lineal. Para esto se determinó la ecuación (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.11. expresando así una función lineal a trozos. 2.figura 2. basada en aproximaciones de la ecuación (2.10 Función Sigmoidal_ROM en System Generator En la figura 2. 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. 6 Autor . 2.10.Figura.7).

5 si 3.8 < x < 1.9509  1  si x < −2 si − 2 ≤ x < −1 si − 1 ≤ x < 0 si x = 0 si 0 < x ≤ 0.12 se observa el desarrollo de la ecuación (2.0 0.8 si 0.5 < x ≤ 3.8779 0.1572   0.5 si 1. un concatenador y un bloque M-Code para la elección del resultado dependiendo de su entrada que es la salida del concatenador.3340  1 / 2  f ( x) = 0. (Ver código en anexo A).5 si 2.12 Bloque Función Sigmoid por función definida a trozos . 2.5 ≤ x ≤ 2.8) en Sysgen en la que se a utilizado bloques lógicos.7356  0.5 < x (2. relacionales.8) En la figura 2.5734 0. Figura.

15 en la que se tiene una neurona de 4 entradas.14 se presenta la neurona completa en la que previamente se han almacenado los pesos en los bloques constant. formado por un bloque M-Code.13 Neurona desarrollada en Sysgen En la figura 2.14 Esquema completo de la neurona en Sysgen Según se requiera mayor número de entradas. Como se lo puede apreciar en la figura 2. 2. 2.13 se observa una neurona de dos entradas y que utiliza la función hardlim. sumadores y la función de transferencia con que deseamos que trabaje la neurona.2. Figura. . 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. En la figura 2.4 Unidad Neuronal Aquí se procede a desarrollar la neurona artificial en Sysgen. Figura. utilizando bloques multiplicadores. se agregan multiplicadores en paralelo y en igual forma se agregan sumadores en cascada.

2. que son los 7 segmentos de display.Figura. La RNA a utilizarse consta de 7 entradas. utilizando 7 switches de la SPARTAN III. de entradas y función de transferencia deseada. en una FPGA Spartan III XC3S200. se puede desarrollar una RNA utilizándola tantas veces como el diseño lo requiera. que serán los 7 segmentos del display. El sistema consiste en introducir un dígito. siendo capaz de determinar el número ingresado a pesar de que el número este parcialmente incompleto.5 Red Neuronal para el Reconocimiento de Dígitos de un Display de Siete Segmentos. tiene una capa y consta de 4 neuronas tipo perceptron para obtener las 4 salidas . Para validar la neurona que se ha desarrollado. La RNA tendrá que reconocer los dígitos. en una RNA. del 0 al 9. 2. 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.15 Neurona de 4 Entradas y Función Hardlim Una vez que se tiene la neurona.

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. . Figura.16 RNA de 7 entradas y 4 neuronas En la figura 2. 2.necesarias de la red que muestran el dígito resultante en código BCD y podrá ser visualizado por medio de 4 leds. 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.16.2. en la que cada neurona posee 7 entradas y obtenemos un valor de salida. se observa la RNA. 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.

Matriz salidas deseadas 0  1 . la matriz de entrada (X) y la matriz de target (t) o salidas deseadas como sigue:      X =      0 1 0 0 0 0 0 1 0 1 0 1 1 1 0 0 1 0 0 1 0 0 0 0 0 1 1 0 1 0 0 1 1 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0  0 0  0 0  . (2.11) bnuevo = banterior + e Para el entrenamiento de la RNA para reconocer los 10 dígitos se determina primeramente. entonces Wnuevo = Wanterior Así mismo se procede a encontrar los nuevos valores de los bias (b) o ganancias.10) Wnuevo = Wanterior + (t − a) X Por lo tanto: Si e = 1 .9) (2. entonces Wnuevo = Wanterior + X Wnuevo = Wanterior − X Si e = −1 . entonces Si e = 0 .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. Matriz de Entrada 0 1  0 0 0 0    t=    0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 1 0 1 0 0 0 0 1 1 1 1 0 0 1 1 0 1 0 1 0 1 0  .

2). (2. y construir la red neuronal que se requiere. 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.9). escoger el tipo de entrenamiento.Utilizando las ecuaciones (2. que es una red de una capa y 4 neuronas tipo perceptron con función hardlim.17 Utilización herramienta nntool de MATLAB para cálculo de pesos y bias . Figura. (2.10) y (2. que utiliza las ecuaciones ya descritas para este caso. Ver figura 2.17. 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. que será learnp.

2  4 0 7 0 -2 3   .1    . Matriz de bias .18. Figura.2 W = . 2.Al pulsar el botón train. se necesitó 16 epochs o épocas de entrenamiento hasta llegar a un error de cero. tal como lo podemos visualizar en la figura 2.2  b =   . y obtenemos las siguientes matrices: . se realizan los cálculos de los nuevos valores de pesos y bias. Matriz de Pesos 1 1 0 -1 2 0   1 -1 0 2 1 0   1 .2  Para encontrar los valores de pesos y bias.1 .2 .1  . que inicialmente tenían valor de cero.1 .2 -1 -1 0 .18 Error en función del número de épocas de entrenamiento .

para los que la RNA reconocerá los dígitos. para visualizar la salida de la red en un display. 2. que serían los 7 segmentos del display.20 Codificador BCD a 7 Segmentos . los valores son almacenados en bloques constant de Sysgen (figura 2. en adición a la visualización del resultado en los 4 leds. para luego realizar la simulación de la red ingresando 7 valores (binarios). Figura.19). y que la red reconocerá presentando los resultados en código BCD.19 Almacenamiento de pesos Como se dijo además de la RNA. Figura. Consta de un bloque M-Code (Ver código en Anexo C) y un bloque de concatenación de 7 entradas.20. 2. Ver figura 2. el sistema esta formado por otros elementos como son: Un decodificador de BCD a 7 segmentos.Una vez obtenidos los valores de pesos y bias.

23 se observa el desarrollo de los bloques de control y divisor de frecuencia.23 Divisor de Frecuencia . 2. Figura 2.21 Figura.22 Lógica de control salidas RNA Figura. es de 50 MHZ y a través del divisor de frecuencia se obtiene una frecuencia en el orden de los KHZ. 2. Inicialmente la frecuencia con la que trabaja la FPGA Spartan III XC3S200. así como también el ánodo del display que deseamos utilizar para mostrar el resultado. lo suficiente para multiplexar la entrada a la RNA como la salida. respectivamente. que controla los datos que se visualizarán en el display.21 Controlador display En las figuras 2.- Un bloque de control. Figura. 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.22 y 2. 2.

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

El tono óptimo o más adecuado para el habla. pero las consonantes introducen armónicos cuyas frecuencias van hasta 5000Hz.Capítulo III Reconocimiento De La Voz 3. se procedió a tratar de especificar soluciones usando una red neuronal artificial perceptron multicapa con propagación hacia atrás. depende de cada individuo y está determinado por la anatomía de las cuerdas vocales. o el que tiene que funcionar en un coche o en una fabrica. al igual que su rango de variación. La Gramática o Hay un gran número de palabras diferentes que debe reconocer el sistema. Se tiene cuatro factores que determinan la complejidad del Reconocimiento del habla: El Locutor o Una persona no pronuncia siempre de la misma forma. 3. 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.2 Metodología Los principales problemas del reconocimiento de voz son: el reconocimiento del tipo de voz y los distintos significados de las palabras. El Entorno físico o No es lo mismo un sistema que funciona en un ambiente poco ruidoso.1 Problemática [10] La voz se define en cuanto a su tono. resonancia e intensidad. Mientras mayor es el número de palabras más difícil es el reconocedor. difieren en la forma de hablar. Por lo que en esta investigación. La voz hablada se ubica entre 100Hz y 160Hz para el hombre y para la mujer entre 200Hz y 320Hz. es muy posible .

pero no son capaces de entender el significado de las formas visuales o de distinguir entre distintas clases de objetos. y muy utilizada en el desarrollo de redes Backpropagation. como ya lo vimos en el capitulo anterior. se basa en la presentación sucesiva y de forma repetida. [11] El entrenamiento de estas redes. Una operación aritmética importante que se requiere para redes neuronales es el cómputo de las funciones de activación. . sigmoidal y de tener una topología feedforward de una o más capas. en la creación. en el procesamiento de textos.que esta sea uno de los elementos apropiados para encontrar una solución correcta. en comunicaciones electrónicas. usando el procedimiento de gradient-descent. Así para cada vector de entrada la red producirá un valor de salida más similar al vector de salida esperado. pero esto se equiparará en las actuales FPGAs con altas velocidades de implementación y mayores recursos que estas ofrecen. manipulación y mantenimiento de bases de datos.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. La red crea un modelo a base de ajustar sus pesos en función de los vectores de entrenamiento. [12] 3. Estos sistemas son secuenciales y son exitosos en la resolución de problemas matemáticos. tener funciones de transferencia tipo hardlim. tiene la característica de tener un aprendizaje supervisado. La red tipo perceptrón es una de las redes más sencillas pero de las más utilizadas. a través de la minimización de la función de error. La función sigmoidal es la función de activación más penetrante y biológicamente creíble [2]. de pares de vectores en las capas de entrada y salida (vectores entrada y salida deseada). hardlims. La estructura de la FPGA limita de cierto modo que estas funciones se lleven a cabo a un costo razonable. usualmente el error cuadrado entre la señal de la salida deseada y la salida de la red neuronal. gráficos y auto edición. pero no poseen la capacidad de interpretar lo que les rodea. siendo eficientes y fáciles de usar.

distribuida sobre la red y procesada en una gran cantidad de neuronas en paralelo. Flexible. se ajusta a nuevos ambientes por aprendizaje. Maneja información difusa.Debido a este problema de los sistemas de cómputos secuenciales. desarrollados por Von Neuman. el resultado es el estado de la red para el cual se logró equilibrio. cuando la información procesada involucra una gran cantidad de neuronas y conexiones. se ha desarrollado nuevos sistemas de procesamiento de información como las Redes Neuronales Artificiales (RNA) [2]. hay mucho que ganar de la implementación de redes neuronales en hardware. Estas redes neuronales poseen características que sobrepasan algunas limitaciones en los sistemas computacionales clásicos [9]. La pérdida de unas neuronas o conexiones no afecta significativamente la conducta de la red. realizados por las redes neuronales biológicas del cerebro. Las RNA no ejecutan instrucciones. permitiendo así solucionar problemas como lo hace normalmente el cerebro humano. [9] Una gran mayoría de redes neuronales aún se implementan en software sobre maquinas secuenciales. sobre todo si se aprovecha del paralelismo de las redes neuronales pero sin elevar costos. respondiendo a nuevos modelos. Procesamiento en el cerebro es principalmente paralelo y distribuido La información es guardada en conexiones. El resultado no es almacenado en una posición de memoria. por los principios de cómputo. Las redes neuronales artificiales son modelos computacionales que son inspirados. el poder de la red está en su topología y en los valores de las conexiones (pesos) entre neuronas. Aunque esto no es una severa limitación. El conocimiento de una red neuronal no se almacena en instrucciones. 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 . responden en paralelo a las entradas de la red. Tienen la habilidad de aprender reglas describiendo datos de entrenamientos y de información anteriormente aprendida. El cerebro es adaptable desde el nacimiento hasta su muerte.

pero para nuestro propósito son ideales para el reconocimiento de patrones. .diversas. como lo son la de la voz.

de las palabras que se desea reconocer. 4. Figura. 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. 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. a la que se le presentará como entradas. etapa de extracción de características y por última etapa.2.12) Fn=2*Fw. la red neuronal. 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.Capitulo IV Diseño Sistema de Reconocimiento de Patrones de Voz 4.25 Procesos del Sistema 4. (4. 4. Figura 4.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).1 Metodología El sistema de reconocimiento de voz.25.2 Adquisición y tratamiento de muestras Primeramente se debe contar con un número determinado de señales de voz (patrones). un vector con un número determinado de características extraídas en la etapa previa. Fn>Fw .

Donde a=0. Donde a=0. Se debe tener en cuenta que la señal queda representada por un vector de valores reales de longitud (L): L = ( Fm * Tm ) 4.15) Figura. depende de la longitud de las palabras que se quieren que el sistema reconozca [13].2 Tratamiento (4. 4.13) 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. 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].14) f ( n ) = f ( n ) − a * f ( n − 1) . 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 . . a truncamientos y para aplanarla espectralmente.95 La ecuación diferencia será: ∧ (4.95 (4.Tiempo de Muestreo: (Tm) Este parámetro es el tiempo de duración que se quiere tomar de la señal.2.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.

54-0. 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). es decir.46*cos 2π t →  T w (t ) =  → 0  ( )  si -T ≤ t ≤ T  2 2  para el resto de la señal   (4. La ventana hamming se define como: 0.16) Después de aplicar la ventana de haming. la señal se divide en tramas y a cada trama se le reduce el efecto de discontinuidad al mínimo. 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. con lo que se genera matrices de entrada y también matrices de salidas o targets. que es el tipo de ventaneo más utilizado para el análisis de la voz [13]. estos representan el valor de salida en cada nodo de las redes neuronales. donde (n) es características máximas de un el número de patrón que representa el número de nodos de entrada de la red. propios de la señal. por lo tanto se aplica ventaneo. A estas señales se les extrae un conjunto de características o parámetros. las cuales sirven para el posterior entrenamiento de la red neuronal. esto que en el entrenamiento se debe presentar un valor de entrada asociado a un valor de salida deseado. son guardados en una matriz (características).4. al final de dicho proceso se tendrá: características(n). A medida que se van generando los valores de los parámetros por cada frame. minimizando el numero de nodos de entrada de las red neuronal. señales estables y suaves. Inicialmente antes de extraer los parámetros. de cada señal analizada.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. lo cual reduce la arquitectura de la red logrando unos tiempos de entrenamiento menores. . para el proyecto se utiliza la ventana de hamming.

primeramente se establece una topología de red neuronal. y la capa intermedia con numero de nodos establecidos por el usuario. Para que la red pueda aprender algo. [14] Se debe establecer el número de nodos en la capa intermedia de forma práctica.27 Arquitectura de la Red Elegida para el Sistema de Reconocimiento de Voz En este tipo de red perceptron multicapa. 4. una capa de entrada cuyo numero de nodos se establece al igual que los nodos de la capa de salida. con tres capas. A mayor cantidad de neuronas en la capa oculta. para completar la arquitectura de la red neuronal. ver figura 4. se implementó el algoritmo de BackPropagation.27 Figura. la red puede variar más rápido en respuesta a los cambios de la entrada. y además se utiliza como algoritmo de entrenamiento el backpropagation con momentum. . la cual tiene tres capas. el problema está en su entrenamiento debido a la dificultad de modificar correctamente los pesos de la capa oculta.4 Arquitectura y Entrenamiento de la Red Neuronal Para el entrenamiento.4. 4. debido a la relativa facilidad con la cual pueden ser adaptadas a diferentes tipos de problemas.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. perceptron multicapa.

...... 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. t2 .19) Ahora se verifica la salida de la última capa con la salida deseada para verificar el error en cada unidad. tq } (4.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. y n es el número de patrones de entrada. (4. x2 .3.20) .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. q es el número de patrones de salida. 4. xn } − {t1 .. La salida de la red en la capa de salida es: (4.18) Donde: es el peso que interconecta la unidad i de la entrada con la unidad j de la siguiente capa.. en caso de ser la primera capa este seria el patrón de entrada. { x1 . La salida de cada unidad en la primera capa e intermedias esta dada por la formula [9]. (V.17) Según la formula anterior.

25) . donde n es el número de pesos de la red. Al final se toma el error cuadrático de entrenamiento.23) Los términos de error para cada unidad en las capas ocultas son. primero para la capa de salida.θ ' s  ∑ w zji .21) Estos pasos se repiten para cada patrón del conjunto propuesto.22) Este error generado por la red neuronal se observa como un espacio n– dimensional. normalizado que es [9]. Ahora lo que se quiere es llegar lo más rápido posible hacia el mínimo absoluto de este espacio. (4.w zji j  i =1  j =1  m  q (4. la manera de lograrlo es seguir la dirección contraria del gradiente de la función del error [9]. por medio de.∑ ϕ sj .24) Después se procede a actualizar los pesos de la red. (4.viz −1   i =1  q   (4. ϕ z = θ ' z  ∑ w zji . 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. ϕ sj = ( d j − y j ) .El error en i-esimo patrón se define como la sumatoria de los errores en cada unidad de salida [9].viz −1  . (4. ahora los términos del error en la capa de salida son [9].

28) . Por lo general se escogen valores altos de para aumentar la velocidad de convergencia de la red.27) Es recomendable ir despacio con la velocidad del gradiente. Ahora esta velocidad se controla con la variable . que lo que hace es modificar el término del peso anterior en el cálculo del nuevo. (4. (4. Un método de evitar esa oscilación es introducir una nueva variable llamada momentum γ [9]. pero se tiende a caer en una oscilación infinita por no existir una amortiguación a velocidad excesiva. 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].26) La derivada de la función de transferencia (θ’) se puede definir como: Si Si Si (4.Donde la variable α se define como velocidad de aprendizaje. pues si va muy rápido se corre el riesgo de oscilar indefinidamente sin llegar al mínimo de error buscado. Ahora para las capas ocultas la actualización será [9]. y su valor varia entre 0 y 1.

A) para una velocidad de aprendizaje baja. El valor del momentum esta entre 0 y 1.28 muestra el comportamiento del momentum. . Repetir los pasos anteriores para todos los patrones hasta reducir el error a un valor elegido. que el entrenamiento haya alcanzado el error mínimo propuesto o haya terminado el número de épocas especificadas. se pueden observar las oscilaciones. ecuaciones 2. se podrá dar pasó a la segunda etapa del proyecto: etapa de reconocimiento o ejecución de la red neuronal artificial. es decir. 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. y entre menor sea el valor del momentum la oscilación tiende a disminuir.28. 4. B) para una velocidad de aprendizaje alta. C) para una velocidad de aprendizaje alta pero adicionándole termino de momento [13] La gráfica 4.2 • • Calcular el error mediante el algoritmo BackPropagation Determinar en qué dirección (+ o -) debe cambiarse los pesos para reducir el error. Dado que el aprendizaje es supervisado.Figura. • • • Determinar la cantidad en que es preciso cambiar cada peso. para los nodos de salida se conoce la respuesta esperada a cada entrada. Corregir los pesos de las conexiones. Espacio de generalización. Después de que las redes neuronales se encuentren entrenadas.

que es la segunda parte del sistema y en la que se implementa la red neuronal artificial en hardware.Capitulo V IMPLEMENTACIÓN SISTEMA RECONOCEDOR DE VOZ 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. Una vez que se ha obtenido un vector con los valores de los parámetros característicos de la señal.1 Introducción El desarrollo del sistema esta divido en dos partes.29. La extracción de características es desarrollada en MATLAB utilizando la Interfaz Gráfica de Usuario (GUI). 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. para luego ser leídos desde la plataforma Sytem Generator. y la segunda parte que es la RNA que sí está desarrollada con la herramienta de diseño de hardware Sysgen 8. es decir. debido a que desarrollarla en Sysgen. proporcionando un entorno vistoso al usuario.1. Primero describiremos la obtención de características de la señal de voz. 5. la misma que puede ser elegida entre los tipos de parámetros LCP (Linear Predicting Code) y FFT (Fast Fourier Transform). implica un mayor tiempo de realización y por otro lado no es el objeto de estudio de esta tesis. este es exportado a workspace de MATLAB. . la primera parte que es la extracción de características. que se desea que la red reconozca. utilizando una FPGA. se desarrolló en MATLAB 7.

2. y de cada trama obtenida extraer las .Figura. reproducción y limpieza de la pantalla. 5. Entonces para la obtención de la señal de voz se tiene: enventanada utilizando el tipo de ventana hamming.15 indicado en el capitulo 4. la que será tratada. descrito en la ecuación 4. el primero para la obtención de la señal.5 segundos.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. 5.2. que es de 11025 Hz. donde se graficará la señal que se ingresó mediante el micrófono. 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.29 Interfaz GUI para Obtención de Señal de Voz Se observa que existen dos conjuntos de opciones. ésta es muestreada y a través de un filtro de primer orden. se elimina el nivel de DC suavizando el espectro e inestabilidades en la manipulación de la señal para luego ser características. El segundo conjunto tiene 2 opciones para recortar la señal de voz cada uno con un método distintito.2. Una vez obtenida la grabación de la señal de voz útil.

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; señal AmplitudMinFin = 0.00009; MinCrucesCero = 4; TamTrama = 330; InicTrama = 4; señal FinTrama = 5; señal % Amplitud mínima al comienzo de % % % % Amplitud mínima Cruces por cero Tamaño de trama Número de trama al final de señal mínimo analizado de inicio de la

% Número de trama de final de la

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, 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; % Overlap = 221; % ValoresLpc = 15; % NumMuestras = length(Patron); NumTramas = floor(((NumMuestras Tamaño de trama, 30ms Incremento de trama Número de valores LPC - TamTrama) / Overlap) + 1);

la

codificación de voz conlleva un proceso básico de muestreo y cuantificación para

el número de nodos en la capa de salida es igual al número de palabras a reconocer. % Tamaño de Trama. 30ms Overlap = 221. de igual forma se determina inicialmente determinados valores. es el desarrollo de la Red Neuronal en System Generator. . 5.TamTrama) / Overlap) + 1). % Número de Tramas NumTramas = floor(((NumMuestras . estos pueden ir incrementando para resolver regiones más complejas. % Incremento de trama NumMuestras = length(Y1). donde Y1 es la señal de voz de la que se desea obtener los parámetros característicos: (Código completo. Como ya se dijo. 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. ver Anexo H) TamTrama = 332.Para obtener los parámetros FFT.4 RNA Propuesta para el Reconocedor de Patrones de Voz La segunda parte del sistema reconocedor de voz. Se decidió en un inicio determinar una arquitectura de red de 20 nodos de entrada. programa que nos permite posteriormente implementarla en la FPGA. la topología de la RNA es una red de 3 capas. En la figura 5. cuyos nodos de entrada es igual al número de patrones característicos de la señal. si son los deseados o no. 8 nodos en capa oculta y 2 nodos capa de salida que serian las palabras a reconocer. dependiendo de las palabras que se desea reconocer y del grado de complejidad en diferenciación.31 se observa la red propuesta desarrollada utilizando System Generator. los nodos de la capa oculta o intermedia varían según los resultados deseados en la red.

32. cada neurona posee un bloque de almacenamiento de pesos.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.Figura. . 5. 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. 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.

este valor es comparado con la señal de salida deseada utilizando la ecuación 4.19. 5.32 Neuronas Capa Oculta y Capa de Salida La RNA propuesta.2.24. 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.33.4. 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. Obtenida la señal de salida de toda la red. Una vez que se tiene los errores en cada capa se procede actualizar los pesos de cada capa utilizando las formulas 4.Figura. es solo la realización del algoritmo FeedFordward utilizando la ecuación 4.31.25-4. en la figura 5.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.20.28. .18-4. Figura 5.

33 Actualización Pesos Capa de Salida y Obtención de Fracción de Error a Propagarse en la Capa Oculta. 5. Figura.34 Determinación en Cada Unidad de la Capa Oculta . 5.Figura.

35 Actualización de los Pesos de la Capa Oculta Figura.36 RNA 3 Capas con Algoritmo Backpropagation Capitulo VI .Figura. 5. 5.

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.38. Hardlim 2 . Utilizando esta herramienta tenemos: Figura.RESULTADOS 6.37 y para el bloque hardlim 2 en la figura 6. Hardlim 1 Figura. 6. 6.37 Recursos Estimados F.38 Recursos Estimados F.

2 y figura 6. Tabla 6. y a través del bloque logsig de Simulink (figura 6. que representa la ecuación (2.1 Función Sigmoid ROM Obtenidos los resultados de la función Sigmoid. a través del bloque ROM.40.1 Tabla 6.7).1 Resultado Resourse Estimator Función Hardlim 1 y 2 Función de Transferencia Hardlim1 Hardlim2 Slices 1 5 LUTs 1 8 IOBs 5 5 6.39). necesita menos recursos de hardware. se puede observar de los resultados que existe un margen de error en determinados puntos (Fig. ya que obtenemos los resultados deseados y menos recursos de hardware. .2 Recursos y Resultados Obtenidos de la Función Sigmoid 6. que la función hardlim 2 que utiliza comparador y sumador. 6. Figura. para lo cual se utiliza el bloque logsig de Simulink. 6.Observando los resultados del bloque Resource Estimator se puede concluir que la función hardlim 1 que utiliza el bloque M-Code. con el bloque M-Code.39 Comparación de resultados bloque Sigmoid_ROM con Simulink En la tabla 6.2. De acuerdo al resultado es preferible utilizar la función de transferencia hardlim1.40) y además no se puede representar valores negativos como ya se dijo anteriormente. los mismos que se compararán con los valores deseados de la función. se observa los resultados del funcionamiento de la función sigmoidal al entregarle determinados valores.

8 4.0 -4.0000 1.0 Entrada punto fijo a F_sig -5.212100 0.0000 Salida Simulink 0.9531 0.0000 -1.8 -1.5 2.982000 0.943300 0.047430 0.8 -0.5000 0.859700 0.5 5.6 0.7344 0.3130 1.8 1.0 1.0000 4.622500 0.8130 -1.8750 0. 6.880800 0.3125 0.5000 0.500000 0.8130 3.9844 0.8125 -0.8130 2.8130 4.9844 0.2 Resultado bloque Sigmoid_ROM y Logsig de Simulink Entrada punto flotante -5.0000 -0.8750 0.5000 3.0000 3.5000 1.8 3.2 0 -6 -4 -2 0 2 4 6 8 Figura.5000 0.0000 -2.422500 0.9844 1.952600 0.0000 Salida Sig_ROM 0.993300 0.3 2.964900 0.0000 -4.5000 0.006693 0.3125 0.5000 0.0 -1.8750 0.140300 0.0 6.0 3.978400 0.5000 0.909900 0.5000 -0.5 -0.0 -3.5000 0.577500 0.40 Resultados Sigmoid_ROM vs Logsig .8 2.0000 1.0000 0.119200 0.997500 logsig & Sig_ROM 1.970700 0.7344 0.5 0.377500 0.0 0.0000 1.731100 0.3 3.8750 0.8125 1.0000 2.8 logsig Sig_ROM 0.5000 0.5 -1.4 0.9531 0.989000 0.5 1.5000 0.0 -2.787900 0.182400 0.307400 0.3130 -1.268900 0.0 -0.5000 0.Tabla 6.924100 0.2 1 0.017990 0.3 -1.692600 0.0000 6.5 3.5000 -1.3 0.9531 0.7344 0.9531 0.0 2.5000 2.5000 0.817600 0.0 4.3 0.3130 3.5000 5.5000 0.0000 -3.7344 0.5000 0.3130 2.5000 0.3 1.

43 comparados con los resultados obtenidos del bloque logsig de Simulink (Fig.2. A este bloque se lo denomina F_Sig. De los resultados. que los datos de salida tienen cierto margen de error con los valores de salida deseados ya que los resultados son una aproximación. sin dejar de lado la exactitud con lo que se requiere obtener resultados. los recursos de hardware son limitados y de estos depende mucho su elección. Figura. .En la figura 6. 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.41 Recursos Estimados de Hardware para el Bloque Sigmoid_ROM 6. El número de bits de entrada también afecta.42). 6.3. se tiene. pero se tiene resultados aproximados para valores negativos de entrada lo que no se obtiene por medio del bloque ROM.2 Función Sigmoid Definida a Trozos El resultado de la función sigmoid utilizando éste método. Resultado que debe tomarse muy en cuenta al momento de elegir entre un bloque u otro porque como ya se ha dicho. los mismos que se visualizan el la figura 6. se puede observar en la tabla 6. aumentando los recursos de hardware.

Figura.182400 0.690100 0.5 0.8750 0.0000 -1.0 Entrada punto fijo a F_sig -5.006693 0.5 -1.0 1.5000 3.9375 0.0000 2.5 1.5 3.8010 3.0 2.908900 0.0 3.9375 1.0000 4.8010 -1.5625 0.214000 0.0000 Salida Simulink 0.1563 0.5000 0.5 -0.3 0.3008 0.0 0.0000 -4.5000 -0.0000 -0.3281 0.574600 0.9375 0.0 -4.0000 1.3010 2.377500 0.858200 0.3 0.8010 2.0000 Salida bloque F_Sig 0.3010 1.3010 3.0 6.8750 0.989000 0.0000 1.3281 0.7344 0.5625 0.5 2.880800 0.0000 0.964500 0.0 -1.952600 0.9375 0.0000 3.141800 0.1563 0.3 3.3 2.8 4.0 -0.500000 0.3281 0.5000 2.978100 0.268900 0.8008 -0.8 1.1563 0.8010 4.997500 .047430 0.425400 0.1563 0.8008 1.3010 -1.5 5.942700 0.817600 0.0000 0.0 4.5000 1.786000 0.8750 0.8750 0.970700 0.8 2.0000 6.622500 0.5000 -1.309900 0.0000 0.3281 0.0 -3.8 -0.8 3.42 Bloque F_sig.7344 0.982000 0.0000 1. por función definida a trozos Tabla 6.0000 1.731100 0.3 Resultado bloque F_Sig y Logsig de Simulink Entrada punto flotante -5.3 -1.8750 0.0000 -3.8 -1.3008 0.5000 5.993300 0.7344 0.0000 1.0000 0.924100 0.0 -2.5000 0.0000 -2.017990 0.119200 0.3 1. 6.

2 0 -6 -4 -2 -0. el funcionamiento y el coste son muy importantes. .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.4 0.2 1 Sa lid a Sig m o id 0.6 0.8 0. 6.2 0 Valore s de e ntrada X 2 4 6 Logs ig F_Sig Figura. 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. Figura.F_Sig & Logsig 1.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). 6.43 Resultado F_Sig vs Logsig En la figura 6. ya que la exactitud.

Sig_ROM & F_Sig & Logsig
1,2 1 Salida Sigmoid 0,8 0,6 0,4 0,2 0 -6 -4 -2 -0,2 0 2 4 6 8 Sig_ROM F_Sig Logsig

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), 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]. mediante la expresión: Se calcula comparar el

  2 R =  
Donde:

1 N

∑ (H
i =1

C

(i ) − µ C )( H D (i ) − µ D )    σ C ×σ D  

2

(6.29)

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:

  2 R =   Para la función F_Sig:

1 N

∑ (H
i =1

C

(i ) − µC )( H D (i) − µ D )    = 0.82 σ C ×σ D  

2

  2 R =  

1 N

∑ (H
i =1

C

(i ) − µC )( H D (i) − µ D )    = 0.93 σ C ×σ D  

2

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

∑ (H
RMSE =
Para la función Sigmoid _ROM:
i =1

N

C

(i ) − H D (i)) 2 N
(6.30)

∑ (H
RMSE =
Para la función F_Sig:
i =1

N

C

(i ) − H D (i )) 2 N = 0.20

∑ (H
RMSE =
i =1

N

C

(i ) − H D (i )) 2 N = 0.04

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 Sigmoid Sig_ROM Sigmoid F_Sig Slices 23 69 FFs 12 15 LUTs 45 125 IOBs 20 16

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.5 donde se observa la representación de los dígitos en siete segmentos y código BCD.6 para los dígitos ingresados correctamente y para los que están parcialmente incompletos. 6. se abre inmediatamente el diseño de la red en Sysgen para iniciar la simulación.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.3.47.3 Simulación e Implementación Reconocedor Dígitos 7 Segmentos 6. De la simulación se tiene la siguiente la tabla de resultados Tabla 6. figura 6. por medio del botón Ir a Red. pero este tiempo es superado en la implementación como se comprueba más adelante. 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. . El resultado de la simulación es obtenido en 2 segundos. Figura.46. teniendo dos opciones para hacerlo. los siete valores binarios que conforman el display como se observa en la interfaz GUI de la figura 6. Como referencia se presenta la tabla 6.6.

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 Siete Segmentos 0000001 1001111 0010010 0000110 1001100 0100100 0100000 0001111 0000000 0000100 1000001 1100001 1010010 1110010 0010110 0010111 1001101 1001000 0101100 1101100 0110000 0101111 0010000 Salida de la RNA Siete Segmentos '0000001 1001111 0010010 0000110 1001100 0100100 0100000 0001111 0000000 0000100 0000001 0000001 0010010 0010010 0000110 0000110 1001100 1001100 0100100 0100100 0100000 0001111 0000000 BCD 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 0000 0000 0010 0010 0011 0011 0100 0100 0101 0101 0110 0111 1000 .Figura.

Para generar el bloque de co-simulación. Simulink System Period: Define el periodo del sistema en simulink.3. se ha generado el bloque de co-simulación. se escogerá VHDL. la tarjeta debe estar debidamente conectada al PC y encendida. Al simular el modelo ya con el bloque co-simulator. el cual lo conectamos a las respectivas entradas y salidas para luego simular el modelo. para que. y además invoca el generador de código que luego es utilizado en la herramienta ISE 8. Figura 6. en unidades de segundo. Hardware Description Language: Especifica el lenguaje de descripción de hardware (HDL) que se usará para la compilación del diseño.1i para la programación de la tarjeta. porque este provee el control del sistema y parámetros de simulación. 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. se tiene: Spartan3 xc3s200-4ft256 Target Directory: Se especifica el directorio donde se ubicara los archivos generados como resultado de la compilación. 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. Part: Automáticamente al elegir SP3 en compilación se determina las partes de la FPGA. (Parámetros tarjeta Spartan III).2 Implementación Realizada la simulación y habiendo comprobado su funcionamiento el siguiente paso es implementarlo en la tarjeta Spartan III XC3S200.6. Una vez definidos los parámetros del bloque System Generator generamos la compilación del modelo realizado. pueden ser VHDL y Verilog. - . en el bloque System Generator determinamos las opciones siguientes: Compilation: Hardware Co-Simulation => SP3.48. Al cabo de unos minutos.

mientras que en otro display observamos el resultado de la red para dicha entrada. sobre una FPGA.6. obtenemos los mismos resultados. Una vez ya descargado el programa en la Spartan III tenemos el sistema completo. a generar el archivo PROM.1i. 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.Figura. 6. por medio de la herramienta ISE 8. que será descargado en la FPGA [18]. 6. de reconocimiento de dígitos de siete segmentos utilizando RNA. que al ir dándoles valores de uno lógico o cero lógico se podrán visualizar en un display. se procede. Figura.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.49 Resultado en FPGA Spartan III para los números 3 y 5 .

funciona correctamente como lo esperado en la simulación. Debido al paralelismo que ofrece la FPGA.Figura. ver figuras 6. se observan en la figura 6. 2 nanosegundos.51. 6. 6.51 Resultado para ingreso de dígitos con error Implementado en hardware.50 Resultado para ingreso de dígitos parcialmente incompletos Figura. pudiendo tener resultados inmediatos al ingreso de los valores de entrada. Los recursos estimados de hardware.52 . la ejecución del modelo se realiza a gran velocidad.49 – 6. la red neuronal artificial. que utiliza el sistema.

que ingresa a la Red Neuronal. esta conformado por algunos valores llamados parámetros característicos. Podemos observar en las figuras 6. siendo estas: Luces y Abrir.53 a la 6. los parámetros característicos obtenidos en el sistema. Para éstas dos palabras se tomaron varios patrones. .4 Resultados Extracción Parámetros Característicos El vector de entrada.52 Recursos estimados de hardware para el sistema de reconocimiento de dígitos 6. para 4 patrones. Lo que se desea es que la red sea entrenada para reconocer dos palabras específicas. que pueden ser del tipo LPC o FFT. y corte2 utilizando el método de cruces por cero. Donde corte1 es utilizando el método de umbral. utilizando los dos métodos que determinan la señal útil. 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.Figura.56. 6. para obtener la señal útil. así como la utilización de los dos métodos de obtención de parámetros característicos. En la etapa de entrenamiento.

53 Patrones Característicos FFT para la palabra Luces .Figura. 6.

Figura. 6.54 Patrones Característicos FFT para la palabra Aire .

Figura.55 Patrones Característicos LPC para la palabra Luces . 6.

6.56 Patrones Característicos LPC para la palabra Aire .Figura.

57 – 6. mientras que con los parámetros FFT se tiene un mapa menos complejo de separación entre regiones. Figuras 6. Al usar parámetros LPC se tiene mayor complejidad de separación lo que significa mayor complejidad de reconocimiento de la red.58. que al momento del entrenamiento se traduce en menos épocas de entrenamiento alcanzando la salida deseada con un error muy reducido.Si comparamos las gráficas de las dos palabras a reconocer. 6. se puede observar a simple inspección. Figura. la complejidad de reconocimiento que debe tener la red neuronal para poder clasificar los parámetros característicos.57 Patrones LPC para las palabras Luces y Aire .

Figura. 6. . 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.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.

=0. .Figura. Figura.5.60 Salida de las Neuronas de Salida para = 0.59 Salida Deseada y disminución del Error para = 0. =0.8. 6.8.5. 6.

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.61-6. se prosiguió a encontrar los valores correctos para que la red llegue a la salida y error deseado sin llegar a tener oscilaciones. según la figura 6. pequeño que amortigüe la Figura.59-6-60. De acuerdo a los resultados obtenidos de las figuras 6. mientras que para la constante de momentum ( ) se tiene el valor de 0.8.61 Salida de la RNA con Backpropagation . Ver figuras 6. y (constante de momentum) = 0. 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 oscilación.60. observamos. 6.59-6. para lo que se tiene valor de alfa igual a 1.62.Para un valor de (velocidad de aprendizaje)=0.3.3.

6.62 Salida Deseada y disminución del Error para = 1.63 Variación de los algunos pesos de capa oculta hasta adaptarse. . 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. 6.Figura. Figura.3. =0.

se encuentra con el problema de las numerosas conexiones entre neuronas y el consumo de más recursos hardware que son limitados. obtenidos mediante la extracción de características.El siguiente paso es comprobar si para los patrones de entrada. A medida que se va aumentando el número de neuronas de la capa oculta. . 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. la red logra adaptar sus pesos para que encuentre la salida deseada según el patrón ingresado.

Se desarrolló tres funciones de transferencia que son la hardlim. puesto que los resultados obtenidos en ambas formas son correctos con lo que basándonos en la tabla 6. ya que los recursos de la FPGA son limitados. alta velocidad.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.Capitulo VII CONCLUSIONES Y RECOMENDACIONES 7. permitiéndonos una gran variedad de posibilidades para obtener soluciones • • • • . utilizando tarjetas FPGAs. hardware re-configurable. utilizando para cada una. Creándose una línea de investigación. de esta forma escoger la que consuma menos recursos. procesamiento en paralelo. lo que nos permitió comparar los resultados de funcionamiento y de cantidad de recursos necesarios para ser implementados en hardware. y Virtex II Pro para la RNA con algoritmo de backpropagation con momentum. entre otras. Se logró implementar dos aplicaciones de redes neuronales en las tarjetas: Spartan III para reconocimiento de dígitos de siete segmentos. cuyo principal aporte es obtener aplicaciones RNA. pero sin renunciar a obtener los resultados deseados. dos formas diferentes de desarrollarlas en System Generator. que antes se podía tener a nivel de software ahora factibles a problemas ingenieriles. en el país y región. hardlims y sigmoid. que permitieron obtener un buen desempeño de las redes. Teniéndose que se aprovechó de las características que las FPGAs nos ofrecen como son: la flexibilidad. 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.1 se concluye que la función obtenerlas a nivel hardware.

como lo es la neurona.45. según la tabla 6. se tiene que.hardlim. a diferencia de la simulación que los resultados los obtenemos en 2 segundos. se obtuvieron en un tiempo de 2 nanosegundos. en términos de hardware. siendo inmediatos al ingreso de los valores de entrada (7 switchs de la Spartan III). Se desarrolló la unidad básica de una red neuronal.82 y un error medio cuadrático de 0. como se puede apreciar en los resultados de la implementación del sistema reconocedor de dígitos de siete segmentos.93 y un error medio cuadrático de 0. misma que se desarrolló con un alto grado de paralelismo. • De las dos implementaciones para la función sigmoid. que consume mayor recursos y obtiene mejores resultados.04. tiempo que es superado en la implementación. Ya que la exactitud de resultados y coste. son importantes. Los resultados (mostrados en el display). se logra generar un sistema de aprendizaje y reconocimiento de • • • • . es la más apropiada para la implementación. que la función desarrollada utilizando memorias ROMs que genera un coeficiente de correlación de 0. la elección depende de los requerimientos de diseño de la RNA. La función sigmoid.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. logrando obtener resultados en menor tiempo de ejecución que las que se pueden obtener con sistemas computacionales clásicos. lo que permitió obtener en general una RNA con verdaderas características de procesamiento en paralelo. Se aprovechó plenamente el paralelismo que ofrece la FPGA. desarrollada por medio del bloque M-Code. 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. tiene un coeficiente de correlación de 0.4 y figura 6. A través del procesamiento digital de señales y las redes neuronales artificiales. desarrollada utilizando la función definida a trozos en comparación al resultado del bloque logsig de simulink.

como son: adquisición de la voz. con estos parámetros representar cada señal de voz para lograr un bajo costo de ejecución del algoritmo de entrenamiento. debido al procesamiento en paralelo que ofrecen. lo que dificulta un buen reconocimiento de la red y sería necesario una red neuronal compleja. ya que ésta es una característica intrínseca de las RNA. 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. • • . 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. lo que no es conveniente. confusas. para optimizar la red neuronal artificial. 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. Por otro lado los parámetros FFT ofrecen regiones de separación mas definidos.57.58. procesamiento. Se logró extraer de la señal de voz un número determinado de características. tal como se observa en la figura 6. como se observa en la figura 6. con mayor cantidad de recursos. extracción de parámetros característicos y entrenamiento de redes neuronales. las más comunes en esta clase de aplicaciones. • De acuerdo a los resultados obtenidos en la sección 6.patrones a través de algunos procesos básicos. • La utilización de FPGAs para el desarrollo de RNA es muy adecuado. Los parámetros característicos LPC obtenidos de las dos palabras luces y aire ofrecen regiones de separación poco definidas. • La FPGA a utilizarse depende de la cantidad de recursos hardware que requiere la RNA a implementarse. esto puede no ser un problema. como lo son: el Linear Predicting Code (LPC) y el Fast Fourier Transform (FFT). lo que la Spartan III XC3S200 es totalmente excelente para implementar el reconocedor de dígitos que no requiere demasiados recursos.5.

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 fue realizada en Matlab. El campo de las redes neuronales es muy extenso y se pueden desarrollar numerosas aplicaciones de redes neuronales implementadas en FPGAs.• Los resultados obtenidos en este proyecto de tesis. que es la obtención del vector de patrones característicos de la señal de voz. 7. 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. que son problemáticas. para así poder establecer una arquitectura de redes neuronales de menor complejidad y épocas de entrenamiento. el procesamiento totalmente paralelo no es factible salvo para redes no muy complejas. Logrando desarrollar numerosas aplicaciones de gran interés en ámbito científico. 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. activación de dispositivos por voz. • Una limitante de la utilización de dispositivos hardware. como la FPGA. como por ejemplo: en el procesamiento de imágenes. control de movimiento de motores para silla de ruedas. que requieren las redes neuronales. La etapa previa a la red neuronal. como comercial. es que poseen un número determinado de recursos y debido a las requeridas y numerosas interconexiones. 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. • • • . sistemas de acceso controlado por voz. lo que sería muy interesante e importante desarrollar esta etapa en System Generator para una total implementación del sistema. etc. En este trabajo se extrajo características LPC y FFT.

tanto a nivel teórico como en su implementación y simulación lógica. 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. .• El proyecto en general. y por consiguiente. que se describe en este trabajo aún no esta finalizado en su totalidad. Se dedicó tiempo y esfuerzo a la definición y prueba de cada uno de los componentes básicos.

http://softwarelibre. JAGATH C. Universidad de Alcalá [17] David G. http://ohm.info. A Real-Time FPGA based Biologically Plausible Neural Network Processor. Rodolfo Antonio Gutiérrez. Perceptrón multicapa. Inteligencia Artificial: Procesamiento de Lenguaje Natural.org/wiki/ASIC [7] Francisco José Palacios Burgos. OMONDI (Flinders University Adelaide. 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.cps.com/ . departamento de Informática FICH-UNL [13] F. 2002. http://dihana. [5] Miguel Morales Sandoval. [11] Martin Pearson. Kevin Gurney. Tendencias y Demos [6] http://es. Francisco Guillermo.unizar. [15] Eduardo Solano. RA-MA.unsa. Editorial Continental. Australia). FPGA Implementations of Neural Networks [3] Introduction to Fixed-Point Arithmetic.REFERENCIAS [1] Yu Hen Hu (University of Wisconsin). Octubre 2002. Handbook of NEURAL NETWORK SIGNAL PROCESSING [2] AMOS R. Help of MATLAB [4] Cavallero.ar/catedras/neuronales/04_Backprop.wikipedia. Redes Neuronales con GNU/Linux.htm Tutorial de Redes Neuronales. VHDL el Arte de Programar Sistemas Digitales.html [16] Oñate-Valdivieso. Jenq-Neng Hwang (University of Washington). MArtinez. RAJAPAKSE (Nanyang Tecnological University.utp. Alfredo Sanz Molina. Sistema de Reconocimiento de Palabras para Activación de Comandos en MATLAB Aplicando Procesamiento Digital de Señales y Redes Neuronales. [18] Programación FPGA Spartan III refiérase a: http://www. Fernando (2007).edu. Singapore). Alejandro Graciano Benítez Carlos F. FPGAs: Aplicaciones. Trabajo De Investigación Tutelado. [14] http://weblidi. Mokhtar Nibouche. Chris Melhuish. UTPL. [10] Héctor F Gómez A. University of the West of England. Lancheros Zapata. 2004. Pontificia Universidad Javeriana.co/neuronales.unlp.xilinx.ar/docs/descarga/2003/curso/htmls/redes_neuronales [8] Bonifacio Martín del Brío.es/investigacion/voz/coderframe. [12] Diego Milone. Codificación de Voz y Audio.ppt. 2002 [9] Universidad Tecnológica de Pereira. Ian Gilhespy.edu. Benjamin Mitchinson. Anthony Pipe. Jessica Alcalá.edu.. “Redes Neuronales y Sistemas Difusos”. Introducción a las FPGA.

8.ANEXO A.334). 6}. 6}. 6}. function [f] = F_sig(X) if X == 256 f = xfix({xlSigned. 8. elseif X == 16 f = xfix({xlSigned. else f = xfix({xlSigned.8779). 8.0.1572). 6}.0.1).0. 8. end . elseif X == 32 f = xfix({xlSigned.0. 6}.5). 8.0.0). elseif X == 2 f = xfix({xlSigned. elseif X == 4 f = xfix({xlSigned. 8. 6}.0.5756). elseif X == 128 f = xfix({xlSigned.0. 8. %Donde f es la salida representada en formato xlSigned de 8 bits punto binario 6. 8. elseif X == 8 f = xfix({xlSigned.9509). 6}. 6}. 8. CÓDIGO F_SIG.7356). BLOQUE M-CODE %Donde X es la entrada del bloque M-Code y representa la salida de la concatenación. elseif X== 64 f = xfix({xlSigned. 6}.

FUNCIONES DE TRANSFERENCIA .ANEXO B.

0. A == 5 0. 1. 1. d3 = 0.d5. d6 = 1. A == 4 1. 0. 0. 1. 0.d2. 1. 0.d3. 1. d1 = 0. 0. d4 = 0. = = = = = . A == 3 0. 0. 0. 1. elseif A== 2 d0 d1 d2 d3 d4 d5 d6 elseif d0 d1 d2 d3 d4 d5 d6 elseif d0 d1 d2 d3 d4 d5 d6 elseif d0 d1 d2 d3 d4 = = = = = = = = = = = = = = = = = = = = = 0. 0.d4. 1. 0. 0. d5 = 0. DECODIFICADOR A 7 SEGMENTOS function [d0. 1. 0. 1.d1.d6] = deco(A) if A == 0 d0 = 0. 0. 1. 0. 0. 1. 0. elseif A == 1 d0 d1 d2 d3 d4 d5 d6 = = = = = = = 1.ANEXO C. d2 = 0. 1.

0. A == 7 0. 0. 0. = = = = = = = = = = = = = = = = = = = = = = = = = = = = A == 6 0. 0.d5 = 0. 0. 1. 0. 1. 0. elseif d0 d1 d2 d3 d4 d5 d6 elseif d0 d1 d2 d3 d4 d5 d6 elseif d0 d1 d2 d3 d4 d5 d6 elseif d0 d1 d2 d3 d4 d5 d6 else d0 d1 d2 d3 d4 d5 d6 end = = = = = = = 0. 0. 0. 0. A == 9 0. A == 8 0. 0. 0. . 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. d6 = 0. 1. 1. 0.

'Fontangle'. hold on %Gráfica la señal de voz ingresada axis([t1(1)-0.12.10.'TriggerRepeat'.'Fontsize'.'SampleRate'.'Fontname'.1).8 0.fig) plot(t1. wavwrite([d1.ANEXO D. CÓDIGO PARA GRABAR LA VOZ POR MICRÓFONO axes(handles.11025.d1).'Bold'.'Fontname'.1) start(AIVoice) [d1.'Arial'.'Italic'.'TriggerType'.chan) set(AIVoice.t1].fig) plot(0) AIVoice = analoginput('winsound').'color'.'Timeout'.'Fontangle'.'Italic'.5) set(AIVoice.'Software') set(AIVoice. grid on. %tiempo de duración de la grabación set(AIVoice.'grabacion') %Guarda en archivo .2) set(AIVoice.[1 1 1]) delete(AIVoice) clear AIVoice .'Arial'.ActualRate*duration) set(AIVoice.'TriggerChannel'.'Fontweig ht'.0.'Fontw eight'.[1 1 1]) title('Señal de Voz'. set(AIVoice.'TriggerCondition'. duration = 0.'SampleRate').8]) xlabel('Time (sec.05 t1(end)+0.wav la señal axes(handles.'Rising') set(AIVoice.'color'.05 -0.'Bold'.)'.%ingreso voz por micrófono chan = addchannel(AIVoice.11025) %tasa de muestreo ActualRate = get(AIVoice.t1] = getdata(AIVoice).5.'Fontsize'.'TriggerConditionValue'.'SamplesPerTrigger'.

'Fontangle'. Lo=length(X). j=1.'Italic'. break.008 final=Lo-i-100.'Fontsize'. for i=inicio:1:final Result(j)=X(i).'Bold'. break.axes9) plot(0) plot(Result).'Vector') . end end Result=[].009 inicio=i. hold on title('señal útil'.[1 1 1]) wavwrite(Result.'color'. for i=1000:1:Lo if abs(X(i))>0.'Fontname'. end end for i=1:1:Lo-100 if abs(X(Lo-i+1))>0. CÓDIGO PARA OBTENER SEÑAL ÚTIL MÉTODO UMBRAL X=wavread('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\grabacion. end axes(handles.12. j=j+1.'Arial'.ANEXO E.'Fontwei ght'.wav'). grid on.

%******************************************************************* ** % f(n) = f(n) . % Cruces por cero mínimo TamTrama = 90. FinAux = NumTrama.1 if InicEstado == 0 if AP(i) > AmplitudMinInic if CC(i) > MinCrucesCero ContInic = 0. % Amplitud mínima al comienzo de señal AmplitudMinFin = 0. sutilAux(1 : TamTrama) = sutil(InicVal : FinalVal).95*f(n .ANEXO F.95 * sutil(1:length(sutil)-1). end for i = 1 : NumTrama .1. % Amplitud mínima al final de señal MinCrucesCero = 4.0005. CC(i) = CrucesCero(sutilAux). % Tamaño de trama analizado InicTrama = 4. AP(i) = Amplitud(sutilAux). %******************************************************************* **for i = 1 : NumTrama .1) * TamTrama + 1.wa v'). % Número de trama de final de la señal %******************************************************************* ** InAux = 1.000002. CÓDIGO PARA OBTENER SEÑAL ÚTIL MÉTODO CRUCES POR CERO sutil=wavread('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\grabacion. % Número de trama de inicio de la señal FinTrama = 5.0. for j = 1 : InicTrama if AP(i + j) > AmplitudMinInic if CC(i + j) > MinCrucesCero ContInic = ContInic + 1.1) -> Filtro de bajo orden para eliminación del nivel DC sutil(2:length(sutil)) = sutil(2:length(sutil)) . NumTrama = floor(length(sutil)/TamTrama). end end end if ContInic == InicTrama InAux = i. FinalVal = InicVal + TamTrama . end . InicEstado = 1.1 InicVal = (i .0. AmplitudMinInic = 0. InicEstado = 0.

Result = Result / max(abs(Result)). ValueInic = (InicTrama .[1 1 1]) wavwrite(Result.'color'. for i = 1 : length(sutilAux) SignVal2 = sign(100 * sutilAux(i)). %******************************************************************* * %******************************************************************* * function ContAP = Amplitud(sutilAux) % Sumatoria del valor absoluto del vector sutilAux sutilAux = abs(sutilAux). if (-1 * SignVal) == SignVal2 ContCC = ContCC + 1.'Vector') %******************************************************************* * %******************************************************************* * function ContCC = CrucesCero(sutilAux) % Contador de cruces por cero ContCC = 0.12.ValueInic + 1) = sutil(ValueInic : ValueFin).axes9) plot(0) plot(Result). ValueFin = FinTrama * TamTrama. grid on. hold on title('señal útil'.'Arial'. 'Italic'. sutilAux = sutilAux. Result(1 : ValueFin . ContAP = sum(sutilAux)/length(sutilAux). end end ContCC = ContCC. axes(handles. SignVal = SignVal2. 'Fontsize'.'Fontweight'. FinTrama = FinAux. end end end end InicTrama = InAux. SignVal = -1. 'Fontangle'.1) * TamTrama + 1. .end end else if AP(i) > AmplitudMinFin if CC(i) > MinCrucesCero FinAux = i.'Bold'.*sutilAux. 'Fontname'.

listbox1.'Arial'. ValoresLpc).caracteristicas) axes(handles. set(handles.axes1) cla Patron=wavread('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\Vector. % Número de valores LPC NumMuestras = length(Patron). 'caracteristicas'). save(savefile. for t = 2 : ValoresLpc + 1 LPCvalAux(t . for i = 1 : 1000 Patron(i) = 0. % Incremento de trama ValoresLpc = 15. end for ContNumF = 1 : NumTramas for n = 1 : TamTrama FramePattern(i) = Patron(n + Begin)*(0. LPCval = [].46*cos(6.listbox1.54 0.'String'.TamTrama) / Overlap) + 1).'Fontsize'.'Fontname'.axes1) plot(caracteristicas). NumTramas = floor(((NumMuestras . savefile = 'caracteristicas. FramePattern = FramePattern + 0. CÓDIGO PARA EXTRAER PARÁMETROS LPC run ('G:\MATLAB71\work\Joha\neuronas\PRINCIPAL\GUI2. % Tamaño de trama Overlap = 330.m') axes(handles. i = 1.ANEXO G. end Begin = Begin + Overlap.12) . t). %************************************* if NumTramas < 2 Patron = []. end caracteristicas = VecResult'.1) = LPCval(1.grid on.2832*n/TamTrama)). i = 1. end NumTramas = 4. set(handles. VecResult(ContNumF) = sqrt(sum(LPCvalAux)/length(LPCvalAux)). Begin = 0. % ************************************ TamTrama = 500.caracteristicas). hold on title('Caracteristicas LPC'. n + Begin.wav' ). LPCval = lpc(FramePattern.00001. i = i + 1. end LPCvalAux = abs(LPCvalAux)/max(abs(LPCvalAux)).'String'.mat'.

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

1 Implementación de Funciones de Transferencia y Neurona Perceptron en FPGAs (Febrero 2008) Johana E.1. etc. Field programmable gate arrays.1 Neurona Las entradas Xi. hardlims y sigmoid.1i. definida como un número que indica a partir de que valor del potencial la neurona produce una salida significativa. ya que es relevante desarrollarlas. Entrada de tendencia. Bias b.1. Estos valores resultantes de las multiplicaciones mas el bias. System Generator 8. debido a que poseen muchas características que sobrepasan los sistemas computacionales clásicos. Esta unidad de procesamiento esta formada por: L I. Para cada elemento es necesario comparar los resultados obtenidos. [2] Los pesos Wi. Neurona Artificial Una red neuronal se encuentra formada por varias unidades neuronales. para después desarrollar la unidad neuronal que es la base para determinar redes neuronales de mayor tamaño y complejidad. que es una característica intrínseca de las RNA. En este sentido. II. celdas. control de robots. son sumados formando una señal resultante n. lográndose aplicaciones como: reconocimiento de imágenes. así como también es necesario determinar los recursos que utiliza en hardware para su implementación. A. y Xilinx 8. todas sobre la herramienta System Generator. que son la intensidad de la sinapsis que conecta la entrada con la neurona o entre dos neuronas. a teoría y diseño de las redes neuronales artificiales han avanzado significativamente durante los últimos 20 años [1]. aprovechando la capacidad de procesamiento paralelo de la tarjeta. reconocimiento del habla y caracteres. lógica programable. bloques comparadores y aproximaciones lineales. Nos dedicaremos al desarrollo y análisis de las funciones de transferencia mas utilizadas en las RNA. hardlims y sigmoid. que luego nos permitieron su implementación en la FPGA Spartan III de Xilinx. jebricenox@gmail. Briceño S. memorias ROM. 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].com Escuela de Electrónica y Telecomunicaciones Universidad Técnica Particular de Loja Resumen— dependiendo de la función a implementarse. que son los datos o señales que ingresan a la neurona. unidades de procesamiento o neuronas que se interconectan entre si formando una red. - n = ∑ Wi X i + b (1) i =1 N . En este trabajo se utiliza código sintetizable de MATLAB. INTRODUCCIÓN - Fig. para determinar su eficacia. Para ello se utilizó herramientas de diseño de sistemas digitales y lógica programable como lo son MATLAB 7. como lo son las funciones hardlim. Palabras Claves— Redes neuronales. 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. se aporta al tema de implementación en Hardware de Redes Neuronales.

Ver figura 3. Fig. a este bloque le llamaremos hardlim1. ganancia b de la neurona. para luego ser sintetizado en código VHDL para la implementación en la FPGA. Donde: sums.2 - La función de transferencia f. Funciones de Transferencia Las funciones de transferencia f. La segunda forma de desarrollar la función hardlim. dentro del bloque M-Code. y es escogida dependiendo del tipo de problema a resolverse con la RNA. Fig. Para esto se utiliza la herramienta Resourse Estimator. comparadores y constantes. Como se observa en la figura 4. que llamaremos hardlim2. 4 Función Hardlim2 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. el mismo que nos permite describir su funcionamiento en MATLAB (archivo m-file). y se le definió formato tipo Xilinx fixed-point (xfix). 2. bias.w1n X 1n + b) (2b) B. es la suma total de las entradas a la neurona multiplicada por su respectiva matriz de pesos. Valor de salida. de lo que depende de un análisis tanto de la precisión de resultados como de los recursos de hardware que consumirían. valor de entrada. Se necesita unas cuantas líneas de código para describir la función hardlim1.2b. FT. valor de entrada. En la figura 2. determinan la salida total de la neurona. 3 Función Hardlim con M-Code y = f ( w11 X 11 + w12 X 12 + . se describe según la expresión III. la que puede ser una función lineal o no lineal de n. que se le aplica a la señal resultante (n)... bias) sums1= sums + bias if sums1 >= 0 ft1 = 1 else ft1 = 0 end FT = xfix({xlSigned. valor signed fixed-point (xlSigned) con 2 bits y puno binario 0. DISEÑO A. y = f i ( ni ) y = f ( ∑ Wi X i + b ) i =1 n (2a) (2b) Fig. que estima rápidamente los recursos requeridos por la FPGA para . La función de transferencia nos entrega un valor de acuerdo a la función de activación que se escoja. 0}.ft1). como se puede observar: function [FT] = Fhardlim(sums. La primera forma de desarrollar la función hardlim es a través del bloque M-Code de System Generator. 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. es utilizando sumadores. se observa las funciones de transferencia diseñadas y luego implementadas en la FPGA. 2 Funciones de Transferencia III.

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

8 S a l id a S ig m o i d 0.2 1 0. obtiene . razón por la que se tiene menor margen de error.4 resultados para valores negativos de entrada. En la figura 8 se observa una neurona de dos entradas y que utiliza la función hardlim. el bloque F_Sig. se agregan multiplicadores en paralelo y en igual forma se agregan sumadores en cascada. Sig_ROM & F_Sig & Logsig 1. B.4 0.2 0 2 4 6 8 Sig_ROM F_Sig Logsig Fig. Fig. 7 Comparación de resultados bloques Sig_ROM. pero a diferencia de ésta. se implementará las funciones AND y XOR. 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 hardware. formado por un bloque M-Code. F_Sig y Logsig De la tabla II se concluye fácilmente que para una entrada de 8 bits. sumadores y la función de transferencia con que deseamos que trabaje la neurona. como se constata en la figura 10. según la figura 7. utilizando bloques multiplicadores. se puede desarrollar una RNA utilizándola tantas veces como el diseño lo requiera.6 0. y se tiene dos Gateway in que son los puertos de entrada de la neurona y que transforman los valores de punto flotante a punto fijo y un Gateway out que es el puerto de salida y transforma el valor en punto fijo a punto flotante. 8 Neurona desarrollada en Sysgen En la figura 9 se presenta la neurona completa en la que previamente se han almacenado los pesos en los bloques constant. de entradas y función de transferencia deseada. el funcionamiento y el coste son muy importantes. IMPLEMENTACIÓN Para comprobar el correcto funcionamiento de la neurona y de la función de transferencia. Se tiene en la figura 7. La función AND es un problema linealmente separable. Una vez que se tiene la neurona. Diseño Neurona Perceptron Aquí se procede a desarrollar la neurona artificial en Sysgen. que se resuelve con una Valores de entrada X Fig. punto binario 4. ya que la exactitud. Tabla II Comparación de recursos de la función sigmoid Función de Transferencia Slices FFs LUTs IOBs Sigmoid Sig_ROM Sigmoid F_Sig 23 69 12 15 45 125 20 16 Fig. 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. IV. la comparación de resultados obtenidos de los dos diseños y en la tabla II los recursos de hardware necesarios para su implementación. el bloque F_Sig necesita más recursos de hardware que la función Sig_ROM. 9 Esquema completo de la neurona en Sysgen Según se requiera mayor número de entradas.2 0 -6 -4 -2 -0.

Las dos entradas a la neurona son asignadas a dos switchs de la tarjeta y la salida podemos visualizarla en uno de los leds. t = [1 0 0 W = [2 1]. 0) Fig.5 Fig. 11 Perceptron que funciona como AND El resultado de la simulación es como se observa en la figura 12. se implementa el modelo en la FPGA Spartan III. 14 Salida de uno para la entrada (1. Fig. . es necesario otra capa con la tercera neurona cuyas entradas serán las salidas de las neuronas anteriores. 1. 12 Simulación Neurona Perceptron que funciona como compuerta AND Habiendo comprobado que el perceptron funciona correctamente como función AND.5 P(1) 1 1. solo cuando ambas entradas son uno.5 0 -0. para que funcione como AND se utilizó la herramienta nntool de Matlab en la que: . con esto se obtienen dos rectas que delimitan tres zonas. caso contrario es cero.5 0 0. en la que el resultado de la neurona es uno.5 -0.5 neurona perceptrón con función de transferencia hardlim como se observa en la figura11.5 Vectors to be Classified 1 P(2) 0. como se observa en la figuras 13 y 14. b = [-3]. 1) La segunda función. una región pertenecería a una de las clases de salida y las otras dos pertenecen a la segunda clase. como lo representa la figura 15. Fig. para poder elegir entre una zona u otra de las tres. 13 Salida de cero para la entrada (1. por lo que la solución a este problema de clasificación se encuentra si se descompone el espacio en tres regiones. Matriz de entrada 0]. 10 Separación de regiones función AND Para encontrar el valor de los pesos y del bias de la neurona perceptron. XOR. es un problema que no es linealmente separable. Salidas deseada Matriz de pesos bias Fig. así que en lugar de utilizar únicamente una neurona de salida se utilizan dos.

Fig. distribuidas en dos capas para solucionar este problema.1) y (0.1) y (1. 18 Resultado implementación función XOR . Los resultados se observan en la figura 18. 17 Simulación red neuronal funcionando como XOR Comprobado que la red funciona correctamente como función XOR.0) se asocian a una salida activa de la red y la zona central se asocia a la salida nula.0) la salida es cero.6 Fig.2 Bias neurona 1: b1= 1. 15 Regiones de la función XOR Las dos zonas o regiones que contienen los puntos (0. se implementa el modelo en la FPGA Spartan III.8 w12= -1.2 Neurona 2: w21= 1. y cuando se tiene (1. en la que el resultado de la neurona es uno cuando las entradas son (1. Los valores de pesos y bia para que la red sea una función XOR son: Neurona 1: w11= -0. como se visualiza en la figura 16.0) y (0.5 Fig. por tanto se ha de utilizar una red de tres neuronas con función hardlim. 16 Red neuronal que funciona como función XOR El resultado de la simulación es como se observa en la figura 17.1).5 Bias neurona 2: b2= -1 Bias neurona 3: b3= -1.8 w32= 1.5 w22= 1 Neurona 3: w31= 0. Las dos entradas a la neurona son asignadas a dos switchs de la tarjeta y la salida podemos visualizarla en uno de los leds. Fig.

Ingeniero en Sistemas Informáticos y Computación. 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. Gómez A. OMONDI (Flinders University Adelaide. REFERENCES [1] Yu Hen Hu (University of Wisconsin). como lo es la neurona perceptron. http://softwarelibre. 2002 AMOS R. son importantes. Alfredo Sanz Molina. Se desarrolló la unidad básica de una red neuronal. Ya que la exactitud de resultados y coste. se tiene que. Especialista en Sistemas de Información Geográfica. Australia). Handbook of NEURAL NETWORK SIGNAL PROCESSING Francisco José Palacios Burgos. desarrollada por medio del bloque M-Code. pero sin renunciar a obtener los resultados deseados.unsa. puesto que los resultados obtenidos en ambas formas son correctos con lo que basándonos en la tabla VII. JAGATH C. misma que se desarrolló con un alto grado de paralelismo. en términos de hardware. lo que nos permitió comparar los resultados de funcionamiento y de cantidad de recursos necesarios para ser implementados en hardware. De las dos implementaciones para la función sigmoid. 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.ar/docs/descarga/2003/curso/htmls/redes_n euronales Bonifacio Martín del Brío. “Redes Neuronales y Sistemas Difusos”. dos formas diferentes de desarrollarlas en System Generator. ya que los recursos de la FPGA son limitados. .edu.7 V. de esta forma escoger la que consuma menos recursos. Héctor F. utilizando para cada una. RA-MA. CONCLUSIONES Se desarrolló tres funciones de transferencia que son la hardlim. lo que permitió obtener en general una RNA con verdaderas características de procesamiento en paralelo. RAJAPAKSE (Nanyang Tecnological University. Redes Neuronales con GNU/Linux. Universidad Técnica Particular de Loja. la elección depende de los requerimientos de diseño de la RNA. hardlims y sigmoid.3 se concluye que la función hardlim. Jenq-Neng Hwang (University of Washington). La función hardlim y hardlims consumen menos recursos hardware que las funciones no lineales. que consume mayor recursos y obtiene mejores resultados. FPGA Implementations of Neural Networks [2] [3] [4] Revisado por: Ing.. Singapore). logrando obtener resultados en menor tiempo de ejecución que las que se pueden obtener con sistemas computacionales clásicos. es la más apropiada para la implementación.

Sign up to vote on this title
UsefulNot useful