Sabemos que la mayor parte de la aplicación tiene que lidiar con una gran cantidad de conjuntos de datos. Por lo tanto, una función no óptima desde el punto de vista computacional puede convertirse en un gran cuello de botella en su algoritmo y puede dar como resultado un modelo que tarde años en ejecutarse. Para asegurarnos de que el código sea computacionalmente eficiente, utilizaremos la vectorización.
La complejidad del tiempo en la ejecución de cualquier algoritmo es crucial para decidir si una aplicación es confiable o no. Ejecutar un algoritmo grande en el tiempo óptimo posible es muy importante cuando se trata de la aplicación de salida en tiempo real. Para hacerlo, Python tiene algunas funciones matemáticas estándar para operaciones rápidas en conjuntos completos de datos sin tener que escribir bucles. Una de esas bibliotecas que contiene dicha función es numpy . Veamos cómo podemos usar esta función estándar en caso de vectorización.
¿Qué es la Vectorización?
La vectorización se usa para acelerar el código de Python sin usar bucle. El uso de dicha función puede ayudar a minimizar el tiempo de ejecución del código de manera eficiente. Se están realizando varias operaciones sobre vectores, como el producto punto de vectores , que también se conoce como producto escalar, ya que produce productos externos de salida única que dan como resultado una array cuadrada de dimensión igual a la longitud X longitud de los vectores, multiplicación sabia de elementos que produce el elemento de los mismos índices y dimensión de la array permanecen sin cambios.
Veremos como los métodos clásicos consumen más tiempo que usar alguna función estándar calculando su tiempo de procesamiento.
exterior(a, b): Calcula el producto exterior de dos vectores.
multiplicar(a, b): Producto matricial de dos arreglos.
dot(a, b): Producto escalar de dos arrays.
zeros((n, m)): Devuelve una array de forma y tipo determinados, llena de ceros.
process_time(): Devuelve el valor (en fracciones de segundo) de la suma del tiempo de CPU del sistema y del usuario del proceso actual. No incluye el tiempo transcurrido durante el sueño.
Producto punto: El
producto punto es una operación algebraica en la que dos vectores de igual longitud se multiplican de modo que se produce un solo número. Producto escalar a menudo llamado producto interno . Este producto da como resultado un número escalar. Consideremos dos arrays a y b de la misma longitud, el producto punto se realiza tomando la transposición de la primera array y luego se sigue la multiplicación matemática de arrays de a’ (transposición de a) y b como se muestra en la figura a continuación.
Representación pictórica del producto escalar –
A continuación se muestra el código de Python:
# Dot product
import time
import numpy
import array
# 8 bytes size int
a = array.array('q')
for i in range(100000):
a.append(i);
b = array.array('q')
for i in range(100000, 200000):
b.append(i)
# classic dot product of vectors implementation
tic = time.process_time()
dot = 0.0;
for i in range(len(a)):
dot += a[i] * b[i]
toc = time.process_time()
print("dot_product = "+ str(dot));
print("Computation time = " + str(1000*(toc - tic )) + "ms")
n_tic = time.process_time()
n_dot_product = numpy.dot(a, b)
n_toc = time.process_time()
print("\nn_dot_product = "+str(n_dot_product))
print("Computation time = "+str(1000*(n_toc - n_tic ))+"ms")
Producción:
dot_product = 833323333350000.0 Computation time = 35.59449199999999ms n_dot_product = 833323333350000 Computation time = 0.1559900000000225ms
Producto exterior:
el producto tensorial de dos vectores de coordenadas se denomina producto exterior . Consideremos dos vectores a y b con dimensión n x 1y m x 1luego el producto exterior del vector da como resultado una array rectangular de n x m. Si dos vectores tienen la misma dimensión, la array resultante será una array cuadrada como se muestra en la figura.
Representación pictórica del producto exterior –
A continuación se muestra el código de Python:
# Outer product
import time
import numpy
import array
a = array.array('i')
for i in range(200):
a.append(i);
b = array.array('i')
for i in range(200, 400):
b.append(i)
# classic outer product of vectors implementation
tic = time.process_time()
outer_product = numpy.zeros((200, 200))
for i in range(len(a)):
for j in range(len(b)):
outer_product[i][j]= a[i]*b[j]
toc = time.process_time()
print("outer_product = "+ str(outer_product));
print("Computation time = "+str(1000*(toc - tic ))+"ms")
n_tic = time.process_time()
outer_product = numpy.outer(a, b)
n_toc = time.process_time()
print("outer_product = "+str(outer_product));
print("\nComputation time = "+str(1000*(n_toc - n_tic ))+"ms")
Producción:
outer_product = [[ 0. 0. 0. ..., 0. 0. 0.] [ 200. 201. 202. ..., 397. 398. 399.] [ 400. 402. 404. ..., 794. 796. 798.] ..., [ 39400. 39597. 39794. ..., 78209. 78406. 78603.] [ 39600. 39798. 39996. ..., 78606. 78804. 79002.] [ 39800. 39999. 40198. ..., 79003. 79202. 79401.]] Computation time = 39.821617ms outer_product = [[ 0 0 0 ..., 0 0 0] [ 200 201 202 ..., 397 398 399] [ 400 402 404 ..., 794 796 798] ..., [39400 39597 39794 ..., 78209 78406 78603] [39600 39798 39996 ..., 78606 78804 79002] [39800 39999 40198 ..., 79003 79202 79401]] Computation time = 0.2809480000000031ms
Producto
por elementos: La multiplicación por elementos de dos arrays es la operación algebraica en la que cada elemento de la primera array se multiplica por su elemento correspondiente en la array posterior. La dimensión de las arrays debe ser la misma.
Considere dos arrays a y b , el índice de un elemento en a es i y j , luego a (i, j) se multiplica con b (i, j) respectivamente, como se muestra en la figura a continuación.
Representación pictórica del producto inteligente Element –
A continuación se muestra el código de Python:
# Element-wise multiplication
import time
import numpy
import array
a = array.array('i')
for i in range(50000):
a.append(i);
b = array.array('i')
for i in range(50000, 100000):
b.append(i)
# classic element wise product of vectors implementation
vector = numpy.zeros((50000))
tic = time.process_time()
for i in range(len(a)):
vector[i]= a[i]*b[i]
toc = time.process_time()
print("Element wise Product = "+ str(vector));
print("\nComputation time = "+str(1000*(toc - tic ))+"ms")
n_tic = time.process_time()
vector = numpy.multiply(a, b)
n_toc = time.process_time()
print("Element wise Product = "+str(vector));
print("\nComputation time = "+str(1000*(n_toc - n_tic ))+"ms")
Producción:
Element wise Product = [ 0.00000000e+00 5.00010000e+04 1.00004000e+05 ..., 4.99955001e+09 4.99970000e+09 4.99985000e+09] Computation time = 23.516678000000013ms Element wise Product = [ 0 50001 100004 ..., 704582713 704732708 704882705] Computation time = 0.2250640000000248ms