Votre fonction renvoie des vecteurs, ils sont donc collectés comme un vecteur de vecteurs. Soit écrire :
permutedims(reduce(hcat, onehotencode.([1,2,3,4], 10)))
qui réutilise votre code et vous donne ce que vous voulez (mais n'est pas très efficace), ou simplement écrire :
.==([1,2,3,4], (1:10)')
o
.==([1,2,3,4], hcat(1:10...))
Si vous voulez obtenir un Int (pas Bool ), on écrit Int.(.==([1,2,3,4], hcat(1:10...))) .
== peut être remplacé par n'importe quelle fonction de votre choix qui fonctionne sur scalaires par exemple :
julia> f(x,y) = (x,y)
f (generic function with 1 method)
julia> f.([1,2,3,4], hcat(1:10...))
4×10 Array{Tuple{Int64,Int64},2}:
(1, 1) (1, 2) (1, 3) (1, 4) (1, 5) (1, 6) (1, 7) (1, 8) (1, 9) (1, 10)
(2, 1) (2, 2) (2, 3) (2, 4) (2, 5) (2, 6) (2, 7) (2, 8) (2, 9) (2, 10)
(3, 1) (3, 2) (3, 3) (3, 4) (3, 5) (3, 6) (3, 7) (3, 8) (3, 9) (3, 10)
(4, 1) (4, 2) (4, 3) (4, 4) (4, 5) (4, 6) (4, 7) (4, 8) (4, 9) (4, 10)
En général une règle, que je trouve utile en pratique dans Julia est d'écrire des fonctions qui travaillent sur des scalaires et ensuite d'utiliser la diffusion ou d'autres composants d'ordre supérieur du langage pour travailler sur eux.
EDITAR
Votre fonction prend des scalaires, mais les développe en fait en interne et renvoie un fichier Vector . Donc, conceptuellement, votre fonction est quelque chose comme :
function onehotencode(n, domain_range)
return [ n == k ? 1 : 0 for k in domain_range]
end
bien qu'il soit caché parce que vous passez un scalaire. Par conséquent, vous êtes autorisé à écrire onehotencode.([1,2,3,4], hcat(1:10...)) avec votre onehotencode mais la valeur de retour est traitée comme une entrée dans une cellule du tableau de bord résultant. Matrix (et ce n'est clairement pas ce que vous voulez).
Si vous définissez votre fonction comme :
function onehotencode(n, v)
return n == v ? 1 : 0
end
c'est-à-dire qu'elle prend des scalaires et renvoie un scalaire (ou plus précisément, elle renvoie une "entrée unique" dans le fichier de sortie attendu). Matrix (car techniquement, il n'est pas nécessaire que ce soit un scalaire), tout fonctionne comme prévu :
julia> onehotencode.([1,2,3,4], hcat(1:10...))
4×10 Array{Int64,2}:
1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
Donc, en résumé, la fonction devrait : obtenir des scalaires en tant qu'arguments et renvoyer un scalaire (et encore une fois, le mot scalaire est une simplification - tant dans les arguments que dans la valeur de retour, il peut s'agir de tout ce qui est considéré comme une entrée unique - simplement les scalaires dans les deux cas sont un cas d'utilisation le plus commun).
