Summe array von Zahl in numpy

Vorausgesetzt, ich habe einen numpy-array wie:
[1,2,3,4,5,6]
und ein weiteres array:
[0,0,1,2,2,1]
Ich möchte, um die Summe der Elemente der ersten array-Gruppe (der zweiten Reihe) und erhalten n-Gruppen-Ergebnisse in der Gruppe Zahl um (in diesem Fall wäre das Ergebnis [3, 9, 9]). Wie mache ich das in numpy?

  • Warum brauchen Sie numpy für diese? Sie sind nicht nur mit Vanille-python-Listen? Wenn nicht, was numpy-Typ sind Sie?
  • Ich brauche numpy für das, weil ich nicht wollen, um eine Schleife durch das array n-mal für n-Gruppen, da mein array-Größen können beliebig groß sein. Ich bin nicht mit python-Listen, ich war nur mit einem Beispiel-Datensatz in Klammern. Der Datentyp ist int.
  • Verwandte stackoverflow.com/questions/7089379/...
InformationsquelleAutor Scribble Master | 2010-12-07
  1. 9

    Gibt es mehr als einen Weg, um dies zu tun, aber hier ist ein Weg:

    import numpy as np
data = np.arange(1, 7)
groups = np.array([0,0,1,2,2,1])

unique_groups = np.unique(groups)
sums = []
for group in unique_groups:
    sums.append(data[groups == group].sum())

    Du kann Vektorisieren Dinge so, dass es keine for-Schleife, aber ich würde empfehlen, gegen Sie. Es unlesbar wird, und erfordert ein paar 2D-arrays, der Sie möglicherweise große Mengen an Speicher, wenn man eine große Menge von Daten.

    Edit: Hier ist eine Möglichkeit, Sie könnten vollständig zu Vektorisieren. Beachten Sie, dass dies kann (und wird wahrscheinlich) langsamer als die version oben. (Und kann es einen besseren Weg, um zu Vektorisieren, aber es ist spät und ich bin müde, so ist dies nur das erste, was zu pop in meinem Kopf...)

    Jedoch halten Sie im Verstand, dass dies ein schlechtes Beispiel... Du bist echt besser aus (sowohl in Bezug auf die Geschwindigkeit und Lesbarkeit) mit der Schleife oben...

    import numpy as np
data = np.arange(1, 7)
groups = np.array([0,0,1,2,2,1])

unique_groups = np.unique(groups)

# Forgive the bad naming here...
# I can't think of more descriptive variable names at the moment...
x, y = np.meshgrid(groups, unique_groups)
data_stack = np.tile(data, (unique_groups.size, 1))

data_in_group = np.zeros_like(data_stack)
data_in_group[x==y] = data_stack[x==y]

sums = data_in_group.sum(axis=1)
    • Danke! Speicher ist nicht ein Problem, und ich möchte vermeiden Schleifen. Wie würden Sie Vektorisieren es?
    • Master - Siehe edit... Es ist nichts falsch mit der Schleife über die einzigartige Gruppen, obwohl. Die zweite version wird wahrscheinlich langsam, und ist verdammt schwer zu Lesen. Mit der Schleife bist du auch nur ein looping (in python sowieso), über die Anzahl eindeutiger Gruppen. Der innere Vergleich data[groups == group] ziemlich schnell.
    • Was dunkle Magie ist dieses data[groups == group] Konstrukt? Vergleich eines Arrays zu einem skalaren Erträgen irgendeine Art von Schnitt oder Ansicht? o_O
    • group liefert einen boolean-array. Sie können den index von arrays in numpy. Dies ist eine sehr häufige Redewendung in numpy (und Matlab). Ich finde es ziemlich gut lesbar (man denke es sich als "wo") und es ist sehr nützlich.
    • Ordentlich, aber vielleicht ein bisschen zu magisch für meinen Geschmack. Ich bin noch nicht sehr viel mit Numpy (habe nicht gefunden wie viel brauchen Sie für es als ich dachte, ich könnte) - es dauert etwas gewöhnungsbedürftig.
    • Ausgezeichnete Antwort! schnelle und effiziente
    • Wie würde das funktionieren, wenn die Daten und Gruppe sind multi-dimensional? E. g. Daten der Form (k,m,n) und es gibt j lang, es würde zurückkehren müssen eine Summe von über die dimension k für j-Behältern. Ergebnis müsste sein, j,m,n

    InformationsquelleAutor Joe Kington
  2. 27

    Die numpy-Funktion bincount wurde für genau diesen Zweck-und ich bin sicher, es wird viel schneller als die anderen Methoden, die für alle Größen der Eingänge:

    data = [1,2,3,4,5,6]
ids  = [0,0,1,2,2,1]

np.bincount(ids, weights=data) #returns [3,9,9] as a float64 array

    Dem i-TEN element der output ist die Summe aller data Elemente der entsprechenden "id" i.

    Hoffe, das hilft.

    • Bestätigen können dies sehr schnell. Über 10-mal schneller als die sum_by_group Methode Bi Rico auf kleine Eingänge.
    • was ist, wenn data sind Vektoren?
    • Es sieht aus wie die GEWICHTE argument ist 1-dimensional. Eine Lösung ist, um zu laufen, bincount einmal für jede dimension des Vektors (d.h. zweimal, ob Daten ist ein Satz von 2-d-Vektoren). Eine leichte Modifikation von Peter ' s Antwort sollte auch funktionieren.
    InformationsquelleAutor Alex
  3. 27

    Dies ist eine vektorisierte Methode, diese Summe basiert auf der Umsetzung von numpy.einzigartig. Nach meinen timings ist es bis zu 500-mal schneller ist als der loop-Methode und bis zu 100-mal schneller als die Histogramm-Methode.

    def sum_by_group(values, groups):
    order = np.argsort(groups)
    groups = groups[order]
    values = values[order]
    values.cumsum(out=values)
    index = np.ones(len(groups), 'bool')
    index[:-1] = groups[1:] != groups[:-1]
    values = values[index]
    groups = groups[index]
    values[1:] = values[1:] - values[:-1]
    return values, groups
    InformationsquelleAutor Bi Rico
  4. 7

    Wenn die Gruppen indiziert durch aufeinanderfolgende ganze zahlen, die Sie missbrauchen können die numpy.histogram() - Funktion, um das Ergebnis zu erhalten:

    data = numpy.arange(1, 7)
groups = numpy.array([0,0,1,2,2,1])
sums = numpy.histogram(groups, 
                       bins=numpy.arange(groups.min(), groups.max()+2), 
                       weights=data)[0]
# array([3, 9, 9])

    Damit vermeiden Sie, dass die Python-Schleifen.

    InformationsquelleAutor Sven Marnach
  5. 5

    Ich habe versucht Skripte von allen und meine überlegungen sind:

    Joe: Wird nur funktionieren, wenn Sie einige Gruppen.

    kevpie: Zu langsam, weil die Schleifen (dies ist nicht pythonic way)

    Bi_Rico und Sven: führen Sie gut, aber funktioniert nur für Int32 (wenn die Summe geht über 2^32/2 wird es scheitern)

    Alex: ist die Schnellste, gut für die Summe.

    Aber wenn Sie wollen, mehr Flexibilität und die Möglichkeit der Gruppierung von anderen Statistiken verwenden SciPy:

    from scipy import ndimage

data = np.arange(10000000)
groups = np.arange(1000).repeat(10000)
ndimage.sum(data, groups, range(1000))

    Dies ist gut, weil Sie viele Statistiken zu Gruppe (Summe, Mittelwert, Varianz, ...).

    InformationsquelleAutor caiohamamura
  6. 3

    Sind Sie alle falsch! Der beste Weg, es zu tun ist:

    a = [1,2,3,4,5,6]
ix = [0,0,1,2,2,1]
accum = np.zeros(np.max(ix)+1)
np.add.at(accum, ix, a)
print accum
> array([ 3.,  9.,  9.])
    InformationsquelleAutor Peter
  7. 0

    Einer reinen python-Umsetzung:

    l = [1,2,3,4,5,6]
g = [0,0,1,2,2,1]

from itertools import izip
from operator import itemgetter
from collections import defaultdict

def group_sum(l, g):
    groups = defaultdict(int)
    for li, gi in izip(l, g):
        groups[gi] += li
    return map(itemgetter(1), sorted(groups.iteritems()))

print group_sum(l, g)

[3, 9, 9]
    InformationsquelleAutor kevpie
  8. 0

    Bemerkte ich, dass die numpy - tag, aber in Fall, dass Sie nicht dagegen, mit pandas diese Aufgabe wird zu einem one-liner:

    import pandas as pd
import numpy as np

data = np.arange(1, 7)
groups = np.array([0, 0, 1, 2, 2, 1])

df = pd.DataFrame({'data': data, 'groups': groups})

    So df sieht dann wie folgt aus:

       data  groups
0     1       0
1     2       0
2     3       1
3     4       2
4     5       2
5     6       1

    Nun können Sie die Funktionen groupby() und sum()

    print df.groupby(['groups'], sort=False).sum()

    gibt Ihnen die gewünschte Ausgabe

            data
groups      
0          3
1          9
2          9

    Standardmäßig ist der dataframe würde sortiert werden, daher nutze ich die Flagge sort=False die möglicherweise verbessern die Geschwindigkeit für große dataframes.

    InformationsquelleAutor Cleb
Schreibe einen Kommentar