cakechat
v2.0.1
Nota en la parte superior: el proyecto no se mantiene.
Los modelos de diálogo basados en transformadores funcionan mejor y recomendamos usarlos en lugar de Cakechat basado en RNN. Ver, por ejemplo, https://github.com/microsoft/dialogpt
Cakechat es un backend para chatbots que pueden expresar emociones a través de conversaciones.
Cakechat se basa en Keras y Tensorflow.
El código es flexible y permite acondicionar las respuestas del modelo mediante una variable categórica arbitraria. Por ejemplo, puede entrenar su propio modelo de conversación neural basado en personal [1] o crear una máquina de chat emocional [2] .
Modelo:
Capa de incrustación de palabras:
Descodificación
Métrica:
En caso de que esté familiarizado con Docker aquí, es la forma más fácil de ejecutar un modelo Cakechat previamente capacitado como servidor. Es posible que deba ejecutar los siguientes comandos con sudo .
Versión de 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"
Versión de 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"
¡Eso es todo! Ahora pruebe su servidor Cakechat ejecutando el siguiente comando en su máquina host:
python tools/test_api.py -f localhost -p 8080 -c "hi!" -c "hi, how are you?" -c "good!" -e "joy"
El dict de respuesta puede verse así:
{'response': "I'm fine!"}
Docker es la forma más fácil de configurar el entorno e instalar todas las dependencias para capacitación y pruebas.
Nota: Recomendamos encarecidamente el uso de un entorno habilitado para GPU para capacitar al modelo Cakechat. La inferencia se puede hacer tanto en las GPU como en las CPU.
Instale Docker.
Tire de una imagen Docker solo de CPU de Dockerhub:
docker pull lukalabs/cakechat:latest
docker run --name <YOUR_CONTAINER_NAME> -it lukalabs/cakechat:latest
Instale NVIDIA-Docker para el soporte de GPU.
Extraiga la imagen Docker habilitada para GPU de DockerHub:
docker pull lukalabs/cakechat-gpu:latest
nvidia-docker run --name <YOUR_CONTAINER_NAME> -it cakechat-gpu:latest
¡Eso es todo! Ahora puede entrenar a su modelo y chatear con él. Consulte la sección correspondiente a continuación para obtener más instrucciones.
Si no desea tratar con Docker, puede instalar todos los requisitos manualmente:
pip install -r requirements.txt -r requirements-local.txt
NÓTESE BIEN:
Recomendamos instalar los requisitos dentro de un VirtualEnv para evitar que se meta con los paquetes de su sistema.
Puede descargar nuestros pesos de modelo previamente capacitados ejecutando python tools/fetch.py .
Los parámetros del modelo previamente capacitado son los siguientes:
El modelo fue entrenado en un corpus de Twitter preprocesado con ~ 50 millones de diálogo (11 GB de datos de texto). Para limpiar el corpus, eliminamos
Usamos nuestro clasificador de emociones para etiquetar cada enunciado con una de las siguientes 5 emociones: "neutral", "joy", "anger", "sadness", "fear" y usaron estas etiquetas durante el entrenamiento. Para marcar su propio corpus con emociones, puede usar, por ejemplo, la herramienta Deepmoji.
Desafortunadamente, debido a la política de privacidad de Twitter, no se nos permite proporcionar nuestro conjunto de datos. Puede entrenar un modelo de diálogo en cualquier conjunto de datos de conversación de texto disponible para usted, se puede encontrar una gran descripción de los conjuntos de datos de conversación existentes aquí: https://breakend.github.io/dialogdatasets/
Los datos de capacitación deben ser un archivo txt, donde cada línea es un objeto JSON válido, que representa una lista de expresiones de diálogo. Consulte nuestro conjunto de datos de tren ficticio para ver la estructura de archivos necesaria. Reemplace este corpus ficticio con sus datos antes de entrenar.
Hay dos opciones:
El primer enfoque es menos restrictivo: puede usar los datos de capacitación que desee y establecer cualquier parámetro de configuración del modelo. Sin embargo, debe tener en cuenta que necesitará suficientes datos de trenes (al menos ~ 50 MB), una o más GPU y suficiente paciencia (días) para obtener las respuestas del modelo de buenas.
El segundo enfoque está limitado por la elección de los parámetros de configuración del modelo previamente capacitado: consulte cakechat/config.py para la lista completa. Si los parámetros predeterminados son adecuados para su tarea, el ajuste fino debería ser una buena opción.
Obtenga el modelo previamente capacitado de Amazon S3 ejecutando python tools/fetch.py .
Coloque su corpus de texto de entrenamiento en data/corpora_processed/train_processed_dialogs.txt . Asegúrese de que su conjunto de datos sea lo suficientemente grande, de lo contrario, su modelo corre el riesgo de sobrevivir los datos y los resultados serán pobres.
Ejecute python tools/train.py .
results/nn_models , la ruta completa se infiere del conjunto de parámetros de configuración.-i , por ejemplo, python tools/train.py -i results/nn_models/my_saved_weights/model.current .CUDA_VISIBLE_DEVICES=<GPU_ID> Variable de entorno (con <GPU_ID> como en la salida del comando nvidia-smi ) si desea usar GPU. Por ejemplo, CUDA_VISIBLE_DEVICES=0 python tools/train.py ejecutará el proceso de trenes en la GPU 0-Th.-s para entrenar el modelo en un subconjunto de las primeras N muestras de sus datos de entrenamiento para acelerar el preprocesamiento para la depuración. Por ejemplo, ejecute python tools/train.py -s 1000 para entrenar en las primeras 1000 muestras. Los pesos del modelo entrenado se guardan en results/nn_models/ .
Coloque su corpus de texto de entrenamiento en data/corpora_processed/train_processed_dialogs.txt .
Configurar los parámetros de entrenamiento en cakechat/config.py . Consulte la descripción de la configuración de la configuración para obtener más detalles.
Considere ejecutar PYTHONHASHSEED=42 python tools/prepare_index_files.py para construir los archivos de índice con tokens y condiciones del corpus de entrenamiento. Asegúrese de establecer la variable de entorno PYTHONHASHSEED , de lo contrario, puede obtener diferentes archivos de índice para diferentes lanzamientos del script. ADVERTENCIA: Este script sobrescribe los archivos de tokens originales data/tokens_index/t_idx_processed_dialogs.json y data/conditions_index/c_idx_processed_dialogs.json . Solo debe ejecutar este script en caso de que su corpus sea lo suficientemente grande como para contener todas las palabras que desea que su modelo comprenda. De lo contrario, considere ajustar el modelo previamente capacitado como se describe anteriormente. Si se equivocó con los archivos de índice y desea obtener las versiones predeterminadas, elimine sus copias y ejecute python tools/fetch.py ANEW.
Considere ejecutar python tools/train_w2v.py para construir W2V Incrusting desde el corpus de entrenamiento. ADVERTENCIA: Este script sobrescribe los pesos W2V originales que se almacenan en data/w2v_models . Solo debe ejecutar este script en caso de que su corpus sea lo suficientemente grande como para contener todas las palabras que desea que su modelo comprenda. De lo contrario, considere ajustar el modelo previamente capacitado como se describe anteriormente. Si se equivocó con archivos W2V y desea obtener la versión predeterminada, elimine su archivo Copiar y ejecutar python tools/fetch.py Anew.
Ejecute python tools/train.py .
CUDA_VISIBLE_DEVICES=<GPU_ID> Variable de entorno (con <GPU_ID> como en la salida del comando nvidia-smi ) si desea usar GPU. Por ejemplo, CUDA_VISIBLE_DEVICES=0 python tools/train.py ejecutará el proceso de tren en la GPU 0-Th.-s para entrenar el modelo en un subconjunto de las primeras N muestras de sus datos de entrenamiento para acelerar el preprocesamiento para la depuración. Por ejemplo, ejecute python tools/train.py -s 1000 para entrenar en las primeras 1000 muestras. También puede configurar IS_DEV=1 para habilitar el "Modo de desarrollo". Utiliza un número reducido de parámetros del modelo (disminución de las dimensiones de la capa oculta, los tamaños de entrada y salida de las secuencias de token, etc.) y realiza el registro verboso. Consulte las líneas inferiores de cakechat/config.py para obtener la lista completa de parámetros de Dev.
Los pesos del modelo entrenado se guardan en results/nn_models/ .
El contenedor Docker habilitado para GPU admite el tren distribuido en múltiples GPU usando Horovod.
Por ejemplo, ejecute python tools/distributed_train.py -g 0 1 para comenzar a entrenar en GPU 0 y 1.
Durante la capacitación, los siguientes conjuntos de datos se utilizan para el cálculo de las métricas de validaciones:
data/corpora_processed/val_processed_dialogs.txt (ejemplo ficticio, reemplazar con sus datos)-para el conjunto de datos sensible al contextodata/quality/context_free_validation_set.txt -para el conjunto de datos de validación sin contextodata/quality/context_free_questions.txt : se utiliza para generar respuestas para registrar y calcular la meternica distintivadata/quality/context_free_test_set.txt : se utiliza para calcular las métricas del modelo capacitado, por ejemplo, métricas de clasificación Las métricas se almacenan para cakechat/results/tensorboard y se pueden visualizar con TensorBoard. Si ejecuta un contenedor Docker desde la CPU proporcionada o la imagen Docker habilitada para GPU, TensorBoard Server debe comenzar automáticamente y servir en http://localhost:6006 . Abra este enlace en su navegador para ver los gráficos de entrenamiento.
Si instaló los requisitos manualmente, inicie el servidor TensorBoard primero ejecutando el siguiente comando desde su directorio raíz de Cakechat:
mkdir -p results/tensorboard && tensorboard --logdir=results/tensorboard 2>results/tensorboard/err.log &
Después de eso, proceda a http://localhost:6006 .
Puede ejecutar las siguientes herramientas para evaluar su modelo capacitado en los datos de prueba (ejemplo ficticio, reemplazar con sus datos):
tools/quality/ranking_quality.py : calcula las métricas de clasificación de un modelo de diálogotools/quality/prediction_distinctness.py : calcula la mética distinta de un modelo de diálogotools/quality/condition_quality.py : calcula las métricas en diferentes subconjuntos de datos de acuerdo con el valor de la condicióntools/generate_predictions.py : evalúa el modelo. Genera predicciones de un modelo de diálogo en el conjunto de contextos de diálogo dados y luego calcula las métricas. Tenga en cuenta que debe tener un modelo inverso en el directorio data/nn_models si desea usar modos de predicción "**-reranking"tools/generate_predictions_for_condition.py : genera predicciones para un valor de condición dado Ejecute un servidor que procesa http-requisitos con mensajes de entrada dados y devuelve mensajes de respuesta del modelo:
python bin/cakechat_server.py
Especifique CUDA_VISIBLE_DEVICES=<GPU_ID> Variable de entorno para ejecutar el servidor en una determinada GPU.
No olvide ejecutar python tools/fetch.py antes de iniciar el servidor si desea usar nuestro modelo previamente capacitado.
Para asegurarse de que todo funcione bien, pruebe el modelo en la siguiente conversación
- Hola, Eddie, ¿qué pasa?
- No mucho, ¿y tú?
- Bien, gracias. ¿Vas al cine mañana?
ejecutando el 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?"
Debe obtener una respuesta significativa, por ejemplo:
{'response': "Of course!"}
Los parámetros JSON son:
| Parámetro | Tipo | Descripción |
|---|---|---|
| contexto | Lista de cuerdas | Lista de mensajes anteriores del historial de diálogo (Max. 3 se usa) |
| emoción | cadena, uno de enum | Uno de {'neutral', 'ira', 'alegría', 'miedo', 'tristeza'}. Una emoción para condicionar la respuesta. Parámetro opcional, si no se especifica, se utiliza 'Neutral' |
POST /cakechat_api/v1/actions/get_response
data: {
'context': ['Hello', 'Hi!', 'How are you?'],
'emotion': 'joy'
}
200 OK
{
'response': 'I'm fine!'
}
Recomendamos usar Gunicorn para servir a la API de su modelo a escala de producción.
Instalar Gunicorn: pip install gunicorn
Ejecute un servidor que procesa las Operias HTTP con mensajes de entrada y devuelve mensajes de respuesta del modelo:
cd bin && gunicorn cakechat_server:app -w 1 -b 127.0.0.1:8080 --timeout 2000
Puede ejecutar su modelo Cakechat como un bot de telegrama:
python tools/telegram_bot.py --token <YOUR_BOT_TOKEN> y chatee con él en Telegram. cakechat/dialog_model/ - Contiene gráfico computacional, procedimiento de capacitación y otras utilidades modelocakechat/dialog_model/inference/ - Algoritmos para la generación de respuestacakechat/dialog_model/quality/ - CÓDIGO PARA Cálculo y registro de métricascakechat/utils/ - Utilidades para el procesamiento de texto, capacitación W2V, etc.cakechat/api/ - Funciones para ejecutar el servidor HTTP: configuración de API, manejo de errorestools/ - Scripts para capacitación, prueba y evaluación de su modelobin/cakechat_server.py : ejecuta un servidor HTTP que devuelve mensajes de respuesta del modelo con contextos de diálogo y una emoción. Consulte la sección Ejecutar para más detalles.tools/train.py : entrena el modelo en sus datos. Puede usar la opción --reverse para entrenar un modelo inverso utilizado en algoritmos de generación de respuesta "*reriables" para predicciones más precisas.tools/prepare_index_files.py : prepara el índice para los tokens y condiciones más utilizados. Use este script antes de entrenar el modelo desde cero en sus propios datos.tools/quality/ranking_quality.py : calcula las métricas de clasificación de un modelo de diálogo.tools/quality/prediction_distinctness.py : calcula la mética distinta de un modelo de diálogo.tools/quality/condition_quality.py : calcula las métricas en diferentes subconjuntos de datos de acuerdo con el valor de la condición.tools/generate_predictions.py : evalúa el modelo. Genera predicciones de un modelo de diálogo en el conjunto de contextos de diálogo dados y luego calcula las métricas. Tenga en cuenta que debe tener un modelo inverso en el directorio de results/nn_models si desea usar modos de predicción "*-reranking".tools/generate_predictions_for_condition.py : genera predicciones para un valor de condición dado.tools/test_api.py : código de ejemplo para enviar solicitudes a un http-server.tools/fetch.py : descarga el modelo previamente capacitado y los archivos de índice asociados con él.tools/telegram_bot.py : ejecuta Bot Telegram en la parte superior del modelo entrenado. Todos los parámetros de configuración para la arquitectura de red, la capacitación, la predicción y los pasos de registro se definen en cakechat/config.py . Algunos parámetros de inferencia utilizados en un servidor HTTP se definen en cakechat/api/config.py .
Arquitectura y tamaño de la red
HIDDEN_LAYER_DIMENSION es el parámetro principal que define el número de unidades ocultas en capas recurrentes.WORD_EMBEDDING_DIMENSION y CONDITION_EMBEDDING_DIMENSION Definen el número de unidades ocultas en las que se asignan cada token/condición.tokens_index .Algoritmo de decodificación:
PREDICTION_MODE_FOR_TESTS define cómo se generan las respuestas del modelo. Las opciones son las siguientes:DEFAULT_TEMPERATURE .SAMPLES_NUM_FOR_RERANKING y los parámetros MMI_REVERSE_MODEL_SCORE_WEIGHT . Tenga en cuenta que hay otros parámetros que afectan el proceso de generación de respuesta. Consulte REPETITION_PENALIZE_COEFFICIENT , NON_PENALIZABLE_TOKENS , MAX_PREDICTIONS_LENGTH .
Al proporcionar etiquetas de condición adicionales dentro de las entradas del conjunto de datos, puede construir los siguientes modelos:
Para utilizar estas condiciones adicionales, consulte la sección Capacitación del modelo. Simplemente establezca el campo "Condición" en el conjunto de capacitación en uno de los siguientes: ID de personalidad , Etiqueta de emoción o tema , actualice los archivos de índice y comience la capacitación.
Cakechat es desarrollado y mantenido por el equipo replika:
Nicolas Ivanov, Michael Khalman, Nikita Smetanin, Artem Rodichev y Denis Fedorenko.
Demo de Oleg Akbarov, Alexander Kuznetsov y Vladimir Chernosvitov.
Todos los problemas y solicitudes de funciones se pueden rastrear aquí: problemas de GitHub.
© 2019 Luka, Inc. licenciado bajo la licencia Apache, versión 2.0. Consulte el archivo de licencia para obtener más detalles.
