minGPT TF

minGPT-TF

Uma reimplementação do TensorFlow do mingpt

Cadernos

play_math.ipynb e play_char.ipynb treinados em colab. Os links estão na parte superior de cada notebook para treinar o modelo em colab. play_char.ipynb notebook batch_size é reduzido para caber na memória GPU colab. Altere os parâmetros de acordo com a memória da GPU.

minGPT - Leiame

Uma reimplementação PyTorch do treinamento GPT. O minGPT tenta ser pequeno, limpo, interpretável e educativo, já que a maioria dos atualmente disponíveis são um pouco extensos. GPT não é um modelo complicado e esta implementação tem aproximadamente 300 linhas de código, incluindo clichê e um módulo de autoatenção causal personalizado totalmente desnecessário. De qualquer forma, tudo o que acontece é que uma sequência de índices entra em uma sequência de blocos transformadores e surge uma distribuição de probabilidade do próximo índice. O resto da complexidade é apenas ser inteligente com o lote (tanto entre exemplos quanto no comprimento da sequência) para que o treinamento seja eficiente.

A "biblioteca" principal do minGPT (hah) consiste em dois arquivos: mingpt/model.py contém a definição real do modelo do Transformer e mingpt/trainer.py é o padrão PyTorch (independente de GPT) que treina o modelo. Os notebooks Jupyter anexados mostram como a "biblioteca" (hah) pode ser usada para treinar modelos de sequência:

• play_math.ipynb treina um GPT focado em adição (inspirado na seção de adição no artigo GPT-3)
• play_char.ipynb treina um GPT para ser um modelo de linguagem em nível de caractere em texto arbitrário, semelhante ao meu antigo char-rnn, mas com um transformador em vez de um RNN
• play_words.ipynb uma versão BPE que ainda não existe

Com um codificador bpe, treinamento distribuído e talvez fp16, esta implementação pode ser capaz de reproduzir resultados GPT-1/GPT-2, embora eu não tenha tentado $$$. O GPT-3 provavelmente está fora de alcance, pois entendo que ele não cabe na memória da GPU e requer um tratamento paralelo de modelo mais cuidadoso.

Exemplo de uso

Este código é simples o suficiente para hackear inline, não "usado", mas a API atual se parece com:

 # you're on your own to define a class that returns individual examples as PyTorch LongTensors
from torch . utils . data import Dataset
train_dataset = MyDataset (...)
test_dataset = MyDataset (...)

# construct a GPT model
from mingpt . model import GPT , GPTConfig
mconf = GPTConfig ( vocab_size , block_size , n_layer = 12 , n_head = 12 , n_embd = 768 ) # a GPT-1
model = GPT ( mconf )

# construct a trainer
from mingpt . trainer import Trainer , TrainerConfig
tconf = TrainerConfig ( max_epochs = 10 , batch_size = 256 )
trainer = Trainer ( model , train_dataset , test_dataset , tconf )
trainer . train ()
# (... enjoy the show for a while... )

# sample from the model (the [None, ...] and [0] are to push/pop a needed dummy batch dimension)
from mingpt . utils import sample
x = torch . tensor ([ 1 , 2 , 3 ], dtype = torch . long )[ None , ...] # context conditioning
y = sample ( model , x , steps = 30 , temperature = 1.0 , sample = True , top_k = 5 )[ 0 ]
print ( y ) # our model filled in the integer sequence with 30 additional likely integers

Referências

Código:

• openai/gpt-2 tem o modelo, mas não o código de treinamento, e no TensorFlow
• 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

Licença

MIT