Une Chaude de l'Encodage à l'aide de numpy

Si l'entrée est à zéro, je veux faire un tableau qui ressemble à ceci:

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

et si l'entrée est de 5:

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

Pour le dessus, j'ai écrit:

np.put(np.zeros(10),5,1)

mais il ne fonctionne pas.

Est-il de toute façon ce qui, ce qui peut être mis en œuvre en une seule ligne?

Comment se fait-il pas de travail?
Pourquoi voulez-vous faire cela en une seule ligne? Si vous voulez garder compact, il suffit d'écrire une fonction.
Il est de coutume pour sélectionner l'une des réponses quand vous avez obtenu au moins un qui résout votre problème.

OriginalL'auteur Abhijay Ghildyal | 2016-07-26

  1. 43

    Habituellement, lorsque vous voulez obtenir un "one-hot" codant pour la classification dans l'apprentissage de la machine, vous avez un tableau d'indices.

    import numpy as np
nb_classes = 6
targets = np.array([[2, 3, 4, 0]]).reshape(-1)
one_hot_targets = np.eye(nb_classes)[targets]

    La one_hot_targets est maintenant

    array([[[ 0.,  0.,  1.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  1.,  0.,  0.],
        [ 0.,  0.,  0.,  0.,  1.,  0.],
        [ 1.,  0.,  0.,  0.,  0.,  0.]]])

    La .reshape(-1) est là pour vous assurer que vous avez le droit d'étiquettes de format (vous pourriez aussi avoir [[2], [3], [4], [0]]). Le -1 est une valeur particulière qui signifie "mettre tous les autres trucs dans cette dimension". Comme il est seul, il aplatit le tableau.

    Copier-Coller solution

    def get_one_hot(targets, nb_classes):
    res = np.eye(nb_classes)[np.array(targets).reshape(-1)]
    return res.reshape(list(targets.shape)+[nb_classes])

    Paquet

    Vous pouvez utiliser mpu.ml.indices2one_hot. Il est testé et simple à utiliser:

    import mpu.ml
one_hot = mpu.ml.indices2one_hot([1, 3, 0], nb_classes=5)
    Mais comment cela fonctionne? np.eye(nb_classes) devrait être 6x6 de la matrice, mais il est de la forme a changé de 4x6. Pouvez-vous eleborate sur ce point?
    np.eye(nb_classes) est une matrice 6x6. Puis-je sélectionner les lignes spécifiées dans la cible. Je ne sélectionnez quatre, c'est donc un 4x6 matrice.
    cela semble fonctionner que pour 2-dim objectifs, mais peut-être généralisée pour d'autres formes, par l'exécution de .reshape(list(targets.shape)+[nb_classes])

    OriginalL'auteur Martin Thoma

  2. 7

    Quelque chose comme : 

    np.array([int(i == 5) for i in range(10)])

    Devrait faire l'affaire.
    Mais je suppose qu'il existe d'autres solutions à l'aide de numpy.

    edit : la raison pour laquelle votre formule ne fonctionne pas : np.mettre ne retourne rien, c'est juste modifie l'élément donné en premier paramètre. La bonne réponse en utilisant np.put() est :

    a = np.zeros(10)
np.put(a,5,1)

    Le problème est qu'il ne peut pas être fait en une seule ligne, vous devez définir le tableau avant de le transmettre à np.put()

    C'est à peu près la plupart des inefficace moyen pour accomplir ce que vous voulez.
    Je sais que le one-liner que j'ai écrit est mauvais, mais avez-vous une source de dire ce que vous devriez et ne devriez pas faire des listes et des tableaux numpy ?
    C'est une règle générale en Python qu'un Python la boucle s'exécute plus lentement que celui qui s'exécute à l'aide du code C. Donc si il y a une façon évidente d'utiliser une boucle C au lieu d'un Python, vous devez utiliser le C de la boucle. Et le point de l'ensemble de l'utilisation de Numpy est de faire le traitement de tableaux à la C la vitesse, lorsque cela est possible. Je ne suis pas familier avec le numpy code source, mais numpy.zeros probablement va encore plus vite que C for boucle, puisque le PROCESSEUR peut remplir un bloc de mémoire avec une valeur unique très rapidement.
    BTW, je suis pas, en disant que votre 1er code de l'exemple est mauvais. Dans un non-Numpy programme, il serait un bon façon de le faire, et il serait bête d'import Numpy juste pour cette opération. Mais si le programme est déjà l'utilisation de Numpy de toute façon il est logique de tirer parti de ce que Numpy a à offrir.

    OriginalL'auteur HolyDanna

  3. 2

    De prendre un coup d'oeil rapide à le manuel, vous verrez que np.put ne retourne pas de valeur. Alors que votre technique est très bien, vous accédez à None au lieu de votre tableau résultat.

    Pour un 1-D de tableau, il est préférable de l'utiliser juste indexation directe, surtout pour un cas simple.

    Ici est de savoir comment réécrire votre code avec un minimum de modifications:

    arr = np.zeros(10)
np.put(arr, 5, 1)

    Ici, c'est comment faire la deuxième ligne avec l'indexation au lieu de put:

    arr[5] = 1

    OriginalL'auteur Mad Physicist

  4. 2

    Le problème ici est que vous enregistrez votre tableau de nulle part. Le put fonction travaille en place sur le tableau et ne renvoie rien. Puisque vous ne donnez jamais votre tableau un nom que vous ne pouvez pas le résoudre plus tard. Donc, ce

    one_pos = 5
x = np.zeros(10)
np.put(x, one_pos, 1)

    mais ensuite, vous pouvez simplement utiliser l'indexation:

    one_pos = 5
x = np.zeros(10)
x[one_pos] = 1

    À mon avis ce serait la bonne façon de le faire que si aucune raison spéciale existe pour ce faire une seule ligne. Cela peut aussi être plus facile à lire et lisible le code est bon code.

    OriginalL'auteur m00am

  5. 2

    La np.put mutation de son tableau arg en place. C'est classique en Python pour les fonctions /méthodes effectuez de mutation pour retourner None; np.put adhère à cette convention. Donc, si a est un tableau 1D et vous ne

    a = np.put(a, 5, 1)

    puis a seront remplacés par None.

    Votre code est semblable à cela, mais elle passe un un-tableau de np.put.

    Un compact & moyen efficace de faire ce que vous voulez, c'est avec une simple fonction, par exemple:

    import numpy as np

def one_hot(i):
    a = np.zeros(10, 'uint8')
    a[i] = 1
    return a

a = one_hot(5) 
print(a)

    sortie

    [0 0 0 0 0 1 0 0 0 0]
    Je vais prendre le pas, afin de ne pas insulter les gens

    OriginalL'auteur PM 2Ring

  6. 2

    Utilisation np.identify ou np.eye. Vous pouvez essayer quelque chose comme cela avec vos commentaires j', et la taille de la matrice s:

    np.identify(s)[i:i+1]

    Par exemple, print(np.identity(5)[0:1]) entraînera:

    [[ 1.  0.  0.  0.  0.  0.  0.  0.  0.  0.]]

    Si vous utilisez TensorFlow, vous pouvez utiliser tf.one_hot: https://www.tensorflow.org/api_docs/python/array_ops/slicing_and_joining#one_hot

    OriginalL'auteur Sung Kim

  7. 2

    Vous pouvez utiliser la Liste de compréhension:

    [0 if i !=5 else 1 for i in range(10)]

    se tourne vers

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

    OriginalL'auteur Rikku Porta

  8. 0
    import time
start_time = time.time()
z=[]
for l in [1,2,3,4,5,6,1,2,3,4,4,6,]:
    a= np.repeat(0,10)
    np.put(a,l,1)
    z.append(a)
print("--- %s seconds ---" % (time.time() - start_time))

#--- 0.00174784660339 seconds ---

import time
start_time = time.time()
z=[]
for l in [1,2,3,4,5,6,1,2,3,4,4,6,]:
    z.append(np.array([int(i == l) for i in range(10)]))
print("--- %s seconds ---" % (time.time() - start_time))

#--- 0.000400066375732 seconds ---
    À l'aide de a=np.zeros(10), je reçois un peu plus vite la version avec la première version : 0.0007712841033935547 seconds contre 0.0008835792541503906 seconds pour la deuxième version
    Essayez a = np.zeros(10); a[l] = 1; indexés affectation est plus rapide que de faire un appel de fonction. Mon one_hot fonction est un peu plus lent que ce inline version, également en raison de la surcharge de l'appel de la fonction, mais il est plus rapide que les autres techniques. Toutefois, ce délai info n'est pas très précis, vous devez utiliser le timeit module, et d'utiliser ses facitlities pour effectuer vos tests des centaines (ou des milliers) de fois pour obtenir des résultats significatifs qui ne sont pas submergés par le "bruit" d'autres tâches de votre CPU.
    Merci. Connaissez-vous des meilleures façons de code de vérification de temps d'exécution?
    Comme je l'ai dit, l'utilisation de la timeit module. FWIW, ici sont un couple de mes dernières réponses que l'utilisation timeit stackoverflow.com/a/38075792/4014959 et stackoverflow.com/a/36030019/4014959

    OriginalL'auteur Abhijay Ghildyal

  9. 0

    Je ne suis pas sûr de la performance, mais le code suivant fonctionne et c'est génial.

    x = np.array([0, 5])
x_onehot = np.identity(6)[x]

    OriginalL'auteur Ken Chan