"Klonen" von Zeilen- oder Spaltenvektoren

Manchmal ist es nützlich, einen Zeilen- oder Spaltenvektor in eine Matrix zu "klonen". Mit Klonen meine ich das Konvertieren eines Zeilenvektors wie z

[1,2,3]

In eine Matrix

[[1,2,3]
 [1,2,3]
 [1,2,3]
]

oder ein Spaltenvektor wie

[1
 2
 3
]

in

[[1,1,1]
 [2,2,2]
 [3,3,3]
]

In Matlab oder Oktave ist dies ziemlich einfach:

 x = [1,2,3]
 a = ones(3,1) * x
 a =

    1   2   3
    1   2   3
    1   2   3

 b = (x') * ones(1,3)
 b =

    1   1   1
    2   2   2
    3   3   3

Ich möchte dies in numpy wiederholen, aber erfolglos

In [14]: x = array([1,2,3])
In [14]: ones((3,1)) * x
Out[14]:
array([[ 1.,  2.,  3.],
       [ 1.,  2.,  3.],
       [ 1.,  2.,  3.]])
# so far so good
In [16]: x.transpose() * ones((1,3))
Out[16]: array([[ 1.,  2.,  3.]])
# DAMN
# I end up with 
In [17]: (ones((3,1)) * x).transpose()
Out[17]:
array([[ 1.,  1.,  1.],
       [ 2.,  2.,  2.],
       [ 3.,  3.,  3.]])

Warum In [16]funktionierte die erste Methode ( ) nicht? Gibt es eine Möglichkeit, diese Aufgabe in Python eleganter zu erfüllen?

Hier ist eine elegante, pythonische Methode:

>>> array([[1,2,3],]*3)
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

>>> array([[1,2,3],]*3).transpose()
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

Das Problem mit [16]scheint zu sein, dass die Transponierung keine Auswirkung auf ein Array hat. Sie möchten wahrscheinlich stattdessen eine Matrix:

>>> x = array([1,2,3])
>>> x
array([1, 2, 3])
>>> x.transpose()
array([1, 2, 3])
>>> matrix([1,2,3])
matrix([[1, 2, 3]])
>>> matrix([1,2,3]).transpose()
matrix([[1],
        [2],
        [3]])

Verwendung numpy.tile:

>>> tile(array([1,2,3]), (3, 1))
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

oder zum Wiederholen von Spalten:

>>> tile(array([[1,2,3]]).transpose(), (1, 3))
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

Zunächst ist zu beachten , dass mit numpy des Rundfunk ist es in der Regel nicht erforderlich , Zeilen und Spalten - Operationen zu duplizieren. Siehe dies und das für Beschreibungen.

Aber um dies zu tun, sind Wiederholung und neue Achse wahrscheinlich der beste Weg

In [12]: x = array([1,2,3])

In [13]: repeat(x[:,newaxis], 3, 1)
Out[13]: 
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

In [14]: repeat(x[newaxis,:], 3, 0)
Out[14]: 
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

Dieses Beispiel bezieht sich auf einen Zeilenvektor, aber die Anwendung auf einen Spaltenvektor ist hoffentlich offensichtlich. Wiederholung scheint dies gut zu buchstabieren, aber Sie können es auch wie in Ihrem Beispiel durch Multiplikation tun

In [15]: x = array([[1, 2, 3]])  # note the double brackets

In [16]: (ones((3,1))*x).transpose()
Out[16]: 
array([[ 1.,  1.,  1.],
       [ 2.,  2.,  2.],
       [ 3.,  3.,  3.]])

Lassen:

>>> n = 1000
>>> x = np.arange(n)
>>> reps = 10000

Kostenfreie Zuweisungen

Eine Ansicht benötigt keinen zusätzlichen Speicher. Somit sind diese Erklärungen augenblicklich:

# New axis
x[np.newaxis, ...]

# Broadcast to specific shape
np.broadcast_to(x, (reps, n))

Erzwungene Zuordnung

Wenn Sie möchten, dass sich der Inhalt im Speicher befindet:

>>> %timeit np.array(np.broadcast_to(x, (reps, n)))
10.2 ms ± 62.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

>>> %timeit np.repeat(x[np.newaxis, :], reps, axis=0)
9.88 ms ± 52.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

>>> %timeit np.tile(x, (reps, 1))
9.97 ms ± 77.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Alle drei Methoden sind ungefähr gleich schnell.

Berechnung

>>> a = np.arange(reps * n).reshape(reps, n)
>>> x_tiled = np.tile(x, (reps, 1))

>>> %timeit np.broadcast_to(x, (reps, n)) * a
17.1 ms ± 284 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

>>> %timeit x[np.newaxis, :] * a
17.5 ms ± 300 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

>>> %timeit x_tiled * a
17.6 ms ± 240 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Alle drei Methoden sind ungefähr gleich schnell.

Fazit

Wenn Sie vor einer Berechnung replizieren möchten, sollten Sie eine der "Zero-Cost-Allocation" -Methoden verwenden. Sie werden nicht die Leistungsstrafe der "erzwungenen Zuweisung" erleiden.

Ich denke, die Sendung in Numpy zu verwenden ist das Beste und schneller

Ich habe einen Vergleich wie folgt durchgeführt

import numpy as np
b = np.random.randn(1000)
In [105]: %timeit c = np.tile(b[:, newaxis], (1,100))
1000 loops, best of 3: 354 µs per loop

In [106]: %timeit c = np.repeat(b[:, newaxis], 100, axis=1)
1000 loops, best of 3: 347 µs per loop

In [107]: %timeit c = np.array([b,]*100).transpose()
100 loops, best of 3: 5.56 ms per loop

etwa 15 mal schneller mit Broadcast

Eine saubere Lösung besteht darin, die Außenproduktfunktion von NumPy mit einem Vektor von Einsen zu verwenden:

np.outer(np.ones(n), x)

gibt sich nwiederholende Zeilen. Ändern Sie die Argumentreihenfolge, um sich wiederholende Spalten zu erhalten. Um eine gleiche Anzahl von Zeilen und Spalten zu erhalten, können Sie dies tun

np.outer(np.ones_like(x), x)

Sie können verwenden

np.tile(x,3).reshape((4,3))

Kachel erzeugt die Wiederholungen des Vektors

und Umformung gibt es die Form, die Sie wollen

Wenn Sie einen Pandas-Datenrahmen haben und die d-Typen, auch die Kategorien, beibehalten möchten, ist dies eine schnelle Möglichkeit:

import numpy as np
import pandas as pd
df = pd.DataFrame({1: [1, 2, 3], 2: [4, 5, 6]})
number_repeats = 50
new_df = df.reindex(np.tile(df.index, number_repeats))

import numpy as np
x=np.array([1,2,3])
y=np.multiply(np.ones((len(x),len(x))),x).T
print(y)

Ausbeuten:

[[ 1.  1.  1.]
 [ 2.  2.  2.]
 [ 3.  3.  3.]]