Já entendemos como são as imagens que queremos gerar. Desejamos criar essas imagens de roupas em escala de cinza.
Agora, o desafio é pensar em como definir uma rede neural que gera imagens.
Estruturando um gerador
Para começar a pensar nisso, vamos construir uma função geradora de imagens, que será uma rede neural.
Primeiramente, vamos importar as funções layers e Sequential do TensorFlow:
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
Queremos criar uma sequência de camadas de uma rede neural. Assim, vamos criar a função constroi_gerador(). Dentro dessa função, definiremos nosso modelo. Nesse caso, o modelo será atribuído a Sequential().
def constroi_gerador():
modelo = Sequential()
Agora, precisamos de uma sequência de camadas, semelhante à de um classificador.
No classificador, queremos transformar uma imagem de alta dimensionalidade (um quadrado com diversos pixels, que são diversos números) em algo menor, como, por exemplo, um único valor para indicar se estamos na classe 0 ou 1 em um problema de classificação binária.
Em contrapartida, no caso do gerador, partimos de uma classe ou de um ruído (um número aleatório) e tentamos gerar algo mais complexo, como uma imagem.
Vamos criar uma sequência de camadas da rede neural que partirá de um vetor de 100 valores aleatórios, transformando-os em algo mais complexo: uma imagem com dimensões de 28x28, como as imagens do Fashion MNIST.
Para construir a camada de entrada, usamos a função modelo.add(), passando layers.Input() e especificando a forma (shape) dos dados como um vetor (100, ).
modelo.add(layers.Input(shape=(100,)))
Desse modo, nosso input será um ruído, um vetor unidimensional de 100 valores aleatórios.
Continuando a construção da sequência de camadas, vamos adicionar uma camada densa de rede neural através da função modelo.add() novamente.
Dessa vez, passamos layers.Dense(), definindo o tamanho da camada que terá 7*7*256 valores. Também passamos o parâmetro use_bias igual a False.
modelo.add(layers.Dense(7*7*256, use_bias=False))
Assim, definimos o número de neurônios para essa camada densa, aumentando as dimensões de 100 para uma camada com mais dimensões.
Em uma imagem, temos pixels entre 0 e 255, então, temos 256 valores. E, apesar de querer chegar a uma dimensão de 28x28, começamos com valores 7x7, equivalente a uma imagem de 7x7 pixels. A medida que passamos pelas camadas da rede neural, aumentaremos esses valores.
Também adicionaremos uma camada de normalização através do modelo.add(), passando layers.BatchNormalization().
modelo.add(layers.BatchNormalization())
E passaremos a função de ativação para essa camada também usando modelo.add() e passando layers.LeakyReLU() que é uma ReLu (Rectified Linear Unit) com algumas funcionalidades a mais.
modelo.add(layers.LeakyReLU())
Repare que estamos passando as funções de ativação separadamente para o código ficar mais legível. Mas podemos pensar em tudo isso como sendo uma única camada que passamos de forma mais sequencial.
Seguimos com a sequência das camadas, fazendo o Reshape da camada. Para isso, fazemos modelo.add(), passando layers.Reshape() com uma matriz de 7, 7, 256.
modelo.add(layers.Reshape((7, 7, 256)))
Dessa forma, que era uma camada densa de valores 7*7*256 agora tem dimensões equivalentes a uma imagem.
Em seguida, digitamos modelo.add() para adicionar uma nova camada layers.Conv2DTranspose() que é uma camada de deconvolução. Assim como em uma camada convolucional, passaremos os seguintes parâmetros:
- o número de filtros como
128 - o tamanho dos filtros como
(5, 5) - os passos (
strides) igual a (1, 1) - as bordas (
padding) igual a 'same' - o viés de uso (
use_bias) igual a False
Assim, teremos 128 filtros quadrados de 5x5 percorrendo os conjuntos de pixels das imagens.
modelo.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
Enquanto as camadas convolucionais tendem a reduzir a dimensionalidade das imagens quando trabalhamos com a classificação de imagens, a camada de deconvolução tende a desfazer o efeito de uma convolução, aumentando a dimensão da imagem, ou seja, aumentando os pixels da imagem.
Para padronizar, aplicaremos essa camada com a sequência de camadas já aplicadas, efetuando novamente a normalização e aplicando uma ativação:
modelo.add(layers.BatchNormalization())
modelo.add(layers.LeakyReLU())
Copiando a estrutura do Conv2DTranspose(), definiremos mais uma camada convolucional. Dessa vez, vamos aplicar 64 filtros, alterar strides para (2, 2) e manter o restante dos parâmetros.
Logo, aplicamos novamente uma normalização e uma ativação.
modelo.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
modelo.add(layers.BatchNormalization())
modelo.add(layers.LeakyReLU())
Não fizemos o Reshape novamente porque ele só é necessário quando estamos convertendo os valores de uma camada densa (que organiza os dados em um formato linear, como um vetor 1D) para um formato bidimensional (2D), que se assemelha a uma imagem.
Feito isso, vamos finalizar com uma camada que deixará o resultado com apenas uma única imagem. Assim, vamos transformar as 64 imagens, resultantes da aplicação de 64 filtros, em uma única imagem.
Para isso, novamente adicionaremos uma camada convolucional, copiando a estrutura de Conv2DTranspose(). Dessa vez, alteraremos apenas o número de filtros para 1.
Além disso, depois do use_bias, acrescentaremos o parâmetro activation igual a 'tanh', uma tangente hiperbólica.
modelo.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
A ativação tanh retornará valores entre -1 e 1, lembrando que normalizamos os dados para ficarem entre esses valores.
Por fim, retornamos o modelo na função:
def constroi_gerador():
modelo = Sequential()
modelo.add(layers.Input(shape&
modelo.add(layers.Dense(7*7*256, use_bias&
modelo.add(layers.BatchNormalization())
modelo.add(layers.LeakyReLU())
modelo.add(layers.Reshape((7, 7, 256)))
modelo.add(layers.Conv2DTranspose(128, (5, 5), strides&
modelo.add(layers.BatchNormalization())
modelo.add(layers.LeakyReLU())
modelo.add(layers.Conv2DTranspose(64, (5, 5), strides&
modelo.add(layers.BatchNormalization())
modelo.add(layers.LeakyReLU())
modelo.add(layers.Conv2DTranspose(1, (5, 5), strides&
return modelo
Executamos o código com "Shift + Enter" para construir a função.
No próximo vídeo, aplicaremos essa função para tentar gerar algum tipo de imagem. Até o próximo vídeo!