es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Vectorización de Numpy con cálculos dependientes del valor (o valores) anterior(es)

16 Jul, 2023 Programación

¿Existe alguna forma vectorizada de cambiar todos los 1s concurrentes que se encuentran dentro de “offset” del primer 1 en 0s (transformar A en B)? Actualmente estoy intentando hacer esto en un array de numpy con más de 1 millón de elementos donde la velocidad es crítica.

Los 1s representan una señal de activación y los 0s representan la falta de activación. Por ejemplo: dada una “offset” de 5, siempre que haya un 1, los siguientes 5 elementos deben ser 0 (para eliminar la concurrencia de señal).

Ejemplo 1:

offset = 3
A = np.array([1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0])
B = np.array([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0])

Ejemplo 2:

offset = 2
A = np.array([1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0])
B = np.array([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0])
Tags:  , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Sí, hay una manera vectorizada de lograr esto usando numpy. Podemos usar la función numpy.diff para encontrar la diferencia entre los elementos consecutivos del arreglo. Luego, podemos usar numpy.where para realizar las sustituciones necesarias basadas en el valor de desplazamiento.

    Aquí tienes un ejemplo de código que demuestra este enfoque:

    import numpy as np

desplazamiento = 5
A = np.array([1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0])

# encontrar la diferencia entre los elementos consecutivos de A
diff_A = np.diff(A)

# encontrar los índices del primer 1 en cada secuencia de 1s que estén dentro del desplazamiento del 1 anterior
indices = np.where(diff_A == 1)[0] + 1
for i in indices:
    A[i:i+desplazamiento] = 0

print(A)

    La salida para la entrada dada será:

    [1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0]

    Este enfoque es vectorizado y debería funcionar de manera eficiente para matrices grandes de numpy.

Comments are closed.