minGPT

mente

Uma reimplementação PyTorch do GPT, tanto treinamento quanto inferência. minGPT tenta ser pequeno, limpo, interpretável e educacional, já que a maioria das implementações de modelo GPT atualmente disponíveis podem ser um pouco extensas. GPT não é um modelo complicado e esta implementação tem aproximadamente 300 linhas de código (consulte mingpt/model.py). Tudo o que acontece é que uma sequência de índices alimenta um Transformer e uma distribuição de probabilidade sobre o próximo índice da sequência é exibida. A maior parte da complexidade está apenas em ser inteligente com o lote (tanto entre exemplos quanto no comprimento da sequência) para obter eficiência.

nota (janeiro de 2023) : embora eu possa continuar a aceitar e alterar alguns detalhes, o minGPT está em um estado semi-arquivado. Para desenvolvimentos mais recentes, veja minha reescrita nanoGPT. Basicamente, o minGPT passou a ser referenciado em uma ampla variedade de lugares (cadernos, blogs, cursos, livros, etc.), o que me deixou menos disposto a fazer as mudanças maiores que eu queria fazer para levar o código adiante. Eu também queria mudar um pouco a direção, de um foco exclusivo na educação para algo que ainda é simples e hackeável, mas tem força (reproduz benchmarks da indústria de médio porte, aceita algumas compensações para ganhar eficiência de tempo de execução, etc.).

A biblioteca minGPT consiste em três arquivos: mingpt/model.py contém a definição real do modelo do Transformer, mingpt/bpe.py contém um codificador de pares de bytes levemente refatorado que traduz entre texto e sequências de números inteiros exatamente como o OpenAI fez no GPT, mingpt/trainer. py é um código padrão PyTorch (independente de GPT) que treina o modelo. Depois, há uma série de demonstrações e projetos que usam a biblioteca na pasta de projects :

projects/adder treina um GPT do zero para adicionar números (inspirado na seção de adição no artigo GPT-3)
projects/chargpt treina um GPT para ser um modelo de linguagem em nível de caractere em algum arquivo de texto de entrada
demo.ipynb mostra um uso mínimo do GPT e Trainer em formato de notebook em um exemplo simples de classificação
generate.ipynb mostra como alguém pode carregar um GPT2 pré-treinado e gerar texto com base em algum prompt

Instalação da Biblioteca

Se você deseja import mingpt para o seu projeto:

 git clone https://github.com/karpathy/minGPT.git
cd minGPT
pip install -e .

Uso

Veja como você instanciaria um GPT-2 (versão de parâmetros de 124M):

 from mingpt . model import GPT
model_config = GPT . get_default_config ()
model_config . model_type = 'gpt2'
model_config . vocab_size = 50257 # openai's model vocabulary
model_config . block_size = 1024  # openai's model block_size (i.e. input context length)
model = GPT ( model_config )

E aqui está como você treinaria:

 # your subclass of torch.utils.data.Dataset that emits example
# torch LongTensor of lengths up to 1024, with integers from [0,50257)
train_dataset = YourDataset ()

from mingpt . trainer import Trainer
train_config = Trainer . get_default_config ()
train_config . learning_rate = 5e-4 # many possible options, see the file
train_config . max_iters = 1000
train_config . batch_size = 32
trainer = Trainer ( train_config , model , train_dataset )
trainer . run ()

Veja demo.ipynb para um exemplo mais concreto.

Testes unitários

A cobertura ainda não é incrível, mas:

 python -m unittest discover tests

todos

adicione demonstração de ajuste fino do gpt-2 em um arquivo de texto arbitrário
adicionar demonstração do agente de diálogo
melhores documentos de resultados para projetos existentes (adder, chargpt)
adicione precisão mista e itens de escalonamento de treinamento relacionados
suporte de treinamento distribuído
reproduzir alguns benchmarks em projetos/, por exemplo, texto8 ou outra modelagem de linguagem
registro adequado em vez de imprimir declaração hora amadora haha
eu provavelmente deveria ter um arquivo requirements.txt ...
deve ser possível carregar muitos outros pesos de modelo além de apenas gpt2-*

Referências

Código:

openai/gpt-2 tem a definição do modelo no TensorFlow, mas não o código de treinamento
openai/image-gpt tem algumas modificações mais modernas do tipo gpt-3 em seu código, boa referência também
huggingface/transformers tem um exemplo de modelagem de linguagem. É completo, mas, como resultado, também é um tanto difícil de rastrear. Por exemplo, algumas funções grandes têm até 90% de código não utilizado por trás de várias instruções de ramificação que não são utilizadas na configuração padrão da modelagem de linguagem simples

Artigos + algumas notas de implementação:

Melhorando a compreensão do idioma por meio do pré-treinamento generativo (GPT-1)

Nosso modelo segue em grande parte o trabalho original do transformador
Treinamos um transformador somente decodificador de 12 camadas com cabeças de autoatenção mascaradas (768 estados dimensionais e 12 cabeças de atenção). Para as redes feed-forward posicionadas, usamos 3.072 estados internos dimensionais.
Taxa máxima de aprendizado de Adam de 2,5e-4. (posteriormente GPT-3 para este tamanho de modelo usa 6e-4)
Decaimento LR: aumentado linearmente de zero nas primeiras 2.000 atualizações e recozido para 0 usando uma programação de cosseno
Treinamos por 100 épocas em minilotes de 64 sequências contíguas amostradas aleatoriamente de 512 tokens.
Como o padrão de camada é usado extensivamente em todo o modelo, uma simples inicialização de peso de N(0, 0,02) foi suficiente
Vocabulário de codificação de bytes (BPE) com 40.000 fusões
resíduos, incorporação e abandono de atenção com taxa de 0,1 para regularização.
versão modificada da regularização L2 proposta em (37), com w = 0,01 em todos os pesos de não viés ou ganho
Para a função de ativação, utilizou-se a Unidade Linear de Erro Gaussiano (GELU).
Usamos embeddings de posição aprendida em vez da versão senoidal proposta no trabalho original
Para ajuste fino: adicionamos dropout ao classificador com uma taxa de 0,1. taxa de aprendizado de 6,25e-5 e tamanho de lote de 32,3 épocas. Usamos um cronograma de redução da taxa de aprendizagem linear com aquecimento superior a 0,2% do treinamento. λ foi definido como 0,5.
O modelo GPT-1 tem 12 camadas e d_model 768, ~ 117 milhões de parâmetros

Modelos de linguagem são alunos multitarefa não supervisionados (GPT-2)

LayerNorm foi movido para a entrada de cada subbloco, semelhante a uma rede residual de pré-ativação
uma normalização de camada adicional foi adicionada após o bloco final de autoatenção.
é usada a inicialização modificada que leva em conta o acúmulo no caminho residual com a profundidade do modelo. Escalamos os pesos das camadas residuais na inicialização por um fator de 1/√N, onde N é o número de camadas residuais. (estranho porque no código lançado só consigo encontrar um uso simples do antigo 0.02... no lançamento do image-gpt achei usado para c_proj, e mesmo assim apenas para attn, não para mlp. hein. https: //github.com/openai/image-gpt/blob/master/src/model.py)
o vocabulário é expandido para 50.257
aumentar o tamanho do contexto de 512 para 1.024 tokens
tamanho de lote maior de 512 é usado
GPT-2 usou 48 camadas e d_model 1600 (vs. 12 camadas originais e d_model 768). ~1.542B parâmetros

Modelos de linguagem são aprendizes rápidos (GPT-3)

GPT-3: 96 camadas, 96 cabeçotes, com d_model de 12.288 (parâmetros 175B).
Tipo GPT-1: 12 camadas, 12 cabeças, d_model 768 (125M)
Usamos o mesmo modelo e arquitetura do GPT-2, incluindo a inicialização modificada, a pré-normalização e a tokenização reversível descritas nele
usamos padrões alternados de atenção esparsa densa e localmente bandada nas camadas do transformador, semelhante ao Transformador Esparso
sempre temos a camada feedforward quatro vezes o tamanho da camada gargalo, dff = 4 ∗ dmodel
todos os modelos usam uma janela de contexto de tokens nctx = 2048.
Adam com β1 = 0,9, β2 = 0,95 e eps = 10−8
Todos os modelos usam redução de peso de 0,1 para fornecer uma pequena quantidade de regularização. (NOTA: GPT-1 usou 0,01, acredito, veja acima)
cortar a norma global do gradiente em 1,0
Aquecimento linear LR sobre os primeiros 375 milhões de tokens. Em seguida, use o decaimento do cosseno para reduzir a taxa de aprendizagem para 10% do seu valor, mais de 260 bilhões de tokens.
aumentar gradualmente o tamanho do lote linearmente de um valor pequeno (32 mil tokens) para o valor total ao longo dos primeiros 4-12 bilhões de tokens de treinamento, dependendo do tamanho do modelo.
janela de contexto de tempo completa de tamanho 2048 é sempre usada, com um delimitador de token especial END OF DOCUMENT

Pré-treinamento generativo de pixels (imagem GPT)

Ao trabalhar com imagens, escolhemos a permutação de identidade πi = i para 1 ≤ i ≤ n, também conhecida como ordem raster.
criamos nossa própria paleta de cores de 9 bits agrupando valores de pixel (R, G, B) usando k-means com k = 512.
Nosso maior modelo, iGPT-XL, contém L = 60 camadas e usa um tamanho de incorporação de d = 3072 para um total de 6,8B de parâmetros.
Nosso próximo maior modelo, iGPT-L, é essencialmente idêntico ao GPT-2 com L = 48 camadas, mas contém um tamanho de incorporação ligeiramente menor de d = 1536 (vs 1600) para um total de parâmetros de 1,4B.
Usamos o mesmo código de modelo do GPT-2, exceto que inicializamos os pesos de maneira dependente da camada, como no Sparse Transformer (Child et al., 2019) e inicializamos com zero todas as projeções produzindo logits.
Também treinamos iGPT-M, um modelo de parâmetro 455M com L = 36 e d = 1024
iGPT-S, um modelo de parâmetros de 76M com L = 24 e d = 512 (ok, e quantas cabeças? Parece o código do Github afirma 8)
Ao pré-treinar o iGPT-XL, usamos um tamanho de lote de 64 e treinamos para 2 milhões de iterações, e para todos os outros modelos usamos um tamanho de lote de 128 e treinamos para 1 milhão de iterações.
Adão com β1 = 0,9 e β2 = 0,95
A taxa de aprendizagem é aquecida por uma época e depois decai para 0
Não usamos redução de peso porque aplicar uma pequena redução de peso de 0,01 não alterou a qualidade da representação.
iGPT-S lr 0,003
Nenhuma desistência é usada.