General Sequence Learning using Recurrent Neural Networks


Hi everyone, this is Alec and I’m going to
be talking to you today about using recurrent neural networks for text analysis.
To get an understanding of why this is a potential tool to use, it’s good to look at a bit of
a history of how text analysis has been done, particularly from a machine learning perspective.
So in machine learning typically we’re used to vector representation so we know how to
deal with numbers. For categories we would use a one HOT vectorization
model. But when we move to trying to understand and
classify and regress sequences for instance, it becomes much less clear because our tools
are typically based on vector approaches. The way this is typically dealt with is by
computing some hard coded feature transformations, for instance, using TFIDF vectorizers, some
sort of compression model like LSA and then plugging a linear model, such as support vector
machine or a softmax classifier, on top of that.
The purpose of this talk today is what happens if we cut out those techniques and instead
replace them with an RNN. To get an understanding of why this might
be an advantage, structure is hard. Ngrams are the typical way of preserving some
structure. This would be we take our sentence, for instance,
‘the cat sat on the mat’, and we re-represent it as the occurrence of any individual word
or combinations of words. These combinations of words begin to get us
the way to see a little bit of structure. By ‘structure’ I mean preserving the ordering
of words. The problem with this is once we have bigrams
or trigrams any combination of two or three words quickly becomes huge possibilities.
You can have easily 10 million plus features and this begins to get cumbersome, require
lots of memory and slows things down in and of itself.
Structure, although it’s difficult, is also very important.
For certain tasks such as humor or sarcasm, looking at a collection of the word ‘cat’
appeared or the word ‘dog’ appeared isn’t going to cut it.
And that’s what a lot of our models today do.
To understand though why many models today are based on this and do quite successful,
ngrams can get you a long way from any task. Specific words are often very strong indicators:
‘useless’ in the case of negative sentiment and ‘fantastic’ in the case of positive
sentiment. If you’re, for instance, trying to classify
whether a document is about the stock market or is a recipe…you don’t see the word
‘green tea’ come up very much in a stock market conversation and you don’t see the
word ‘NASDAQ’ come up very much in a recipe. You can quickly separate things in those kinds
of tasks. It’s often a question of knowing what’s
right for your task at hand. If you’re trying to get at a more qualitative
understanding of what’s going on in a body of text this is where structure may be very
important. Whereas if you’re just trying to separate
out something that may be very indicative on a word level, then in many ways a bag of
words model can be quite strong. How an R&N works.
To understand its potential advantages over a bag of words model what an RNN does is it
reads through a sequence iteratively which is really nice because it’s how people do
it as well. It’s able to preserve some of the structure
of the model. It goes through each word and updates its
hidden representation based on that word and the input from the previous hidden state.
At time zero where we have no previous hidden state we feed in either a bunch of zeroes
or we treat it as another parameter to be learned in [INAUDIBLE] representation.
It just continues to do this all the way through the sequence.
At each time step we have a 512, in this case we had 512 hidden units, dimensional vector
representation of our sequence. It’s a way of taking the sequence of words
and using time step converting it into fixed length representation.
As a bit of notation, arrows would be projections dot products and boxes would represent activities. Vector is the values.
For instance, the activation of each hidden unit would be this box.
It just proceeds iteratively through. It’s important to note these projections
are largely shared across all time sequences. This projection with this arrow shared for
all inputs, across all time steps and this hidden to hidden unit connections are preserved
as well across the sequence. This is what makes learning tractable in these
models. At the end of iterating through the sequence
we’ve got now a learned representation of the sequence, a vector form of our sequence
which then can be used by slapping on a traditional classifier.
In this toy example what we’ve done is we’ve read in an input sentence.
For instance, we’re trying to teach the model how to classify the subject of a sentence.
You can also stack them. Just as your RNN can go through an input sequence
and return its internal representation of that sequence, you can then train another
RNN on top of it or you can jointly train both. The structure is actually quite flexible. One final note is the way that we do this
original input to hidden feed forward is this is typically represented either as a traditional
one HOT which really doesn’t get us too much advantage but what’s really exciting
is we can represent this as what’s called an ‘embedding matrix’. These words, ‘the cat sat on the mat’,
would be represented as indexes into a matrix. ‘The’ would be represented as index 100. When we read through the sequence we would
look up the row, row 100, and we would return as the input being fed into the RNN the learned
representation in that embedding matrix. Let’s say we had 128 dimensions to be learned
as an input representation for our words. It would be equivalent to 128 by let’s say,
10,000 matrix if we do 10,000 words. We would then feed this in as input. That’s really cool because we can treat
it as a learned w ay to learn representations of our words. We’ll look later in this presentation at what
those actually look like. They give the model a lot of power. The big thing in the literature is RNNs have
a reputation for being very difficult to learn. They are often known to be unstable in simple
art in strange with generic stochastic gradients are actually very unstable and difficult to
learn. What has happened in the research literature
over the last few years is there are a bunch of tricks that have been developed that help
them be much more stable, much more powerful and much more reliable, effectively. To get an understanding of these we’re going
to go quickly through all these various tricks. The first of these is gating units. To understand what a gating unit is we first
need to look a little bit more into detail how a simple RNN works. What happens is we have our hidden state from
our previous time step. Again, at the original time step this can
just be zeroes or parameters and we receive input at time step T. We take input from the hidden state of h of
T minus one and we take input of T. We just add them together for instance via
a dot product projection and then we apply an element wise activation function like [INAUDIBLE]
for instance. Then we have a new hidden state. At the next time step we receive more input,
we add it together and apply another element wise activation function and this process
continues forward. To understand what the problem that can be
with this, is information is always being updated at each time step. As a result it becomes difficult for information
to persist through a model like this. You can think of this as a form of exponential
decay. If we have a value let’s say here, of one
and through this process we effectively end up multiplying that value by a reasonable
.05 what happens after the course of several time steps is that value will exponentially
decay for instance, to zero. Information has difficulty spreading through
a structure like this. There have been various changes called ‘gating
units’ to make this work better. What a gating unit does is instead of having
the hidden state at a new time step be a direct operation of the previous time step, it adds
in a variety of gating units that effectively transform the information in a more structured
way. One of these is called the ‘gated recurrent
unit’ introduced recently. What it does is it uses two types of gates. It uses a reset gate and a dynamics gate. This is the reset gate and this is the dynamics
gate. What the reset gate does is it takes an input
from a previous time step, both the hidden representation and the input, and it computes
a…there should be element wise sigmoid squash in here, and what it does is it basically
computes how much of the previous time steps’ information should continue along this route. A reset value could be anywhere between zero
and one and what it does is it multiplies the previous hidden states by those reset
states. What this does is it allows a model to adaptively
forget information. For instance, you can imagine for sentiment
analysis that some of our information might be only relevant on the sentence level and
once you see a period your model can then clear some of its information because it knows
the sentence is over and then be able to use it again. Once we have the previous times states information
effectively gated by a reset gate, we then update and get our potential new hidden state,
h~t. What we then do is we use the dynamics gate
to instead of just using h~t as would be a somewhat similar model to the previous example,
we average it effectively with the previous hidden state based on the dynamics gate. We take the output of h~t, multiply it by
Z again is like our computes values between and one for each unit and we multiply it and
add together. This effectively [INAUDIBLE] If ‘Z’ is zero what it would do is it
would take entirely the new updated h~t and none of the previous hidden state. This would be equivalent in many ways to our
previous simple recurrent unit. In that case we would just have the new value
come through. Sure it would be gated by the recurrent unit
but again the new hidden state would be a completely new update compared to the previous
hidden state. Whereas if Z is one and this value here is
one and this value here is zero so then our new hidden state is just a copy effectively
of the previous hidden state. Z values of near one are ways of effectively
propagating information over longer steps of time. You can think of it as the easiest way to
remember something is just not to change it. A value can be spread over very long periods
of time if we just have Z values near one because that way we don’t have all this noise
of updating our hidden states. We just lock it and let that value persist. That’s a way to, for instance, on the sentence
level keep context from the previous sentence around if we had Z values that were locked
on. Again, like in our previous model, this can
be expanded to another time step just so you see how information flows. Again, there are all these calculations involved
in updating our hidden states and our gating values but the information at its core really
flows through this upper loop of gated values interacting with previous hidden states. Gating is essential. That was enough of an example of all the theoretical
reasons why these better designed gates might help propagate information better. But empirically it’s also very important. For sentiment analysis of longer sequence
of text, for instance, a paragraph or so, a few hundred words for instance, a simple
RNN has difficulty learning it all. You can see that it initially climbs downhill
a little bit but all it’s actually doing here is just predicting the average sentiment,
for instance, 0.5. Whereas a gated unit, a recurrent neural network,
is able to quickly learn and continuously learn. Again, you can’t use simple recurrent units
for these more complex tasks especially when you have longer sequences of 100 plus words
or tokens. They just don’t work well because information
is hard to keep over longer sequences of time in those kinds of models. Now that we’ve talked about gating there’s
another question which is what kind of gating do you use. There are two types of models that have been
proposed. Gated recurrent units by Cho, recently from
the University Montreal, which are used for machine translation and speech recognition
tasks. Then there’s also with the more traditional
long short term memory. This has been around much longer and has been
used in far more papers. Various modifications to the classic architecture
exist but for text analysis GRU seems to be quite nice in general. It seems to be simpler, faster and optimizes
quicker at least on the sentiment analysis dataset. Because it only has two gates compared to
LSTM’s four it’s also a little bit faster. If you have a larger dataset and you don’t
mind waiting a little bit longer, LSTM may be better in the long run especially with
larger datasets because it has additional complexity with more gates. But again it seems like GRU does quite well
in these kinds of problems generally. I tend to favor it myself but you can try
both. The library we’ll be introducing later in
this talk supports both. The next question is exploding gradients. Exploding gradients are a training dynamics
phenomena that happens in recurrent neural networks where the values that we’re trying
to update [INAUDIBLE] at each step of our training algorithm can become very large and
very unstable. This is one of the sources of the reputation
of RNNs being hard to train. Typically you would see small values, for
instance the norm of your gradient would be around one and just bouncing around and then
sometimes you’d see huge spikes. Those spikes can be quite damaging because
a traditional learning update would then rapidly change your values and this could result in
unstable oscillations and your whole model explodes. In 2012 there was a great paper that proposed
simply clipping the norm of the gradient. If the gradient exceeded a set value, for
instance 15, it would just be reset and scaled to that value. This was a common form of making RNNs much
more stable. Interestingly though, at least on text analysis
for sentiment, we don’t seem to see this problem with modern optimizers. It seems that the gradient decays pretty cleanly
and becomes quite stable over the course of learning. There’s another way of making recurrent neural
networks better and this is by using better gating functions. There was an interesting paper this year at
NIPS the basic idea of which was let’s make our gates steeper so they change more rapidly
from being a value of zero to a value of one. What this means is a traditional sigmoid would
change pretty smoothly between negative five and five. But when you randomly initialize one of these
numbers at the beginning of training typically your values wouldn’t lie along the average
0.5, for instance. You wouldn’t see much dynamics here. If we make our gate steeper what that means
is our gates begin to rapidly switch between zero and one much more easily, particularly
near the beginning of learning. What this seems to suggest is that models
that have used these steeper gating units tend to learn a bit faster because they begin
to learn how to use these gates quicker. This is another quick easy technique to add. Again, the library we’ll be introducing
later in this talk supports to help make learning better in these models. Another technique is orthogonal initialization. Andrew Saxe last year did some great work
on showing that initializing. When we begin training these models we don’t
know the values of these parameters to use in these dot products, for instance; the weight
matrices effectively. What the research literature typically does
is initialize [INAUDIBLE] for instance, random Gaussian or random uniform noise. What this research showed is that using random
orthogonal matrices worked much better. It’s in line with some previous other work
that has also noted various forms of similar initializations worked well for RNNs. Now we want to understand how we train these
models. There are a variety of techniques that can
be used. This is a visualization of the training dynamics
of various algorithms on toy datasets where we’re trying to classify these red dots
from these blue dots. We only have a linear model so all it can
do is learn effectively a line separating these two. It can’t do it perfectly because there’s always
going to be values separating this. What we see is that the traditional most basic
optimizer is stochastic gradient descent whereas there are these various other improvements
and techniques. The main point of this example is to demonstrate
to not use Sgd effectively. Sgd very early on in training can look quite
similar but once the norm of your gradients becomes slower due to later stages optimization
you want some sort of dynamicism to your learning algorithm whereas Sgd once it gets out of
the very steep earlier areas of learning tends to slow down. This is particularly a problem oftentimes
in the space of text analysis because we have very sparse updates on words, for instance. There are rare words that you only see once
every thousand or 100,000 words and those words are very difficult to learn in a traditional
Sgd framework. Whereas these various techniques like momentum
and [INAUDIBLE] accelerated gradient what they do is effectively average together multiple
updates and accumulate those averages. They’re a form of smoothing out this stochastic
noise and accelerating directions of continuous updates. There’s another family of acceleration methods;
the adafamily that effectively scale the learning rate, the amount by which we update a parameter
given a gradient by some dynamics, some heuristics describing the local gradient. In the case of adagrad what we do is we accumulate
the norm of the gradients update seen so far with respect to a parameter and we scale our
learning rate. It’s a form of learning rate where we can
see that early on it learns quite quickly and later on it begins to slow down as it
reaches in this case near [INAUDIBLE]. Adadelta an RMS prop do something a little
bit like that but make it dynamic. It’s based on the local history instead
of the global history of the gradients for a parameter. There are a variety of optimizers and one
recently introduced called ‘Adam’ combines the early optimization speed that we saw in
that earlier example of adagrad with the better later convergence of various other methods
like adadelta and RMS prop. This looks quite good for text analysis in
RNN. We can see that Adam gets off to a very early
learning start just like adagrad. These results…actually there’s a slight
bug in my code for this so take them with a grain of salt but they still look good and
it’s a bug in the code so it might still be okay. That might actually explain one of the reasons
why we saw slightly worse generalization performance. It would train quite well but we would see
its performance on held out data might not have been as good for Adam because it learned
so much more quickly. We’re still looking into reasons why this
happens but in general, modern optimizers are essential on these kinds of problems. This just gives you a background on all the
various techniques for making RNNs more efficient in training and it can add quite a lot. Early on in learning we can see that Adam
and all these other techniques added together so this would be a just a standard gating
RNN. Again, if we had a simple RNN on here it would
look pretty linear. If we add gradient clipping to make it more
stable so we can use a slightly larger learning rate it begins to learn faster. If we add orthogonal initialization we can
see again that it began to learn faster and learn better. Finally, if we had only Adam we see another
huge gain over traditional Sgd. These add up. We can see that Adam and all these other techniques
are able to reach lower effective minima and are at least faster. Up to 10x faster. Admittedly these techniques add a little bit
of computation time so it might only be for instance 7.5x faster on a wall clock compared
to efficiency per rate update. This is interesting because now RNNs can actually
overfit quite a lot. As they continue to fit to training data for
instance their test data might plateau. We continue to improve on the training dataset
we’re given but this is called ‘overfitting’ where our RNN is effectively optimizing for
the details of the training data that aren’t true of new data. To combat this one of the techniques that
is used is called ‘early stopping’ which is each iteration of our dataset we will record
the train and test validation training test scores of these models and we will stop once
we notice that our test validation performances are improving. Oftentimes this is going to occur in your
first or second iteration through the dataset with all these various techniques together. That’s good news because oftentimes models
in this space can take ten, 50 or 100 iterations for your training data to converge. It seems in the case of RNNs we often overfit
after one or two epics through the data. To understand and get a better sense of how
these models can do we’re going to compare them to a much more standard technique in
the literature. We’re going to use the Fantastic Machine
Learning Library, SKLearn, and we’re going to use a standard linear model approach, a
traditional approach to text analysis. This would be using at TFIDFI vectorizer and
a linear model such as logistic regression. This is by no means meant to be the best model. In many cases, naïve Bayes SVN is actually
better than [INAUDIBLE] regression for classification for instance, but this is just a very easily
accessible, very easily comparable to technique To be fair, we’re going to use bigrams which
is a way of getting a little bit of structure into our data. Again, this way we could see ‘not good’
instead of just seeing the tokens for ‘not’ and ‘good’ occurring. We can get a little bit of structure which
might be useful in sentiment analysis. We’re going to use grid search to evaluate
potential [INAUDIBLE] for these linear models. We’re going to look at two which is minimum
document frequency which is way of controlling for the size of our input to our linear model. This would take tokens or words that appear
less than, in less than and many documents and would ignore them. If we see, for instance, the word ‘dinosaur’
and we’ve only seen it once in our dataset we’re going to ignore it effectively. Also we’re going to look at the regulization
coefficient which is a way of preventing overfitting for the new models. What we’re doing is grid search so we’re
looking at potential values for both of these. We’re not just explaining a potential performance
improvement based on poorly fitted parameters. Because these linear models tend to be faster
we are able to more effectively search over potential parameters. This is a fair way to get the linear model
potential advantage because they’re much faster so we can much more quickly search through
multiple values. Our second model we’re going to be looking
at is one of these recurrent neural networks. Admittedly, this is our own personal research:
take every result with a grain of salt. I’m using whatever I’ve tried that worked. The general message though is that using a
modern optimizer such as Adam, a gated recurrent unit, steeper sigmoid gates and orthogonal
initialization are good defaults. A medium-size model that can work quite well
is a 256 dimensional embedding and a 512 dimensional hidden representation. Then we put on whatever output we need: logistic
regression for binary sentiment classification, linear regression for predicting real values,
etc. It’s quite flexible because the RNN in its
core is a way of taking these sequences of values and converting them into a vector. Once we’ve got that vector we can put whatever
traditional model we want on top of it so long as it’s differential and open to gradient
based training. How does this work on datasets? What we see quickly here is that our linear
regression model does incredibly well for smaller datasets. When we have for instance only 1,000 or 10,000
training examples we see that the linear model outperforms the RNN by 50%, for instance. But what we notice that’s interesting as
our datasets get bigger the RNN tends to scale better until till later training into larger
dataset sizes. Because the RNN is admittedly a much more
complex model and operates on the sequences themselves ideally with more training data
it can learn a much better way to do the task at hand. Whereas your linear model because it’s operating
on unstructured bag of words and is just a linear model might eventually hit a wall where
it’s not able to do any better. You can imagine certain situations that you
just aren’t going to be able to classify the sentiment, positiveness or negativeness of
a text when it uses double negation, for instance. That’s one example with sentiment analysis. What’s also interesting is we see this replicated
for instance for predicting the helpfulness of a customer review. This is interesting because this is a much
more qualitative thing. Sentiment is as well but how helpful a user’s
review of a product is even more getting a much more abstract concept. We see again that as before with small amounts
of data the linear model, in this case reg since we’re predicting real values, does much
better but it doesn’t seem to scale and make use of more data as effectively as an RNN. This is interesting. We can see that RNNs seem to have poor generalization
properties with small amounts of data but they seem to be doing better when we have
large amounts of data. At one million labeled examples we can often
be between zero and 30% better than the equivalent linear model. Again these are just these examples with logistic
regression and linear regression but that crossover seems to be robust and somewhere
between 100,000 and a million examples but it is dependent on the dataset. There’s only one unfortunate caveat to this
approach which is it’s quite slow. For a million paragraph size text examples
to converge that linear model takes about 30 minutes on a single CPU core. For an RNN if we use a high-powered graphics
card such as the GTX 980 it takes about two hours. That’s not too bad. Our RNN on a proper high-end graphics card
is only about four times slower at a million examples to converge than the linear model. Again this is on a basic CPU core. But if we train our RNN on just that CPU core
it takes five days. This is unfortunate because this means our
RNN is about 250 times slower than a CPU and that’s just not going to cut it. This effectively is why we use GPUs in this
research. Here’s the cool part of the presentation. Again, an RNN when it’s being fed an input
sequence takes in the sequence and effectively learns a representation for each word. Each word gets replaced from its identifier
some value like ‘the’ is token 100 and gets replaced with a vector representation
that is learned by our model. These visualizations we’ll be showing you
are what happen when you look at what representations are learned by those models. What we’re going to do is use an algorithm
called ‘TSNE’ to visualize these embeddings that our RNN learns. What we’ve done to make it a little clearer
is this is the representations learned from training on only binary sentiment analysis. We’re trying to predict whether a given
customer review, for instance, likes a product or doesn’t like a product. What we’ve done is we’ve visualized these
representations in two dimensions using TSNE and we’ve colored each word by the average
sentiment of a review it appears in. What we see is a kind of axis. Again, it doesn’t correspond to any actual
axis aligned because it’s TSNE. But we see this continuum between very negative
words and very positive words. This isn’t too surprising. A model trained on sentiment analysis learns
to separate out negative and positive words. That’s what you’d expect to happen. We can take a little look at these very positive
and very negative clusters and see that it’s grouped into very understandable words like
‘useless, waste, poorly, disappointed’ as negative. You can see some interesting stuff where again
this visualization tries to group similar things close together. We can see that it’s actually identified
even though it is a very negative grouping, it’s also identified ‘returned, returning,
returns, return’ all together as well. That’s interesting because it seems to know
that ‘returned’ and return related words are very negative unsurprisingly if you find
them in a review. But it’s also separated them out slightly
from other more generic words. Then on the positive side we also see very
unsurprising indicators of happy if sentiments. So ‘fantastic, wonderful, and pleased’. But what’s even more interesting about this
model is that we see other forms of grouping and structure being learned. We see that it pulls out for instance, quantities
of time; weeks, months, hours, minutes. We also see that it pulls out qualifiers like
‘really, absolutely, extremely, totally’. Again, qualifiers are interesting because
they are by themselves neutral. They don’t necessarily indicate positive or
negative sentiment; instead they modify it. You can have ‘extremely good’ and ‘extremely
bad’. You see that being pulled out together. You also see product nouns, for instance things
that products could be, things that are products like movies, books, stories, items, devices
are also grouped together. Additionally, punctuation is grouped together. This is indicative potentially of our model
learning to use these kinds of data which again implies that our model may actually
be learning to use some of the structure present in the data. Punctuation by grouping it together and learning
similar representations for it imply that it’s finding some use for it. We would expect again punctuation to be quite
useful for segmenting out and separating out meanings and notions. Quantities of time are interesting. They are slightly negatively associated which
is understandable when you talk about, ‘this product took months to show up’ or, ‘it
worked for a total of an hour’. Again, grouping them all together implies
some use of it and the same thing with qualifiers. We have no true evidence at least in this
picture of these words being used but by learning similar representations and by having them
grouped together it implies it’s finding a use for them. We can extrapolate from there that it may
in fact be learning to use these words in natural ways for sentiment analysis. Again, this is learned purely from zero and
one binary indicator variables. This is a bit like seeing a sequence of numbers,
1,000, 2,000, 3046, five and then realizing that tokens five and one thousand are exclamation
point and period. They’re similar to tokens 2,000 and 7,000
which are comma and colon. This is a very strong result and very interesting
to see this kind of similarity being learned by our model. This is cool but how can we actually use these
models? We’re also presenting today a basic library
to allow developers to use these recurrent neural networks for text analysis. It’s called Passage and it’s a tiny library
built on top of the great Theano machine learning for framework [INAUDIBLE] math library. It’s incredibly alpha; we’re working on it
but it has a variety of features. We’re going to walk through now an example
of how to use Passage. This is Passage. It’s clonable via GitHub and it has a variety
of tools to make this useful. This is a little example we’re going to walk
through and explain real quickly on how we can use Passage to do analysis of text. We need to import the components that are
necessary. One of these is the tokenizer which is a way
of taking strings of text and separating them out into the individual tokens which would
be words and punctuation, for instance. A tokenizer can just be instantiated. It has a variety of parameters but has sensible
defaults. What we do is we emulate a SKLearn style interface. We can call fit transform on a body of training
text which would be again a list of strings for instance and that would return a list
of these training tokens which can be used natively by Passage to train RNN models. Additionally, we’re going to import the various
layers of a model. We have that embedding matrix we talked about,
the gated recurrent unit, and a dense output classifier. The way that we compose these into a training
model is by stacking them together in a list. Our input is one of these embedding matrices
and we’re going to set it to have 128 dimensions. We need to know how many of these features
to learn, how many of these tokens there are, and we’re going to just pull that out of how
many our tokenizer decided we needed. Then we’re going to use one of these gated
recurrent layers where in this case setting its size to 128. The sizes are sometimes smaller than you would
use for actual models and you can see better performance from larger models, for instance,
but these are small enough to be run on a CPU and not take forever. They’ll still take quite a while though. Finally, we have our dense output unit which
would be if we were doing binary sentiment classifications, detecting if it’s negative
or positive for a string of text, would be one unit because we’d be predicting one
value. We would use a sigmoid activation as a way
of quickly separating out negative and positive values. Then to make this model we instantiate it
through the model class which is just importable from Passage dot models RNN. We give it the layers we want to build our
custom architecture out of and we tell it what cost function we want to optimize. The cost function is the effective function
that lets us train this model. It’s just a way of telling the model how good
was this, how good did you do on this example, effectively. For binary classification we use binary [INAUDIBLE]
in this example. To train this model we just call a fit interface
which takes in training tokens which are made from training text and also takes in the training
labels we want to predict given those training texts. Then once that model has been trained…It
should be noted this only transfers one iteration through your dataset. As mentioned earlier, you may want to train
for multiple iterations if for instance your model hasn’t converged and you may want
to measure your performance on hold out data to know when to stop training a model if it
begins to overfit. Right now we’ve left that part to you but
we will be extending this to have interfaces to automatically do this. Finally, if you want to have your model then
predict on new data you can just call model dot predict on tokenizer dot transform or
test text and this will return how the model predicts new data. That’s an example of how to use Passage. To summarize, RNNs are now a potentially competitive
tool in certain situations for text analysis. Admittedly there are a lot of disclaimers
there but there seems to be a general trend that seems to be emerging which is if you
have a large, for instance, million-plus example dataset and you have a GPU they can look quite
good. They potentially can outperform linear models
and might not take all that much longer. But if you have a smaller dataset and don’t
have a GPU it can be very difficult to justify despite how cool these models might seem compared
to linear models. They are a lot slower, they have a lot of
complexity, a lot of different parts and a lot of different architectures you can change
and they seem to have poor generalization results with small datasets. Thanks for listening. If you have any questions you can let me know
at Alec at Indico dot I-O. Also if you’d like to see a more general introduction
to machine learning and deep learning in Python I have another video that you can check out
in the upper right, introducing that as a Python developer, how to use the awesome Theano
library to implement these algorithms yourself. Additionally if you’d like to check out and
learn more about Indico feel free to visit our website at Indico dot I-O where we have
various tools like Passage available for developers to use for machine learning. Thanks.

Leave a Reply