Vivencie na prática como os modelos de linguagem funcionam com o pequeno modelo de linguagem GuppyLM

 (github.com/arman-bd)
46 pontos por GN⁺ 23 일 전 | 1 comentários | Compartilhar no WhatsApp
  • Um modelo de linguagem ultracompacto com cerca de 9 milhões de parâmetros, com estrutura que permite treinamento em menos de 5 minutos com um único notebook no Colab
  • Da geração de dados ao tokenizador, treinamento do modelo e inferência, todo o processo é realizado em um único ambiente, com suporte a navegador, Colab e ambiente local
  • Projetado em torno do personagem ‘Guppy’, que imagina um ambiente subaquático, conversa com frases curtas e simples e foca em transparência para fins educacionais
  • Usa uma arquitetura Transformer básica, mostrando com clareza a estrutura central de um modelo de linguagem sem técnicas complexas
  • Projeto open source com dataset público no HuggingFace e licença MIT, permitindo que qualquer pessoa experimente e aprenda

Visão geral do GuppyLM

  • GuppyLM é um modelo de linguagem ultracompacto com cerca de 9 milhões de parâmetros, que conversa como o personagem peixe “Guppy”
  • Foi projetado com o objetivo de ser um LLM que pode ser treinado diretamente em menos de 5 minutos com um único notebook no Colab, permitindo realizar em um só ambiente todo o processo, da geração de dados ao tokenizador, arquitetura do modelo, loop de treinamento e inferência
  • Foi criado para que seja possível experimentar diretamente o funcionamento interno de um modelo de linguagem sem precisar de grandes clusters de GPU ou conhecimento especializado
  • Não gera textos longos como modelos maiores, mas é um modelo educacional que mostra de forma transparente todo o processo de entrada, aprendizado de pesos e geração de saída
  • Pode ser executado em navegador, Colab e ambiente local, e o dataset e o modelo são publicados via HuggingFace

Características do modelo

  • O GuppyLM é um personagem que pensa principalmente em ambientes subaquáticos, como água, temperatura, luz, vibração e comida
  • Usa frases curtas em minúsculas e não entende conceitos abstratos humanos, como dinheiro ou política
  • Tem uma personalidade amigável, curiosa e simples
  • Os dados de treinamento são compostos por 60 tópicos e 60 mil amostras sintéticas de conversa, e o treinamento pode ser feito em cerca de 5 minutos em uma única GPU
  • Como o modelo é pequeno, também é possível fazer inferência no navegador com base em WebAssembly

Arquitetura

  • Número de parâmetros: 8.7M
  • Número de camadas: 6
  • Dimensão oculta: 384
  • Cabeças de atenção: 6
  • Dimensão FFN: 768 (ReLU)
  • Tamanho do vocabulário: 4.096 (BPE)
  • Comprimento máximo de sequência: 128 tokens
  • Normalização: LayerNorm
  • Embeddings posicionais: treináveis
  • Cabeça LM: compartilhamento de pesos com os embeddings
  • Estrutura Transformer básica sem uso de técnicas complexas como GQA, RoPE, SwiGLU e early exit

Personalidade e tópicos de conversa

  • O Guppy conversa com frases curtas, expressões em minúsculas e pensamento centrado em sensações
  • Reage a vários temas, como comida, água, luz, aquário, bolhas, reflexos, superfície da água e mundo exterior
  • Os 60 tópicos principais incluem saudações, emoções, temperatura, comida, luz, água, aquário, ruído, solidão, sonhos, estações, piadas, amor, saúde e TV

Como executar e usar

  • Executar no navegador

    • Realiza inferência local com base em WebAssembly
    • Baixa um modelo ONNX quantizado de cerca de 10MB e pode ser executado sem servidor nem chave de API

  • Conversar no Colab

    • Baixa um modelo pré-treinado do HuggingFace e o usa em uma interface interativa de chat
    • Basta executar todas as células para começar a conversar imediatamente

  • Treinar no Colab

    • Defina o runtime como GPU T4 e execute todas as células
    • Faz automaticamente o download do dataset, treinamento do tokenizador, treinamento do modelo e testes
    • O modelo resultante pode ser enviado ao HuggingFace ou salvo localmente

  • Conversar em ambiente local

    • Instale com pip install torch tokenizers e execute com o comando python -m guppylm chat
    • Se a conversa ficar longa, a qualidade cai por causa do limite de 128 tokens
    • Também há suporte a um modo que recebe apenas um prompt, retorna a resposta e encerra

Dataset

  • Usa o dataset arman-bd/guppylm-60k-generic do HuggingFace
  • Número de amostras: 60.000 (treino 57K / teste 3K)
  • Formato: {"input": "...", "output": "...", "category": "..."}
  • Número de categorias: 60
  • Modo de geração: dados sintéticos baseados em templates
    • Aproximadamente 60 templates, 30 objetos de aquário, 17 tipos de alimento e 25 combinações de atividade geram cerca de 16.000 saídas únicas

Estrutura do projeto

  • guppylm/

    • config.py: hiperparâmetros do modelo e do treinamento
    • model.py: modelo Transformer básico
    • dataset.py: carregamento de dados e processamento em lotes
    • train.py: loop de treinamento (cosine LR, AMP)
    • generate_data.py: geração de dados de conversa para 60 tópicos
    • eval_cases.py: casos de teste
    • prepare_data.py: preparação dos dados e treinamento do tokenizador
    • inference.py: interface de chat

  • tools/

    • make_colab.py: geração do notebook do Colab
    • export_onnx.py: exportação para modelo ONNX (quantização uint8)
    • export_dataset.py: envio do dataset ao HuggingFace
    • dataset_card.md: descrição do dataset para o HuggingFace

  • docs/

    • index.html: demo no navegador (ONNX + WASM)
    • download.sh: download do modelo e do tokenizador
    • model.onnx: modelo quantizado (~10MB)
    • tokenizer.json: tokenizador BPE
    • guppy.png: imagem do logotipo

Decisões de design

  • Remoção do system prompt:como um modelo de 9M tem dificuldade em seguir instruções condicionais, em vez de usar o mesmo prompt em todas as amostras, a personalidade foi incorporada diretamente aos pesos

    • Isso economiza cerca de 60 tokens durante a inferência
    • Conversa de turno único: devido ao limite de 128 tokens, a qualidade cai após 3 a 4 turnos
    • Isso combina com o conceito de “memória de peixinho dourado” do Guppy, mas o turno único é o mais estável
    • Manutenção do Transformer básico: GQA, SwiGLU, RoPE e early exit não trouxeram melhora de qualidade na escala de 9M e apenas aumentaram a complexidade
    • A combinação de atenção padrão + ReLU FFN + LayerNorm garante desempenho suficiente
    • Uso de dados sintéticos: para manter uma personalidade consistente do personagem, foi adotada a geração de dados baseada em templates

Licença

  • Licença MIT

Leituras relacionadas

1 comentários

 
GN⁺ 23 일 전
Comentários do Hacker News

  • Fico me perguntando se existe documentação para este projeto
    O código em si parece ser uma das implementações mais simples de um (Not So) Large Language Model, mas não é fácil de entender para desenvolvedores que não estão familiarizados com multi-head attention, ReLU FFN, LayerNorm, positional embedding etc.
    Este projeto tem um caráter educacional parecido com o do Minix. Assim como o Minix foi usado como ferramenta para aprender design de sistemas operacionais, também é uma boa abordagem que estudantes aprendam o design de LLMs adicionando recursos ao GuppyLM

    • Também parece uma boa ideia inserir o código em um LLM e conversar sobre ele

  • Fico curioso sobre como este projeto se diferencia do microgpt ou do minGPT do Andrej Karpathy

    • Ainda não comparei, mas agradeço a sugestão. Pretendo dar uma olhada nos dois projetos
    • A comparação não é o mais importante. Isto não é um produto, e sim um projeto experimental legal

  • Em bbycroft.net/llm há um exemplo de visualização 3D de pequenas camadas de LLM. Isso ajuda muito a entender o funcionamento interno
    A discussão relacionada também pode ser vista aqui

    • Bem legal! Vou explorar com mais profundidade
    • Não é diretamente relacionado, mas o projeto é realmente muito legal. Talvez fosse bom adicionar um pouco mais de UI
    • Visualização interessante

  • É realmente excelente como introdução a LLMs
    Já fiz meu próprio modelo no passado com base em Paradise Lost, de Milton
    Referência: wvrk.org/works/milton

  • Isso provavelmente aconteceu porque os dados de treinamento estão todos em minúsculas

    You> hello
Guppy> hi. did you bring micro pellets.
You> HELLO
Guppy> i don't know what it means but it's mine.
    • Boa observação! Parece que não há nenhum token em maiúsculas no tokenizador
      Mesmo assim, a reação do personagem continua viva

  • Fiquei curioso se seria possível criar um LLM treinado apenas em Toki Pona
    Veja a wiki de Toki Pona

    • Mas não há dados de treinamento suficientes. O essencial nos LLMs é ter dados e recursos computacionais em enorme escala

  • Estou trabalhando em um projeto em que vários agentes de LLM compartilham um mesmo mundo virtual e interagem de forma autônoma
    O mais surpreendente é que a existência desse ‘mundo’ influencia bastante o comportamento do modelo
    Mesmo com o mesmo modelo e o mesmo prompt, o resultado muda completamente quando fatores do ambiente, como restrições de recursos, outros agentes e memória persistente, são diferentes
    Estamos focando demais apenas na otimização do modelo em si e pensando de menos no seu ambiente de operação

  • Dá a sensação de que finalmente surgiu um LLM honesto sobre o mundo
    A resposta “o sentido da vida é comida” parece menos errada do que as respostas dadas por modelos 10 mil vezes maiores

    • Talvez seja até uma interpretação melhor do que aquela resposta famosa
    • O propósito da vida é a reprodução. A comida é apenas o meio para isso, e todos os recursos e características existem para ajudar no acasalamento

  • A ideia é boa, mas os exemplos parecem ter sido copiados diretamente dos dados de treinamento
    Fico curioso sobre como ele responde a consultas desconhecidas

    • Quase não responde. Com 9M de parâmetros, a capacidade é muito limitada
      O objetivo deste projeto é demonstrar o princípio de funcionamento dos LLMs

  • Ótimo trabalho. Obrigado por compartilhar
    Mas agora fiquei curioso se os LLMs realmente parecem algo ‘sem mistério’ para você
    Ainda é surpreendente que resultados como esse saiam apenas de estatística simples e de uma quantidade enorme de computação