Aprendizado profundo com Keras - preparação de dados

Antes de alimentarmos os dados em nossa rede, eles devem ser convertidos para o formato exigido pela rede. Isso é chamado de preparação de dados para a rede. Geralmente consiste em converter uma entrada multidimensional em um vetor unidimensional e normalizar os pontos de dados.

Remodelando o vetor de entrada

As imagens em nosso conjunto de dados consistem em 28 x 28 pixels. Isso deve ser convertido em um vetor unidimensional de tamanho 28 * 28 = 784 para alimentá-lo em nossa rede. Fazemos isso chamando oreshape método no vetor.

X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)

Agora, nosso vetor de treinamento consistirá em 60.000 pontos de dados, cada um consistindo em um vetor de dimensão única de tamanho 784. Da mesma forma, nosso vetor de teste consistirá em 10.000 pontos de dados de um vetor de dimensão única de tamanho 784.

Normalizando Dados

Os dados que o vetor de entrada contém atualmente têm um valor discreto entre 0 e 255 - os níveis da escala de cinza. Normalizar esses valores de pixel entre 0 e 1 ajuda a acelerar o treinamento. Como usaremos a descida gradiente estocástica, a normalização dos dados também ajudará a reduzir a chance de ficar preso em ótimos locais.

Para normalizar os dados, nós os representamos como tipo float e os dividimos por 255, conforme mostrado no seguinte trecho de código -

X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

Vejamos agora como os dados normalizados se parecem.

Examinando Dados Normalizados

Para visualizar os dados normalizados, chamaremos a função de histograma conforme mostrado aqui -

plot.hist(X_train[0])
plot.title("Digit: {}".format(y_train[0]))

Aqui, traçamos o histograma do primeiro elemento do X_trainvetor. Também imprimimos o dígito representado por este ponto de dados. O resultado da execução do código acima é mostrado aqui -

Você notará uma densidade espessa de pontos com valores próximos a zero. Esses são os pontos pretos na imagem, que obviamente são a parte principal da imagem. O resto dos pontos da escala de cinza, que estão próximos da cor branca, representam o dígito. Você pode verificar a distribuição de pixels para outro dígito. O código a seguir imprime o histograma de um dígito no índice de 2 no conjunto de dados de treinamento.

plot.hist(X_train[2])
plot.title("Digit: {}".format(y_train[2])

O resultado da execução do código acima é mostrado abaixo -

Comparando as duas figuras acima, você notará que a distribuição dos pixels brancos em duas imagens difere, indicando uma representação de um dígito diferente - “5” e “4” nas duas imagens acima.

A seguir, examinaremos a distribuição de dados em nosso conjunto de dados de treinamento completo.

Examinando a distribuição de dados

Antes de treinar nosso modelo de aprendizado de máquina em nosso conjunto de dados, devemos saber a distribuição de dígitos únicos em nosso conjunto de dados. Nossas imagens representam 10 dígitos distintos que variam de 0 a 9. Gostaríamos de saber o número de dígitos 0, 1, etc., em nosso conjunto de dados. Podemos obter essas informações usando ounique método de Numpy.

Use o seguinte comando para imprimir o número de valores únicos e o número de ocorrências de cada um

print(np.unique(y_train, return_counts=True))

Ao executar o comando acima, você verá a seguinte saída -

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8), array([5923, 6742, 5958, 6131, 5842, 5421, 5918, 6265, 5851, 5949]))

Mostra que existem 10 valores distintos - 0 a 9. Existem 5923 ocorrências do dígito 0, 6742 ocorrências do dígito 1 e assim por diante. A captura de tela da saída é mostrada aqui -

Como uma etapa final na preparação de dados, precisamos codificar nossos dados.

Dados de codificação

Temos dez categorias em nosso conjunto de dados. Assim, codificaremos nossa saída nessas dez categorias usando codificação one-hot. Usamos o método to_categorial dos utilitários Numpy para realizar a codificação. Depois que os dados de saída são codificados, cada ponto de dados seria convertido em um vetor dimensional único de tamanho 10. Por exemplo, o dígito 5 agora será representado como [0,0,0,0,0,1,0,0,0 , 0].

Codifique os dados usando o seguinte trecho de código -

n_classes = 10
Y_train = np_utils.to_categorical(y_train, n_classes)

Você pode verificar o resultado da codificação imprimindo os primeiros 5 elementos do vetor Y_train categorizado.

Use o seguinte código para imprimir os primeiros 5 vetores -

for i in range(5):
   print (Y_train[i])

Você verá a seguinte saída -

[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]

O primeiro elemento representa o dígito 5, o segundo representa o dígito 0 e assim por diante.

Finalmente, você terá que categorizar os dados de teste também, o que é feito usando a seguinte instrução -

Y_test = np_utils.to_categorical(y_test, n_classes)

Nesse estágio, seus dados estão totalmente preparados para alimentação na rede.

A seguir, vem a parte mais importante que é treinar nosso modelo de rede.