Desafio: Construindo uma CNN
Redes neurais convolucionais (CNNs) são amplamente utilizadas em classificação de imagens devido à sua capacidade de extrair características hierárquicas. Nesta tarefa, será implementada e treinada uma CNN inspirada na VGG utilizando TensorFlow e Keras no conjunto de dados CIFAR-10
. O conjunto de dados é composto por 60.000 imagens (32×32×3
) pertencentes a 10 classes diferentes, incluindo aviões, carros, pássaros, gatos e outros.
Este projeto orienta sobre carregamento do conjunto de dados, pré-processamento das imagens, definição do modelo CNN, treinamento e avaliação de desempenho.

1. Pré-processamento de Dados para CNNs
Antes do treinamento de uma CNN, o pré-processamento dos dados é uma etapa fundamental para garantir melhor desempenho e convergência mais rápida. Métodos comuns de pré-processamento incluem:
-
Normalização: este método consiste em escalar os valores dos pixels das imagens de um intervalo entre 0 e 255 para um intervalo entre 0 e 1. Geralmente é implementado como
x_train / 255.0, x_test / 255.0
; -
Codificação One-Hot: os rótulos frequentemente são convertidos em vetores one-hot para tarefas de classificação. Normalmente, utiliza-se a função
keras.utils.to_categorical
, que transforma rótulos inteiros (por exemplo, 0, 1, 2, etc.) em um vetor one-hot, como[1, 0, 0, 0]
para um problema de classificação com 4 classes.
2. Construindo a Arquitetura da CNN
Uma arquitetura de CNN é composta por diversas camadas que executam tarefas diferentes para extrair características e realizar previsões. É possível implementar as principais camadas de uma CNN por meio de:
Camada Convolucional (Conv2D)
keras.layers.Conv2D(filters, kernel_size, activation='relu', padding='same', input_shape=(height, width, channels))
Parâmetro input_shape
, necessário especificar apenas na camada de entrada.
Camada de Pooling (MaxPooling2D)
keras.layers.MaxPooling2D(pool_size=(2, 2))
Camada Flatten
keras.layers.Flatten()
Camada Densa
layers.Dense(units=512, activation='relu')
layers.Dense(10, activation='softmax')
A camada densa final geralmente possui o número de unidades igual ao número de classes e utiliza uma função de ativação softmax para fornecer uma distribuição de probabilidade entre as classes.
3. Compilação do Modelo
Após definir a arquitetura, é necessário compilar o modelo. Esta etapa envolve especificar a função de perda, o otimizador e as métricas que irão orientar o modelo durante o treinamento. Os seguintes métodos são comumente utilizados em CNNs:
Otimizador (Adam)
O otimizador ajusta os pesos do modelo para minimizar a função de perda. O otimizador Adam é popular devido à sua eficiência e capacidade de adaptar a taxa de aprendizado durante o treinamento.
keras.optimizers.Adam()
Função de Perda (Categorical Crossentropy)
Para classificação multiclasse, normalmente utiliza-se a função de perda categorical crossentropy. Isso pode ser implementado como:
keras.losses.CategoricalCrossentropy()
Métricas
O desempenho do modelo é monitorado utilizando métricas para tarefas de classificação, como acurácia, precisão, recall, entre outras. Estas podem ser definidas como:
metrics = [
keras.metrics.Accuracy(),
keras.metrics.Precision(),
keras.metrics.Recall()
]
Compilar
model.compile(optimizer='adam',
loss='categorical_crossentropy', # Or keras.losses.CategoricalCrossentropy()
metrics=metrics)
4. Treinamento do Modelo
O treinamento de uma CNN envolve fornecer os dados de entrada para a rede, calcular a perda e atualizar os pesos utilizando retropropagação. O processo de treinamento é controlado pelos seguintes métodos principais:
- Ajuste do Modelo: o método
fit()
é utilizado para treinar o modelo. Este método recebe os dados de treinamento, o número de épocas e o tamanho do lote. Também inclui uma divisão opcional de validação para avaliar o desempenho do modelo em dados não vistos durante o treinamento:
history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)
- Tamanho do Lote e Épocas: o tamanho do lote determina o número de amostras processadas antes de atualizar os pesos do modelo, e o número de épocas refere-se a quantas vezes todo o conjunto de dados é passado pelo modelo.
5. Avaliação
Relatório de Classificação
sklearn.metrics.classification_report()
compara valores reais e previstos do conjunto de teste. Inclui precisão, recall e F1 score para cada classe. Porém, os métodos precisam receber apenas os rótulos das classes, então não se esqueça de converter de volta dos vetores ([0,0,1,0]
-> 2
):
y_pred = model.predict(x_test)
y_pred_classes = np.argmax(y_pred,axis = 1)
y_test_classes = np.argmax(y_test, axis = 1)
report = classification_report(y_test_classes, y_pred_classes, target_names=class_names)
print(report)
Avaliar
Após o treinamento do modelo, ele é avaliado no conjunto de teste para verificar sua capacidade de generalização. A avaliação fornece métricas, que foram mencionadas no método .compile()
. A avaliação é realizada utilizando o .evaluate()
:
results = model.evaluate(x_test, y_test, verbose=2, return_dict=True)
Matriz de Confusão
Para obter mais informações sobre o desempenho do modelo, é possível visualizar a matriz de confusão, que mostra as previsões verdadeiras positivas, falsas positivas, verdadeiras negativas e falsas negativas para cada classe. A matriz de confusão pode ser calculada utilizando o TensorFlow:
confusion_mtx = tf.math.confusion_matrix(y_test_classes, y_pred_classes)
Esta matriz pode então ser visualizada utilizando mapas de calor para observar o desempenho do modelo em cada classe:
plt.figure(figsize=(12, 9))
c = sns.heatmap(confusion_mtx, annot=True, fmt='g')
c.set(xticklabels=class_names, yticklabels=class_names)
plt.show()
1. Carregar e pré-processar o conjunto de dados
- Importar o conjunto de dados CIFAR-10 do Keras;
- Normalizar os valores dos pixels para o intervalo
[0,1]
para melhor convergência; - Converter os rótulos das classes para o formato
one-hot encoded
para classificação categórica.
2. Definir o modelo CNN
Implementar uma arquitetura CNN semelhante à VGG com as seguintes camadas principais:
Camadas convolucionais:
- Tamanho do kernel:
3×3
; - Função de ativação:
ReLU
; - Preenchimento:
'same'
.
Camadas de pooling:
- Tipo de pooling:
max pooling
; - Tamanho do pooling:
2×2
.
Camadas de dropout (Previnem overfitting desativando aleatoriamente neurônios):
- Taxa de dropout:
25%
.
Camada Flatten - converte mapas de características 2D em um vetor 1D para classificação.
Camadas totalmente conectadas - camadas densas para classificação final, com camada de saída relu ou softmax.
Compilar o modelo utilizando:
Adam optimizer
(para aprendizado eficiente);- Função de perda
Categorical cross-entropy
(para classificação multiclasse); - Métrica de
Accuracy metric
para medir desempenho (as classes são balanceadas, e outras métricas podem ser adicionadas conforme necessário).
3. Treinar o modelo
- Especificar os parâmetros
epochs
ebatch_size
para o treinamento (ex:epochs=20, batch_size=64
); - Especificar o parâmetro
validation_split
para definir a porcentagem dos dados de treinamento que se tornarão validação para acompanhar o desempenho do modelo em imagens não vistas; - Salvar o histórico de treinamento para visualizar tendências de acurácia e perda.
4. Avaliar e visualizar os resultados
- Testar o modelo nos dados de teste do CIFAR-10 e exibir a acurácia;
- Plotar perda de treinamento vs. perda de validação para verificar overfitting;
- Plotar acurácia de treinamento vs. acurácia de validação para garantir a progressão do aprendizado.
Obrigado pelo seu feedback!
Pergunte à IA
Pergunte à IA
Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo
Awesome!
Completion rate improved to 3.45
Desafio: Construindo uma CNN
Deslize para mostrar o menu
Redes neurais convolucionais (CNNs) são amplamente utilizadas em classificação de imagens devido à sua capacidade de extrair características hierárquicas. Nesta tarefa, será implementada e treinada uma CNN inspirada na VGG utilizando TensorFlow e Keras no conjunto de dados CIFAR-10
. O conjunto de dados é composto por 60.000 imagens (32×32×3
) pertencentes a 10 classes diferentes, incluindo aviões, carros, pássaros, gatos e outros.
Este projeto orienta sobre carregamento do conjunto de dados, pré-processamento das imagens, definição do modelo CNN, treinamento e avaliação de desempenho.

1. Pré-processamento de Dados para CNNs
Antes do treinamento de uma CNN, o pré-processamento dos dados é uma etapa fundamental para garantir melhor desempenho e convergência mais rápida. Métodos comuns de pré-processamento incluem:
-
Normalização: este método consiste em escalar os valores dos pixels das imagens de um intervalo entre 0 e 255 para um intervalo entre 0 e 1. Geralmente é implementado como
x_train / 255.0, x_test / 255.0
; -
Codificação One-Hot: os rótulos frequentemente são convertidos em vetores one-hot para tarefas de classificação. Normalmente, utiliza-se a função
keras.utils.to_categorical
, que transforma rótulos inteiros (por exemplo, 0, 1, 2, etc.) em um vetor one-hot, como[1, 0, 0, 0]
para um problema de classificação com 4 classes.
2. Construindo a Arquitetura da CNN
Uma arquitetura de CNN é composta por diversas camadas que executam tarefas diferentes para extrair características e realizar previsões. É possível implementar as principais camadas de uma CNN por meio de:
Camada Convolucional (Conv2D)
keras.layers.Conv2D(filters, kernel_size, activation='relu', padding='same', input_shape=(height, width, channels))
Parâmetro input_shape
, necessário especificar apenas na camada de entrada.
Camada de Pooling (MaxPooling2D)
keras.layers.MaxPooling2D(pool_size=(2, 2))
Camada Flatten
keras.layers.Flatten()
Camada Densa
layers.Dense(units=512, activation='relu')
layers.Dense(10, activation='softmax')
A camada densa final geralmente possui o número de unidades igual ao número de classes e utiliza uma função de ativação softmax para fornecer uma distribuição de probabilidade entre as classes.
3. Compilação do Modelo
Após definir a arquitetura, é necessário compilar o modelo. Esta etapa envolve especificar a função de perda, o otimizador e as métricas que irão orientar o modelo durante o treinamento. Os seguintes métodos são comumente utilizados em CNNs:
Otimizador (Adam)
O otimizador ajusta os pesos do modelo para minimizar a função de perda. O otimizador Adam é popular devido à sua eficiência e capacidade de adaptar a taxa de aprendizado durante o treinamento.
keras.optimizers.Adam()
Função de Perda (Categorical Crossentropy)
Para classificação multiclasse, normalmente utiliza-se a função de perda categorical crossentropy. Isso pode ser implementado como:
keras.losses.CategoricalCrossentropy()
Métricas
O desempenho do modelo é monitorado utilizando métricas para tarefas de classificação, como acurácia, precisão, recall, entre outras. Estas podem ser definidas como:
metrics = [
keras.metrics.Accuracy(),
keras.metrics.Precision(),
keras.metrics.Recall()
]
Compilar
model.compile(optimizer='adam',
loss='categorical_crossentropy', # Or keras.losses.CategoricalCrossentropy()
metrics=metrics)
4. Treinamento do Modelo
O treinamento de uma CNN envolve fornecer os dados de entrada para a rede, calcular a perda e atualizar os pesos utilizando retropropagação. O processo de treinamento é controlado pelos seguintes métodos principais:
- Ajuste do Modelo: o método
fit()
é utilizado para treinar o modelo. Este método recebe os dados de treinamento, o número de épocas e o tamanho do lote. Também inclui uma divisão opcional de validação para avaliar o desempenho do modelo em dados não vistos durante o treinamento:
history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)
- Tamanho do Lote e Épocas: o tamanho do lote determina o número de amostras processadas antes de atualizar os pesos do modelo, e o número de épocas refere-se a quantas vezes todo o conjunto de dados é passado pelo modelo.
5. Avaliação
Relatório de Classificação
sklearn.metrics.classification_report()
compara valores reais e previstos do conjunto de teste. Inclui precisão, recall e F1 score para cada classe. Porém, os métodos precisam receber apenas os rótulos das classes, então não se esqueça de converter de volta dos vetores ([0,0,1,0]
-> 2
):
y_pred = model.predict(x_test)
y_pred_classes = np.argmax(y_pred,axis = 1)
y_test_classes = np.argmax(y_test, axis = 1)
report = classification_report(y_test_classes, y_pred_classes, target_names=class_names)
print(report)
Avaliar
Após o treinamento do modelo, ele é avaliado no conjunto de teste para verificar sua capacidade de generalização. A avaliação fornece métricas, que foram mencionadas no método .compile()
. A avaliação é realizada utilizando o .evaluate()
:
results = model.evaluate(x_test, y_test, verbose=2, return_dict=True)
Matriz de Confusão
Para obter mais informações sobre o desempenho do modelo, é possível visualizar a matriz de confusão, que mostra as previsões verdadeiras positivas, falsas positivas, verdadeiras negativas e falsas negativas para cada classe. A matriz de confusão pode ser calculada utilizando o TensorFlow:
confusion_mtx = tf.math.confusion_matrix(y_test_classes, y_pred_classes)
Esta matriz pode então ser visualizada utilizando mapas de calor para observar o desempenho do modelo em cada classe:
plt.figure(figsize=(12, 9))
c = sns.heatmap(confusion_mtx, annot=True, fmt='g')
c.set(xticklabels=class_names, yticklabels=class_names)
plt.show()
1. Carregar e pré-processar o conjunto de dados
- Importar o conjunto de dados CIFAR-10 do Keras;
- Normalizar os valores dos pixels para o intervalo
[0,1]
para melhor convergência; - Converter os rótulos das classes para o formato
one-hot encoded
para classificação categórica.
2. Definir o modelo CNN
Implementar uma arquitetura CNN semelhante à VGG com as seguintes camadas principais:
Camadas convolucionais:
- Tamanho do kernel:
3×3
; - Função de ativação:
ReLU
; - Preenchimento:
'same'
.
Camadas de pooling:
- Tipo de pooling:
max pooling
; - Tamanho do pooling:
2×2
.
Camadas de dropout (Previnem overfitting desativando aleatoriamente neurônios):
- Taxa de dropout:
25%
.
Camada Flatten - converte mapas de características 2D em um vetor 1D para classificação.
Camadas totalmente conectadas - camadas densas para classificação final, com camada de saída relu ou softmax.
Compilar o modelo utilizando:
Adam optimizer
(para aprendizado eficiente);- Função de perda
Categorical cross-entropy
(para classificação multiclasse); - Métrica de
Accuracy metric
para medir desempenho (as classes são balanceadas, e outras métricas podem ser adicionadas conforme necessário).
3. Treinar o modelo
- Especificar os parâmetros
epochs
ebatch_size
para o treinamento (ex:epochs=20, batch_size=64
); - Especificar o parâmetro
validation_split
para definir a porcentagem dos dados de treinamento que se tornarão validação para acompanhar o desempenho do modelo em imagens não vistas; - Salvar o histórico de treinamento para visualizar tendências de acurácia e perda.
4. Avaliar e visualizar os resultados
- Testar o modelo nos dados de teste do CIFAR-10 e exibir a acurácia;
- Plotar perda de treinamento vs. perda de validação para verificar overfitting;
- Plotar acurácia de treinamento vs. acurácia de validação para garantir a progressão do aprendizado.
Obrigado pelo seu feedback!