DialoGPT
1.0.0
Este repositório contém o código-fonte e o modelo treinado para um modelo de geração de resposta de diálogo pré-escala pré-escala. Os resultados da avaliação humana indicam que a resposta gerada a partir de diálogo é comparável à qualidade da resposta humana em um teste de Turing de conversação de uma única volta.
O repositório é baseado em Huggingface Pytorch-Transformer e OpenAI GPT-2, contendo script de extração de dados, código de treinamento de modelos e médio médio (117m) pré-terenciado (117m) (345m) e grande (762m) de ponto de verificação do modelo.
O modelo é treinado no diálogo de 147m de várias turnos do thread de discussão do Reddit. O maior modelo pode ser treinado em várias horas em uma máquinas de 8 V100 (no entanto, isso não é necessário), com treinamento distribuído e opção FP16.
O script inclui pode ser usado para reproduzir os resultados do desafio de geração de diálogo DSTC-7 fundamentado e um conjunto de dados de multi-referência de 6k criado a partir de dados do Reddit.
Página da web do projeto: https://www.microsoft.com/en-us/research/project/large-scale-preretraining-for-rosponse-generação/
Arxiv Paper: https://arxiv.org/abs/1911.00536
(Atualização 07/09/2022) Alterações no arquivo.pushshift.io/reddit O servidor fez com que nosso pipeline de geração de dados quebrasse. Esses problemas já foram corrigidos e as etapas explicadas na subseção de preparação de dados abaixo devem funcionar novamente. Os dados são gerados em cerca de 10 horas com 8 processos ( -j 8 ) e é necessário 800 GB de espaço de disco temporário.
(ATUALIZAÇÃO 23/06/2021) Lançamos uma versão de diálogo (Retgen) de Recuperação de Recuperação (Retgen). Confira o Retgen Repo e o Retgen Paper
(ATUALIZAÇÃO 20/05/2021) Um passo a passo de vídeo incrível no YouTube para Dialogpt por Prakhar Mishra
(ATUALIZA
(Atualização 15/09/2020) Um conjunto de modelos de classificação de diálogo em larga escala foi lançado!
A geração de diálogo é aprimorada integrando com nossos mais recentes modelos de classificação de diálogo, dialogrpt
(ATUALIZAÇÃO 07/08/2020) O conjunto de testes multi-ref 6K foi lançado!
Para gerar os dados, Pleaser Run demo.py e defina a opção de dados como 'Full', o conjunto de testes multi-ref gerado 6K estará localizado em
./data/test.refs.txt
(ATUALIZAÇÃO 03/10/2020) Cartões de modelo disponíveis em Transformers Huggingface!
Confira nossos cartões de modelo no Repositório de Transformers do HuggingFace. Com várias linhas de código, deve ser bastante reto para brincar com o diálogo interativamente.
Modelo pequeno: https://huggingface.co/microsoft/dialogpt-small
Modelo médio: https://huggingface.co/microsoft/dialogpt-medium
Modelo grande: https://huggingface.co/microsoft/dialogpt-large
(Novo) Modelo de classificação: https://huggingface.co/microsoft/dialogptup updown
(Atualização 01/06/2020) Algumas implementações de scripts de decodificação de terceiros:
O diálogo foi desenvolvido inteiramente no Ubuntu 16.04 e - dependendo da nossa disponibilidade - tentamos fornecer suporte se você tiver dificuldades em executar o código na mesma configuração. No entanto, não podemos fornecer suporte para outras distribuições ou sistemas operacionais . Partes do código podem ser executadas em outros sabores Unix (macOS, subsistema do Windows para Linux, Cygwin etc.), mas é recomendável usar o Ubuntu para o código de treinamento principal.
O código de treinamento pode ser executado na CPU, mas pode ser lento. Recomendamos usar a GPU para treinar e Finetune todos os modelos. Não há limite mínimo do número de GPUs. No entanto, se estiver usando o trem distribuído para configuração de GPUs múltiplas, a velocidade versus o número de GPUs é aproximadamente sub-linear. Para simular o mesmo lote ao usar menos GPUs, use um gradient_accumulation_steps maior_accumulation_steps no treinamento de modelos.
O modelo de 117m e 345m pode ser carregado em uma única GPU com memória 12g. O modelo 762M exigiria uma única GPU que tenha maior que 16g de memória para treinamento eficiente. A velocidade de treinamento em dados de referência com 50 milhões de instâncias de treinamento e GPUs V100:
| N_GPU | tempo de época (h) | Token/Sec |
|---|---|---|
| 1 | 118 | 10847 |
| 2 | 62 | 20645 |
| 4 | 34 | 37647 |
| 8 | 18 | 71356 |
O ajuste fino do nosso modelo pré-treinado em um novo conjunto de dados geralmente requer 1-2 épocas.
Criamos um Demo Script demo.py para facilitar a dificuldade da implantação deste sistema. O demo.py contém um pipeline de download de modelos , extração de dados, pré -processamento de dados e treinamento de modelos em um conjunto de dados dummy dentro de um comando.
Use as linhas de comando abaixo para clonar, instalar os requisitos e carregar o ambiente do CONDA (observe que é necessário o NVIDIA CUDA 10.0 Developer Toolkit):
sudo apt-get install -y make wget gzip bzip2 xz-utils zstd sedgit clone https://github.com/microsoft/DialoGPT.git
cd DialoGPT
conda env create -f LSP-linux.yml -n LSP
conda activate LSP Se você executar isso em uma arquitetura que não seja o Linux, use LSP-generic.yml em vez do LSP-linux.yml , mas observe que o genérico não é testado em toda a plataforma, para que a estábura não possa ser gaureada. Para usar o treinamento FP16, instale o APEX usando os comandos abaixo
conda activate LSP
git clone https://github.com/NVIDIA/apex
cd apex
git reset --hard 3d01e4a0a188cc8df54bc6e44cf5eb40ff6b4cc5
pip install -v --no-cache-dir --global-option= " --cpp_ext " --global-option= " --cuda_ext " .
python3.6 demo.pyPara começar, primeiro instale o Docker e o Nvidia-Docker a partir de seus repositórios oficiais. O ambiente de imagem para executar o código pode ser carregado como abaixo:
Nvidia-Docker V2. *
$ docker run --gpus all --ipc=host --rm -it -v $PWD :/workspace --network=host icaruszyz/large-scale-training:dialogpt bashNvidia-Docker V1. *
$ nvidia-docker --rm -it -v $PWD :/workspace --network=host icaruszyz/large-scale-training:dialogpt bashDentro do recipiente do docker, execute
python demo.py Esta seção explica todos os componentes no demo.py
Antes de executar demo.py , você pode definir Data_Folder (Valor padrão ./models ) no demo.py como o local que deseja baixar todos os dados e modelos pré-treinados/ajustados. Em seguida, basta correr
python demo.pypara
Observe que, por padrão, o demo.py usará um dummy Data, especifique os dados de treinamento do Reddit usando a opção --data . Três opções estão disponíveis: dummy , small e full .
python demo.py --data small
python demo.py --data fullOs pequenos dados do Reddit são de cerca de 140 MB e os dados completos do Reddit são superiores a 27 GB. Você pode preparar uma xícara de café ao processar com os dados completos do Reddit, porque leva muito tempo !
Para gerar os dados do conjunto de testes multi-ref 6K, Pleaser Run demo.py e definir a opção de dados como 'Full', a geração estará localizada em
./data/test.refs.txt
Os modelos pré-treinados e afinados estão disponíveis no Azure Blobstorage. Execute/consulte demo.py para obter mais detalhes sobre como baixar/usar esses modelos. Ou você pode baixar diretamente usando os links em demo_utils.py .
Primeiro, use o prepare4db.sh para converter um arquivo de dados TSV no formato correto que o script a seguir pode reconhecer. Os dados do treinamento precisam ser processados em um arquivo de banco de dados com o comando abaixo:
python prepro.py --corpus $DATA_PATH O script de treinamento pode ser usado em configurações de GPU ou GPU único (treinamento distribuído em várias GPUs dentro de um único nó):
python ./LSP_train.py # Single GPU training
python -m torch.distributed.launch --nproc_per_node=8 ./LSP_train.py # Training on 8 GPUsO script de treinamento aceita vários argumentos para ajustar o treinamento:
| Argumento | Tipo | Valor padrão | Descrição |
|---|---|---|---|
| max_seq_length | int | 128 | Número máximo de tokens para cada instância de treinamento. |
| TRIN_INPUT_FILE | str | "" | Caminho do conjunto de dados de treinamento em um formato .db |
| Eval_input_file | str | "" | Caminho da validação definida em um formato TSV |
| continue_from | int | 0 | Retomando o treinamento após um número especificado de etapas |
| FP16 | boolean | True | Se deve usar o ponto flutuante de 16 bits para treinamento de modelos. |
| TRIN_BATCH_SIZE | int | 4 | Tamanho do lote para treinamento |
| valid_batch_size | int | 4 | Tamanho do lote para validação |
| gradiente_accumulation_steps | int | 2 | Acumular gradientes em várias etapas |
| Aprendizagem_rate | float | 1e-5 | Taxa de aprendizado |
| lr_schedule | str | noam | O cronograma da taxa de aprendizado pode ser escolhido de [ noam , noamwd , BERT , None ] |
| NUM_OPTIM_STEPS | int | 1000000 | Número de etapas de otimização de treinamento |
| NO_TOKEN_ID | boolean | True | Se definido, o uso de incorporação do tipo Token All-Zen. |
Durante o treinamento, dois arquivos de log serão atualizados. O train_log.txt e eval_log.txt contêm as estatísticas de perda, perplexidade e velocidade de treinamento (tokens/s) para o treinamento e o conjunto de dev.
O arquivo de log e o ponto de verificação do modelo salvo podem ser encontrados em ./models/output_model
Observamos que, mesmo com o conjunto de dados do Reddit corretamente filtrado, às vezes nosso modelo ainda pode gerar respostas moderadamente tóxicas/inadequadas. Por esse motivo, não podemos fornecer o script de decodificação neste momento (a demonstração ao vivo e o acesso ao script de decodificação estão sob convite apenas agora). Atualmente, ainda estamos trabalhando em um método de decodificação controlada para impedir que esse sistema geração tóxica. Por favor, fique atento.
Consulte as questões 3 e as discussões do Reddit para algumas discussões sobre métodos de decodificação de terceiros.
Veja abaixo alguns métodos de decodificação de terceiros:
Lançamos 6 modelos de ajuste fino que podem ser mais ajustados no conjunto de dados de baixo resistência ao usuário. Os parâmetros totais nesses modelos variam de 117m a 762m, de acordo com os tamanhos dos modelos OpenAI GPT-2.
| Modelo | Ajustado fino do GPT-2 | Treinado do zero |
|---|---|---|
| Modelo de diálogo 762m | [Link] [cartão de modelo Huggingface] | [link] |
| Modelo de diálogo 345m | [Link] [cartão de modelo Huggingface] | [link] |
| Modelo de diálogo 117M | [Link] [cartão de modelo Huggingface] | [link] |
| Modelo de diálogo 345m (reverso, para MMI) | link | - |
| Dialogpt ( novos modelos de classificação) | link | - |
Os arquivos do modelo podem ser carregados exatamente como os pontos de verificação do modelo GPT-2 dos Transformers do Huggingface. Você pode encontrar os arquivos de configuração correspondentes ( merges.txt , config.json , vocab.json ) no repo do dialogpt em ./configs/* .
O modelo reverso está prevendo a fonte do alvo. Este modelo é usado para reranger o MMI.
Os modelos de dialogrpt nossos modelos de classificação recentemente propostos usados para prever o feedback humano (votos, respostas) das respostas. Esses modelos podem ser usados para melhorar a qualidade da geração de diálogo (consulte nosso papel EMNLP para obter detalhes).
A primeira etapa para treinar os modelos completos é gerar o conjunto de dados Reddit de 27 GB de 27 GB. Isso envolve o download do envio completo do Reddit e dos comentários do https://files.pushshift.io/reddit e na criação de arquivos intermediários, que requerem 700 GB de espaço em disco local . O download e o processamento dos dados completos requer cerca de 1-2 dias, dependendo de suas capabiltias de computação (CPU) (por exemplo, ~ 24 horas com 8 núcleos em um computador recente). Supondo que você executou as etapas de instalação e instalação acima (CONDA Ative LSP, etc.), você pode criar o conjunto de dados completo executando:
python demo.py --data full
ou
cd reddit_extractor; SIZE=full make -j 8; cd ..
O comando anterior chama o último, para que os dois métodos sejam equivalentes. Recomendamos o primeiro, pois o último é útil se você tiver algum problema ou desejar personalizar quaisquer argumentos (por exemplo, o comando make permite criar apenas um subconjunto dos dados). Observe que a fase de download pode ser propensa a erros, por exemplo, com base na sua geolocalização (firewall etc.). Se os comandos acima não conseguirem gerar data/train.tsv , ou se esse arquivo não estiver perto de 27 GB, isso significa que algo deu errado. Nesse caso, convém inspecionar reddit_extractor/wget-log e reddit_extractor/logs/*.log para qualquer erro óbvio (por exemplo, WGET não puder baixar do PushShift.io). Se as mensagens de erro não fizeram sentido para você, não hesite em entrar em contato conosco. Nesse caso, inclua qualquer mensagem de erro coletada desses arquivos de log.
Estatísticas de dados de treinamento: O arquivo TSV de treinamento gerado deve ser de aproximadamente 26,8 GB não compactado, com 146,8m de treinamento em instâncias de treinamento, tokens de origem de 3,87b e tokens de alvo 2,14b (incluindo pesos 0/1 no nível da expressão). O arquivo de trem.TSV resultante deve conter 146.846.215 linhas.
Recomendamos a geração dos dados acima usando o demo.py --data full , pois (1) gera os dados, (2) os converte em formato db e (3) treina um modelo usando python LSP_train.py . Por favor, edite diretamente demo.py se você deseja personalizar algum dos hiperparâmetros.
Nosso modelo alcançou os resultados de última geração na tarefa de geração de resposta de desafios do DSTC-7.
| Experimentar | NIST2 | Nist4 | Bleu2 | Bleu4 | METEORO | ENT-4 | Dist-1 | Dist-2 | Avg. Len |
|---|---|---|---|---|---|---|---|---|---|
| Resposta humana | 2.62 | 2.65 | 12,35% | 3,13% | 8,31% | 10.45 | 16,66% | 67,01% | 18.8 |
| Vencedor do DSTC-7 | 2.51 | 2.52 | 14,35% | 1,83% | 8,07% | 9.03 | 10,89% | 32,49% | 15.1 |
| Dialogpt 345m | 2.80 | 2.82 | 14,16% | 2,31% | 8,51% | 10.08 | 9,13% | 39,73% | 16.9 |
| Dialogpt 345m (BS) | 2.92 | 2.97 | 19,18% | 6,05% | 9,29% | 9.57 | 15,73% | 51,03% | 14.2 |
onde o ENT representa a pontuação da entropia e o Dist representa a pontuação distinta. Para todas as métricas, exceto o comprimento médio, maiores são melhores.
Observe que a avaliação automática superior em comparação com as respostas humanas não é necessária que nosso modelo alcança a paridade humana. Confira nosso artigo para uma análise mais detalhada.
Para ajustar o modelo de diálogo 345M nos dados do DSTC-7 Challenge em um servidor com 8 GPUs V100, execute o seguinte CommandLine (os dados do DSTC podem ser encontrados no repo DSTC-7):
python3 -m torch.distributed.launch --nproc_per_node=8 train_LSP.py --init_checkpoint ./models/medium/medium_ft.pkl --train_input_file ./data/DSTC_train.db --eval_input_file ./data/DSTC_valid.tsv --model_name_or_path ./model/medium/ --learning_rate 1e-4 --train_batch_size 64 --eval_batch_size 64 --no_token_idO modelo treinado pode ser encontrado no modelo DSTC Medium
Faça o download dos seguintes pacotes de terceiros e salve na pasta vazia 3rdparty :
cpan install ): XML: TWIG, Sort: Naturally and String: UTIL. Siga o repositório oficial do DSTC-7 para extrair os dados e coloque data-official-test/test.refs.txt na pasta ./dstc/data/ .
Execute o script de extração abaixo para produzir o arquivo de hipótese de resposta humana human.resp.txt :
python extract_human.pyFinalmente, para reproduzir os resultados da hipótese humana no conjunto de dados do DSTC, execute os seguintes comandos na pasta repo:
python batch_eval.py Os resultados da avaliação serão gerados na pasta ./dstc/eval/
Testamos o conjunto de dados de 6K multi-ref do Reddit. Os resultados estão resumidos abaixo
| Experimentar | NIST2 | Nist4 | Bleu2 | Bleu4 | METEORO | ENT-4 | Dist-1 | Dist-2 | Avg. Len |
|---|---|---|---|---|---|---|---|---|---|
| Resposta humana | 3.41 | 4.25 | 17,90% | 7,48% | 10,64% | 11 | 14,50% | 63,00% | 13.1 |
| Dialogpt 117m | 2.39 | 2.41 | 10,54% | 1,55% | 7,53% | 10.78 | 8,60% | 39,90% | 12.8 |
| Dialogpt 345m | 3 | 3.06 | 16,96% | 4,56% | 9,81% | 9.13 | 6,80% | 26,30% | 12.2 |
| Dialogpt 762m | 2.84 | 2.9 | 18,66% | 5,25% | 9,66% | 9.72 | 7,76% | 29,93% | 11.2 |
| Dialogpt 345m (BS) | 3.4 | 3.5 | 21,76% | 7,92% | 10,74% | 10.48 | 12,38% | 48,74% | 11.3 |
| Dialogpt 345m (W/MMI) | 3.28 | 3.33 | 15,68% | 3,94% | 11,23% | 11.25 | 9,39% | 45,55% | 17.2 |
Além disso, realizamos avaliações humanas (6K exemplos para cada métodos, cada exemplo é avaliado por 3 juízes humanos). Os resultados mostram uma forte evidência de que nossa qualidade de geração é abordar a qualidade das respostas humanas reais, neste teste de Turing não interativo:
Relevância : A e B, qual é mais relevante para o prompt de origem.
| Sistema a | A Wins (%) | Laços (%) | B vitórias (%) | Sistema b |
|---|---|---|---|---|
| Dialogpt 345m | 2671 (45%) | 513 (9%) | 2816 (47%) | Respostas humanas |
| Dialogpt 345m | 3281 (72%) | 394 (9%) | 882 (19%) | PersonalityChat |
| Dialogpt 345m w/ mmi | 2871 (48%) | 522 (9%) | 2607 (43%) | Respostas humanas |
Informatividade : A e B, qual é mais conteúdo e informativo.
| Sistema a | A Wins (%) | Laços (%) | B vitórias (%) | Sistema b |
|---|---|---|---|---|
| Dialogpt 345m | 2722 (45%) | 234 (4%) | 3044 (51%) | Respostas humanas |
| Dialogpt 345m | 3490 (77%) | 206 (5%) | 861 (19%) | PersonalityChat |
| Dialogpt 345m w/ mmi | 3011 (50%) | 234 (4%) | 2755 (46%) | Respostas humanas |
Humanos : A e B, que você acha que é mais provável que seja gerado pelo humano.
| Sistema a | A Wins (%) | Laços (%) | B vitórias (%) | Sistema b |
|---|---|---|---|---|
| Dialogpt 345m | 2716 (45%) | 263 (4%) | 3021 (50%) | Respostas humanas |
| Dialogpt 345m | 3462 (76%) | 196 (4%) | 899 (20%) | PersonalityChat |
| Dialogpt 345m w/ mmi | 2978 (50%) | 241 (4%) | 2781 (46%) | Respostas humanas |
Por favor, veja os detalhes completos em nosso artigo ARXIV.
| Papel | Resposta |
|---|---|
| Usuário | O dinheiro compra felicidade? |
| Robô | Depende de quanto dinheiro você gasta com isso. |
| Usuário | Qual é a melhor maneira de comprar felicidade? |
| Robô | Você só precisa ser um milionário aos seus 20 anos, então pode ser feliz. |
| Usuário | Isso é tão difícil! |
| Robô | Você não tem idéia de como é difícil ser um milionário e feliz. Há uma razão pela qual os ricos têm muito dinheiro |
| Papel | Resposta |
|---|---|
| Usuário | Qual é o significado da vida? |
| Robô | O significado é estar com sua família e amigos. |
| Robô | Vou adivinhar: isso significa que seus pais e amigos te amaram. Esse é o significado, acredito. |
| Robô | Eu acho que o significado é garantir que você esteja vivo quando morre. Então você estará com sua família, amigos e você mesmo. |
| Robô | Não é, mas obrigado por tentar ajudar. |
| Usuário | Robô |
|---|---|
| Quem é o primeiro presidente dos Estados Unidos | George Washington |
| Qual é o ponto de ebulição da água? | Eu acho que é cerca de 212 F. |
| Qual é maior, sol ou lua? | O sol. |
| Qual animal tem listras em preto e branco? | Um gato listrado em preto e branco. |
| Usuário | Robô |
|---|---|
| A guerra comercial entre a China e os EUA ainda está acontecendo. | Tenho certeza que o governo chinês e o u. S. Ficarei bem com isso, desde que eles manterem os braços na mesa e o dinheiro fluindo. |
| Quem venceu a Copa do Mundo em 2018? | Alemanha, acredito. |
| O Titan RTX da Nvidia é realmente bom. | Eu tenho este cartão e adoro isso. Sem queixas. |
| A Porsche pode vencer Tesla com seu novo Taycan EV? | Eu não acho . O Tesla é mais poderoso que o Porsche. |
| Usuário | Robô |
|---|---|
| Qual é o significado de uma boa vida? | Eu acho que é que todos estamos conectados às nossas vidas passadas e o significado da vida é viver da maneira que você deseja e como deseja. |
| O que é mais importante - ser bem -sucedido ou feliz? | Ser bem -sucedido é infinito. Ser feliz é a única coisa que importa. |
| A paz é a única maneira de parar a guerra? | Não se o mundo não estiver disposto a trabalhar com você. A paz é o objetivo final, mas a paz exige mais do que isso. |
| Quanta liberdade as pessoas devem ter? | A quantidade certa de liberdade é a liberdade de fazer o que quiser, desde que você não machuque pessoas ou propriedades. |
| Usuário | Robô |
|---|---|
| O que você acha do repositório de diálogo? | É muito bom, mas é muito fácil encontrar um bug. |
Por favor, comece um problema se você encontrar algum :)
A demonstração ao vivo e o acesso ao script de decodificação estão mediante convite agora. Por favor, fiquei atento para o lançamento completo.
Retgen: https://github.com/deresysnail/retgen. Diálogo de recuperação upentada/aterrada e além. O Retgen é uma estrutura de treinamento conjunta que otimiza simultaneamente um denso Retriever de passagem e um gerador de texto fundamentado no conhecimento de uma maneira de ponta a ponta.
Microsoft IceCaps: https://github.com/microsoft/icecaps.
Como repositório ortogonal deste projeto, o Microsoft IceCaps é um kit de ferramentas de código aberto (em Tensorflow) para a criação de sistemas de conversação neural. O IceCaps fornece uma variedade de ferramentas de modelagem recente de conversas e literatura geral de PNL em um paradigma flexível que permite configurações complexas de aprendizado de várias tarefas.
Unilm pré -tenhado: https://github.com/microsoft/unilm
Mt-dnn: https://github.com/namisan/mt-dnn
Uma contraparte chinesa de diálogo por Yangjianxin1. https://github.com/yangjianxin1/gpt2-chitchat. Estamos felizes em ver que a estratégia MMI que usamos no diálogo também melhorou o desempenho deste projeto!
Entre em contato com [email protected] se você tiver alguma dúvida/sugestão. No entanto, a resposta será esporádica. Por favor, espere atraso.
Este projeto recebe contribuições e sugestões. A maioria das contribuições exige que você concorde com um Contrato de Licença de Colaborador (CLA) declarando que você tem o direito e, na verdade, concede -nos os direitos de usar sua contribuição. Para detalhes, visite https://cla.opensource.microsoft.com.
Quando você envia uma solicitação de tração, um BOT do CLA determina automaticamente se você precisa fornecer um CLA e decorar o PR adequadamente (por exemplo, verificação de status, comentar). Simplesmente siga as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios usando nosso CLA.
Este projeto adotou o Código de Conduta Open Microsoft. Para obter mais informações, consulte o Código de Conduta Perguntas frequentes ou entre em contato com [email protected] com quaisquer perguntas ou comentários adicionais.
Este repositório visa facilitar a pesquisa em pré-treinamento em larga escala para dados de conversação. Este kit de ferramentas contém apenas parte da maquinaria de modelagem necessária para realmente produzir um arquivo de peso de modelo em uma caixa de diálogo em execução. Por si só, este modelo fornece apenas informações sobre os pesos de vários períodos de texto; Para que um pesquisador o use, ele precisará trazer dados de conversação própria e decodificar a geração de respostas do sistema pré -treinado. A Microsoft não é responsável por nenhuma geração da utilização de terceiros do sistema pré -treinado.
Se você usar este código em sua pesquisa, poderá citar nosso artigo ARXIV:
@inproceedings{zhang2019dialogpt,
title={DialoGPT: Large-Scale Generative Pre-training for Conversational Response Generation},
author={Yizhe Zhang and Siqi Sun and Michel Galley and Yen-Chun Chen and Chris Brockett and Xiang Gao and Jianfeng Gao and Jingjing Liu and Bill Dolan},
year={2020},
booktitle={ACL, system demonstration}
}
