torch/lua: récupérer le meilleur sous-ensemble de Tensor

Question

J'ai maintenant le code suivant, qui stocke les indices avec le score maximum pour chaque question dans pred, et le convertit en chaîne. Je veux faire la même chose pour les indices n-meilleurs pour chaque question, pas seulement l'index unique avec le score maximum, et les convertir en chaîne. Je veux aussi afficher le score pour chaque index (ou chaque chaîne convertie).

Donc scores devra être trié, et pred devra être plusieurs lignes/colonnes au lieu de 1 x nqs. Et la valeur score correspondante pour chaque entrée dans pred doit être récupérable.

Je ne sais rien de la syntaxe de lua/torch, et toute aide serait grandement appréciée.

nqs=dataset['question']:size(1); 
scores=torch.Tensor(nqs,noutput); 
qids=torch.LongTensor(nqs); 
for i=1,nqs,batch_size do 
    xlua.progress(i, nqs) 
    r=math.min(i+batch_size-1,nqs); 
    scores[{{i,r},{}}],qids[{{i,r}}]=forward(i,r); 
end 

tmp,pred=torch.max(scores,2); 

answer=json_file['ix_to_ans'][tostring(pred[{i,1}])] 
print(answer) 

Answer 1

Voici ma tentative, je démontrer son comportement à l'aide d'un simple tenseur scores aléatoire:

> scores=torch.floor(torch.rand(4,10)*100) 
> =scores 
9 1 90 12 62 1 62 86 46 27 
7 4 7 4 71 99 33 48 98 63 
82 5 73 84 61 92 81 99 65 9 
33 93 64 77 36 68 89 44 19 25 
[torch.DoubleTensor of size 4x10] 

Maintenant, puisque vous voulez les N meilleurs index pour chaque question (ligne), nous allons trier chaque ligne du tenseur:

> values,indexes=scores:sort(2) 

maintenant, regardons ce que les tenseurs de retour contiennent:

> =values 
    1 1 9 12 27 46 62 62 86 90 
    4 4 7 7 33 48 63 71 98 99 
    5 9 61 65 73 81 82 84 92 99 
    19 25 33 36 44 64 68 77 89 93 
    [torch.DoubleTensor of size 4x10] 

> =indexes 
    2 6 1 4 10 9 5 7 8 3 
    2 4 1 3 7 8 10 5 9 6 
    2 10 5 9 3 7 1 4 6 8 
    9 10 1 5 8 3 6 4 7 2 
    [torch.LongTensor of size 4x10] 

Comme vous le voyez, la ligne de i-thvalues est la version triée (par ordre croissant) de la ligne de i-thscores, et chaque ligne de indexes vous donne les indices correspondants.

Vous pouvez obtenir les N meilleures valeurs/indices pour chaque question (-à-dire ligne) avec

> N_best_indexes=indexes[{{},{indexes:size(2)-N+1,indexes:size(2)}}] 
> N_best_values=values[{{},{values:size(2)-N+1,values:size(2)}}] 

Voyons voir leurs valeurs pour l'exemple donné, avec N=3:

> return N_best_indexes 
7 8 3 
5 9 6 
4 6 8 
4 7 2 
[torch.LongTensor of size 4x3] 

> return N_best_values 
62 86 90 
71 98 99 
84 92 99 
77 89 93 
[torch.DoubleTensor of size 4x3] 

Alors , la meilleure valeur de k-th pour la question j est N_best_values[{{j},{values:size(2)-k+1}]], et son index correspondant dans la matrice scores est donné par thi s row, column valeurs:

row=j 
column=N_best_indexes[{{j},indexes:size(2)-k+1}}]. 

Par exemple, la première meilleure valeur (k=1) pour la deuxième question est 99, qui se trouve au 2nd rangée et colonne 6th dans scores. Et vous pouvez voir que values[{{2},values:size(2)}}] est 99, et que indexes[{{2},{indexes:size(2)}}] vous donne 6, qui est l'index de colonne dans la matrice scores.

J'espère que j'ai bien expliqué ma solution.