Qu'est-ce qu'un encodage à chaud dans Tensorflow?

Je suis actuellement en cours de tensorflow dans lequel ils ont utilisé tf.one_hot (indices, profondeur). Maintenant, je ne comprends pas comment ces indices se transforment en cette séquence binaire.

Quelqu'un peut-il m'expliquer le processus exact ???

Supposons que vous ayez une entité catégorielle dans votre jeu de données (par exemple, la couleur). Et vos échantillons peuvent être rouges, jaunes ou bleus. Afin de passer cet argument à un algorithme ML, vous devez d'abord le coder de sorte qu'au lieu de chaînes, vous ayez des nombres.

La façon la plus simple de faire une telle chose est de créer une cartographie où:

rouge -> 1
jaune -> 2
bleu -> 3

et remplacez chaque chaîne par sa valeur mappée.

Cependant, cela pourrait créer des effets secondaires indésirables dans notre modèle ML, car lorsqu'il s'agit de nombres, il peut penser que bleu> jaune (parce que 3> 2) ou que rouge + jaune = bleu (parce que 1 + 2 = 3). Le modèle n'a aucun moyen de savoir que ces données étaient catégoriques et ont ensuite été mappées sous forme d'entiers.

La solution à ce problème est l'encodage à chaud où nous créons N nouvelles fonctionnalités , où N est le nombre de valeurs uniques dans la fonctionnalité d'origine. Dans notre exemple, N serait égal à 3, car nous avons 3 couleurs uniques (rouge, jaune et bleu).

Chacune de ces fonctionnalités serait binaire et correspondrait à l' une de ces valeurs uniques. Dans notre exemple, la première fonctionnalité serait une fonctionnalité binaire nous indiquant si cet échantillon est rouge ou non, la seconde serait la même chose pour le jaune et la troisième pour le bleu.

Un exemple d'une telle transformation est illustré ci-dessous:

Notez que parce que cette approche augmente la dimensionnalité de l'ensemble de données, si nous avons une entité qui prend de nombreuses valeurs uniques, nous pouvons vouloir utiliser un encodage plus clairsemé (comme celui que j'ai présenté ci-dessus).

depth: un scalaire définissant la profondeur de la seule dimension chaude.

indices: un tenseur d'indices.

C'est l'exemple donné dans la documentation tensorflow.
1. Spécifier uniquement les indices et la profondeur (les valeurs par défaut de on_value est 1 et off_value est 0)

 indices = [0, 1, 2]
    depth = 3
    tf.one_hot(indices, depth)  # output: [3 x 3]
    # [[1., 0., 0.],
    #  [0., 1., 0.],
    #  [0., 0., 1.]]

2. Spécification de on_value et off_value

indices = [0, 2, -1, 1]
profondeur = 3
tf.one_hot (indices, profondeur, on_value = 5.0, off_value = 0.0, axis = -1)
## sortie: [4 x 3]
    # [[5.0, 0.0, 0.0], # one_hot (0)
    # [0.0, 0.0, 5.0], # one_hot (2)
    # [0,0, 0,0, 0,0], # one_hot (-1)
    # [0.0, 5.0, 0.0]] # one_hot (1)

Vous pouvez également voir le code sur GitHub