Melhorando a Eficiência do Modelo de Linguagem Através da Predição de Mudanças
Um método pra melhorar as tarefas do modelo de linguagem prevendo as mudanças necessárias em vez de gerar textos inteiros.
― 5 min ler
Modelos de linguagem grandes (LLMs) são sistemas de computador que conseguem analisar e gerar linguagem humana. Esses modelos chamaram bastante atenção porque se saem bem em várias tarefas relacionadas à linguagem. LLMs são especialmente úteis em tarefas onde a maior parte do texto não muda, tipo corrigir gramática ou ajustar a formalidade de um texto. Mas, criar uma nova versão do texto pode ser lento e ineficiente, especialmente se o modelo gera palavras desnecessárias.
Esse artigo fala sobre um método para acelerar essas tarefas prevendo mudanças em vez de gerar todo o texto. Focando só no que precisa mudar, dá pra reduzir a quantidade de texto que o modelo precisa trabalhar. Isso também pode levar a tempos de processamento mais rápidos e menos custo computacional.
A ideia principal é identificar edições específicas que o texto precisa e representá-las como mudanças, em vez de gerar cada palavra. Assim, conseguimos manter o texto original quase intacto, mudando só as partes necessárias. Essa abordagem pode resultar numa redução significativa no tamanho do novo texto.
Pra ensinar o modelo a prever essas mudanças, usamos um método chamado ajuste por instrução. Esse processo faz com que o modelo aprenda a responder melhor a várias instruções. Treinamos os modelos com dados que incluíam tanto os textos originais quanto as mudanças necessárias. Os resultados dos testes mostraram que esse novo método performou tão bem quanto os métodos tradicionais.
Em tarefas de transdução de sequência local, como Correção gramatical e transferência de estilo, só pequenas partes do texto original são modificadas. Por exemplo, se começamos com a frase "O gato está no tapete" e queremos mudar para "O gato estava no tapete", a mudança é pequena. Em vez de recriar a frase toda, podemos simplesmente identificar que "está" deve se tornar "estava."
Usando esse método, conseguimos focar só nas mudanças importantes. Isso diminui a quantidade total de texto que o modelo gera, o que também diminui o tempo que leva pra processar o texto. Ao omitir partes do texto que não mudam, tornamos a tarefa mais eficiente.
Pra extrair as mudanças necessárias dos textos de origem e destino, buscamos alinhações entre os dois. Esse processo envolve identificar quais palavras correspondem entre os dois textos. Usando informações linguísticas, conseguimos alinhar palavras não só com base na posição, mas também no significado e papel gramatical. Isso leva a uma identificação mais precisa das mudanças.
Uma vez que temos as mudanças, ensinamos os LLMs a produzir um conjunto de instruções indicando as posições de início e fim das mudanças, além de quaisquer novas palavras que forem necessárias. A saída pode ser processada usando regras simples pra converter essas instruções de volta em texto simples.
Testamos essa nova abordagem em várias tarefas, incluindo correção gramatical, paráfrase, ajuste de estilo e simplificação de texto. O método apresentou resultados promissores, igualando o desempenho das abordagens tradicionais e reduzindo a quantidade de texto gerado.
Nos nossos experimentos, comparamos o desempenho dos modelos treinados usando a abordagem tradicional com aqueles treinados usando nosso método proposto. A maioria dos modelos que usou o novo método performou tão bem quanto aqueles que geraram o texto alvo diretamente. Isso demonstra que prever mudanças leva a uma forma eficiente e eficaz de processar linguagem.
Uma parte importante desse estudo foi a capacidade de manter o desempenho em outros tipos de tarefas, especialmente as abertas. Como as tarefas em questão geralmente usam texto simples enquanto nossas mudanças podem criar um formato diferente, foi essencial garantir que não houvesse impacto negativo no desempenho. Combinamos dados de tarefas de transdução de sequência local e tarefas abertas pra manter um equilíbrio.
Dividimos nossos dados em um conjunto de treinamento e um conjunto de avaliação pra observar como os modelos se saíram. Os resultados mostraram que combinar múltiplos tipos de tarefas ajudou os modelos a manter um desempenho forte de modo geral.
Também analisamos como as edições feitas pelo modelo correspondiam às mudanças identificadas pelo nosso processo de alinhamento. Um alto nível de concordância foi encontrado, confirmando que o modelo aprendeu a identificar mudanças úteis através do treinamento. Essa capacidade de prever com precisão as edições necessárias sugere que nosso método é uma abordagem valiosa.
Pra testar ainda mais a eficácia do nosso método, ajustamos modelos especificamente pra cada tarefa. Esse treinamento envolveu apresentar aos modelos apenas os textos originais e suas edições necessárias. Os modelos ajustados mostraram um desempenho ainda melhor comparado a estudos anteriores, indicando que nossa abordagem é adequada para tarefas especializadas.
Ao concentrar nas partes do texto que precisam ser mudadas em vez de gerar tudo do zero, conseguimos reduzir significativamente tanto a quantidade de texto produzido quanto o custo computacional. Essa abordagem representa um passo promissor na eficiência dos LLMs, especialmente em tarefas onde só algumas mudanças são necessárias.
Em resumo, treinar LLMs pra prever operações de edição em vez de gerar textos alvo inteiros pode levar a reduções significativas tanto no comprimento do texto quanto no tempo de processamento. Nossos experimentos mostram que esse método não compromete a precisão e pode ajudar esses modelos a manter desempenho em várias tarefas, incluindo as abertas. À medida que os modelos de linguagem continuam a crescer em tamanho e poder, explorar métodos eficientes será essencial pra sua aplicação em cenários do mundo real.
Título: Reducing Sequence Length by Predicting Edit Operations with Large Language Models
Resumo: Large Language Models (LLMs) have demonstrated remarkable performance in various tasks and gained significant attention. LLMs are also used for local sequence transduction tasks, including grammatical error correction (GEC) and formality style transfer, where most tokens in a source text are kept unchanged. However, the models that generate all target tokens in such tasks have a tendency to simply copy the input text as is, without making needed changes, because the difference between input and output texts is minimal in the training data. This is also inefficient because the computational cost grows quadratically with the target sequence length with Transformer. This paper proposes predicting edit spans for the source text for local sequence transduction tasks. Representing an edit span with a position of the source text and corrected tokens, we can reduce the length of the target sequence and the computational cost for inference. We apply instruction tuning for LLMs on the supervision data of edit spans. Experiments show that the proposed method achieves comparable performance to the baseline in four tasks, paraphrasing, formality style transfer, GEC, and text simplification, despite reducing the length of the target text by as small as 21%. Furthermore, we report that the task-specific fine-tuning with the proposed method achieved state-of-the-art performance in the four tasks.
Autores: Masahiro Kaneko, Naoaki Okazaki
Última atualização: 2023-10-20 00:00:00
Idioma: English
Fonte URL: https://arxiv.org/abs/2305.11862
Fonte PDF: https://arxiv.org/pdf/2305.11862
Licença: https://creativecommons.org/licenses/by/4.0/
Alterações: Este resumo foi elaborado com a assistência da AI e pode conter imprecisões. Para obter informações exactas, consulte os documentos originais ligados aqui.
Obrigado ao arxiv pela utilização da sua interoperabilidade de acesso aberto.
Ligações de referência
- https://www.latex-project.org/help/documentation/encguide.pdf
- https://chat.openai.com/
- https://bard.google.com/
- https://www.kaggle.com/c/quora-question-pairs
- https://github.com/XingxingZhang/dress
- https://huggingface.co/datasets/databricks/databricks-dolly-15k/viewer/databricks--databricks-dolly-15k
- https://github.com/Tiiiger/bert_score
- https://huggingface.co/roberta-large
- https://huggingface.co/mosaicml/mpt-7b
- https://huggingface.co/facebook/opt-6.7b
- https://github.com/facebookresearch/llama
- https://huggingface.co/bigscience/bloom-7b1
- https://github.com/tatsu-lab/stanford_alpaca
- https://github.com/chrisjbryant/errant