OSCHINA-MIRROR/mirrors-plato-research-dialogue-system

Платон поддерживает настройку архитектуры агента под различные нужды, включая использование совместных компонентов, текстовых или голосовых модулей, а также любых других конфигураций. Эта модель отличается от стандартной архитектуры разговорного агента и позволяет загружать существующие или предварительно обученные модели в Платон.

Пользователи могут определять свою собственную архитектуру и/или подключать собственные компоненты к Платону, просто предоставив имя класса Python и путь к пакету этого модуля, а также аргументы инициализации модели. Всё, что нужно сделать пользователю, — это перечислить модули в том порядке, в котором они должны быть выполнены, и Платон позаботится обо всём остальном, включая упаковку ввода/вывода, объединение модулей в цепочку и управление диалогами. Платон поддерживает последовательное и параллельное выполнение модулей.

Платон также обеспечивает поддержку байесовской оптимизации архитектур разговорного ИИ или отдельных параметров модуля с помощью байесовской оптимизации комбинаторных структур (BOCS).

Установка

Прежде всего убедитесь, что на вашем компьютере установлена версия Python 3.6 или выше. Затем вам необходимо клонировать репозиторий Платона:

git clone git@github.com:uber-research/plato-research-dialogue-system.git

Далее вам нужно установить некоторые предварительные условия:

TensorFlow:
```
pip install tensorflow>=1.14.0
```
Установите библиотеку SpeechRecognition для поддержки аудио:
```
pip install SpeechRecognition
```

Для MacOS:

brew install portaudio
brew install gmp 
pip install pyaudio

Для Ubuntu/Debian:
```
sudo apt-get install python3-pyaudio
```
Для Windows: ничего не нужно устанавливать заранее.

Следующим шагом будет установка Платона. Чтобы установить Платон, вы должны установить его непосредственно из исходного кода.

Установка Платона из исходного кода (рекомендуется)

Установка Платона из исходного кода позволяет установить его в редактируемом режиме, что означает, что если вы внесёте изменения в исходный код, это напрямую повлияет на выполнение.

Перейдите в каталог Платона (где вы клонировали репозиторий Plato на предыдущем шаге).
Мы рекомендуем создать новую среду Python. Чтобы настроить новую среду Python: 2.1 установите virtualenv:
```
sudo pip install virtualenv
```
2.2 создайте новую среду Python:
```
python3 -m venv </path/to/new/virtual/environment>
```
2.3 активируйте новую среду Python:
```
source </path/to/new/virtual/environment/bin>/bin/activate
```
Установите Платон:
```
pip install -e . 
```

Чтобы поддерживать речь, необходимо установить PyAudio, который имеет ряд зависимостей, которые могут отсутствовать на машине разработчика. Если описанные выше шаги не увенчались успехом, этот пост об ошибке установки PyAudio включает инструкции о том, как получить эти зависимости и установить PyAudio.

Общие проблемы при установке

Файл CommonIssues.md содержит общие проблемы и их решения, с которыми пользователь может столкнуться во время установки.

Запуск Платона

После установки вы можете просто запустить команду plato в терминале. Команда plato получает 4 подкоманды:

run
gui
domain
parse

Каждая из этих подкоманд получает значение аргумента --config, которое указывает на файл конфигурации. Мы подробно опишем эти файлы конфигурации позже в документе, но помните, что plato run --config и plato gui --config получают файл конфигурации приложения (примеры можно найти здесь: Пример использования Plato: построение диалогового агента

В запросе рассматривается использование инструмента Plato для построения диалоговых агентов. В тексте описывается, как создать и настроить приложение в Plato, которое включает три основные части: домен, контроллер и агент.

Домен представляет собой набор данных, которые используются для обучения модели. Контроллер управляет взаимодействием между агентами. Агент отвечает за обработку запросов пользователя и генерацию ответов.

Для создания домена необходимо указать путь к файлу с данными, а также пути для сохранения базы данных и файла онтологии. Также нужно определить, какие слоты будут доступны пользователю, агенту и системе.

После создания конфигурации домена можно запустить команду для генерации файлов базы данных и онтологии. Если всё прошло успешно, эти файлы появятся в указанном каталоге.

Контроллер — это объект, который координирует взаимодействие между агентами. Он создаёт экземпляры агентов, инициализирует их перед каждым диалогом, передаёт входные и выходные данные и отслеживает статистику.

Чтобы запустить диалоговый агент, нужно выполнить команду с указанием пути к конфигурационному файлу. Примеры таких файлов можно найти в каталоге example/config/application/.

Примечание: В ответе переведён только основной текст запроса. Специальные символы и форматирование оставлены без изменений. Парсеры для наборов данных DSTC2 и MetaLWOZ.

В качестве примера использования этих парсеров для офлайн-обучения в Plato мы будем использовать набор данных DSTC2, который можно получить с веб-сайта 2-го конкурса по отслеживанию состояния диалога:

http://camdial.org/~mh521/dstc/downloads/dstc2_traindev.tar.gz

После завершения загрузки необходимо разархивировать файл. Файл конфигурации для анализа этого набора данных находится в example/config/parser/Parse_DSTC2.yaml.

Вы можете проанализировать данные, которые вы скачали, сначала отредактировав значение data_path в example/config/parser/Parse_DSTC2.yaml, чтобы указать путь к месту, куда вы загрузили и разархивировали данные DSTC2. Затем вы можете запустить скрипт анализа следующим образом:

plato parse --config Parse_DSTC2.yaml

Или вы можете написать свой собственный файл конфигурации и передать абсолютный адрес этого файла команде:

plato parse --config <абсолютный путь к файлу конфигурации анализа>

Выполнение этой команды запустит скрипт анализа для DSTC2 (который находится под plato/utilities/parser/parse_dstc2.py) и создаст обучающие данные для отслеживания состояния диалога, NLU и NLG как для пользователя, так и для системы в каталоге data корневого каталога этого репозитория. Теперь эти проанализированные данные можно использовать для обучения моделей различных компонентов Платона.

Обучение компонентов разговорных агентов

Существует несколько способов обучить каждый компонент агента Платона: онлайн (поскольку агент взаимодействует с другими агентами, симуляторами или пользователями) или офлайн. Кроме того, вы можете использовать алгоритмы, реализованные в Платоне, или внешние фреймворки, такие как TensorFlow, PyTorch, Keras, Ludwig и т. д.

Ludwig — это открытый фреймворк глубокого обучения, который позволяет обучать модели без написания кода. Вам нужно только проанализировать ваши данные в файлы .csv, создать конфигурацию Ludwig (в YAML), описывающую желаемую архитектуру, какие функции использовать из .csv и другие параметры, а затем просто запустить команду в терминале.

Людвиг также предоставляет API, с которым совместим Платон. Это позволяет Платону интегрироваться с моделями Людвига, то есть загружать или сохранять модели, обучать их и запрашивать.

Обучить NLU

В предыдущем разделе анализатор DSTC2 Платона создал несколько файлов .csv, которые можно использовать для обучения NLU и NLG. Существует один файл NLU .csv для системы (data/DSTC2_NLU_sys.csv) и один для пользователя (data/DSTC2_NLU_usr.csv). Они выглядят так:

transcript	intent	iob
дорогой ресторан, где подают вегетарианскую еду	inform	B-inform-pricerange O O O B-inform-food O
вегетарианская еда	inform	B-inform-food O
азиатская восточная кухня	inform	B-inform-food I-inform-food O O O
дорогой азиатский ресторан	inform	B-inform-pricerange O O O

Для обучения модели NLU вам необходимо написать файл конфигурации, который выглядит следующим образом:

input_features:
    -
        name: transcript
        type: sequence
        reduce_output: null
        encoder: parallel_cnn

output_features:
    -
        name: intent
        type: set
        reduce_output: null

    -
        name: iob
        type: sequence
        decoder: tagger
        dependencies: [intent]
        reduce_output: null

training:
    epochs: 100
    early_stop: 50
    learning_rate: 0.0025
    dropout: 0.5
    batch_size: 128

Пример этого конфигурационного файла существует в example/config/ludwig/ludwig_nlu_train.yaml. Тренировочное задание можно запустить, выполнив:

ludwig experiment \
       --model_definition_file example/config/ludwig/ludwig_nlu_train.yaml \
       --data_csv data/DSTC2_NLU_sys.csv \
       --output_directory models/camrest_nlu/sys/

Следующим шагом будет загрузка модели в конфигурацию приложения. В example/config/application/CamRest_model_nlu.yaml мы предоставляем конфигурацию приложения, которая имеет модель на основе NLU, а остальные компоненты не основаны на ML. Обновив путь к модели (model_path) до значения, которое вы указали. Диалог-менеджер Generic аргументы: DST: пакет: plato.agent.component.dialogue_state_tracker.slot_filling_dst класс: SlotFillingDST

  политика:
    пакет: plato.agent.component.dialogue_policy.deep_learning.supervised_policy
    класс: SupervisedPolicy
    аргументы:
      тренировка: True
      скорость обучения: 0,9
      уровень исследования: 0,995
      фактор дисконтирования: 0,95
      коэффициент затухания скорости обучения: 0,95
      коэффициент затухания уровня исследования: 0,995

      путь к политике: models/camrest_policy/sys/sys_supervised_data

...

Обратите внимание, что мы запускаем этого агента только для одного диалога, но обучаем в течение 100 эпох, используя опыт, загруженный из журналов:

plato run --config CamRest_model_supervised_policy_train.yaml

После завершения обучения мы можем протестировать нашу политику с обучением:

plato run --config CamRest_model_supervised_policy_test.yaml

Обучение политики диалога на основе Reinforce

В предыдущем разделе мы увидели, как обучить политику диалога с обучением. Теперь мы можем увидеть, как мы можем обучить политику на основе машинного обучения с подкреплением, используя алгоритм Reinforce. Для этого мы определяем соответствующий класс в файле конфигурации:

...

AGENT_0:
  роль: система
  max_turns: 15
  интервал тренировки: 500
  эпохи тренировки: 3
  мини-пакет тренировки: 200
  интервал сохранения: 5000

  ...

  DM:
    пакет: plato.agent.component.dialogue_manager.dialogue_manager_generic
    класс: DialogueManagerGeneric
    аргументы:
      DST:
        пакет: plato.agent.component.dialogue_state_tracker.slot_filling_dst
        класс: SlotFillingDST

      политика:
        пакет: plato.agent.component.dialogue_policy.deep_learning.reinforce_policy
        класс: ReinforcePolicy
        аргументы:
          тренировка: True
          скорость обучения: 0,9
          уровень исследования: 0,995
          фактор дисконтирования: 0,95
          коэффициент затухания скорости обучения: 0,95
          коэффициент затухания уровня исследования: 0,995

          путь к политике: models/camrest_policy/sys/sys_reinforce

  ...

Обратите внимание на параметры обучения под AGENT_0 и специфичные для алгоритма параметры под аргументами политики. Затем мы вызываем plato с этой конфигурацией:

plato run --config CamRest_model_reinforce_policy_train.yaml


и тестируем обученную модель политики:

plato run --config CamRest_model_reinforce_policy_test.yaml


*Примечание:* другие компоненты также можно обучить онлайн, либо используя API Ludwig, либо реализуя алгоритмы обучения в Plato.

*Также обратите внимание,* что файлы журналов можно загрузить и использовать в качестве пула опыта для любого компонента и алгоритма обучения. Однако вам может потребоваться реализовать собственные алгоритмы обучения для некоторых компонентов Plato.

**Тренировка NLG**

Чтобы обучить модуль NLG, вам необходимо написать файл конфигурации (например, `example/config/application/CamRest_model_nlg.yaml`):

input_features: - имя: nlg_input тип: последовательность кодировщик: rnn тип ячейки: lstm

output_features: - имя: nlg_output тип: последовательность декодер: генератор тип ячейки: lstm

обучение: эпохи: 20 скорость обучения: 0,001 отсев: 0,2


И обучите свою модель:

ludwig experiment
--model_definition_file example/config/ludwig/ludwig_nlg_train.yaml
--data_csv data/DSTC2_NLG_sys.csv
--output_directory models/camrest_nlg/sys/


Следующим шагом будет загрузка модели в Plato. Перейдите в файл конфигурации `CamRest_model_nlg.yaml` и при необходимости обновите путь:

...

NLG: пакет: applications.cambridge_restaurants.camrest_nlg класс: CamRestNLG аргументы: путь к модели: models/camrest_nlg/sys/experiment_run/model ...


и протестируйте работу модели:

plato run --config CamRest_model_nlg.yaml


Помните, что Ludwig будет создавать новый каталог *experiment_run_i* каждый раз, когда он вызывается, поэтому убедитесь, что вы поддерживаете правильный путь в конфигурации Plato в актуальном состоянии. Для создания, обучения и оценки нового компонента глубокого обучения в Plato вам потребуется написать совсем немного кода.

#### Обучите сквозного диалогового агента на основе Seq2Seq

В этом примере мы будем использовать набор данных MetalWoz, который можно скачать по ссылке [здесь](https://www.microsoft.com/en-us/research/project/metalwoz/).

Plato поддерживает совместно обученные модели через Generic Agents. Здесь мы рассмотрим шаги, необходимые для создания простого сквозного диалогового агента с нуля. Используя MetalWOZ в качестве примера, нам нужно сделать следующее:

##### 1. Напишите парсер данных MetalWOZ, который считывает данные и создаёт файлы CSV
Поскольку мы обучаем только простую модель seq2seq (текст в текст), нам нужен наш парсер для извлечения высказываний пользователя и системы. Они будут сохранены в файлах .csv, которые будут использоваться Ludwig на шаге 4.

Для простой реализации парсера MetalWOZ см. ````utilities/parser/Parse_MetalWOZ.py````.

Обратите внимание, что этот парсер будет анализировать только один файл (один домен). Вы можете легко изменить его в соответствии со своими потребностями. Вот пример вывода, созданного парсером для домена заказа пиццы:

| пользователь | система |
|-------------|--------|
| привет | Здравствуйте, чем я могу вам помочь? |
| Мне нужно оформить заказ на пиццу, нужна помощь | Конечно, что бы вы хотели добавить к своему заказу? |
| Я хочу пиццу с грибами, пепперони и беконом | К сожалению, в этом месте нет бекона, который вы просили. Может быть, вы хотите заменить его чем-то другим? |
| Как насчёт ананаса | Эта начинка доступна. Я добавил пиццу с грибами, пепперони и ананасом в ваш заказ. Какой размер вы бы хотели? |
| Средний | Хорошо, обновлено. Хотите добавить ещё что-нибудь к вашему заказу? |
| Это всё, спасибо | Хорошо, ваша общая сумма составляет 14,99. Ваша пицца будет готова к получению примерно через 20 минут. |

Обратите внимание, что первое высказывание пользователя на самом деле не существует в данных. Однако нам нужно что-то, чтобы побудить модель выдать приветствие системы — мы могли бы использовать пустое предложение или любое другое приветствие (или их комбинацию).

##### 2. Напишите конфигурацию для анализа plato
Затем вы можете запустить анализ plato следующим образом:

plato parse --config Parse_MetalWOZ.yaml


##### 3. Обучите сквозную модель
Чтобы начать работу, мы можем обучить очень простую модель с помощью Ludwig (не стесняйтесь использовать здесь свою любимую платформу глубокого обучения):

input_features: - name: user type: text level: word encoder: rnn cell_type: lstm reduce_output: null

output_features: - name: system type: text level: word decoder: generator cell_type: lstm attention: bahdanau

training: epochs: 100


Вы можете изменить эту конфигурацию, чтобы она отражала архитектуру по вашему выбору, и обучить её с помощью Ludwig:

ludwig train
--data_csv data/metalwoz.csv
--model_definition_file example/config/ludwig/metalWOZ_seq2seq_ludwig.yaml
--output_directory "models/joint_models/"


##### 4. Напишите класс, наследуемый от Conversational Module, который загружает и запрашивает модель
Этот класс просто должен обрабатывать загрузку модели, соответствующим образом запрашивать её и форматировать вывод соответствующим образом. В нашем случае нам нужно обернуть входной текст в фреймворк pandas, получить предсказанные токены из выходных данных и объединить их в строку, которая будет возвращена. См. класс здесь: `plato.agent.component.joint_model.metal_woz_seq2seq.py`

##### 5. Напишите общий yaml-файл конфигурации Plato и запустите своего агента!
См. `example/config/application/metalwoz_generic.yaml` для примера общего файла конфигурации, который взаимодействует с агентом seq2seq через текст. Вы можете попробовать это следующим образом:

plato run --config metalwoz_text.yaml


**Помните**, что необходимо обновить путь к вашей обученной модели, если это необходимо! По умолчанию путь предполагает, что вы запускаете команду ludwig train из корневого каталога Plato.

### Одновременное обучение нескольких диалоговых агентов

Одна из основных функций Plato позволяет двум агентам взаимодействовать друг с другом. Каждый агент может иметь... **Вероятность**

...

**Системный набор. Акт 2 -->** ...

Ключ представляет собой входной диалог (например, от разговорного агента «система»). Значение каждого ключа — это словарь из двух элементов, представляющих распределения вероятностей по диалогам или шаблонам высказываний, из которых симулятор будет брать выборку.

Чтобы увидеть пример, вы можете запустить следующую конфигурацию:

`plato run --config CamRest_dtl_simulator.yaml`

### Создание нового модуля

Есть два способа создать новый модуль в зависимости от его функции. Если модуль, например, реализует новый способ выполнения NLU или политики диалога, то вам следует написать класс, который наследуется от соответствующего абстрактного класса.

Если же модуль не подходит ни к одному из основных компонентов одного агента, например, он выполняет распознавание именованных сущностей или предсказывает диалоги на основе текста, то вы должны написать класс, наследующийся непосредственно от `conversational_module`. Затем вы можете загрузить модуль через универсальный агент, предоставив соответствующий путь к пакету, имя класса и аргументы в конфигурации.

... MODULE_i: package: my_package.my_module Class: MyModule arguments: model_path: models/my_module/parameters/ ... ...


**Будьте осторожны!** Вы отвечаете за то, чтобы ввод-вывод этого модуля мог быть обработан и использован модулями до и после него, как указано в вашем общем файле конфигурации.

Plato также поддерживает (логически) параллельное выполнение модулей. Чтобы включить это, вам нужно иметь следующую структуру в вашей конфигурации:

... MODULE_i: parallel_modules: 5

PARALLEL_MODULE_0:
    package: my_package.my_module
    Class: MyModule
    arguments:
      model_path: models/myModule/parameters/
      ...
      
PARALLEL_MODULE_1:
    package: my_package.my_module
    Class: MyModule
    arguments:
      model_path: models/my_module/parameters/
      ...
      
...

...


**Будьте осторожны!** Выходные данные модулей, выполняемых параллельно, будут упакованы в список. Следующий модуль (например, MODULE_i+1) должен будет уметь обрабатывать этот тип ввода. **Предоставленные модули Plato не предназначены для обработки такого рода данных, вам потребуется написать собственный модуль для обработки ввода из нескольких источников.**

#### Создание новых состояний, действий, алгоритмов обучения и т. д.

Платон разработан так, чтобы его можно было расширять, поэтому не стесняйтесь создавать свои собственные состояния диалога, действия, функции вознаграждения, алгоритмы или любые другие компоненты в соответствии с вашими конкретными потребностями. Вам нужно только наследовать от соответствующего класса, чтобы ваша реализация была совместима с Платоном.

## Графический интерфейс пользователя

В Plato используется [PySimpleGUI](https://pysimplegui.readthedocs.io/en/latest/) для работы с графическими интерфейсами пользователя. Пример графического интерфейса для Plato реализован в `plato.controller.sgui_controller`, и вы можете попробовать его, используя следующую команду:

`plato gui --config CamRest_GUI_speech.yaml`

# Предстоящие учебные пособия

1. Использование предварительно обученных моделей (BERT, GPT и т.д.) в Plato
2. Многодоменные разговорные агенты
3. Многоязычные разговорные агенты

# Предстоящие функции

1. Принципиальное ведение журнала и печать
2. Больше парсеров наборов данных
3. Дополнительные опции для контроллеров с несколькими агентами
4. Байесовская оптимизация в Plato

# Благодарности

Особая благодарность Махди Намазифару, Чандре Хатри, И-Чиа Вангу, Пьеро Молино, Майклу Пирсу, Заку Кейдену и Гохану Туру за их вклад и поддержку, а также [studio FF3300](http://ff3300.com/) за разрешение использовать шрифт Messapia.

# Заключение

Пожалуйста, поймите, что многие функции всё ещё находятся в стадии разработки, и некоторые варианты использования могут ещё не поддерживаться.

Наслаждайтесь!