From ee25bdb8755dda56deca25175df7af041b5d8ffd Mon Sep 17 00:00:00 2001 From: Dave Taniguchi Date: Tue, 9 Jul 2019 14:27:37 -0700 Subject: [PATCH 1/2] Corebot 101 initial checkin --- .../101.corebot-bert-bidaf/Dockerfile_bot | 35 ++ .../Dockerfile_model_runtime | 30 ++ .../101.corebot-bert-bidaf/NOTICE.md | 8 + .../101.corebot-bert-bidaf/README.md | 336 ++++++++++++++++ .../bot/bots/__init__.py | 10 + .../bot/bots/dialog_and_welcome_bot.py | 42 ++ .../bot/bots/dialog_bot.py | 34 ++ .../bot/bots/resources/welcomeCard.json | 46 +++ .../101.corebot-bert-bidaf/bot/config.py | 24 ++ .../bot/dialogs/__init__.py | 13 + .../bot/dialogs/booking_dialog.py | 95 +++++ .../bot/dialogs/cancel_and_help_dialog.py | 37 ++ .../bot/dialogs/date_resolver_dialog.py | 63 +++ .../bot/dialogs/main_dialog.py | 81 ++++ .../bot/helpers/__init__.py | 10 + .../bot/helpers/activity_helper.py | 26 ++ .../bot/helpers/dialog_helper.py | 19 + .../101.corebot-bert-bidaf/bot/main.py | 60 +++ .../bot/requirements.txt | 41 ++ .../docker/docker-compose.yml | 20 + .../media/jupyter_lab_bert_complete.PNG | Bin 0 -> 117341 bytes .../media/jupyter_lab_bert_runtime.PNG | Bin 0 -> 58729 bytes .../media/jupyter_lab_bert_train.PNG | Bin 0 -> 54254 bytes .../media/jupyter_lab_bidaf_runtime.PNG | Bin 0 -> 79956 bytes .../media/jupyter_lab_model_nav.PNG | Bin 0 -> 116037 bytes .../media/jupyter_lab_run_all_cells.PNG | Bin 0 -> 101699 bytes .../media/jupyter_lab_select_kernel.PNG | Bin 0 -> 15738 bytes .../model/model_corebot101/about.py | 12 + .../model_corebot101/bert/common/__init__.py | 12 + .../model_corebot101/bert/common/bert_util.py | 156 ++++++++ .../bert/common/input_example.py | 22 ++ .../bert/common/input_features.py | 11 + .../bert/model_runtime/__init__.py | 8 + .../bert/model_runtime/bert_model_runtime.py | 114 ++++++ .../model_corebot101/bert/requirements.txt | 3 + .../model_corebot101/bert/train/__init__.py | 13 + .../model/model_corebot101/bert/train/args.py | 50 +++ .../bert/train/bert_train_eval.py | 373 ++++++++++++++++++ .../bert/train/flight_booking_processor.py | 51 +++ .../bert/training_data/FlightBooking.json | 241 +++++++++++ .../bidaf/model_runtime/__init__.py | 8 + .../model_runtime/bidaf_model_runtime.py | 105 +++++ .../model_corebot101/bidaf/requirements.txt | 3 + .../model/model_corebot101/booking_details.py | 11 + .../model/model_corebot101/language_helper.py | 178 +++++++++ .../101.corebot-bert-bidaf/model/setup.py | 51 +++ .../model_runtime_svc_corebot101/__init__.py | 8 + .../model_runtime_svc_corebot101/about.py | 12 + .../docker_init.py | 18 + .../handlers/__init__.py | 2 + .../handlers/model_handler.py | 51 +++ .../model_runtime_svc_corebot101/main.py | 91 +++++ .../model_cache.py | 58 +++ .../model_runtime_svc/setup.py | 45 +++ .../notebooks/bert_model_runtime.ipynb | 323 +++++++++++++++ .../notebooks/bert_train.ipynb | 281 +++++++++++++ .../notebooks/bidaf_model_runtime.ipynb | 228 +++++++++++ .../notebooks/model_runtime.ipynb | 206 ++++++++++ .../101.corebot-bert-bidaf/requirements.txt | 41 ++ 59 files changed, 3816 insertions(+) create mode 100644 samples/python_flask/101.corebot-bert-bidaf/Dockerfile_bot create mode 100644 samples/python_flask/101.corebot-bert-bidaf/Dockerfile_model_runtime create mode 100644 samples/python_flask/101.corebot-bert-bidaf/NOTICE.md create mode 100644 samples/python_flask/101.corebot-bert-bidaf/README.md create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/bots/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/bots/dialog_and_welcome_bot.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/bots/dialog_bot.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/bots/resources/welcomeCard.json create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/config.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/booking_dialog.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/cancel_and_help_dialog.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/date_resolver_dialog.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/main_dialog.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/helpers/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/helpers/activity_helper.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/helpers/dialog_helper.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/main.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/bot/requirements.txt create mode 100644 samples/python_flask/101.corebot-bert-bidaf/docker/docker-compose.yml create mode 100644 samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bert_complete.PNG create mode 100644 samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bert_runtime.PNG create mode 100644 samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bert_train.PNG create mode 100644 samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bidaf_runtime.PNG create mode 100644 samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_model_nav.PNG create mode 100644 samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_run_all_cells.PNG create mode 100644 samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_select_kernel.PNG create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/about.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/bert_util.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/input_example.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/input_features.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/model_runtime/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/model_runtime/bert_model_runtime.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/requirements.txt create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/args.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/bert_train_eval.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/flight_booking_processor.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/training_data/FlightBooking.json create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/model_runtime/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/model_runtime/bidaf_model_runtime.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/requirements.txt create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/booking_details.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/language_helper.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model/setup.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/about.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/docker_init.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/handlers/__init__.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/handlers/model_handler.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/main.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/model_cache.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/setup.py create mode 100644 samples/python_flask/101.corebot-bert-bidaf/notebooks/bert_model_runtime.ipynb create mode 100644 samples/python_flask/101.corebot-bert-bidaf/notebooks/bert_train.ipynb create mode 100644 samples/python_flask/101.corebot-bert-bidaf/notebooks/bidaf_model_runtime.ipynb create mode 100644 samples/python_flask/101.corebot-bert-bidaf/notebooks/model_runtime.ipynb create mode 100644 samples/python_flask/101.corebot-bert-bidaf/requirements.txt diff --git a/samples/python_flask/101.corebot-bert-bidaf/Dockerfile_bot b/samples/python_flask/101.corebot-bert-bidaf/Dockerfile_bot new file mode 100644 index 000000000..322372e67 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/Dockerfile_bot @@ -0,0 +1,35 @@ +FROM tiangolo/uwsgi-nginx-flask:python3.6 + +# Setup for nginx +RUN mkdir -p /home/LogFiles \ + && apt update \ + && apt install -y --no-install-recommends vim + +EXPOSE 3978 + +COPY /model /model + +# Pytorch very large. Install from wheel. +RUN wget https://files.pythonhosted.org/packages/69/60/f685fb2cfb3088736bafbc9bdbb455327bdc8906b606da9c9a81bae1c81e/torch-1.1.0-cp36-cp36m-manylinux1_x86_64.whl +RUN pip3 install torch-1.1.0-cp36-cp36m-manylinux1_x86_64.whl + +RUN pip3 install -e /model/ + + +COPY ./bot /bot + +RUN pip3 install -r /bot/requirements.txt + +ENV FLASK_APP=/bot/main.py +ENV LANG=C.UTF-8 +ENV LC_ALL=C.UTF-8 +ENV PATH ${PATH}:/home/site/wwwroot + +WORKDIR bot +# Initialize models + + +# For Debugging, uncomment the following: +#ENTRYPOINT ["python3.6", "-c", "import time ; time.sleep(500000)"] +ENTRYPOINT [ "flask" ] +CMD [ "run", "--port", "3978", "--host", "0.0.0.0" ] diff --git a/samples/python_flask/101.corebot-bert-bidaf/Dockerfile_model_runtime b/samples/python_flask/101.corebot-bert-bidaf/Dockerfile_model_runtime new file mode 100644 index 000000000..d2387d3b8 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/Dockerfile_model_runtime @@ -0,0 +1,30 @@ +# https://github.com/tornadoweb/tornado/blob/master/demos/blog/Dockerfile +FROM python:3.6 + +# Port the model runtime service will listen on. +EXPOSE 8880 + +# Make structure where the models will live. +RUN mkdir -p /cognitiveModels/bert +RUN mkdir -p /cognitiveModels/bidaf + +# Copy and install models. +COPY model /model/ +#RUN pip3 install --upgrade pip +#RUN pip3 install --upgrade nltk +RUN wget https://files.pythonhosted.org/packages/69/60/f685fb2cfb3088736bafbc9bdbb455327bdc8906b606da9c9a81bae1c81e/torch-1.1.0-cp36-cp36m-manylinux1_x86_64.whl +RUN pip3 install torch-1.1.0-cp36-cp36m-manylinux1_x86_64.whl +RUN pip3 install -e /model + +# Copy and install model runtime service api. +COPY model_runtime_svc /model_runtime_svc/ +RUN pip3 install -e /model_runtime_svc + +# One time initialization of the models. +RUN python3 /model_runtime_svc/model_runtime_svc_corebot101/docker_init.py +RUN rm /model_runtime_svc/model_runtime_svc_corebot101/docker_init.py + +# -c "from model_corebot101.language_helper import LanguageHelper; lh = LanguageHelper(). lh.initialize_models(bert_model_dir='/model_runtime_api/model/bert', bidaf_model_dir='/model_runtime_api/model/bidaf')" +WORKDIR /model_runtime_svc + +ENTRYPOINT ["python3", "./model_runtime_svc_corebot101/main.py"] \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/NOTICE.md b/samples/python_flask/101.corebot-bert-bidaf/NOTICE.md new file mode 100644 index 000000000..984258e65 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/NOTICE.md @@ -0,0 +1,8 @@ +## NOTICE + +Please note that while the 101.corebot-bert-bidaf sample is licensed under the MIT license, the sample has dependencies that use other types of licenses. + +Since Microsoft does not modify nor distribute these dependencies, it is the sole responsibility of the user to determine the correct/compliant usage of these dependencies. Please refer to the +[bot requirements](./bot/requirements.txt), [model requirements](./model/setup.py) and [model runtime requirements](./model_runtime_svc/setup.py) for a list of the **direct** dependencies. + +Please also note that the sample depends on the `requests` package, which has a dependency `chardet` that uses LGPL license. \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/README.md b/samples/python_flask/101.corebot-bert-bidaf/README.md new file mode 100644 index 000000000..e566935ab --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/README.md @@ -0,0 +1,336 @@ +# CoreBot-bert-bidaf + +Bot Framework v4 core bot sample demonstrating using open source language models employing the BERT and BiDAF. This is for demonstration purposes only. + +## Table of Contents +- [Overview](#overview) +- [Terminology](#terminology) +- [Setup](#setup) +- [Model Development](#model-development) +- [Model Runtime Options](#model-runtime-options) + - [In-Process](#in-process) + - [Out-of-process to local service](#out-of-process-to-local-service) + - [Using Docker Containers](#using-docker-containers) + + +## Overview +This bot has been created using [Bot Framework](https://dev.botframework.com). It demonstrates the following: +- Train a one layer logistic regression classifier on top of the pretrained BERT model to infer intents. +- Use locally the ONNX BiDAF pre-trained model to infer entities for the scenario, in this case simple flight booking. +- Run the bot with the model runtime in-process to the bot. +- Run the bot with the model runtime external to the bot. + +## Terminology +This document uses the following terminology. +**Model Development**: Model Development broadly covers gathering data, data processing, training/validation/evaluation and testing. This can also be thought of as model preparation or authoring time. +**Model Runtime**: The built model which can be used to perform inferences against bot utterances. The model runtime refers to the model and the associated code to perform inferences. The model runtime is used when the bot is running to infer intents and entities. +**Inference**: Applying the bot utterance to a model yields intents and entities. The intents and entities are the inferences used by the bot. + +## Setup + +This sample uses the Anaconda environment (which provides Jupyter Lab and other machine learning tools) in order to run. + +The following instructions assume using the [Anaconda]() environment (v4.6.11+). + +Note: Be sure to install the **64-bit** version of Anaconda for the purposes of this tutorial. + +### Create and activate virtual environment + +In your local folder, open an **Anaconda prompt** and run the following commands: + +```bash +cd 101.corebot-bert-bidaf +conda create -n botsample python=3.6 anaconda -y +conda activate botsample # source conda + +# Add extension to handle Jupyter kernel based on the new environemnt. +pip install ipykernel +ipython kernel install --user --name=botsample + +# Add extension for visual controls to display correctly +conda install -c conda-forge nodejs -y +jupyter labextension install @jupyter-widgets/jupyterlab-manager +``` + +From here on out, all CLI interactions should occur within the `botsample` Anaconda virtual environment. + +### Install models package +The `models` package contains source to perform model development support and runtime inferencing using the tuned BERT and BiDAF models. + + +```bash +# Install Pytorch +conda install -c pytorch pytorch -y + +# Install models package using code in sample +# This will create the python package that contains all the +# models used in the Jupyter Notebooks and the Bot code. +cd model +pip install -e . # Note the '.' after -e + +# Verify packages installed + # On Windows: + conda list | findstr "corebot pytorch onnx" + + # On Linux/etc: + conda list | grep -e corebot -e pytorch -e onnx +``` + +You should see something like: +```bash +model-corebot101 0.0.1 dev_0 +onnx 1.5.0 pypi_0 pypi +onnxruntime 0.4.0 pypi_0 pypi +pytorch 1.1.0 py3.6_cuda100_cudnn7_1 pytorch +pytorch-pretrained-bert 0.6.2 pypi_0 pypi +``` + +## Model Development +Model development in this sample involves building a BERT classifier model and is performed in the Juypter Lab environment. + +### Training in Jupyter Lab +Training the model can be performed in Jupyter Lab. +Within the Anaconda shell, launch Jupyter Lab from the sample directory. + +```bash +# Start JupyterLab in sample directory +(botsample) 101.corebot-bert-bidaf> jupyter lab + +``` +#### Click on `notebooks` folder in the left hand navigation of JupyterLab + +
+ Click for screen shot. + Selecting notebooks folder in Jupyter + Selecting notebooks folder in Jupyter +
+ +#### Click on `bert_train.ipynb` notebook +If running the first time, you should select the `botsample` environment. +
+ Click for screen shot. + Selecting Anaconda `botsample` environment for Jupyter Kernel + Selecting Jupyter Kernel +
+ +#### Train the model + +To build the BERT classifier model, run the Jupyterlab Notebok (Run->**Run All Cells**). + +
+ Click for screen shot. + Selecting Model to build folder + Selecting Bert model +
+ +This process may take several minutes. The built model is placed into a directory that will get packaged with the bot during deployment. The sample demonstrates using this package in-process to the bot, our of process in a separate host that performs inferences, and within Jupyter Notebooks. + +After running the Jupyter Notebook, the output should resemble something like the following: +
+ Click for screen shot. + Showing Completed Model Build + Completed Model Build] +
+ + + +#### Test the BERT runtime model classification +Once the model has been built, you can test the model with a separately provided Jupyter Notebook (Run->Run All Cells). +- Within the `notebooks` folder, select the `bert_model_runtime.ipynb` file. +- Run the notebook. + +[![Sample output of the bert model](./media/jupyter_lab_bert_runtime.PNG)] + +- The output shows intents (`Book flight`, `Cancel`) that will be used by the bot. + +- Add additional test cases to see how phrases will be inferenced. + +- To modify the training data, update the file below. The format of this is compatible with the LUIS schema. When done modifying the training data [re-train the model](#train-the-model) before testing. + `101.corebot-bert-bidaf/model/model_corebot101/bert/training_data/FlightBooking.json` + + [Click to edit Training Data.](./model/model_corebot101/bert/training_data/FlightBooking.json) + +> **NOTE**: The default file output location for the tuned BERT model is `/models/bert`. + +### Test the BiDAF runtime model classification +Similarly, you can test the BiDAF model. Note there is no explicit data processing for the bidaf model. The entities detected are configured at runtime in the notebook. + +[![Sample output of the bert model](./media/jupyter_lab_bidaf_runtime.PNG)] + +> **NOTE**: The default file output location for the BiDAF model is `/models/bidaf`. + + + +## Model Runtime Options + +The sample can host the model runtime within the bot process or out-of-process in a REST API service. The following sections demonstrate how to do this on the local machine. In addition, the sample provides Dockerfiles to run this sample in containers. + +### In-process +Within an Anaconda environment (bring up a new Anaconda shell and activate your virtual environment if you would like to continue having JupyterLab running in the original shell), install dependencies for the bot: +```bash +# Install requirements required for the bot +(botsample) 101.corebot-bert-bidaf> pip install -r requirements.txt +``` +> **NOTE**: If `requirements.txt` doesn't install, you may have to stop JupyterLab if it's running. + +```bash +# Run the bot +(botsample) 101.corebot-bert-bidaf> cd bot +(botsample) 101.corebot-bert-bidaf\bot> python main.py +``` + + +> **NOTE**: If executing `main.py` with Python above doesn't work, try running Flask directly: +> +> ```bash +> # Set FLASK_APP with full path to main.py in the sample directory +> # On linux, use export instead of set. +> (botsample) 101.corebot-bert-bidaf> set FLASK_APP=main.py +> +> # Turn on development +> (botsample) 101.corebot-bert-bidaf> set FLASK_ENV=development +> +> # Run flask +> (botsample) 101.corebot-bert-bidaf> flask run +> ``` + +At this point, you can [test the bot](#testing-the-bot-using-bot-framework-emulator). + +### Out-of-process to local service +Sometimes it's helpful to host the model outside the bot's process space and serve inferences from a separate process. + +This section builds on the previous section of [In-process](#in-process). + +#### Modify bot configuration for localhost +To call the out-of-process REST API, the bot configuration is modified. Edit the following file: +`101.corebot-bert-bidaf/bot/config.py` + +Edit the settings for `USE_MODEL_RUNTIME_SERVICE` and set to `True`. + +```python +class DefaultConfig(object): + """Bot configuration parameters.""" + # TCP port that the bot listens on (default:3978) + PORT = 3978 + + # Azure Application ID (not required if running locally) + APP_ID = "" + # Azure Application Password (not required if running locally) + APP_PASSWORD = "" + + # Determines if the bot calls the models in-proc to the bot or call out of process + # to the service api using a REST API. + USE_MODEL_RUNTIME_SERVICE = True + # Host serving the out-of-process model runtime service api. + MODEL_RUNTIME_SERVICE_HOST = "localhost" + # TCP serving the out-of-process model runtime service api. + MODEL_RUNTIME_SERVICE_PORT = 8880 +``` +#### Set up model runtime service +Inside a separate Anaconda shell, activate the `botsample` environment, and install the model runtime service. + +```bash +# Install requirements required for model runtime service +(botsample) 101.corebot-bert-bidaf> cd bot +(botsample) 101.corebot-bert-bidaf\model_runtime_svc> pip install -e . # Note the dot after the -e switch +``` + +#### Run model runtime service +To run the model runtime service, execute the following: +```bash +# From 101.corebot-bert-bidaf\model_runtime_svc\model_runtime_svc_corebot101 directory +python main.py +``` +If not already running, create a separate Anaconda shell set to the `botsample` environment and [run the local bot](#local-in-process) as described above. If it was already running, ensure [the configuration changes made above](#modify-bot-configuration) are running. + +At this point, you can [test the bot](#testing-the-bot-using-bot-framework-emulator). + +### Using Docker Containers +This sample also demonstrates using Docker and Docker Compose to run a bot and model runtime service on the local host, that communicate together. + +> **NOTE**: For Windows: https://hub.docker.com/editions/community/docker-ce-desktop-windows In the configuration dialog make sure the use Linux containers is checked. + + +#### Modify bot configuration for Docker +To call the out-of-process REST API inside a Docker containerI, the bot configuration is modified. Edit the following file: +`101.corebot-bert-bidaf/bot/config.py` + +Ensure that the bot configuration is set to serve model predictions remotely by setting `USE_MODEL_RUNTIME_SERVICE` to `True`. + +In addition, modify the `MODEL_RUNTIME_SERVICE_HOST` to `api` (previously `localhost`). This will allow the `bot` container to properly address the model `model runtime api` service container. + +The resulting `config.py`should look like the following: +```python +class DefaultConfig(object): + """Bot configuration parameters.""" + # TCP port that the bot listens on (default:3978) + PORT = 3978 + + # Azure Application ID (not required if running locally) + APP_ID = "" + # Azure Application Password (not required if running locally) + APP_PASSWORD = "" + + # Determines if the bot calls the models in-proc to the bot or call out of process + # to the service api using a REST API. + USE_MODEL_RUNTIME_SERVICE = True + # Host serving the out-of-process model runtime service api. + MODEL_RUNTIME_SERVICE_HOST = "api" + # TCP serving the out-of-process model runtime service api. + MODEL_RUNTIME_SERVICE_PORT = 8880 +``` +#### Build the containers + +The following command builds both the bot and the model runtime service containers. +```bash +# From 101.corebot-bert-bidaf directory +docker-compose --project-directory . --file docker/docker-compose.yml build +``` +> **NOTE**: If you get error code 137, you may need to increase the amount of memory supplied to Docker. + +#### Run the containers locally +```bash +# From 101.corebot-bert-bidaf directory +docker-compose --project-directory . --file docker/docker-compose.yml up -d +``` +#### Verify +```bash +# From 101.corebot-bert-bidaf directory +docker-compose --project-directory . --file docker/docker-compose.yml logs +docker ps +``` +Look at the logs and docker to ensure the containers are running. + +## Testing the bot using Bot Framework Emulator + +[Bot Framework Emulator](https://github.com/microsoft/botframework-emulator) is a desktop application that allows bot developers to test and debug their bots on localhost or running remotely through a tunnel. + +- Install the Bot Framework Emulator version 4.3.0 or greater from [here](https://github.com/Microsoft/BotFramework-Emulator/releases) + +### Connect to the bot using Bot Framework Emulator + +- Launch Bot Framework Emulator +- File -> Open Bot +- Enter a Bot URL of `http://localhost:3978/api/messages` + +### Test the bot +In the emulator, type phrases such as`hello`, `book flight from seattle to miami`, etc + + + +## Further reading + +- [Bot Framework Documentation](https://docs.botframework.com) +- [Bot Basics](https://docs.microsoft.com/azure/bot-service/bot-builder-basics?view=azure-bot-service-4.0) +- [Dialogs](https://docs.microsoft.com/azure/bot-service/bot-builder-concept-dialog?view=azure-bot-service-4.0) +- [Gathering Input Using Prompts](https://docs.microsoft.com/azure/bot-service/bot-builder-prompts?view=azure-bot-service-4.0&tabs=csharp) +- [Activity processing](https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-concept-activity-processing?view=azure-bot-service-4.0) +- [Azure Bot Service Introduction](https://docs.microsoft.com/azure/bot-service/bot-service-overview-introduction?view=azure-bot-service-4.0) +- [Azure Bot Service Documentation](https://docs.microsoft.com/azure/bot-service/?view=azure-bot-service-4.0) +- [.NET Core CLI tools](https://docs.microsoft.com/dotnet/core/tools/?tabs=netcore2x) +- [Azure CLI](https://docs.microsoft.com/cli/azure/?view=azure-cli-latest) +- [Azure Portal](https://portal.azure.com) +- [Language Understanding using LUIS](https://docs.microsoft.com/azure/cognitive-services/luis/) +- [Channels and Bot Connector Service](https://docs.microsoft.com/azure/bot-service/bot-concepts?view=azure-bot-service-4.0) +- [Google BERT](https://github.com/google-research/bert) +- [ONNX BiDAF](https://github.com/onnx/models/tree/master/bidaf) \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/bots/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/bot/bots/__init__.py new file mode 100644 index 000000000..74b723fd8 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/bots/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""bots module.""" + +from .dialog_bot import DialogBot +from .dialog_and_welcome_bot import DialogAndWelcomeBot + +__all__ = [ + 'DialogBot', + 'DialogAndWelcomeBot'] diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/bots/dialog_and_welcome_bot.py b/samples/python_flask/101.corebot-bert-bidaf/bot/bots/dialog_and_welcome_bot.py new file mode 100644 index 000000000..63943100d --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/bots/dialog_and_welcome_bot.py @@ -0,0 +1,42 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Main dialog to welcome users.""" +import json +import os.path +from typing import List +from botbuilder.core import TurnContext +from botbuilder.schema import Activity, Attachment, ChannelAccount +from helpers.activity_helper import create_activity_reply +from .dialog_bot import DialogBot + +class DialogAndWelcomeBot(DialogBot): + """Main dialog to welcome users implementation.""" + + async def on_members_added_activity(self, members_added: List[ChannelAccount], + turn_context: TurnContext): + for member in members_added: + # Greet anyone that was not the target (recipient) of this message. + # To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards + # for more details. + if member.id != turn_context.activity.recipient.id: + welcome_card = self.create_adaptive_card_attachment() + response = self.create_response(turn_context.activity, welcome_card) + await turn_context.send_activity(response) + + def create_response(self, activity: Activity, attachment: Attachment): + """Create an attachment message response.""" + response = create_activity_reply(activity) + response.attachments = [attachment] + return response + + # Load attachment from file. + def create_adaptive_card_attachment(self): + """Create an adaptive card.""" + relative_path = os.path.abspath(os.path.dirname(__file__)) + path = os.path.join(relative_path, "resources/welcomeCard.json") + with open(path) as card_file: + card = json.load(card_file) + + return Attachment( + content_type="application/vnd.microsoft.card.adaptive", + content=card) diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/bots/dialog_bot.py b/samples/python_flask/101.corebot-bert-bidaf/bot/bots/dialog_bot.py new file mode 100644 index 000000000..ed908a428 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/bots/dialog_bot.py @@ -0,0 +1,34 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Implements bot Activity handler.""" + +from botbuilder.core import ActivityHandler, ConversationState, UserState, TurnContext +from botbuilder.dialogs import Dialog +from helpers.dialog_helper import DialogHelper + +class DialogBot(ActivityHandler): + """Main activity handler for the bot.""" + def __init__(self, conversation_state: ConversationState, + user_state: UserState, dialog: Dialog): + if conversation_state is None: + raise Exception('[DialogBot]: Missing parameter. conversation_state is required') + if user_state is None: + raise Exception('[DialogBot]: Missing parameter. user_state is required') + if dialog is None: + raise Exception('[DialogBot]: Missing parameter. dialog is required') + + self.conversation_state = conversation_state + self.user_state = user_state + self.dialog = dialog + self.dialogState = self.conversation_state.create_property('DialogState') # pylint: disable=C0103 + + async def on_turn(self, turn_context: TurnContext): + await super().on_turn(turn_context) + + # Save any state changes that might have occured during the turn. + await self.conversation_state.save_changes(turn_context, False) + await self.user_state.save_changes(turn_context, False) + + async def on_message_activity(self, turn_context: TurnContext): + await DialogHelper.run_dialog(self.dialog, turn_context, + self.conversation_state.create_property("DialogState")) # pylint: disable=C0103 diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/bots/resources/welcomeCard.json b/samples/python_flask/101.corebot-bert-bidaf/bot/bots/resources/welcomeCard.json new file mode 100644 index 000000000..169f6328d --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/bots/resources/welcomeCard.json @@ -0,0 +1,46 @@ +{ + "$schema": "http://adaptivecards.io/schemas/adaptive-card.json", + "type": "AdaptiveCard", + "version": "1.0", + "body": [ + { + "type": "Image", + "url": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQtB3AwMUeNoq4gUBGe6Ocj8kyh3bXa9ZbV7u1fVKQoyKFHdkqU", + "size": "stretch" + }, + { + "type": "TextBlock", + "spacing": "medium", + "size": "default", + "weight": "bolder", + "text": "Welcome to Bot Framework!", + "wrap": true, + "maxLines": 0 + }, + { + "type": "TextBlock", + "size": "default", + "isSubtle": "yes", + "text": "Now that you have successfully run your bot, follow the links in this Adaptive Card to expand your knowledge of Bot Framework.", + "wrap": true, + "maxLines": 0 + } + ], + "actions": [ + { + "type": "Action.OpenUrl", + "title": "Get an overview", + "url": "https://docs.microsoft.com/en-us/azure/bot-service/?view=azure-bot-service-4.0" + }, + { + "type": "Action.OpenUrl", + "title": "Ask a question", + "url": "https://stackoverflow.com/questions/tagged/botframework" + }, + { + "type": "Action.OpenUrl", + "title": "Learn how to deploy", + "url": "https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-deploy-azure?view=azure-bot-service-4.0" + } + ] +} \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/config.py b/samples/python_flask/101.corebot-bert-bidaf/bot/config.py new file mode 100644 index 000000000..72fab86e4 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/config.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python3 +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Bot/Flask Configuration parameters. +Configuration parameters for the bot. +""" + +class DefaultConfig(object): + """Bot configuration parameters.""" + # TCP port that the bot listens on (default:3978) + PORT = 3978 + + # Azure Application ID (not required if running locally) + APP_ID = "" + # Azure Application Password (not required if running locally) + APP_PASSWORD = "" + + # Determines if the bot calls the models in-proc to the bot or call out of process + # to the service api. + USE_MODEL_RUNTIME_SERVICE = False + # Host serving the out-of-process model runtime service api. + MODEL_RUNTIME_SERVICE_HOST = "localhost" + # TCP serving the out-of-process model runtime service api. + MODEL_RUNTIME_SERVICE_PORT = 8880 diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/__init__.py new file mode 100644 index 000000000..e8c9730b8 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/__init__.py @@ -0,0 +1,13 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Dialogs module""" +from .booking_dialog import BookingDialog +from .cancel_and_help_dialog import CancelAndHelpDialog +from .date_resolver_dialog import DateResolverDialog +from .main_dialog import MainDialog + +__all__ = [ + 'BookingDialog', + 'CancelAndHelpDialog', + 'DateResolverDialog', + 'MainDialog'] diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/booking_dialog.py b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/booking_dialog.py new file mode 100644 index 000000000..7390c8d89 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/booking_dialog.py @@ -0,0 +1,95 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Flight booking dialog.""" + +from botbuilder.dialogs import WaterfallDialog, WaterfallStepContext, DialogTurnResult +from botbuilder.dialogs.prompts import ConfirmPrompt, TextPrompt, PromptOptions +from botbuilder.core import MessageFactory +from datatypes_date_time.timex import Timex +from .cancel_and_help_dialog import CancelAndHelpDialog +from .date_resolver_dialog import DateResolverDialog + + + +class BookingDialog(CancelAndHelpDialog): + """Flight booking implementation.""" + + def __init__(self, dialog_id: str = None): + super(BookingDialog, self).__init__(dialog_id or BookingDialog.__name__) + + self.add_dialog(TextPrompt(TextPrompt.__name__)) + #self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__)) + self.add_dialog(DateResolverDialog(DateResolverDialog.__name__)) + self.add_dialog(WaterfallDialog(WaterfallDialog.__name__, [ + self.destination_step, + self.origin_step, + self.travel_date_step, + #self.confirm_step, + self.final_step + ])) + + self.initial_dialog_id = WaterfallDialog.__name__ + + async def destination_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Prompt for destination.""" + booking_details = step_context.options + + if booking_details.destination is None: + return await step_context.prompt(TextPrompt.__name__, + PromptOptions(prompt=MessageFactory.text( + 'To what city would you like to travel?'))) # pylint: disable=line-too-long,bad-continuation + else: + return await step_context.next(booking_details.destination) + + async def origin_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Prompt for origin city.""" + booking_details = step_context.options + + # Capture the response to the previous step's prompt + booking_details.destination = step_context.result + if booking_details.origin is None: + return await step_context.prompt(TextPrompt.__name__, + PromptOptions(prompt=MessageFactory.text('From what city will you be travelling?'))) # pylint: disable=line-too-long,bad-continuation + else: + return await step_context.next(booking_details.origin) + + async def travel_date_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Prompt for travel date. + This will use the DATE_RESOLVER_DIALOG.""" + + booking_details = step_context.options + + # Capture the results of the previous step + booking_details.origin = step_context.result + if (not booking_details.travel_date or self.is_ambiguous(booking_details.travel_date)): + return await step_context.begin_dialog(DateResolverDialog.__name__, booking_details.travel_date) # pylint: disable=line-too-long + else: + return await step_context.next(booking_details.travel_date) + + async def confirm_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Confirm the information the user has provided.""" + booking_details = step_context.options + + # Capture the results of the previous step + booking_details.travel_date = step_context.result + msg = f'Please confirm, I have you traveling to: { booking_details.destination }'\ + f' from: { booking_details.origin } on: { booking_details.travel_date}.' + + # Offer a YES/NO prompt. + return await step_context.prompt(ConfirmPrompt.__name__, + PromptOptions(prompt=MessageFactory.text(msg))) + + async def final_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Complete the interaction and end the dialog.""" + if step_context.result: + booking_details = step_context.options + booking_details.travel_date = step_context.result + + return await step_context.end_dialog(booking_details) + else: + return await step_context.end_dialog() + + def is_ambiguous(self, timex: str) -> bool: + """Ensure time is correct.""" + timex_property = Timex(timex) + return 'definite' not in timex_property.types diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/cancel_and_help_dialog.py b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/cancel_and_help_dialog.py new file mode 100644 index 000000000..bc71e6734 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/cancel_and_help_dialog.py @@ -0,0 +1,37 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Handle cancel and help intents.""" +from botbuilder.dialogs import ComponentDialog, DialogContext, DialogTurnResult, DialogTurnStatus +from botbuilder.schema import ActivityTypes + + +class CancelAndHelpDialog(ComponentDialog): + """Implementation of handling cancel and help.""" + async def on_begin_dialog(self, inner_dc: DialogContext, options: object) -> DialogTurnResult: + result = await self.interrupt(inner_dc) + if result is not None: + return result + + return await super(CancelAndHelpDialog, self).on_begin_dialog(inner_dc, options) + + async def on_continue_dialog(self, inner_dc: DialogContext) -> DialogTurnResult: + result = await self.interrupt(inner_dc) + if result is not None: + return result + + return await super(CancelAndHelpDialog, self).on_continue_dialog(inner_dc) + + async def interrupt(self, inner_dc: DialogContext) -> DialogTurnResult: + """Detect interruptions.""" + if inner_dc.context.activity.type == ActivityTypes.message: + text = inner_dc.context.activity.text.lower() + + if text == 'help' or text == '?': + await inner_dc.context.send_activity("Show Help...") + return DialogTurnResult(DialogTurnStatus.Waiting) + + if text == 'cancel' or text == 'quit': + await inner_dc.context.send_activity("Cancelling") + return await inner_dc.cancel_all_dialogs() + + return None diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/date_resolver_dialog.py b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/date_resolver_dialog.py new file mode 100644 index 000000000..1606ce538 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/date_resolver_dialog.py @@ -0,0 +1,63 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Handle date/time resolution for booking dialog.""" +from botbuilder.core import MessageFactory +from botbuilder.dialogs import WaterfallDialog, DialogTurnResult, WaterfallStepContext +from botbuilder.dialogs.prompts import DateTimePrompt, PromptValidatorContext, \ + PromptOptions, DateTimeResolution +from datatypes_date_time.timex import Timex +from .cancel_and_help_dialog import CancelAndHelpDialog + +class DateResolverDialog(CancelAndHelpDialog): + """Resolve the date""" + def __init__(self, dialog_id: str = None): + super(DateResolverDialog, self).__init__(dialog_id or DateResolverDialog.__name__) + + self.add_dialog(DateTimePrompt(DateTimePrompt.__name__, + DateResolverDialog.datetime_prompt_validator)) + self.add_dialog(WaterfallDialog(WaterfallDialog.__name__ + '2', [ + self.initial_step, + self.final_step + ])) + + self.initial_dialog_id = WaterfallDialog.__name__ + '2' + + async def initial_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Prompt for the date.""" + timex = step_context.options + + prompt_msg = 'On what date would you like to travel?' + reprompt_msg = "I'm sorry, for best results, please enter your travel "\ + "date including the month, day and year." + + if timex is None: + # We were not given any date at all so prompt the user. + return await step_context.prompt(DateTimePrompt.__name__, + PromptOptions( # pylint: disable=bad-continuation + prompt=MessageFactory.text(prompt_msg), + retry_prompt=MessageFactory.text(reprompt_msg) + )) + else: + # We have a Date we just need to check it is unambiguous. + if 'definite' in Timex(timex).types: + # This is essentially a "reprompt" of the data we were given up front. + return await step_context.prompt(DateTimePrompt.__name__, + PromptOptions(prompt=reprompt_msg)) + else: + return await step_context.next(DateTimeResolution(timex=timex)) + + async def final_step(self, step_context: WaterfallStepContext): + """Cleanup - set final return value and end dialog.""" + timex = step_context.result[0].timex + return await step_context.end_dialog(timex) + + @staticmethod + async def datetime_prompt_validator(prompt_context: PromptValidatorContext) -> bool: + """ Validate the date provided is in proper form. """ + if prompt_context.recognized.succeeded: + timex = prompt_context.recognized.value[0].timex.split('T')[0] + + # TODO: Needs TimexProperty + return 'definite' in Timex(timex).types + + return False diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/main_dialog.py b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/main_dialog.py new file mode 100644 index 000000000..06fa2a9da --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/dialogs/main_dialog.py @@ -0,0 +1,81 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Main dialog. """ +from typing import Dict +from botbuilder.dialogs import ComponentDialog, WaterfallDialog, \ + WaterfallStepContext, DialogTurnResult +from botbuilder.dialogs.prompts import TextPrompt, PromptOptions +from botbuilder.core import MessageFactory +from model_corebot101.booking_details import BookingDetails +from model_corebot101.language_helper import LanguageHelper +from .booking_dialog import BookingDialog + +#pylint:disable=line-too-long +class MainDialog(ComponentDialog): + """Main dialog.""" + def __init__(self, configuration: Dict[str, object], dialog_id: str = None, language_helper: LanguageHelper = None): + super(MainDialog, self).__init__(dialog_id or MainDialog.__name__) + + self._configuration = configuration + self._language_helper = language_helper + + self.add_dialog(TextPrompt(TextPrompt.__name__)) + self.add_dialog(BookingDialog()) + self.add_dialog(WaterfallDialog('WFDialog', [ + self.intro_step, + self.act_step, + self.final_step + ])) + + self.initial_dialog_id = 'WFDialog' + + # Initialize language models if we're not using service + self._language_helper = LanguageHelper() + if not self._configuration["USE_MODEL_RUNTIME_SERVICE"]: + self._language_helper.initialize_models() + + async def intro_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Initial prompt.""" + return await step_context.prompt(TextPrompt.__name__, PromptOptions( + prompt=MessageFactory.text("What can I help you with today?"))) + + + async def act_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Use language understanding to gather details about booking. + In this sample we only have a single Intent we are concerned with. + However, typically a scenario will have multiple different Intents + each corresponding to starting a different child Dialog.""" + + if step_context.result is not None: + utterance = step_context.context.activity.text + if not self._configuration["USE_MODEL_RUNTIME_SERVICE"]: + booking_details = await self._language_helper.excecute_query_inproc(utterance) + else: + booking_details = await self._language_helper.excecute_query_service(self._configuration, utterance) + else: + booking_details = BookingDetails() + + # Run the BookingDialog giving it whatever details we have from the + # model. The dialog will prompt to find out the remaining details. + return await step_context.begin_dialog(BookingDialog.__name__, booking_details) + + async def final_step(self, step_context: WaterfallStepContext) -> DialogTurnResult: + """Complete dialog. + At this step, with details from the user, display the completed + flight booking to the user. + """ + # If the child dialog ("BookingDialog") was cancelled or the user failed + # to confirm, the Result here will be null. + if step_context.result is not None: + result = step_context.result + + # Now we have all the booking details call the booking service. + # If the call to the booking service was successful tell the user. + #time_property = Timex(result.travel_date) + #travel_date_msg = time_property.to_natural_language(datetime.now()) + msg = f'I have you booked to {result.destination} from'\ + f' {result.origin} on {result.travel_date}.' + await step_context.context.send_activity(MessageFactory.text(msg)) + else: + await step_context.context.send_activity(MessageFactory.text("Thank you.")) + return await step_context.end_dialog() diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/__init__.py new file mode 100644 index 000000000..cf6a9151e --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Helpers module.""" + +from . import activity_helper, dialog_helper + +__all__ = [ + 'activity_helper', + 'dialog_helper', + ] diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/activity_helper.py b/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/activity_helper.py new file mode 100644 index 000000000..144f63650 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/activity_helper.py @@ -0,0 +1,26 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Helper to create reply object.""" + +from datetime import datetime +from botbuilder.schema import Activity, ActivityTypes, ChannelAccount, ConversationAccount + +def create_activity_reply(activity: Activity, text: str = None, locale: str = None): + """Helper to create reply object.""" + return Activity( + type=ActivityTypes.message, + timestamp=datetime.utcnow(), + from_property=ChannelAccount(id=getattr(activity.recipient, 'id', None), + name=getattr(activity.recipient, 'name', None)), + recipient=ChannelAccount(id=activity.from_property.id, name=activity.from_property.name), + reply_to_id=activity.id, + service_url=activity.service_url, + channel_id=activity.channel_id, + conversation=ConversationAccount(is_group=activity.conversation.is_group, + id=activity.conversation.id, + name=activity.conversation.name), + text=text or '', + locale=locale or '', + attachments=[], + entities=[] + ) diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/dialog_helper.py b/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/dialog_helper.py new file mode 100644 index 000000000..71ae06907 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/helpers/dialog_helper.py @@ -0,0 +1,19 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Utility to run dialogs.""" +from botbuilder.core import StatePropertyAccessor, TurnContext +from botbuilder.dialogs import Dialog, DialogSet, DialogTurnStatus + +class DialogHelper: + """Dialog Helper implementation.""" + + @staticmethod + async def run_dialog(dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor): # pylint: disable=line-too-long + """Run dialog.""" + dialog_set = DialogSet(accessor) + dialog_set.add(dialog) + + dialog_context = await dialog_set.create_context(turn_context) + results = await dialog_context.continue_dialog() + if results.status == DialogTurnStatus.Empty: + await dialog_context.begin_dialog(dialog.id) diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/main.py b/samples/python_flask/101.corebot-bert-bidaf/bot/main.py new file mode 100644 index 000000000..5b2de0a56 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/main.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +""" +This sample shows how to create a simple EchoBot with state. +""" +import asyncio + +from flask import Flask, request, Response +from botbuilder.core import (BotFrameworkAdapter, BotFrameworkAdapterSettings, + ConversationState, MemoryStorage, UserState) +from botbuilder.schema import (Activity) +from dialogs import MainDialog +from bots import DialogAndWelcomeBot + +LOOP = asyncio.get_event_loop() +APP = Flask(__name__, instance_relative_config=True) + +# Retrieve Flask/Bot configuration +APP.config.from_object('config.DefaultConfig') + +SETTINGS = BotFrameworkAdapterSettings(APP.config['APP_ID'], APP.config['APP_PASSWORD']) +ADAPTER = BotFrameworkAdapter(SETTINGS) + +# Create MemoryStorage, UserState and ConversationState +MEMORY = MemoryStorage() +USER_STATE = UserState(MEMORY) +CONVERSATION_STATE = ConversationState(MEMORY) +DIALOG = MainDialog(APP.config) +BOT = DialogAndWelcomeBot(CONVERSATION_STATE, USER_STATE, DIALOG) + + +@APP.route('/api/messages', methods=['POST']) +def messages(): + """Main bot message handler.""" + if request.headers['Content-Type'] == 'application/json': + body = request.json + else: + return Response(status=415) + + activity = Activity().deserialize(body) + auth_header = request.headers['Authorization'] if 'Authorization' in request.headers else '' + + async def aux_func(turn_context): + await BOT.on_turn(turn_context) + + try: + task = LOOP.create_task(ADAPTER.process_activity(activity, auth_header, aux_func)) + LOOP.run_until_complete(task) + return Response(status=201) + + except Exception as exception: + raise exception + +if __name__ == "__main__": + try: + APP.run(debug=True, port=APP.config["PORT"]) # nosec debug + except Exception as exception: + raise exception diff --git a/samples/python_flask/101.corebot-bert-bidaf/bot/requirements.txt b/samples/python_flask/101.corebot-bert-bidaf/bot/requirements.txt new file mode 100644 index 000000000..4b99b18d5 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/bot/requirements.txt @@ -0,0 +1,41 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +# Note: The model must be built first! +# cd model +# + +# The following are installed outside of requirements.txt +# conda install -c pytorch pytorch -y +# pip install onnxruntime +# Install python package dependencies with the following: +# `pip install -r requirements.txt` + +# Bot +Flask>=1.0.2 +asyncio>=3.4.3 +requests>=2.18.1 + +# Bot Framework +botframework-connector>=4.4.0.b1 +botbuilder-schema>=4.4.0.b1 +botbuilder-core>=4.4.0.b1 +botbuilder-dialogs>=4.4.0.b1 +botbuilder-ai>=4.4.0.b1 +datatypes-date-time>=1.0.0.a1 +azure-cognitiveservices-language-luis>=0.2.0 +msrest>=0.6.6 + +# Internal library - must be built first! +model_corebot101>=0.0.1 + +torch +onnx +onnxruntime +tqdm>=4.32.1 +pytorch-pretrained-bert>=0.6.2 +nltk>=3.4.1 +numpy>=1.16.3 +scipy>=1.3.0 +scikit-learn>=0.21.2 + diff --git a/samples/python_flask/101.corebot-bert-bidaf/docker/docker-compose.yml b/samples/python_flask/101.corebot-bert-bidaf/docker/docker-compose.yml new file mode 100644 index 000000000..29c6de853 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/docker/docker-compose.yml @@ -0,0 +1,20 @@ +version: '3.7' +services: + bot: + build: + context: . + dockerfile: Dockerfile_bot + ports: + - "3978:3978" + links: + - api + environment: + MODEL_RUNTIME_API_HOST : api + + api: + build: + context: . + dockerfile: Dockerfile_model_runtime + ports: + - "8880:8880" + diff --git a/samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bert_complete.PNG b/samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bert_complete.PNG new file mode 100644 index 0000000000000000000000000000000000000000..0254191fe786dd586f04bd7033b1e003b9a80e0b GIT binary patch literal 117341 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\`e7i=_P>Tawcfdp@B~zL-WV^almttL9C)@W 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 lg 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 literal 0 HcmV?d00001 diff --git a/samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bert_runtime.PNG b/samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bert_runtime.PNG new file mode 100644 index 0000000000000000000000000000000000000000..cbf7f5f7688b78e6298cb11326067cd16fe6089a GIT binary patch literal 58729 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 literal 0 HcmV?d00001 diff --git a/samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bidaf_runtime.PNG b/samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_bidaf_runtime.PNG new file mode 100644 index 0000000000000000000000000000000000000000..80e7bb79fba14e2c0bc623e1dd20e39b4a1490b3 GIT binary patch literal 79956 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

bmoX9`8 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≻e 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 MjN*gbdr$rT7iniXF#rGn literal 0 HcmV?d00001 diff --git a/samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_run_all_cells.PNG b/samples/python_flask/101.corebot-bert-bidaf/media/jupyter_lab_run_all_cells.PNG new file mode 100644 index 0000000000000000000000000000000000000000..eb151981f6de52a865eb5583154e274c852a3e32 GIT binary patch literal 101699 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 oO7z=F;mtDmzJZY-QqcJu#1I;*kez^7CJ1P> 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 O77aCB)snjpU;KZTOTPsG literal 0 HcmV?d00001 diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/about.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/about.py new file mode 100644 index 000000000..d46192b87 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/about.py @@ -0,0 +1,12 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Package information.""" +import os + +__title__ = 'model_corebot101' +__version__ = os.environ["packageVersion"] if "packageVersion" in os.environ else "0.0.1" +__uri__ = 'https://www.github.com/Microsoft/botbuilder-python' +__author__ = 'Microsoft' +__description__ = 'Microsoft Bot Framework Bot Builder' +__summary__ = 'Microsoft Bot Framework Bot Builder SDK for Python.' +__license__ = 'MIT' diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/__init__.py new file mode 100644 index 000000000..3c70a7ee3 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .bert_util import BertUtil +from .input_example import InputExample +from .input_features import InputFeatures + +__all__ = [ + 'BertUtil', + 'InputExample', + 'InputFeatures' + ] \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/bert_util.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/bert_util.py new file mode 100644 index 000000000..ee9ab630e --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/bert_util.py @@ -0,0 +1,156 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import logging +from typing import List + +from .input_features import InputFeatures +from scipy.stats import pearsonr, spearmanr +from sklearn.metrics import f1_score + + +class BertUtil: + logger = logging.getLogger(__name__) + + @classmethod + def convert_examples_to_features( + cls, examples, label_list, max_seq_length, tokenizer, output_mode + ) -> List: + """Loads a data file into a list of `InputBatch`s.""" + + label_map = {label: i for i, label in enumerate(label_list)} + + features = [] + for (ex_index, example) in enumerate(examples): + if ex_index % 10000 == 0: + cls.logger.info("Writing example %d of %d" % (ex_index, len(examples))) + + tokens_a = tokenizer.tokenize(example.text_a) + + tokens_b = None + if example.text_b: + tokens_b = tokenizer.tokenize(example.text_b) + # Modifies `tokens_a` and `tokens_b` in place so that the total + # length is less than the specified length. + # Account for [CLS], [SEP], [SEP] with "- 3" + BertUtil._truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3) + else: + # Account for [CLS] and [SEP] with "- 2" + if len(tokens_a) > max_seq_length - 2: + tokens_a = tokens_a[: (max_seq_length - 2)] + + # The convention in BERT is: + # (a) For sequence pairs: + # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP] + # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1 + # (b) For single sequences: + # tokens: [CLS] the dog is hairy . [SEP] + # type_ids: 0 0 0 0 0 0 0 + # + # Where "type_ids" are used to indicate whether this is the first + # sequence or the second sequence. The embedding vectors for `type=0` and + # `type=1` were learned during pre-training and are added to the wordpiece + # embedding vector (and position vector). This is not *strictly* necessary + # since the [SEP] token unambiguously separates the sequences, but it makes + # it easier for the model to learn the concept of sequences. + # + # For classification tasks, the first vector (corresponding to [CLS]) is + # used as as the "sentence vector". Note that this only makes sense because + # the entire model is fine-tuned. + tokens = ["[CLS]"] + tokens_a + ["[SEP]"] + segment_ids = [0] * len(tokens) + + if tokens_b: + tokens += tokens_b + ["[SEP]"] + segment_ids += [1] * (len(tokens_b) + 1) + + input_ids = tokenizer.convert_tokens_to_ids(tokens) + + # The mask has 1 for real tokens and 0 for padding tokens. Only real + # tokens are attended to. + input_mask = [1] * len(input_ids) + + # Zero-pad up to the sequence length. + padding = [0] * (max_seq_length - len(input_ids)) + input_ids += padding + input_mask += padding + segment_ids += padding + + assert len(input_ids) == max_seq_length + assert len(input_mask) == max_seq_length + assert len(segment_ids) == max_seq_length + + if output_mode == "classification": + label_id = label_map[example.label] + elif output_mode == "regression": + label_id = float(example.label) + else: + raise KeyError(output_mode) + + if ex_index < 5: + cls.logger.info("*** Example ***") + cls.logger.info("guid: %s" % (example.guid)) + cls.logger.info("tokens: %s" % " ".join([str(x) for x in tokens])) + cls.logger.info("input_ids: %s" % " ".join([str(x) for x in input_ids])) + cls.logger.info( + "input_mask: %s" % " ".join([str(x) for x in input_mask]) + ) + cls.logger.info( + "segment_ids: %s" % " ".join([str(x) for x in segment_ids]) + ) + cls.logger.info("label: %s (id = %d)" % (example.label, label_id)) + + features.append( + InputFeatures( + input_ids=input_ids, + input_mask=input_mask, + segment_ids=segment_ids, + label_id=label_id, + ) + ) + return features + + @staticmethod + def _truncate_seq_pair(tokens_a, tokens_b, max_length): + """Truncates a sequence pair in place to the maximum length.""" + + # This is a simple heuristic which will always truncate the longer sequence + # one token at a time. This makes more sense than truncating an equal percent + # of tokens from each, since if one sequence is very short then each token + # that's truncated likely contains more information than a longer sequence. + while True: + total_length = len(tokens_a) + len(tokens_b) + if total_length <= max_length: + break + if len(tokens_a) > len(tokens_b): + tokens_a.pop() + else: + tokens_b.pop() + + @staticmethod + def simple_accuracy(preds, labels): + return (preds == labels).mean() + + @staticmethod + def acc_and_f1(preds, labels): + acc = BertUtil.simple_accuracy(preds, labels) + f1 = f1_score(y_true=labels, y_pred=preds) + return {"acc": acc, "f1": f1, "acc_and_f1": (acc + f1) / 2} + + @staticmethod + def pearson_and_spearman(preds, labels): + pearson_corr = pearsonr(preds, labels)[0] + spearman_corr = spearmanr(preds, labels)[0] + return { + "pearson": pearson_corr, + "spearmanr": spearman_corr, + "corr": (pearson_corr + spearman_corr) / 2, + } + + @staticmethod + def compute_metrics(task_name, preds, labels): + assert len(preds) == len(labels) + if task_name == "flight_booking": + return BertUtil.acc_and_f1(preds, labels) + else: + raise KeyError(task_name) diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/input_example.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/input_example.py new file mode 100644 index 000000000..6398aec4e --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/input_example.py @@ -0,0 +1,22 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +class InputExample(object): + """A single training/test example for sequence classification.""" + + def __init__(self, guid, text_a, text_b=None, label=None): + """Constructs a InputExample. + + Args: + guid: Unique id for the example. + text_a: string. The untokenized text of the first sequence. For single + sequence tasks, only this sequence must be specified. + text_b: (Optional) string. The untokenized text of the second sequence. + Only must be specified for sequence pair tasks. + label: (Optional) string. The label of the example. This should be + specified for train and dev examples, but not for test examples. + """ + self.guid = guid + self.text_a = text_a + self.text_b = text_b + self.label = label diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/input_features.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/input_features.py new file mode 100644 index 000000000..d6d50013f --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/common/input_features.py @@ -0,0 +1,11 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +class InputFeatures(object): + """A single set of features of data.""" + + def __init__(self, input_ids, input_mask, segment_ids, label_id): + self.input_ids = input_ids + self.input_mask = input_mask + self.segment_ids = segment_ids + self.label_id = label_id diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/model_runtime/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/model_runtime/__init__.py new file mode 100644 index 000000000..fa3f35162 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/model_runtime/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .bert_model_runtime import BertModelRuntime + +__all__ = [ + 'BertModelRuntime' + ] \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/model_runtime/bert_model_runtime.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/model_runtime/bert_model_runtime.py new file mode 100644 index 000000000..d4317c2c0 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/model_runtime/bert_model_runtime.py @@ -0,0 +1,114 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Bert model runtime.""" + +import os +import sys +from typing import List +import numpy as np +import torch +from torch.utils.data import DataLoader, SequentialSampler, TensorDataset +from pytorch_pretrained_bert import BertForSequenceClassification, BertTokenizer +from model_corebot101.bert.common.bert_util import BertUtil +from model_corebot101.bert.common.input_example import InputExample + +class BertModelRuntime: + """Model runtime for the Bert model.""" + def __init__(self, model_dir: str, label_list: List[str], + max_seq_length: int = 128, output_mode: str = "classification", + no_cuda: bool = False, do_lower_case: bool = True): + self.model_dir = model_dir + self.label_list = label_list + self.num_labels = len(self.label_list) + self.max_seq_length = max_seq_length + self.output_mode = output_mode + self.no_cuda = no_cuda + self.do_lower_case = do_lower_case + self._load_model() + + # pylint:disable=unused-argument + @staticmethod + def init_bert(bert_model_dir: str) -> bool: + """ Handle any one-time initlization """ + if os.path.isdir(bert_model_dir): + print('bert model directory already present..', file=sys.stderr) + else: + print('Creating bert model directory..', file=sys.stderr) + os.makedirs(bert_model_dir, exist_ok=True) + return True + + def _load_model(self) -> None: + self.device = torch.device( + "cuda" if torch.cuda.is_available() and not self.no_cuda else "cpu" + ) + self.n_gpu = torch.cuda.device_count() + + # Load a trained model and vocabulary that you have fine-tuned + self.model = BertForSequenceClassification.from_pretrained( + self.model_dir, num_labels=self.num_labels + ) + self.tokenizer = BertTokenizer.from_pretrained( + self.model_dir, do_lower_case=self.do_lower_case + ) + self.model.to(self.device) + + def serve(self, query: str) -> str: + example = InputExample( + guid="", text_a=query, text_b=None, label=self.label_list[0] + ) + examples = [example] + + eval_features = BertUtil.convert_examples_to_features( + examples, + self.label_list, + self.max_seq_length, + self.tokenizer, + self.output_mode, + ) + all_input_ids = torch.tensor( + [f.input_ids for f in eval_features], dtype=torch.long + ) + all_input_mask = torch.tensor( + [f.input_mask for f in eval_features], dtype=torch.long + ) + all_segment_ids = torch.tensor( + [f.segment_ids for f in eval_features], dtype=torch.long + ) + + if self.output_mode == "classification": + all_label_ids = torch.tensor( + [f.label_id for f in eval_features], dtype=torch.long + ) + + eval_data = TensorDataset( + all_input_ids, all_input_mask, all_segment_ids, all_label_ids + ) + # Run prediction for full data + eval_sampler = SequentialSampler(eval_data) + eval_dataloader = DataLoader(eval_data, sampler=eval_sampler, batch_size=1) + + self.model.eval() + nb_eval_steps = 0 + preds = [] + + for input_ids, input_mask, segment_ids, label_ids in eval_dataloader: + input_ids = input_ids.to(self.device) + input_mask = input_mask.to(self.device) + segment_ids = segment_ids.to(self.device) + + with torch.no_grad(): + logits = self.model(input_ids, segment_ids, input_mask, labels=None) + + nb_eval_steps += 1 + if len(preds) == 0: + preds.append(logits.detach().cpu().numpy()) + else: + preds[0] = np.append(preds[0], logits.detach().cpu().numpy(), axis=0) + + preds = preds[0] + if self.output_mode == "classification": + preds = np.argmax(preds, axis=1) + + label_id = preds[0] + pred_label = self.label_list[label_id] + return pred_label diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/requirements.txt b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/requirements.txt new file mode 100644 index 000000000..10f898f8b --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/requirements.txt @@ -0,0 +1,3 @@ +torch +tqdm +pytorch-pretrained-bert diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/__init__.py new file mode 100644 index 000000000..57128c41b --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/__init__.py @@ -0,0 +1,13 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Bert tuning training.""" + +from .args import Args +from .bert_train_eval import BertTrainEval +from .flight_booking_processor import FlightBookingProcessor + +__all__ = [ + 'Args', + 'BertTrainEval', + 'FlightBookingProcessor' + ] diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/args.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/args.py new file mode 100644 index 000000000..43063b4f3 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/args.py @@ -0,0 +1,50 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Arguments for the model. """ + +import os +import sys +from pathlib import Path + +#pylint:disable=line-too-long +class Args: + """Arguments for the model.""" + training_data_dir: str = None + bert_model: str = None + task_name: str = None + model_dir: str = None + cleanup_output_dir: bool = False + cache_dir: str = "" + max_seq_length: int = 128 + do_train: bool = None + do_eval: bool = None + do_lower_case: bool = None + train_batch_size: int = 4 + eval_batch_size: int = 8 + learning_rate: float = 5e-5 + num_train_epochs: float = 3.0 + warmup_proportion: float = 0.1 + no_cuda: bool = None + local_rank: int = -1 + seed: int = 42 + gradient_accumulation_steps: int = 1 + fp16: bool = None + loss_scale: float = 0 + + @classmethod + def for_flight_booking(cls, + training_data_dir: str = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../training_data')), + task_name: str = "flight_booking"): + """Return the flight booking args.""" + args = cls() + + args.training_data_dir = training_data_dir + args.task_name = task_name + home_dir = str(Path.home()) + args.model_dir = os.path.abspath(os.path.join(home_dir, "models/bert")) + args.bert_model = "bert-base-uncased" + args.do_lower_case = True + + print(f'Bert Model training_data_dir is set to {args.training_data_dir}', file=sys.stderr) + print(f'Bert Model model_dir is set to {args.model_dir}', file=sys.stderr) + return args diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/bert_train_eval.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/bert_train_eval.py new file mode 100644 index 000000000..3173bfd52 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/bert_train_eval.py @@ -0,0 +1,373 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import logging +import os +import random +import shutil +import numpy as np +import torch +from .args import Args + +from model_corebot101.bert.common.bert_util import BertUtil +from model_corebot101.bert.train.flight_booking_processor import FlightBookingProcessor +from pytorch_pretrained_bert.file_utils import ( + CONFIG_NAME, + PYTORCH_PRETRAINED_BERT_CACHE, + WEIGHTS_NAME, +) +from pytorch_pretrained_bert.modeling import ( + BertForSequenceClassification, + BertPreTrainedModel, +) +from pytorch_pretrained_bert.optimization import BertAdam +from pytorch_pretrained_bert.tokenization import BertTokenizer +from torch.nn import CrossEntropyLoss +from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset +from torch.utils.data.distributed import DistributedSampler + +from tqdm import tqdm, trange + + +class BertTrainEval: + logger = logging.getLogger(__name__) + + def __init__(self, args: Args): + self.processor = FlightBookingProcessor() + self.output_mode = "classification" + self.args = args + self._prepare() + self.model = self._prepare_model() + + @classmethod + def train_eval(cls, cleanup_output_dir: bool = False) -> None: + # uncomment the following line for debugging. + # import pdb; pdb.set_trace() + args = Args.for_flight_booking() + args.do_train = True + args.do_eval = True + args.cleanup_output_dir = cleanup_output_dir + bert = cls(args) + bert.train() + bert.eval() + + def train(self) -> None: + # Prepare optimizer + param_optimizer = list(self.model.named_parameters()) + no_decay = ["bias", "LayerNorm.bias", "LayerNorm.weight"] + optimizer_grouped_parameters = [ + { + "params": [ + p for n, p in param_optimizer if not any(nd in n for nd in no_decay) + ], + "weight_decay": 0.01, + }, + { + "params": [ + p for n, p in param_optimizer if any(nd in n for nd in no_decay) + ], + "weight_decay": 0.0, + }, + ] + optimizer = BertAdam( + optimizer_grouped_parameters, + lr=self.args.learning_rate, + warmup=self.args.warmup_proportion, + t_total=self.num_train_optimization_steps, + ) + + global_step: int = 0 + nb_tr_steps = 0 + tr_loss: float = 0 + train_features = BertUtil.convert_examples_to_features( + self.train_examples, + self.label_list, + self.args.max_seq_length, + self.tokenizer, + self.output_mode, + ) + self.logger.info("***** Running training *****") + self.logger.info(" Num examples = %d", len(self.train_examples)) + self.logger.info(" Batch size = %d", self.args.train_batch_size) + self.logger.info(" Num steps = %d", self.num_train_optimization_steps) + all_input_ids = torch.tensor( + [f.input_ids for f in train_features], dtype=torch.long + ) + all_input_mask = torch.tensor( + [f.input_mask for f in train_features], dtype=torch.long + ) + all_segment_ids = torch.tensor( + [f.segment_ids for f in train_features], dtype=torch.long + ) + + if self.output_mode == "classification": + all_label_ids = torch.tensor( + [f.label_id for f in train_features], dtype=torch.long + ) + + train_data = TensorDataset( + all_input_ids, all_input_mask, all_segment_ids, all_label_ids + ) + if self.args.local_rank == -1: + train_sampler = RandomSampler(train_data) + else: + train_sampler = DistributedSampler(train_data) + train_dataloader = DataLoader( + train_data, sampler=train_sampler, batch_size=self.args.train_batch_size + ) + + self.model.train() + for _ in trange(int(self.args.num_train_epochs), desc="Epoch"): + tr_loss = 0 + nb_tr_examples, nb_tr_steps = 0, 0 + for step, batch in enumerate(tqdm(train_dataloader, desc="Iteration")): + batch = tuple(t.to(self.device) for t in batch) + input_ids, input_mask, segment_ids, label_ids = batch + + # define a new function to compute loss values for both output_modes + logits = self.model(input_ids, segment_ids, input_mask, labels=None) + + if self.output_mode == "classification": + loss_fct = CrossEntropyLoss() + loss = loss_fct( + logits.view(-1, self.num_labels), label_ids.view(-1) + ) + + if self.args.gradient_accumulation_steps > 1: + loss = loss / self.args.gradient_accumulation_steps + + loss.backward() + + tr_loss += loss.item() + nb_tr_examples += input_ids.size(0) + nb_tr_steps += 1 + if (step + 1) % self.args.gradient_accumulation_steps == 0: + optimizer.step() + optimizer.zero_grad() + global_step += 1 + + if self.args.local_rank == -1 or torch.distributed.get_rank() == 0: + # Save a trained model, configuration and tokenizer + model_to_save = ( + self.model.module if hasattr(self.model, "module") else self.model + ) # Only save the model it-self + + # If we save using the predefined names, we can load using `from_pretrained` + output_model_file = os.path.join(self.args.model_dir, WEIGHTS_NAME) + output_config_file = os.path.join(self.args.model_dir, CONFIG_NAME) + + torch.save(model_to_save.state_dict(), output_model_file) + model_to_save.config.to_json_file(output_config_file) + self.tokenizer.save_vocabulary(self.args.model_dir) + + # Load a trained model and vocabulary that you have fine-tuned + self.model = BertForSequenceClassification.from_pretrained( + self.args.model_dir, num_labels=self.num_labels + ) + self.tokenizer = BertTokenizer.from_pretrained( + self.args.model_dir, do_lower_case=self.args.do_lower_case + ) + else: + self.model = BertForSequenceClassification.from_pretrained( + self.args.bert_model, num_labels=self.num_labels + ) + self.model.to(self.device) + + self.tr_loss, self.global_step = tr_loss, global_step + + self.logger.info("DONE TRAINING."), + + def eval(self) -> None: + if not (self.args.local_rank == -1 or torch.distributed.get_rank() == 0): + return + + eval_examples = self.processor.get_dev_examples(self.args.training_data_dir) + eval_features = BertUtil.convert_examples_to_features( + eval_examples, + self.label_list, + self.args.max_seq_length, + self.tokenizer, + self.output_mode, + ) + self.logger.info("***** Running evaluation *****") + self.logger.info(" Num examples = %d", len(eval_examples)) + self.logger.info(" Batch size = %d", self.args.eval_batch_size) + all_input_ids = torch.tensor( + [f.input_ids for f in eval_features], dtype=torch.long + ) + all_input_mask = torch.tensor( + [f.input_mask for f in eval_features], dtype=torch.long + ) + all_segment_ids = torch.tensor( + [f.segment_ids for f in eval_features], dtype=torch.long + ) + + if self.output_mode == "classification": + all_label_ids = torch.tensor( + [f.label_id for f in eval_features], dtype=torch.long + ) + + eval_data = TensorDataset( + all_input_ids, all_input_mask, all_segment_ids, all_label_ids + ) + # Run prediction for full data + eval_sampler = SequentialSampler(eval_data) + eval_dataloader = DataLoader( + eval_data, sampler=eval_sampler, batch_size=self.args.eval_batch_size + ) + + self.model.eval() + eval_loss = 0 + nb_eval_steps = 0 + preds = [] + + for input_ids, input_mask, segment_ids, label_ids in tqdm( + eval_dataloader, desc="Evaluating" + ): + input_ids = input_ids.to(self.device) + input_mask = input_mask.to(self.device) + segment_ids = segment_ids.to(self.device) + label_ids = label_ids.to(self.device) + + with torch.no_grad(): + logits = self.model(input_ids, segment_ids, input_mask, labels=None) + + # create eval loss and other metric required by the task + if self.output_mode == "classification": + loss_fct = CrossEntropyLoss() + tmp_eval_loss = loss_fct( + logits.view(-1, self.num_labels), label_ids.view(-1) + ) + + eval_loss += tmp_eval_loss.mean().item() + nb_eval_steps += 1 + if len(preds) == 0: + preds.append(logits.detach().cpu().numpy()) + else: + preds[0] = np.append(preds[0], logits.detach().cpu().numpy(), axis=0) + + eval_loss = eval_loss / nb_eval_steps + preds = preds[0] + if self.output_mode == "classification": + preds = np.argmax(preds, axis=1) + result = BertUtil.compute_metrics(self.task_name, preds, all_label_ids.numpy()) + loss = self.tr_loss / self.global_step if self.args.do_train else None + + result["eval_loss"] = eval_loss + result["global_step"] = self.global_step + result["loss"] = loss + + output_eval_file = os.path.join(self.args.model_dir, "eval_results.txt") + with open(output_eval_file, "w") as writer: + self.logger.info("***** Eval results *****") + for key in sorted(result.keys()): + self.logger.info(" %s = %s", key, str(result[key])) + writer.write("%s = %s\n" % (key, str(result[key]))) + + self.logger.info("DONE EVALUATING.") + + def _prepare(self, cleanup_output_dir: bool = False) -> None: + if self.args.local_rank == -1 or self.args.no_cuda: + self.device = torch.device( + "cuda" if torch.cuda.is_available() and not self.args.no_cuda else "cpu" + ) + self.n_gpu = torch.cuda.device_count() + else: + torch.cuda.set_device(self.args.local_rank) + self.device = torch.device("cuda", self.args.local_rank) + self.n_gpu = 1 + # Initializes the distributed backend which will take care of sychronizing nodes/GPUs + torch.distributed.init_process_group(backend="nccl") + + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO if self.args.local_rank in [-1, 0] else logging.WARN, + ) + + self.logger.info( + "device: {} n_gpu: {}, distributed training: {}, 16-bits training: {}".format( + self.device, + self.n_gpu, + bool(self.args.local_rank != -1), + self.args.fp16, + ) + ) + + if self.args.gradient_accumulation_steps < 1: + raise ValueError( + "Invalid gradient_accumulation_steps parameter: {}, should be >= 1".format( + self.args.gradient_accumulation_steps + ) + ) + + self.args.train_batch_size = ( + self.args.train_batch_size // self.args.gradient_accumulation_steps + ) + + random.seed(self.args.seed) + np.random.seed(self.args.seed) + torch.manual_seed(self.args.seed) + if self.n_gpu > 0: + torch.cuda.manual_seed_all(self.args.seed) + + if not self.args.do_train and not self.args.do_eval: + raise ValueError("At least one of `do_train` or `do_eval` must be True.") + + if self.args.cleanup_output_dir: + if os.path.exists(self.args.model_dir): + shutil.rmtree(self.args.model_dir) + + if ( + os.path.exists(self.args.model_dir) + and os.listdir(self.args.model_dir) + and self.args.do_train + ): + raise ValueError( + "Output directory ({}) already exists and is not empty.".format( + self.args.model_dir + ) + ) + if not os.path.exists(self.args.model_dir): + os.makedirs(self.args.model_dir) + + self.task_name = self.args.task_name.lower() + + self.label_list = self.processor.get_labels() + self.num_labels = len(self.label_list) + + self.tokenizer = BertTokenizer.from_pretrained( + self.args.bert_model, do_lower_case=self.args.do_lower_case + ) + + self.train_examples = None + self.num_train_optimization_steps = None + if self.args.do_train: + self.train_examples = self.processor.get_train_examples(self.args.training_data_dir) + self.num_train_optimization_steps = ( + int( + len(self.train_examples) + / self.args.train_batch_size + / self.args.gradient_accumulation_steps + ) + * self.args.num_train_epochs + ) + if self.args.local_rank != -1: + self.num_train_optimization_steps = ( + self.num_train_optimization_steps + // torch.distributed.get_world_size() + ) + + def _prepare_model(self) -> BertPreTrainedModel: + if self.args.cache_dir: + cache_dir = self.args.cache_dir + else: + cache_dir = os.path.join( + str(PYTORCH_PRETRAINED_BERT_CACHE), + f"distributed_{self.args.local_rank}", + ) + model = BertForSequenceClassification.from_pretrained( + self.args.bert_model, cache_dir=cache_dir, num_labels=self.num_labels + ) + model.to(self.device) + return model diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/flight_booking_processor.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/flight_booking_processor.py new file mode 100644 index 000000000..f59759d53 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/train/flight_booking_processor.py @@ -0,0 +1,51 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import json +import os +from typing import List, Tuple + +from model_corebot101.bert.common.input_example import InputExample + + +class FlightBookingProcessor: + """Processor for the flight booking data set.""" + + def get_train_examples(self, data_dir): + """See base class.""" + return self._create_examples( + self._read_json(os.path.join(data_dir, "FlightBooking.json")), "train" + ) + + def get_dev_examples(self, data_dir): + """See base class.""" + return self._create_examples( + self._read_json(os.path.join(data_dir, "FlightBooking.json")), "dev" + ) + + def get_labels(self): + """See base class.""" + return ["Book flight", "Cancel"] + + def _create_examples(self, lines, set_type): + """Creates examples for the training and dev sets.""" + examples = [] + for (i, line) in enumerate(lines): + guid = "%s-%s" % (set_type, i) + text_a = line[1] + label = line[0] + examples.append( + InputExample(guid=guid, text_a=text_a, text_b=None, label=label) + ) + return examples + + @classmethod + def _read_json(cls, input_file): + with open(input_file, "r", encoding="utf-8") as f: + obj = json.load(f) + examples = obj["utterances"] + lines: List[Tuple[str, str]] = [] + for example in examples: + lines.append((example["intent"], example["text"])) + + return lines diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/training_data/FlightBooking.json b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/training_data/FlightBooking.json new file mode 100644 index 000000000..43781ee85 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bert/training_data/FlightBooking.json @@ -0,0 +1,241 @@ +{ + "luis_schema_version": "3.2.0", + "versionId": "0.1", + "name": "Airline Reservation", + "desc": "A LUIS model that uses intent and entities.", + "culture": "en-us", + "tokenizerVersion": "1.0.0", + "intents": [ + { + "name": "Book flight" + }, + { + "name": "Cancel" + }, + { + "name": "None" + } + ], + "entities": [], + "composites": [ + { + "name": "From", + "children": [ + "Airport" + ], + "roles": [] + }, + { + "name": "To", + "children": [ + "Airport" + ], + "roles": [] + } + ], + "closedLists": [ + { + "name": "Airport", + "subLists": [ + { + "canonicalForm": "Paris", + "list": [ + "paris" + ] + }, + { + "canonicalForm": "London", + "list": [ + "london" + ] + }, + { + "canonicalForm": "Berlin", + "list": [ + "berlin" + ] + }, + { + "canonicalForm": "New York", + "list": [ + "new york" + ] + } + ], + "roles": [] + } + ], + "patternAnyEntities": [], + "regex_entities": [], + "prebuiltEntities": [ + { + "name": "datetimeV2", + "roles": [] + } + ], + "model_features": [], + "regex_features": [], + "patterns": [], + "utterances": [ + { + "text": "book flight from london to paris on feb 14th", + "intent": "Book flight", + "entities": [ + { + "entity": "To", + "startPos": 27, + "endPos": 31 + }, + { + "entity": "From", + "startPos": 17, + "endPos": 22 + } + ] + }, + { + "text": "book flight to berlin on feb 14th", + "intent": "Book flight", + "entities": [ + { + "entity": "To", + "startPos": 15, + "endPos": 20 + } + ] + }, + { + "text": "book me a flight from london to paris", + "intent": "Book flight", + "entities": [ + { + "entity": "From", + "startPos": 22, + "endPos": 27 + }, + { + "entity": "To", + "startPos": 32, + "endPos": 36 + } + ] + }, + { + "text": "bye", + "intent": "Cancel", + "entities": [] + }, + { + "text": "cancel booking", + "intent": "Cancel", + "entities": [] + }, + { + "text": "exit", + "intent": "Cancel", + "entities": [] + }, + { + "text": "I don't want that", + "intent": "Cancel", + "entities": [] + }, + { + "text": "not this one", + "intent": "Cancel", + "entities": [] + }, + { + "text": "don't want that", + "intent": "Cancel", + "entities": [] + }, + { + "text": "flight to paris", + "intent": "Book flight", + "entities": [ + { + "entity": "To", + "startPos": 10, + "endPos": 14 + } + ] + }, + { + "text": "flight to paris from london on feb 14th", + "intent": "Book flight", + "entities": [ + { + "entity": "To", + "startPos": 10, + "endPos": 14 + }, + { + "entity": "From", + "startPos": 21, + "endPos": 26 + } + ] + }, + { + "text": "fly from berlin to paris on may 5th", + "intent": "Book flight", + "entities": [ + { + "entity": "To", + "startPos": 19, + "endPos": 23 + }, + { + "entity": "From", + "startPos": 9, + "endPos": 14 + } + ] + }, + { + "text": "go to paris", + "intent": "Book flight", + "entities": [ + { + "entity": "To", + "startPos": 6, + "endPos": 10 + } + ] + }, + { + "text": "going from paris to berlin", + "intent": "Book flight", + "entities": [ + { + "entity": "To", + "startPos": 20, + "endPos": 25 + }, + { + "entity": "From", + "startPos": 11, + "endPos": 15 + } + ] + }, + { + "text": "ignore", + "intent": "Cancel", + "entities": [] + }, + { + "text": "travel to paris", + "intent": "Book flight", + "entities": [ + { + "entity": "To", + "startPos": 10, + "endPos": 14 + } + ] + } + ], + "settings": [] +} \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/model_runtime/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/model_runtime/__init__.py new file mode 100644 index 000000000..6a1c7693d --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/model_runtime/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +from .bidaf_model_runtime import BidafModelRuntime + +__all__ = [ + 'BidafModelRuntime' + ] \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/model_runtime/bidaf_model_runtime.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/model_runtime/bidaf_model_runtime.py new file mode 100644 index 000000000..da5fd1abb --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/model_runtime/bidaf_model_runtime.py @@ -0,0 +1,105 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +import os +import sys +import requests +import shutil +from typing import Dict, List, Tuple +import nltk +import numpy as np +from nltk import word_tokenize +from onnxruntime import InferenceSession + +# pylint:disable=line-too-long +class BidafModelRuntime: + def __init__( + self, + targets: List[str], + queries: Dict[str, str], + model_dir: str + ): + self.queries = queries + self.targets = targets + bidaf_model = os.path.abspath(os.path.join(model_dir, 'bidaf.onnx')) + print(f'Loading Inference session from {bidaf_model}..', file=sys.stderr) + self.session = InferenceSession(bidaf_model) + print(f'Inference session loaded..', file=sys.stderr) + self.processed_queries = self._process_queries() + print(f'Processed queries..', file=sys.stderr) + + @staticmethod + def init_bidaf(bidaf_model_dir: str, download_ntlk_punkt: bool = False) -> bool: + if os.path.isdir(bidaf_model_dir): + print('bidaf model directory already present..', file=sys.stderr) + else: + print('Creating bidaf model directory..', file=sys.stderr) + os.makedirs(bidaf_model_dir, exist_ok=True) + + # Download Punkt Sentence Tokenizer + if download_ntlk_punkt: + nltk.download("punkt", download_dir=bidaf_model_dir) + nltk.download("punkt") + + # Download bidaf onnx model + onnx_model_file = os.path.abspath(os.path.join(bidaf_model_dir, 'bidaf.onnx')) + + print(f'Checking file {onnx_model_file}..', file=sys.stderr) + if os.path.isfile(onnx_model_file): + print('bidaf.onnx downloaded already!', file=sys.stderr) + else: + print('Downloading bidaf.onnx...', file=sys.stderr) + response = requests.get('https://onnxzoo.blob.core.windows.net/models/opset_9/bidaf/bidaf.onnx', stream=True) + with open(onnx_model_file, 'wb') as f: + response.raw.decode_content = True + shutil.copyfileobj(response.raw, f) + return True + + + def serve(self, context: str) -> Dict[str, str]: + result = {} + cw, cc = BidafModelRuntime._preprocess(context) + for target in self.targets: + qw, qc = self.processed_queries[target] + answer = self.session.run( + ["start_pos", "end_pos"], + { + "context_word": cw, + "context_char": cc, + "query_word": qw, + "query_char": qc, + }, + ) + start = answer[0].item() + end = answer[1].item() + result_item = cw[start : end + 1] + result[target] = BidafModelRuntime._convert_result(result_item) + + return result + + + def _process_queries(self) -> Dict[str, Tuple[np.ndarray, np.ndarray]]: + result = {} + for target in self.targets: + question = self.queries[target] + result[target] = BidafModelRuntime._preprocess(question) + + return result + + @staticmethod + def _convert_result(result_item: np.ndarray) -> str: + result = [] + for item in result_item: + result.append(item[0]) + + return " ".join(result) + + @staticmethod + def _preprocess(text: str) -> Tuple[np.ndarray, np.ndarray]: + tokens = word_tokenize(text) + # split into lower-case word tokens, in numpy array with shape of (seq, 1) + words = np.asarray([w.lower() for w in tokens]).reshape(-1, 1) + # split words into chars, in numpy array with shape of (seq, 1, 1, 16) + chars = [[c for c in t][:16] for t in tokens] + chars = [cs + [""] * (16 - len(cs)) for cs in chars] + chars = np.asarray(chars).reshape(-1, 1, 1, 16) + return words, chars diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/requirements.txt b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/requirements.txt new file mode 100644 index 000000000..a2eea036e --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/bidaf/requirements.txt @@ -0,0 +1,3 @@ +nltk +numpy +onnxruntime diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/booking_details.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/booking_details.py new file mode 100644 index 000000000..e9379e02e --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/booking_details.py @@ -0,0 +1,11 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Booking Details. +The lu model will detect the properties of a flight booking. +""" +class BookingDetails: + """Booking properties from lu model.""" + def __init__(self, destination: str = None, origin: str = None, travel_date: str = None): + self.destination = destination + self.origin = origin + self.travel_date = travel_date diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/language_helper.py b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/language_helper.py new file mode 100644 index 000000000..8f832c3cb --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/model_corebot101/language_helper.py @@ -0,0 +1,178 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Language helper that invokes the language model. +This is used from the Bot and Model Runtime to load and invoke the language models. +""" + +import os +import sys +from typing import Dict +from pathlib import Path +import requests +from datatypes_date_time.timex import Timex +from model_corebot101.booking_details import BookingDetails +from model_corebot101.bidaf.model_runtime import BidafModelRuntime +from model_corebot101.bert.model_runtime import BertModelRuntime +from model_corebot101.bert.train import BertTrainEval + +# pylint:disable=line-too-long +class LanguageHelper: + """Language helper that invokes the language model.""" + home_dir = str(Path.home()) + bert_model_dir_default = os.path.abspath(os.path.join(home_dir, "models/bert")) + bidaf_model_dir_default = os.path.abspath(os.path.join(home_dir, "models/bidaf")) + + # pylint:disable=bad-continuation + def __init__(self): + """Create Language Helper. + Note: Creating the Bert/Bidaf Model Runtime is only necessary for in-proc usage. + """ + self._bidaf_entities = None + self._bert_intents = None + + @property + def entities(self) -> BidafModelRuntime: + """Model used to detect entities.""" + return self._bidaf_entities + + @property + def intents(self) -> BertModelRuntime: + """Model used to detect intents.""" + return self._bert_intents + + def initialize_models(self, bert_model_dir: str = bert_model_dir_default, bidaf_model_dir: str = bidaf_model_dir_default) -> bool: + """ Initialize models. + Perform initialization of the models. + """ + if not BidafModelRuntime.init_bidaf(bidaf_model_dir, download_ntlk_punkt=True): + print(f'bidaf model creation failed at model directory {bidaf_model_dir}..', file=sys.stderr) + return False + + if not BertModelRuntime.init_bert(bert_model_dir): + print('bert model creation failed at model directory {bert_model_dir}..', file=sys.stderr) + return False + + print(f'Loading BERT model from {bert_model_dir}...', file=sys.stderr) + if not os.listdir(bert_model_dir): + print(f'No BERT model present, building model..', file=sys.stderr) + BertTrainEval.train_eval(cleanup_output_dir=True) + + self._bert_intents = BertModelRuntime(model_dir=bert_model_dir, label_list=["Book flight", "Cancel"]) + print(f'Loaded BERT model. Loading BiDaf model..', file=sys.stderr) + + self._bidaf_entities = BidafModelRuntime(targets=["from", "to", "date"], + queries={ + "from": "which city will you travel from?", + "to": "which city will you travel to?", + "date": "which date will you travel?", + }, + model_dir=bidaf_model_dir + ) + print(f'Loaded BiDAF model from {bidaf_model_dir}.', file=sys.stderr) + + return True + + async def excecute_query_inproc(self, utterance: str) -> BookingDetails: + """Exeecute a query against language model.""" + booking_details = BookingDetails() + intent = self.intents.serve(utterance) + print(f'Recognized intent "{intent}" from "{utterance}".', file=sys.stderr) + if intent == 'Book flight': + # Bert gave us the intent. + # Now look for entities with BiDAF.. + entities = self.entities.serve(utterance) + + if 'to' in entities: + print(f' Recognized "to" entitiy: {entities["to"]}.', file=sys.stderr) + booking_details.destination = entities['to'] + if 'from' in entities: + print(f' Recognized "from" entitiy: {entities["from"]}.', file=sys.stderr) + booking_details.origin = entities['from'] + if 'date' in entities: + # This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part. + # TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year. + print(f' Recognized "date" entitiy: {entities["date"]}.', file=sys.stderr) + travel_date = entities['date'] + if await LanguageHelper.validate_timex(travel_date): + booking_details.travel_date = travel_date + + return booking_details + + @staticmethod + async def excecute_query_service(configuration: dict, utterance: str) -> BookingDetails: + """Invoke lu service to perform prediction/evaluation of utterance.""" + booking_details = BookingDetails() + lu_response = await LanguageHelper.call_model_runtime(configuration, utterance) + if lu_response.status_code == 200: + + response_json = lu_response.json() + intent = response_json['intent'] if 'intent' in response_json else None + entities = await LanguageHelper.validate_entities(response_json['entities'] if 'entities' in response_json else None) + if intent: + if 'to' in entities: + print(f' Recognized "to" entity: {entities["to"]}.', file=sys.stderr) + booking_details.destination = entities['to'] + if 'from' in entities: + print(f' Recognized "from" entity: {entities["from"]}.', file=sys.stderr) + booking_details.origin = entities['from'] + if 'date' in entities: + # This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part. + # TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year. + print(f' Recognized "date" entity: {entities["date"]}.', file=sys.stderr) + travel_date = entities['date'] + if await LanguageHelper.validate_timex(travel_date): + booking_details.travel_date = travel_date + return booking_details + + @staticmethod + async def call_model_runtime(configuration: Dict[str, object], text: str) -> requests.Request: + """ Makes a call to the model runtime api + + The model runtime api signature is: + http://:/v1.0/model?q= + + where: + + model_runtime_host - The host running the model runtime api. To resolve + the host running the model runtime api (in the following order): + - MODEL_RUNTIME_API environment variable. Used in docker. + - config.py (which contains the DefaultConfig class). Used running + locally. + + port - http port number (ie, 8880) + + q - A query string to process (ie, the text utterance from user) + + For more details: (See TBD swagger file) + """ + port = os.environ.get('MODEL_RUNTIME_SERVICE_PORT') + host = os.environ.get('MODEL_RUNTIME_SERVICE_HOST') + if host is None: + host = configuration['MODEL_RUNTIME_SERVICE_HOST'] + if port is None: + port = configuration['MODEL_RUNTIME_SERVICE_PORT'] + + api_url = f'http://{host}:{port}/v1.0/model' + qstrings = {'q': text} + return requests.get(api_url, params=qstrings) + + @staticmethod + async def validate_entities(entities: Dict[str, str]) -> bool: + """Validate the entities. + The to and from cities can't be the same. If this is detected, + remove the ambiguous results. """ + if 'to' in entities and 'from' in entities: + if entities['to'] == entities['from']: + del entities['to'] + del entities['from'] + return entities + + @staticmethod + async def validate_timex(travel_date: str) -> bool: + """Validate the time. + Make sure time given in the right format. """ + # uncomment the following line for debugging. + #import pdb; pdb.set_trace() + timex_property = Timex(travel_date) + + return len(timex_property.types) > 0 and 'definite' not in timex_property.types diff --git a/samples/python_flask/101.corebot-bert-bidaf/model/setup.py b/samples/python_flask/101.corebot-bert-bidaf/model/setup.py new file mode 100644 index 000000000..e91d93a58 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model/setup.py @@ -0,0 +1,51 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import os +from setuptools import setup + +REQUIRES = [ + "torch", + "tqdm", + "pytorch-pretrained-bert", + "onnxruntime>=0.4.0", + "onnx>=1.5.0", + "datatypes-date-time>=1.0.0.a1", + "nltk>=3.4.1", +] + + +root = os.path.abspath(os.path.dirname(__file__)) + +with open(os.path.join(root, "model_corebot101", "about.py")) as f: + package_info = {} + info = f.read() + exec(info, package_info) + +setup( + name=package_info["__title__"], + version=package_info["__version__"], + url=package_info["__uri__"], + author=package_info["__author__"], + description=package_info["__description__"], + keywords="botframework azure botbuilder", + long_description=package_info["__summary__"], + license=package_info["__license__"], + packages=[ + "model_corebot101.bert.train", + "model_corebot101.bert.common", + "model_corebot101.bert.model_runtime", + "model_corebot101.bidaf.model_runtime" + ], + install_requires=REQUIRES, + dependency_links=['https://github.com/pytorch/pytorch'], + include_package_data=True, + classifiers=[ + "Programming Language :: Python :: 3.6", + "Intended Audience :: Developers", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Development Status :: 3 - Alpha", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + ] +) diff --git a/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/__init__.py new file mode 100644 index 000000000..36d8f03ff --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Model Runtime.""" +from .model_cache import ModelCache + +__all__ = [ + 'ModelCache' + ] \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/about.py b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/about.py new file mode 100644 index 000000000..5a886889b --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/about.py @@ -0,0 +1,12 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import os + +__title__ = 'model_runtime_svc_corebot101' +__version__ = os.environ["packageVersion"] if "packageVersion" in os.environ else "0.0.1" +__uri__ = 'https://www.github.com/Microsoft/botbuilder-python' +__author__ = 'Microsoft' +__description__ = 'Microsoft Bot Framework Bot Builder' +__summary__ = 'Microsoft Bot Framework Bot Builder SDK for Python.' +__license__ = 'MIT' diff --git a/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/docker_init.py b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/docker_init.py new file mode 100644 index 000000000..082234bd0 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/docker_init.py @@ -0,0 +1,18 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Docker initialization. +This is called from the Dockerfile when creating the model runtime service API +container. +""" +import os +from pathlib import Path +from model_corebot101.language_helper import LanguageHelper + +# Initialize the models +LH = LanguageHelper() +HOME_DIR = str(Path.home()) +BERT_MODEL_DIR_DEFAULT = os.path.abspath(os.path.join(HOME_DIR, "models/bert")) +BIDAF_MODEL_DIR_DEFAULT = os.path.abspath(os.path.join(HOME_DIR, "models/bidaf")) + +LH.initialize_models(bert_model_dir=BERT_MODEL_DIR_DEFAULT, + bidaf_model_dir=BIDAF_MODEL_DIR_DEFAULT) diff --git a/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/handlers/__init__.py b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/handlers/__init__.py new file mode 100644 index 000000000..6fcf0de49 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/handlers/__init__.py @@ -0,0 +1,2 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. \ No newline at end of file diff --git a/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/handlers/model_handler.py b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/handlers/model_handler.py new file mode 100644 index 000000000..4e2300232 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/handlers/model_handler.py @@ -0,0 +1,51 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Tornado handler to access the model runtime. + +To invoke: + /v1.0/model?q= +""" + +import logging +import json +from tornado.web import RequestHandler +from model_corebot101.language_helper import LanguageHelper + +# pylint:disable=abstract-method +class ModelHandler(RequestHandler): + """Model Handler implementation to access the model runtime.""" + _handler_routes = ['/v1.0/model/$', + '/v1.0/model$'] + @classmethod + def build_config(cls, ref_obj: dict): + """Build the Tornado configuration for this handler.""" + return [(route, ModelHandler, ref_obj) for route in cls._handler_routes] + + def set_default_headers(self): + """Set the default HTTP headers.""" + RequestHandler.set_default_headers(self) + self.set_header('Content-Type', 'application/json') + self.set_header("Access-Control-Allow-Origin", "*") + self.set_header("Access-Control-Allow-Headers", "Origin, Content-Type, Accept") + self.set_header('Access-Control-Allow-Methods', 'OPTIONS, GET') + + # pylint:disable=attribute-defined-outside-init + def initialize(self, language_helper: LanguageHelper): + """Initialize the handler.""" + RequestHandler.initialize(self) + self._language_helper = language_helper + self._logger = logging.getLogger('MODEL_HANDLER') + + async def get(self): + """Handle HTTP GET request.""" + text = self.get_argument('q', None, True) + if not text: + return (404, 'Missing the q query string with the text') + + response = {} + intent = self._language_helper.intents.serve(text) + response['intent'] = intent if intent else 'None' + entities = self._language_helper.entities.serve(text) + response['entities'] = entities if entities else 'None' + self.write(json.dumps(response)) + return (200, 'Complete') diff --git a/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/main.py b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/main.py new file mode 100644 index 000000000..1fbdb8899 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/main.py @@ -0,0 +1,91 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Model Runtime. +Entry point for the model runtime. +""" +import os +import signal +import logging +from logging.handlers import RotatingFileHandler +import tornado +from tornado.options import define, options +from pathlib import Path +from model_corebot101.language_helper import LanguageHelper +from handlers.model_handler import ModelHandler + +HOME_DIR = str(Path.home()) + +# Define Tornado options +define('port', default=8880, help='HTTP port for model runtime to listen on', type=int) +define('bidaf_model_dir', default=os.path.abspath(os.path.join(HOME_DIR, 'models/bidaf')), + help='bidaf model directory') +define('bert_model_dir', default=os.path.abspath(os.path.join(HOME_DIR, 'models/bert')), + help='bert model directory') + +def setup_logging(): + """Set up logging.""" + logging.info('Setting up logging infrastructure') + + # Create the rotating log handler + if not os.path.exists('logs'): + os.mkdir('logs') + handler = RotatingFileHandler(os.path.join('./logs', 'model-runtime.log'), + maxBytes=5*1024**2, # 5 MB chunks, + backupCount=5 # limit to 25 MB logs max + ) + + # Set the formatter + handler.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) + + # Setup the root logging with the necessary handlers + log = logging.getLogger() + log.addHandler(handler) + + # Set to info for normal processing + log.setLevel(logging.INFO) + +# pylint:disable=unused-argument +def signal_handler(sig_num, frame): + """Stop activity on signal.""" + tornado.ioloop.IOLoop.instance().stop() + +def run(): + """Main entry point for model runtime api.""" + + # Register signal handlers. + logging.info('Preparing signal handlers..') + signal.signal(signal.SIGINT, signal_handler) + signal.signal(signal.SIGTERM, signal_handler) + + # Set up model cache. + # If containerizing, suggest initializing the directories (and associated + # file downloads) be performed during container build time. + logging.info('Initializing model directories:') + logging.info(' bert : %s', options.bert_model_dir) + logging.info(' bidaf : %s', options.bidaf_model_dir) + + language_helper = LanguageHelper() + if language_helper.initialize_models(options.bert_model_dir, options.bidaf_model_dir) is False: + logging.error('Could not initilize model directories. Exiting..') + return + + # Build the configuration + logging.info('Building config..') + ref_obj = {"language_helper" : language_helper} + app_config = ModelHandler.build_config(ref_obj) + + logging.info('Starting Tornado model runtime service..') + application = tornado.web.Application(app_config) + application.listen(options.port) + + # Protect the loop with a try/catch + try: + # Start the app and wait for a close + tornado.ioloop.IOLoop.instance().start() + finally: + # handle error with shutting down loop + tornado.ioloop.IOLoop.instance().stop() + +if __name__ == '__main__': + setup_logging() + run() diff --git a/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/model_cache.py b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/model_cache.py new file mode 100644 index 000000000..027867aa4 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/model_runtime_svc_corebot101/model_cache.py @@ -0,0 +1,58 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Model Cache. +Simple container for bidaf/bert models. +""" +import os +import logging + +from model_corebot101.bidaf.model_runtime import BidafModelRuntime +from model_corebot101.bert.model_runtime import BertModelRuntime + +#pylint:disable=line-too-long,bad-continuation +class DeprecateModelCache(object): + """Model Cache implementation.""" + def __init__(self): + self._logger = logging.getLogger('ModelCache') + self._bert_model_dir = None + self._bidaf_model_dir = None + self._bert_intents = None + self._bidaf_entities = None + + def init_model_dir(self, bidaf_model_dir: str, bert_model_dir: str) -> bool: + """ Initialize models """ + if not os.path.exists(bidaf_model_dir): + # BiDAF needs no training, just download + if not BidafModelRuntime.init_bidaf(bidaf_model_dir, True): + self._logger.error('bidaf model creation failed at model directory %s..', bidaf_model_dir) + return False + + if not os.path.exists(bert_model_dir): + self._logger.error('BERT model directory does not exist "%s"', bert_model_dir) + return False + + self._bert_model_dir = os.path.normpath(bert_model_dir) + self._bidaf_model_dir = os.path.normpath(bidaf_model_dir) + + self._bert_intents = BertModelRuntime(model_dir=self._bert_model_dir, label_list=["Book flight", "Cancel"]) + self._bidaf_entities = BidafModelRuntime(targets=["from", "to", "date"], + queries={ + "from": "which city will you travel from?", + "to": "which city will you travel to?", + "date": "which date will you travel?", + }, + model_dir=self._bidaf_model_dir + ) + self._logger.info('bidaf entities model created : %s..', self._bidaf_model_dir) + + return True + + @property + def entities(self): + """Get the model that detect entities: bidaf.""" + return self._bidaf_entities + + @property + def intents(self): + """Get the model that detect intents: bert.""" + return self._bert_intents diff --git a/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/setup.py b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/setup.py new file mode 100644 index 000000000..26e4b3bca --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/model_runtime_svc/setup.py @@ -0,0 +1,45 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import os +from setuptools import setup + +REQUIRES = [ + "scikit-learn>=0.21.2", + "scipy>=1.3.0", + "tornado>=6.0.2", + "model_corebot101>=0.0.1", +] + +root = os.path.abspath(os.path.dirname(__file__)) + +with open(os.path.join(root, "model_runtime_svc_corebot101", "about.py")) as f: + package_info = {} + info = f.read() + exec(info, package_info) + +setup( + name=package_info["__title__"], + version=package_info["__version__"], + url=package_info["__uri__"], + author=package_info["__author__"], + description=package_info["__description__"], + keywords="botframework azure botbuilder", + long_description=package_info["__summary__"], + license=package_info["__license__"], + packages=[ + "model_runtime_svc_corebot101", + "model_runtime_svc_corebot101.handlers" + ], + install_requires=REQUIRES, + dependency_links=['https://github.com/pytorch/pytorch'], + include_package_data=True, + classifiers=[ + "Programming Language :: Python :: 3.6", + "Intended Audience :: Developers", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Development Status :: 3 - Alpha", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + ] +) diff --git a/samples/python_flask/101.corebot-bert-bidaf/notebooks/bert_model_runtime.ipynb b/samples/python_flask/101.corebot-bert-bidaf/notebooks/bert_model_runtime.ipynb new file mode 100644 index 000000000..4dd87e70d --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/notebooks/bert_model_runtime.ipynb @@ -0,0 +1,323 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test the intent classifier\n", + "This notebook uses the model trained in [bert_train.ipynb notebook](bert_train.ipynb). See the [README.md](../README.md) for instructions on how to use that notebook.\n", + "\n", + "## `model_corebot101` package\n", + "This sample creates a separate python package (`model_corebot101`) which contains code to train (tune), evaluate and infer intent classifiers for this sample.\n", + "\n", + "\n", + "## See also:\n", + "- [bert_train.ipynb](bert_train.ipynb) to train the intent classifier model.\n", + "- [bidaf_model_runtime.ipynb](bidaf_model_runtime.ipynb) to test the associated BiDAF model to test the entity classifier model.\n", + "- [The model runtime](model_runtime.ipynb) to test the both the BERT and BiDAF model together." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from model_corebot101.bert.model_runtime.bert_model_runtime import BertModelRuntime" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `BertModelRuntime` class\n", + "The `BertModelRuntime` class is used to perform the inferences against the bot utterances.\n", + "\n", + "The model is placed (during training) in the `/models/bert` directory which is packaged with the bot.\n", + "\n", + "The `label_list` is an array of intents." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from pathlib import Path\n", + "bert_model_dir = os.path.abspath(os.path.join(Path.home(), \"models/bert\"))\n", + "s = BertModelRuntime(model_dir=bert_model_dir, label_list=[\"Book flight\", \"Cancel\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `BertModelRuntime.serve` method\n", + "The `BertModelRuntime.serve` method is used to perform the classification against the bot utterances." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Book flight'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve('i want to travel from new york to berlin')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Book flight'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"please book a flight for me\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Book flight'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"from seattle to san\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Cancel'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"random random random 42\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Cancel'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"any\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Book flight'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"take me to New York\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Book flight'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"we'd like to go to seattle\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Cancel'" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"not this one\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Cancel'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"I don't care about this one\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Cancel'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"I don't want to see that\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Cancel'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"boring\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Book flight'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"you have no clue how to book a flight\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "botsample", + "language": "python", + "name": "botsample" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/samples/python_flask/101.corebot-bert-bidaf/notebooks/bert_train.ipynb b/samples/python_flask/101.corebot-bert-bidaf/notebooks/bert_train.ipynb new file mode 100644 index 000000000..a9296240e --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/notebooks/bert_train.ipynb @@ -0,0 +1,281 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train the intent classifier using pretrained BERT model as featurizer\n", + "This notebook creates the BERT language classifier model. See the [README.md](../README.md) for instructions on how to run this sample.\n", + "The resulting model is placed in the `/models/bert` directory which is packaged with the bot.\n", + "\n", + "## `model_corebot101` package\n", + "This sample creates a separate python package (`model_corebot101`) which contains all the code to train, evaluate and infer intent classifiers for this sample.\n", + "\n", + "## See also:\n", + "- [The BERT runtime model](bert_model_runtime.ipynb) to test the resulting intent classifier model.\n", + "- [The BiDAF runtime model](bidaf_model_runtime.ipynb) to test the associated BiDAF model to test the entity classifier model.\n", + "- [The model runtime](model_runtime.ipynb) to test the both the BERT and BiDAF model together.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from model_corebot101.bert.train import BertTrainEval" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `BertTrainEvan.train_eval` method\n", + "This method performs all the training and performs evaluation that's listed at the bottom of the output. Training may take several minutes to complete.\n", + "\n", + "The evaluation output should look something like the following:\n", + "```bash\n", + "06/02/2019 19:46:52 - INFO - model_corebot101.bert.train.bert_train_eval - ***** Eval results *****\n", + "06/02/2019 19:46:52 - INFO - model_corebot101.bert.train.bert_train_eval - acc = 1.0\n", + "06/02/2019 19:46:52 - INFO - model_corebot101.bert.train.bert_train_eval - acc_and_f1 = 1.0\n", + "06/02/2019 19:46:52 - INFO - model_corebot101.bert.train.bert_train_eval - eval_loss = 0.06498947739601135\n", + "06/02/2019 19:46:52 - INFO - model_corebot101.bert.train.bert_train_eval - f1 = 1.0\n", + "06/02/2019 19:46:52 - INFO - model_corebot101.bert.train.bert_train_eval - global_step = 12\n", + "06/02/2019 19:46:52 - INFO - model_corebot101.bert.train.bert_train_eval - loss = 0.02480666587750117\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Bert Model training_data_dir is set to d:\\python\\daveta-docker-wizard\\apub\\samples\\flask\\101.corebot-bert-bidaf\\model\\model_corebot101\\bert\\training_data\n", + "Bert Model model_dir is set to C:\\Users\\daveta\\models\\bert\n", + "07/02/2019 07:16:09 - INFO - model_corebot101.bert.train.bert_train_eval - device: cpu n_gpu: 0, distributed training: False, 16-bits training: None\n", + "07/02/2019 07:16:09 - INFO - pytorch_pretrained_bert.tokenization - loading vocabulary file https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt from cache at C:\\Users\\daveta\\.pytorch_pretrained_bert\\26bc1ad6c0ac742e9b52263248f6d0f00068293b33709fae12320c0e35ccfbbb.542ce4285a40d23a559526243235df47c5f75c197f04f37d1a0c124c32c9a084\n", + "07/02/2019 07:16:10 - INFO - pytorch_pretrained_bert.modeling - loading archive file https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased.tar.gz from cache at C:\\Users\\daveta\\.pytorch_pretrained_bert\\distributed_-1\\9c41111e2de84547a463fd39217199738d1e3deb72d4fec4399e6e241983c6f0.ae3cef932725ca7a30cdcb93fc6e09150a55e2a130ec7af63975a16c153ae2ba\n", + "07/02/2019 07:16:10 - INFO - pytorch_pretrained_bert.modeling - extracting archive file C:\\Users\\daveta\\.pytorch_pretrained_bert\\distributed_-1\\9c41111e2de84547a463fd39217199738d1e3deb72d4fec4399e6e241983c6f0.ae3cef932725ca7a30cdcb93fc6e09150a55e2a130ec7af63975a16c153ae2ba to temp dir C:\\Users\\daveta\\AppData\\Local\\Temp\\tmp9hepebcl\n", + "07/02/2019 07:16:13 - INFO - pytorch_pretrained_bert.modeling - Model config {\n", + " \"attention_probs_dropout_prob\": 0.1,\n", + " \"hidden_act\": \"gelu\",\n", + " \"hidden_dropout_prob\": 0.1,\n", + " \"hidden_size\": 768,\n", + " \"initializer_range\": 0.02,\n", + " \"intermediate_size\": 3072,\n", + " \"max_position_embeddings\": 512,\n", + " \"num_attention_heads\": 12,\n", + " \"num_hidden_layers\": 12,\n", + " \"type_vocab_size\": 2,\n", + " \"vocab_size\": 30522\n", + "}\n", + "\n", + "07/02/2019 07:16:16 - INFO - pytorch_pretrained_bert.modeling - Weights of BertForSequenceClassification not initialized from pretrained model: ['classifier.weight', 'classifier.bias']\n", + "07/02/2019 07:16:16 - INFO - pytorch_pretrained_bert.modeling - Weights from pretrained model not used in BertForSequenceClassification: ['cls.predictions.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias']\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - Writing example 0 of 16\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - *** Example ***\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - guid: train-0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - tokens: [CLS] book flight from london to paris on feb 14th [SEP]\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_ids: 101 2338 3462 2013 2414 2000 3000 2006 13114 6400 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_mask: 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - segment_ids: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - label: Book flight (id = 0)\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - *** Example ***\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - guid: train-1\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - tokens: [CLS] book flight to berlin on feb 14th [SEP]\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_ids: 101 2338 3462 2000 4068 2006 13114 6400 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_mask: 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - segment_ids: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - label: Book flight (id = 0)\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - *** Example ***\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - guid: train-2\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - tokens: [CLS] book me a flight from london to paris [SEP]\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_ids: 101 2338 2033 1037 3462 2013 2414 2000 3000 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_mask: 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - segment_ids: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - label: Book flight (id = 0)\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - *** Example ***\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - guid: train-3\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - tokens: [CLS] bye [SEP]\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_ids: 101 9061 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_mask: 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - segment_ids: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - label: Cancel (id = 1)\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - *** Example ***\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - guid: train-4\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - tokens: [CLS] cancel booking [SEP]\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_ids: 101 17542 21725 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - input_mask: 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - segment_ids: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.common.bert_util - label: Cancel (id = 1)\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.train.bert_train_eval - ***** Running training *****\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.train.bert_train_eval - Num examples = 16\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.train.bert_train_eval - Batch size = 4\n", + "07/02/2019 07:16:16 - INFO - model_corebot101.bert.train.bert_train_eval - Num steps = 12\n", + "Epoch: 0%| | 0/3 [00:00 float(.30):\n", + " raise Exception(f'Size of output file {f} is out of range of expected.')\n", + " else:\n", + " raise Exception(f'Expected file {f} missing from output.')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "botsample", + "language": "python", + "name": "botsample" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/samples/python_flask/101.corebot-bert-bidaf/notebooks/bidaf_model_runtime.ipynb b/samples/python_flask/101.corebot-bert-bidaf/notebooks/bidaf_model_runtime.ipynb new file mode 100644 index 000000000..682df02c8 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/notebooks/bidaf_model_runtime.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test the BiDAF runtime model\n", + "This notebook uses the BiDAF language entitiy recognizer model. See the [README.md](../README.md) for instructions on how to run this sample.\n", + "\n", + "## `model_corebot101` package\n", + "This sample creates a python package (`model_corebot101`) which contains all the code to train, evaluate and infer intent classifier for this sample.\n", + "\n", + "## See also:\n", + "- [The BERT training model](bert_train.ipynb) to train the intent classifier model.\n", + "- [The BERT runtime model](bert_model_runtime.ipynb) to test the BERT model to test the intent classifier model.\n", + "- [The model runtime](model_runtime.ipynb) to test the both the BERT and BiDAF model together." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from model_corebot101.bidaf.model_runtime.bidaf_model_runtime import BidafModelRuntime\n", + "import os\n", + "from pathlib import Path\n", + "from IPython.display import display\n", + "\n", + "bidaf_model_dir = os.path.abspath(os.path.join(Path.home(), \"models/bidaf\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `BidafModelRuntime` class\n", + "The `BidafModelRuntime` class is used to perform the classification for entities on the bot utterances.\n", + "\n", + "The model is completely is downloaded and placed in the `/models/bidaf` directory.\n", + "\n", + "## `BidafModelRuntime.init_bidaf` method\n", + "The `BidafModelRuntime.init_bidaf` method downloads the necessary ONNX model.\n", + "\n", + "Output should look like the following: \n", + "\n", + "```bash\n", + "Creating bidaf model directory..\n", + "Checking file ../../bot/cognitiveModels/bidaf\\bidaf.onnx..\n", + "Downloading bidaf.onnx...\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "bidaf model directory already present..\n", + "[nltk_data] Downloading package punkt to\n", + "[nltk_data] C:\\Users\\daveta\\models\\bidaf...\n", + "[nltk_data] Package punkt is already up-to-date!\n", + "[nltk_data] Downloading package punkt to\n", + "[nltk_data] C:\\Users\\daveta\\AppData\\Roaming\\nltk_data...\n", + "[nltk_data] Package punkt is already up-to-date!\n", + "Checking file C:\\Users\\daveta\\models\\bidaf\\bidaf.onnx..\n", + "bidaf.onnx downloaded already!\n" + ] + }, + { + "data": { + "text/plain": [ + "'The BiDAF model successfully downloaded.'" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if not BidafModelRuntime.init_bidaf(bidaf_model_dir, True):\n", + " display('The BiDAF model was not downloaded successfully. See output below for more details.')\n", + "else:\n", + " display('The BiDAF model successfully downloaded.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `BidafModelRuntime` class\n", + "The `BidafModelRuntime` class is used to perform the classification against the bot utterances.\n", + "\n", + "- `targets` : an array of entities to classify.\n", + "- `queries` : examples passed to assist the classifier\n", + "- `model_dir` : path to the model\n", + "\n", + "The output should resemble the following:\n", + "\n", + "```bash\n", + "Loading Inference session from C:\\Users\\<>\\models\\bidaf\\bidaf.onnx..\n", + "Inference session loaded..\n", + "Processed queries..\n", + "```\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading Inference session from C:\\Users\\daveta\\models\\bidaf\\bidaf.onnx..\n", + "Inference session loaded..\n", + "Processed queries..\n" + ] + } + ], + "source": [ + "s = BidafModelRuntime(\n", + " targets=[\"from\", \"to\", \"date\"],\n", + " queries={\n", + " \"from\": \"which city will you travel from?\",\n", + " \"to\": \"which city will you travel to?\",\n", + " \"date\": \"which date will you travel?\",\n", + " },\n", + " model_dir = bidaf_model_dir\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'from': 'london', 'to': 'paris', 'date': 'feb 14th'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"flight to paris from london on feb 14th\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'from': 'london', 'to': 'paris', 'date': 'feb 14th'}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"book flight from london to paris on feb 14th\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'from': 'berlin', 'to': 'berlin', 'date': '5th'}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.serve(\"fly from berlin to paris on may 5th\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "botsample", + "language": "python", + "name": "botsample" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/samples/python_flask/101.corebot-bert-bidaf/notebooks/model_runtime.ipynb b/samples/python_flask/101.corebot-bert-bidaf/notebooks/model_runtime.ipynb new file mode 100644 index 000000000..8adca2b30 --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/notebooks/model_runtime.ipynb @@ -0,0 +1,206 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test the intent classifier and entity extractor\n", + "This notebook uses the pretrained BiDAF model and BERT model tuned in [bert_train.ipynb notebook](bert_train.ipynb). See the [README.md](../README.md) for instructions on how to use that notebook.\n", + "\n", + "## See also:\n", + "- [bert_train.ipynb](bert_train.ipynb) to train the intent classifier model.\n", + "- [bert_model_runtime.ipynb](bert_model_runtime.ipynb) to test the BERT intent classifier model.\n", + "- [bidaf_model_runtime.ipynb](bidaf_model_runtime.ipynb) to test the associated BiDAF model to test the entity extractor model." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from model_corebot101.bert.model_runtime.bert_model_runtime import BertModelRuntime\n", + "from model_corebot101.bidaf.model_runtime.bidaf_model_runtime import BidafModelRuntime\n", + "import os\n", + "from pathlib import Path\n", + "bidaf_model_dir = os.path.abspath(os.path.join(Path.home(), \"models/bidaf\"))\n", + "bert_model_dir = os.path.abspath(os.path.join(Path.home(), \"models/bert\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "bidaf model directory already present..\n" + ] + } + ], + "source": [ + "BidafModelRuntime.init_bidaf(bidaf_model_dir, True)\n", + "bidaf = BidafModelRuntime(\n", + " targets=[\"from\", \"to\", \"date\"],\n", + " queries={\n", + " \"from\": \"which city will you travel from?\",\n", + " \"to\": \"which city will you travel to?\",\n", + " \"date\": \"which date will you travel?\",\n", + " },\n", + " model_dir = bidaf_model_dir\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "bert = BertModelRuntime(model_dir=bert_model_dir, label_list=[\"Book flight\", \"Cancel\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def serve(utterance):\n", + " intent = bert.serve(utterance)\n", + " entities = bidaf.serve(utterance)\n", + " return intent, entities" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `BertModelRuntime.serve` method\n", + "The `BertModelRuntime.serve` method is used to perform the classification against the bot utterances." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"flight to paris from london on feb 14th\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"from seattle to san\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"random random random 42\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"any\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"take me to New York\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"we'd like to go to seattle\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"not this one\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"I don't care about this one\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"I don't want to see that\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"boring\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "serve(\"you have no clue how to book a flight\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/samples/python_flask/101.corebot-bert-bidaf/requirements.txt b/samples/python_flask/101.corebot-bert-bidaf/requirements.txt new file mode 100644 index 000000000..496696f2c --- /dev/null +++ b/samples/python_flask/101.corebot-bert-bidaf/requirements.txt @@ -0,0 +1,41 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +# Note: The model must be built first! +# cd model +# + +# The following are installed outside of requirements.txt +# conda install -c pytorch pytorch -y +# pip install onnxruntime +# Install python package dependencies with the following: +# `pip install -r requirements.txt` + +# Bot +Flask>=1.0.2 +asyncio>=3.4.3 +requests>=2.18.1 + +# Bot Framework +botframework-connector>=4.4.0.b1 +botbuilder-schema>=4.4.0.b1 +botbuilder-core>=4.4.0.b1 +botbuilder-dialogs>=4.4.0.b1 +botbuilder-ai>=4.4.0.b1 +datatypes-date-time>=1.0.0.a1 +azure-cognitiveservices-language-luis>=0.2.0 +msrest>=0.6.6 + +# Internal library - must be built first! +model_corebot101>=0.0.1 + +torch +onnx +onnxruntime +tqdm>=4.32.1 +pytorch-pretrained-bert>=0.6.2 +nltk>=3.4.1 +numpy>=1.16.3 +scipy>=1.3.0 +scikit-learn>=0.21.2 + From e16988f5aa0ed9e2bfc28cd062dfc2a2ffb4b512 Mon Sep 17 00:00:00 2001 From: Ashley Ho <35248895+Zerryth@users.noreply.github.com> Date: Wed, 10 Jul 2019 11:26:31 -0700 Subject: [PATCH 2/2] readme edits --- .../101.corebot-bert-bidaf/README.md | 25 ++++++++++++++----- 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/samples/python_flask/101.corebot-bert-bidaf/README.md b/samples/python_flask/101.corebot-bert-bidaf/README.md index e566935ab..4d66d258b 100644 --- a/samples/python_flask/101.corebot-bert-bidaf/README.md +++ b/samples/python_flask/101.corebot-bert-bidaf/README.md @@ -93,7 +93,7 @@ Training the model can be performed in Jupyter Lab. Within the Anaconda shell, launch Jupyter Lab from the sample directory. ```bash -# Start JupyterLab in sample directory +# Start JupyterLab from the root of the sample directory (botsample) 101.corebot-bert-bidaf> jupyter lab ``` @@ -129,7 +129,7 @@ After running the Jupyter Notebook, the output should resemble something like th

Click for screen shot. Showing Completed Model Build - Completed Model Build] + Completed Model Build
@@ -201,6 +201,9 @@ Sometimes it's helpful to host the model outside the bot's process space and ser This section builds on the previous section of [In-process](#in-process). +#### Stop any running bot/model runtime processes +Ensure there are no running bot or model runtimes executing. Hit ^C on any Anaconda shells running flask/bot or the model service runtime (`python main.py`). + #### Modify bot configuration for localhost To call the out-of-process REST API, the bot configuration is modified. Edit the following file: `101.corebot-bert-bidaf/bot/config.py` @@ -231,15 +234,18 @@ Inside a separate Anaconda shell, activate the `botsample` environment, and inst ```bash # Install requirements required for model runtime service -(botsample) 101.corebot-bert-bidaf> cd bot +(botsample) 101.corebot-bert-bidaf> cd model_runtime_svc (botsample) 101.corebot-bert-bidaf\model_runtime_svc> pip install -e . # Note the dot after the -e switch ``` #### Run model runtime service To run the model runtime service, execute the following: ```bash -# From 101.corebot-bert-bidaf\model_runtime_svc\model_runtime_svc_corebot101 directory -python main.py +# Navigate into the model_runtime_svc_corebot101 folder +cd model_runtime_svc_corebot101 + +# From 101.corebot-bert-bidaf\model_runtime_svc\model_runtime_svc_corebot101 +python main.py ``` If not already running, create a separate Anaconda shell set to the `botsample` environment and [run the local bot](#local-in-process) as described above. If it was already running, ensure [the configuration changes made above](#modify-bot-configuration) are running. @@ -252,7 +258,7 @@ This sample also demonstrates using Docker and Docker Compose to run a bot and m #### Modify bot configuration for Docker -To call the out-of-process REST API inside a Docker containerI, the bot configuration is modified. Edit the following file: +To call the out-of-process REST API inside a Docker container, the bot configuration is modified. Edit the following file: `101.corebot-bert-bidaf/bot/config.py` Ensure that the bot configuration is set to serve model predictions remotely by setting `USE_MODEL_RUNTIME_SERVICE` to `True`. @@ -301,6 +307,13 @@ docker ps ``` Look at the logs and docker to ensure the containers are running. +> **NOTE**: When testing the bot inside containers, use your local IP address instead of `localhost` (`http://:3978/api/messages`). +> To find your IP address: +> +> - On **Windows**, `ipconfig` at a command prompt. +> - On **Linux**, `ip addr` at a command prompt. + + ## Testing the bot using Bot Framework Emulator [Bot Framework Emulator](https://github.com/microsoft/botframework-emulator) is a desktop application that allows bot developers to test and debug their bots on localhost or running remotely through a tunnel.