Treine seu próprio LLM semelhante ao ChatGPT com FlanT5 e Replicate

Com o crescimento de modelos LLM como ChatGPT, tem havido uma corrida por parte das empresas para comercializar aplicativos de aprendizagem profunda baseados em linguagem. Empresas como Duolingo e Blinkist estão construindo aplicativos de bate-papo educacionais, empresas como a Cocounsel estão construindo modelos de análise de documentos e algumas, como a MedGPT, estão até construindo modelos especializados que podem fazer coisas como diagnóstico médico. Em um artigo anterior, escrevi sobre como alguém pode usar ChatGPT e solicitar engenharia para construir um analisador de documentos avançado.

Para oferecer suporte a aplicativos LLM mais poderosos e específicos de domínio, os provedores de tecnologia disponibilizaram muitas soluções em nuvem. OpenAI, a empresa por trás do ChatGPT, por exemplo, disponibilizou aos usuários uma API de ajuste fino simples, mas poderosa, permitindo que eles construíssem seus próprios modelos de linguagem baseados na tecnologia GPT3. O Google, para não ficar para trás, disponibilizou seu modelo bison-text, amplamente considerado um concorrente capaz do GPT 3 e GPT 3.5, para ajuste fino por meio da plataforma Google Cloud. Em um artigo anterior, escrevi sobre como usar a API de ajuste fino para criar um LLM especialista em domínio.

Por mais poderosos que estes serviços possam ser, uma empresa que considere um investimento sério em tecnologia LLM quererá aprender a treinar os seus próprios modelos a partir de tecnologias de código aberto. Em comparação com o uso desses endpoints fornecidos pelo fornecedor, treinar seu próprio modelo oferece as seguintes vantagens :

• Você ganha flexibilidade para escolher e alterar sua infraestrutura de implantação. Isto pode levar a poupanças de custos, maior integração e, talvez o mais importante em aplicações médicas e financeiras, mais privacidade.
• Você obtém mais controle sobre a tecnologia subjacente, oferecendo opções de modelos de código aberto para usar. Diferentes modelos de código aberto são criados com diferentes casos de uso em mente, e você pode escolher a melhor ferramenta para o trabalho.
• Suas aplicações tornam-se mais preparadas para o futuro. Ao usar tecnologia de código aberto, você pode definir seu próprio ritmo de desenvolvimento. Você pode usar tecnologia de ponta e não terá que se preocupar com descontinuações de fornecedores e interrupções de serviço.

Neste artigo, pegaremos um modelo LLM de código aberto popular e capaz, treiná-lo-emos em nossos próprios dados, semelhante ao que fizemos em um artigo anterior, e validaremos os resultados. Embora o exemplo que estamos abordando não seja comercial e se baseie em informações públicas, as técnicas podem ser facilmente aplicadas de forma cruzada a empreendimentos comerciais. Iremos nos aprofundar em sugestões específicas sobre quais aplicações comerciais podem ser construídas usando esta técnica na seção “Modelo Expert LLM”, onde definimos o problema que iremos resolver neste artigo.

Tecnologias subjacentes

Flan-T5

Para o experimento de hoje, contaremos com o Flan-T5 Large, que é um modelo de linguagem grande lançado pelo Google. Embora esta não seja a tecnologia subjacente à Bard, este modelo é amplamente considerado competitivo com as tecnologias baseadas em GPT. O que é impressionante nos modelos Flan T5, entretanto, é que eles alcançam resultados satisfatórios usando muito menos parâmetros do que os modelos baseados em GPT. Mesmo a versão XL do modelo, por exemplo, possui apenas 3 bilhões de parâmetros, em comparação ao GPT3, que possui 175 bilhões.

Como resultado desta compacidade, é relativamente barato treinar e armazenar estes modelos em ativos de computação em nuvem. Além disso, a família de modelos Flan-T5 é lançada com a licença Apache, que permite o uso comercial, reduzindo possíveis dores de cabeça com licenças que acompanham alguns dos outros LLMs de código aberto. O LLaMa do Facebook, por exemplo, ainda está disponível apenas para pesquisa e para fins não comerciais.

Para escrever este artigo, experimentei algumas classes diferentes de tarefas para testar a eficácia da tecnologia. Geralmente, o Flan-T5, especialmente a variante XL, parece ter excelentes capacidades de compreensão de linguagem natural, semelhantes a alguns dos modelos GPT no mercado. No entanto, o modelo falha um pouco ao desenhar conexões abstratas e tem alguns problemas para gerar resultados longos. Portanto, deve-se ter o cuidado de selecionar o modelo certo para a tarefa certa.

Replicar

Replicate é uma empresa de plataforma como serviço que permite às pessoas alugar GPUs para treinar e executar grandes modelos de IA a um preço acessível. Seu conjunto de ferramentas de gerenciamento de modelos de IA permite que os usuários se concentrem em trabalhar com dados em vez de gerenciar recursos do servidor.

Para escrever este artigo, experimentei várias ofertas de PaaS de treinamento de IA, incluindo AWS SageMaker, Google Colab e PaperSpace Gradient. O Replicate foi de longe a plataforma mais fácil de começar e ofereceu preços muito competitivos em relação aos outros serviços mencionados.

Pitão

Python é a língua franca da engenharia de dados. O extenso ecossistema permite que os programadores ingiram, analisem e processem dados rapidamente. A maioria das principais plataformas de treinamento de IA tem suporte de primeira classe para Python, o que torna nosso trabalho muito mais fácil. Devido à excelente integração do Replicate, escreveremos todo o nosso código hoje em Python.

Modelo LLM Especialista

Classificador de dramaturgos

Como a família de modelos Flan-T5 é muito melhor na compreensão de texto do que na geração de texto, queremos escolher uma tarefa que tenha muita entrada, mas pouca saída. Classificadores de linguagem natural são um caso de uso perfeito para esse tipo de cenário, então hoje estaremos construindo um identificador de dramaturgo. Especificamente, daremos ao modelo passagens de William Shakespeare ou Anton Chekhov e veremos se podemos ensinar o modelo a identificar o dramaturgo com base no estilo de escrita e na escolha das palavras.

Claro, por se tratar de um tutorial público, escolhemos intencionalmente um modelo com dados públicos e de fácil acesso. No entanto, isto pode ser facilmente adaptado a um contexto comercial . Aqui estão alguns exemplos em que classificadores de linguagem natural podem ser úteis:

• Classificar comentários e reclamações de clientes em várias categorias, como problemas de envio, qualidade do produto, atendimento ao cliente, etc.
• Realizar análise de sentimento em uma transcrição de uma chamada de vendas para ver se o humor do cliente em potencial mudou durante a ligação.
• A análise de um grande número de transcrições de chamadas de lucros para determinar se os CEOs são geralmente otimistas ou pessimistas.

Construindo os dados de treinamento

Para criar os dados de treinamento, podemos baixar algumas peças de Anton Chekhov e William Shakespeare do Projeto Gutenberg. Para configurar a ingestão de dados, podemos executar o seguinte script Python.

 import requests import openai import replicate import os import pandas as pd import random texts = { 'chekhov': 'https://www.gutenberg.org/files/7986/7986-0.txt', 'chekhov_2': 'https://www.gutenberg.org/cache/epub/1755/pg1755.txt', 'shakespeare_midsummer': 'https://www.gutenberg.org/cache/epub/1514/pg1514.txt', 'shakespeare_romeo_juliet': 'https://www.gutenberg.org/cache/epub/1112/pg1112.txt', 'shakespeare_macbeth': 'https://www.gutenberg.org/cache/epub/2264/pg2264.txt', 'shakespeare_hamlet': 'https://www.gutenberg.org/cache/epub/2265/pg2265.txt', }

Agora criamos a pasta de dados de treinamento e baixamos os textos:

 if not os.path.exists('training_text'): os.mkdir('training_text') for name, url in texts.items(): print(name) res = requests.get(url) with open(os.path.join('training_text', '%s.txt' % name), 'w') as fp_write: fp_write.write(res.text)

Você deverá ver alguns resultados como este para mostrar que foi bem-sucedido:

 chekhov chekhov_2 shakespeare_midsummer shakespeare_romeo_juliet shakespeare_macbeth Shakespeare_hamlet

Você também pode verificar a pasta training_text para ver se os arquivos foram baixados corretamente.

Agora queremos ler esses arquivos de volta na memória e dividi-los em uma lista de linhas. Enquanto estamos nisso, contaremos o número de linhas em cada arquivo.

 lines_by_file = {} for fn in os.listdir('training_text'): if not fn.endswith('.txt'): continue with open(os.path.join('training_text', fn)) as fp_file: lines_by_file[fn.split('.')[0]] = '\n'.join(fp_file.readlines()) print(fn, len(lines_by_file[fn.split('.')[0]]))

Você deverá ver uma saída como a abaixo:

 shakespeare_midsummer.txt 120198 shakespeare_romeo_juliet.txt 179726 shakespeare_macbeth.txt 140022 shakespeare_hamlet.txt 204169 chekhov.txt 419063 chekhov_2.txt 148324

Agora vem a parte divertida. Queremos dividir as linhas em dados reais de treinamento. Para isso, primeiro removemos a primeira e a última 1000 linhas, que são ocupadas pelo conteúdo da introdução, cabeçalho e rodapé. Então, pegaremos o texto restante 50 linhas de cada vez. Em seguida, transformaremos as 50 linhas em um par de prompt e conclusão.

 train_data = [] for k in lines_by_file: is_chekhov = 'chekhov' in k useful_lines = lines_by_file[k].split('\n')[1000:-1000] prompt_fmt = "Which playwright wrote the following passage? \n ==== \n %s \n ====" for i in range(0, len(useful_lines), 50): training_set = useful_lines[i: i+50] train_data.append({ 'prompt': prompt_fmt % '\n'.join(training_set), 'completion': 'Anton Chekhov' if is_chekhov else 'William Shakespeare' })

Portanto, agora definimos claramente o problema - dadas 50 linhas de texto de uma peça, determine se o dramaturgo é Anton Chekov ou William Shakespeare. Ainda não terminamos. Precisamos escrever os dados no formato jsonl (Linhas JSON) para treinamento e também queremos reservar algumas amostras para fins de teste. Execute o seguinte código assim:

 df = pd.DataFrame(train_data) df_chekhov = df[df['completion'] == 'Anton Chekhov'] df_shakespeare = df[df['completion'] == 'William Shakespeare'] chekhov_test_indices = random.sample(df_chekhov.index.tolist(), 15) shakespeare_test_indices = random.sample(df_shakespeare.index.tolist(), 15) df_chekhov_test = df_chekhov.loc[chekhov_test_indices] df_shakespeare_test = df_shakespeare.loc[shakespeare_test_indices] df_chekhov_train = df_chekhov.loc[[i for i in df_chekhov.index if i not in chekhov_test_indices]] df_shakespeare_train = df_shakespeare.loc[[i for i in df_shakespeare.index if i not in shakespeare_test_indices]] pd.concat([df_chekhov_train, df_shakespeare_train]).to_json('chekhov_shakespeare_train.jsonl', orient='records', lines=True) pd.concat([df_chekhov_test, df_shakespeare_test]).to_json('chekhov_shakespeare_test.jsonl', orient='records', lines=True)

Claro, se quiser usar todo o corpus para treinamento, você pode simplesmente executar

pd.DataFrame(train_data).to_json('output.jsonl', orient='records', lines=True) .

Treinamento com replicação

Precisamos fazer duas coisas antes de podermos invocar o treinamento: primeiro, precisamos carregar os dados de treinamento em algum lugar acessível por replicação. Uma maneira muito fácil de fazer isso seria fazer upload do arquivo para um bucket do Google Cloud, tornar o bucket e o arquivo públicos e fornecer o URL no formato https://storage.googleapis.com/<bucket_name>/<file_name> .

Em seguida, precisamos criar um destino. Para fazer isso, basta fazer login no Replicate (o que você pode fazer através do Github OAuth) e criar um novo modelo. Depois que o modelo for criado e nomeado, você poderá enviá-lo para este espaço.

Depois que tudo estiver configurado, você pode iniciar o treinamento assim:

 training = replicate.trainings.create( version="[flant5-large location]", input={ "train_data": "[Data Location]", }, destination="[Destination]" ) print(training)

Você deverá ver alguma saída informando que o treinamento está começando. Aguarde alguns minutos e volte ao treinamento executando o seguinte código:

 training.reload() print(training)

Você também pode monitorar o progresso do treinamento no site do Replicate. Assim que o treinamento for concluído, você pode recarregar o objeto de treinamento para obter o nome da saída e prosseguir para a próxima etapa.

Esteja avisado que há períodos em que os recursos da GPU são escassos e você pode receber um erro de “falha no treinamento”. Se isso acontecer com você, espere algumas horas e tente novamente. Há uma escassez de GPU e os provedores de PaaS não estão imunes!

Testando o modelo

Tudo bem! Agora que temos nosso modelo ajustado, precisamos testá-lo. Lembre-se de que reservamos 15 passagens de Tchekhov e Shakespeare para teste. Podemos usá-los aqui assim:

 for _, row in df_chekhov_test.iterrows(): output = replicate.run( training.output["version"], input={"prompt": row['prompt']} ) for s in output: print(s, end="", flush=True) print('')

Após um curto período de inicialização, você deverá ver a saída sendo impressa no console. O modelo deve ser extremamente preciso e retornar “Anton Chekhov” todas as vezes. Vamos tentar isso com Shakespeare:

 for _, row in df_shakespeare_test.iterrows(): output = replicate.run( training.output["version"], input={"prompt": row['prompt']} ) for s in output: print(s, end="", flush=True) print('')

Semelhante ao exemplo de Chekhov, você verá que o modelo é sempre capaz de identificar Shakespeare.

Para garantir, vamos ver se o modelo básico é capaz de identificar Shakespeare ou Chekhov:

 for _, row in df_shakespeare_test.iterrows(): output = replicate.run( "[base flant5-large location]", input={"prompt": row['prompt']} ) for s in output: print(s, end="", flush=True) print('') for _, row in df_chekhov_test.iterrows(): output = replicate.run( "[base flant5-large location]", input={"prompt": row['prompt']} ) for s in output: print(s, end="", flush=True) print('')

Você verá que o modelo básico não é capaz de identificar com segurança o dramaturgo nas mesmas passagens. Isso mostra que nosso ajuste fino forneceu novas informações ao modelo de maneira confiável, e construímos para nós mesmos um classificador de dramaturgos em linguagem natural!

Conclusão

No artigo de hoje, treinamos um classificador de linguagem natural simples baseado em Flan-T5, um grande modelo de linguagem fornecido pelo Google. Devido ao seu tamanho compacto e licença permissiva, o Flan-T5 pode ser treinado e implantado em infraestrutura privada, o que o diferencia de muitos outros modelos populares no mercado, como o ChatGPT.

Embora o exemplo atual tenha sido baseado em dados públicos e decididamente não comercial, esta prova de conceito pode ser facilmente adaptada a muitas outras aplicações comerciais, conforme descrito acima. Se você tem uma ideia com LLMs que gostaria de ver transformada em realidade, sinta-se à vontade para iniciar uma conversa visitando minha página no GitHub ou no LinkedIn . Além disso, sinta-se à vontade para ler meus artigos anteriores do LLM, incluindo um sobre Construindo um Analisador de Documentos usando ChatGPT e Criando um LLM de Especialista em Domínio usando a API de ajuste fino da OpenAI .

Feliz hacking!