Introdução à Otimização de Contexto em Modelos Multimodais

O aprendizado por pistas (prompt learning) emergiu como uma técnica fundamental para adaptar modelos pré-treinados a tarefas específicas sem re-treinar os parâmetros completos. Entre essas abordagens, o CoOp (Context Optimizaton) destaca-se por focar exclusivamente na otimização de vetores de contexto inseridos nas entradas textuais. Esta metodologia permite que redes neurais de visão e linguagem, como o CLIP, operem com alta eficiência em cenários de poucos dados (few-shot).

A Arquitetura Central: Vetores de Contexto

Diferente das técnicas tradicionais que ajustam camadas inteiras da rede, o CoOp introduz um conjunto de embeddings treináveis que antecedem ou substituem partes fixas da frase de entrada. Esses vetores funcionam como marcadores genéricos que guiam o modelo na extração de características relevantes durante a inferência.

Para configurar esses embeddings, existem estratégias distintas de inicialização. Abaixo apresentamos uma implementação alternativa ao padrão original, alterando nomes de variáveis e lógica interna:

def setup_context_vectors(num_classes, length_ctx, dim_emb, device):
    """
    Inicializa os parâmetros do prompt aprendido.
    """
    # Seleciona se será específico por classe ou genérico
    if is_class_specific:
        shape_vector = (num_classes, length_ctx, dim_emb)
        print("Modo: Contexto Específico por Classe")
    else:
        shape_vector = (length_ctx, dim_emb)
        print("Modo: Contexto Genérico Universal")
    
    # Criação do tensor de pesos aprendíveis
    context_params = torch.nn.Parameter(torch.randn(shape_vector, device=device))
    
    # Aplicação de distribuição normal inicial
    torch.nn.init.uniform_(context_params, a=-0.01, b=0.01)
    
    return context_params

Gerenciamento de Gradientes e Eficiência

Um dos pilares da eficácia do CoOp é o congelamento dos codificadores originais de imagem e texto. Isso previne o sobreajuste e reduz drasticamente o custo computacional. A lógica abaixo ilustra como desabilitar a propagação gradiente nos componentes estáticos, permitindo treinamento apenas na seção de prompting:

def freeze_encoder_weights(base_network, learner_module):
    print("Bloqueando gradiente nos codificadores visuais e textuais")
    for nome_param, parametro in base_network.named_parameters():
        # Mantém ativo apenas o módulo responsável pelo aprendizado de contexto
        if nome_param not in learner_module.get_full_names():
            parametro.requires_grad = False
    
    # Garante que apenas os vetores de contexto sejam atualizados
    trainable_params = [p for p in learner_module.parameters() if p.requires_grad]
    return trainable_params

Mecanismo de Geração de Pistas Condicionais

O processo de construção da entrada textual segue um fluxo estruturado onde os vetores aprendidos são concatenados com o tokenizador de classes. A posição da classe pode variar conforme a configuração de arquitetura definida nos arquivos de configuração YAML.

Processamento do Encoder de Texto

No interior da classe TextEncoder, os tokens processados passam por transformações dimensionais antes de entrar na camada Transformer. Abaixo, uma versão modificada do método forward demonstra essa manipulação tensorial:

def executar_codificacao_texto(embeddings_prompt, tokens_input):
    # Adiciona embedding de posição aos prompts aprendidos
    sequence_completa = embeddings_prompt + self.embedding_posicao.to(dtype=self.data_type)
    
    # Reorganização para formato LND (Sequence, Batch, Feature)
    seq_transposta = sequence_completa.permute(1, 0, 2)
    
    # Passagem pela rede transformer
    saida_transformer = self.camadas_transformer(seq_transposta)
    
    # Restauração do formato NLD para leitura final
    saida_final = saida_transformer.permute(1, 0, 2)
    normalized_saidas = self.ln_final(saida_final).type(self.data_type)
    
    # Extração do vetor representativo baseado no token fim-de-sentence
    indices_eot = tokens_input.argmax(dim=-1)
    feature_vector = normalized_saidas[
        torch.arange(normalized_saidas.shape[0]), 
        indices_eot
    ]
    
    # Projeção final para espaço de features
    return feature_vector @ self.text_projection_matriz

Calculo de Similaridade para Classificação

A decisão final ocorre através da comparação coseno entre as representações visuais e textuais. A normalização é aplicada previamente para garantir estabilidade numérica, seguida pela escala de temperatura característica do modelo CLIP:

def calcular_probs_similaridade(repr_imagem, repr_texto, escala_logit):
    # Normalização unitária dos vetores
    img_norm = repr_imagem / repr_imagem.norm(dim=-1, keepdim=True)
    txt_norm = repr_texto / repr_texto.norm(dim=-1, keepdim=True)
    
    # Matriz de similaridade crua
    matriz_similaridade = torch.matmul(img_norm, txt_norm.t())
    
    # Aplicação da escala de temperatura
    prob_classificacao = matriz_similaridade * escala_logit.exp()
    
    return prob_classificacao

Vantagens Técnicas Implementadas

• Adaptação Rápida: A redução significativa no número de parâmetros ajustáveis permite convergência veloz mesmo com conjuntos de treino reduzidos (ex: 1 a 16 imagens por classe).
• Generalização: Ao não modificar os pesos pesados do backbone, o modelo preserva seu conhecimento geral, facilitando a transferência para novos domínios sem catástrofe de esquecimento.
• Resiliência Distribucional: As pistas aprendidas mostram capacidade de adaptação a variações estatísticas nos dados de entrada, mantendo acurácia em benchmarks desafiadores como sketch ou versões corrompidas das bases de teste.

Procedimentos Opreacionais

Para colocar a estratégia em prática, o fluxo típico envolve a execução de scripts de linha de comando que gerenciam hiperparâmetros como o comprimento do contexto e o tipo de inicialização. Um exemplo simplificado de invocação para treinamento em um dataset de referência:

O ambiente deve ser configurado apontando para o diretório de saída desejado, especificando o backbone (ex: ResNet50) e as condições de shot learning. Após o ciclo de epochs, os resultados são consolidados através de utilitários de parseamento que calculam a acurácia média macro e micro.

A interpretação dos vetores aprendidos pode ser realizada mapeando-os de volta para o vocabulário léxico mais próximo, oferecendo insights sobre quais conceitos linguísticos foram incorporados durante o ajuste fino.

Esta abordagem representa um avanço substancial para ambientes onde recursos computacionais ou dados rotulados são escassos, equilibrando desempenho e complexidade de implementação.