Disons que j'ai un tableau numpy 1d

a = array([1,0,3])

Je voudrais encoder ceci en tant que tableau 2d 1-hot

b = array([[0,1,0,0], [1,0,0,0], [0,0,0,1]])

Existe-t-il un moyen rapide de procéder? Plus rapide que de simplement boucler apour définir des éléments de b, c'est-à-dire.

Votre tableau adéfinit les colonnes des éléments non nuls dans le tableau de sortie. Vous devez également définir les lignes, puis utiliser une indexation sophistiquée:

>>> a = np.array([1, 0, 3])
>>> b = np.zeros((a.size, a.max()+1))
>>> b[np.arange(a.size),a] = 1
>>> b
array([[ 0.,  1.,  0.,  0.],
       [ 1.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  1.]])

>>> values = [1, 0, 3]
>>> n_values = np.max(values) + 1
>>> np.eye(n_values)[values]
array([[ 0.,  1.,  0.,  0.],
       [ 1.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  1.]])

Dans le cas où vous utilisez des keras, il existe un utilitaire intégré pour cela:

from keras.utils.np_utils import to_categorical   

categorical_labels = to_categorical(int_labels, num_classes=3)

Et cela fait à peu près la même chose que la réponse de @ YXD (voir code source ).

Voici ce que je trouve utile:

def one_hot(a, num_classes):
  return np.squeeze(np.eye(num_classes)[a.reshape(-1)])

Ici num_classesreprésente le nombre de classes que vous avez. Donc, si vous avez un avecteur de forme (10000,) cette fonction le transforme en (10000, C) . Notez qu'il aest indexé zéro, c'est-à-dire one_hot(np.array([0, 1]), 2)qu'il donnera [[1, 0], [0, 1]].

Exactement ce que vous vouliez avoir, je crois.

PS: la source est les modèles de séquence - deeplearning.ai

Vous pouvez utiliser sklearn.preprocessing.LabelBinarizer:

Exemple:

import sklearn.preprocessing
a = [1,0,3]
label_binarizer = sklearn.preprocessing.LabelBinarizer()
label_binarizer.fit(range(max(a)+1))
b = label_binarizer.transform(a)
print('{0}'.format(b))

production:

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

Entre autres choses, vous pouvez initialiser de sklearn.preprocessing.LabelBinarizer()sorte que la sortie de transformsoit rare.

Vous pouvez également utiliser la fonction oculaire de numpy:

numpy.eye(number of classes)[vector containing the labels]

Voici une fonction qui convertit un vecteur 1D en un tableau unidimensionnel 2D.

#!/usr/bin/env python
import numpy as np

def convertToOneHot(vector, num_classes=None):
    """
    Converts an input 1-D vector of integers into an output
    2-D array of one-hot vectors, where an i'th input value
    of j will set a '1' in the i'th row, j'th column of the
    output array.

    Example:
        v = np.array((1, 0, 4))
        one_hot_v = convertToOneHot(v)
        print one_hot_v

        [[0 1 0 0 0]
         [1 0 0 0 0]
         [0 0 0 0 1]]
    """

    assert isinstance(vector, np.ndarray)
    assert len(vector) > 0

    if num_classes is None:
        num_classes = np.max(vector)+1
    else:
        assert num_classes > 0
        assert num_classes >= np.max(vector)

    result = np.zeros(shape=(len(vector), num_classes))
    result[np.arange(len(vector)), vector] = 1
    return result.astype(int)

Voici un exemple d'utilisation:

>>> a = np.array([1, 0, 3])

>>> convertToOneHot(a)
array([[0, 1, 0, 0],
       [1, 0, 0, 0],
       [0, 0, 0, 1]])

>>> convertToOneHot(a, num_classes=10)
array([[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]])

Pour 1-encodage à chaud

   one_hot_encode=pandas.get_dummies(array)

Par exemple

PROFITEZ DU CODAGE

Je pense que la réponse courte est non. Pour un cas plus générique dans les ndimensions, j'ai trouvé ceci:

# For 2-dimensional data, 4 values
a = np.array([[0, 1, 2], [3, 2, 1]])
z = np.zeros(list(a.shape) + [4])
z[list(np.indices(z.shape[:-1])) + [a]] = 1

Je me demande s'il y a une meilleure solution - je n'aime pas que je doive créer ces listes dans les deux dernières lignes. Quoi qu'il en soit, j'ai fait quelques mesures avec timeitet il semble que les versions numpybasées sur ( indices/ arange) et les versions itératives fonctionnent à peu près de la même manière.

Juste pour développer l' excellente réponse de K3 --- rnc , voici une version plus générique:

def onehottify(x, n=None, dtype=float):
    """1-hot encode x with the max value n (computed from data if n is None)."""
    x = np.asarray(x)
    n = np.max(x) + 1 if n is None else n
    return np.eye(n, dtype=dtype)[x]

En outre, voici un benchmark rapide et sale de cette méthode et une méthode de la réponse actuellement acceptée par YXD (légèrement modifiée, afin qu'ils offrent la même API, sauf que cette dernière ne fonctionne qu'avec des ndarrays 1D):

def onehottify_only_1d(x, n=None, dtype=float):
    x = np.asarray(x)
    n = np.max(x) + 1 if n is None else n
    b = np.zeros((len(x), n), dtype=dtype)
    b[np.arange(len(x)), x] = 1
    return b

Cette dernière méthode est ~ 35% plus rapide (MacBook Pro 13 2015), mais la première est plus générale:

>>> import numpy as np
>>> np.random.seed(42)
>>> a = np.random.randint(0, 9, size=(10_000,))
>>> a
array([6, 3, 7, ..., 5, 8, 6])
>>> %timeit onehottify(a, 10)
188 µs ± 5.03 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> %timeit onehottify_only_1d(a, 10)
139 µs ± 2.78 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Vous pouvez utiliser le code suivant pour la conversion en un vecteur unique:

soit x est le vecteur de classe normal ayant une seule colonne avec des classes 0 à un certain nombre:

import numpy as np
np.eye(x.max()+1)[x]

si 0 n'est pas une classe; puis supprimez +1.

J'ai récemment rencontré un problème du même genre et j'ai trouvé cette solution qui s'est avérée satisfaisante uniquement si vous avez des nombres qui entrent dans une certaine formation. Par exemple, si vous souhaitez coder à chaud la liste suivante:

all_good_list = [0,1,2,3,4]

allez-y, les solutions affichées sont déjà mentionnées ci-dessus. Mais que faire si l'on considère ces données:

problematic_list = [0,23,12,89,10]

Si vous le faites avec les méthodes mentionnées ci-dessus, vous vous retrouverez probablement avec 90 colonnes à chaud. C'est parce que toutes les réponses incluent quelque chose comme n = np.max(a)+1. J'ai trouvé une solution plus générique qui a fonctionné pour moi et j'ai voulu partager avec vous:

import numpy as np
import sklearn
sklb = sklearn.preprocessing.LabelBinarizer()
a = np.asarray([1,2,44,3,2])
n = np.unique(a)
sklb.fit(n)
b = sklb.transform(a)

J'espère que quelqu'un a rencontré les mêmes restrictions sur les solutions ci-dessus et cela pourrait être utile

Ce type d'encodage fait généralement partie du tableau numpy. Si vous utilisez un tableau numpy comme celui-ci:

a = np.array([1,0,3])

alors il y a un moyen très simple de convertir cela en un encodage à chaud

out = (np.arange(4) == a[:,None]).astype(np.float32)

C'est tout.

• p sera un ndarray 2D.
• Nous voulons savoir quelle valeur est la plus élevée d'affilée, pour y mettre 1 et partout ailleurs 0.

solution propre et facile:

max_elements_i = np.expand_dims(np.argmax(p, axis=1), axis=1)
one_hot = np.zeros(p.shape)
np.put_along_axis(one_hot, max_elements_i, 1, axis=1)

Utilisation d'une étape de pipeline Neuraxle :

1. Configurez votre exemple

import numpy as np
a = np.array([1,0,3])
b = np.array([[0,1,0,0], [1,0,0,0], [0,0,0,1]])

2. Faire la conversion réelle

from neuraxle.steps.numpy import OneHotEncoder
encoder = OneHotEncoder(nb_columns=4)
b_pred = encoder.transform(a)

3. Affirmez que cela fonctionne

assert b_pred == b

Lien vers la documentation: neuraxle.steps.numpy.OneHotEncoder

Voici un exemple de fonction que j'ai écrit pour ce faire en fonction des réponses ci-dessus et de mon propre cas d'utilisation:

def label_vector_to_one_hot_vector(vector, one_hot_size=10):
    """
    Use to convert a column vector to a 'one-hot' matrix

    Example:
        vector: [[2], [0], [1]]
        one_hot_size: 3
        returns:
            [[ 0.,  0.,  1.],
             [ 1.,  0.,  0.],
             [ 0.,  1.,  0.]]

    Parameters:
        vector (np.array): of size (n, 1) to be converted
        one_hot_size (int) optional: size of 'one-hot' row vector

    Returns:
        np.array size (vector.size, one_hot_size): converted to a 'one-hot' matrix
    """
    squeezed_vector = np.squeeze(vector, axis=-1)

    one_hot = np.zeros((squeezed_vector.size, one_hot_size))

    one_hot[np.arange(squeezed_vector.size), squeezed_vector] = 1

    return one_hot

label_vector_to_one_hot_vector(vector=[[2], [0], [1]], one_hot_size=3)

J'ajoute pour terminer une fonction simple, en utilisant uniquement des opérateurs numpy:

   def probs_to_onehot(output_probabilities):
        argmax_indices_array = np.argmax(output_probabilities, axis=1)
        onehot_output_array = np.eye(np.unique(argmax_indices_array).shape[0])[argmax_indices_array.reshape(-1)]
        return onehot_output_array

Il prend en entrée une matrice de probabilité: ex:

[[0,03038822 0,65810204 0,16549407 0,37797123] ... [0,02771272 0,2760752 0,3280924 0,33458805]]

Et ça reviendra

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

Voici une solution autonome indépendante de la dimension.

Cela convertira tout tableau N-dimensionnel arrd'entiers non négatifs en un tableau N + 1 unidimensionnel one_hot, où one_hot[i_1,...,i_N,c] = 1signifie arr[i_1,...,i_N] = c. Vous pouvez récupérer l'entrée vianp.argmax(one_hot, -1)

def expand_integer_grid(arr, n_classes):
    """

    :param arr: N dim array of size i_1, ..., i_N
    :param n_classes: C
    :returns: one-hot N+1 dim array of size i_1, ..., i_N, C
    :rtype: ndarray

    """
    one_hot = np.zeros(arr.shape + (n_classes,))
    axes_ranges = [range(arr.shape[i]) for i in range(arr.ndim)]
    flat_grids = [_.ravel() for _ in np.meshgrid(*axes_ranges, indexing='ij')]
    one_hot[flat_grids + [arr.ravel()]] = 1
    assert((one_hot.sum(-1) == 1).all())
    assert(np.allclose(np.argmax(one_hot, -1), arr))
    return one_hot

Utilisez le code suivant. Cela fonctionne mieux.

def one_hot_encode(x):
"""
    argument
        - x: a list of labels
    return
        - one hot encoding matrix (number of labels, number of class)
"""
encoded = np.zeros((len(x), 10))

for idx, val in enumerate(x):
    encoded[idx][val] = 1

return encoded

Trouvé ici PS Vous n'avez pas besoin d'entrer dans le lien.