Table of Contents
This work tries to reproduce the results of A Neural Conversational Model (aka the Google chatbot). It uses a RNN (seq2seq model) for sentence predictions. It is done using python and TensorFlow.
The loading corpus part of the program is inspired by the Torch neuralconvo from macournoyer.
For now, DeepQA support the following dialog corpus:
To speedup the training, it's also possible to use pre-trained word embeddings (thanks to Eschnou). More info here.
The program requires the following dependencies (easy to install using pip:
pip3 install -r requirements.txt):
- python 3.5
- tensorflow (tested with v1.0)
- CUDA (for using GPU)
- nltk (natural language toolkit for tokenized the sentences)
- tqdm (for the nice progression bars)
You might also need to download additional data to make nltk work.
python3 -m nltk.downloader punkt
The Cornell dataset is already included. For the other datasets, look at the readme files into their respective folders (inside
The web interface requires some additional packages:
- django (tested with 1.10)
- Redis (see here)
- asgi_redis (at least 1.0)
A Docker installation is also available. More detailed instructions here.
To train the model, simply run
main.py. Once trained, you can test the results with
main.py --test (results generated in 'save/model/samples_predictions.txt') or
main.py --test interactive (more fun).
Here are some flags which could be useful. For more help and options, use
python main.py -h:
--modelTag <name>: allow to give a name to the current model to differentiate between them when testing/training.
--keepAll: use this flag when training if when testing, you want to see the predictions at different steps (it can be interesting to see the program changes its name and age as the training progress). Warning: It can quickly take a lot of storage space if you don't increase the
--filterVocab 20 or
--vocabularySize 30000: Limit the vocabulary size to and optimize the performances and memory usage. Replace the words used less than 20 times by the
<unknown> token and set a maximum vocabulary size.
--verbose: when testing, will print the sentences as they are computed.
--playDataset: show some dialogue samples from the dataset (can be use conjointly with
--createDataset if this is the only action you want to perform).
To visualize the computational graph and the cost with TensorBoard, just run
tensorboard --logdir save/.
By default, the network architecture is a standard encoder/decoder with two LSTM layers (hidden size of 256) and an embedding size for the vocabulary of 32. The network is trained using ADAM. The maximum sentence length is set to 10 words, but can be increased.
Once trained, it's possible to chat with it using a more user friendly interface. The server will look at the model copied to
save/model-server/model.ckpt. The first time you want to use it, you'll need to configure it with:
python manage.py makemigrations
python manage.py migrate
Then, to launch the server locally, use the following commands:
redis-server & # Launch Redis in background
python manage.py runserver
After launch, the interface should be available on http://localhost:8000/. If you want to deploy the program on a server, use
python manage.py runserver 0.0.0.0 instead. More info here.
Surprisingly, it's possible to get some results after only 1 or 2 hours of training (on a GeForce GT 740M), by drastically reducing the input sequence to 5 words and output to 3 (plus the
eos tokens) and by using a small embedding size (something like 25). Since then I modified the code and now the output length has to match the input one but you can still reproduce the original results, using this version.
Of course, the network won't be really chatty:
Q: What is your name ?
Q: What does that mean ?
A: I dunno.
Q: How old are you ?
Q: Will Google hire me ?
Q: Tell me the alphabet
A: Fuck you.
Q: That's not nice
Here is some case where it fails:
Q: Who is Laura ?
A: My brother.
Q: Say 'goodbye'
Q: What is cooking ?
A: A channel.
Q: Can you say no ?
Q: Two plus two
With longer sentences, the network is much slower to train. After 250000 iterations with maxLength=10, the network still mainly gives evasive answers (by answering most of the open ended questions by 'I don't know') but it seems to have integrated some basic semantic:
Q: When are the fireworks ?
Q: What color ?
Q: Which apple ?
A: That's the first one.
Q: What time is it ?
A: Eleven o'clock.
Q: Who is Skywalker ?
A: She's a freelance bio-exorcist.
Q: Who is John ?
A: The old man.
Q: Who is Jenny ?
A: The man who killed herself.
Q: When were you born ?
As shown on the last questions, the network still does some confusion between the genders and the present/future. I also tried some deeper philosophical questions with more or less success.
Q: What is the purpose of being intelligent ?
A: The man are obsolete.
Q: What is immoral ?
A: The truth.
Q: What is morality ?
A: The worst.
Q: What is the purpose of existence ?
A: It 's private.
Q: What happens if machines can think ?
A: I think I'll just lie with you.
The model I trained is quite limited by the embedding size I put and by its size, and by the training corpus size. Its 'thought vector' is also probably too small to answer the kind of following:
Q: My name is David. What is my name ?
Q: My name is John. What is my name ?
A: Carl Smith.
Q: How many legs does a cat have ?
Q: How many legs does a spider have ?
Q: Do you prefer football or soccer ?
It also seems to overfit as sometimes it will just pop out sentences from its training set unrelated to the question. Adding some dropout should reduce the issue.
Q: I play tennis. What do I play ?
A: I'm going to get laid.
Q: What color is the sky ?
A: One of the deputies is everywhere.
You can find a pre-trained model here, trained of the default corpus. To use it:
- Extract the zip file inside
- Copy the preprocessed dataset from
./main.py --modelTag pretrainedv2 --test interactive.
Thanks to Nicholas C., here (original) are some additional pre-trained models (compatible with TF 1.2) for diverse datasets. The folder also contains the pre-processed dataset for Cornell, OpenSubtitles, Ubuntu and Scotus (to move inside
data/samples/). Those are required is you don't want to process the datasets yourself.
If you have a high-end GPU, don't hesitate to play with the hyper-parameters/corpus to train a better model. From my experiments, it seems that the learning rate and dropout rate have the most impact on the results. Also if you want to share your models, don't hesitate to contact me and I'll add it here.
In addition to trying larger/deeper model, there are a lot of small improvements which could be tested. Don't hesitate to send a pull request if you implement one of those. Here are some ideas:
- For now, the predictions are deterministic (the network just take the most likely output) so when answering a question, the network will always gives the same answer. By adding a sampling mechanism, the network could give more diverse (and maybe more interesting) answers. The easiest way to do that is to sample the next predicted word from the SoftMax probability distribution. By combining that with the
loop_function argument of
tf.nn.seq2seq.rnn_decoder, it shouldn't be too difficult to add. After that, it should be possible to play with the SoftMax temperature to get more conservative or exotic predictions.
- Adding attention could potentially improve the predictions, especially for longer sentences. It should be straightforward by replacing
- Having more data usually don't hurt. Training on a bigger corpus should be beneficial. Reddit comments dataset seems the biggest for now (and is too big for this program to support it). Another trick to artificially increase the dataset size when creating the corpus could be to split the sentences of each training sample (ex: from the sample
Q:Sentence 1. Sentence 2. => A:Sentence X. Sentence Y. we could generate 3 new samples:
Q:Sentence 1. Sentence 2. => A:Sentence X.,
Q:Sentence 2. => A:Sentence X. Sentence Y. and
Q:Sentence 2. => A:Sentence X.. Warning: other combinations like
Q:Sentence 1. => A:Sentence X. won't work because it would break the transition
2 => X which links the question to the answer)
- The testing curve should really be monitored as done in my other music generation project. This would greatly help to see the impact of dropout on overfitting. For now it's just done empirically by manually checking the testing prediction at different training steps.
- For now, the questions are independent from each other. To link questions together, a straightforward way would be to feed all previous questions and answer to the encoder before giving the answer. Some caching could be done on the final encoder stated to avoid recomputing it each time. To improve the accuracy, the network should be retrain on entire dialogues instead of just individual QA. Also when feeding the previous dialogue to the encoder, new tokens
<A> could be added so the encoder knows when the interlocutor is changing. I'm not sure though that the simple seq2seq model would be sufficient to capture long term dependencies between sentences. Adding a bucket system to group similar input lengths together could greatly improve training speed.