PDF de programación - Reconocimiento de fonemas mediante red neuronal

Imágen de pdf Reconocimiento de fonemas mediante red neuronal

Reconocimiento de fonemas mediante red neuronalgráfica de visualizaciones

Publicado el 18 de Octubre del 2018
269 visualizaciones desde el 18 de Octubre del 2018
49,3 KB
16 paginas
Creado hace 17a (01/01/2003)
/***************************************************************************/
/*** RECONOCIMIENTO DE FONEMAS MEDIANTE RED NEURONAL ***/
/*** ***/
/*** Marco Aurelio Alzate Monroy. Universidad Distrital F.J.C. ***/
/*** Programa de Maestría en Teleinformática. Junio de 1995. ***/
/*** ***/
/*** Este programa captura tramas de señales de voz, detectando las ***/
/*** correspondientes a fonemas vocalizados para encontrarles los ***/
/*** parámetros propios de un modelo predictivo lineal: Coeficientes ***/
/*** LPC, coeficientes de correlación parcial, coeficientes de razón ***/
/*** de área logarítmica, coeficientes de par de espectro en línea y ***/
/*** coeficientes de seno inverso. Cada uno de estos conjuntos de ***/
/*** coeficientes se usan como entrada a una red neuronal de una ***/
/*** sola capa con cinco elementos de procesamiento, cada uno de los ***/
/*** cuales posee 10 entradas para intentar clasificar la trama como ***/
/*** correspondiente a un alófono de alguna de las cinco vocales del ***/
/*** español (al menos del español hablado por el autor del proyecto) ***/
/***************************************************************************/

/***************************************************************************/
// 33 de las funciones utilizadas se encuentran en archivos de encabezado:
#include <stdio.h> // FILE, fopen, fscanf, fprintf, fclose
#include <stdlib.h> // exit, ltoa, rand
#include <conio.h> // clrscr, kbhit, getchar
#include <dos.h> // FP_OFF, FP_SEG, MK_FP
#include <graphics.h> // DETECT, initgraph, closegraph, cleardevice,

// setcolor, moveto, lineto, outtextxy, line,

// setviewport, clearviewport
#include <complex.h> // complex, fabsl (<math.h>)
#include <string.h> // strlen, strcpy, strcat
#include <alloc.h> // farmalloc, farcoreleft, farfree
/***************************************************************************/
#define UnSh unsigned short // Se usarán muchos moldes (unsigned short)
#define iterando 0 // Estados posibles del proceso Raices:
#define dentrodetol 1 // Durante el proceso de búsqueda de raices
#define maxiteralcanzado 2 // complejas de los polinomios LSP pueden
#define casicero 3 // sucederse cada una de estas condiciones
#define muyplana 4
#define Jcasicero 5
typedef double vector[20]; // Coeficientes de polinomios (para Raices)
const PI = 3.141592654, // Sin comentario
fs = 10000, // Frecuencia de muestreo
LTrama = 256; // Tamano de la trama
unsigned char *BloqueD; // Bloque de datos retornado por mallocSB()
unsigned char *Muestras; // El mismo bloque, alineado en un párrafo

unsigned char Direccion; // Dirección del bloque alineado (Muestras)
double w[12][6]; // Coeficientes de la red neuronal
FILE *ft;
/***************************************************************************/

/***************************************************************************/
/**************** RUTINAS DE CONTROL DE LA SOUNBLASTER ***************/
/***************************************************************************/

/***************************************************************************/

// para almacenar muestras de voz mediante DMA



// Archivo de datos para el entrenamiento



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115


void EscribeDSP (unsigned char c)
// Esta funcion permite escribir un byte al puerto DSPWriteData/Command
{
while(inportb(0x022C)&0x80); // Espera que el DSPWriteBufferStatus se
outportb(0x022C,c); // desactive antes de sacar el dato solicitado
}
/***************************************************************************/
unsigned char LeeDSP(void)
// Esta funcion permite leer un byte del puerto DSPReadData
{
while(!(inportb(0x22E)&0x80)); // Espera que se active el DSPDataAvailable
return(inportb(0x22A)); // antes de retornar el contenido del puerto
}
/***************************************************************************/
void IniciaSB(void)
// Esta función permite inicializar la tarjeta SoundBlaster
{
UnSh x;
inportb(0x022E); // Ejecuta una secuencia de Reset:
outportb(0x0226,0x01); // Escribe un uno al registro de Reset
inportb(0x0226); // Espera mas de 3 microsegundos
inportb(0x0226); // Escribe un cero al registro de Reset
inportb(0x0226); // Al finalizar la secuencia de reset la tarjeta
inportb(0x0226); // debe responder con 0xAA dentro de los próximos
outportb(0x0226,0x00); // milisegundos.
for(x=0;x<100;x++) // Intenta durante cien lecturas:
{
if(inportb(0x022E)&0x80) // Si hay un dato disponible...


{

if(inportb(0x022A)==0xAA) break; // ... y es 0xAA : Todo ok

}
}
if(x==100) // Si pasaron cien lecturas y la tarjeta no respondió con
{ // 0xAA es porque no existe una SoundBlaster en el equipo



}
}
/***************************************************************************/
void far *SBfarmalloc(long l)
// Reserva l bytes y retorna el puntero donde se encuentran.
// Si no hay suficiente memoria, detiene la ejecución del programa porque
// seria un error fatal.
{
void far *Puntero;
Puntero = farmalloc(l); // Intenta reservar l bytes
if(Puntero==NULL) // Reporta en caso de falta de memoria
{
closegraph();
printf("Error de asignacion de memoria:\n");
printf(" Quedaban %li bytes y pidieron %li",farcoreleft(),l);
exit(1);
}
return Puntero; // Devuelve un puntero al bloque de memoria reservado
}
/**************************************************************************/
void MallocSB(void)


closegraph();
printf("No existe una Sound Blaster en la Base de E/S 0220h\n");
exit(1);

116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173



// naran las muestras de sonido


// Esta funcion permite disponer de un bloque de memoria donde almacenar
// las muestras de sonido
{
unsigned long DirFisica; // Direccion fisica de 20 bits donde se almace-

BloqueD=(unsigned char *)SBfarmalloc(131071L); // Reserva memoria
DirFisica=(( unsigned long)FP_OFF(BloqueD)) + // Calcula la direccion

(((unsigned long)FP_SEG(BloqueD))<<4); // del bloque reservado
DirFisica+=0x0FFFFL; // Encuentra un segmento a partir del cual se pue-
DirFisica&=0xF0000L; // dan direccionar 64K con las l6 lineas menos sig-
Direccion=(DirFisica>>16)&15; // nificativas del bus de direcciones
// Crea un puntero de muestras para ser usado por el DMA en el programa
Muestras=(unsigned char *)MK_FP(((UnSh)Direccion<<12)&0xF000,0);
}
/***************************************************************************/
void EstableceTC(unsigned char tc)
// Esta función permite establecer la constante de tiempo, calculada
// segun la tasa de muestreo asi: tc = 256 - 1000000/tasa_de_muestreo)
{
inportb(0x022E); // Lectura "profilactica"
EscribeDSP(0x40); // Comando para escribir la constante de tiempo
EscribeDSP(tc); // Constante de tiempo
}
/***************************************************************************/
void DetieneDMA(void)
// Esta funcion detiene cualquier proceso de E/S mediante DMA
{
EscribeDSP(0xD0);
}
/***************************************************************************/
void DesactivaParlante(void)
// Esta funcion desconecta el parlante de la salida del DAC
{
EscribeDSP(0xD3); // Comando de desactivacion del parlante
}
/***************************************************************************/
void GrabaSB(UnSh NumMuestras)
// Esta funcion captura NumMuestras bytes del conversor ADC y las almacena
// en *Muestras (deben ser menos de 65535)
{
NumMuestras--; // Desde cero hasta NumMuestras-1
outportb(0x0A,0x05); // Enmascara el canal 1 de DMA
outportb(0x0C,0x00); // Borra el puntero
outportb(0x0B,0x45); // Modo de transferencia: por bytes, inrementan-

outportb(0x02,0); // Direccion base, parte baja
outportb(0x02,0); // parte alta
outportb(0x83,Direccion);// Pagina de direcciones para el canal 1
outportb(0x03,(unsigned char)(NumMuestras&0xFF)); // Numero de bytes
outportb(0x03,(unsigned char)((NumMuestras>>8)&0xFF)); // (lo,hi)
outportb(0x0A,0x01); // Desenmascara el canal 1 del DMA
EscribeDSP(0x24); // Conversion ADC de 8 bits en modo DMA
EscribeDSP((unsigned char)(NumMuestras&0xFF)); // Numero de muestras para
EscribeDSP((unsigned char)((NumMuestras>>8)&0xFF)); // el DSP
}
/***************************************************************************/
UnSh EstadoDMA(void)
// Esta funcion retorna el estado del DMA:
  • Links de descarga
http://lwp-l.com/pdf13932

Comentarios de: Reconocimiento de fonemas mediante red neuronal (0)


No hay comentarios
 

Comentar...

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios
Es necesario revisar y aceptar las políticas de privacidad