introduccion - upmlorien.die.upm.es/juancho/pfcs/cmv/programasdef.doc · web viewen este apartado...

MODELADO DE LA FRECUENCIA FUNDAMENTAL MEDIANTE REDES NEURONALES PARA SÍNTESIS DE VOZ EN DOMINIO RESTRINGIDO

Carlos Martín Valle

4 Los programas

4.1 Introducción

Este capítulo se puede estructurar en dos partes: un primer conjunto de programas

que sirve para generar los ficheros *.nn, etc. que ya existían cuando se comenzó este

proyecto y otro segundo grupo desarrollado específicamente para este trabajo.

Lógicamente, los primeros se explicarán antes que los segundos, ya que éstos no

funcionarían sin los archivos generados previamente por el otro grupo.

4.2 Primer grupo de programas4.2.1 La función dzscore

Esta función supone que trabajamos con fenómenos gaussianos, que vendrán

caracterizados por su media y su varianza. Al restar y sumar 1.96 por la desviación típica

a la media del proceso, el 95% de los valores del mismo caerá dentro de dicho intervalo;

usaremos una transformación para trasladar este intervalo a otro más adecuado para

nuestro trabajo, que será (0.1, 0.9). La transformación vendrá dada por la siguiente

expresión:

valor_out = [[(valor-0.1)/((0.9-0.1)/(2*1.96))] - 1.96] * dtp +

donde “valor_out” es el valor de salida de la función, “valor” es el valor que se le pasa

como entrada a la ecuación, y “dtp” y “” son la desviación típica y la media del proceso

gaussiano, respectivamente.

La transformación inversa vendrá dada por:

valor = [(valor_out-)/dtp + 1.96] * [(0.9-0.1)/(2*1.96)] + 0.1

Esta última expresión es la que normaliza, mientras que la primera es la que

desnormaliza.

4.2.2 Obtención de ficheros *.inEn este apartado se va a describir la parte inicial del proceso, que consiste en la

obtención de ficheros *.in.

Capítulo 5: Los programas Página 58



Para empezar debemos aclarar cuál va a ser la notación empleada en los ficheros.

Un ejemplo de uno de ellos puede ser “Bv01001”, donde el “01” que está justo al lado de

las letras indica que se trata de la frase patrón 1 y el “001” restante significa que se trata

de la grabación 1 de esa frase patrón. La notación puede variar ligeramente para otros

archivos, pero será equivalente; así, hablaremos de ficheros Bv02xxx, Bv03xxx, Bv04xxx,

etc.

Se puede decir, a grandes rasgos, que tenemos dos directorios: Textos y Par. Dentro de Textos tenemos un directorio por cada frase, y en cada uno de estos

directorios tenemos otro, Originales, por cada grabación, dentro de los cuales hay

ficheros *.txt con los textos originales de cada frase.

Por otro lado, el directorio Par tiene la misma estructura que textos, es decir, un

directorio por cada frase, donde se encuentra el directorio Originales correspondiente a

cada frase, y en estos directorios están las marcas y la voz de cada una de ellas,

recogidas en los ficheros *.par y *.pcm, respectivamente. Así, los *.par son ficheros de

texto con información de duraciones y del tono y con la peculiaridad de que sólo son

fiables las marcas de las palabras clave, mientras que los otros ficheros (*.pcm) contienen la voz grabada con 16 bits y a 32 kilohertzios.




Figura 5-1: Ejemplo de fichero *.par.

En los ficheros *.par la información de duración se encuentra por duplicado ya que

se facilita en muestras y en segundos. Se prefiere la segunda opción al ser independiente

de la frecuencia de muestreo.

También contamos con el programa Pcv_50, el cual necesita que los ficheros *.par y

*.pcm estén en el mismo directorio y que tengan el mismo nombre. En el directorio en el

que se encuentra dicho programa existen unos ficheros con información muy importante

como, por ejemplo, Raw.ini, que contiene la frecuencia de muestreo; Gthmatlab.ini, que

pone el modo de depuración y el de leer a cero y además indica cuáles son el pitch

máximo y el mínimo; Atonas.lis, que contiene una lista de palabras no acentuadas; etc.

Figura 5-2: Ejemplo de fichero *.pcm.

Una vez que se dispone del conjunto de ficheros *.par revisados de forma que sean

compatibles con los *.txt, con la información sobre la posición y la duración de los

fonemas (segmentación) y posición de las marcas de tono (marcado), de cada una de las

frases que fueron grabadas, el siguiente paso es proceder a la extracción de los

difonemas contenidos en dichas frases para generar posteriormente la base de datos con

todos esos difonemas.




Figura 5-3: Ejemplo de fichero *.txt.

Para hacer más sencillo todo el proceso de extracción de los difonemas de cada una

de las frases que constituyen la base de datos, se emplea un conjunto de ficheros por

lotes de MSDOS (*.bat) que se encargan de realizar toda la secuencia de procesos de

una forma automática [González del Campo-00].

El proceso comienza haciendo una referencia al programa Regenera.bat, que crea

dos clases de ficheros: los *.dur y los *.nn. Los primeros son ficheros de la base de datos

sin normalizar y contienen dos campos muy importantes para nosotros: “o", con la

duración real de los fonemas en muestras; y “num”, que tiene relación con el fonema de

que se trata. Los segundos ficheros contienen parámetros de entrada de la Red, pero no

tienen información acerca del tono; además, no tienen formato internacional. Cabe

destacar que la información de las duraciones se da en fonemas, mientras que la de tono

se da en sílabas.

El programa Regenera.bat comienza haciendo una llamada a Borra.bat, que elimina

la información sobre extracción de difonemas procedente de procesamientos anteriores.

Una vez hecho esto, comienza el verdadero proceso de extracción de difonemas.

Regenera.bat lee la información contenida en el fichero Frases.dir, que es una lista con

los tipos de frase que debe procesar (frase1, frase2, etc.). Para cada frase se llama a la

subrutina Procesa. Esta subrutina lee de un fichero contenido en el directorio de la frase

(Frase*) y de nombre Frase*.dir –siendo “*” el número concreto de la frase- la lista de

frases o grabaciones que deberán ser procesadas. Este fichero Frase*.dir se le pasa

como argumento a otro programa llamado Superbat.bat, que, básicamente, es el

encargado de ir llamando a los diferentes programas involucrados en la extracción de los

difonemas. Por lo tanto, Superbat.bat recorre todas las grabaciones de una frase y para

cada grabación ejecuta Sacadif32. Vamos a centrarnos un poco más en este programa

Superbat.bat.




4.2.3 Superbat.batEl fichero por lotes Superbat.bat dispone de una serie de parámetros que permiten

elegir entre diferentes modos de trabajo, estos parámetros son [González del Campo-00]:

o MODO_CD_SIN_TEXTOS: a 0 indica que los ficheros *.par y *.txt se leen del CD-

ROM y el *.pcm del disco duro; a 1 indica que los ficheros *.par y *.txt se leen del

disco duro y los *.pcm del CD-ROM.

o MODO_COPIA: a 1 indica que para cada procesamiento se crea un directorio de

nombre PCM_TMP, en el cual se guarda una copia de los ficheros *.pcm y *.txt, mientras que se elimina toda la información contenida en dicho directorio

procedente de procesados anteriores.

o RES_DEBUG: a 1 indica que, tras la ejecución de cada uno de los programas que

componen el proceso, se muestra en pantalla el fichero de depuración asociado a

los mismos.

A su vez, el programa puede recibir como argumento o bien un fichero *.par (para

ello damos como argumento al programa el nombre del fichero, por ejemplo,

“Superbat.bat Bv01001”), o bien una lista con los nombres de los ficheros *.par que debe

tratar. Estas listas de ficheros se encuentran dentro de un fichero, por ello, para que el

programa sepa que realmente le estamos pasando una lista de ficheros, se escribe antes

del nombre del fichero una arroba (por ejemplo, “Superbat.bat @frase1.dir”).

Cuando ejecutamos Superbat.bat realizamos la extracción de los difonemas, pero

también una resíntesis de cada una de las frases contenidas en el fichero Frase*.dir. El

proceso que se sigue para llegar a este fin es el siguiente: en primer lugar se hace una

llamada al programa encargado de extraer los difonemas de la frase a partir de la

información contenida en el fichero *.par; a continuación se construye una base de datos

con todos los difonemas de la frase que acaban de ser extraídos y, finalmente, se utiliza

esta base de datos para tratar de resintetizar la frase original.

En la resíntesis se emplean los difonemas originales, por tanto el sintetizador no

debería encontrarse con ningún problema para obtener resultados de una alta calidad

(similar a la de la frase original), pues las modificaciones prosódicas que debe realizar




sobre las unidades empleadas serán mínimas, limitándose a meros redondeos en las

duraciones y a una linealización del tono fundamental, por parte del algoritmo TD-PSOLA.

Como se ha dicho, se realiza una resíntesis completa de los ficheros en lugar de,

únicamente, ejecutar el programa que extraía los difonemas de esos ficheros. La

justificación de esto se encuentra en el hecho de que una revisión manual de todos los

ficheros de parámetros consumiría demasiado tiempo y, por tanto, para la extracción de

los difonemas, en su día se prefirió recurrir a una estrategia más compleja que la simple

ejecución del programa de extracción. Con esta otra estrategia, además, se permite

detectar muchas de las frases que contienen errores de marcado sin necesidad de

revisar todo el fichero de parámetros (.*par).

Al aplicar el fichero por lotes nos encontramos con tres tipos de situaciones: aquellas

en que la resíntesis se produce de forma satisfactoria, aquellas otras en las que el fichero

por lotes no es capaz de resintetizar frases como consecuencia de algún error grave en el

fichero de parámetros de la frase en cuestión (como pueden ser etiquetas mal marcadas

o sin marcas de pitch en su interior, o de generación de tonos nulos para algunos

difonemas), o aquellas otras situaciones en las que el programa consigue resintetizar las

frases sin ningún problema pero, al ser escuchadas, la calidad resulta bastante mala.

Para las frases de la primera situación no es necesario llevar a cabo una revisión

detallada. Para las del segundo caso, la forma de corregir sus errores suele ser la

revisión manual de los ficheros y su posterior corrección mediante la aplicación del

programa PCV-GTH, tras lo cual se debe repetir el proceso de resíntesis para cerciorarse

de que el problema ha sido resuelto adecuadamente.

Para las frases de la tercera situación la solución no se alcanza de una forma tan

directa como en el caso anterior, y se necesita analizar los ficheros de depuración que

hayan sido generados al ejecutar los programas oportunos; de esta manera detectaremos

el programa concreto en el que se haya producido el error, que, en la mayoría de los

casos, se corresponderá con fallos internos de los programas o situaciones que no han

sido previstos por los mismos.

Como ya habíamos dicho, Superbat.bat recorre todas las grabaciones de una frase

y para cada una de ellas ejecuta el programa Sacadif32.




4.2.4 Sacadif32.exeEs este el primer programa que se ejecuta en Superbat.bat y se encarga de llevar a

cabo la extracción automática de los difonemas de la frase. Este programa recibe como

argumentos el fichero de muestras (*.pcm), el de parámetros (*.par) y el de textos de la

frase (*.txt).

La extracción de los difonemas en Sacadif32.exe se hace de forma automática, a

partir de la información contenida en el fichero de parámetros asociado a la frase,

basándose para ello en una serie de reglas dependientes del tipo de fonema, con el fin de

determinar el punto de corte óptimo del mismo (aquel en el que la señal de voz presenta

una mayor estabilidad y que, por lo tanto, nos ofrece mayores ventajas de cara al

pegado). Así, por ejemplo, en el caso de los sonidos vocálicos se supone que el punto de

máxima estabilidad se encuentra justo en la zona central, en los sonidos fricativos se

corta por las zonas inicial y final, y en los sonidos oclusivos se tiende a cortar por el

silencio inicial (estos dos últimos para cortar el número de unidades a generar).

El programa genera un conjunto de ficheros que contiene distinta información

relacionada con los difonemas. Los ficheros que se producen tienen como nombre el del

difonema extraído de la frase y las posibilidades para las extensiones son [González del

Campo-00]:

o *.mst: muestras del difonema. Se añaden 512 bytes correspondientes a la

cabecera de los ficheros.

o *.par: marcas de pitch para cada difonema, así como etiquetado del mismo.

o *.mar: posición de las marcas del difonema (en formato binario). Contiene

información sobre el número de muestras, número de marcas, posición –en

número de muestras- de dichas marcas y frecuencia de muestreo.

o *.ram: posición de las marcas en formato texto. Contiene la misma información

que el *.mar.

o *.mfc: coeficientes Mel Frequency Cepstrum de las tramas del difonema.




o *.ene: coeficientes de energía en bandas logarítmicas de las tramas del difonema.

Estas bandas son las mismas que se emplean para el cálculo de los coeficientes

*.mfc.

Además de esto, se genera un fichero asociado a la frase con extensión *.di que

contiene todos los difonemas de la misma junto a sus características prosódicas de

duración y tono.

El programa también genera un fichero de nombre Listetiq que contiene una lista

con los difonemas presentes en la frase y un archivo con el nombre de la frase y

extensión *.crr. En este archivo aparece toda la información contenida en el fichero *.par –con el mismo formato para etiquetas y marcas de tono- y además aparecen unas

nuevas secciones de la forma:

o LBO: muestra_inicio, muestra_media, muestra_fin, fonema (empleado para la

base de datos SPEECHDAT).

o LBB: muestra_inicio, muestra_fin, fonema (empleado para la generación de la

curva de tono).

Adicionalmente se genera un fichero con el nombre de la frase y extensión *.dps, en

el cual aparecen todos los mensajes de depuración que saca el programa Sacadif32.exe por pantalla. Entre estos mensajes se pueden destacar los siguientes:

o Información sobre fonemas remarcados, como en el caso de las oclusivas o

fricativas, en los cuales se obvian las marcas generadas por el programa PCV y

se colocan unas nuevas con una frecuencia fija.

o Información sobre el alineamiento entre el fichero *.txt de la frase y el *.par

de la misma, y en caso de existir diferencias entre ellos, éstas se notifican al

usuario (entraremos más en detalle sobre este aspecto un poco más adelante).

o Información sobre la extracción de los difonemas en cuanto a su localización y

su duración.

o Cálculo del pitch de los difonemas: se calcula, además de las marcas de tono

contenidas dentro del difonema, el tono medio del mismo. Este tono medio puede

ser corregido posteriormente en función de si difiere más allá de un tanto por




ciento del de los fonemas fiables presentes en el mismo (normalmente suele ser

una vocal, en cuyo caso pasa a tener ese valor) o en el caso de tratarse de un

difonema sordo.

Por último, Sacadif32.exe genera otros dos ficheros del tipo *.dur y *.nn. Los

primeros tienen la peculiaridad de que pueden entrenar la Red Neuronal, aunque no son

óptimos por quitar información conocida. Por ejemplo, miden cuánto se desvía esta “a” de

la “a” típica, en lugar de medir la duración de dicha “a”, que es lo normal.

Como se aprecia, ponemos que Sacadif.32 genera dos ficheros del tipo de los *.dur y *.nn, sin embargo los dota de otra extensión: *.dep; así, los que antes eran *.dur ahora

son DepurDUR.dep y los que eran *.nn ahora serán Depuraf0.dep. De los del primer

tipo se pueden sacar los ficheros *.in, pero de los del segundo tipo no se puede por

carecer de la información sobre el tono de la sílaba.

En estos ficheros aparece la misma información que en el *.crr en el que aparecen

las correcciones citadas anteriormente.

Una vez que son extraídos los difonemas de la frase, el siguiente paso a seguir es

generar una pequeña base de datos con dichos difonemas para realizar más tarde la

resíntesis de la frase y comprobar de este modo que los difonemas han sido bien

generados. Para ello, en primer lugar se ejecuta el programa Lista.per, con lo que se

cambia el formato de los ficheros de *.di al formato que lee el programa Gendb32.exe (que es el encargado de generar la base de datos).

Este cambio de formato viene motivado por las nuevas características que se deben

almacenar en la base de datos para la posterior selección de unidades.

Una vez efectuado el cambio de formato, tras lo cual se obtiene el fichero

Listetiq.lis, se ejecuta el programa Gendb32.exe, que recibe como argumentos este

fichero y el nombre del fichero que va a contener la base de datos (*.dfm). El programa

va tomando la información contenida en los ficheros *.mst y *.mar asociados a los

distintos difonemas que aparecen en Listetiq.lis, y la va almacenando en el fichero de la

base de datos. Además de obtenerse como resultado el fichero *.dfm con la base de

datos en sí, también se generan, entre otros, un fichero con extensión *.mfd que contiene




la misma información que el *.dfm pero en formato texto, y un fichero con extensión

*.gdb con información de depuración.

El último paso en la resíntesis consiste en la ejecución del programa Conca32.exe, que recibe como argumento de entrada el fichero *.di que había generado Sacadif32.exe y genera el fichero con la frase sintetizada (Pru.mst) y un fichero con extensión *.dpc que contiene información de depuración.

Al final de todo el proceso se comprimen todos los ficheros generados por los

distintos programas en un fichero con el nombre de la frase y con extensión *.arj, y se

almacena dentro del directorio correspondiente a la frase.

4.2.5 ProcesoEl proceso comienza con una llamada de LeeParametros a CreaFonemas, el cual

lee el fichero *.txt y convierte de grafema a fonema (mediante Graf2Fon); a continuación

se llama a ConvierteFrase, programa que realiza la conversión de texto a voz, para lo

cual se debe analizar el texto y dividir en palabras. Para realizar todas estas

transformaciones es preciso sacar la frecuencia de los fonemas, su duración y su tono,

realmente podría decirse que se está llevando a cabo un proceso de sintetizar la

prosodia.

El primer paso para realizar la síntesis es un pre-procesado mediante el cual se

analizan las abreviaturas y las siglas y se expanden. Cabe destacar que los ficheros *.txt no tienen ni abreviaturas ni siglas y que se trabaja a nivel de palabra.

El siguiente paso es realizar un pausado: consiste en insertar pausas en una frase

muy larga donde sea adecuado y conveniente, así, no meteremos una de estas pausas,

por ejemplo, entre “la” y “casa”. Estas pausas vienen marcadas por signos de puntuación

pues el sintetizador no se debe inventar nada.

El tercer paso es la conversión de cada palabra y/o cada letra a fonema mediante el

programa Graf2Fon.

Lo siguiente a realizar es la conversión de cada cadena de palabras en una cadena

de fonemas (de símbolos fonéticos realmente).




Quinto paso: comparar fonemas del fichero con extensión *.par con los que genera el

ConvierteFrase. Los fonemas de un sitio y del otro deben ser compatibles aunque se

admiten diferencias (en la rutina FonemasCompatibles). Ejemplos de fonemas

diferentes pero compatibles son la tilde de un acento; “ll” o “y” son equivalentes; signos

de puntuación compatibles con pausas; en el caso de vocales nasalizadas, el *.txt las

identifica mientras que el *.par no, pero son igualmente fonemas compatibles; “b”, “d”, “g”

son sonidos aproximantes u oclusivos, prevalece lo que tenga marcado el *.txt sobre lo

que tenga el *.par; etc.

El fichero *.txt siempre debe estar bien escrito, por el contrario, el *.par puede tener

pequeños fallos; como regla general, siempre prevalece lo del *.txt sobre lo del otro

fichero. La causa de que el *.par pueda tener algún fallo es que es más simple y se

construye más rápidamente.

El sexto paso consiste en aplicar un módulo de duraciones y de f0 (en la rutina

EntonacionDuracionNN). Este módulo recibe una secuencia de fonemas, se pone en el

primero de ellos, busca la siguiente pausa y procesa lo que hay entre medias, y se

repiten estos pasos hasta el final de la frase. El procesamiento al que nos referimos

consiste en calcular los parámetros de entrada a la Red Neuronal, esta información se

vuelca posteriormente en DepurDUR y en Depuraf0. La salida se obtiene del *.par. Se

lee del *.par y se guarda en fonemas secuencia, mientras que lo del *.txt va a fonini. Estas dos estructuras se han comparado previamente y se ha determinado que son

compatibles.

En FraseTon se guarda el texto para su división en sílabas. Los fonemas se pasan a

letras y tenemos un silabicador. Sin embargo, se presenta el problema de que este

proceso puede tildar más sílabas que las que había en un principio.

A continuación se llama a Silabica, con lo que se calcula el número de sílabas del

texto y dónde comienza y acaba cada una de ellas. La información de las sílabas aparece

en Silabas.x, FraseTon.x contiene el texto no original, Fonemas_de_pal.x contiene en

qué fonema comienza cada palabra y Sil_dur.x contiene dónde acaba cada sílaba.

Además, cada fonema tiene un flag que indica si es fin de palabra o no [Montero-01].




4.3 Segundo grupo de programas4.3.1 Introducción

Vamos a detallar a continuación el conjunto de programas que nos van a permitir

realizar experimentos, y van a ser la base de este proyecto, ya que, con ellos, vamos a

obtener resultados que nos van a permitir decidir sobre la conveniencia o no de incluir

ciertos parámetros como argumentos de entrada a la Red Neuronal.

Para llevar a cabo un experimento es necesario realizar llamadas a distintos

programas, cada uno de los cuales tiene su propia función dentro de todo el proceso. Así,

cada programa consta básicamente de una primera parte en la que se realizan

determinados cálculos, y de una segunda en la que se llama al siguiente programa en la

cadena de programas que se ha comentado. Más adelante entraremos con más detalle

en cada uno de estos programas.

Cabe destacar que el lenguaje de programación no es homogéneo, y tan pronto nos

encontraremos programas escritos en C, como en Perl o como en los scripts de MS-DOS.

Al proceso necesario para realizar un experimento se le ha dotado de una

automatización prácticamente completa, entendiendo por automatización el hecho de que

los programas se encargan, por sí mismos, de hacer las llamadas a los siguientes

programas.

De lo único que nos tenemos que preocupar cuando queremos lanzar un

experimento, es de rellenar los ficheros *.lis (que más adelante se explicarán) con los

valores apropiados de acuerdo con el experimento (o experimentos) que deseemos llevar

a cabo. Y además, de cambiar el número de experimento en el programa Newexper.bat, que nos será muy útil para diferenciar unos experimentos de otros con sólo ver su

nombre, ya que éste número aparecerá al comienzo del nombre del experimento.

Una vez que hayamos modificado los dos puntos anteriores, ya sólo tenemos que

escribir Newexper.bat por la línea de comandos y darle al “Enter”, del resto del proceso

hasta completar el experimento completo, incluida la fase de obtención de resultados, ya

no tenemos por qué preocuparnos. De aquí que digamos que la automatización del

proceso es prácticamente completa.




4.3.2 Prenewexper.batEs un sencillo script en el que se da un valor a la variable global

NUMERO_EXPERIMENTO para nombrar de alguna manera a los distintos experimentos

que se van a realizar y distinguir así unos de otros. También, en este programa se ponen

los números de las frases con que se van a realizar los experimentos, es decir, se carga

de manera automática el fichero Frases.lis. En esto se diferencia del resto de estos

ficheros, ya que los demás se deben rellenar de manera manual abriendo cada uno de

ellos. El objetivo de esta forma de proceder para Frases.lis es poder hacer experimentos

de manera consecutiva con distintos conjuntos de frases aunque con los mismos valores

de los parámetros.

1 2

1 2 3 4 1 2 1 2 3

PRENEWEXPER.BAT

NEWEXPER.BAT

SUSTITUY.PER

AL3EXPER.BAT

AL22EXPER.BAT

EXPERIM.BAT

EJEMPLO.EXE

WC.BAT

NEWCODE22.PER

EXCEL.BAT

WC.PER

EXCEL.PER

SUSTITUY.PER

MEDIA.PER

RESULT.PER

Figura 5-4: Relación entre los programas.




4.3.3 Newexper.batSe trata del segundo programa de la larga sucesión de los mismos que se

necesitarán para completar cualquier experimento. Básicamente, es el encargado de

rellenar con los datos adecuados los distintos ficheros que se deben preparar para lanzar

un experimento, tanto en las fases de entrenamiento de la Red Neuronal, como en la de

evaluación y en la de test; es una tarea que, a simple vista, puede parecer bastante

sencilla pero que en absoluto lo es. Este programa incluye otras funcionalidades además

de la ya citada que pasamos a describir con más detalle a continuación.

En primer lugar, tal y como se explicó en la introducción anterior, debemos dar un

número distinto a cada experimento con el fin de distinguir y clasificar los distintos

experimentos que vayamos realizando a lo largo del proyecto. Para ello, simplemente

cambiamos el valor asignado a la variable NUMERO_EXPERIMENTO. Como ya se

comentó, es uno de los pasos que se deben hacer a mano.

El propio programa se encarga de llamar a otro, llamado Sustituy.per (escrito en el

lenguaje de programación Perl), que lo único que hace es sustituir un valor por otro; estos

valores se pasan como argumentos junto con el nombre del programa; en este caso, el

primer argumento es el que se debe buscar para reemplazarlo por el segundo.

Así, Newexper.bat busca en los directorios adecuados los ficheros *.nn de todas las

frases que vayan a intervenir en cada experimento y los copia en el fichero Dep0.lis. Pero el listado de estos ficheros debe aparecer sin la extensión, y para suprimirla

hacemos la primera llamada a Sustituy.per, de tal forma que busque la cadena “.nn”

todas las veces que aparezca y la sustituya por la cadena vacía “”, es decir, que

realmente no hace otra cosa que suprimir la extensión de los ficheros y copiar el

resultado en el fichero Exp*.lis, donde, en el lugar del asterisco, se pone el número del

experimento (lo hace el programa, por supuesto).

El siguiente paso es generar la lista de los diez subexperimentos de que consta cada

experimento; para ello, tenemos una lista patrón en Experim.lis que no es otra cosa que

una sucesión de los siguientes valores: 1_1, 1_2, y así hasta 1_10. Simplemente, esto

nos ayuda a identificar cada subexperimento dentro de un experimento. Mediante una

llamada a Sustituy.per conseguimos que se sustituya el primer uno por el número del




experimento actual (NUMERO_EXPERIMENTO) y que el resultado quede almacenado

en Dep*.lis.

Figura 5-5: Ejemplo de fichero *.nn.

Figura 5-6: Ejemplo de fichero exp*.lis.

El siguiente paso consiste en definir una serie de variables e inicializarlas a unos

valores determinados. Entre estas variables destacaremos dos:

o CONTADOR: lo usaremos para el número total de archivos *.nn con que

contaremos para cada experimento.

o BASE_DIV: a la que daremos un valor fijo de diez, ya que ése será el número

total de conjuntos de ficheros que generaremos y, de los cuales, unos cuantos se

emplearán en el entrenamiento, otros en la evaluación y otros en el test.




Precisamente, este último proceso de generar conjuntos de ficheros y realizar

distintas agrupaciones para las tres fases de que consta el proceso de reconocimiento de

la voz es lo más complicado del programa. Lo vemos a continuación.

Para hacer los diez ficheros (que realmente son conjuntos de ficheros) usamos el

resto de la división, de forma que, si nos quedamos con el resto de dividir el valor de la

variable CONTADOR más 0, 1, 2, ..., 9 entre BASE_DIV, obtendremos diez conjuntos

diferentes, que serán, en primer lugar, todos los ficheros Bv*.nn cuyo número termine en

0, en segundo lugar, los ficheros que terminen en 1, y así sucesivamente hasta agrupar a

todos aquellos que terminen en 9. Estos ficheros se guardan con extensión *.txt.

A continuación, se agrupan siete de estos ficheros-conjunto de ficheros y se dedican

para el entrenamiento de la Red Neuronal, otros dos se dedican para la fase de test y el

restante para la fase de evaluación.

Además, se incluye un bucle de forma que estas asignaciones tengan carácter

circular, es decir, que si en la primera iteración hemos dedicado los ficheros primero,

segundo, tercero, cuarto, quinto, sexto y séptimo para el entrenamiento, el octavo para la

evaluación y el noveno y décimo para el test, en la siguiente iteración los que

dedicaremos para el entrenamiento serán del segundo al octavo mientras que el noveno

lo emplearemos para la evaluación y serán el décimo y el primero los que emplearemos

para la fase de test. Se recorrerá el bucle sucesivamente hasta que no queden más

opciones, por lo tanto, se harán diez iteraciones.

El siguiente paso es llamar al programa Al3exper.bat ya que Newexper.bat ha

terminado sus tareas.

4.3.4 Al3exper.batEn un principio, se ejecutaba “a mano” Newexper.bat y a continuación se procedía a

ejecutar este programa para llevar a cabo cualquier experimento, pues a partir de este

programa, la automatización sí que era total prácticamente hasta el final del proceso, ya

que éste se encarga de llamar al siguiente programa (que es Al22exper.bat, como luego

veremos), y el siguiente al siguiente, y así sucesivamente hasta, casi, el final de la

cadena. Sin embargo, en una posterior revisión de los programas, se decidió dar una




vuelta de tuerca más y llevar a cabo la automatización completa de que hablábamos

antes.

En primer lugar, este archivo por lotes va recorriendo, uno detrás de otro, unos

archivos con extensión *.lis, en los cuales se encuentran los valores que damos a cada

variable. Estos valores son los que determinan el total de experimentos que se van a

realizar y cuáles van a ser, que es el objetivo de Al3exper.bat.

Estas variables se detallan a continuación, donde también se explica la función que

tiene cada una de ellas [Montero-01]:

o ZSCORE: para indicar al programa si se va a usar o no esa codificación de las

salidas.

o NEURONAS_OCULTAS: tamaño de la capa oculta de la Red Neuronal.

o MODO_NORM: indica la media y el rango que usaremos para normalizar los

datos con los que trabajaremos (primero se resta por la media y luego se divide

por el rango).

o INICIO: indica si una sílaba es inicial o no; para ello, debe encontrarse en el rango

que va desde la primera sílaba de la palabra hasta la primera acentuada, ambas

inclusive. Puede tomar los valores 0 y 1.

o FIN: indica si una sílaba es final o no; para lo que, dicha sílaba debe estar situada

entre la anterior a la última tónica y la última sílaba, ambas inclusive. Puede tomar

los valores 0 y 1.

o ACENT: señala si una sílaba es tónica o no. Al igual que las dos anteriores, sólo

puede tomar los valores 0 y 1.

o SILABAS: codifica el número de sílabas. Puede tomar los valores 0, 1 y 2. Hay

dos tipos diferentes de codificaciones, que se verán más adelante cuando se

explique el programa Newexper22.per.

o CONTEXTO: es el tamaño de la ventana de ACENT, INICIO y FIN. Indica el

número de sílabas a izquierda y derecha de la actual que tenemos en cuenta para

procesar dicha sílaba. Puede valer 0, 1, 2, 3, 4 ó 5. Así, por ejemplo, si la variable

vale 2, quiere decir que realmente la ventana de observación que se está tomando




es de 5 sílabas, que son la actual, 2 a su izquierda y otras 2 a su derecha. Si vale

0, evidentemente, significa que sólo se tiene en consideración la sílaba actual y no

se va a evaluar el efecto que sus vecinas tendrán sobre ella.

o FREC_ANT: es la frecuencia de la sílaba anterior. Puede valer 0 ó 1.

o NUMERO_FRASE: es un valor que sirve para identificar la frase. Puede valer 1 y

19.

o TERMINAC: lo usamos para codificar el tipo de terminación (signos de

puntuación) que, de alguna manera, indica el tipo de grupo fónico de cada frase.

Se consideran cuatro signos de puntuación: el punto (“.”), la coma (“,”), el punto y

coma (“;”) y el guión (“-”). Los valores que puede tomar son 0, 2 y 4. La

codificación de esta variable es de tipo binario: cada signo de puntuación tiene un

bit asignado y sólo se puede activar uno de ellos cada vez.

o TERMINAC_ANT: tiene el mismo significado que TERMINAC pero añade la

posibilidad de tener también en cuenta el comienzo del grupo fónico. Sus valores

pueden ser 0 ó 5.

o PAL_FUNC: indica el modo de codificar si la palabra es o no una palabra función.

Puede tomar los valores 0, 1 y 3.

o NUM_PAL: codificación del número de palabras dentro del grupo fónico. Los

valores que puede tomar son 0 y 1.

o POS_PAL: señala la posición de la palabra dentro del grupo fónico. Puede valer 0

y 1.

o FIN_PAL: señala si la sílaba considerada, la anterior y la siguiente son final de

palabra o no. Al igual que PAL_FUNC, puede tomar los valores 0, 1 y 3.

En función de los valores que reciban todas estas variables se calculan un número y

una expresión que se asignarán a ENTRADAS y a COMENTARIO, respectivamente;

éstos sirven para diferenciar unos experimentos de otros y para que se ejecuten de forma

adecuada. La forma de calcular la variable ENTRADAS depende de los números que

hayamos asignado a INICIO, FIN y ACENT, y se corresponde con el número de neuronas

que tendrá la primera capa de la Red Neuronal.




Todos los valores que toman estas variables para cada experimento quedan

recogidas en el fichero Allexper.dep. Cada fila de este fichero se corresponde con un

experimento, por lo tanto, se deberán realizar tantos experimentos como filas haya.

A continuación, este programa hará su primera llamada a otro, en este caso, a

Al22exper.bat.

4.3.5 Al22exper.batSe trata de un sencillo programa que simplemente recorre las líneas del fichero

Allexper.dep y llama a Experim.bat para que se ejecute el experimento correspondiente.

En primer lugar, y para cada línea del citado fichero, lee los valores de cada variable

así como de ENTRADAS y de COMENTARIO. Para esto usamos la función “Word”, con

la que asignamos un valor separado por espacios en blanco a una variable.

Figura 5-7: Ejemplo de uso de la función Word de 4DOS.

A continuación, y en función del valor de la variable TERMINAC se hace la llamada

al archivo por lotes Experim.bat, al cual se le pasan como parámetros, por este orden,

ENTRADAS, NEURONAS_OCULTAS, ACEN, INICIO, FIN, CONTEXTO, SILABAS (cinco veces), una sucesión de ceros y unos, PAL_FUNC, NUM_PAL, POS_PAL, FIN_PAL, MODO_NORM, COMEN, TERM_AN, FREC_AN, NUMERO_FRASE y ZSCORE.

La citada “sucesión de ceros y unos” es un conjunto de quince números con valores

diferentes, en su conjunto, para los tres tipos de experimentos que se pueden lanzar




atendiendo a los valores de TERMINAC (ya que esta variable sólo puede tomar los

valores 0, 2 y 4).

Centrémonos un poco más en la función “Word” que se mencionaba más arriba. Se

trata de una función de 4DOS a la que se le pasan como argumentos de entrada un

número natural y una línea determinada de un fichero, en nuestro caso este fichero es

Allexper.dep. En este programa, esta función se usa para ir leyendo cada una de las

variables que quedan escritas en cada línea del citado archivo y asignar sus valores a las

variables adecuadas. “Word” tiene la peculiaridad de que diferencia los espacios en

blanco de lo que no lo son, y de ahí su utilidad en este proyecto: lee un dato y se lo

asignamos a una variable, a continuación reconoce un espacio en blanco, y el siguiente

dato se lo asignamos a otra variable, y así hasta el final de cada línea. El número natural

al que nos referíamos antes representa el orden de cada dato en cada línea, así, el

primer dato llevará asociado el número cero, el segundo el uno, etc.

4.3.6 Experim.batSe trata del tercer programa en la cadena que hemos formado para realizar los

experimentos. Como ya sabemos, es llamado por Al22exper.bat y presenta la

peculiaridad de que llama a cuatro programas y no a uno solamente. Éstos programas

son Ejemplo.exe, Newcode22.per, Wc.bat y Excel.bat; el primero de ellos es el

ejecutable de un programa escrito en el lenguaje de programación C, el segundo está

escrito en Perl y el tercero y cuarto son otros archivos por lotes de MS-DOS.

Experim.bat comienza tomando los parámetros que le interesan de entre todos los

que le pasa Al22exper.bat, estos parámetros son: ENTRADAS, NEURONAS_OCULTAS, MODO_NORM, COMENTARIO, TERM_AN, FREC_AN, NUMERO_FRASE y ZSCORE. Y con ellos crea directorios con nombres suficientemente

representativos de los experimentos como para distinguir unos de otros.

A continuación, para cada experimento crea un conjunto de diez “subexperimentos“,

que se nombrarán como un cierto nombre seguido de *_1, *_2, *_3, ..., *_10, donde el

asterisco se sustituye por el número de ese experimento concreto. Cada uno de ellos da

lugar a un subdirectorio diferente, de tal forma que, para cada experimento tendremos

diez subdirectorios diferentes.




Figura 5-8: Ejemplo de directorios y subdirectorios creados al llevar a cabo los experimentos.

Cada uno de estos subexperimentos consta de tres partes: la parte de

entrenamiento, la parte de test y la parte de evaluación de los resultados. Para cada una

de estas partes se generan dos ficheros en el directorio correspondiente, uno con

extensión *.in y el otro con *.nn. Además, dentro de cada subdirectorio aparecerán otros

dos ficheros: uno con extensión *.dep y el otro de nombre Salida.out, pero éstos dos los

veremos más adelante con más detalle, por ahora, basta decir que contienen parámetros

de salida (hasta ahora sólo habíamos visto ficheros que contenían parámetros de

entrada).

Para comprender un poco mejor la notación que se emplea al nombrar cada

experimento y los ficheros que se generan, vamos a ver un ejemplo: supongamos que

hemos dado a las variables de entrada los valores que generan el siguiente experimento:

e1_nozs_n_81_5_1__f19_m_110_150__c_nozs_110_150_1_1_1_5_5_4_1_1_1_1_5_5_0_19




Para empezar se crea un directorio con el nombre del experimento. Dentro de ese

directorio se crean, a su vez, diez directorios (subdirectorios) más, que llevarán por

nombre: Exp1_1, Exp1_2, Exp1_3, ..., Exp1_10.

Y dentro de cada uno de estos subdirectorios tendremos un total de ocho ficheros.

Por ejemplo, para el subexperimento Exp1_1 del experimento anterior tendremos los

siguientes ficheros:

o EVAL_1_1_e1_nozs_n_81_5_1__f19_m_110_150__c_nozs_110_150_1_1_1_5_5

_4_1_1_1_1_5_5_0_19.in.

o EVAL_1_1_e1_nozs_n_81_5_1__f19_m_110_150__c_nozs_110_150_1_1_1_5_5

_4_1_1_1_1_5_5_0_19.nn.

o TEST_1_1_e1_nozs_n_81_5_1__f19_m_110_150__c_nozs_110_150_1_1_1_5_5

_4_1_1_1_1_5_5_0_19.in.

o TEST_1_1_e1_nozs_n_81_5_1__f19_m_110_150__c_nozs_110_150_1_1_1_5_5

_4_1_1_1_1_5_5_0_19.nn.

o TRAIN_1_1_e1_nozs_n_81_5_1__f19_m_110_150__c_nozs_110_150_1_1_1_5_

5_4_1_1_1_1_5_5_0_19.in.

o TRAIN_1_1_e1_nozs_n_81_5_1__f19_m_110_150__c_nozs_110_150_1_1_1_5_

5_4_1_1_1_1_5_5_0_19.nn.

o e1_nozs_n_81_5_1__f19_m_110_150__c_nozs_110_150_1_1_1_5_5_4_1_1_1_

1_5_5_0_19.dep.

o Salida.out.

Figura 5-9: Ficheros que genera Experim.bat.




El siguiente paso que da este programa es llamar a Newcode22.per, al que le pasa

los argumentos adecuados (todos excepto ENTRADAS, NEURONAS_OCULTAS, COMENTARIO y ZSCORE). Tras esta llamada, se hace otra a Ejemplo.exe y, del

resultado de la ejecución de todos estos programas, se copia en Salida.out la

información que nos interesa (porcentaje de aciertos conseguidos, error cuadrático

medio, error medio, error absoluto, desviación típica, valor medio, valor máximo, valor

mínimo, error relativo, tasas de ejemplos e iteración máxima a la que se ha llegado). Para

finalizar con este programa, se llama a Excel.per.

A partir de Experim.bat ya se comienza a lanzar los experimentos propiamente

dichos. Como hemos visto, hasta ahora no habíamos hecho más que preparativos para

ellos, pero preparativos que son indispensables, tanto para lanzar los experimentos que

realmente queremos como para su mejor comprensión.

4.3.7 Newcode22.perComo ya se ha comentado anteriormente, se trata de un programa escrito en el

lenguaje de programación Perl. Básicamente, este programa lee una serie de parámetros

(en total treinta y tres) que le pasa Experim.bat y los codifica en función de sus valores

para, a continuación, pasárselos como entradas a la Red Neuronal.

Este programa lee ficheros *.nn y genera otros con extensión *.in. Los primeros

contienen tres campos diferentes: “i”, “o” y “a”, mientras que los segundos sólo contienen

los campos “i” y “o”. Éstos son generados por este programa a partir de los tres campos

de los ficheros *.nn a través de diferentes codificaciones y transformaciones.

Figura 5-10: Ejemplo de fichero *.in.




El primero de ellos (“i”) precede a una línea que contiene valores codificados en

binario. El número de estos valores binarios es variable y depende de los parámetros que

hayamos incluido en los ficheros *.lis. Para empezar, se crean unas variables llamadas

“Inicial”, “Final”, “Tonica” y “Pre_ult_ton”.

Una primera codificación tendrá en cuenta los valores que tomen estas variables que

acabamos de nombrar; en primer lugar, se hace una distinción en función de si ACENT, INI o FIN valen 1 alguna de ellas, si valen 0 las tres al mismo tiempo o si valen 25 las tres

simultáneamente. Según el grupo en que se encuentre nuestro experimento se pasará a

una segunda clasificación teniendo en cuenta los valores de las variables “Inicial”,

“Tonica” y, en ocasiones, “Final” y “Pre_ult_ton”. En función de todos estos valores (y de

los siguientes) se escribirán en los ficheros o bien ceros o bien unos, y la longitud de

cada campo “i” también vendrá dada por todos estos valores [Montero-01].

Así, si valen 0 las tres variables, ACENT, INI y FIN, se codifican los siguientes casos

con siete bits (el número de bits con que se realiza la codificación marca, de alguna

manera, la profundidad de dicha codificación):

o Caso en que la sílaba es inicial y tónica.

o Caso en que es inicial y átona.

o Caso en que es no inicial, no final y tónica.

o Caso de ser no inicial, no final y átona.

o Final, no inicial y tónica.

o Final, no inicial y átona posterior a la última tónica.

o Final, no inicial y átona anterior a la última tónica.

Como se puede apreciar, en esta codificación, si una sílaba es inicial y final al mismo

tiempo, puede corresponder a dos casos diferentes: única tónica o anterior a la única

tónica. En esta codificación, si se da este caso, dicha sílaba se codificará como inicial.

Si ACENT, INI y FIN valen las tres 25, codificamos los siguientes casos, en esta

ocasión con seis bits:




o Caso de ser la sílaba inicial y tónica.

o Caso de ser inicial y átona.

o No inicial, no final y tónica.

o No inicial, no final y átona o final, no inicial y átona anterior a la última tónica.

o No inicial, final y tónica.

o No inicial, final y átona posterior a la última tónica.

Tras realizar varios experimentos, se comprueba que esta última codificación

funciona bastante mal, en contra de lo que se esperaba de ella. Una de las razones es

que, en el cuarto punto, la sílaba anterior a la última tónica se ve influenciada por la

última tónica y se parece a la zona final. Por tanto, habría que codificarla como si

estuviera en la zona final en vez de estar en la anterior. Para solucionar este problema se

creó la codificación con siete bits, en la que las tres variables, ACENT, INI y FIN, valen

simultáneamente 15, y en la que se distinguen los siguientes casos:

o Si la sílaba es inicial, no final y tónica.

o Si es inicial, no final y átona.

o Si es no inicial, no final y tónica.

o Si es no inicial, no final y átona.

o Si es final y tónica.

o Si es final y átona anterior a la última tónica.

o Si es final y átona posterior a la última tónica.

En esta caso y, a diferencia de lo que pasaba en la codificación en que las tres

variables que estamos tratando valían 0 simultáneamente, si una sílaba es inicial y final al

mismo tiempo, se codifica con las finales.

En cualquier otro caso, es decir, si al menos una de entre ACENT, INI y FIN, vale 1,

la codificación tendrá una profundidad igual al número de estas variables que valgan 1.




Los siguientes valores que se codifican dependen de la variable TERMINAC_ANT; en primera instancia se decide realizar codificación solamente si la anterior variable vale

5, y si es así, se codifica en función del valor que tome el quinto elemento del campo “a”,

que puede valer 0, 5, 6, 7 o 11. Este elemento estará relacionado con TERMINAC_ANT, lógicamente.

La siguiente codificación depende de NUM_PAL, FIN_PAL, PAL_FUNC y POS_PAL [Montero-01].

Como ya se explicó anteriormente, NUM_PAL se usa para tener o no en

consideración el número de palabras dentro de cada grupo fónico. Sus valores pueden

ser 0 y 1. En el caso de valer 1 (se considera dicho número de palabras), se emplean tres

bits para su codificación, que indican si el grupo fónico contiene una palabra, dos o más

de dos.

Para el caso de PAL_FUNC, como ya sabemos, los valores que puede recibir son 0,

1 y 3:

o Si vale 0 no se tiene en cuenta este término.

o Si vale 1, se codifica si la palabra a la que pertenece la sílaba es palabra función o

no.

o Si vale 3, se usan tres bits en la codificación, que indican, cada uno de ellos, si la

sílaba anterior a la de estudio pertenece a una palabra función o no, y lo mismo

para la sílaba actual y para la siguiente.

Para FIN_PAL, el tratamiento es análogo al de PAL_FUNC, ya que, al igual que

ésta, puede tomar los valores 0, 1 y 3.

Para POS_PAL, que sólo puede valer 0 y 1, la codificación sigue el modelo de

NUM_PAL.

El siguiente bloque que se codifica tiene que ver con la variable SILABAS. Como ya

sabemos, los valores que puede tomar esta variable son 0, 1 y 2.

o Se asigna el valor 1 si se codifica con los números 0, 5, 10, 15 y 20.




o Se asigna el 2 si se codifica con los números 0, 3, 7, 10 y 15.

o En caso de no considerar ninguna codificación, se asigna el valor 0.

Para realizar esta codificación se compara el valor de cada variable con unos

umbrales. De esta manera lo que se consigue es implementar una codificación de tipo

termómetro, es decir, que si, por ejemplo, una frase tiene diez sílabas, a los números 0, 5

y 10 se les asignará el valor 1, y a 15 y 20 se les asignará un 0.

Se continúa codificando para los casos en que “term1”, “term2”, “term3”,... “term15”

sean mayores que cero y también para el caso en que “f0_ant” sea igualmente mayor que

cero. La última comparación que se efectúa en esta parte del programa tiene que ver con

el valor de “numero_frase”, realizándose codificación, al igual que antes, si su valor es

mayor que cero. Aunque usemos 19 frases diferentes como base de este proyecto, el que

se asigne el valor 19 a esta variable no quiere decir que se esté usando

permanentemente la frase número 19, sino que, únicamente, aparece ese 19 porque es

el valor que se utiliza cuando se realiza el cálculo del número de neuronas de entrada a

la Red Neuronal en Al3exper.bat.

Veamos qué información contiene ese campo “a” al que tanto hemos nombrado

hasta ahora. Los dos primeros valores se corresponden con las frecuencias

fundamentales mínima y máxima de la frase en cuestión y los siguientes valores tienen

que ver con la terminación anterior, las sílabas, si las sílabas son final de palabra, si

pertenecen a la última palabra, etc. Los parámetros que nos encontramos en este campo

son los que usaremos preferentemente para realizar las codificaciones que venimos

explicando.

Lo siguiente que nos encontramos en Newcode22.per es la codificación del campo

“o”, la cual dependerá del modo de normalización que hayamos seleccionado y aparecerá

en una línea a continuación de la del campo “a” en los ficheros de salida que genera este

programa. Para calcular la frecuencia fundamental, nosotros restaremos a nuestro valor

anterior de f0 una media (110) y dividiremos el resultado por una rango (150), con lo que

realizaremos una normalización del resultado. Básicamente, esta es la única

transformación que se llevará a cabo en este campo, ya que el resto de parámetros que

aparecerán simplemente serán los del campo “o” del fichero de entrada *.nn (f0 no




normalizada, valores óptimos con los que normalizar –en nuestro caso, la media y el

rango-, la sílaba en cuestión y el fichero en el que se encuentra).

4.3.8 Wc.batEste programa busca todos aquellos directorios que comiencen por la letra “e” (por

“exp”) seguida por un número (que será el número que asignemos a cada experimento),

es decir, busca todas las carpetas de experimentos que haya en el directorio desde el

cual se lanza el programa, y copia los nombres de dichos experimentos en Wc.dir.

A continuación, calcula el tamaño de cada uno de los diez subexperimentos que

componen un experimento. Estos tamaños serán diez números que se deben pasar al

programa Media.per como argumentos de entrada.

Para calcular estos números se llama a otro pequeño programa, Wc.per, el cual, lo

único que hace es incrementar un contador de acuerdo con la cantidad de parámetros

que vaya leyendo para cada experimento.

No es necesario pasarle a Media.per el tamaño exacto de cada subexperimento, en

el sentido de que da igual pasarle los diez tamaños exactos que pasarle números

proporcionales al tamaño real (sí es necesario que la constante de proporcionalidad sea

la misma para todos los subexperimentos) ya que más tarde se va a realizar una

normalización de estos tamaños, con lo que la constante de normalización (en caso de

que la haya) se va a eliminar.

El resultado quedará recogido en el fichero Wc*.wc junto con el tamaño total del

experimento, que se calcula como la suma de los tamaños de los diez subexperimentos

dividida por cuatro. La razón de efectuar esta división tiene que ver con que tomemos

cada fichero *.nn más de una vez en los procesos de entrenamiento, test y evaluación de

la Red Neuronal [Montero-01].




Figura 5-11: Ejemplo de fichero *.wc.

En una versión anterior de todos estos programas, al llegar a este punto, se debía

detener la ejecución, ya que, tras obtener Wc.bat estos valores, el siguiente programa,

Media.per, no los leía directamente, como pasa ahora. Por lo tanto, estos valores se

copiaban “a mano” de Wc*.wc y se pegaban en las primeras líneas de Media.per, con lo

que la ejecución de un experimento debía hacerse en varias etapas; este problema está

solucionado actualmente.

Se debe señalar una llamada que existe al final de Wc.bat al programa Sustituy.per, cuyo cometido es el de presentar en la misma línea los parámetros que se calculan, en

vez de presentarlos en líneas diferentes, de forma que facilitemos las tareas de lectura al

siguiente programa. Para tal fin, se debe sustituir el carácter retorno de carro “\n” por un

espacio en blanco.

4.3.9 Ejemplo.exeComo ya hemos dicho, es el ejecutable de un programa escrito en lenguaje de

programación C, y es el programa que simula la Red Neuronal [San Segundo-00].

Recoge por su entrada los ficheros que genera Newcode22.per y hace funcionar la Red,

la cual nos da unos resultados que más tarde trataremos adecuadamente para obtener la

información que deseamos.

Dentro de este apartado titulado como Ejemplo.exe se van a explicar conjuntamente

los programas Ejemplo.c, Redneuro.c, Estad.c, Normaliz.c y también Impr_fin.c, ya

que, aunque el programa principal es Ejemplo.c, realiza llamadas a funciones que están

en los otros programas.

El programa empieza comprobando que el número de parámetros que recibe por su

entrada es el adecuado (a lo largo de éste y de todos los demás programas en C se

realizan numerosas comprobaciones, muy habituales por su utilidad al programar en este

lenguaje). A continuación, se leen los ficheros que contienen los vectores de

entrenamiento, de evaluación y de test. En la función que se encarga de abrir y cerrar los

ficheros para su lectura, se incluyen unas líneas de código necesarias para leer el

número de parámetros de las líneas “i” de estos ficheros, que nos van a dar el número de

neuronas que habrá en la capa de entrada de la Red Neuronal. El siguiente paso dentro




de esta función es leer una por una las líneas de los archivos, que deben tener formato

de MUME (un conjunto de líneas con la siguiente estructura: una “i” seguida de un grupo

de números, y a continuación, un punto y coma, y en la siguiente línea, una “o” más otro

grupo de números también finalizados en punto y coma), para detectar posibles errores

antes de que la Red entre a funcionar de lleno; en esta parte se comprueba que cada

línea comience con una “i” o con una “o” seguida de los números adecuados y que acabe

en punto y coma.

Una vez hechas una serie de comprobaciones, se procede a inicializar la Red

Neuronal, para ello se pasan las neuronas que compondrán cada capa. Así, el número de

la primera capa ha sido calculado previamente y es ese número el que se pasa, el de la

segunda capa lo escribimos nosotros en el archivo Oculta.lis y el de la tercera está fijado

a uno. Además, se da peso cero a cada conexión entre neuronas.

Figura 5-12: Fichero con formato de MUME.

El siguiente paso ya es el de entrenar la Red con los vectores de entrenamiento que

teníamos con anterioridad y obtener los resultados que se obtienen de las fases de

entrenamiento, evaluación y test.

Estos resultados se presentan en forma de valores (predichos y leídos) normalizados

y no normalizados, calculados mediante funciones implementadas en el módulo

Normaliz.c. La diferencia entre los valores predichos y los reales (leídos) es la que nos

va a marcar cómo de buenos son nuestros experimentos, y en función de esos

resultados, se calculará la tasa de aciertos, que será uno de los números críticos que

usaremos para sacar conclusiones de los parámetros que realmente son importantes

para nuestros objetivos.




Concretamente, en Normaliz.c, se incluyen las funciones dzscore (que veíamos con

anterioridad, al principio de este capítulo), para calcular los valores desnormalizados

mediante la fórmula que allí se veía; zscore, para todo lo contrario; y desnormaliza, que

es la función encargada de llamar a las dos primeras y pasarlas los argumentos

adecuados según el modo de normalización que se haya elegido usar.

Los valores estadísticos que nos interesan se calculan gracias al módulo Estad.c. Se

trata de un sencillo programa en el que se cuantifican magnitudes como el error

cuadrático o el error absoluto a partir de los valores predichos y leídos, tanto de los

valores normalizados como de los no normalizados. También calcula valores máximos y

mínimos de errores.

Impr_fin.c es un módulo que se encarga de calcular otros estadísticos

complementarios a partir de los que ya se habían calculado previamente con Estad.c y,

además, los presenta de forma adecuada volcándolos al fichero que se le indique. Así,

calcula valores como el error absoluto medio, el error medio, la desviación típica absoluta

y el error relativo. Todos estos valores los imprime (en el fichero Excel.dep que veremos

más adelante) tanto en unidades sin desnormalizar como en hertzios. Y todos estos

valores aparecerán para cada experimento que realicemos y para las fases de

entrenamiento, de evaluación y de test.

Redneuro.c es el módulo que implementa la Red Neuronal, de ahí su nombre.

Perfectamente se podría decir que Redneuro.c es la Red Neuronal. Entre las funciones

que incluye, están la que inicializa la Red (y que se comentó algunas líneas más arriba);

la que obtiene la salida a partir de los datos de entrada, salida que se dará en forma de

error cuadrático; aquella función que representa la característica de retropropagación

propia de las redes neuronales para esta red en concreto, y que, a partir de los datos de

salida corrige sucesivamente los pesos de las conexiones entre las distintas neuronas

que componen la Red; aquella otra función que calcula la derivada de la función no lineal

de las neuronas; la función que calcula el valor de dicha función no lineal de las neuronas

en cada punto concreto (y que será de tipo exponencial inversa); la función encargada de

guardar los pesos de cada conexión en un fichero binario que tendrá extensión *.wgt; y,

finalmente, la función complementaria de la anterior que lee dichos pesos del archivo

binario en el que se han guardado.




El hecho de utilizar una función no lineal para implementar la Red tiene su

explicación en que es preferible usar una función con derivada continua, y la función no

lineal que vamos a usar, llamada función sigmoidea, cumple tal requisito. Lo ideal sería

usar la función escalón, ya que representa perfectamente el comportamiento de una

neurona: dependiendo de la entrada se activa la conexión entre neuronas (salida = 1) o

no (salida = 0). Esta decisión puede depender de si la salida es capaz de superar un

cierto umbral o no. Sin embargo y a pesar de que esta función escalón representa, como

decimos, el comportamiento ideal de las neuronas, se prefiere usar la función sigmoidea,

muy parecida al escalón y derivable en las inmediaciones de cualquier punto del eje x. El

requisito de que la función derivada sea continua en todos los puntos es necesario en el

algoritmo de retropropagación, pues éste está basado en la minimización del error con

respecto a los pesos, por lo que hay que derivar e igualar a cero.

Como vemos, los programas en C que se usan en esta parte del proyecto, están

dotados de una cierta jerarquía: el programa principal sería Ejemplo.c, el cual realizaría

las funciones de leer los diferentes archivos que se deben abrir, llevaría a cabo el

entrenamiento de la Red Neuronal y la evaluación y el test de los resultados. Pero todo

ello lo realiza usando el resto de módulos (a saber, Estad.c, Impr_fin.c, Normaliz.c y

Redneuro.c), cada uno de los cuales tendrá su propio cometido dentro de toda la

estructura de programas que venimos detallando.

Como consecuencia de la llamada que se hace a Ejemplo.exe desde Experim.bat, se guardan una serie de resultados en el fichero Base.dep, donde “base” es el nombre

de cada subexperimento concreto. Estos resultados se agrupan en bloques homogéneos

y son, entre otros, la media, el contador, la desviación y la banda en cada iteración del

subexperimento en un primer bloque; el error de entrenamiento y de evaluación en cada

iteración en un segundo bloque; y los valores de las frecuencias fundamentales máximas

y mínimas normalizadas y sin normalizar, y otros datos como la media y la varianza por

las que se normaliza, fichero en el que aparece cada frase concreta, errores en unidades

sin normalizar y en hertzios para cada una de las tres fases de las que se compone cada

experimento así como sus porcentajes de aciertos y sus tasas de ejemplos.

Tras realizar Ejemplo.exe todas sus tareas, retorna a Experim.bat, al que no le

queda más que rellenar los ficheros Salida.out (ya comentados anteriormente) de cada




subexperimento con los datos adecuados y borrar los archivos que contienen los pesos

de las conexiones de la Red Neuronal (aquellos con extensión *.wgt).

Figura 5-13: Ejemplo de fichero Salida.out.

4.3.10 Excel.batA continuación, Experim.bat cede el testigo a este otro archivo por lotes de MS-

DOS. Tanto éste como los demás programas que le siguen se encargan de seleccionar y

presentar datos definitivos para nuestro posterior análisis, y guardarlos ordenadamente

en los archivos que corresponda.

En concreto, Excel.bat recorre el fichero Experim*.dir (siendo el asterisco, como

siempre, el número que hemos asignado al experimento en cuestión), donde se

encuentran recogidos todos los experimentos (se recogen los experimentos, no los

subexperimentos) que se han seleccionado en cada caso concreto, y para cada uno de

ellos pasa a ejecutar los programas en Perl, Excel.per, Media.per y Result.per.

Además, al principio del programa se definen unos ficheros, concretamente,

Excel.dep, Depura.dep y Depura.txt, sobre los cuales, los programas anteriormente

citados van a volcar información.




4.3.11 Excel.perSe trata de un programa que comienza escribiendo una serie de parámetros

siguiendo un orden determinado y va rellenando las líneas sucesivas con los datos de

cada subexperimento siguiendo el mismo orden de los parámetros anteriores, de forma

que cada línea se corresponde con un subexperimento y que, al abrir con el Microsoft

Excel el fichero final de resultados, si elegimos que use como separadores de columnas

los espacios en blanco, cada dato de cada subexperimento quedará perfectamente

alineado en la misma columna con su parámetro correspondiente, de tal manera que

dichos parámetros funcionan como títulos o cabeceras de cada columna.

Los parámetros que citamos hacen referencia (por este orden) al nombre del

experimento en cuestión, al número de neuronas de la primera, segunda y tercera capas

de la Red Neuronal, al número de la frase, al modo de normalización, al “zscore”, a la

media y el rango por las que normalizamos (para este modo de normalización), a si las

palabras son acentuadas, iniciales o finales o no lo son, al contexto que tomamos, a las

sílabas, a la terminación, a los parámetros PAL_FUNC, NUM_PAL, POS_PAL y

FIN_PAL, al número de neuronas de la capa oculta otra vez, a la terminación anterior, a

la frecuencia anterior, al número de iteraciones al que se ha llegado en cada caso, al

error cuadrático medio, error medio, error absoluto, desviación típica, valor medio, valor

máximo, valor mínimo y error relativo de las fase de entrenamiento y test y, finalmente,

también hacen referencia a la tasa de ejemplos [Montero-01].

Muchos de estos parámetros se repiten o no los vamos a considerar como críticos a

la hora de analizar los resultados, por ello se creará más adelante una plantilla en

Microsoft Excel (Depura.xls) en la que sólo consten los datos que consideremos

realmente importantes y, tras ejecutar un experimento, pegaremos todos los datos que

sacamos del experimento en esta plantilla, de forma que quedarán ocultos aquellos que

no vayamos a usar.

Para colocar cada dato en su columna correspondiente, usaremos el comentario

asociado a cada subexperimento, ya que posee todos los valores asignados a cada

variable. Estos valores aparecen concatenados mediante guiones bajos (“_”), por lo que

no tenemos más que eliminar esos guiones para guardar cada valor de cada variable en

su columna correspondiente, justo debajo de su indicador.




Para realizar esta operación de separar los valores que aparecen entre el carácter

“_” (se usa este carácter en este programa, pero puede ser cualquier otro), se usa la

instrucción “split” de Perl. Ésta no hace otra cosa que dividir un string en un array de

strings, y lo devuelve.

La sintaxis de esta función es: “split /patrón/, expresión, límite”. Si se omite la

expresión, por defecto, se toma el string “$_” de Perl. El argumento patrón es lo que nos

interesa para explicar esta función, ya que es lo que se toma como delimitador de los

distintos campos. Este delimitador debe ser mayor que un carácter. El argumento límite

añade más opciones a esta instrucción; en nuestros programas siempre aparecerá con el

valor de 9999 pero, si se quita, surge el mismo efecto, se trata de un parámetro opcional;

se usa para delimitar el número de caracteres que queremos que aparezcan en cada

array de strings [Man-Perl].

Un ejemplo de uso de esta instrucción es el siguiente:

Print join(‘:’, split(/ */, ‘hi there’))

Que producirá la salida ‘h:i:t:h:e:r:e’.

Ejemplos de usos de esta función en este programa son los siguientes [Jara-00]:

@campos = split(/\s+/, $_, 9999)

@campos_sub = split(/_/, $_, 9999)

Los resultados generados por este programa se guardan en los ficheros Excel.dep y

Depura.dep.

4.3.12 Media.perAl terminar la ejecución de Excel.per, el programa Excel.bat llama a este otro

programa que está escrito en Perl.

Se trata de un programa muy sencillo que lo único que hace es calcular la media y la

desviación de cada parámetro para los diez subexperimentos de un experimento, de

forma que, al final, tendremos un solo conjunto de resultados para cada experimento.




Es necesario que este programa sea capaz de leer los diez primeros parámetros que

se calculan en Wc.bat. Conseguido esto, no tenemos que preocuparnos de posibles

paradas durante el lanzamiento de un experimento, ya que se ha conseguido una

automatización prácticamente total de los mismos.

Por otra parte, los resultados que obtenemos de este último programa quedarán

plasmados en los ficheros Depura.dep y Depura.txt.

4.3.13 Result.perEste programa es el último de todos los que se deben ejecutar para completar los

experimentos deseados.

Es un programa que saca por pantalla unos determinados resultados de interés para

nosotros y, a continuación, los redirige al fichero Depura.txt. Estos resultados a los que

nos referimos van a ser los que más interés tendrán para nuestro análisis posterior que,

como ya sabemos, consiste en determinar qué parámetros de aquellos que le pasamos a

la Red son realmente determinantes en su comportamiento y cuáles no.

Como ya hemos dicho, con este programa finaliza toda la cadena de los mismos

necesaria para ejecutar una serie de experimentos, desde el primer paso, que consistía

en leer los valores de cada variable para configurar los experimentos concretos que se

deben realizar en cada caso, hasta la fase final, en la que se presentan los resultados

finales de cada uno de ellos.

En la siguiente fase de este proyecto el ordenador no nos proporciona más ayuda, ya

que tenemos que ser nosotros mismos los que, a partir de los resultados obtenidos,

seamos capaces de deducir qué parámetros son críticos y cuáles prescindibles.


introduccion - upmlorien.die.upm.es/juancho/pfcs/cmv/programasdef.doc · web viewen este apartado...

Documents