Wie berechnen die gewichtete Summe aller Elemente in einer Zeile in pandas?

Habe ich ein Pandabären-Daten-frame mit mehreren Spalten. Ich will eine neue Spalte erstellen weighted_sum von den Werten in der Zeile und eine weitere Spalte vector-dataframe weight

weighted_sum sollte den folgenden Wert haben:

row[weighted_sum] = row[col0]*weight[0] + row[col1]*weight[1] + row[col2]*weight[2] + ...

Fand ich die Funktion sum(axis=1), aber es lässt mich nicht multiplizieren mit weight.

Bearbeiten:
Ich änderte die Dinge ein wenig.

weight sieht wie folgt aus:

     0
col1 0.5
col2 0.3
col3 0.2

df sieht wie folgt aus:

col1 col2 col3
1.0  2.2  3.5
6.1  0.4  1.2

df*weight gibt einen dataframe voller Nan Werte.

Können Sie zeigen einige Ihrer DataFrame und weights? Es ist nicht klar, warum Sie ein problem, dies zu tun. Wenn Sie wollen einfach nur das Skalarprodukt der Zeile Werte mit weights dann verwenden Sie die ndarray.dot Methode: row.values.dot(weights.values).

InformationsquelleAutor ask | 2013-08-24

10

Das problem ist, dass man die Multiplikation a-frame mit einem frame von einer anderen Größe, mit einer anderen Zeile, index. Hier ist die Lösung:
```
In [121]: df = DataFrame([[1,2.2,3.5],[6.1,0.4,1.2]], columns=list('abc'))

In [122]: weight = DataFrame(Series([0.5, 0.3, 0.2], index=list('abc'), name=0))

In [123]: df
Out[123]:
           a          b          c
0       1.00       2.20       3.50
1       6.10       0.40       1.20

In [124]: weight
Out[124]:
           0
a       0.50
b       0.30
c       0.20

In [125]: df * weight
Out[125]:
           0          a          b          c
0        nan        nan        nan        nan
1        nan        nan        nan        nan
a        nan        nan        nan        nan
b        nan        nan        nan        nan
c        nan        nan        nan        nan
```
Können Sie entweder auf die Spalte:
```
In [126]: df * weight[0]
Out[126]:
           a          b          c
0       0.50       0.66       0.70
1       3.05       0.12       0.24

In [128]: (df * weight[0]).sum(1)
Out[128]:
0         1.86
1         3.41
dtype: float64
```
Oder verwenden Sie dot um wieder anderen DataFrame
```
In [127]: df.dot(weight)
Out[127]:
           0
0       1.86
1       3.41
```
Bringen Sie alle zusammen:
```
In [130]: df['weighted_sum'] = df.dot(weight)

In [131]: df
Out[131]:
           a          b          c  weighted_sum
0       1.00       2.20       3.50          1.86
1       6.10       0.40       1.20          3.41
```
Hier sind die timeits, jede Methode, die Verwendung einer größeren DataFrame.
```
In [145]: df = DataFrame(randn(10000000, 3), columns=list('abc'))
weight
In [146]: weight = DataFrame(Series([0.5, 0.3, 0.2], index=list('abc'), name=0))

In [147]: timeit df.dot(weight)
10 loops, best of 3: 57.5 ms per loop

In [148]: timeit (df * weight[0]).sum(1)
10 loops, best of 3: 125 ms per loop
```
Für eine Breite DataFrame:
```
In [162]: df = DataFrame(randn(10000, 1000))

In [163]: weight = DataFrame(randn(1000, 1))

In [164]: timeit df.dot(weight)
100 loops, best of 3: 5.14 ms per loop

In [165]: timeit (df * weight[0]).sum(1)
10 loops, best of 3: 41.8 ms per loop
```
So, dot ist schneller und besser lesbar.

HINWEIS:, Wenn alle Ihre Daten enthalten NaNs, dann sollten Sie nicht verwenden dot sollten Sie die multiply-and-sum-Methode. dot nicht in den Griff NaNs, da es nur ein dünner wrapper um numpy.dot() (was nicht handhaben NaNs).
- Ich war ziemlich erstaunt über diese Geschwindigkeit zu steigern, aber eigentlich bin ich nicht sicher, dass dot erzeugt das gleiche Ergebnis. Und df.mul(weight).sum(1) scheint über die gleichen (wenn auch ein wenig langsamer).
- df.dot(weight) produzieren eine DataFrame wenn df und weight sind beide DataFrames eine Series wenn entweder ein Series und eine Skalare sind beide Series. Numerisch sind Sie gleichwertig.
- Der speedup ist wahrscheinlich wegen der vorübergehenden erstellt durch die * Betrieb. dot braucht keine solche temporäre 🙂
- Stellt sich heraus dot tut, was numpy mit NaNs: barfs Sie gleich wieder in Sie.
- (df * weight).sum(1).head() != df.dot(weight).head() ?
- Welche der weights verwenden Sie? Series oder DataFrame?
- Wenn weight ist ein DataFrame dann Ihre obige code korrekt ist. Wenn weight ist ein Series dann ist es falsch. Die weight die OP vorgesehen ist, eine DataFrame das ist der Grund, warum er immer alle NaNs.
- Natürlich Punkt ist die Art und Weise, dies zu tun (anstatt mult gefolgt von Summe) 🙂
- Es sei denn, Sie haben NaNs, die ich bemerkt :s
- Es gibt ein Problem bei der Verwendung NaNs in dot in bestimmten Fällen, wie z.B. der Kovarianz-Matrizen nicht positiv semi-definit ist, wenn man Sie ignorieren. Ich denke, dass R lief auch in dieser Frage an einem gewissen Punkt, aber ich kann mich nicht erinnern, was Sie Taten. Vielleicht war es so etwas wie "lassen Sie den Benutzer entscheiden, ob Sie zulassen möchten, nichtNaN Werte in die Berechnung ein." Ich erstelle ein Thema, da ich denke, dass sollten wir lassen die user entscheiden, und halten Sie das aktuelle Verhalten als Standard.
InformationsquelleAutor Phillip Cloud

Vorausgesetzt GEWICHTE ist eine Reihe von gewichten für die einzelnen Spalten können Sie einfach multiplizieren und tun der Summe:

In [11]: df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['a', 'b', 'c'])

In [12]: weights = pd.Series([7, 8, 9], index=['a', 'b', 'c'])

In [13]: (df * weights)
Out[13]: 
    a   b   c
0   7  16  27
1  28  40  54

In [14]: (df * weights).sum(1)
Out[14]: 
0     50
1    122
dtype: int64

Der Vorteil dieses Ansatzes ist es kümmert sich um Spalten, die Sie nicht wollen, zu Wiegen:

In [21]: weights = pd.Series([7, 8], index=['a', 'b'])

In [22]: (df * weights)
Out[22]: 
    a   b   c
0   7  16 NaN
1  28  40 NaN

In [23]: (df * weights).sum(1)
Out[23]: 
0    23
1    68
dtype: float64

InformationsquelleAutor Andy Hayden

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.