Como substituir os valores de NaN pelos dados da imagem?

Meu conjunto de dados tem um total de 200 colunas, em que cada coluna corresponde ao mesmo pixel em todas as minhas imagens. No total, tenho 48.500 linhas. Os rótulos para os dados variam de 0 a 9.

Os dados são mais ou menos assim:

raw_0   raw_1   raw_2   raw_3   raw_4
0   120.0   133.0   96.0    155.0   66.0
1   159.0   167.0   163.0   185.0   160.0
2   45.0    239.0   66.0    252.0   NaN
3   126.0   239.0   137.0   NaN 120.0
4   226.0   222.0   153.0   235.0   171.0
5   169.0   81.0    100.0   44.0    104.0
6   154.0   145.0   76.0    134.0   175.0
7   77.0    35.0    105.0   108.0   112.0
8   104.0   55.0    113.0   90.0    107.0
9   97.0    253.0   255.0   251.0   141.0
10  224.0   227.0   84.0    214.0   57.0
11  NaN 13.0    51.0    50.0    NaN
12  82.0    213.0   61.0    98.0    59.0
13  NaN 40.0    84.0    7.0 39.0
14  129.0   103.0   65.0    159.0   NaN
15  123.0   128.0   116.0   198.0   111.0

Cada coluna tem cerca de 5% de valores ausentes e eu quero preencher esses valores de NaN com algo significativo. No entanto, não tenho certeza de como fazer isso. Todas as sugestões serão bem-vindas.

Obrigado!

Como você tem imagens estendidas como colunas em uma tabela com ~ 48.500 linhas, suponho que você tenha as imagens brutas com dimensões de 220x220.

Você pode usar uma função disponível via OpenCV chamada inpaint, que restaurará os valores de pixels ausentes (por exemplo, pixels pretos de fotos degradadas).

Aqui está um exemplo de imagem. O canto superior esquerdo mostra a imagem com valores ausentes (em preto). O canto superior direito mostra apenas os valores ausentes (a máscara). Parte inferior esquerda e parte inferior direita são a saída final, comparando dois algoritmos diferentes para preencher as imagens.

Sugiro tentar os dois métodos em suas imagens para ver o que parece melhor.

Tenha um olhar a documentação para obter mais detalhes sobre os próprios algoritmos. Aqui está a documentação da função real .

Quanto ao código, será algo parecido com isto:

import opencv as cv    # you will need to install OpenCV

dst = cv.inpaint(img, mask, 3, cv.INPAINT_TELEA)

• o primeiro argumento é sua imagem com valores ausentes
• o segundo é a máscara, com locais onde os pixels ausentes estão, ou seja, quais pixels devem ser preenchidos / interpolados.
• terceiro é o raio em torno dos pixels ausentes para preencher
• quarto é o sinalizador para o algoritmo usar (veja o link acima para duas alternativas)

Para cada imagem, você pode gerar a máscara com algo como isto:

mask = image[image == np.nan]

Existem várias maneiras de seguir isso. Você pode significar imputação mediana, imputação de modo ou imputação de valor mais comum. Calcule um dos valores acima para linhas ou colunas, dependendo de como seus dados estão estruturados. Uma das maneiras mais simples de encher Nan é df.fillnaem pandas

para qualquer (x, y) se NAN, você pode imputar à média dos pixels adjacentes como:

if((x==0  & y==0):
 return (x+1)+(y+1))/2 

else if(x==x_max & y==y_max):
 return (x-1)+(y-1))/2

else if(x==0 & y==y_max):
 return (x+1)+(y-1))/2

else if(x==x_max & y==0):
 return (x-1)+(y+1))/2

else if(x==0):
 return ((x+1)+(y-1)+(y+1))/3

else if(x==x_max):
 return ((x-1)+(y-1)+(y+1))/3

else if(y==0):
 return ((x+1)+(x-1)+(y+1))/3

else if(y==y_max):
 return ((x-1)+(x+1)+(y-1))/3

else :
  return  ((x-1)+(x+1)+(y-1)+(y+1))/4 

Se linhas adjacentes forem pixels adjacentes, eu usaria o valor médio dos pixels adjacentes. Parece que faria sentido para uma imagem e certamente seria difícil para o olho humano ver.