LLMDOZERO - Modelo GPT Pré-Treinado em Português do Brasil

Este repositório contém um modelo GPT (Generative Pre-trained Transformer) criado e treinado do zero em português do Brasil. O modelo foi desenvolvido como parte de uma série de artigos com o objetivo de demonstrar e explicar o processo de construção e treinamento de Large Language Models (LLMs) desde o início.

Visão Geral da Série de Artigos:

Este modelo é o resultado do sétimo artigo de uma série que explora a criação de LLMs, cobrindo desde os conceitos fundamentais até o treinamento prático. A série completa inclui:

Introdução: Conceitos básicos de LLMs e a proposta da série.
Tokenização: Criação de um tokenizador SentencePiece do zero.
Embedding: Implementação de camadas de embedding para representação de tokens.
Mecanismo de Atenção: Desenvolvimento do mecanismo de Multi-Head Attention.
Bloco Transformer: Construção de blocos Transformer completos.
Criando um GPT: Montagem da arquitetura GPT a partir dos blocos.
Treinando um Foundational Model (Este Repositório): Pré-treinamento do modelo GPT em um corpus de textos em português.

Ele pode ser acessado em: https://blog.zfab.me/construindo-um-llm-do-zero-treinando-um-foundational-model-a44d2d0abc6d

Sobre este Modelo:

Este repositório fornece o checkpoint do modelo GPT após a fase de pré-treinamento (Foundational Model). O modelo foi treinado em um corpus de aproximadamente 33 milhões de tokens em português do Brasil, extraído de parte do dataset GigaVerbo.

Arquitetura do Modelo:

Tipo: GPT (Decoder-only Transformer)
Parâmetros: 88 milhões
Vocabulário: 4096 tokens (SentencePiece)
Dimensão do Embedding: 768
Context Length: 256 tokens
Número de Layers: 12
Número de Heads de Atenção: 12

Arquivos no Repositório:

model.safetensors: Checkpoint do modelo pré-treinado em formato safetensors (apenas os pesos do modelo).
tokenizer.model: Modelo SentencePiece do tokenizador utilizado.
README.md: Este arquivo, contendo informações sobre o modelo e como utilizá-lo.
checkpoint.pth: Checkpoint completo do treinamento em formato .pth, incluindo pesos do modelo, estado do otimizador, scheduler e histórico de treinamento (útil para retomar o treinamento, mas não essencial para inferência).

Como usar o modelo:

Para utilizar este modelo, você precisará dos seguintes arquivos deste repositório: model.safetensors e tokenizer.model. Você também precisará do código fonte do modelo, que pode ser encontrado nos arquivos model.py, dataloader.py e train_model.py (disponíveis no repositório GitHub do projeto - https://github.com/z-fab/llm-zero).

Passos para carregar e usar o modelo com PyTorch:

Certifique-se de ter as bibliotecas instaladas:
```
pip install torch sentencepiece safetensors
```
Baixe os arquivos do modelo: model.safetensors e tokenizer.model para uma pasta local (ex: llmdozero).
Baixe os scripts do modelo: model.py, dataloader.py e train_model.py do repositório GitHub e coloque-os na mesma pasta ou ajuste os paths no código abaixo.
Use o código Python abaixo para carregar o modelo e gerar texto:

import torch
from model import GPTModel  # Certifique-se que model.py está no mesmo diretório ou path correto
import sentencepiece as spm
from safetensors.torch import load_model
import json

# 1. Carregue o tokenizador
tokenizer = spm.SentencePieceProcessor(model_file="tokenizer.model")

# 2. Instancie o modelo GPT com a configuração
model = GPTModel(
    d_vocab=tokenizer.vocab_size(),
    d_emb=768,
    context_length=256,
    n_layers=12,
    n_heads=12,
    dropout=0.1,
    qkv_bias=True
)

# 3. Carregue os pesos do modelo a partir do arquivo safetensors
load_model(model, "model.safetensors")

model.eval() # Coloque o modelo em modo de avaliação

# 4. Gerar texto de exemplo 
phrase = "O Brasil é um país muito"
phrase = tokenizer.encode(phrase)
phrase = torch.tensor(phrase, dtype=torch.long).unsqueeze(0)

response = model.generate(
    phrase, 
    max=30, 
    temperature=0.4, 
    top_k=40, 
    top_p=0.9
)

response = tokenizer.decode(response.squeeze().tolist())
print(response)

Detalhes do Treinamento:

Corpus: Parte do dataset GigaVerbo (aproximadamente 25 milhões de tokens em português do Brasil).
Infraestrutura: RunPod (VM com RTX 2000 Ada)
Tempo de Treinamento: 3 horas e 30 minutos (aproximadamente 4000 steps)
Otimizador: AdamW com Decaimento de Peso Diferenciado
Scheduler: OneCycleLR

Resultados e Limitações:

O modelo alcançou uma loss de validação de aproximadamente 3.5 e perplexidade de 34 após o pré-treinamento. Embora o modelo demonstre a capacidade de gerar texto em português e aprender padrões básicos da linguagem, ele ainda possui limitações:

Tamanho do Modelo e Corpus: Modelo pequeno (88M parâmetros) treinado em um corpus relativamente modesto (25M tokens) em comparação com LLMs de última geração.
Qualidade do Texto Gerado: O texto gerado pode apresentar erros gramaticais, falta de coerência em textos longos e repetições.
Capacidades Limitadas: O modelo é um modelo fundacional e não foi especializado para tarefas específicas. Suas capacidades em tarefas como compreensão de leitura, resposta a perguntas ou conversação são limitadas.

Créditos

Modelo e código desenvolvido como parte de uma série de artigos por Fabricio Zillig

Linkedin: https://www.linkedin.com/in/fazillig/.
Github https://github.com/z-fab
Site: https://zfab.me

Repositório GitHub do Projeto:

https://github.com/z-fab/llm-zero

zfab
/

llmdozero