cakechat
v2.0.1
Nota no topo: o projeto não é mantido.
Os modelos de diálogo baseados em transformadores funcionam melhor e recomendamos usá-los em vez do Cakechat baseado em RNN. Veja, por exemplo, https://github.com/microsoft/dialogpt
O Cakechat é um back -end para chatbots capazes de expressar emoções por meio de conversas.
O Cakechat é construído em Keras e Tensorflow.
O código é flexível e permite condicionar as respostas do modelo por uma variável categórica arbitrária. Por exemplo, você pode treinar seu próprio modelo de conversação neural baseado em persona [1] ou criar uma máquina de bate-papo emocional [2] .
Modelo:
Camada de incorporação de palavras:
Decodificação
Métricas:
Caso você esteja familiarizado com o Docker, aqui está a maneira mais fácil de executar um modelo de Cakechat pré-treinado como servidor. Pode ser necessário executar os seguintes comandos com sudo .
Versão da CPU:
docker pull lukalabs/cakechat:latest &&
docker run --name cakechat-server -p 127.0.0.1:8080:8080 -it lukalabs/cakechat:latest bash -c "python bin/cakechat_server.py"
Versão da GPU:
docker pull lukalabs/cakechat-gpu:latest &&
nvidia-docker run --name cakechat-gpu-server -p 127.0.0.1:8080:8080 -it lukalabs/cakechat-gpu:latest bash -c "CUDA_VISIBLE_DEVICES=0 python bin/cakechat_server.py"
É isso! Agora teste seu servidor Cakechat executando o seguinte comando em sua máquina host:
python tools/test_api.py -f localhost -p 8080 -c "hi!" -c "hi, how are you?" -c "good!" -e "joy"
O ditado de resposta pode ser assim:
{'response': "I'm fine!"}
O Docker é a maneira mais fácil de configurar o ambiente e instalar todas as dependências para treinamento e teste.
Nota: Recomendamos fortemente o uso do ambiente habilitado para GPU para treinamento do modelo Cakechat. A inferência pode ser feita tanto nas GPUs quanto nas CPUs.
Instale o docker.
Puxe uma imagem do Docker somente CPU do DockerHub:
docker pull lukalabs/cakechat:latest
docker run --name <YOUR_CONTAINER_NAME> -it lukalabs/cakechat:latest
Instale o NVIDIA-Docker para o suporte da GPU.
Puxe a imagem do docker habilitada para GPU do DockerHub:
docker pull lukalabs/cakechat-gpu:latest
nvidia-docker run --name <YOUR_CONTAINER_NAME> -it cakechat-gpu:latest
É isso! Agora você pode treinar seu modelo e conversar com ele. Veja a seção correspondente abaixo para obter mais instruções.
Se você não quiser lidar com o Docker, pode instalar todos os requisitos manualmente:
pip install -r requirements.txt -r requirements-local.txt
NB:
Recomendamos instalar os requisitos dentro de um VirtualEnv para evitar mexer com os pacotes do sistema.
Você pode fazer o download de nossos pesos de modelo pré-treinado executando python tools/fetch.py .
Os parâmetros do modelo pré-treinado são os seguintes:
O modelo foi treinado em um corpus do Twitter pré -processado com ~ 50 milhões de diálogos (11 GB de dados de texto). Para limpar o corpus, removemos
Usamos nosso classificador de emoções para rotular cada enunciada com uma das 5 emoções a seguir: "neutral", "joy", "anger", "sadness", "fear" e usamos esses rótulos durante o treinamento. Para marcar seu próprio corpus com emoções que você pode usar, por exemplo, ferramenta Deepmoji.
Infelizmente, devido à política de privacidade do Twitter, não temos permissão para fornecer nosso conjunto de dados. Você pode treinar um modelo de diálogo em qualquer conjunto de dados de conversação de texto disponível para você, uma ótima visão geral dos conjuntos de dados de conversação existentes pode ser encontrada aqui: https://breakend.github.io/dialogdatasets/
Os dados de treinamento devem ser um arquivo TXT, onde cada linha é um objeto JSON válido, representando uma lista de enunciados de diálogo. Consulte nosso conjunto de dados de trem fictício para ver a estrutura de arquivo necessária. Substitua este corpus fictício pelos seus dados antes do treinamento.
Existem duas opções:
A primeira abordagem é menos restritiva: você pode usar os dados de treinamento desejar e definir qualquer params de configuração do modelo. No entanto, você deve estar ciente de que precisará de dados de trem suficientes (pelo menos de 50 MB), uma ou mais GPUs e paciência suficiente (dias) para obter as respostas do bom modelo.
A segunda abordagem é limitada pela escolha dos parâmetros de configuração do modelo pré-treinado-consulte cakechat/config.py para a lista completa. Se os parâmetros padrão forem adequados para sua tarefa, o ajuste fino deve ser uma boa opção.
Busque o modelo pré-treinado da Amazon S3 executando python tools/fetch.py .
Coloque seu corpus de texto de treinamento em data/corpora_processed/train_processed_dialogs.txt . Certifique -se de que seu conjunto de dados seja grande o suficiente, caso contrário, o seu modelo risca para exceder os dados e os resultados serão ruins.
Execute python tools/train.py .
results/nn_models , o caminho completo é inferido a partir do conjunto de parâmetros de configuração.-i , por exemplo, python tools/train.py -i results/nn_models/my_saved_weights/model.current .CUDA_VISIBLE_DEVICES=<GPU_ID> Variável de ambiente (com <gpu_id> como na saída do comando nvidia-smi ) se você deseja usar a GPU. Por exemplo, CUDA_VISIBLE_DEVICES=0 python tools/train.py executará o processo de trem na GPU 0-és.-s para treinar o modelo em um subconjunto das primeiras n amostras de seus dados de treinamento para acelerar o pré -processamento para depuração. Por exemplo, execute python tools/train.py -s 1000 para treinar nas primeiras 1000 amostras. Os pesos do modelo treinado são salvos nos results/nn_models/ .
Coloque seu corpus de texto de treinamento em data/corpora_processed/train_processed_dialogs.txt .
Configure parâmetros de treinamento em cakechat/config.py . Consulte Configurações Descrição Para obter mais detalhes.
Considere a execução PYTHONHASHSEED=42 python tools/prepare_index_files.py para criar os arquivos de índice com tokens e condições a partir do corpus de treinamento. Certifique -se de definir a variável de ambiente PYTHONHASHSEED ; caso contrário, você poderá obter diferentes arquivos de índice para diferentes lançamentos do script. AVISO: Este script substitui os arquivos de índice de tokens originais data/tokens_index/t_idx_processed_dialogs.json e data/conditions_index/c_idx_processed_dialogs.json . Você deve executar apenas esse script, caso seu corpus seja grande o suficiente para conter todas as palavras que deseja que seu modelo entenda. Caso contrário, considere o ajuste fino do modelo pré-treinado, conforme descrito acima. Se você errou com arquivos de índice e deseja obter as versões padrão, exclua suas cópias e execute python tools/fetch.py Anew.
Considere executar python tools/train_w2v.py para construir a incorporação W2V do corpus de treinamento. AVISO: Este script substitui os pesos W2V originais que são armazenados em data/w2v_models . Você deve executar apenas esse script, caso seu corpus seja grande o suficiente para conter todas as palavras que deseja que seu modelo entenda. Caso contrário, considere o ajuste fino do modelo pré-treinado, conforme descrito acima. Se você errou com os arquivos W2V e deseja obter a versão padrão, exclua sua cópia de arquivo e execute python tools/fetch.py Anew.
Execute python tools/train.py .
CUDA_VISIBLE_DEVICES=<GPU_ID> Variável de ambiente (com <gpu_id> como na saída do comando nvidia-smi ) se você deseja usar a GPU. Por exemplo, CUDA_VISIBLE_DEVICES=0 python tools/train.py executará o processo de trem na 0ª GPU.-s para treinar o modelo em um subconjunto das primeiras n amostras de seus dados de treinamento para acelerar o pré -processamento para depuração. Por exemplo, execute python tools/train.py -s 1000 para treinar nas primeiras 1000 amostras. Você também pode definir IS_DEV=1 para ativar o "modo de desenvolvimento". Ele usa um número reduzido de parâmetros do modelo (diminuição das dimensões da camada oculta, tamanhos de entrada e saída das seqüências de token etc.) e executa o logbose de registro. Consulte as linhas de fundo do cakechat/config.py para obter a lista completa de parâmetros dev.
Os pesos do modelo treinado são salvos nos results/nn_models/ .
O contêiner do Docker, habilitado para GPU, suporta o trem distribuído em várias GPUs usando o Horovod.
Por exemplo, execute python tools/distributed_train.py -g 0 1 para começar o treinamento em 0 e 1 GPUs.
Durante o treinamento, os seguintes conjuntos de dados são usados para validações de cálculo de métricas:
data/corpora_processed/val_processed_dialogs.txt (exemplo dummy, substitua pelos seus dados)-pelo conjunto de dados sensível ao contextodata/quality/context_free_validation_set.txt -Para o conjunto de dados de validação sem contextodata/quality/context_free_questions.txt -é usado para gerar respostas para registro e computação distinta-metricsdata/quality/context_free_test_set.txt - é usado para calcular métricas do modelo treinado, por exemplo, métricas de classificação As métricas são armazenadas no cakechat/results/tensorboard e podem ser visualizadas usando o Tensorboard. Se você executar um contêiner do Docker a partir da imagem do Docker, habilitada para CPU ou GPU,, o servidor de tensorboard deve iniciar automaticamente e servir no http://localhost:6006 . Abra este link no seu navegador para ver os gráficos de treinamento.
Se você instalou os requisitos manualmente, inicie o Tensorboard Server primeiro, executando o seguinte comando do seu diretório raiz do Cakechat:
mkdir -p results/tensorboard && tensorboard --logdir=results/tensorboard 2>results/tensorboard/err.log &
Depois disso, prossiga para http://localhost:6006 .
Você pode executar as seguintes ferramentas para avaliar seu modelo treinado nos dados de teste (exemplo dummy, substitua pelos seus dados):
tools/quality/ranking_quality.py - calcula métricas de classificação de um modelo de diálogotools/quality/prediction_distinctness.py -calcula a metrics distinta de um modelo de diálogotools/quality/condition_quality.py - calcula métricas em diferentes subconjuntos de dados de acordo com o valor da condiçãotools/generate_predictions.py - avalia o modelo. Gera previsões de um modelo de diálogo no conjunto de contextos de diálogo determinados e calcula métricas. Observe que você deve ter um modelo reverso no diretório data/nn_models se quiser usar modos de previsão "-Reranking"tools/generate_predictions_for_condition.py - gera previsões para um determinado valor de condição Execute um servidor que processa as solicitações HTTP com as mensagens de entrada fornecidas e retorna mensagens de resposta do modelo:
python bin/cakechat_server.py
Especifique CUDA_VISIBLE_DEVICES=<GPU_ID> Variável de ambiente para executar o servidor em uma determinada GPU.
Não se esqueça de executar python tools/fetch.py antes de iniciar o servidor, se desejar usar nosso modelo pré-treinado.
Para garantir que tudo funcione bem, teste o modelo na seguinte conversa
- Oi, Eddie, o que foi?
- Não muito, e você?
- Bem obrigado. Você vai ao cinema amanhã?
Ao executar o comando:
python tools/test_api.py -f 127.0.0.1 -p 8080
-c "Hi, Eddie, what's up?"
-c "Not much, what about you?"
-c "Fine, thanks. Are you going to the movies tomorrow?"
Você deve obter uma resposta significativa, por exemplo:
{'response': "Of course!"}
Os parâmetros JSON são:
| Parâmetro | Tipo | Descrição |
|---|---|---|
| contexto | Lista de strings | Lista de mensagens anteriores do histórico de diálogo (máx. 3 é usado) |
| emoção | string, um de enum | Um dos {'neutro', 'raiva', 'alegria', 'medo', 'tristeza'}. Uma emoção para condicionar a resposta. Param opcional, se não especificado, 'neutro' é usado |
POST /cakechat_api/v1/actions/get_response
data: {
'context': ['Hello', 'Hi!', 'How are you?'],
'emotion': 'joy'
}
200 OK
{
'response': 'I'm fine!'
}
Recomendamos o uso do Gunicorn para servir a API do seu modelo em escala de produção.
Instale Gunicorn: pip install gunicorn
Execute um servidor que processa HTTP-Queries com mensagens de entrada e retorna mensagens de resposta do modelo:
cd bin && gunicorn cakechat_server:app -w 1 -b 127.0.0.1:8080 --timeout 2000
Você pode executar seu modelo Cakechat como um bot de telegrama:
python tools/telegram_bot.py --token <YOUR_BOT_TOKEN> e converse com ele no Telegram. cakechat/dialog_model/ - contém gráfico computacional, procedimento de treinamento e outros utilitários de modeloscakechat/dialog_model/inference/ - algoritmos para geração de respostascakechat/dialog_model/quality/ - código para cálculo e registro de métricascakechat/utils/ - Utilitários para processamento de texto, treinamento W2V, etc.cakechat/api/ - funções para executar o servidor HTTP: configuração da API, manuseio de errostools/ - Scripts para treinamento, teste e avaliação do seu modelobin/cakechat_server.py -executa um servidor HTTP que retorna mensagens de resposta dos contextos de diálogo do modelo, dados e uma emoção. Consulte a seção Run para obter detalhes.tools/train.py - treina o modelo em seus dados. Você pode usar a opção --reverse para treinar um modelo reverso usado em algoritmos de geração de resposta "-Reranking" para previsões mais precisas.tools/prepare_index_files.py - prepara o índice para os tokens e condições mais comumente usados. Use este script antes de treinar o modelo do zero em seus próprios dados.tools/quality/ranking_quality.py - calcula métricas de classificação de um modelo de diálogo.tools/quality/prediction_distinctness.py -calcula a metrics distinta de um modelo de diálogo.tools/quality/condition_quality.py - calcula métricas em diferentes subconjuntos de dados de acordo com o valor da condição.tools/generate_predictions.py - avalia o modelo. Gera previsões de um modelo de diálogo no conjunto de contextos de diálogo determinados e calcula métricas. Observe que você deve ter um modelo reverso no diretório de results/nn_models se desejar usar os modos de previsão "*-Reranking".tools/generate_predictions_for_condition.py - gera previsões para um determinado valor de condição.tools/test_api.py -código de exemplo para enviar solicitações para um http-server em execução.tools/fetch.py -Download dos arquivos de modelo e índice pré-treinados associados a ele.tools/telegram_bot.py - Executa o Telegram Bot no topo do modelo treinado. Todos os parâmetros de configuração para as etapas de arquitetura de rede, treinamento, previsão e log são definidas em cakechat/config.py . Alguns parâmetros de inferência usados em um servidor http são definidos em cakechat/api/config.py .
Arquitetura e tamanho de rede
HIDDEN_LAYER_DIMENSION é o parâmetro principal que define o número de unidades ocultas em camadas recorrentes.WORD_EMBEDDING_DIMENSION e CONDITION_EMBEDDING_DIMENSION definem o número de unidades ocultas nas quais cada token/condição é mapeado.tokens_index .Algoritmo de decodificação:
PREDICTION_MODE_FOR_TESTS define como as respostas do modelo são geradas. As opções são as seguintes:DEFAULT_TEMPERATURE .SAMPLES_NUM_FOR_RERANKING e MMI_REVERSE_MODEL_SCORE_WEIGHT Parâmetros. Observe que existem outros parâmetros que afetam o processo de geração de resposta. Consulte REPETITION_PENALIZE_COEFFICIENT , NON_PENALIZABLE_TOKENS , MAX_PREDICTIONS_LENGTH .
Ao fornecer rótulos de condição adicionais nas entradas do conjunto de dados, você pode criar os seguintes modelos:
Para fazer uso dessas condições extras, consulte a seção treinando o modelo. Basta definir o campo "Condição" no conjunto de treinamento como um dos seguintes: ID persona , emoção ou rótulo de tópico , atualizar os arquivos de índice e iniciar o treinamento.
O Cakechat é desenvolvido e mantido pela equipe Replika:
Nicolas Ivanov, Michael Khalman, Nikita Smetanin, Artem Rodichev e Denis Fedorenko.
Demoção de Oleg Akbarov, Alexander Kuznetsov e Vladimir Chernosvitov.
Todos os problemas e solicitações de recursos podem ser rastreados aqui - problemas do GitHub.
© 2019 Luka, Inc. Licenciado sob a licença Apache, versão 2.0. Consulte o arquivo de licença para obter mais detalhes.
