Model Reference

## Basic 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)
    Dense(5, 2)

    julia> d(rand(5))
    Tracked 2-element Array{Float64,1}:
      0.00257447
      -0.00449443

source

## Recurrent Layers

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

## Normalisation & Regularisation

These layers don't affect the structure of the network but may improve training times or reduce overfitting.

`Flux.Dropout` — Type.

    Dropout(p)

A Dropout layer. For each input, either sets that input to `0` (with probability `p`) or scales it by `1/(1-p)`. This is used as a regularisation, i.e. it reduces overfitting during training.

Does nothing to the input once in `testmode!`.

source