Python | Transmitiendo con NumPy Arrays

El término transmisión se refiere a cómo numpy trata las arrays con diferentes dimensiones durante las operaciones aritméticas que conducen a ciertas restricciones, la array más pequeña se transmite a través de la array más grande para que tengan formas compatibles. 
La transmisión proporciona un medio para vectorizar operaciones de array para que el bucle se produzca en C en lugar de Python, como sabemos que Numpy implementó en C. Lo hace sin hacer copias innecesarias de datos y lo que conduce a implementaciones de algoritmos eficientes. Hay casos en los que la transmisión es una mala idea porque conduce a un uso ineficiente de la memoria que ralentiza el cálculo.
Ejemplo – 
 

import numpy as np
 
a = np.array([5, 7, 3, 1])
b = np.array([90, 50, 0, 30])
 
# array are compatible because of same Dimension
c = a * b
print (c)

Ejemplo para obtener una comprensión más profunda: 
supongamos que tenemos un gran conjunto de datos, cada dato es una lista de parámetros. En Numpy tenemos una array 2-D, donde cada fila es un dato y el número de filas es el tamaño del conjunto de datos. Supongamos que queremos aplicar algún tipo de escala a todos estos datos, cada parámetro obtiene su propio factor de escala o digamos Cada parámetro se multiplica por algún factor.
Solo para tener una comprensión clara, contemos las calorías de los alimentos usando un desglose de macronutrientes. En términos generales, las partes calóricas de los alimentos están compuestas de grasas (9 calorías por gramo), proteína (4 cpg) y carbohidratos (4 cpg). Entonces, si enumeramos algunos alimentos (nuestros datos), y para cada alimento enumeramos su desglose de macronutrientes (parámetros), podemos multiplicar cada nutriente por su valor calórico (aplicar escala) para calcular el desglose calórico de cada alimento. 
 

Con esta transformación, ahora podemos calcular todo tipo de información útil. Por ejemplo, cuál es el número total de calorías presentes en algún alimento o, dado un desglose de mi cena, saber cuántas calorías obtuve de las proteínas, etc.
Veamos una forma ingenua de producir este cálculo con Numpy: 
 

macros = array([
  [0.8, 2.9, 3.9],
  [52.4, 23.6, 36.5],
  [55.2, 31.7, 23.9],
  [14.4, 11, 4.9]
   ])
 
# Create a new array filled with zeros,
# of the same shape as macros.
result = zeros_like(macros)
 
cal_per_macro = array([3, 3, 8])
 
# Now multiply each row of macros by
# cal_per_macro. In Numpy, `*` is
# element-wise multiplication between two arrays.
 for i in range(macros.shape[0]):
     result[i, :] = macros[i, :] * cal_per_macro
 
result

producción: 
 

array([[   2.4,    8.7,   31.2 ],
       [  157.2,   70.8,  292 ],
       [   165.6,  95.1,   191.2],
       [   43.2,   33,    39.2]])

Algoritmo:

Entradas: array A con m dimensiones y array B con n dimensiones 
 

p = max(m, n)
if m < p:
    left-pad A's shape with 1s until it also has p dimensions

else if n < p:
    left-pad B's shape with 1s until it also has p dimensions
result_dims = new list with p elements

for i in p-1 ... 0:
    A_dim_i = A.shape[i]
    B_dim_i = B.shape[i]
    if A_dim_i != 1 and B_dim_i != 1 and A_dim_i != B_dim_i:
        raise ValueError("could not broadcast")
    else:
        # Pick the Array which is having maximum Dimension
        result_dims[i] = max(A_dim_i, B_dim_i) 

Reglas de transmisión: 
la transmisión de dos arreglos juntos sigue estas reglas:
 

1. Si las arrays no tienen el mismo rango, anteponga 1 a la forma de la array de rango inferior hasta que ambas formas tengan la misma longitud.
2. Las dos arrays son compatibles en una dimensión si tienen el mismo tamaño en la dimensión o si una de las arrays tiene el tamaño 1 en esa dimensión.
3. Las arrays se pueden transmitir juntas si son compatibles con todas las dimensiones.
4. Después de la transmisión, cada array se comporta como si tuviera una forma igual al máximo de formas de elementos de las dos arrays de entrada.
5. En cualquier dimensión en la que una array tenga un tamaño de 1 y la otra array tenga un tamaño superior a 1, la primera array se comporta como si se hubiera copiado a lo largo de esa dimensión.

  
Ejemplo n.º 1: array de una sola dimensión 
 

import numpy as np
a = np.array([17, 11, 19]) # 1x3 Dimension array
print(a)
b = 3 
print(b)
 
# Broadcasting happened because of
# miss match in array Dimension.
c = a + b
print(c)

Producción: 
 

[17 11 19]
3
[20 14 22]

Ejemplo 2: array bidimensional 
 

import numpy as np
A = np.array([[11, 22, 33], [10, 20, 30]])
print(A)
 
b = 4
print(b)
 
C = A + b
print(C)

Producción: 
 

[[11 22 33]
 [10 20 30]]
 4
[[15 26 37]
 [14 24 34]]

Ejemplo 3: 
 

import numpy as np
 
v = np.array([12, 24, 36]) 
w = np.array([45, 55])   
 
# To compute an outer product we first
# reshape v to a column vector of shape 3x1
# then broadcast it against w to yield an output
# of shape 3x2 which is the outer product of v and w
print(np.reshape(v, (3, 1)) * w)
 
x = np.array([[12, 22, 33], [45, 55, 66]])
 
# x has shape  2x3 and v has shape (3, )
# so they broadcast to 2x3,
print(x + v)
 
# Add a vector to each column of a matrix X has
# shape 2x3 and w has shape (2, ) If we transpose X
# then it has shape 3x2 and can be broadcast against w
# to yield a result of shape 3x2.
 
# Transposing this yields the final result
# of shape  2x3 which is the matrix.
print((x.T + w).T)
 
# Another solution is to reshape w to be a column
# vector of shape 2X1 we can then broadcast it
# directly against X to produce the same output.
print(x + np.reshape(w, (2, 1)))
 
# Multiply a matrix by a constant, X has shape  2x3.
# Numpy treats scalars as arrays of shape();
# these can be broadcast together to shape 2x3.
print(x * 2)

Producción: 
 

[[ 4  5]
 [ 8 10]
 [12 15]]

[[2 4 6]
 [5 7 9]]

[[ 5  6  7]
 [ 9 10 11]]

[[ 5  6  7]
 [ 9 10 11]]

[[ 2  4  6]
 [ 8 10 12]]

Trazado de una función bidimensional: la
transmisión también se usa con frecuencia para mostrar imágenes basadas en funciones bidimensionales. Si queremos definir una función z=f(x, y).
Ejemplo: 
 

import numpy as np
import matplotlib.pyplot as plt
 
# Computes x and y coordinates for
# points on sine and cosine curves
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
 
# Plot the points using matplotlib
plt.plot(x, y_sin)
plt.plot(x, y_cos)
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('Sine and Cosine')
plt.legend(['Sine', 'Cosine'])
 
plt.show()

Producción: