Porquê infligir preenchimento a matrizes com NumPy

Imagem por foto gratuito

Digamos que você esteja trabalhando com dados de imagem. Frequentemente, ao infligir filtros ou executar operações de convolução, as bordas da imagem podem ser problemáticas porque não há pixels vizinhos suficientes para infligir as operações de forma consistente. Preencher a imagem (adicionando linhas e colunas de pixels ao volta da imagem original) garante que cada pixel seja tratado também, o que resulta em uma saída mais precisa e visualmente deleitável.

Você pode estar se perguntando se o preenchimento é restringido ao processamento de imagens. A resposta é Não. No estágio profundo, o preenchimento é crucial ao trabalhar com redes neurais convolucionais (CNNs). Ele permite que você mantenha as dimensões espaciais dos seus dados por meio de camadas sucessivas da rede, evitando que os dados encolham a cada operação. Isso é mormente importante ao preservar os recursos e a estrutura originais dos seus dados de ingresso.

Na estudo de séries temporais, o padding pode ajudar a alinhar sequências de diferentes comprimentos. Esse alinhamento é necessário para nutrir dados em modelos de machine learning, onde a consistência no tamanho da ingresso é frequentemente necessária.

Neste cláusula, você aprenderá uma vez que infligir preenchimento a matrizes com o NumPy, muito uma vez que os diferentes tipos de preenchimento e as melhores práticas ao usar o NumPy para preencher matrizes.

teclado numérico

O Sua visita nos ajuda a continuar oferecendo o melhor para você! target="_blank" rel="nofollow noopener">teclado numérico function é a instrumento de referência no NumPy para aditar preenchimento a arrays. A sintaxe desta função é mostrada inferior:

numpy.pad(matriz, largura_do_pad, modo=”permanente”, **kwargs)

Onde:

• variedade: A matriz de ingresso à qual você deseja aditar preenchimento.
• largura_pad: Leste é o número de valores preenchidos nas bordas de cada eixo. Ele especifica o número de elementos a serem adicionados a cada extremidade dos eixos do array. Pode ser um único inteiro (mesmo preenchimento para todos os eixos), uma tupla de dois inteiros (preenchimento dissemelhante para cada extremidade do eixo) ou uma sequência dessas tuplas para eixos diferentes.
• modo: Leste é o método usado para padding, ele determina o tipo de padding a ser aplicado. Modos comuns incluem: zero, edge, symmetric, etc.
• kwargs: Estes são argumentos de palavras-chave adicionais dependendo do modo.

Vamos examinar um exemplo de array e ver uma vez que podemos aditar padding a ele usando NumPy. Para simplificar, vamos focar em um tipo de padding: padding zero, que é o mais geral e direto.

Lanço 1: Criando o Array

Primeiro, vamos gerar uma matriz 2D simples para trabalhar:

import numpy as np
# Create a 2D array
array = np.array([[1, 2], [3, 4]])
print("Original Array:")
print(array)

Saída:

Original Array:
[[1 2]
 [3 4]]

Lanço 2: Aditar preenchimento zero

Em seguida, adicionaremos preenchimento zero a esta matriz. Usamos o np.pad função para conseguir isso. Especificaremos uma largura de preenchimento de 1, adicionando uma risca/poste de zeros ao volta de todo o array.

# Add zero padding
padded_array = np.pad(array, pad_width=1, mode="constant", constant_values=0)
print("Padded Array with Zero Padding:")
print(padded_array)

Saída:

Padded Array with Zero Padding:
[[0 0 0 0]
 [0 1 2 0]
 [0 3 4 0]
 [0 0 0 0]]

Explicação

• Matriz original: Nossa matriz inicial é uma matriz 2×2 simples com valores [[1, 2], [3, 4]].
• Preenchimento Zero: Ao usar np.padadicionamos uma classe de zeros ao volta do array original. O pad_width=1 argumento especifica que uma risca/poste de preenchimento é adicionada em cada lado. O mode="constant" argumento indica que o preenchimento deve ser um valor permanente, que definimos uma vez que zero com constant_values=0.

Tipos de preenchimento

Existem diferentes tipos de preenchimento, preenchimento zero, que foi usado no exemplo supra, é um deles; outros exemplos incluem preenchimento permanente, preenchimento de borda, preenchimento de reflexão e preenchimento simétrico. Vamos discutir esses tipos de preenchimento em detalhes e ver uma vez que usá-los

Preenchimento Zero

Preenchimento com zeros é o método mais simples e comumente usado para aditar valores extras às bordas de um array. Essa técnica envolve preencher o array com zeros, o que pode ser muito útil em várias aplicações, uma vez que processamento de imagens.

O preenchimento com zeros envolve aditar linhas e colunas preenchidas com zeros às bordas do seu array. Isso ajuda a manter o tamanho dos dados enquanto executa operações que poderiam encolhê-los.

Exemplo:

import numpy as np
array = np.array([[1, 2], [3, 4]])
padded_array = np.pad(array, pad_width=1, mode="constant", constant_values=0)
print(padded_array)

Saída:

[[0 0 0 0]
 [0 1 2 0]
 [0 3 4 0]
 [0 0 0 0]]

Preenchimento permanente

O preenchimento permanente permite que você preencha o array com um valor permanente de sua escolha, não unicamente zeros. Esse valor pode ser qualquer coisa que você escolher, uma vez que 0, 1 ou qualquer outro número. É particularmente útil quando você quer manter certas condições de perímetro ou quando o preenchimento zero pode não ser adequado para sua estudo.

Exemplo:

array = np.array([[1, 2], [3, 4]])
padded_array = np.pad(array, pad_width=1, mode="constant", constant_values=5)
print(padded_array)

Saída:

[[5 5 5 5]
 [5 1 2 5]
 [5 3 4 5]
 [5 5 5 5]]

Acolchoamento de Borda

O preenchimento de bordas preenche o array com valores da borda. Em vez de aditar zeros ou qualquer valor permanente, você usa o valor de borda mais próximo para preencher as lacunas. Essa abordagem ajuda a manter os padrões de dados originais e pode ser muito útil quando você quer evitar introduzir valores novos ou arbitrários em seus dados.

Exemplo:

array = np.array([[1, 2], [3, 4]])
padded_array = np.pad(array, pad_width=1, mode="edge")
print(padded_array)

Saída:

[[1 1 2 2]
 [1 1 2 2]
 [3 3 4 4]
 [3 3 4 4]]

Refletir preenchimento

Reflect padding é uma técnica em que você preenche o array espelhando os valores das bordas do array original. Isso significa que os valores de borda são refletidos nas bordas, o que ajuda a manter os padrões e a perenidade em seus dados sem introduzir quaisquer valores novos ou arbitrários.

Exemplo:

array = np.array([[1, 2], [3, 4]])
padded_array = np.pad(array, pad_width=1, mode="reflect")
print(padded_array)

Saída:

[[4 3 4 3]
 [2 1 2 1]
 [4 3 4 3]
 [2 1 2 1]]

Preenchimento simétrico

O preenchimento simétrico é uma técnica para manipular matrizes que ajuda a manter uma extensão equilibrada e originário dos dados originais. É semelhante ao preenchimento de reflexão, mas inclui os próprios valores de borda na reflexão. Leste método é útil para manter a simetria na matriz preenchida.

Exemplo:

array = np.array([[1, 2], [3, 4]])
padded_array = np.pad(array, pad_width=1, mode="symmetric")
print(padded_array)

Saída:

[[1 1 2 2]
 [1 1 2 2]
 [3 3 4 4]
 [3 3 4 4]]

Melhores práticas comuns para infligir preenchimento a matrizes com NumPy

1. Escolha o tipo de preenchimento correto
2. Garanta que os valores de preenchimento sejam consistentes com a natureza dos dados. Por exemplo, o preenchimento zero deve ser usado para dados binários, mas evite-o para tarefas de processamento de imagem em que o preenchimento de borda ou reflexão pode ser Sua visita nos ajuda a continuar oferecendo o melhor para você! favorável.
3. Considere uma vez que o padding afeta a tarefa de estudo ou processamento de dados. O padding pode introduzir artefatos, mormente no processamento de imagem ou sinal, logo escolha um tipo de padding que minimize esse efeito.
4. Ao preencher arrays multidimensionais, garanta que as dimensões de preenchimento estejam especificadas corretamente. Dimensões desalinhadas podem levar a erros ou resultados inesperados.
5. Documente claramente por que e uma vez que o padding é aplicado em seu código. Isso ajuda a manter a transparência e garante que outros usuários (ou você no horizonte) entendam o propósito e o método do padding.

Desfecho

Neste cláusula, você aprendeu o concepção de padding arrays, uma técnica fundamental amplamente usada em vários campos, uma vez que processamento de imagens e estudo de séries temporais. Exploramos uma vez que o padding ajuda a estender o tamanho dos arrays, tornando-os adequados para diferentes tarefas computacionais.

Nós introduzimos o numpy.pad função, que simplifica a soma de preenchimento a matrizes em NumPy. Por meio de exemplos claros e concisos, Sua visita nos ajuda a continuar oferecendo o melhor para você! uma vez que usar numpy.pad para aditar preenchimento a matrizes, mostrando vários tipos de preenchimento, uma vez que preenchimento zero, preenchimento permanente, preenchimento de borda, preenchimento de reflexão e preenchimento simétrico.

Seguindo essas práticas recomendadas, você pode infligir preenchimento a matrizes com o NumPy, garantindo que sua manipulação de dados seja precisa, eficiente e adequada para sua emprego específica.

Shittu Olumida é um engenheiro de software e repórter técnico enamorado por alavancar tecnologias de ponta para gerar narrativas atraentes, com um olhar atilado aos detalhes e um talento para simplificar conceitos complexos. Você também pode encontrar Shittu em Twitter.