From 61707145664a575ca34353cd0347114ae069fda1 Mon Sep 17 00:00:00 2001 From: autodocs Date: Wed, 18 Oct 2017 14:47:11 +0000 Subject: [PATCH] build based on b817ce6 --- latest/models/layers.html | 14 +++++++++----- latest/search_index.js | 26 +++++++++++++++++++++++++- latest/training/optimisers.html | 2 +- 3 files changed, 35 insertions(+), 7 deletions(-) diff --git a/latest/models/layers.html b/latest/models/layers.html index cb85de10..900b98d7 100644 --- a/latest/models/layers.html +++ b/latest/models/layers.html @@ -6,17 +6,21 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m) ga('create', 'UA-36890222-9', 'auto'); ga('send', 'pageview'); -
Model Reference

Layers

These core layers form the foundation of almost all neural networks.

Flux.Chain — Type.
Chain(layers...)

Chain multiple layers / functions together, so that they are called in sequence on a given input.

m = Chain(x -> x^2, x -> x+1)
+
Model Reference
Layers
These core layers form the foundation of almost all neural networks.
Flux.Chain — Type.
Chain(layers...)
Chain multiple layers / functions together, so that they are called in sequence on a given input.
m = Chain(x -> x^2, x -> x+1)
 m(5) == 26
 
 m = Chain(Dense(10, 5), Dense(5, 2))
 x = rand(10)
-m(x) == m[2](m[1](x))
Chain also supports indexing and slicing, e.g. m[2] or m[1:end-1]. m[1:3](x) will calculate the output of the first three layers.
source
Flux.Dense — Type.
Dense(in::Integer, out::Integer, σ = identity)
Creates a traditional Dense layer with parameters W and b.
y = σ.(W * x .+ b)
The input x must be a vector of length in, or a batch of vectors represented as an in × N matrix. The out y will be a vector or batch of length out.
julia> d = Dense(5, 2)
+m(x) == m[2](m[1](x))
Chain also supports indexing and slicing, e.g. m[2] or m[1:end-1]. m[1:3](x) will calculate the output of the first three layers.
source
Flux.Dense — Type.
Dense(in::Integer, out::Integer, σ = identity)
Creates a traditional Dense layer with parameters W and b.
y = σ.(W * x .+ b)
The input x must be a vector of length in, or a batch of vectors represented as an in × N matrix. The out y will be a vector or batch of length out.
julia> d = Dense(5, 2)
 Dense(5, 2)
 
 julia> d(rand(5))
 Tracked 2-element Array{Float64,1}:
   0.00257447
-  -0.00449443
source
Recurrent Cells
Much like the core layers above, but can be used to process sequence data (as well as other kinds of structured data).
RNN
-LSTM
-Recur
Activation Functions
Non-linearities that go between layers of your model. Most of these functions are defined in NNlib but are available by default in Flux.
Note that, unless otherwise stated, activation functions operate on scalars. To apply them to an array you can call σ.(xs), relu.(xs) and so on.
NNlib.σ — Function.
σ(x) = 1 / (1 + exp(-x))
Classic sigmoid activation function.
source
NNlib.relu — Function.
relu(x) = max(0, x)
Rectified Linear Unit activation function.
source
NNlib.leakyrelu — Function.
leakyrelu(x) = max(0.01x, x)
Leaky Rectified Linear Unit activation function.
You can also specify the coefficient explicitly, e.g. leakyrelu(x, 0.01).
source
NNlib.elu — Function.
elu(x; α = 1) = x > 0 ? x : α * (exp(x) - one(x)
Exponential Linear Unit activation function. See Fast and Accurate Deep Network Learning by Exponential Linear Units
source
NNlib.swish — Function.
swish(x) = x * σ(x)
Self-gated actvation function.
See Swish: a Self-Gated Activation Function.
source

+  -0.00449443
source

Recurrent Cells

Much like the core layers above, but can be used to process sequence data (as well as other kinds of structured data).

Flux.RNN — Function.
RNN(in::Integer, out::Integer, σ = tanh)

The most basic recurrent layer; essentially acts as a Dense layer, but with the output fed back into the input each time step.

source
Flux.LSTM — Function.
LSTM(in::Integer, out::Integer, σ = tanh)

Long Short Term Memory recurrent layer. Behaves like an RNN but generally exhibits a longer memory span over sequences.

See this article for a good overview of the internals.

source
Flux.Recur — Type.
Recur(cell)

Recur takes a recurrent cell and makes it stateful, managing the hidden state in the background. cell should be a model of the form:

h, y = cell(h, x...)

For example, here's a recurrent network that keeps a running total of its inputs.

accum(h, x) = (h+x, x)
+rnn = Flux.Recur(accum, 0)
+rnn(2) # 2
+rnn(3) # 3
+rnn.state # 5
+rnn.(1:10) # apply to a sequence
+rnn.state # 60
source

Activation Functions

Non-linearities that go between layers of your model. Most of these functions are defined in NNlib but are available by default in Flux.

Note that, unless otherwise stated, activation functions operate on scalars. To apply them to an array you can call σ.(xs), relu.(xs) and so on.

NNlib.σ — Function.
σ(x) = 1 / (1 + exp(-x))

Classic sigmoid activation function.

source
NNlib.relu — Function.
relu(x) = max(0, x)

Rectified Linear Unit activation function.

source
NNlib.leakyrelu — Function.
leakyrelu(x) = max(0.01x, x)

Leaky Rectified Linear Unit activation function.

You can also specify the coefficient explicitly, e.g. leakyrelu(x, 0.01).

source
NNlib.elu — Function.
elu(x; α = 1) = x > 0 ? x : α * (exp(x) - one(x)

Exponential Linear Unit activation function. See Fast and Accurate Deep Network Learning by Exponential Linear Units

source
NNlib.swish — Function.
swish(x) = x * σ(x)

Self-gated actvation function.

See Swish: a Self-Gated Activation Function.

source
diff --git a/latest/search_index.js b/latest/search_index.js index 58cb914c..6a5142b5 100644 --- a/latest/search_index.js +++ b/latest/search_index.js @@ -144,12 +144,36 @@ var documenterSearchIndex = {"docs": [ "text": "These core layers form the foundation of almost all neural networks.Chain\nDense" }, +{ + "location": "models/layers.html#Flux.RNN", + "page": "Model Reference", + "title": "Flux.RNN", + "category": "Function", + "text": "RNN(in::Integer, out::Integer, σ = tanh)\n\nThe most basic recurrent layer; essentially acts as a Dense layer, but with the output fed back into the input each time step.\n\n\n\n" +}, + +{ + "location": "models/layers.html#Flux.LSTM", + "page": "Model Reference", + "title": "Flux.LSTM", + "category": "Function", + "text": "LSTM(in::Integer, out::Integer, σ = tanh)\n\nLong Short Term Memory recurrent layer. Behaves like an RNN but generally exhibits a longer memory span over sequences.\n\nSee this article for a good overview of the internals.\n\n\n\n" +}, + +{ + "location": "models/layers.html#Flux.Recur", + "page": "Model Reference", + "title": "Flux.Recur", + "category": "Type", + "text": "Recur(cell)\n\nRecur takes a recurrent cell and makes it stateful, managing the hidden state in the background. cell should be a model of the form:\n\nh, y = cell(h, x...)\n\nFor example, here's a recurrent network that keeps a running total of its inputs.\n\naccum(h, x) = (h+x, x)\nrnn = Flux.Recur(accum, 0)\nrnn(2) # 2\nrnn(3) # 3\nrnn.state # 5\nrnn.(1:10) # apply to a sequence\nrnn.state # 60\n\n\n\n" +}, + { "location": "models/layers.html#Recurrent-Cells-1", "page": "Model Reference", "title": "Recurrent Cells", "category": "section", - "text": "Much like the core layers above, but can be used to process sequence data (as well as other kinds of structured data).RNN\nLSTM\nRecur" + "text": "Much like the core layers above, but can be used to process sequence data (as well as other kinds of structured data).RNN\nLSTM\nFlux.Recur" }, { diff --git a/latest/training/optimisers.html b/latest/training/optimisers.html index 51268454..592c57ce 100644 --- a/latest/training/optimisers.html +++ b/latest/training/optimisers.html @@ -27,4 +27,4 @@ end

If we call update, the parameters W Dense(10, 5, σ), Dense(5, 2), softmax)

Instead of having to write [m[1].W, m[1].b, ...], Flux provides a params function params(m) that returns a list of all parameters in the model for you.

For the update step, there's nothing whatsoever wrong with writing the loop above – it'll work just fine – but Flux provides various optimisers that make it more convenient.

opt = SGD([W, b], 0.1) # Gradient descent with learning rate 0.1
 
-opt() # Carry out the update, modifying `W` and `b`.

An optimiser takes a parameter list and returns a function that does the same thing as update above. We can pass either opt or update to our training loop, which will then run the optimiser after every mini-batch of data.

Optimiser Reference

All optimisers return a function that, when called, will update the parameters passed to it.

Flux.Optimise.SGD — Function.
SGD(params, η = 1; decay = 0)

Classic gradient descent optimiser. For each parameter p and its gradient δp, this runs p -= η*δp.

Supports decayed learning rate decay if the decay argument is provided.

source
Flux.Optimise.Momentum — Function.
Momentum(params, ρ, decay = 0)

SGD with momentum ρ and optional learning rate decay.

source
Flux.Optimise.Nesterov — Function.
Nesterov(params, ρ, decay = 0)

SGD with Nesterov momentum ρ and optional learning rate decay.

source
Flux.Optimise.RMSProp — Function.
RMSProp(params; η = 0.001, ρ = 0.9, ϵ = 1e-8, decay = 0)

RMSProp optimiser. Parameters other than learning rate don't need tuning. Often a good choice for recurrent networks.

source
Flux.Optimise.ADAM — Function.
ADAM(params; η = 0.001, β1 = 0.9, β2 = 0.999, ϵ = 1e-08, decay = 0)

ADAM optimiser.

source
Flux.Optimise.ADAGrad — Function.
ADAGrad(params; η = 0.01, ϵ = 1e-8, decay = 0)

ADAGrad optimiser. Parameters don't need tuning.

source
Flux.Optimise.ADADelta — Function.
ADADelta(params; η = 0.01, ρ = 0.95, ϵ = 1e-8, decay = 0)

ADADelta optimiser. Parameters don't need tuning.

source
+opt() # Carry out the update, modifying `W` and `b`.

An optimiser takes a parameter list and returns a function that does the same thing as update above. We can pass either opt or update to our training loop, which will then run the optimiser after every mini-batch of data.

Optimiser Reference

All optimisers return a function that, when called, will update the parameters passed to it.

Flux.Optimise.SGD — Function.
SGD(params, η = 1; decay = 0)

Classic gradient descent optimiser. For each parameter p and its gradient δp, this runs p -= η*δp.

Supports decayed learning rate decay if the decay argument is provided.

source
Flux.Optimise.Momentum — Function.
Momentum(params, ρ, decay = 0)

SGD with momentum ρ and optional learning rate decay.

source
Flux.Optimise.Nesterov — Function.
Nesterov(params, ρ, decay = 0)

SGD with Nesterov momentum ρ and optional learning rate decay.

source
Flux.Optimise.RMSProp — Function.
RMSProp(params; η = 0.001, ρ = 0.9, ϵ = 1e-8, decay = 0)

RMSProp optimiser. Parameters other than learning rate don't need tuning. Often a good choice for recurrent networks.

source
Flux.Optimise.ADAM — Function.
ADAM(params; η = 0.001, β1 = 0.9, β2 = 0.999, ϵ = 1e-08, decay = 0)

ADAM optimiser.

source
Flux.Optimise.ADAGrad — Function.
ADAGrad(params; η = 0.01, ϵ = 1e-8, decay = 0)

ADAGrad optimiser. Parameters don't need tuning.

source
Flux.Optimise.ADADelta — Function.
ADADelta(params; η = 0.01, ρ = 0.95, ϵ = 1e-8, decay = 0)

ADADelta optimiser. Parameters don't need tuning.

source