Генерация одного горячего кодирования из значений dict

Question

Я пытался создать один горячий массив на основе символов моего словаря: сначала я создал пустые нули со столбцом X строки (3x7), а затем я ищу идентификатор каждого символа и присваиваю «1» каждомустрока массива numpy.

Моя цель - назначить каждому символу один горячий массив.«1» как «присутствует» и «0» как «нет».Здесь у нас есть 3 символа, поэтому у нас должно быть 3 строки, в то время как 7 столбцов служат существованием символов в словаре.

Однако я получил сообщение о том, что «TypeError: только скалярные целочисленные массивы могут быть преобразованы в скалярный индекс».Может кто-нибудь помочь мне в этом?Спасибо

Чтобы все не поняли мой словарь:

Вот как я создаю слово:

sent = ["a", "b", "c", "d", "e", "f", "g"]
aaa = len(sent)
aa = {x:i for i,x in enumerate(sent)}

Мой код:

import numpy as np
sentences = ["b", "c", "e"]
a = {}
for xx in sentences:
   a[xx] = aa[xx]
a = {"b":1, "c":2, "e":4}
aa =len(a)

for x,y in a.items():
    aa = np.zeros((aa,aaa))
    aa[y] = 1

print(aa)

Текущая ошибка:

TypeError: only integer scalar arrays can be converted to a scalar index

Мой ожидаемый вывод:

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

-------> Так как его словарь, то расположение индекса должно быть другим, и "1в массиве находится пустышка, так что я могу показать ожидаемый результат.

Answer 1

Вот еще один пример с использованием sklearn.preprocessing

Строки довольно длинные и без большой разницы. Я не знаю почему, но привел к подобным результатам.

import numpy as np
from sklearn.preprocessing import OneHotEncoder
sent = ["a", "b", "c", "d", "e", "f", "g"]
aaa = len(sent)
aa = {x:i for i,x in enumerate(sent)}


sentences = ["b", "c", "e"]
a = {}
for xx in sentences:
   a[xx] = aa[xx]
a = {"a":0, "b":1, "c":2, "d":3, "e":4, "f":5, "g":6}
aa =len(a)

index = []
for x,y in a.items():
    index.append([y])

index = np.asarray(index)

enc = OneHotEncoder()
enc.fit(index)

print(enc.transform([[1], [2], [4]]).toarray())

выход

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

Answer 2

Мне нравится использовать LabelEncoder с OneHotEncoder от sklearn.

import sklearn.preprocessing
import numpy as np

texty_data = np.array(["a", "c", "b"])
le = sklearn.preprocessing.LabelEncoder().fit(texty_data)
integery_data = le.transform(texty_data)
ohe = sklearn.preprocessing.OneHotEncoder().fit(integery_data.reshape((-1,1)))
onehot_data = ohe.transform(integery_data.reshape((-1,1)))

Хранит его редко, так что это удобно. Вы также можете использовать LabelBinarizer, чтобы упростить это:

import sklearn.preprocessing
import numpy as np

texty_data = np.array(["a", "c", "b"])
lb = sklearn.preprocessing.LabelBinarizer().fit(texty_data)
onehot_data = lb.transform(texty_data)
print(onehot_data, lb.inverse_transform(onehot_data))

Answer 3

Одно горячее кодирование обрабатывает выборку как последовательность, где каждый элемент последовательности является индексом в словарь, указывающий, присутствует ли этот элемент (например, слово или буква) в выборке.Например, если ваш словарь представляет собой строчный алфавит, код рабочей кошки в одну горячую строку может выглядеть следующим образом:

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

Указывая, что это слово содержит буквы c, a иt.

Чтобы сделать горячее кодирование, вам понадобится две вещи - поиск словаря со всеми возможными значениями (поэтому при использовании слов матрицы могут быть такими большими, потому что словарь огромный!).Но если кодировать алфавит в нижнем регистре, вам нужно только 26.

Тогда вы, как правило, представляете свои выборки в качестве индексов в словаре.Таким образом, набор слов может выглядеть следующим образом:

#bag, cab, fad
sentences = np.array([[1, 0, 6], [2, 0, 1], [5, 0, 3]])

Когда вы горячо закодируете, вы получите матрицу 3 x 26:

vocab = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

#bag, cab, fad
sentences = np.array([[1, 0, 6], [2, 0, 1], [5, 0, 3]])

def onHot(sequences, dimension=len(vocab)):
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
      results[i, sequence] = 1
    return results

onHot(sentences)

Что приводит к вамобразцы в горячем коде с 26-буквенным словарем, готовые для передачи в нейронную сеть:

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

Answer 4

Мое решение и для будущих читателей:

Я строю словарь для списка «отправленных»:

sent = ["a", "b", "c", "d", "e", "f", "g"]
aaa = len(sent)
aa = {x:i for i,x in enumerate(sent)}

Затем я нахожу индексы для своих собственных предложений на основе словаря иназначил числовые значения этим предложениям.

import numpy as np
sentences = ["b", "c", "e"]
a = {}
for xx in sentences:
   a[xx] = aa[xx]
a = {"b":1, "c":2, "e":4}
aa =len(a)

Я извлекаю индексы из нового присваивания "a":

index = []
for x,y in a.items():
    index.append(y)

Затем я создаю еще один массив для этих извлеченных индексов из a.

index = np.asarray(index)

Теперь я создаю пустые нули для хранения существования каждого символа:

new = np.zeros((aa,aaa))
new[np.arange(aa), index] = 1

print (new)

Вывод:

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

Answer 5

Настройка индексов

(комментарии вписаны.)

# Sort and extract the indices.
idx = sorted(a.values())
# Initialise a matrix of zeros.
aa = np.zeros((len(idx), max(idx) + 1))
# Assign 1 to appropriate indices.
aa[np.arange(len(aa)), idx] = 1

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

---

numpy.eye

idx = sorted(a.values())
eye = np.eye(max(idx) + 1)    
aa = eye[idx]

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