Few-shot learning

Prof. João Cláudio Nunes Carvalho — Ifce

A técnica de aprendizado few-shot é um método de aprendizado de máquina que foi desenvolvido para adquirir conhecimento sobre novas tarefas ou fazer previsões utilizando uma quantidade mínima de dados — geralmente apenas alguns exemplos, conhecidos como “shots”. Isso é diferente dos métodos convencionais de aprendizado de máquina que necessitam de grandes volumes de dados para apresentar um bom desempenho.

O objetivo do aprendizado few-shot é adaptar um modelo que foi pré-treinado em um grande conjunto de dados para uma nova tarefa onde apenas uma pequena quantidade de dados de treinamento está disponível. Isso é particularmente útil em cenários onde a coleta de dados é desafiadora, custosa ou quando é necessária a implantação rápida de modelos de aprendizado de máquina.

Conceitos-chave no aprendizado few-shot:

• Conjunto de Suporte: Este é o pequeno conjunto de dados fornecido para treinar o modelo em uma nova tarefa. Ele inclui alguns exemplos por classe.
• Conjunto de Consulta: Estes são novos exemplos que precisam ser classificados após o modelo ter sido treinado no conjunto de suporte.
• Episódios: O treinamento em aprendizado few-shot tipicamente envolve múltiplos episódios. Cada episódio apresenta ao modelo um novo conjunto de suporte e um novo conjunto de consulta, o que ajuda o modelo a aprender a generalizar entre tarefas.

Técnicas Usadas no Aprendizado Few-shot:

• Aprendizado Métrico: O modelo aprende um espaço de incorporação no qual as distâncias correspondem diretamente a uma medida de similaridade de classe. Por exemplo, modelos como Redes Siamesas ou Redes Tripletas são treinados para minimizar ou maximizar a distância entre exemplos, dependendo se eles pertencem ou não à mesma classe.
• Model-Agnostic Meta-Learning (MAML): Esta abordagem envolve treinar um modelo em uma variedade de tarefas de aprendizado, de modo que ele possa resolver novas tarefas de aprendizado usando apenas um pequeno número de etapas de treinamento. A chave é encontrar parâmetros do modelo que sejam sensíveis a mudanças na tarefa, permitindo uma rápida adaptação.
• Transferência de Aprendizado: Usar um modelo pré-treinado em um grande conjunto de dados e ajustá-lo no pequeno conjunto de suporte da nova tarefa também pode ser eficaz em cenários de few-shot.
• Métodos Bayesianos: Esses métodos usam distribuições de probabilidade anteriores e as atualizam com novos dados (o conjunto de suporte) para fazer previsões. Esta abordagem é naturalmente adequada para o aprendizado few-shot porque formaliza a aprendizagem a partir de dados limitados.

Exemplo:

Vamos criar um exemplo de aprendizado few-shot usando a biblioteca Python e o conjunto de dados MNIST, que é famoso por incluir imagens de dígitos escritos à mão. Neste exemplo, usaremos um modelo simples de classificação baseado em uma rede neural para demonstrar como se pode abordar um problema de aprendizado few-shot com um conjunto de dados de imagens.

Passos do exemplo:

1. Carregar o conjunto de dados MNIST.
2. Selecionar um pequeno número de exemplos de cada classe para formar o conjunto de suporte.
3. Usar o restante dos dados como conjunto de consulta.
4. Treinar uma rede neural simples no conjunto de suporte.
5. Avaliar o desempenho da rede no conjunto de consulta

import numpy as np
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import to_categorical

# Carregar o conjunto de dados MNIST
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# Normalizar as imagens
train_images = train_images / 255.0
test_images = test_images / 255.0
# Selecionar poucos exemplos para o aprendizado few-shot
# Vamos selecionar 10 exemplos de cada classe para o treinamento
indices = []
for i in range(10):
    indices += list(np.where(train_labels == i)[0][:10])
few_shot_images = train_images[indices]
few_shot_labels = train_labels[indices]
# Converter rótulos para formato one-hot
few_shot_labels = to_categorical(few_shot_labels, 10)
# Construir o modelo de rede neural
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])
# Compilar o modelo
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Treinar o modelo
model.fit(few_shot_images, few_shot_labels, epochs=50, verbose=2)
# Avaliar o modelo no conjunto de teste
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f"Acurácia de teste: {test_acc * 100:.2f}%")

Neste script, normalizamos as imagens dividindo por 255 para garantir que os valores dos pixels estejam entre 0 e 1. Usamos uma rede neural simples com uma camada oculta. O modelo é treinado em um conjunto muito pequeno de dados (apenas 100 imagens, 10 de cada classe), e depois é avaliado em um conjunto de teste mais extenso para ver como ele generaliza.