Writing Code for NLP

Research
EMNLP 2018
{joelg,mattg,markn}@allenai.org
Who we are
Matt Gardner (@nlpmattg)
Matt is a research scientist on AllenNLP. He was the original
architect of AllenNLP, and he co-hosts the NLP Highlights podcast.

Mark Neumann (@markneumannnn)

Mark is a research engineer on AllenNLP. He helped build AllenNLP
and its precursor DeepQA with Matt, and has implemented many of
the models in the demos.

Joel Grus (@joelgrus)

Joel is a research engineer on AllenNLP, although you may know
him better from "I Don't Like Notebooks" or from "Fizz Buzz in
Tensorflow" or from his book Data Science from Scratch.
Outline
● How to write code when prototyping
● Developing good processes

BREAK

● How to write reusable code for NLP

● Case Study: A Part-of-Speech Tagger
● Sharing Your Research
What we expect you
know already
What we expect you know already

modern (neural) NLP

What we expect you know already

Python
What we expect you know already
the difference between good science and bad science
What you'll learn
today
What you'll learn today
how to write code in a way that facilitates good science and
reproducible experiments
What you'll learn today
how to write code in a way that makes your life easier
The Elephant in the Room: AllenNLP
● This is not a tutorial about AllenNLP
● But (obviously, seeing as we wrote it)
AllenNLP represents our experiences
and opinions about how best to write AllenNLP

research code
● Accordingly, we'll use it in most of our
examples
● And we hope you'll come out of this
tutorial wanting to give it a try
● But our goal is that you find the tutorial
useful even if you never use AllenNLP
Two modes of writing
research code
 2: writing
1: prototyping components
Prototyping New
Models
Main goals during prototyping

- Write code quickly

- Run experiments, keep track of what you tried

- Analyze model behavior - did it do what you wanted?

Main goals during prototyping

- Write code quickly

- Run experiments, keep track of what you tried

- Analyze model behavior - did it do what you wanted?

Writing code quickly - Use a framework!
Writing code quickly - Use a framework!
- Training loop?
Writing code quickly - Use a framework!
- Training loop?
Writing code quickly - Use a framework!
- Tensorboard logging?
- Model checkpointing?
- Complex data processing, with smart batching?
- Computing span representations?
- Bi-directional attention matrices?

- Easily thousands of lines of code!

Writing code quickly - Use a framework!
- Don’t start from scratch! Use someone else’s components.
Writing code quickly - Use a framework!
- But...
Writing code quickly - Use a framework!
- But...

- Make sure you can bypass the abstractions when you need to
Writing code quickly - Get a good starting place
Writing code quickly - Get a good starting place
- First step: get a baseline running

- This is good research practice, too

Writing code quickly - Get a good starting place
- Could be someone else’s code... as long as you can read it
Writing code quickly - Get a good starting place
- Could be someone else’s code... as long as you can read it
Writing code quickly - Get a good starting place
- Even better if this code already modularizes what you want to
change

Add ELMo / BERT here

Writing code quickly - Get a good starting place

- Re-implementing a SOTA baseline is incredibly helpful for

understanding what’s going on, and where some decisions might
have been made better
Writing code quickly - Copy first, refactor later
- CS degree:
Writing code quickly - Copy first, refactor later
- CS degree:
Writing code quickly - Copy first, refactor later
- CS degree:

We’re prototyping! Just go fast and find

something that works, then go back and
refactor (if you made something useful)
Writing code quickly - Copy first, refactor later
- Really bad idea: using inheritance to share code for related models

- Instead: just copy the code, figure out how to share later, if it makes
sense
Writing code quickly - Do use good code style
- CS degree:
Writing code quickly - Do use good code style
- CS degree:
Writing code quickly - Do use good code style
Writing code quickly - Do use good code style
Writing code quickly - Do use good code style
Writing code quickly - Do use good code style
Meaningful names
Writing code quickly - Do use good code style

Shape comments on
tensors
Writing code quickly - Do use good code style

Comments describing
non-obvious logic
Writing code quickly - Do use good code style

Write code for people,

not machines
Writing code quickly - Minimal testing (but not no testing)
- CS degree:
Writing code quickly - Minimal testing (but not no testing)
- CS degree:
Writing code quickly - Minimal testing (but not no testing)
- A test that checks experimental behavior is a waste of time
Writing code quickly - Minimal testing (but not no testing)
- But, some parts of your code aren’t experimental
Writing code quickly - Minimal testing (but not no testing)
- And even experimental parts can have useful tests
Writing code quickly - Minimal testing (but not no testing)
- And even experimental parts can have useful tests

Makes sure data processing

works consistently, that tensor
operations run, gradients are
non-zero
Writing code quickly - Minimal testing (but not no testing)
- And even experimental parts can have useful tests
Run on small test fixtures, so debugging
cycle is seconds, not minutes
Writing code quickly - How much to hard-code?
- Which one should I do?
Writing code quickly - How much to hard-code?
- Which one should I do?
I’m just prototyping! Why
shouldn’t I just hard-code an
embedding layer?
Writing code quickly - How much to hard-code?
- Which one should I do?

Why so abstract?
Writing code quickly - How much to hard-code?
- Which one should I do?

On the parts that aren’t what

you’re focusing on, you start
simple. Later add ELMo, etc.,
without rewriting your code.
Writing code quickly - How much to hard-code?
- Which one should I do?

This also makes controlled

experiments easier (both for you and
for people who come after you).
Writing code quickly - How much to hard-code?
- Which one should I do?

And it helps you think more clearly

about the pieces of your model.
Main goals during prototyping

- Write code quickly

- Run experiments, keep track of what you tried

- Analyze model behavior - did it do what you wanted?

Running experiments - Keep track of what you ran
- You run a lot of stuff when you’re prototyping, it can be hard to keep
track of what happened when, and with what code
Running experiments - Keep track of what you ran
Running experiments - Keep track of what you ran
This is important!
Running experiments - Keep track of what you ran

- Currently in invite-only alpha; public beta coming soon

- https://github.com/allenai/beaker
- https://beaker-pub.allenai.org
Running experiments - Keep track of what you ran
Running experiments - Keep track of what you ran
Running experiments - Keep track of what you ran
Running experiments - Controlled experiments
- Which one gives more understanding?
Running experiments - Controlled experiments
- Which one gives more understanding?

Important for putting your work in

context
Running experiments - Controlled experiments
- Which one gives more understanding?

But… too many moving parts, hard

to know what caused the difference
Running experiments - Controlled experiments
- Which one gives more understanding?

Very controlled experiments,

varying one thing: we can make
causal claims
Running experiments - Controlled experiments
- Which one gives more understanding?

How do you set up your code for

this?
Running experiments - Controlled experiments
Running experiments - Controlled experiments

Possible ablations
Running experiments - Controlled experiments

GloVe vs. character CNN vs.

ELMo vs. BERT
Running experiments - Controlled experiments

LSTM vs. Transformer vs.

GatedCNN vs. QRNN
Running experiments - Controlled experiments
- Not good: modifying code to run different variants; hard to keep
track of what you ran
- Better: configuration files, or separate scripts, or something
Main goals during prototyping

- Write code quickly

- Run experiments, keep track of what you tried

- Analyze model behavior - did it do what you wanted?

Analyze results - Tensorboard
- Crucial tool for understanding model behavior during training
- There is no better visualizer. If you don’t use this, start now.
Analyze results - Tensorboard
- Crucial tool for understanding model behavior during training
- There is no better visualizer. If you don’t use this, start now.

A good training loop will give you

this for free, for any model.
Analyze results - Tensorboard
● Metrics
○ Loss
○ Accuracy etc.
● Gradients
○ Mean values
○ Std values
○ Actual update values
● Parameters
○ Mean values
○ Std values
● Activations
○ Log problematic activations
Analyze results - Tensorboard

Tensorboard will find

optimisation bugs for
you for free.

Here, the gradient for

the embedding is 2
orders of magnitude
different from the rest
of the gradients.
Analyze results - Tensorboard

Tensorboard will find

optimisation bugs for
you for free.

Here, the gradient for

the embedding is 2
orders of magnitude
different from the Can
restanyone guess why?
of the gradients.
Analyze results - Tensorboard
Embeddings have
Tensorboard willsparse
find
gradients (only some
optimisation
embeddings bugs for but
are updated),
you for free.
the momentum coefficients
from ADAM are calculated for
the whole embedding every Solution:
Here, thetime.
gradient for
the embedding is 2
orders of magnitude
different from the rest
of the gradients. (uses sparse accumulators for
gradient moments)
Analyze results - Look at your data!
- Good:
Analyze results - Look at your data!
- Better:
Analyze results - Look at your data!
- Better:
Analyze results - Look at your data!
- Best:
Analyze results - Look at your data!
- Best:

How do you design

your code for this?
Analyze results - Look at your data!
- Best:

How do you design

your code for this?

Well say more later, but the key points are:

- Separate data processing that also works on JSON
- Model needs to run without labels / computing loss
Key point during
prototyping:
The components that
you use matter. A lot.
We’ll give specific
thoughts on designing
components after the
break
Developing Good
Processes
Source Control
We Hope You're Already Using
Source Control!

makes it easy to safely experiment with

code changes

○ if things go wrong, just revert!

We Hope You're Already Using Source Control!
● makes it easy to collaborate
We Hope You're Already Using Source Control!
● makes it easy to revisit older versions of your code
We Hope You're Already Using Source Control!
● makes it easy to implement code reviews
That's right, code
reviews!
About Code Reviews
● code reviewers find mistakes
About Code Reviews
● code reviewers point out improvements
About Code Reviews
● code reviewers force you to make your code readable
About Code Reviews

and clear, readable code

allows your code reviews to
be discussions of your
modeling decisions
About Code Reviews
● code reviewers can be your scapegoat when it turns out your results
are wrong because of a bug
Continuous Integration

(+ Build Automation)
Continuous Integration (+ Build Automation)
Continuous Integration

always be merging (into a branch)

Build Automation

always be running your tests (+ other checks)

(this means you have to write tests)

Example: Typical AllenNLP PR
if you're not building a
library that lots of
other people rely on,
you probably don't
need all these steps
but you do need some
of them
Testing Your Code
What do we mean by "test your
code"?
Write Unit Tests

a unit test is an
automated
check that a
small part of
your code
works correctly
What should I test?
If You're Prototyping,
Test the Basics
Prototyping? Test the Basics
Prototyping? Test the Basics
If You're Writing
Reusable Components,
Test Everything
Test Everything

test your model can train,

save, and load
Test Everything

test that it's computing /

backpropagating gradients
Test Everything

but how?
Use Test Fixtures
create tiny datasets that look
like the real thing
Use Test Fixtures
use them to create tiny
pretrained models

It’s ok if the weights are

essentially random. We’re
not testing that the model is
any good.
Use Test Fixtures
● write unit tests that use them to run your data pipelines and models
○ detect logic errors
○ detect malformed outputs
○ detect incorrect outputs
Use your knowledge to write clever tests

Attention is hard to
test because it relies
on parameters
Use your knowledge to write clever tests

Idea: Make the

parameters deterministic
so you can test
everything else
Pre-Break Summary
● Two Modes of Writing Research Code
○ Difference between prototyping and building components
○ When should you transition?
○ Good ways to analyse results
● Developing Good Processes
○ How to write good tests
○ How to know what to test
○ Why you should do code reviews
BREAK
please fill out our survey:

will tweet out link to slides after talk

@ai2_allennlp
Reusable Components
What are the right abstractions
for NLP?
 The Right
Abstractions

● AllenNLP now
has more than
20 models in it
○ some simple
○ some complex
● Some
abstractions
have
consistently
proven useful
● (Some haven't)
Things That We Use A Lot

● training a model
● mapping words (or
characters, or labels) to
indexes
● summarizing a sequence of
tensors with a single tensor
Things That Require a Fair
Amount of Code
● training a model
● (some ways of) summarizing a
sequence of tensors with a single
tensor
● some neural network modules
Things That Have Many Variations
● turning a word (or a character, or a label) into a tensor
● summarizing a sequence of tensors with a single tensor
● transforming a sequence of tensors into a sequence of tensors
Things that reflect our higher-level thinking
● we'll have some inputs:
○ text, almost certainly
○ tags/labels, often
○ spans, sometimes
● we need some ways of embedding them as
tensors
○ one hot encoding
○ low-dimensional embeddings
● we need some ways of dealing with
sequences of tensors
○ sequence in -> sequence out (e.g. all outputs of an
LSTM)
○ sequence in -> tensor out (e.g. last output of an
LSTM)
Along the way, we need to worry
about some things that make
NLP tricky
Inputs are text, but neural models want tensors
Inputs are sequences of things
and order matters
Inputs can vary in length
Some sentences are short.

Whereas other sentences are so long that by the time you finish reading
them you've already forgotten what they started off talking about and
you have to go back and read them a second time in order to remember
the parts at the beginning.
Reusable Components
in AllenNLP
AllenNLP is built on
PyTorch
AllenNLP is built on PyTorch

and is inspired by the question

"what higher-level components
would help NLP researchers do
their research better + more
easily?"
AllenNLP is built on PyTorch

under the covers, every piece of

a model is a
and every number is part of a
AllenNLP is built on PyTorch

but we want you to be able to

reason at a higher level most of
the time
hence the higher level
concepts
the Model
Model.forward

● returns a dict [!]

● by convention, tensor is what the training loop will optimize
● but as a dict entry, is completely optional
○ which is good, since at inference / prediction time you don't have one
● can also return predictions, model internals, or any other outputs
you'd want in an output dataset or a demo
every NLP project needs a Vocabulary
a Vocabulary is built from Instances
an Instance is a collection of Fields
a Field contains a data element and knows how to turn it into a tensor
Many kinds of Fields
● TextField: represents a sentence, or a paragraph, or a question, or ...
● LabelField: represents a single label (e.g. "entailment" or "sentiment")
● SequenceLabelField: represents the labels for a sequence (e.g.
part-of-speech tags)
● SpanField: represents a span (start, end)
● IndexField: represents a single integer index
● ListField[T]: for repeated fields
● MetadataField: represents anything (but not tensorizable)
Example: an Instance for SNLI
Example: an Instance for SQuAD
What's a TokenIndexer?
● how to represent text in our model is one of the fundamental
decisions in doing NLP
● many ways, but pretty much always want to turn text into indices
● many choices
○ sequence of unique s (or id for OOV) from a vocabulary
○ sequence of sequence of s
○ sequence of ids representing byte-pairs / word pieces
○ sequence of s
● might want to use several
● this is (deliberately) independent of the choice about how to embed
these as tensors
And don't forget
● "given a path [usually but not necessarily to a file], produce
s"
● decouples your modeling code from your data-on-disk format
● two pieces:
○ : creates an instance from named inputs ("passage", "question",
"label", etc..)
○ : parses data from a file and (typically) hands it to
● new dataset -> create a new DatasetReader (not too much code),
but keep the model as-is
● same dataset, new model -> just re-use the DatasetReader
● default is to read all instances into memory, but base class handles
laziness if you want it
Library also handles batching, via
● just shuffles (optionally)
and produces fixed-size batches
● groups together
instances with similar "length" to
minimize padding
● (Correctly padding and sorting instances
that contain a variety of fields is slightly
tricky; a lot of the API here is designed
around getting this right)
● Maybe someday we'll have a working
that creates variable
GPU-sized batches
Tokenizer
● Single abstraction for both word-level
and character-level tokenization
● Possibly this wasn't the right decision!
● Pros:
○ easy to switch between words-as-tokens
and characters-as-tokens in the same
model
● Cons:
○ non-standard names + extra complexity
○ doesn’t seem to get used this way at all
back to the Model
Model is a subclass of torch.nn.Module
● so if you give it members that are s or are
themselves s, all the optimization will just work*
● for reasons we'll see in a bit, we'll also inject any model component
that we might want to configure
● and AllenNLP provides NLP / deep-learning abstractions that allow
us not to reinvent the wheel

*usually on the first try it won't "just work", but usually that's your fault not PyTorch's
TokenEmbedder
● turns ids (the outputs of your TokenIndexers) into tensors
● many options:
○ learned word embeddings
○ pretrained word embeddings
○ contextual embeddings (e.g. ELMo)
○ character embeddings + Seq2VecEncoder
Seq2VecEncoder

● bag of words
● (last output of) LSTM
● CNN + pooling
Seq2SeqEncoder

● LSTM (and friends)

● self-attention
● do-nothing
Wait, Two Different Abstractions for RNNs?
● Conceptually, RNN-for-Seq2Seq is
different from RNN-for-Seq2Vec
● In particular, the class of possible
replacements for the former is
different from the class of
replacements for the latter
● That is, "RNN" is not the right
abstraction for NLP!
Attention

● dot product (xTy)

● bilinear (xTWy)
● linear ([x;y;x*y;...]Tw)
MatrixAttention

● dot product (xTy)

● bilinear (xTWy)
● linear ([x;y;x*y;...]Tw)
Attention and MatrixAttention
● These look similar - you could imagine sharing the similarity
computation code
● We did this at first - code sharing, yay!
● But it was very memory inefficient - code sharing isn’t always a good
idea
● You could also imagine having a single Attention abstraction that
also works for attention matrices
● But then you have a muddied and confusing input/output spec
● So, again, more duplicated (or at least very similar) code, but in this
case that’s probably the right decision, especially for efficiency
SpanExtractor

● Many modern NLP models use representations of spans of text

○ Used by the Constituency Parser and the Co-reference model in AllenNLP
○ We generalised this after needing it again to implement the Constituency Parser.
● Lots of ways to represent a span:
○ Difference of endpoints
○ Concatenation of endpoints (etc)
○ Attention over intermediate words
This seems like a lot of abstractions!
● But in most cases it's pretty simple:
○ create a DatasetReader that generates the Instances you want
■ (if you're using a standard dataset, likely one already exists)
○ create a Model that turns Instances into predictions and a loss
■ use off-the-shelf components => can often write little code
○ create a JSON config and use the AllenNLP training code
○ (and also often a Predictor, coming up next)
● We'll go through a detailed example at the end of the tutorial
● And you can write as much PyTorch as you want when the built-in
components don't do what you need
Abstractions just to
make your life nicer
Declarative syntax

most AllenNLP objects can be

instantiated from Jsonnet blobs
Declarative syntax
● allows us to specify an entire experiment using JSON
● allows us to change architectures without changing code
Declarative syntax
How does it work?

● Registrable
○ retrieve a class by its name
● FromParams
○ instantiate a class instance
from JSON
Registrable
● so now, given a model "type"
(specified in the JSON config),
we can programmatically
retrieve the class
● remaining problem: how do we
programmatically call the
constructor?

returns the class itself

Model config, again
from_params, originally

● have to write all the parameters twice

● better make sure you use the same
default values in both places!
● tedious + error-prone
● the way from_params works should (in
most cases) be obvious from the
constructor
from_params, now
from_params, now
Trainer
● configurable training loop with tons of options
○ your favorite PyTorch optimizer
○ early stopping
○ many logging options
○ many serialization options
○ learning rate schedulers
● (almost all of them optional)
● as always, configuration happens in your JSON
experiment config
Model archives
● training loop produces a model.tar.gz
○ config.json + vocabulary + trained model weights
● can be used with command line tools to evaluate on test datasets or
to make predictions
● can be used to power an interactive demo
Making
Predictions
Predictor
● models are tensor-in,
tensor-out
● for creating a web demo, want
JSON-in, JSON-out
● same for making predictions
interactively
● Predictor is just a simple JSON
wrapper for your model

and this is enabled by all

of our models taking
optional labels and this is (partly) why we split
returning an optional loss out text_to_instance as its
and also various model own function in the
internals and interesting dataset reader
results
 Serving a demo
With this setup, serving a demo is easy.

○ DatasetReader gives us
○ Labels are optional in the model and
dataset reader
○ Model returns an arbitrary dict, so can get
and visualize model internals
○ Predictor wraps it all in JSON
○ Archive lets us load a pre-trained model in
a server
○ Even better: pre-built UI components
(using React) to visualize standard pieces
of a model, like attentions, or span labels
We don't have it all figured out!
still figuring out some abstractions that we may
not have correct

● regularization and initialization

● models with pretrained components
● more complex training loops
○ e.g. multi-task learning
● Caching preprocessed data
● Expanding vocabulary / embeddings at test time
● Discoverability of config options

you can do all these things, but almost

certainly not in the most optimal /
generalizable way
Case study
 "an LSTM for
part-of-speech
tagging"
(based on the official PyTorch tutorial)
The Problem
Given a training dataset that looks like

learn to predict part-of-speech tags

With a Few Enhancements to Make Things More Realistic

● read data from files

● check performance on a separate validation dataset
● use to track training progress
● implement early stopping based on validation loss
● track accuracy as we're training
Start With a Simple Baseline Model
● compute a vector embedding for each word
● feed the sequence of embeddings into an LSTM
● feed the hidden states into a feed-forward layer to produce a
sequence of logits The dog ate the apple

embedding

vThe vdog vate vthe vapple word vectors

LSTM
wdo
wThe wate wthe wapple encodings
g

Linear

LThe Ldog Late Lthe Lapple tag logits

v0: numpy

aka "this is why we use libraries"

v0: numpy (aka "this is why we use libraries")
v1: PyTorch
v1: PyTorch - Load Data

seems reasonable
v1: PyTorch - Define Model

much nicer than writing

our own LSTM!
 this part is maybe less

v1: PyTorch - Train Model than ideal

v2: AllenNLP

(but without config files)

v2: AllenNLP - Dataset Reader
v2: AllenNLP - Model
v2: AllenNLP - Training

this is where the

config-driven
approach would
make our lives a
lot easier
v3: AllenNLP + config
v3: AllenNLP - config
Augmenting the
Tagger with
Character-Level
Features
v1: PyTorch
add char_embedding_dim

add char_embedding layer =

embedding + LSTM?

change LSTM input dim

compute char
embeddings
concatenate inputs

we really have to change our model code and how it works

v1: PyTorch

I'm not really

that thrilled to
do this exercise
 no

v2: AllenNLP changes

add a second
token indexer
to the
model
itself!
add an extra
parameter

add a
character
embedder

use the
character
embedder
v3: AllenNLP - config

we can accomplish
this with just a
couple of minimal
config changes
v3: AllenNLP - config

add a couple of new Jsonnet variables

v3: AllenNLP - config

add a second token indexer

v3: AllenNLP - config

add a corresponding token

embedder
For a one-time change this is
maybe not such a big win.
But being able to experiment
with lots of architectures
without having to change any
code (and with a reproducible
JSON description of each
experiment) is a huge boon to
research! (we think)
Sharing Your Research

How to make it easy to release

your code
In the least amount of time possible:

Simplify your workflow Make your code run Isolated environments

for installation and data anywhere* for your project
Docker
Objective: You don’t feel like this about Docker
What does Docker Do?
● Creates a virtual machine that will always
run the same anywhere (In theory)

● Allows you to package up a virtual

machine and some code and send it to
someone, knowing the same thing will run

● Includes operating systems,

dependencies for your code, your code
etc.

● Let’s you specify in a series of steps how

to create this virtual machine and does
clever caching when you change it.
3 Ideas: Dockerfiles, Images and Containers
Step 1: Write a Dockerfile

Here is a finished
Dockerfile.

How does this work?

Step 1: Write a Dockerfile
Step 1: Write a Dockerfile

Dockerfile commands are

capitalised. Some
important ones are:
Step 1: Write a Dockerfile

FROM includes another

Dockerfile in your one.
Here we start from a base
Python Dockerfile.
Step 1: Write a Dockerfile

RUN … runs a command.

To use a command, it must
be installed in a previous
step!
Step 1: Write a Dockerfile

ENV sets an environment

variable which can be used
inside the container.
Step 1: Write a Dockerfile

COPY copies code from

your current folder into the
Docker image.
Step 1: Write a Dockerfile

Do yourself a favour.
Don’t change the names
of things during this
step.
Step 1: Write a Dockerfile

CMD is what gets run

when you run a built
image.
Step 1: Write a Dockerfile

Here is a finished
Dockerfile.
Step 2: Build your Dockerfile into an Image
Step 2: Build your Dockerfile into an Image

This is what you want the

image to be called, e.g
Step 2: Build your Dockerfile into an Image

You can see what images

you have built already by
running
Step 2: Build your Dockerfile into an Image

This describes where

docker should look for a
Dockerfile. It can also be a
URL.
Step 2: Build your Dockerfile into an Image

If you’ve already built a line of

your dockerfile before,
Docker will remember and
not build it again (so long as
things before it haven’t
changed.)
Step 2: Build your Dockerfile into an Image

TIP: Put things that change

more frequently (like your
code) lower down in your
Dockerfile.
Step 3: Run your Image as a Container
Step 3: Run your Image as a Container
Step 3: Run your Image as a Container

These arguments will give you a

command prompt inside any docker
container, regardless of the CMD in
the Dockerfile.
Optional Step 4: DockerHub

DockerHub is to Docker as Github is to Git

Docker automatically looks at dockerhub to

find Docker images to run
Pros of Docker
● Good for running CI - ALL your code
dependencies are pinned, even system
level stuff.

● Good for debugging people’s problems

with your code - just ask: Can you
reproduce bug that in a Docker Container

● Great for deploying demos where you just

need a model to run as a service.
Cons of Docker
● Docker is designed for production
systems - it is very hard to debug inside a
minimal docker container

● Takes up a lot of memory if you have a lot

of large dependencies (e.g the JVM
makes up about half of the AllenNLP
Docker image)

● Just because your code is exactly

reproducible doesn’t mean that it’s any
good
Releasing your data
Use a simple file cache

There are currently 27

CoreNLP Jar files you
could download from the
CoreNLP website
Use a simple file cache
Use a simple file cache

But now I have to

write a file cache ....
Use a simple file cache

Copy this file into

your project
Isolated (Python) environments
Python environments

Stable environments
for Python can be
tricky

This makes releasing

code very annoying
 Python environments

Docker is ideal, but not great for

developing locally. For this, you
should either use virtualenvs or
anaconda.

Here we will talk about anaconda,

because it’s what we use.
Python environments

Anaconda is a very stable

distribution of Python (amongst
other things). Installing it is easy:

https://www.anaconda.com/
 Python environments

One annoying install step - adding

where you installed it to the front
of your PATH environment
variable.
Python environments

Now, your default should

be an anaconda one (you did
install python > 3.6, didn’t you).
 Virtual environments

Every time you start a new project,

make a new virtual environment
which has only its dependencies
in.
Virtual environments

Before you work on your project,

run this command. This prepends
the location of this particular copy
of Python to your PATH.
 Virtual environments

When you’re done, or you want to

work on a different project, run:
In Conclusion
In Conclusion
● Prototype fast (but still safely)
● Write production code safely (but still fast)
● Good processes => good science
● Use the right abstractions
● Check out AllenNLP
 Thanks for Coming!

Questions?

please fill out our survey:

will tweet out link to slides after talk

@ai2_allennlp