Interpretable reaction prediction

Requirements

OpenNMT-py as described below

Usage

Integrated Gradients

Given a reactant and reagents and two possible target structures, it attributes the difference in probability between the two targets to part of the input.

python translate_IG.py

opts:

• -model model file used, type: .pt
• -baseline The baseline for IGs, a single . by default, type: .txt
• -src reactant and reagent and tokenized strings, type: .txt
• -tgt and -tgt2 are the two targets as tokenized strings, type: .txt
• -n_ig_steps number of points to approximate the straight line path for IG, type: int
• -output file where the IG attributions are saved, type: .npy

Remaining arguments are the same as for the translate.py which is the file used to make predictions.

Attribution to Training Data

Attribute the prediction to some of the training set reactions.

Usage:

• Generate the encoder hidden state for each reaction in the training set using experiments/data_attribution/gen_hiddens.sh
• Concatentate the hidden states into a single numpy array using experiments/data_attribution/process_hiddens.sh
• Prepare the training set for visualisation of the best matching reactions using experiments/data_attribution/prep_train_rxs.sh
• attribute the reaction of interest using experiments/data_attribution/attribute_to_data.sh

OpenNMT-py: Open-Source Neural Machine Translation

This is a Pytorch port of OpenNMT, an open-source (MIT) neural machine translation system. It is designed to be research friendly to try out new ideas in translation, summary, image-to-text, morphology, and many other domains. Some companies have proven the code to be production ready.

We love contributions. Please consult the Issues page for any Contributions Welcome tagged post.

Before raising an issue, make sure you read the requirements and the documentation examples.

Unless there is a bug, please use the Forum or Gitter to ask questions.

Table of Contents

• Full Documentation
• Requirements
• Features
• Quickstart
• Run on FloydHub
• Acknowledgements
• Citation

Requirements

Install OpenNMT-py from pip:

pip install OpenNMT-py

or from the sources:

git clone https://github.com/OpenNMT/OpenNMT-py.git
cd OpenNMT-py
python setup.py install

Note: If you have MemoryError in the install try to use pip with --no-cache-dir.

(Optionnal) some advanced features (e.g. working audio, image or pretrained models) requires extra packages, you can install it with:

pip install -r requirements.opt.txt

Note:

• some features require Python 3.5 and after (eg: Distributed multigpu, entmax)
• we currently only support PyTorch 1.2 (should work with 1.1)

Features

• Seq2Seq models (encoder-decoder) with multiple RNN cells (lstm/gru) and attention (dotprod/mlp) types
• Transformer models
• Copy and Coverage Attention
• Pretrained Embeddings
• Source word features
• Image-to-text processing
• Speech-to-text processing
• TensorBoard logging
• Multi-GPU training
• Data preprocessing
• Inference (translation) with batching and beam search
• Inference time loss functions.
• [Conv2Conv convolution model]
• SRU "RNNs faster than CNN" paper
• Mixed-precision training with APEX, optimized on Tensor Cores

Quickstart

Full Documentation

Step 1: Preprocess the data

onmt_preprocess -train_src data/src-train.txt -train_tgt data/tgt-train.txt -valid_src data/src-val.txt -valid_tgt data/tgt-val.txt -save_data data/demo

We will be working with some example data in data/ folder.

The data consists of parallel source (src) and target (tgt) data containing one sentence per line with tokens separated by a space:

• src-train.txt
• tgt-train.txt
• src-val.txt
• tgt-val.txt

Validation files are required and used to evaluate the convergence of the training. It usually contains no more than 5000 sentences.

After running the preprocessing, the following files are generated:

• demo.train.pt: serialized PyTorch file containing training data
• demo.valid.pt: serialized PyTorch file containing validation data
• demo.vocab.pt: serialized PyTorch file containing vocabulary data

Internally the system never touches the words themselves, but uses these indices.

Step 2: Train the model

onmt_train -data data/demo -save_model demo-model

The main train command is quite simple. Minimally it takes a data file and a save file. This will run the default model, which consists of a 2-layer LSTM with 500 hidden units on both the encoder/decoder. If you want to train on GPU, you need to set, as an example: CUDA_VISIBLE_DEVICES=1,3 -world_size 2 -gpu_ranks 0 1 to use (say) GPU 1 and 3 on this node only. To know more about distributed training on single or multi nodes, read the FAQ section.

Step 3: Translate

onmt_translate -model demo-model_acc_XX.XX_ppl_XXX.XX_eX.pt -src data/src-test.txt -output pred.txt -replace_unk -verbose

Now you have a model which you can use to predict on new data. We do this by running beam search. This will output predictions into pred.txt.

!!! note "Note" The predictions are going to be quite terrible, as the demo dataset is small. Try running on some larger datasets! For example you can download millions of parallel sentences for translation or summarization.

Alternative: Run on FloydHub

Click this button to open a Workspace on FloydHub for training/testing your code.

Pretrained embeddings (e.g. GloVe)

Please see the FAQ: How to use GloVe pre-trained embeddings in OpenNMT-py

Pretrained Models

The following pretrained models can be downloaded and used with translate.py.

http://opennmt.net/Models-py/

Acknowledgements

OpenNMT-py is run as a collaborative open-source project. The original code was written by Adam Lerer (NYC) to reproduce OpenNMT-Lua using Pytorch.

Major contributors are: Sasha Rush (Cambridge, MA) Vincent Nguyen (Ubiqus) Ben Peters (Lisbon) Sebastian Gehrmann (Harvard NLP) Yuntian Deng (Harvard NLP) Guillaume Klein (Systran) Paul Tardy (Ubiqus / Lium) François Hernandez (Ubiqus) Jianyu Zhan (Shanghai) [Dylan Flaute](http://github.com/flauted (University of Dayton) and more !

OpentNMT-py belongs to the OpenNMT project along with OpenNMT-Lua and OpenNMT-tf.

Citation

OpenNMT: Neural Machine Translation Toolkit

OpenNMT technical report

@inproceedings{opennmt,
  author    = {Guillaume Klein and
               Yoon Kim and
               Yuntian Deng and
               Jean Senellart and
               Alexander M. Rush},
  title     = {Open{NMT}: Open-Source Toolkit for Neural Machine Translation},
  booktitle = {Proc. ACL},
  year      = {2017},
  url       = {https://doi.org/10.18653/v1/P17-4012},
  doi       = {10.18653/v1/P17-4012}
}