Numpy Broadcasting

Matrizes de tamanho diferente não podem ser adicionadas, subtraídas ou usadas em aritmética. Duplicar a matriz de pequeno para dar as mesmas dimensões e tamanho que a matriz maior é uma abordagem. Ao conduzir a aritmética da matriz, Numpy oferece um recurso conhecido como transmissão de array que pode diminuir significativamente e simplificar seu código. Você aprenderá sobre a ideia de transmissão de matriz e como usá -la em Numpy neste tutorial. Além disso, vários programas de exemplo são fornecidos.

O que é transmissão Numpy?

Ao executar operações aritméticas em matrizes de diferentes formas, Numpy se refere a isso como transmissão. Essas operações de matriz são frequentemente realizadas nos respectivos elementos. Se duas matrizes tiverem a mesma forma, isso pode ser feito com facilidade. Embora esse conceito seja útil, a transmissão nem sempre é recomendada porque pode resultar em uso ineficiente da memória que diminui o cálculo. Operações numpy são frequentemente realizadas em pares de matrizes que são quebrados elemento por elemento.

Regras de transmissão

Um conjunto específico de diretrizes deve ser seguido ao transmitir. Estes são descritos abaixo:

1. A forma de matriz de classificação mais baixa é importante para ser presa com 1s até que ambas as formas das matrizes compartilhem o mesmo comprimento se duas matrizes não estiverem com a mesma classificação.
2. Duas matrizes são consideradas compatíveis se tiverem o mesmo tamanho de dimensão ou se uma delas tiver o tamanho da dimensão definido como 1.
3. As matrizes só podem ser transmitidas juntas se seus tamanhos e dimensões correspondem.
4. Depois que a transmissão está concluída, cada matriz age como se sua forma corresponda à do maior elemento nas formas das duas matrizes de entrada.
5. Uma das matrizes se comporta como se fosse replicada com essa dimensão se a outra matriz tiver uma dimensão maior que 1 e a primeira matriz tem uma dimensão de 1.

Agora, vamos discutir alguns exemplos de implementação do conceito de transmissão.

Exemplo 1:

Em pares de matrizes, as operações numpy geralmente são realizadas elemento a elemento. As duas matrizes devem, no cenário mais direto, ter a mesma forma, como no exemplo abaixo:

importar numpy
One_arr = Numpy.Array ([2.0, 3.0, 1.0])
dois_arr = Numpy.Array ([3.0, 3.0, 3.0])
Imprima (One_arr * dois_arr)

Como você pode ver no código acima, temos duas matrizes: 'One_arr' e 'Two_ Arr'. Cada um dos quais tem um conjunto separado de valores. Os valores em 'One_arr' são [2.0,3.0,1.0] e 'dois _arr' são [3.0,3.0,3.0]. Você pode ver que o resultado do calcular o produto dessas duas matrizes é o seguinte:

Quando certos requisitos são atendidos pelos formulários das matrizes, a regra de transmissão de Numpy reduz essa restrição. Quando uma matriz e um valor escalar são unidos em uma operação, a transmissão é demonstrada em sua forma mais básica. Como você pode ver, 3 está contido na variável denominada 'Two_arr.'

importar numpy
One_arr = Numpy.Array ([2.0, 3.0, 1.0])
dois_arr = 3.0
Imprima (One_arr * dois_arr)

O código acima produz o seguinte resultado.

No exemplo anterior, onde 'Two_arr' foi uma matriz, o resultado é equivalente. Podemos imaginar o escalar 'dois_arr' sendo expandido durante o processo aritmético para uma matriz com a mesma forma que 'um _arr.'The Array' Two_arr 'contém novos elementos que são apenas duplicados do primeiro escalar. A comparação de alongamento é apenas hipotética. Para tornar as operações de transmissão como memória e computacionalmente econômicas como viáveis, Numpy é inteligente o suficiente para usar o valor escalar original, em vez de produzir cópias.

Exemplo 2:

Aqui está outro programa Python simples que executa a transmissão. Mais uma vez, duas matrizes são criadas contendo valores diferentes. É necessário remodelar 'First_arr' em um vetor de coluna com uma forma 3 × 1 para calcular um produto externo. Depois disso, a transmissão é realizada contra 'Second_arr' para fornecer o resultado do tamanho 3 × 2, conhecido como o produto externo de 'First_arr' e 'Second_arr.'A transmissão para 2 × 3 é possível, pois' resultado_arr 'tem a forma 2 × 3 e a forma (3).

Depois de seguir todas as etapas acima mencionadas, um vetor deve ser incluído em todas as colunas das matrizes que são 'resultado_arr' e 'Second_arr.'Estes têm dimensões de 2 × 3 e (2). A transposição 'resultado_arr' produzirá uma forma de 3 × 2, que pode ser transmitida contra 'Second_arr' para obter a mesma forma. Normalmente, a transposição isso produz um produto final na forma 2 × 3.

importar numpy
primeiro_arr = Numpy.Array ([12, 24, 14])
Second_arr = Numpy.Array ([15, 22])
Imprimir (Numpy.Reshape (First_arr, (3, 1)) * Second_arr)
resultado_arr = Numpy.Array ([[12, 22, 31], [15, 22, 45]]))
print (resultado_arr + primeiro_arr)
print ((resultado_arr.T + Second_arr).T)
Imprimir (Result_arr + Numpy.Reshape (Second_arr, (2, 1))))
Imprimir (resultado_arr * 2)

Você pode ver a saída abaixo.

Exemplo 3:

Uma matriz tridimensional pode ser transmitida usando o seguinte programa Python. Neste exemplo, duas matrizes chamadas 'First_arr' e 'Second_arr' foram geradas. A matriz 'First_arr' contém [4,13,26,12] e 'Second_arr' contém [32,67,45,17] valores. As 2 dimensões da matriz inicial fazem a diferença. A soma da primeira e segunda matriz será mostrada abaixo após a execução do código. Você pode ver que temos três declarações de impressão no código, cada uma das quais exibe o texto 'Primeira matriz:', 'Second Array' e 'Terceira Array:' Por sua vez. A soma dessas duas matrizes recém -geradas é então mostrada.

importar numpy
primeiro_arr = Numpy.Array ([[4, 13, 26, 12], [32, 67, 45, 17]]))
Second_arr = Numpy.Array ([24,45,66,87])
print ("\ n Primeira matriz:")
Print (First_arr)
print ("\ n Segunda Array:")
print (Second_arr)
print ("\ nsum de primeira e segunda matriz:")
Sum_Result = First_arr + Second_arr;
Imprimir (Sum_Result)

Aqui está a captura de tela de saída do código fornecido.

Exemplo 4:

O último programa Python que transmite uma matriz tridimensional é dada aqui. Duas matrizes são especificadas neste programa, a primeira das quais tem três dimensões. A soma da primeira e segunda matriz será mostrada como mostrado acima depois que o código foi executado. Embora os valores nessas matrizes variem, o código restante é o mesmo usado no programa de exemplo acima.

importar numpy
primeiro_arr = Numpy.Array ([[12, 45, 22, 13], [22, 54, 25, 12], [50, 40, 18, 26]]))
Second_arr = Numpy.Array ([12,44,22,12])
print ("\ n Primeira matriz:")
Print (First_arr)
print ("\ n Segunda Array:")
print (Second_arr)
print ("\ nsum de primeira e segunda matriz:")
Sum_Result = First_arr + Second_arr;
Imprimir (Sum_Result)

Você pode ver na figura abaixo que uma matriz tridimensional da primeira matriz é apresentada, seguida de uma matriz bidimensional da segunda matriz e o resultado desses dois empregando o princípio de transmissão.

Conclusão

Este artigo discutiu a transmissão, um conceito crucial de Python. Em Numpy, o termo 'transmissão' refere -se à capacidade de lidar com matrizes de várias formas enquanto realizam operações aritméticas que são frequentemente realizadas. O sujeito mencionado foi completamente coberto com uma variedade de exemplos. Este artigo usou os programas de exemplo mencionados para demonstrar como transmitir em matrizes 1-D, 2-D e 3D, respectivamente. Você pode tentar executar esses exemplos em seu sistema e ver os resultados para compreender melhor como tudo funciona em geral.