Algorithme de classement du meilleur effort de vecteur

Question

Étant donné quatre vecteurs binaires qui représentent des "classes":

[1,0,0,0,0,0,0,0,0,0]
[0,0,0,0,0,0,0,0,0,1]
[0,1,1,1,1,1,1,1,1,0]
[0,1,0,0,0,0,0,0,0,0]

Quelles sont les méthodes disponibles pour classer un vecteur de valeurs à virgule flottante dans une de ces « classes »?

arrondi de base fonctionne dans la plupart des cas:

round([0.8,0,0,0,0.3,0,0.1,0,0,0]) = [1 0 0 0 0 0 0 0 0 0] 

Mais comment puis-je gérer des interférences?

round([0.8,0,0,0,0.6,0,0.1,0,0,0]) != [1 0 0 0 0 1 0 0 0 0]

Ce second cas devrait être un meilleur match pour la 1.000.000.000, mais au contraire, j'ai perdu entièrement la solution car il n'y a pas de correspondance claire.

Je veux utiliser cette tâche pour Matlab.

Answer 1

Trouvez SSD (somme des différences au carré) de votre vecteur de test avec chaque « classe "et utiliser celui avec le moins SSD.

Voici un code: j'ai ajouté un 0 à la fin du vecteur de test que vous avez fourni, car il était seulement 9 chiffres alors que les classes avaient 10

.

CLASSES = [1,0,0,0,0,0,0,0,0,0
           0,0,0,0,0,0,0,0,0,1
           0,1,1,1,1,1,1,1,1,0
           0,1,0,0,0,0,0,0,0,0];

TEST = [0.8,0,0,0,0.6,0,0.1,0,0,0];

% Find the difference between the TEST vector and each row in CLASSES
difference = bsxfun(@minus,CLASSES,TEST);
% Class differences
class_diff = sum(difference.^2,2);
% Store the row index of the vector with the minimum difference from TEST
[val CLASS_ID] = min(class_diff);
% Display
disp(CLASSES(CLASS_ID,:))

À titre d'illustration, difference ressemble à ceci:

 0.2    0   0   0   -0.6    0   -0.1    0   0   0
-0.8    0   0   0   -0.6    0   -0.1    0   0   1
-0.8    1   1   1    0.4    1    0.9    1   1   0
-0.8    1   0   0   -0.6    0   -0.1    0   0   0

Et la distance de chaque classe de l'essai ressemble à ceci, class_diff:

 0.41
 2.01
 7.61
 2.01

Et évidemment, le premier est le meilleur match car il a la moindre différence.

Answer 2

Ceci est la même chose que Jacob fait, seulement avec quatre différentes mesures de distance:

• distance euclidienne
• Distance Centre-bloc
• la distance Cosinus
• Tchebycheff la distance

---

%%
CLASSES = [1,0,0,0,0,0,0,0,0,0
           0,0,0,0,0,0,0,0,0,1
           0,1,1,1,1,1,1,1,1,0
           0,1,0,0,0,0,0,0,0,0];

TEST = [0.8,0,0,0,0.6,0,0.1,0,0,0];

%%
% sqrt( sum((x-y).^2) )
euclidean = sqrt( sum(bsxfun(@minus,CLASSES,TEST).^2, 2) );

% sum( |x-y| )
cityblock = sum(abs(bsxfun(@minus,CLASSES,TEST)), 2);

% 1 - dot(x,y)/(sqrt(dot(x,x))*sqrt(dot(y,y)))
cosine = 1 - ( CLASSES*TEST' ./ (norm(TEST)*sqrt(sum(CLASSES.^2,2))) );

% max( |x-y| )
chebychev = max( abs(bsxfun(@minus,CLASSES,TEST)), [], 2 );

dist = [euclidean cityblock cosine chebychev];

%%
[minDist classIdx] = min(dist);

Choisissez celui que vous aimez:)

Answer 3

Un simple algorithme de distance euclidienne devrait suffire. La classe à la distance minimale au point serait votre candidat.

http://en.wikipedia.org/wiki/Euclidean_distance