Multiplicação de matriz numpy

Numpy é a Biblioteca de Python, que nos fornece uma ampla gama de métodos para realizar vários cálculos matemáticos em matrizes. Quando se trata da multiplicação de uma matriz, é fácil multiplicar 2 × 2, 3 × 3 ou até 5 × 5. Mas quando excede o tamanho 5 × 5, pode ser uma tarefa difícil e demorada para multiplicá -los manualmente. Mas as funções internas numpy facilitaram a realização de multiplicação em grandes matrizes. A multiplicação da matriz é aquela em que duas matrizes são multiplicadas e fornece uma única matriz como resultado. Existem três métodos fornecidos pela Numpy para multiplicar as matrizes.

Existem três métodos para executar a multiplicação da matriz. Estes são os seguintes:

O produto DOT de matrizes

O produto DOT também é conhecido como produto escalar. Nesse tipo de multiplicação, um valor inteiro constante é multiplicado pela matriz, ou duas matrizes das mesmas dimensões são multiplicadas. Em uma matriz escalar, o tamanho da matriz não importa quando uma constante é multiplicada porque apenas multiplicamos o valor constante por cada valor da matriz.

Sintaxe

A sintaxe a seguir é usada para calcular o produto DOT da matriz:

NP.DOT (constant_value, matriz)

Aqui, dois argumentos são passados ​​primeiro - um é o número constante e o outro é a matriz a ser multiplicada. Mais uma coisa a lembrar é que essa ordem dos argumentos passados ​​não importa. Podemos passar pela matriz primeiro e a segunda pode ser os valores constantes, o mesmo que no caso de multiplicação de matriz.

NP.DOT (Array_A, Array_B)

Aqui, dois argumentos são aprovados: essas são matrizes.

Exemplo 1

Vamos realizar um exemplo para entender profundamente o produto escalar. Neste exemplo, multiplicaremos uma matriz com o valor constante. Primeiro, importe a biblioteca Numpy enquanto usamos a função interna fornecida pela biblioteca Numpy. Em seguida, declaramos uma variável que mantém o valor que deve ser multiplicado pela variável da matriz "Cons_Val" com valor "2" e uma matriz que mantém a matriz 2 × 2 com valores de "3", "6", "5 "E" 2 ".

Depois de declarar nossa variável e matriz constante, declaramos outra variável chamada "resultante_arr" que contém o produto DOT da matriz. Nós passamos pelo NP.Função dot () responsável por calcular o produto DOT com dois argumentos: nossa matriz e o valor constante.

importar numpy como np
Cons_Val = 2
arr = [[3, 6], [5, 2]]
Reslting_arr = np.DOT (Cons_Val, arr)
print ("Array original:", arr)
print ("Produto escalar da Array arr é:", Reslting_arr)

Finalmente, usando a instrução print (), imprimimos ambas. A saída do nosso código é exibida na amostra a seguir após ser executada:

Exemplo 2

No exemplo anterior, multiplicamos o valor constante com uma matriz usando o NP.função dot (). A multiplicação escalar também pode ser realizada em duas matrizes. Vamos realizar este exemplo para entender o funcionamento de produtos DOT em diferentes matrizes. Primeiro, importando nossa biblioteca Numpy com sucesso, declaramos duas matrizes do mesmo tamanho que são: Array_a cujos valores são "3" e "6" e Array_B com valores de "12" e "4". Em seguida, declaramos outra variável à qual atribuímos o NP.função dot () que contém dois argumentos que são nossas matrizes que devem ser multiplicadas. Em seguida, exiba as duas matrizes originais usando as declarações de impressão.

O snippet seguinte é a saída do código que executamos. O produto escalar resultante de nossas matrizes é "60".

Produto matricial de matrizes

O produto Matrix da matriz nos permite multiplicar duas matrizes enquanto fazemos matematicamente. Nesse tipo de multiplicação, pegamos uma linha da primeira matriz e uma coluna do segundo. A linha "R1" da primeira matriz é multiplicada pela coluna "C1" da segunda matriz e depois os adicionamos para obter o produto. Nesse tipo de multiplicação, as linhas da primeira matriz devem ser iguais à coluna da segunda matriz.

Sintaxe

NP.matmul (Array1, Array2)

O matmul () é a função interna fornecida pela biblioteca Numpy para calcular a multiplicação da matriz simplesmente passando por eles as matrizes a serem multiplicadas. Na sintaxe anterior, Array1 e Array2 são as matrizes que multiplicaremos.

Exemplo 1

Para entender o uso da função matmul () mais brevemente, vamos implementar um exemplo. Depois de importarmos com sucesso nossa biblioteca Numpy, declaramos duas matrizes - "ARR_A" e "ARR_B". A matriz FIRT, "ARR_A", contém os valores "3", "6", "5" e "2", enquanto "arr_b" contém "12", "4", "6" e "1". Agora, passando para a próxima etapa em que declaramos outra variável responsável por manter o resultado da multiplicação de matrizes para a variável chamada “Reslting_arr”, passamos a função Matmul () com as matrizes como argumentos. Por fim, imprimimos as matrizes originais e o produto de matrizes que calculamos usando a função matmul ().

importar numpy como np
ARR_A = NP.Array ([[3, 6], [5, 2]])
arr_b = np.Array ([[12, 4], [6, 1]]))
Reslting_arr = np.matmul (arr_a, arr_b)
print ("Matriz original A:", ARR_A)
print ("Matriz original B:", ARR_B)
print ("Matrix Product of Array Arr é:", Reslting_arr)

Como funciona

Nesse caso, Arr_A (0,0) é multiplicado pelo ARR_B (0,0) e adicionado ao produto de ARR_A (0,1) e ARR_B (1,0) para obter o elemento Reslting_arr (0,0) de a matriz resultante. O mesmo é feito para os próximos elementos que se correspondem.

Calculamos com fedelismo o produto de ambas as matrizes, como visto na figura a seguir:

Multiplicação de elemento

Ambas as matrizes devem ter as mesmas dimensões que 2 × 2, 3 × 3 e assim por diante. A multiplicação em termos de elemento é realizada usando a função embutida Numpy que é NP.multiplicar().

Sintaxe

NP.Multiply (Array1, Array2)

Exemplo 1

Para explicar o conceito de multiplicação em termos de elemento, damos um exemplo para obter uma melhor compreensão. Vamos primeiro incluir nossa biblioteca Numpy como NP. Depois disso, inicializamos duas variáveis ​​que contêm a matriz original que vamos multiplicar. Array1 detém os valores "5", "1", "6" e "2", enquanto o Array2 contém os valores "3", "3", "4" e "2". Agora, criamos outra variável que mantém a variedade resultante de multiplicação para a qual passamos as duas matrizes como argumentos para o nosso NP.Multiply () Função responsável por calcular o produto em termos de elemento.

Como funciona

O ARR_A (0,0) é multiplicado pela matriz arr_b (0, 0). Enquanto arr_a (0,1) é multiplicado pelo ARR_B (0,1) e assim por diante. O resultado é armazenado na matriz resultante que declaramos como resultante_arr ao qual atribuímos NP.Multiply () função com dois parâmetros que são nossas matrizes originais.

importar numpy como np
Array1 = np.Array ([[5, 1], [6, 2]]))
Array2 = np.Array ([[3, 3], [4, 2]]))
Array_result = np.Multiply (Array1, Array2)
print ("Array1 original1:", Array1)
Print ("Array2 original2:", Array2)
Print ("Produto de elemento da matriz é:", Array_result)

No final, simplesmente imprimimos as duas matrizes e a matriz resultante usando a instrução print (). Quanto à execução, o snippet a seguir exibe a saída de nosso código:

Conclusão

Neste artigo, discutimos sobre a multiplicação da matriz Numpy usando diferentes funções Numpy. Tentamos o nosso melhor para elaborar os diferentes métodos para calcular o produto de matrizes. Numpy nos permite realizar vários cálculos em matrizes usando os métodos simples internos. Quando se trata de um grande número de multiplicação da matriz, ele pode ser mantido apenas usando as funções explicadas. Não precisamos calculá -los manualmente.