Vectores de fila o columna de "clonación"

A veces es útil "clonar" un vector de fila o columna a una matriz. Al clonar me refiero a convertir un vector de fila como

[1,2,3]

En una matriz

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

o un vector de columna como

[1
 2
 3
]

dentro

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

En matlab u octava, esto se hace con bastante facilidad:

 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

Quiero repetir esto en numpy, pero sin éxito

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.]])

¿Por qué no funcionaba el primer método ( In [16])? ¿Hay alguna manera de lograr esta tarea en Python de una manera más elegante?

Aquí hay una forma elegante y pitónica de hacerlo:

>>> 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]])

El problema con [16]parece ser que la transposición no tiene ningún efecto para una matriz. probablemente quieras una matriz en su lugar:

>>> 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]])

Uso numpy.tile:

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

o para repetir columnas:

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

Primero tenga en cuenta que con las operaciones de transmisión de numpy generalmente no es necesario duplicar filas y columnas. Vea esto y esto para descripciones.

Pero para hacer esto, repetir y newaxis son probablemente la mejor manera

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]])

Este ejemplo es para un vector de fila, pero es de esperar que aplicar esto a un vector de columna sea obvio. la repetición parece deletrear esto bien, pero también puedes hacerlo mediante la multiplicación como en tu ejemplo

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.]])

Dejar:

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

Asignaciones de costo cero

Una vista no toma memoria adicional. Por lo tanto, estas declaraciones son instantáneas:

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

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

Asignación forzada

Si desea forzar los contenidos a residir en la memoria:

>>> %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)

Los tres métodos tienen aproximadamente la misma velocidad.

Cálculo

>>> 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)

Los tres métodos tienen aproximadamente la misma velocidad.

Conclusión

Si desea replicar antes de un cálculo, considere usar uno de los métodos de "asignación de costo cero". No sufrirá la penalización de rendimiento de la "asignación forzada".

Creo que usar la transmisión en numpy es lo mejor y más rápido

Hice una comparación de la siguiente manera

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

aproximadamente 15 veces más rápido usando la transmisión

Una solución limpia es usar la función de producto externo de NumPy con un vector de unos:

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

da nfilas repetidas. Cambie el orden de los argumentos para obtener columnas repetidas. Para obtener el mismo número de filas y columnas, puede hacer

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

Puedes usar

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

el mosaico generará las repeticiones del vector

y remodelar le dará la forma que deseas

Si tiene un marco de datos de pandas y desea preservar los tipos, incluso los categóricos, esta es una forma rápida de hacerlo:

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)

rendimientos:

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