Diyelim ki 1d numpy dizim var

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

Bunu 2d 1-hot dizi olarak kodlamak istiyorum

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

Bunu yapmanın hızlı bir yolu var mı? aÖğelerini ayarlamak için sadece döngüden daha hızlı b.

Diziniz a, çıkış dizisindeki sıfır olmayan öğelerin sütunlarını tanımlar. Ayrıca satırları tanımlamanız ve ardından süslü dizin oluşturmayı kullanmanız gerekir:

>>> 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.]])

Keras kullanıyorsanız, bunun için yerleşik bir yardımcı program vardır:

from keras.utils.np_utils import to_categorical   

categorical_labels = to_categorical(int_labels, num_classes=3)

Ve @ YXD'nin cevabı ile hemen hemen aynı şeyi yapıyor ( kaynak koduna bakınız ).

İşte yararlı bulduğum:

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

Burada num_classessahip olduğunuz sınıf sayısı anlamına gelir. Yani (10000,)a şeklinde bir vektörünüz varsa bu işlev onu (10000, C) 'ye dönüştürür . Sıfır indeksli olduğunu unutmayın , yani verecektir .aone_hot(np.array([0, 1]), 2)[[1, 0], [0, 1]]

Tam olarak neye sahip olmak istediğine inanıyorum.

PS: kaynak Dizi modelleri - deeplearning.ai

Şunları kullanabilirsiniz sklearn.preprocessing.LabelBinarizer:

Misal:

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))

çıktı:

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

Diğer şeylerin yanı sıra sklearn.preprocessing.LabelBinarizer(), çıktısının transformseyrek olması için başlatabilirsiniz.

Numpy'nin göz işlevini de kullanabilirsiniz :

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

1-B vektörü 2-B tek-sıcak diziye dönüştüren bir fonksiyon.

#!/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)

Aşağıda bazı örnek kullanımlar verilmiştir:

>>> 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]])

1-hot-encoding için

   one_hot_encode=pandas.get_dummies(array)

Örneğin

KODLAMAYI KEYFİNİZ

Bence kısa cevap hayır. nBoyutlarda daha genel bir durum için şunu buldum:

# 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

Daha iyi bir çözüm olup olmadığını merak ediyorum - son iki satırda bu listeleri oluşturmak zorunda olduğumu sevmiyorum. Her neyse, bazı ölçümler yaptım timeitve görünüşe göre numpy-bazlı ( indices/ arange) ve yinelemeli sürümler yaklaşık aynı performansı gösteriyor.

Sadece üzerinde durmak için mükemmel cevap den K3 --- RNC , burada daha genel bir versiyonudur:

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]

Ayrıca, bu yöntemin hızlı ve kirli bir karşılaştırması ve YXD tarafından şu anda kabul edilen cevaptan bir yöntem (biraz değişti, böylece aynı API'yi sunmaları dışında, sadece 1D ndarrays ile çalışır):

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

İkinci yöntem ~% 35 daha hızlıdır (MacBook Pro 13 2015), ancak önceki yöntem daha geneldir:

>>> 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)

Sıcak bir vektöre dönüştürmek için aşağıdaki kodu kullanabilirsiniz:

let x, 0 ile bazı sayıların bulunduğu tek bir sütuna sahip normal sınıf vektörüdür:

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

0 bir sınıf değilse; ardından + 1'i kaldırın.

Son zamanlarda aynı tür bir sorunla karşılaştım ve sadece belirli bir oluşumda sayılarınız varsa tatmin edici olduğu söylenen çözümü buldum. Örneğin, aşağıdaki listeyi bir etkin kodlama yapmak istiyorsanız:

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

devam edin, yayınlanan çözümler yukarıda belirtilmiştir. Peki ya bu verileri dikkate alırsak:

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

Yukarıda belirtilen yöntemlerle yaparsanız, muhtemelen 90 tek sıcak sütunla karşılaşırsınız. Bunun nedeni, tüm cevapların benzer bir şey içermesidir n = np.max(a)+1. Benim için işe yarayan ve sizinle paylaşmak isteyen daha genel bir çözüm buldum:

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)

Umarım birisi yukarıdaki çözümlerde aynı kısıtlamalarla karşılaşmıştır ve bu kullanışlı olabilir

Bu tip kodlama genellikle numpy dizisinin bir parçasıdır. Bunun gibi bir numpy dizisi kullanıyorsanız:

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

o zaman 1-hot kodlamaya dönüştürmenin çok basit bir yolu var

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

Bu kadar.

• p 2d bir ndarray olacaktır.
• Hangi değerin üst üste en yüksek olduğunu bilmek istiyoruz, oraya 1 ve diğer her yere 0 koymak.

temiz ve kolay çözüm:

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)

Neuraxle boru hattı adımı kullanma :

1. Örneğinizi ayarlayın

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. Gerçek dönüşümü yapın

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

3. Çalıştığını iddia et

assert b_pred == b

Belgelere bağlantı: neuraxle.steps.numpy.OneHotEncoder

Yukarıdaki yanıtlara ve kendi kullanım durumuma dayanarak bunu yapmak için yazdığım örnek bir işlev:

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)

Tamamlamak için sadece numpy operatörleri kullanarak basit bir fonksiyon ekliyorum:

   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

Girdi olarak bir olasılık matrisi alır: örneğin:

[[0.03038822 0.65810204 0.16549407 0.3797123] ... [0.02771272 0.2760752 0.3280924 0.33458805]]

Ve geri dönecek

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

İşte boyutsallıktan bağımsız bağımsız bir çözüm.

Bu, herhangi bir N-boyutlu bir dizi dönüştürür arrbir sıcak N + 1-boyutlu dizi için negatif olmayan tamsayılar one_hot, one_hot[i_1,...,i_N,c] = 1araçlar arr[i_1,...,i_N] = c. Girişi şu yolla kurtarabilirsiniz:np.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

Aşağıdaki kodu kullanın. En iyi çalışır.

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

Burada buldum PS Linke gitmenize gerek yok.