Se você sempre teve curiosidade sobre como os computadores conseguem “enxergar” e identificar objetos em imagens, este tutorial é o seu ponto de partida! Vamos embarcar em uma jornada prática para construir um classificador de imagens simples utilizando duas das bibliotecas mais poderosas e amigáveis do mundo do aprendizado de máquina: TensorFlow e Keras.

O TensorFlow é um framework de código aberto desenvolvido pelo Google para computação numérica de alto desempenho, especialmente adequado para tarefas de aprendizado de máquina. O Keras, por sua vez, é uma API de alto nível para redes neurais, que roda sobre o TensorFlow (e outros backends), tornando a prototipagem e a experimentação com modelos de aprendizado profundo muito mais intuitivas e acessíveis, especialmente para iniciantes.

Ao final deste tutorial, você terá construído um modelo capaz de distinguir entre diferentes categorias de imagens (neste exemplo, usaremos um conjunto de dados simples). Você entenderá os passos fundamentais do processo de construção de um classificador de imagens, desde a preparação dos dados até o treinamento e a avaliação do modelo.

Pré-requisitos:

• Python instalado: Certifique-se de ter o Python (versão 3.6 ou superior) instalado em sua máquina. Clique aqui para ver um tutorial de como instalar o Python e o Pip.
• TensorFlow e Keras instalados: Você pode instalar essas bibliotecas facilmente usando o pip, o gerenciador de pacotes do Python. Abra seu terminal ou prompt de comando e execute:

pip install tensorflow

(O Keras já vem incluído no TensorFlow a partir da versão 2.0)

• Bibliotecas adicionais (opcional, mas recomendado):
  • matplotlib: Para visualização de dados e gráficos.
  • numpy: Para operações numéricas eficientes.

pip install matplotlib numpy

Passo 1: Importando as Bibliotecas Necessárias

O primeiro passo é importar as bibliotecas que usaremos ao longo do nosso projeto. Abra um novo arquivo Python (por exemplo, classificador_imagens.py) e adicione o seguinte código:

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import numpy as np

Passo 2: Carregando e Explorando o Conjunto de Dados

Para treinar nosso classificador, precisamos de um conjunto de dados de imagens rotuladas. O Keras já vem com alguns conjuntos de dados populares para aprendizado, o que facilita muito para iniciantes. Vamos usar o conjunto de dados Fashion MNIST, que contém imagens em escala de cinza de 10 categorias diferentes de roupas (camisetas, calças, vestidos, etc.).

fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

Este código carrega o conjunto de dados e o divide em dois conjuntos: dados de treinamento (que usaremos para ensinar o modelo) e dados de teste (que usaremos para avaliar o desempenho do modelo em dados não vistos). As variáveis train_images e test_images contêm as imagens propriamente ditas (representadas como arrays NumPy), e train_labels e test_labels contêm os rótulos correspondentes (números inteiros de 0 a 9, cada um representando uma categoria de roupa).

Vamos explorar um pouco os dados:

print(f"Formato das imagens de treinamento: {train_images.shape}")
print(f"Número de rótulos de treinamento: {len(train_labels)}")
print(f"Formato das imagens de teste: {test_images.shape}")
print(f"Número de rótulos de teste: {len(test_labels)}")

Também podemos ver algumas das imagens:

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

Este código mostra as primeiras 25 imagens do conjunto de treinamento, juntamente com seus rótulos correspondentes.

Passo 3: Pré-processando os Dados

Antes de alimentar as imagens em nosso modelo, precisamos pré-processá-las. As imagens estão atualmente representadas como arrays de pixels com valores entre 0 e 255. Para facilitar o treinamento do modelo, vamos normalizar esses valores para o intervalo de 0 a 1, dividindo cada valor de pixel por 255.

train_images = train_images / 255.0
test_images = test_images / 255.0

Passo 4: Construindo o Modelo da Rede Neural

Agora, vamos construir a arquitetura da nossa rede neural. Usaremos um modelo sequencial, que é uma pilha linear de camadas.

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)), # Transforma o formato 2D (28x28 pixels) em um array 1D de 784 pixels
    keras.layers.Dense(128, activation='relu'), # Camada densa (totalmente conectada) com 128 neurônios e função de ativação ReLU
    keras.layers.Dense(10, activation='softmax') # Camada densa de saída com 10 neurônios (um para cada classe) e função de ativação softmax (para obter probabilidades)
])

Vamos entender cada camada:

• keras.layers.Flatten(input_shape=(28, 28)): Esta é a primeira camada e transforma o formato bidimensional das imagens (28×28 pixels) em um vetor unidimensional de 784 pixels. É como “desenrolar” cada imagem em uma longa linha de pixels. O input_shape especifica o formato esperado das imagens de entrada.
• keras.layers.Dense(128, activation='relu'): Esta é uma camada densa (ou totalmente conectada) com 128 neurônios. Cada neurônio nesta camada recebe entrada de todos os 784 pixels da camada anterior. A função de ativação ReLU (Rectified Linear Unit) é uma função não linear que ajuda o modelo a aprender relações complexas nos dados.
• keras.layers.Dense(10, activation='softmax'): Esta é a camada de saída, com 10 neurônios (um para cada classe de roupa). A função de ativação softmax transforma a saída de cada neurônio em uma probabilidade entre 0 e 1, de forma que a soma de todas as probabilidades seja 1. O neurônio com a maior probabilidade será a classe prevista para a imagem.

Passo 5: Compilando o Modelo

Antes de treinar o modelo, precisamos configurá-lo, especificando algumas propriedades importantes:

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

• optimizer='adam': Este é o algoritmo de otimização que o modelo usará para ajustar seus pesos internos com base nos dados de treinamento, com o objetivo de minimizar a função de perda. Adam é um otimizador popular e eficiente.
• loss='sparse_categorical_crossentropy': Esta é a função de perda que o modelo tentará minimizar durante o treinamento. Ela é adequada para problemas de classificação multi-classe onde os rótulos são inteiros.
• metrics=['accuracy']: Esta é a métrica que queremos monitorar durante o treinamento e a avaliação. A acurácia mede a proporção de imagens que foram classificadas corretamente.

Passo 6: Treinando o Modelo

Agora, vamos treinar o modelo usando os dados de treinamento. O processo de treinamento envolve alimentar o modelo com as imagens de treinamento e seus rótulos correspondentes, e o modelo ajustará seus pesos para aprender a mapear as imagens para as classes corretas.

epochs = 10 # Número de vezes que o modelo percorrerá todo o conjunto de dados de treinamento
model.fit(train_images, train_labels, epochs=epochs)

A linha model.fit() inicia o treinamento. O argumento epochs especifica o número de iterações completas sobre o conjunto de dados de treinamento. Durante cada época, o modelo processa todos os exemplos de treinamento, atualiza seus pesos e calcula a perda e as métricas.

Passo 7: Avaliando o Modelo

Após o treinamento, é importante avaliar o desempenho do modelo em dados que ele nunca viu antes (o conjunto de teste). Isso nos dá uma ideia de como o modelo generaliza para novos exemplos.

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print(f'\nPrecisão no conjunto de teste: {test_acc*100:.2f}%')
print(f'Perda no conjunto de teste: {test_loss:.4f}')

A função model.evaluate() calcula a perda e as métricas (neste caso, a acurácia) para o conjunto de teste. A precisão no conjunto de teste nos diz a porcentagem de imagens que o modelo classificou corretamente nos dados não vistos.

Passo 8: Fazendo Previsões

Com o modelo treinado e avaliado, podemos usá-lo para fazer previsões em novas imagens.

predictions = model.predict(test_images)

# Vamos visualizar algumas previsões
def plot_image(i, predictions_array, true_label, img, class_names):
    true_label, img = true_label[i], img[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img, cmap=plt.cm.binary)

    predicted_label = np.argmax(predictions_array)
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'

    plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
    true_label = true_label[i]
    plt.grid(False)
    plt.xticks(range(10))
    plt.yticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#777777")
    plt.ylim([0, 1])
    predicted_label = np.argmax(predictions_array)

    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
    plt.subplot(num_rows, 2*num_cols, 2*i+1)
    plot_image(i, predictions[i], test_labels, test_images, class_names)
    plt.subplot(num_rows, 2*num_cols, 2*i+2)
    plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

Este código usa o modelo treinado para fazer previsões em todas as imagens do conjunto de teste. A função model.predict() retorna um array de probabilidades para cada imagem, onde cada probabilidade indica a confiança do modelo de que a imagem pertence a uma determinada classe. Usamos np.argmax() para obter o índice da classe com a maior probabilidade, que é a previsão do modelo. A função de visualização ajuda a comparar as previsões com os rótulos verdadeiros.

Conclusão:

Parabéns! Você construiu e treinou com sucesso um classificador de imagens simples usando TensorFlow e Keras. Este tutorial cobriu os passos essenciais do processo de aprendizado de máquina para classificação de imagens: carregamento e exploração de dados, pré-processamento, construção do modelo de rede neural, compilação, treinamento, avaliação e realização de previsões.

Este é apenas o começo da sua jornada no mundo da visão computacional e do aprendizado profundo. Há muitas maneiras de melhorar este modelo, como experimentar diferentes arquiteturas de rede, ajustar os hiperparâmetros (como o número de neurônios e épocas), usar técnicas de aumento de dados e explorar conjuntos de dados mais complexos.

Continue explorando, experimentando e aprendendo. O poder das redes neurais para resolver problemas complexos de reconhecimento de padrões é vasto, e você agora tem uma base sólida para construir projetos mais ambiciosos!