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))

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')

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 e batch_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.

PROJETO CNN NO COLAB