J'ai mes données comme telles: où mes étiquettes sont les clés des données code> code> et la clé du dictionnaire intérieur sont des fonctionnalités: P > from collections import Counter
from scipy.sparse import csc_matrix
import numpy as np
all_features = ['a','b','c']
all_labels = ['x','y']
csc_matrix(np.array([[data[label][feat] for feat in all_features] for label in all_labels]))
3 Réponses :
Conversion d'un dictionnaire de dictionnaires en une matrice numpue ou scipy est, comme vous vivez, pas trop de plaisir. Si vous connaissez Si possible ou Non, vous voudrez conserver vos listes de fonctionnalités et d'étiquettes dans la commande triée, d'accélérer les looks. Donc, je vais supposer que ce qui suit ne change pas non plus un tableau: p> all_features code> et ALL_LABELLS CODE> Avant la main, vous êtes probablement mieux à l'aide d'une matrice SCIPY SPARSE COO à partir du début pour garder vos comptes. >>> sps_data.A
array([[ 1, 45, 0],
[ 0, 1, 212]], dtype=int64)
>>> all_labels
array(['x', 'y'],
dtype='<S1')
>>> all_features
array(['a', 'b', 'c'],
dtype='<S1')
Notez l'existence de ithertools.chain.from_iterable .
Le jeu de données est assez grand, donc je ne pense pas être pratique pour construire un tableau numpopy temporaire (si les entiers 32 bits sont utilisés une matrice 1E5 x 5E6 nécessiterait ~ 2 téraoctets de mémoire).
Je suppose que vous connaître la limite supérieure du nombre d'étiquettes. p>
Le code pourrait ressembler à: p>
import scipy.sparse
n_rows = len(data.keys())
max_col = int(5e6)
temp_sparse = scipy.sparse.lil_matrix((n_rows, max_col), dtype='int')
for i, (features, counts) in enumerate(data.iteritems()):
for label, n in counts.iteritem():
j = label_pos[label]
temp_sparse[i, j] = n
csc_matrix = temp_sparse.csc_matrix(temp_matrix)
s Il y a autre moyen de créer la matrice scipe des données sans boucle à travers toutes les caractéristiques et toutes les étiquettes? P>
Je ne pense pas qu'il y ait une coupe courte qui réduit le nombre total de recherches. Vous commencez par un dictionnaire de comptoirs (une sous-classe dict) afin que les deux niveaux de nidification soient des collections non ordonnées. Le seul moyen de les remettre dans la commande requise consiste à faire un
de données [étiquette] [feat] code> recherche pour chaque point de données. P>Vous pouvez couper l'heure à moitié en deux par Assurez-vous que les données
[étiquette] code> ne sont effectuées qu'une fois par étiquette: p>xxx pré> Vous pouvez également essayer de accélérer l'heure de fonctionnement en utilisant mappe () em> au lieu d'une compréhension de la liste (la cartographie peut tirer parti de la longueur interne_hint à la pré-dimension de la matrice de résultat): p>
def f(data, all_features, all_labels): counters = [data[label] for label in all_labels] return [map(counter.__getitem__, all_features) for counter in counters]
Je ne vois pas comment la création de la liste elle-même pourrait être beaucoup plus rapide si vous utilisez Pury Python, puisque le dictionnaire recherche est déjà une heure constante. Avez-vous essayé d'utiliser une typage statique des éléments (par exemple, Cyron?) De cette façon, vous pouvez probablement éviter le type de vérification des éléments de liste lorsque vous initialisez la matrice numpue (mais je ne sais pas si c'est le goulot d'étranglement dans le premier endroit)
Je n'en connais pas assez sur
numpy /scipy pour commenter comment "vectoriser" de votre fonctionnement, mais que vous développez une liste de 500 milliard < / i> des éléments avant de jamais le donner à Numpy. Voir si l'alimentationnp.fromiter une expression génératrice est plus rapide pour vous.Vous avez une solution plus rapide de 100 ms à l'aide de
opérateur.Itemplgeter , mais je ne pense pas que cela suffira pour un ensemble de données très volumineux. db.tt/jmdaxs7i