A multiplicación de matrices é unha operación fundamental en álxebra lineal.
Polo xeral usámolo en numerosas aplicacións, como procesamento de imaxes, aprendizaxe automática e moitas máis. NumPy é un paquete Python notable para a informática científica.
Non obstante, nesta publicación, analizaremos varios métodos para facer a multiplicación de matrices en Python sen utilizar NumPy.
Utilizaremos lazos aniñados, a función map() integrada e a comprensión de listas.
Ademais, analizaremos os beneficios e inconvenientes de cada estratexia, así como cando aplicar cada unha delas. Se es novo na álxebra lineal e queres aprender máis sobre a multiplicación matricial; segue lendo.
Onde usamos a multiplicación matricial?
Utilízase a multiplicación matricial gráficos informáticos para alterar as imaxes 2D e 3D. Por exemplo, pode xirar, escalar e traducir obxectos na pantalla. As matrices úsanse no procesamento de imaxes para representar imaxes como matrices de píxeles. Ademais, pódense usar matrices para realizar operacións como o filtrado de imaxes.
Tamén facemos uso de matrices en aprendizaxe de máquina. Poden axudarnos a representar os datos e os parámetros do modelo. Podemos realizar numerosas operacións, como o cálculo de produtos puntuais e produtos de vectores matriz.
Seguramente, esta operación tamén é moi vantaxosa nas operacións científicas. Podemos usalo en física e enxeñería para describir magnitudes físicas. Polo tanto, podemos operar con vectores e tensores.
Por que non podemos escoller usar NumPy?
Mentres que NumPy é un Biblioteca Python, non sempre é a opción ideal para a multiplicación matricial. É posible que non optemos por usar NumPy por razóns como o tamaño e a dependencia, a aprendizaxe e os sistemas legados.
Usar as funcións integradas de Python ou desenvolver código personalizado pode ser máis eficiente nalgúns casos. Non obstante, é fundamental ter en conta que NumPy é unha biblioteca forte. Ademais, tamén podes usalo para a multiplicación matricial.
Agora, vexamos como podemos conseguir a multiplicación matricial sen NumPy.
Método de bucles anidados
A técnica de bucles aniñados usa bucles anidados para executar a multiplicación de matrices en Python. A función itera sobre cada elemento da matriz. E, multiplícaos mediante unha serie de bucles aniñados. A función devolve o resultado, que se almacena nunha nova matriz.
Este enfoque é sinxelo de comprender. Non obstante, pode non ser tan eficiente como outras formas, especialmente para matrices máis grandes. Non obstante, é unha opción marabillosa para ti se es novo na álxebra lineal.
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# Establece a matriz de resultados en ceros.
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
Imos ter un exemplo de como facelo. Podes engadir estas liñas de código a continuación para probar este exemplo.
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
Beneficios:
- Doado de comprender.
- Ideal para novatos ou para aqueles que buscan unha comprensión máis profunda da multiplicación matricial.
desvantaxes:
- Non tan eficaces como as técnicas alternativas, especialmente para matrices máis grandes.
- Non é tan lexible como os enfoques alternativos.
método de función map().
O método da función map() proporciona un enfoque alternativo para facer a multiplicación matricial en Python. Neste enfoque, usamos a función map() integrada. Por iso, utilizamos unha ferramenta de programación funcional que aplica unha función proporcionada a cada elemento iterable (lista, tupla, etc.). Ademais, a función map() acepta dous parámetros, unha función e un iterable. E, devolve un iterador que aplica a función a cada elemento iterable.
Neste enfoque, pasamos por cada membro da matriz e facemos a multiplicación usando a función aniñada map().
A función zip() úsase para iterar a través de cada elemento das matrices en paralelo.
Finalmente, a función sum() úsase para sumar os resultados.
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
Agora, de novo, podemos probar o noso código cun exemplo.
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
vantaxes
- Máis eficaz que o enfoque de bucles apilados
- Usa programación funcional para simplificar o código.
Desvantaxes
- Algunhas persoas que non están familiarizadas coa programación funcional poden considerala menos lexible.
- É menos comprensible que a técnica de bucles aniñados.
Método de comprensión de listas
A comprensión de listas permítelle xerar unha nova lista nunha única liña de código. Polo tanto, isto é aplicando unha expresión a cada membro dunha lista existente.
Neste enfoque, a multiplicación realízase iterando repetidamente cada membro da matriz. Estamos a usar a comprensión de listas en capas.
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
Beneficios
- En comparación co método da función map(), é máis curto e lexible.
Desvantaxes
- Pode ser menos eficaz que usar a función map(), especialmente para matrices grandes.
- É máis difícil que o enfoque de bucles aniñados.
Conclusión
Nesta publicación, analizamos alternativas ao uso de NumPy ao multiplicar matrices en Python. Realizamos a multiplicación de matrices en bucles aniñados, a función map() integrada e a comprensión de listas.
A mellor estratexia dependerá das necesidades particulares do teu proxecto.
Cada unha das estratexias ten pros e contras. Para asegurarse de que a función funciona correctamente, é unha boa idea engadir algúns casos de proba con varias dimensións e valores da matriz.
Tamén debería incluír algunhas probas de rendemento para comparar o ben que se executan estes métodos.
Deixe unha resposta