Meilleure façon de créer un tableau NumPy à partir d'un dictionnaire?

Je viens juste de commencer avec NumPy donc j'ai peut-être raté quelques concepts de base...

Quelle est la meilleure façon de créer un tableau NumPy à partir d'un dictionnaire dont les valeurs sont des listes?

Quelque chose comme ceci:

d = { 1: [10,20,30] , 2: [50,60], 3: [100,200,300,400,500] }

Doit se transformer en quelque chose comme:

data = [
  [10,20,30,?,?],
  [50,60,?,?,?],
  [100,200,300,400,500]
]

Je vais faire quelques statistiques de base sur chaque ligne, par exemple:

deviations = numpy.std(data, axis=1)

Questions:

  • Quel est le meilleur /le plus efficace pour créer de la numpy.tableau à partir du dictionnaire? Le dictionnaire est grande; un couple de millions de clés, chacune avec ~20 articles.

  • Le nombre de valeurs pour chaque "ligne" sont différents. Si je comprends bien numpy veut uniforme de taille, de sorte que dois-je remplir pour les éléments manquants à faire des mst() heureux?

Mise à jour: Une chose que j'ai oublié de mentionner -, tandis que le python techniques sont raisonnables (par exemple. boucle de plus de quelques millions d'articles est rapide), il est limité à un seul PROCESSEUR. Numpy opérations échelle bien pour le matériel et a frappé tous les Processeurs, de sorte qu'ils sont beaux.

OriginalL'auteur Parand | 2009-03-02

  1. 8

    Vous n'avez pas besoin de créer des tableaux numpy pour appeler numpy.std().
    Vous pouvez appeler numpy.std() dans une boucle sur toutes les valeurs de votre dictionnaire. La liste sera converti en un tableau numpy à la volée pour calculer la norme de la variation.

    L'inconvénient de cette méthode est que la boucle principale sera en python et pas en C. Mais je suppose que cela devrait être assez rapide: vous aurez toujours calculer les mst au C de la vitesse, et vous permettra d'économiser beaucoup de mémoire, vous n'aurez pas à stocker les valeurs 0, où vous avez à taille variable tableaux.

    • Si vous souhaitez poursuivre l'optimisation de cela, vous pouvez stocker vos valeurs dans une liste de tableaux numpy, de sorte que vous ne le python liste -> tableau numpy conversion en une seule fois.
    • si vous trouvez que c'est encore trop lent, essayez d'utiliser psycho pour optimiser la boucle python.
    • si c'est encore trop lent, essayez d'utiliser Cython avec le module numpy. Cette Tutoriel revendications impressionnante amélioration de la vitesse de traitement de l'image. Ou tout simplement le programme de l'ensemble de la fonction std en Cython (voir cette pour des repères et des exemples avec la fonction somme )
    • Une alternative à Cython serait d'utiliser SWIG avec numpy.j'.
    • si vous souhaitez utiliser numpy et ont tout calculé au niveau C, essayez de regrouper tous les enregistrements de la même taille dans les différents tableaux et appel numpy.std() sur chacun d'eux. Il devrait ressembler à l'exemple suivant.

    exemple avec O(N) complexité:

    import numpy
list_size_1 = []
list_size_2 = []
for row in data.itervalues():
    if len(row) == 1:
      list_size_1.append(row)
    elif len(row) == 2:
      list_size_2.append(row)
list_size_1 = numpy.array(list_size_1)
list_size_2 = numpy.array(list_size_2)
std_1 = numpy.std(list_size_1, axis = 1)
std_2 = numpy.std(list_size_2, axis = 1)
    Je suis en train de faire la numpy.les mst dans une boucle maintenant, et vous avez raison, la mémoire des économies sont importantes. Je voudrais au moins faire une comparaison de la vitesse avec la numpy version.
    Le problème est que numpy.std() a été faite pour accepter uniquement à fixer la taille du tableau. Donc le seul moyen que je vois pour faire ce test consiste à regrouper tous les enregistrements de la même taille et les appeler numpy.std() sur chacun d'eux.
    Ne devrait pas Disponible vraiment être Cython? Ai-je eu tort?
    Oui, c'est exact. Fixe.
    Le groupement des mêmes enregistrements taille, simple mais efficace. Je l'aime.

    OriginalL'auteur

  2. 2

    Alors qu'il existe déjà quelques-unes assez raisonnable idées ici présents, je crois que la suite vaut la peine de mentionner.

    De remplissage des données manquantes avec toute la valeur par défaut serait gâcher les caractéristiques statistiques (mst, etc). De toute évidence c'est pourquoi Mapad proposé la tour de nice avec le groupement de même de la taille des dossiers.
    Le problème avec lui (en supposant qu'il n'est pas a priori des données sur les enregistrements des longueurs est à portée de main), c'est qu'il implique encore plus de calculs que la solution simple et efficace:

    1. au moins O(N*logN) 'len' appels et les comparaisons pour le tri avec un algorithme efficace
    2. O(N) vérifications sur le second chemin à travers la liste pour obtenir des groupes(le début et la fin de l'index sur la verticale de l'axe)

    À l'aide de Psyco est une bonne idée (c'est étonnamment facile à utiliser, assurez-vous donc de faire un essai).

    Il semble que le meilleur moyen est de prendre la stratégie décrite par Mapad de balle #1, mais avec une modification - de ne pas générer l'ensemble de la liste, mais itérer dans le dictionnaire de la conversion de chaque ligne dans numpy.tableau et effectuer les calculs nécessaires. Comme ceci:

    for row in data.itervalues():
    np_row = numpy.array(row)    
    this_row_std = numpy.std(np_row)
    # compute any other statistic descriptors needed and then save to some list

    En tout cas, quelques millions de boucles en python ne prendra pas aussi longtemps que l'on pourrait attendre. D'ailleurs ça ne ressemble pas à une routine de calcul, alors, qui se soucie si il faut plus de seconde/minute si il est exécuté une seule fois dans un certain temps ou même juste une fois.

    Généralisée variante de ce qui a été suggéré par Mapad:

    from numpy import array, mean, std

def get_statistical_descriptors(a):
    if ax = len(shape(a))-1
    functions = [mean, std]
    return f(a, axis = ax) for f in functions


def process_long_list_stats(data):
    import numpy

    groups = {}

    for key, row in data.iteritems():
        size = len(row)
        try:
            groups[size].append(key)
        except KeyError:
            groups[size] = ([key])

    results = []

    for gr_keys in groups.itervalues():             
        gr_rows = numpy.array([data[k] for k in gr_keys])       
        stats = get_statistical_descriptors(gr_rows)                
        results.extend( zip(gr_keys, zip(*stats)) )

    return dict(results)
    Grâce Maleev, c'est essentiellement ce que j'ai fait. Une chose que j'ai oublié de mentionner - en bouclant en Python est rapide, je crois que je suis le seul à l'aide d'un PROCESSEUR unique avec cette méthode. La matrice des opérations de frapper tous les Cpu, de sorte qu'ils sont beaux.
    Pourquoi auriez-vous besoin pour trier les lignes avant de regroupement des vecteurs en fonction de la longueur? Seul le regroupement est nécessaire. D'ailleurs, je serais prudent avec le big O notation: ici N ~ 1000000 mais la vitesse entre Python et C programme peut être ~100 fois plus lent. Donc N -> 1000 n'est pas vraiment tendance à l'infini
    2 Parand: Vous avez raison, la prise de multi-threading en compte le fait vraiment sens. 2 Mapad: Si je ne suis pas terriblement erronée, le groupement est essentiellement équivalent à un traitement de tri. Alors, comment pouvez-vous suggérer à un groupe?
    Le code Python, si c'est juste une boucle sur les lignes ou le groupement, est exécutée dans tous les cas. Donc parler exclusivement de code python de la complexité asymptotique, nous avons différence à pO(NlogN) - pO(N) p = O(NlogN). En plus de code C boucle sur les lignes à l'intérieur de groupes ajoute cO(N).
    Vous dites que c << p. Assurez-vous. Mais qui laisse tout de même que la p*O(NlogN) différence. Sauf si vous pouvez prouver que vous pouvez vraiment faire de regroupement en O(N) en moyenne et dans le pire des cas.

    OriginalL'auteur

  3. 0

    numpy dictionnaire

    Vous pouvez utiliser un tableau structuré afin de préserver la capacité de répondre à une numpy objet par une clé, comme un dictionnaire.

    import numpy as np


dd = {'a':1,'b':2,'c':3}
dtype = eval('[' + ','.join(["('%s', float)" % key for key in dd.keys()]) + ']')
values = [tuple(dd.values())]
numpy_dict = np.array(values, dtype=dtype)

numpy_dict['c']

    maintenant sortie

    array([ 3.])
    Toutefois, le tableau qui en résulte a un imbriquée tuple, de sorte qu'il pourrait être plus lente pour certaines opérations.

    OriginalL'auteur Davoud Taghawi-Nejad