About
____ __ __ _____ _____
/ _ \____ __ ______ ______/ /_____/ /___ /_ _\ /_ _\
/ /_/ / __ \/ / / / __ \/ ___\, / __ \, / __ \ 0> 0> <0 <0
/ ,\ ,/ /_/ /\ \/ / /_/ /\__, / / /_/ / / /_/ / \__⊽__/ \__⊽__/
\/ \/\__/\/ \__/ ,___/\____/\/\__/\/\/ ,___/ ⋂ - Hey! ⋂
\____/ \____/ Olà! -
Ravestate is a reactive library for real-time natural language dialog systems.
It combines elements from event-based and reactive programming into an API,
where application states are defined as functions that are run when a certain
boolean set of criteria (signals) in the current application context is satisfied.
It is the first reactive API to allow for boolean combinations of events.
You may find a short introductory video here.
Reactive Hello World
import ravestate as rs
import ravestate_rawio as rawio
import ravestate_conio
with rs.Module(name="hi!", depends=(rawio.mod,)):
@rs.state(cond=rs.sig_startup, write=rawio.prop_out)
def hello_world(context):
context[rawio.prop_out] = "Waddup waddup waddup!"
rs.Context("hi!").run()
Raveboard
Ravestate has an angular/socket.io-based
interactive (beta) UI called Raveboard. It shows the events (spikes) that are
currently relevant, as well as potential state activations that are referencing these spikes.
When using raveboard.UIContext
instead of Context
, or python3 -m raveboard
instead of
python3 -m ravestate
, a real-time visualization of all spikes/activations, as well as a chat window,
will be hosted on a configurable port. You can find dedicated docs here.
The following GIF shows raveboard together with ravestate_visionio
:
Installation
Via PIP
The easiest way to install ravestate is through pip:
pip install ravestate
Note: Ravestate requires Python 3.6 or higher. It is tested
on Ubuntu 16.04 and 18.04, as well as macOS > High Sierra.
It is currently not tested on Windows.
For reliability, we recommend using an environment virtualization tool,
like virtualenv
or conda.
Via Docker/Docker-compose
Why Docker?
Ravestate offers a docker image that bundles runtime dependencies that are required
for advanced cognitive dialog systems/chatbots:
- 📦 Neo4j: The Neo4j Graph DBMS is used by Scientio for long-term memory.
- 💡 Redis: A Redis in-memory DB is used for fast short-term memory, e.g. to store/recall facial feature vectors.
- 🤦 FaceOracle: A Roboy-developed server-client architecture used by
ravestate_visionio
for real-time face recognition. - 🤖 ROS Melodic: Version 1 of the Robot Operating System for distributed real-time communication.
This version of ROS requires a broker process (
roscore
), which is started automatically inside the container. - 🤖 ROS2 Dashing: Version 2 of the Robot Operating System for distributed real-time communication.
- 🤗 HuggingFace Transformer Models: Language models (ConvAI GPT/OpenAI GPT2)
for neural-network-generated conversation.
- 💌 Roboy ROS Messages: Message defs. that are required to interact with Roboy hardware.
Installing these dependencies by hand is time-consuming and error-prone, so using Docker
to ship them makes everyone's lives easier!
How to build?
Clone ravestate:
git clone git@github.com:roboy/ravestate && cd ravestate
You can build the ravestate container using the provided Dockerfile
:
docker build -t ravestate .
Note: Building the container takes time and requires a good internet connection, since
all of the dependencies are several Gigabytes in size.
How to run?
Use one of the following docker-compose commands to run ravestate in Docker:
Platform | Command |
---|
Linux | docker-compose up -d rs-linux |
macOS | docker-compose up -d rs-macos |
Windows | Not supported yet. |
The container is now running and a shell inside the container can be opened with:
docker exec -it rs bash
You can now start ravestate or raveboard as described in the section Running Hello World.
python3 -m ravestate [...]
Which services are exposed from the container?
Service | Port | Description |
---|
Neo4j UI | 7474 | Neo4j UI for DB stored under <ravestate>/db/neo4j |
Neo4j Bolt Interface | 7687 | Communication with Neo4j DBMS |
Redis Database Dump | - | A dump of the Redis DB in the container can be found under <ravestate>/db/redis |
FaceOracle Client Interface | 8088 | Visualisation for the FaceOracle client. |
Raveboard | 42424 | Default port for raveboard, the ravestate debug UI. |
For development
Initial configuration and setup
Clone the repository and install dependencies:
cd ~
python3 -m virtualenv -p python3 python-ravestate
. python-ravestate/bin/activate
git clone git@github.com:roboy/ravestate && cd ravestate
pip install -r requirements.txt
pip install -r requirements-dev.txt
pip install -e .
Launch the ravestate docker container as described above. It will serve you Neo4j,
which is a backend for Scientio, Roboy's
long-term memory system.
In the config
folder, create a file called keys.yml
. It should have the following content:
module: telegramio
config:
telegram-token: <sexycactus>
You may now conduct your first conversation with ravestate:
python3 -m raveboard -f config/generic.yml -f config/keys.yml
Open raveboard on localhost:42424/ravestate/index.html?rs-sio-url=http%3A//localhost%3A42424
to conduct your first conversation with ravestate.
After the conversation, check the Neo4j interface under localhost:7474
. It should now contain some nodes!
Reminder: Whenever you use ravestate from the command line, source the virtual environment first!
Running your Telegram bot
To test your telegram bot with a custom bot token in your keys.yml
,
just run telegram_test.yml
instead of generic.yml
. This will load the ravestate_telegramio
module.
Setting up PyCharm
- Open your local ravestate clone as a project in pycharm.
- Under
Project Preferences > Python interpreter
, set your virtual environment. - Mark the
modules
folder as sources root via the right-click context menu. - Create a run config via the "Edit configurations menu":
• Create a new Python configuration.
• Set raveboard
as the module to execute
• Set the working directory to the git clone directory.
• Set parameters to -f config/generic.yml -f config/keys.yml
.
- You should now be able to run the generic ravestate config from PyCharm.
Running Hello World
Ravestate applications are defined by a configuration,
which specifies the ravestate modules that should be loaded.
To run the basic hello world application, run ravestate
with a config file or command line arguments:
Running with command line spec
You can easily run a combination of ravestate modules in a shared context,
by listing them as arguments to python3 -m ravestate
:
python3 -m ravestate \
ravestate_wildtalk \
ravestate_conio \
ravestate_hibye \
ravestate_persqa
Run python3 -m ravestate -h
to see more options!
Running with config file(s)
You may specify a series of config files to configure ravestate context,
when specifying everything through the command line becomes too laborious:
module: core
config:
import:
- ravestate_wildtalk
- ravestate_conio
- ravestate_hibye
- ravestate_persqa
Then, run ravestate
with this config file:
python3 -m ravestate -f hello_world.yml
Modules
Ravestate offers a landscape of fine-grained modules
for different aspects of dialog application tasks, which
may be seen in the following dependency diagram. Broadly,
the modules are categorized into Core (Blue), I/O (Yellow),
External (Red) and Skills (Green):
Core Modules
Module name | Description |
---|
ravestate | Core ravestate library. |
ravestate_rawio | Provides raw_in , raw_out , pic_in properties, which are served by the IO modules. |
ravestate_ontology | Connects to scientio to serve a built-in ontology. |
ravestate_interloc | Provides the all_interlocutors property, where present interlocutors are registered by the IO modules. |
ravestate_idle | Provides bored and impatient signals, as specified here. |
ravestate_verbaliser | Utilities for easy management of conversational text, documented here. |
ravestate_nlp | Spacy-based NLP properties and signals, documented here. |
ravestate_emotion | Generates signals for, and recognizes specific emotions (sig_shy , sig_surprise , sig_happy , sig_affectionate ). |
ravestate_ros1 | Provides specific Ros1PubProperty , Ros1SubProperty and Ros1CallProperty context properties, which greatly simplify working with ROS1 in ravestate. Documentation here. |
ravestate_ros2 | Provides specific Ros2PubProperty , Ros2SubProperty and Ros2CallProperty context properties, which greatly simplify working with ROS2 in ravestate. |
IO Modules
Module name | Description |
---|
ravestate_conio | Simple command-line based IO for development purposes. |
ravestate_telegramio | Single- or Multi-process Telegram server module, documented here. |
ravestate_roboyio | PyroBoy -based STT/TTS with ROS2. |
ravestate_visionio | See dedicated docs here. Enables face-recognition based dialog interactions. |
Skill Modules
Module name | Description |
---|
ravestate_wildtalk | See docs here - runs generative language models (GPT-2, ConvAi, ParlAi)! |
ravestate_hibye | Simply voices Hi! (or the likes thereof) when an interlocutor is added, and Bye when one is removed. |
ravestate_persqa | Conducts personalized smalltalk with interlocutors, interacts with Scientio to persist trivia. |
ravestate_genqa | DrQA -based general question answering module. |
ravestate_roboyqa | QA module which provides answers to questions about Roboy, such as Who is your dad? |
ravestate_akinator (*) | Enables dialog-based play of Akinator! |
ravestate_sendpics (*) | Uses face recognition to extract facial features and an assiciated Person with pic_in and ontology, which are then persisted in Redis and Scientio. |
ravestate_fillers | Recognize when the dialog context is taking a long time to produce an answer, and voice a filler like "Uhm" or "Let's see...". |
Note: (*) = deprecated.
Running tests
If you have built the ravestate docker image as described above,
you may run the test suite as follows:
docker run -t -v $(pwd):/ravestate -w /ravestate ravestate ./run_tests.sh
Building/maintaining the docs
If you have installed the dependencies from requirements-dev.txt
,
generate the docs by running this command at project root:
export PYTHONPATH=$PYTHONPATH:$(pwd)/modules
git rm -rf docs
rm -rf _build docs
pydocmd build
mkdir -p docs/resources/docs && cp resources/docs/*.png docs/resources/docs && cp resources/docs/*.gif docs/resources/docs
git add docs/*
The structure and content of the docs are defined in the file pydocmd.yml
.