Estaba tratando de hacer una matriz activa basada en los caracteres de mi diccionario: primero, creé unos ceros numpy que tienen una fila X columna (3x7) y luego busco la identificación de cada carácter y asigno "1" a cada fila del matriz numpy

Mi objetivo es asignar a cada personaje con una matriz activa. "1" como "presente" y "0" como "no presente". Aquí tenemos 3 caracteres, por lo que deberíamos tener 3 filas, mientras que las 7 columnas sirven como la existencia de caracteres en el diccionario.

Sin embargo, recibí un error que indica que "TypeError: solo las matrices escalares enteras se pueden convertir en un índice escalar". ¿Alguien puede ayudarme en esto? Gracias

Para no hacer que todas malentiendan mi diccionario:

Así es como creo la dic:

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

Mi código:

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)

Error actual:

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

Mi salida esperada:

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

-------> Dado que es un diccionario, la disposición del índice debe ser diferente y el "1" dentro de la matriz es un falso para que pueda mostrar mi salida esperada.

1
JJson 14 sep. 2018 a las 03:50

5 respuestas

La mejor respuesta

Establecer índices

(Comentarios en línea).

# 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.]])
4
cs95 14 sep. 2018 a las 01:38

Una codificación única trata una muestra como una secuencia, donde cada elemento de la secuencia es el índice en un vocabulario que indica si ese elemento (como una palabra o letra) está en la muestra. Por ejemplo, si su vocabulario era el alfabeto en minúsculas, una codificación única del gato de trabajo podría verse así:

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

Indicando que esta palabra contiene las letras c, a y t.

Para hacer una codificación única, necesita dos cosas: una búsqueda de vocabulario con todos los valores posibles (cuando se usan palabras, esta es la razón por la cual las matrices pueden ser tan grandes porque el vocabulario es enorme). Pero si codifica el alfabeto en minúsculas solo necesita 26.

Luego, normalmente representa sus muestras como índices en el vocabulario. Entonces el conjunto de palabras podría verse así:

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

Cuando codifica en caliente, obtendrá una matriz de 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)

Lo que da como resultado tres muestras codificadas con un vocabulario de 26 letras listas para ser alimentadas a una red neuronal:

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.]])
2
Mark Meyer 14 sep. 2018 a las 01:56

Aquí hay otro usando sklearn.preprocessing

Las líneas son bastante largas y no hay mucha diferencia. No sé por qué, pero produjo resultados similares.

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

Salida

[[0. 1. 0. 0. 0. 0. 0.]
 [0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1. 0. 0.]]
1
JJson 14 sep. 2018 a las 04:57

Me gusta usar un LabelEncoder con un OneHotEncoder de {{ X2}}.

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

Lo almacena escaso, por lo que es útil. También puede usar un LabelBinarizer para racionalizar esto:

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))
0
Scott 14 sep. 2018 a las 14:48

Mi solución y para futuras lectoras:

Construyo el diccionario para la lista de "enviados":

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

Luego encuentro los índices para mis propias oraciones basadas en el diccionario y les asigno los valores numéricos a estas oraciones.

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)

Extraigo los índices de la nueva asignación de "a":

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

Luego creo otra matriz numpy para estos índices de extracto de a.

index = np.asarray(index)

Ahora creo ceros numpy para almacenar la existencia de cada personaje:

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

Imprimir (nuevo)

Salida:

[[0. 1. 0. 0. 0. 0. 0.]
[0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1. 0. 0.]]
1
JJson 14 sep. 2018 a las 02:04