
Dutch: 
Hello world! Siraj hier.
Als je maar een kleine hoeveelheid data hebt,
kun je er dan alsnog van leren?
We gaan een model bouwen dat afbeeldingen leert classificeren,
met gebruik van slechts een hele kleine dataset.
'Deep Learning' is nog altijd een Zwarte Kunst.
Het is een snel opkomende praktijk in de wereld van 'Machine Learning',
die zelfs door vooraanstaande onderzoekers in het veld nog niet volledig begrepen wordt,
wat het interessant maakt omdat er nog zo veel ontdekt kan worden.
En het is niet één algoritme,
het is een hele verzameling:
'Recurrent' netwerken, 'Convolutional' netwerken, 'Restricted Boltzmann machines', Barbra Streisand
Dit zijn allemaal netwerken die patronen in de wereld kunnen herkennen,
en ook die netwerken zelf hebben onderlinge patronen, zoals het feit dat ze hiërarchische lagen hebben.
Een ander is het gebruik van differerentieerbare lagen, zodat we hun voorspellingen kunnen verbeteren met gradiëntgebaseerde optimalisatie.

English: 
Hello, world.
It's Siraj.
And if you only have
a little bit of data,
can you still learn from it?
We're going to
build the model that
learns to classify
images using a very
small dataset for training.
Deep learning is still
very much a dark art.
It's an emerging practice in
the world of machine learning
that isn't well understood,
even by those pushing the state
of the art, which is exciting.
Because it means that there's
so much potential for discovery.
And it's not just one algorithm.
It's a collection of them.
Recurrent nets,
convolutional nets,
restrictive Boltzmann
machines, Barbara Streisand--
These are all networks
that can recognize patterns
in the world.
And they themselves
have shared patterns.
One shared pattern is that they
all use a hierarchy of layers,
the other is using
differentiable layers,
so that we can use
gradient-based optimization
to improve their prediction.
Design patterns are nothing
new in computer science.
There are many books
on design patterns

Dutch: 
Ontwerppatronen zijn niets nieuws binnen informatica. Er zijn vele boeken over ontwerppatronen voor zaken als
objectgeoriënteerd programmeren, gebruikersinterfaces...
maar wanneer het op 'Deep Learning  aankomt, is er niet echt een definitieve gids voor ontwerppatronen.
We zijn het momenteel collectief een beetje aan het uitzoeken.
Misschien lijkt het of er een solide wiskundige onderbouwing is voor wat de onderzoekers
proberen te doen, wanneer je vluchtig door een 'Deep Learning' paper heen bladert,
omdat je allerlei vergelijkingen ziet voor dingen als Hilbertruimtes en maattheorie,
maar in feite is ons collectief begrip nog altijd vrij minimaal.
Theorieën worden vaak geformuleerd omdat wiskundig 'handig' zijn.
De normale verdeling zie je bijvoorbeeld overal,
niet omdat het een of ander goddelijk concept is dat het universum ons geschonken heeft,
maar omdat het wiskundig 'handig' is.
Dus het definiëren van standaard ontwerppatronen voor patroonherkenning is een veld
waar veel te ontdekken valt. In de context van 'Machine Learning' kun je het "Meta-Learning' noemen.
of "leren hoe je moet leren". Kunnen we een systeem ontwerpen dat leert hoe het het best kan leren?

English: 
for topics like object-oriented
programming and user
interfaces.
But when it comes
to deep learning,
there's not really a definitive
design pattern guide.
We're all kind of figuring it
out collectively right now.
You might glaze over
a deep learning paper
and assume that there is some
solid mathematical foundation
behind what the
researchers attempted.
Because you see all sorts
of equations for things
like Hilbert spaces
and measure theory.
But the reality is that our
collective understanding
is still pretty minimal.
Theories are often formulated
because they are mathematically
convenient.
For example, the
Gaussian distribution
is ubiquitous, not
because it's some divine
construct that the universe
has bestowed on us,
but because it's
mathematically convenient.
So defining standard
design patterns
for pattern recognition networks
is a field ripe for discovery.
In the context of
machine learning,
we can call it meta-learning,
or learning to learn.
Can we design a system that
learns how best to learn?
That it learns how
to perform well

English: 
at an immediate task
in the short term.
And in the long term, it
learns a common structure
across many tasks.
We see meta level constructs
in nature all the time.
DNA is a great example.
It carries the
instructions, the blueprint
to create learning systems
that can expire our brains.
But it acts as long-term
memory by transcending death,
just like Oracle.
As long as there is a
mechanism for memory and one
to alter behavior based
on that memory, then
that mechanism can serve
as a meta level construct.
In the past few
months there have
been several papers
on meta learning
that have been published.
But I want to talk
about one that
uses meta learning
as a tool to solve
another task, one-shot learning,
the goal of learning from one
or only a few data points.
This is what we should be
aiming for, since GPU costs are
too damn high.
They used a modified
version of a model
called a Neural Turing
Machine, to learn
to classify character images
with just a few examples.

Dutch: 
Als in, op de korte termijn leert het hoe het goed kan presteren op een directe taak, en op de lange termijn
leert het een gedeelde structuur tussen vele verschillende taken
Dit soort meta-niveau constructen zien we overal in de natuur. DNA is een uitstekend voorbeeld.
Het draagt de instructies, de blauwdruk, om lerende systemen te maken die verdwijnen (ons brein),
maar het heeft toegang tot langetermijngeheugen door de dood te overstijgen.
Net als Oracle.
Zolang er een geheugenmechanisme is, én een mechanisme om gedrag te wijzigen aan de hand van dat geheugen,
kan dat mechanisme gebruikt worden als een meta-niveau construct.
De afgelopen maanden zijn er verscheidene papers gepubliceerd over meta-leren,
maar ik wil het specifiek hebben over eentje
die meta-leren als een hulpstuk gebruikt om een andere taak op te lossen: "one-shot" leren.
Oftewel het leren met het gebruik van één, of weinig, datapunten.
Hier moten we op concentreren omdat de kosten van GPU's veel te hoog zijn.
Ze gebruikten een aangepaste versie van een model genaamd de "Neurale Turing Machine",
welke geleerd heeft om plaatjes van karakters te classificeren, vanuit slechts enkele voorbeelden.
Deep Mind heeft het idee voor NTM's voor het eerst gepubliceerd in 2014.

Dutch: 
Het heeft twee componenten. De eerste is een neuraal netwerk dat we de 'controller' noemen, en de ander is een geheugenbank.
De controller neemt vectoren als input, en geeft ook als output vectoren,
net als 'oude' neurale netwerken. Maar wat het bijzonder maakt
is dat het ook data uitwisselt met een 'geheugenmatrix'
via lees- en schrijfoperaties. Dit is waar de analogie met de turingmachine vandaan komt.
Niet alleen om dat het cool klinkt,
maar omdat een turingmachine symbolen op een band manipuleert, volgens bepaalde regels.
Het is net als werkgeheugen voor een brein.
Het netwerk leert hoe het zijn geheugen het best kan gebruiken om de oplossing voor een bepaald probleem te leren
Voor de controller gebruikten ze een LSTM neuraal netwerk, omdat de interne staat een functie is van zowel de huidige staat als de input van het systeem
Het kan contextafhankelijke berekeningen uitvoeren, dus een signaal in de huidige tijdstap kan het gedrag van het netwerk in een latere tijdstap beïnvloeden
Alle componenten, inclusief het geheugen, moeten differentieerbaar zijn,
zodat we hun waardes tijdens het trainen incrementeel kunnen updaten.

English: 
DeepMind first drizzed-opped
the idea of NTMs in 2014.
It contains two components.
The first is a neural network
that we call the controller,
and the other is a memory bank.
The controller takes
vectors as inputs,
and outputs vectors as well,
just like all neural nets.
But what makes it
special is that it also
interacts with a memory
matrix, using read and write
operations.
This is where the Turing Machine
analogy comes from, not just
because it sounds dope, but
because a Turing machine
manipulates symbols
on a strip of tape,
according to a table of rules.
It's like having a working
memory for a brain.
The network learns how best to
use its memory when learning
a solution to a given problem.
For the controller, they use
an LSTM recurrent network,
since its internal state is a
function of the current state
and the input to the system.
It can perform
context-dependent computation.
So, a signal at a
current time step
can influence the network's
behavior later on.
And we need all the components,
including the memory store,
to be differentiable so that
we can incrementally update
their values during training.

Dutch: 
Om dit te bewerkstelligen hebben ze een aandachtsmechanisme toegevoegd, zodat de interactie tussen elke lees- en schrijfoperatie
en de elementen in het geheugen instelbaar is, in plaats dat een enkel element wordt aangesproken, zoals in een klassieke turingmachine het geval zou zijn.
Elke rij in de geheugenmatrix representeert een geheugenlocatie.
Lees- en schrijfkoppen gebruiken een gewichtsvector,met een component voor elke locatie.
Dus als er 10 geheugenlocaties zijn, dan concentreert de gewichtsfactor met slechts één waarde op index 3
de aandacht op de geheugenoperatie op locatie 3. Maar een gewichtsvector zoals deze spreidt de aandacht over het geheugen op verschillende locaties.
Een leesoperatie is gewoon een combinatie van de geheugenmatrix, en de gewichtsvector.
Een schrijfoperatie heeft twee onderdelen: een 'wissen' operatie, en een 'toevoegen' operatie
Deze lees- en schrijfkoppen worden gemaakt door twee geheugenadresseringsmechanismen te combineren.
De eerste is gebaseerd op inhoud:

English: 
To achieve this, they added
an attention mechanism,
so that each read and
write operation interacts
to a tunable degree with
all the elements in memory,
rather than addressing a single
element like a normal Turing
machine would.
Each row in the memory matrix
represents a memory location.
Read and write heads
use a weighting vector
with a component
for each location.
So if there are 10
memory locations,
then the weighting vector with
just one value at index 3,
would focus the attention of the
memory operation on location 3.
But a weighting
vector, like this,
spreads its attention
to the memory
across multiple locations.
A read operation is just a
combination of the memory
matrix and weighting vector.
A write operation though, has
two parts, an erase operation
then an add operation.
The way there read and
write heads are produced
is by combining two memory
addressing mechanisms.
The first is content based.
We focus on locations
based on the similarity

English: 
between their current
values and the controller's
emitted values.
The second is location based.
It facilitates iterations
across locations of the memory
and random access jumps.
Controller and memory
bank, read and writes
are so, so dank.
So, so dank.
So the authors of our one-shot
learning paper knew that NTMs
were a subset of memory
augmented neural networks.
And they saw the potential
to improve on it,
so that they could learn
from just a little data.
They discovered that
using a pure content based
memory writer, instead
of content plus location,
let them do just this.
That's because there's a
trade-off when training MANNs.
The more complex the
memory mechanism,
the more training the
controller requires.
The dataset has 1,600
separate classes,
and only a few
examples per class,
perfect for one-shot learning.
They randomly
selected five classes,

Dutch: 
We vestigen de aandacht op locaties gebaseerd op de gelijkenis tussen hun huidige waardes,
en de waardes die door de controllers worden uitgezonden.
De  tweede is gebaseerd op locatie:
Het faciliteert iteraties tussen locaties binnen het geheugen, en 'Random Access Jumps'.
♫ Controller ♫
♫ En geheugenbank ♫
♫ Lezen en schrijven is zo, zo 'dank' ♫
♫ Zo, zo 'dank' ♫
De auteurs van het paper over "one-shot" leren wisten dat NTM's een subset van "door geheugen geaugmenteerde neurale netwerken" waren,
en ze zagen de kans om het te verbeteren, zodat ze van een kleine hoeveelheid data konden leren.
Ze ontdekten dat het gebruik van een enkel op inhoud gebaseerde geheugenschrijver,
in plaats van een die op zowel inhoud als locatie gebaseerd is, dit mogelijk maakte.
Dit komt doordat er een compromis is bij het trainen van MANN's. Hoe complexer het geheugenmechanisme,
hoe meer training de controller nodig heeft.
De dataset heeft 1600 aparte klasses, en slechts een paar voorbeelden per klasse; ideaal voor one-shot leren.

Dutch: 
Ze kozen willekeurig vijf klasses, en wezen elke klasse willekeurig een label tussen een en vijf toe.
Dus, het model krijgt een instantie van een klasse te zien,
probeert het te classificeren, en krijgt te horen wat het correcte label is.
We hebben alleen Tensorflow en NumPy nodig voor ons model. We definiëren eerst onze geheugenbank,
initialiseren alle benodigde variabelen, en dan definiëren we onze controller; een 'feed-forward' neuraal netwerk.
We definiëren elke set gewichten en biases, laag voor laag, totdat we de output-laag bereiken.
We kunnen de interactie tussen beide componenten onder de 'stap' functie definiëren.
Deze wordt tijdens training elke tijdstap  aangeroepen.
Net als bij een reguliere NTM lezen we een vector uit het geheugen, welke een lineaire combinatie van zijn rijen is, geschaald door een genormaliseerde gewichtsvector,
Voor de gegeven input X produceert de leesvector een sleutel. We vergelijken elke sleutel met elke rij in het geheugen, met de cosinusgelijkenis.

English: 
and randomly assigned each
class a label between 1 and 5.
So the model gets shown
an instance of a class,
tries to classify
it, then it gets
informed of what the
correct label is.
We'll only need TensorFlow
and Numpy for our model.
We'll first define
our memory bank,
initializing each of the
variables that make it up.
Then we can define
our controller,
a feed-forward neural network.
We'll define each set of
weights and biases layer
by layer, until we've
reached the output layer.
We can define the
interaction that
happens between both components
under the step function, which
is called every time
step during training.
Just like with a regular
NTM, we read a vector
from memory that is a linear
combination of its rows,
scaled by a normalized
weight vector.
For the given input x, the
read vector will produce a key.
We compare each key
against each row in memory,
using the cosine
similarity as a measure.
This produces the
read weight vector,
which tells us how much
each row should contribute

English: 
to the linear combination.
The difference here is that
there is no extra parameter
to control the read weight
vectors' concentration.
To write to memory,
the controller
interpolates between writing
to the most recently read
memory rows and writing to
the least used memory rows.
Using the read weight vector
at a previous time step,
and the weight vector that
captures the least used memory
location, the controller
combines the two,
using a scalar parameter
and the sigmoid function
to create a write_weight_vector.
Each row in memory
is then updated
using the write_weight_vector
and the key issued
by the controller.
The model eventually
returns the probabilities
for each class as a vector.
After we've initialized
our TensorFlow session,
we'll use gradient
ascent via Adam
to optimize our network for
every image label pair we
feed in via a dictionary.
We'll print out our
results iteratively.
After training,
we can test it out
on some different
recognizable characters.
And notice how the accuracy
is surprisingly good.

Dutch: 
Hieruit volgt de leesgewichtsvector, welke ons vertelt hoeveel elke rij zou moeten bijdragen aan de lineaire combinatie.
Het verschil hier is dat er geen extra parameter bestaat die de focus van de leesvector beïnvloedt.
Om naar het geheugen te schrijven interpoleert de controller tussen de meest recent gelezen geheugenrijen, en de minstgebruikte geheugenrijen.
De controller creëert een schrijfgewichtsvector,
door de leesgewichtsvector uit de vorige tijdstap, en de gewichtsvector die de minstgebruikte geheugenlocatie aangeeft
te combineren middels een scalaire parameter en de sigmoïde functie.
Elke rij in het geheugen wordt vervolgens geüpdatet door de schrijfgewichtsvector en de sleutel die door de controller wordt verschaft.
Uiteindelijk produceert het model de kansen voor elke klasse als een vector.
Nadat we onze Tensorflowsessie hebben geïnitialiseerd,
gebruiken we de gradiëntgebaseerde optimalisatie, via Adam, om ons netwerk te optimaliseren,
voor elke afbeelding en bijbehorend label die we via een 'dictionary' invoeren.
We geven onze resultaten iteratief weer.
Na het trainen kunnen we het model testen op verscheidene herkenbare karakters.
Zie dat de de voorspellingen verrassend accuraat zijn.

English: 
Normally training time
would take a lot longer
for similar results.
These results are very
promising for one-shot learning.
And that's all it
takes to train, folks.
Let's get down to brass tacks.
A meta learning
system learns how
to perform well at
an immediate task,
and also learns a common
structure across many tasks.
Memory augmented neural networks
like a Neural Turing Machine,
use a controller and an
external memory store
to perform meta learning.
And meta learning can
be a way to achieve
one-shot learning,
which means learning
from one or a few examples.
This week's coding challenge
is to use a memory augmented
network to learn to classify
two classes of animals.
Details are in the Read Me.
Get Help links go into comments.
And winners will be
announced in one week.
And although this is the
last video for this course,
I'm still just getting started.
Please subscribe for
more programming videos,
and for now I've
got to go celebrate.
So, thanks for watching.

Dutch: 
Gewoonlijk zou het trainen een stuk langer duren om tot vergelijkbare resultaten te komen.
Deze resultaten zijn erg veelbelovend voor 'one-shot' leren.
En dat is alles wat er nodig is om te trainen, mensen!
Alles kort samenvattend:
Een "metal-erend" systeem leert hoe het goed kan presteren op een directe taak,
en leert tegelijkertijd een algemene structuur voor vele andere taken.
Door geheugen geaugmenteerde neurale netwerken, zoals de neurale turingmachine,
gebruiken een controller en een externe geheugenopslag om te 'meta-leren'.
En 'meta-leren' kan een manier zijn om 'one-shot' leren te bereiken,
wat een manier is om te leren van een, of weinig, voorbeelden.
De code-uitdaging van deze week is om een door geheugen geaugmenteerd neuraal netwerk te gebruiken,
om twee klasses van dieren te leren herkennen.
De details staan in de 'readme', zet je GitHub-links in de reacties,
en de winnaars worden over een week aangekondigd.
En hoewel dit de laatste video voor deze cursus is, ben ik nog steeds pas net begonnen.
Abonneer je voor meer programmeervideo's,  en nu moet ik dit gaan vieren, dus bedankt voor het kijken.
