Reconnaissance vocale utilisant le réseau kohonen avec des fonctions MFCC. Comment je définis une distance entre les neurones et leurs poids?

Question

Je ne sais pas comment définir une localisation de chaque neurone dans la carte. Ceci est un neurone et carte:

typedef struct _neuron 
{ 
    mfcc_frame *frames; 
    char *name; 
    double *weights; 
    int num_weights; 
    int x; 
    int y; 
} neuron; 
typedef struct _map 
{ 
neuron *lattice; 
    int latice_size; 
    double mapRadius; 
    int sideX, sideY; 
    int scale; 
} map; 

Si j'ai plus d'un mot égal, comment calculer une distance entre l'entrée de motif (mot) et mon neurone.

Je ne suis pas sûr du poids. Je définis les poids comme la quantité de caractéristiques mfcc d'un mot, mais à l'entraînement, j'ai besoin de mettre à jour ce poids en fonction de la distance entre les neurones. J'utilise la distance euclidienne entre les neurones. Mais le doute est de savoir comment mettre à jour les poids. Voici le code de la carte init et les neurones

void init_neuron(neuron *n, int x, int y, mfcc_frame *mfcc_frames, unsigned int n_frames, char *name){ 

double r; 
register int i, j; 
n->frames = mfcc_frames; 
n->num_weights = n_frames; 
n->x = x; 
n->y = y; 

n->name = malloc (strlen(name) * sizeof(char)); 
strcpy(n->name, name); 
n->weights= malloc (n_frames * sizeof (double)); 

for(i = 0; i < n_frames; i++) 
    for(j = 0; j < N_MFCC; j++) 
     n->weights[i] = mfcc_frames[i].features[j]; 

printf("%s lattice %d, %d\n", n->name, n->x, n->y); 

}

carte init:

map* init_map(int sideX, int sideY, int scale){ 
register int i, x, y; 
char *name = NULL; 
void **word_adresses; 
unsigned int n = 0, count = 0; 
int aux = 0; 
word *words = malloc(sizeof(word)); 

map *_map = malloc(sizeof(map)); 
_map->latice_size = sideX * sideY; 
_map->sideX  = sideX; 
_map->sideY  = sideY; 
_map->scale  = scale; 
_map->lattice  = malloc(_map->latice_size * sizeof(neuron)); 
mt_seed(); 

if ((n = get_list(words))){ 
    word_adresses = malloc(n * sizeof(void *)); 
    while (words != NULL){ 
     x = mt_rand() %sideX; 
     y = mt_rand() %sideY; 
     printf("y : %d x: %d\n", y, x); 
     init_neuron(_map->lattice + y * sideX + x, x, y, words->frames, words->n, words->name); 

     word_adresses[count++] = words;  
     words = words->next; 
    } 
    for (i = 0; i < count; i++) 
     free(word_adresses[i]); 
    free(word_adresses); 
    aux++; 
} 

return _map; 

}

Answer 1

Dans la Kohonen SOM, les poids sont dans l'espace de représentation, de sorte que signifie que chaque neurone contient un vecteur prototype. Si l'entrée est de 12 MFCC, chaque entrée peut ressembler à un vecteur de 12 valeurs doubles, ce qui signifie que chaque neurone a 12 valeurs, une pour chacun des MFCC. Après une entrée, vous trouvez la meilleure unité correspondante, puis déplacez les 12 valeurs du livre de codes pour ce neurone vers le vecteur d'entrée, une petite quantité basée sur le taux d'apprentissage.