Scipy Convolve

O conceito básico de convolução é combinar dois sinais usando alguma função matemática para fazer o terceiro sinal. É a técnica de processamento de sinal digital mais comumente usado. A convolução de dois sinais é considerada a integral de um sinal de que se encaixa em outro sinal. Isso é feito enquanto se multiplica com o produto escalar em cada ponto de vetores que estão sobrepostos.

O mesmo conceito de convolução é usado em python. A matriz é considerada um sinal usado na função Scipy Convolve para executar a convolução por várias matrizes unidimensionais. O Scipy Convolve é uma matriz n-dimensional. Geralmente são duas ou mais sequências 1-D. Neste artigo, discutiremos a função Scipy Compolve em detalhes e tentaremos aprender o uso da função complicada com a ajuda de exemplos.

Uso de convolução do Scipy e sua sintaxe

O convolveio ccepy é usado para cometer duas matrizes n-dimensionais. Aqui está a sintaxe da função Scipy Convolve:

# Scipy.sinal.comvolve (inp1, inp2, modo = 'completo', método = 'auto')

O 'inp1' é a primeira matriz de entrada, 'inp2' é a segunda matriz de entrada e deve ter o mesmo número de dimensões que o parâmetro 'inp1'. O parâmetro 'modo' é um parâmetro de string que determina o tamanho da saída; é definido por três opções, iguais, válidas ou completas. É um parâmetro opcional.

O modo 'completo' indica que a convolução linear discreta completa das entradas deve ser fornecida e é o modo padrão; Se nenhum modo for fornecido, o modo 'completo' é considerado como padrão. O modo "mesmo" retorna a saída do tamanho do parâmetro "inp1", centralizado de acordo com a saída "completa".

O último modo, também um modo "válido", retorna itens que não confiam apenas no acalmar zero. O parâmetro 'método' é outro parâmetro opcional. É um parâmetro de string que indica qual método deve ser usado para convolução. Também é preciso um dos três argumentos; automático, fft e direto. O 'FFT' é a transformação de Fourier, usada para executar a convolução chamando a função FFTCOLVE integrada.

O argumento 'direto' representa a convolução direta que é a definição básica de convolução. E, finalmente, o argumento 'automático' é fornecido onde é necessária a seleção automática do argumento 'direto' ou 'fft', o que for mais rápido. O argumento 'Auto' é o padrão; Se nada for fornecido, 'Auto' é considerado o argumento padrão.

A saída da função convolve será o subconjunto de convolução linear discreta de INP1 com INP2. Vamos ver os exemplos abaixo para entender como implementar o Scipy Compolve.

Exemplo 1:

Este é o primeiro exemplo deste artigo que ajudará a esclarecer os pensamentos sobre as informações teóricas que mencionamos acima.

Neste exemplo, planejaremos um pulso suave em forma quadrada usando uma janela Hann. O código do programa usa uma matriz NP (indicada como SIG_ONE) para plotar a curva e sinal.Convolve () é usado para cometer os sinais.

Veja o código completo anexado abaixo. Aqui, importamos as bibliotecas necessárias primeiro e declaramos a matriz. Depois de chamar a função de convolução, plotamos o pulso. No restante do código, você pode ver que definimos as margens e exibimos a resposta de impulso original e filtrada e o sinal filtrado no gráfico.

do sinal de importação ccepy
importar numpy como p
importar matplotlib.Pyplot como MTP
sig_one = p.Repita ([1., 0., 1.], 100)
window_one = sinal.janelas.Hann (65)
filtred_res = sinal.Convolve (sig_one, window_one, modo = 'mesmo') / sum (window_one)
Figura_One, (Axis_orig, Axis_win, Axis_filt) = MTP.subtramas (3, 1, sharex = true)
AXIS_ORIG.plot (sig_one)
AXIS_ORIG.set_title ('aqui está o pulso original')
AXIS_ORIG.margens (0, 0.1)
AXIS_WIN.plot (window_one)
AXIS_WIN.set_title ('Aqui está a resposta do impulso do filtro')
AXIS_WIN.margens (0, 0.1)
AXIS_FILT.plot (filtrado_res)
AXIS_FILT.set_title ('Aqui está o sinal filtrado')
AXIS_FILT.margens (0, 0.1)
figura_One.Fight_Layout ()
figura_One.mostrar()

Observe que o código é executado no Google Collab. O Google Collaboratory é uma ferramenta de código aberto usado para implementar códigos Python. É uma ferramenta gratuita e facilmente acessível através do Google ou de qualquer outro navegador.

Depois de executar o código, você poderá ver as ondas. Consulte a imagem anexada abaixo.

Exemplo 2:

Este é o segundo exemplo deste artigo e aqui usaremos o método ndimage para demonstrar a funcionalidade da função de convolução.

Neste exemplo, o parâmetro 'modo' do ndimage leva um dos cinco argumentos; envolver, espelho, mais próximo, constante e refletir. O argumento 'refletir' representa a metade da amostra simétrica estendida relembrando a borda. A 'constante' é usada para representar todos os valores que estão além da borda, mas com o mesmo valor constante.

O 'mais próximo' representa um valor específico que é estendido pela replicação do pixel final. O 'Mirror' representa o centro do último pixel, e o argumento 'Wrap' representa o envolvimento na borda oposta. Veja o código fornecido abaixo:

De Importar Scipy ndimage
importar numpy como p
One_arr = p.Array ([[1, 0, 2],
[1, 1, 0],
[1, 0, 0]])
dois_arr = p.Array ([[0, 1, 0],
[1, 1, 0],
[0, 1, 0],
[0, 1, 1],
[0, 1, 0]])
Imprimir (ndimage.compvolve (One_arr, dois_arr, mode = 'mais próximo'))

Aqui está a saída do código acima, que é a matriz complicada como você pode ver.

Exemplo 3:

O exemplo a seguir demonstrará uma função 2D de convolução. As duas matrizes bidimensionais são cometidas usando a função Convolve2D. O CONCOLVE2D usa dois parâmetros opcionais extras 'FillValue' e 'Boundy'.

O parâmetro 'limite' leva um dos três argumentos; preencher, envolver e symm. O argumento 'preenchimento' é o valor padrão e as matrizes de entrada do PAD com FillValue. O argumento 'Wrap' representa as condições de contorno circulares. O argumento 'SyMM' representa as condições de contorno simétricas.

O 'FillValue' é representado por um valor escalar que é usado para preencher a matriz de entrada da almofada, e seu valor padrão é 0. No código anexado, calcularemos o gradiente de uma imagem.

do sinal de importação ccepy
De Scipy Import Misc
importar numpy como p
importar matplotlib.Pyplot como mtb
Ascent_One = Misc.subida()
SCHARR_ONE = p.Array ([[-3-3J, 0-10J, +3 -3j],
[-6 +0J, 1+ 0J, +6 +0J],
[-2 +2j, 0 +6j, +3 +2j]])
grad_one = sinal.CONCOLVE2D (ASCENT_ONE, SCHARR_ONE, LIMADE = 'SYMM', MODE = 'MESMO')
fig_one, (axis_orig, axis_mag, axis_ang) = mtb.subparcelas (3, 1, figSize = (7, 16))
AXIS_ORIG.imshow (ascent_one, cmap = 'cinza')
AXIS_ORIG.set_title ('original')
AXIS_ORIG.set_axis_off ()
AXIS_MAG.imshow (p.absoluto (grad_one), cmap = 'cinza')
AXIS_MAG.set_title ('Resultado da magnitude do gradiente')
AXIS_MAG.set_axis_off ()
Axis_ang.imshow (p.ângulo (grad_one), cmap = 'hsv')
Axis_ang.set_title ('resultado de orientação para gradiente')
Axis_ang.set_axis_off ()
fig_one.mostrar()

Aqui está a saída do código acima dado:

Conclusão

Neste artigo, aprendemos a função Scipy Compolve com a ajuda de exemplos. Primeiro, discutimos o conceito básico de função de convolução e, em seguida, aprendemos sobre a sintaxe da função complicada e, posteriormente, examinamos três exemplos diferentes para ver o uso da função Scipy Convolve de uma maneira muito diferente.