¿Cómo transformar los elementos negativos a cero sin un bucle?

Question

Si tengo una matriz como

a = np.array([2, 3, -1, -4, 3]) 

Quiero configurar todos los elementos negativos a cero: [2, 3, 0, 0, 3]. ¿Cómo hacerlo con numpy sin un explícito para? Necesito utilizar la a modificado en un cálculo, por ejemplo

c = a * b 

donde b es otra matriz con la misma longitud del original a

Conclusión

import numpy as np 
from time import time 

a = np.random.uniform(-1, 1, 20000000) 
t = time(); b = np.where(a>0, a, 0); print "1. ", time() - t 
a = np.random.uniform(-1, 1, 20000000) 
t = time(); b = a.clip(min=0); print "2. ", time() - t 
a = np.random.uniform(-1, 1, 20000000) 
t = time(); a[a < 0] = 0; print "3. ", time() - t 
a = np.random.uniform(-1, 1, 20000000) 
t = time(); a[np.where(a<0)] = 0; print "4. ", time() - t 
a = np.random.uniform(-1, 1, 20000000) 
t = time(); b = [max(x, 0) for x in a]; print "5. ", time() - t 

1. 1,38629984856
2. 0.516846179962 < - más rápido a.clip (min = 0);
3. 0,615426063538
4. 0,944557905197
5. 51,7364809513

Answer 1

a = a.clip(min=0) 

Answer 2

Me gustaría hacer esto:

a[a < 0] = 0 

Si desea conservar el original a y único conjunto de los elementos negativos a cero en una copia, puede copiar primero la matriz:

c = a.copy() 
c[c < 0] = 0 

Answer 3

Uso where

a[numpy.where(a<0)] = 0 

Answer 4

Otro truco es usar la multiplicación. En realidad, esto parece ser mucho más rápido que cualquier otro método aquí. Por ejemplo

b = a*(a>0) # copies data 

o

a *= (a>0) # in-place zero-ing 

Me hicieron pruebas con timeit, pre-cálculo de la del < y> debido a que algunos de éstos modifican en el lugar y que podría afectar considerablemente los resultados. En todos los casos a fue np.random.uniform(-1, 1, 20000000) pero con los negativos ya establecidos en 0 pero L = a < 0 y G = a > 0 antes de a se ha cambiado. El clip tiene un impacto relativamente negativo ya que no llega a utilizar L o G (sin embargo, el cálculo de aquellos en la misma máquina tomó solo 17ms cada uno, por lo que no es la causa principal de la diferencia de velocidad).

%timeit b = np.where(G, a, 0) # 132ms copies 
%timeit b = a.clip(min=0)  # 165ms copies 
%timeit a[L] = 0    # 158ms in-place 
%timeit a[np.where(L)] = 0  # 122ms in-place 
%timeit b = a*G    # 87.4ms copies 
%timeit np.multiply(a,G,a)  # 40.1ms in-place (normal code would use `a*=G`) 

Al elegir a penalizar a los métodos in situ en lugar de clip, los siguientes tiempos: permite enviar una

%timeit b = np.where(a>0, a, 0)    # 152ms 
%timeit b = a.clip(min=0)     # 165ms 
%timeit b = a.copy(); b[a<0] = 0   # 231ms 
%timeit b = a.copy(); b[np.where(a<0)] = 0 # 205ms 
%timeit b = a*(a>0)       # 108ms 
%timeit b = a.copy(); b*=a>0    # 121ms 

no en el lugar métodos son penalizados por 20 ms (el tiempo necesario para calcular a>0 o a<0) y los métodos in-situ penalizan 73-83 ms (por lo que tarda de 53-63ms en hacer b.copy()).

En general, los métodos de multiplicación son mucho más rápidos que clip. Si no está en su lugar, es 1.5x más rápido. Si puede hacerlo en el lugar, entonces es 2.75x más rápido.