¿Cuál es la forma más rápida de copiar datos de la matriz b a la matriz a, sin modificar la dirección de la matriz a. Necesito esto porque una biblioteca externa (PyFFTW) usa un puntero a mi matriz que no puede cambiar.
Por ejemplo:
a = numpy.empty(n, dtype=complex)
for i in xrange(a.size):
a[i] = b[i]
¿Es posible hacerlo sin bucle?
Yo creo
a = numpy.empty_like (b)
a[:] = b
hará una copia profunda rápidamente. Como menciona Funsi, las versiones recientes de numpy también tienen la copytofunción.
La versión 1.7 de NumPy tiene la numpy.copytofunción que hace lo que estás buscando:
numpy.copyto (dst, src)
Copia valores de una matriz a otra y difunde según sea necesario.
Ver: https://docs.scipy.org/doc/numpy/reference/generated/numpy.copyto.html
AttributeError: 'module' object has no attribute 'copyto'
a = numpy.array(b)
es incluso más rápido que las soluciones sugeridas hasta numpy v1.6 y también hace una copia de la matriz. Sin embargo, no pude probarlo contra copyto (a, b), ya que no tengo la versión más reciente de numpy.
Para responder a su pregunta, jugué con algunas variantes y las perfilé.
Conclusión: para copiar datos de una matriz numérica a otra, utilice una de las funciones numéricas integradas numpy.array(src)o numpy.copyto(dst, src)siempre que sea posible.
(Pero siempre elija el último si dstla memoria ya está asignada, para reutilizar la memoria. Consulte el perfil al final de la publicación).
configuración de perfiles
import timeit
import numpy as np
import pandas as pd
from IPython.display import display
def profile_this(methods, setup='', niter=10 ** 4, p_globals=None, **kwargs):
if p_globals is not None:
print('globals: {0}, tested {1:.0e} times'.format(p_globals, niter))
timings = np.array([timeit.timeit(method, setup=setup, number=niter,
globals=p_globals, **kwargs) for
method in methods])
ranking = np.argsort(timings)
timings = np.array(timings)[ranking]
methods = np.array(methods)[ranking]
speedups = np.amax(timings) / timings
pd.set_option('html', False)
data = {'time (s)': timings,
'speedup': ['{:.2f}x'.format(s) if 1 != s else '' for s in speedups],
'methods': methods}
data_frame = pd.DataFrame(data, columns=['time (s)', 'speedup', 'methods'])
display(data_frame)
print()
código de perfil
setup = '''import numpy as np; x = np.random.random(n)'''
methods = (
'''y = np.zeros(n, dtype=x.dtype); y[:] = x''',
'''y = np.zeros_like(x); y[:] = x''',
'''y = np.empty(n, dtype=x.dtype); y[:] = x''',
'''y = np.empty_like(x); y[:] = x''',
'''y = np.copy(x)''',
'''y = x.astype(x.dtype)''',
'''y = 1*x''',
'''y = np.empty_like(x); np.copyto(y, x)''',
'''y = np.empty_like(x); np.copyto(y, x, casting='no')''',
'''y = np.empty(n)\nfor i in range(x.size):\n\ty[i] = x[i]'''
)
for n, it in ((2, 6), (3, 6), (3.8, 6), (4, 6), (5, 5), (6, 4.5)):
profile_this(methods[:-1:] if n > 2 else methods, setup,
niter=int(10 ** it), p_globals={'n': int(10 ** n)})
resultados para Windows 7 en CPU Intel i7, CPython v3.5.0, numpy v1.10.1.
Además, vea los resultados de una variante del perfil donde la memoria del destino ya está preasignada durante la copia de valores, ya que y = np.empty_like(x)es parte de la configuración:
x.copy()es tan rápido como np.array(x)y me gusta mucho más la sintaxis: $ python3 -m timeit -s "import numpy as np; x = np.random.random((100, 100))" "x.copy()"- 100000 loops, best of 3: 4.7 usec per loop. Tengo resultados similares para np.array(x). Probado en Linux con un i5-4210U y numpy 1.10.4
np.copyes más permisiva: np.copy(False), np.copy(None)siendo el trabajo, mientras a = None; a.copy()lanza AttributeError: 'NoneType' object has no attribute 'copy'. Además, somos más precisos al declarar lo que queremos que suceda en esta línea de código usando la función en lugar de la sintaxis del método.
np.copy(None)que no arroje un error es realmente atípico. Una razón más para usar a.copy():)
y[:] = xahora es ligeramente más rápido que copyto(y, x). Código y salida en gist.github.com/bhawkins/7cdbd5b9372cb798e34e21f92279d2dc
puedes usarlo fácilmente:
b = 1*a
esta es la forma más rápida, pero también tiene algunos problemas. Si no define directamente el dtypede ay tampoco marca el dtypede b, puede meterse en problemas. Por ejemplo:
a = np.arange(10) # dtype = int64
b = 1*a # dtype = int64
a = np.arange(10.) # dtype = float64
b = 1*a # dtype = float64
a = np.arange(10) # dtype = int64
b = 1. * a # dtype = float64
Espero poder aclarar el punto. A veces, tendrá un cambio de tipo de datos con solo una pequeña operación.
a = numpy.zeros(len(b))o a = numpy.empty(n,dtype=complex)también creará una nueva matriz.
Hay muchas cosas diferentes que puede hacer:
a=np.copy(b)
a=np.array(b) # Does exactly the same as np.copy
a[:]=b # a needs to be preallocated
a=b[np.arange(b.shape[0])]
a=copy.deepcopy(b)
Cosas que no funcionan
a=b
a=b[:] # This have given my code bugs
Por qué no usar
a = 0 + b
Creo que es similar a la multiplicación anterior, pero podría ser más simple.
a = bsimplemente crea una nueva referencia ab.a[:] = bsignifica "establecer todos los elementos deaiguales a los deb". La diferencia es importante porque las matrices numpy son tipos mutables.empty()es aproximadamente un 10% más rápido quezeros(). Sorprendentemente,empty_like()es incluso más rápido.copyto(a,b)es más rápido que la sintaxis de matriza[:] = b. Ver gist.github.com/bhawkins/5095558np.copyto(a, b)y cuándoa = b.astype(b.dtype)mejorar la velocidad, consulte la respuesta a continuación: stackoverflow.com/a/33672015/3703716empty_likesea mucho más rápido queempty, especialmente porquezeros_likees más lento quezeros. Por cierto, volví a ejecutar mi punto de referencia (ahora actualizado) y la diferencia entrecopyto(a,b)ya[:] = bparece haberse evaporado. gist.github.com/bhawkins/5095558