gpt 2 simple - gpt 2 simple de código fonte

gpt 2 simple

Outro código-fonte

v0.8.1: Tensor

Baixar

GPT-2-Simple

gen_demo

Um pacote simples de python que envolve scripts de ajuste fino e geração existentes para o modelo de geração de texto GPT-2 do OpenAI (especificamente as versões hiperparameter "Small" 124M e "Medium" 355M). Além disso, este pacote permite uma geração mais fácil de texto, gerando um arquivo para facilitar a curadoria, permitindo que os prefixos forcem o texto a começar com uma determinada frase.

Este pacote incorpora e faz alterações mínimas de baixo nível para:

Gerenciamento de modelos do repo oficial do OpenAI (licença do MIT)
Modelo Finetuning do Fork of GPT-2 de Neil Shepperd (MIT Licença)
Gerenciamento de saída de geração de texto da textgenrnn (MIT License / também criado por mim)

Para o Finetuning, é altamente recomendável usar uma GPU, embora você possa gerar usando uma CPU (embora muito mais lentamente). Se você estiver treinando na nuvem, o uso de um notebook colaboratório ou uma VM do Google Compute Engine com a imagem de aprendizado profundo do TensorFlow é fortemente recomendado. (Como o modelo GPT-2 está hospedado no GCP)

Você pode usar o GPT-2-SIMPLE para treinar um modelo usando uma GPU gratuitamente neste notebook colaboratório, que também demos recursos adicionais do pacote.

NOTA: O desenvolvimento do GPT-2-SIMPLE foi substituído pela AITEXTGEN, que possui recursos semelhantes de geração de texto com AI com tempo de treinamento mais eficiente e uso de recursos. Se você não precisar de usar o TensorFlow, recomendo usar o AITEXTGEN. Os pontos de verificação treinados usando GPT-2-SIMPLE também podem ser carregados usando o AITEXTGEN.

Instalar

GPT-2-SIMPLE pode ser instalado via Pypi:

pip3 install gpt-2-simple

Você também precisará instalar a versão TensorFlow 2.x correspondente (min 2.5.1) para o seu sistema (por exemplo, tensorflow ou tensorflow-gpu ).

Uso

Um exemplo para baixar o modelo para o sistema local, Finetuning -o em um conjunto de dados. e gerando algum texto.

AVISO: O modelo de 124m pré -treinado e, portanto, qualquer modelo FinetUned é de 500 MB! (O modelo de 355m pré -treinado é de 1,5 GB)

 import gpt_2_simple as gpt2
import os
import requests

model_name = "124M"
if not os . path . isdir ( os . path . join ( "models" , model_name )):
	print ( f"Downloading { model_name } model..." )
	gpt2 . download_gpt2 ( model_name = model_name )   # model is saved into current directory under /models/124M/


file_name = "shakespeare.txt"
if not os . path . isfile ( file_name ):
	url = "https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt"
	data = requests . get ( url )

	with open ( file_name , 'w' ) as f :
		f . write ( data . text )


sess = gpt2 . start_tf_sess ()
gpt2 . finetune ( sess ,
              file_name ,
              model_name = model_name ,
              steps = 1000 )   # steps is max number of training steps

gpt2 . generate ( sess )

Os pontos de verificação do modelo gerado são por padrão /checkpoint/run1 . Se você deseja carregar um modelo dessa pasta e gerar texto a partir dela:

 import gpt_2_simple as gpt2

sess = gpt2 . start_tf_sess ()
gpt2 . load_gpt2 ( sess )

gpt2 . generate ( sess )

Como no TextGenRNN, você pode gerar e salvar texto para uso posterior (por exemplo, uma API ou um bot) usando o parâmetro return_as_list .

 single_text = gpt2 . generate ( sess , return_as_list = True )[ 0 ]
print ( single_text )

Você pode passar um parâmetro run_name para finetune e load_gpt2 se desejar armazenar/carregar vários modelos em uma pasta checkpoint .

Há também uma interface de linha de comando para finetuning e geração com fortes padrões para executar apenas uma VM em nuvem com GPU. Para finetuning (que também baixará o modelo, se não estiver presente):

gpt_2_simple finetune shakespeare.txt

E para a geração, que gera textos para arquivos em uma pasta gen :

gpt_2_simple generate

A maioria dos mesmos parâmetros disponíveis nas funções está disponível como argumentos da CLI, por exemplo:

gpt_2_simple generate --temperature 1.0 --nsamples 20 --batch_size 20 --length 50 --prefix " <|startoftext|> " --truncate " <|endoftext|> " --include_prefix False --nfiles 5

Veja abaixo para ver o que alguns dos argumentos da CLI fazem.

NB: reinicie a sessão do Python primeiro se você deseja o Finetune em outro conjunto de dados ou carregue outro modelo.

Diferenças entre GPT-2-Simple e outros utilitários de geração de texto

O método que o GPT-2 usa para gerar texto é um pouco diferente daqueles como outros pacotes como o TextGenRNN (especificamente, gerando a sequência de texto completa puramente na GPU e decodificando-a posteriormente), que não pode ser facilmente fixada sem hackear o código do modelo subjacente. Como resultado:

Em geral, o GPT-2 é melhor em manter o contexto durante todo o comprimento da geração, tornando-o bom para gerar texto de conversação. O texto também é geralmente correto gramaticamente, com capitalização adequada e poucos erros de digitação.
O modelo GPT-2 original foi treinado em uma variedade muito grande de fontes, permitindo que o modelo incorpore idiomas não vistos no texto de entrada.
O GPT-2 pode gerar apenas um máximo de 1024 tokens por solicitação (cerca de 3-4 parágrafos de texto em inglês).
O GPT-2 não pode parar cedo para atingir um token final específico. (Solução alternativa: passe o parâmetro truncate para uma função generate apenas para coletar texto até um token final especificado. Você pode reduzir length adequadamente.)
As temperaturas mais altas funcionam melhor (por exemplo, 0,7 - 1,0) para gerar texto mais interessante, enquanto outras estruturas funcionam melhor entre 0,2 e 0,5.
Ao Finetuning GPT-2, ele não tem sentido do início ou final de um documento dentro de um texto maior. Você precisará usar uma sequência de caracteres sob medida para indicar o início e o final de um documento. Então, ao gerar, você pode especificar um prefix direcionado às seqüências de token iniciantes e um truncate direcionado à sequência de token final. Você também pode definir include_prefix=False para descartar o token prefixo ao gerar (por exemplo, se for algo indesejado como <|startoftext|> ).
Se você passar por um arquivo .csv em uma coluna única para finetune() , ele analisará automaticamente o CSV em um formato ideal para treinamento com GPT-2 (incluindo a pré-adolescente <|startoftext|> e sufixo <|endoftext|> para todos os documentos de texto, para que os truques truncate acima sejam úteis ao gerar saída). Isso é necessário para lidar com as citações e as novas linhas em cada documento de texto corretamente.
O GPT-2 permite gerar textos em paralelo, definindo um batch_size divisível em nsamples , resultando em geração muito mais rápida. Funciona muito bem com uma GPU (pode definir batch_size até 20 no K80 do Colaboratório)!
Devido à arquitetura do GPT-2, ele escala bem com GPUs mais poderosas. Para o modelo 124M, se você deseja treinar por períodos mais longos, a GPU P100 do GCP é cerca de 3x mais rápido que um K80/T4 por apenas 3x o preço, tornando-o comparável ao preço (o V100 é cerca de 1,5x mais rápido que o P100, mas cerca de 2x o preço). O P100 usa 100% da GPU mesmo com batch_size=1 e cerca de 88% da GPU V100.
Se você possui um modelo GPT-2 parcialmente treinado e deseja continuar o Finetuning, poderá definir overwrite=True como FineTune, que continuará treinando e removerá a iteração anterior do modelo sem criar uma cópia duplicada. Isso pode ser especialmente útil para o aprendizado de transferência (por exemplo, fortemente Finetune GPT-2 em um conjunto de dados e, em seguida, o FineTune em outro conjunto de dados para obter uma "fusão" de ambos os conjuntos de dados).
Se o seu conjunto de dados de texto de entrada for enorme (> 100 MB), convém pré -codificar e compactar o conjunto de dados usando gpt2.encode_dataset(file_path) . A saída é um arquivo .npz compactado que carregará muito mais rápido na GPU para o Finetuning.
O modelo "grande" de 774m pode suportar o Finetuning, pois fará com que as GPUs modernas fiquem fora da memória (você pode ter sorte se usar uma GPU P100 no colaboratório). No entanto, você ainda pode gerar a partir do modelo pré -traido padrão usando gpt2.load_gpt2(sess, model_name='774M') e gpt2.generate(sess, model_name='774M') .
O modelo "extra grande" de 1558m, pode não funcionar pronto para uso com a GPU incluída no caderno colaboratório. Mais testes são necessários para identificar configurações ideais para ele.

Aplicativos interativos usando GPT-2-Simple

Gpt2-Small-App usando o modelo padrão GPT-2 de 124m pré-teria
GPT2-REDDIT-APP para gerar títulos do Reddit com base em um subreddit especificado e/ou palavras-chave (s)
GPT2-MTG-APP para gerar magia: os cartões de coleta

Exemplos de geração de texto usando GPT-2-Simple

Resetera - Gerated Video Game Forum Discussões (Github com despejos)
/R/LegalAdvice - Geração do título (Github com despejos)
Hacker News - Dezenas de milhares de títulos de envio de notícias de hackers gerados

Mantenedor/criador

Max Woolf (@Minimaxir)

Os projetos de código aberto de Max são apoiados por seu Patreon. Se você achou esse projeto útil, quaisquer contribuições monetárias para o Patreon serão apreciadas e serão usadas com bom uso criativo.