Basic Layers
These core layers form the foundation of almost all neural networks.
Flux.Chain
— TypeChain(layers...)
Chain multiple layers / functions together, so that they are called in sequence on a given input.
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.
Examples
julia> m = Chain(x -> x^2, x -> x+1);
julia> m(5) == 26
true
julia> m = Chain(Dense(10, 5), Dense(5, 2));
julia> x = rand(10);
julia> m(x) == m[2](m[1](x))
true
Flux.Dense
— TypeDense(in, out, σ=identity; bias=true, init=glorot_uniform)
Dense(W::AbstractMatrix, [bias, σ])
Create a traditional Dense
layer, whose forward pass is given by:
y = σ.(W * x .+ bias)
The input x
should be a vector of length in
, or batch of vectors represented as an in × N
matrix, or any array with size(x,1) == in
. The out y
will be a vector of length out
, or a batch with size(y) == (out, size(x)[2:end]...)
Keyword bias=false
will switch off trainable bias for the layer. The initialisation of the weight matrix is W = init(out, in)
, calling the function given to keyword init
, with default glorot_uniform
. The weight matrix and/or the bias vector (of length out
) may also be provided explicitly.
Examples
julia> d = Dense(5, 2)
Dense(5, 2)
julia> d(rand(Float32, 5, 64)) |> size
(2, 64)
julia> d(rand(Float32, 5, 1, 1, 64)) |> size # treated as three batch dimensions
(2, 1, 1, 64)
julia> d1 = Dense(ones(2, 5), false, tanh) # using provided weight matrix
Dense(5, 2, tanh; bias=false)
julia> d1(ones(5))
2-element Vector{Float64}:
0.9999092042625951
0.9999092042625951
julia> Flux.params(d1) # no trainable bias
Params([[1.0 1.0 … 1.0 1.0; 1.0 1.0 … 1.0 1.0]])
Convolution and Pooling Layers
These layers are used to build convolutional neural networks (CNNs).
Flux.Conv
— TypeConv(filter, in => out, σ=identity; stride=1, pad=0, dilation=1, [bias, init])
Standard convolutional layer. filter
is a tuple of integers specifying the size of the convolutional kernel; in
and out
specify the number of input and output channels.
Image data should be stored in WHCN order (width, height, channels, batch). In other words, a 100×100 RGB image would be a 100×100×3×1
array, and a batch of 50 would be a 100×100×3×50
array. This has N=2
spatial dimensions, and needs a kernel size like (5,5)
, a 2-tuple of integers.
For N
spatial dimensions, this layer expects as input an array with ndims(x) == N+2
, where size(x,N+1) == in
is the number of channels. Then:
filter
should be a tuple ofN
integers.- Keywords
stride
anddilation
should each be either single integer, or a tuple withN
integers. - Keyword
pad
can be:- a single integer for equal padding all around,
- a tuple of
N
integers, to apply the same padding at begin/end of each spatial dimension, - a tuple of
2*N
integers, for asymmetric padding, or - the singleton
SamePad()
, to calculate padding such thatsize(output,d) == size(x,d) / stride
(possibly rounded) for each spatial dimension.
Accepts two keywords to control its parameters:
- Initial weights are generated by the function
init = glorot_uniform
. - Initial bias is zero by default, this can be disabled entirely with
bias = false
, or another vector provided asbias = randn(Float32, out)
.
See also ConvTranspose
, DepthwiseConv
, CrossCor
.
Examples
julia> xs = rand(Float32, 100, 100, 3, 50); # a batch of images
julia> lay = Conv((5,5), 3 => 7, relu; bias=false)
Conv((5, 5), 3=>7, relu)
julia> lay(xs) |> size
(96, 96, 7, 50)
julia> Conv((5,5), 3 => 7; stride=2)(xs) |> size
(48, 48, 7, 50)
julia> Conv((5,5), 3 => 7; stride=2, pad=SamePad())(xs) |> size
(50, 50, 7, 50)
julia> Conv((1,1), 3 => 7; pad=(20,10,0,0))(xs) |> size
(130, 100, 7, 50)
julia> Conv((5,5), 3 => 7; stride=2, dilation=4)(xs) |> size
(42, 42, 7, 50)
Flux.AdaptiveMaxPool
— TypeAdaptiveMaxPool(out::NTuple)
Adaptive max pooling layer. Calculates the necessary window size such that its output has size(y)[1:N] == out
.
Expects as input an array with ndims(x) == N+2
, i.e. channel and batch dimensions, after the N
feature dimensions, where N = length(out)
.
See also MaxPool
, AdaptiveMeanPool
.
Examples
julia> xs = rand(Float32, 100, 100, 3, 50); # batch of 50 RGB images
julia> AdaptiveMaxPool((25, 25))(xs) |> size
(25, 25, 3, 50)
julia> MaxPool((4,4))(xs) ≈ AdaptiveMaxPool((25, 25))(xs)
true
Flux.MaxPool
— TypeMaxPool(window::NTuple; pad=0, stride=window)
Max pooling layer, which replaces all pixels in a block of size window
with one.
Expects as input an array with ndims(x) == N+2
, i.e. channel and batch dimensions, after the N
feature dimensions, where N = length(window)
.
By default the window size is also the stride in each dimension. The keyword pad
accepts the same options as for the Conv
layer, including SamePad()
.
See also Conv
, MeanPool
, AdaptiveMaxPool
, GlobalMaxPool
.
Examples
julia> xs = rand(Float32, 100, 100, 3, 50); # batch of 50 RGB images
julia> m = Chain(Conv((5, 5), 3=>7, pad=SamePad()), MaxPool((5, 5), pad=SamePad()))
Chain(Conv((5, 5), 3=>7), MaxPool((5, 5), pad=2))
julia> m[1](xs) |> size
(100, 100, 7, 50)
julia> m(xs) |> size
(20, 20, 7, 50)
julia> lay = MaxPool((5,), pad=2, stride=(3,)) # one-dimensional window
MaxPool((5,), pad=2, stride=3)
julia> lay(rand(Float32, 100, 7, 50)) |> size
(34, 7, 50)
Flux.GlobalMaxPool
— TypeGlobalMaxPool()
Global max pooling layer.
Transforms (w,h,c,b)-shaped input into (1,1,c,b)-shaped output, by performing max pooling on the complete (w,h)-shaped feature maps.
See also MaxPool
, GlobalMeanPool
.
julia> xs = rand(Float32, 100, 100, 3, 50);
julia> m = Chain(Conv((3,3), 3=>7), GlobalMaxPool())
Chain(Conv((3, 3), 3=>7), GlobalMaxPool())
julia> m(xs) |> size
(1, 1, 7, 50)
julia> GlobalMaxPool()(rand(3,5,7)) |> size # preserves 2 dimensions
(1, 5, 7)
Flux.AdaptiveMeanPool
— TypeAdaptiveMeanPool(out::NTuple)
Adaptive mean pooling layer. Calculates the necessary window size such that its output has size(y)[1:N] == out
.
Expects as input an array with ndims(x) == N+2
, i.e. channel and batch dimensions, after the N
feature dimensions, where N = length(out)
.
See also MaxPool
, AdaptiveMaxPool
.
Examples
julia> xs = rand(Float32, 100, 100, 3, 50); # batch of 50 RGB images
julia> AdaptiveMeanPool((25, 25))(xs) |> size
(25, 25, 3, 50)
julia> MeanPool((4,4))(xs) ≈ AdaptiveMeanPool((25, 25))(xs)
true
Flux.MeanPool
— TypeMeanPool(window::NTuple; pad=0, stride=window)
Mean pooling layer, averaging all pixels in a block of size window
.
Expects as input an array with ndims(x) == N+2
, i.e. channel and batch dimensions, after the N
feature dimensions, where N = length(window)
.
By default the window size is also the stride in each dimension. The keyword pad
accepts the same options as for the Conv
layer, including SamePad()
.
See also Conv
, MaxPool
, AdaptiveMeanPool
.
Examples
julia> xs = rand(Float32, 100, 100, 3, 50);
julia> m = Chain(Conv((5,5), 3 => 7), MeanPool((5,5), pad=SamePad()))
Chain(Conv((5, 5), 3=>7), MeanPool((5, 5), pad=2))
julia> m[1](xs) |> size
(96, 96, 7, 50)
julia> m(xs) |> size
(20, 20, 7, 50)
Flux.GlobalMeanPool
— TypeGlobalMeanPool()
Global mean pooling layer.
Transforms (w,h,c,b)-shaped input into (1,1,c,b)-shaped output, by performing mean pooling on the complete (w,h)-shaped feature maps.
julia> xs = rand(Float32, 100, 100, 3, 50);
julia> m = Chain(Conv((3,3), 3=>7), GlobalMeanPool())
Chain(Conv((3, 3), 3=>7), GlobalMeanPool())
julia> m(xs) |> size
(1, 1, 7, 50)
Flux.DepthwiseConv
— TypeDepthwiseConv(filter, in=>out, σ=identity; stride=1, pad=0, dilation=1, [bias, init])
Depthwise convolutional layer. filter
is a tuple of integers specifying the size of the convolutional kernel, while in
and out
specify the number of input and output channels.
Note that out
must be an integer multiple of in
.
Parameters are controlled by additional keywords, with defaults init=glorot_uniform
and bias=true
.
See also Conv
for more detailed description of keywords.
Examples
julia> xs = rand(Float32, 100, 100, 3, 50); # a batch of 50 RGB images
julia> lay = DepthwiseConv((5,5), 3 => 6, relu; bias=false)
DepthwiseConv((5, 5), 3=>6, relu)
julia> lay(xs) |> size
(96, 96, 6, 50)
julia> DepthwiseConv((5,5), 3 => 9, stride=2, pad=2)(xs) |> size
(50, 50, 9, 50)
Flux.ConvTranspose
— TypeConvTranspose(filter, in => out, σ=identity; stride=1, pad=0, dilation=1, [bias, init])
Standard convolutional transpose layer. filter
is a tuple of integers specifying the size of the convolutional kernel, while in
and out
specify the number of input and output channels.
Note that pad=SamePad()
here tries to ensure size(output,d) == size(x,d) * stride
.
Parameters are controlled by additional keywords, with defaults init=glorot_uniform
and bias=true
.
See also Conv
for more detailed description of keywords.
Examples
julia> xs = rand(Float32, 100, 100, 3, 50); # a batch of 50 RGB images
julia> lay = ConvTranspose((5,5), 3 => 7, relu)
ConvTranspose((5, 5), 3=>7, relu)
julia> lay(xs) |> size
(104, 104, 7, 50)
julia> ConvTranspose((5,5), 3=>7, stride=2)(xs) |> size
(203, 203, 7, 50)
julia> ConvTranspose((5,5), 3=>7, stride=3, pad=SamePad())(xs) |> size
(300, 300, 7, 50)
Flux.CrossCor
— TypeCrossCor(filter, in => out, σ=identity; stride=1, pad=0, dilation=1, [bias, init])
Standard cross convolutional layer. filter
is a tuple of integers specifying the size of the convolutional kernel; in
and out
specify the number of input and output channels.
Parameters are controlled by additional keywords, with defaults init=glorot_uniform
and bias=true
.
See also Conv
for more detailed description of keywords.
Examples
julia> xs = rand(Float32, 100, 100, 3, 50); # a batch of 50 RGB images
julia> lay = CrossCor((5,5), 3 => 6, relu; bias=false)
CrossCor((5, 5), 3=>6, relu)
julia> lay(xs) |> size
(96, 96, 6, 50)
julia> CrossCor((5,5), 3=>7, stride=3, pad=(2,0))(xs) |> size
(34, 32, 7, 50)
Flux.SamePad
— TypeSamePad()
Passed as an option to convolutional layers (and friends), this causes the padding to be chosen such that the input and output sizes agree (on the first N
dimensions, the kernel or window) when stride==1
.
Flux.flatten
— Functionflatten(x::AbstractArray)
Reshape arbitrarly-shaped input into a matrix-shaped output, preserving the size of the last dimension.
See also unsqueeze
.
Examples
julia> rand(3,4,5) |> Flux.flatten |> size
(12, 5)
julia> xs = rand(Float32, 10,10,3,7);
julia> m = Chain(Conv((3,3), 3=>4, pad=1), Flux.flatten, Dense(400,33));
julia> xs |> m[1] |> size
(10, 10, 4, 7)
julia> xs |> m |> size
(33, 7)
Flux.convfilter
— Functionconvfilter(filter::Tuple, in=>out)
Constructs a standard convolutional weight matrix with given filter
and channels from in
to out
.
Accepts the keyword init
(default: glorot_uniform
) to control the sampling distribution.
See also: depthwiseconvfilter
Flux.depthwiseconvfilter
— Functiondepthwiseconvfilter(filter::Tuple, in=>out)
Constructs a depthwise convolutional weight array defined by filter
and channels from in
to out
.
Accepts the keyword init
(default: glorot_uniform
) to control the sampling distribution.
See also: convfilter
Upsampling Layers
Flux.Upsample
— TypeUpsample(mode = :nearest; [scale, size]) Upsample(scale, mode = :nearest)
An upsampling layer. One of two keywords must be given:
If scale
is a number, this applies to all but the last two dimensions (channel and batch) of the input. It may also be a tuple, to control dimensions individually. Alternatively, keyword size
accepts a tuple, to directly specify the leading dimensions of the output.
Currently supported upsampling mode
s and corresponding NNlib's methods are:
:nearest
->NNlib.upsample_nearest
:bilinear
->NNlib.upsample_bilinear
Examples
julia> m = Upsample(scale = (2, 3))
Upsample(:nearest, scale = (2, 3))
julia> m(ones(2, 2, 1, 1)) |> size
(4, 6, 1, 1)
julia> m = Upsample(:bilinear, size = (4, 5))
Upsample(:bilinear, size = (4, 5))
julia> m(ones(2, 2, 1, 1)) |> size
(4, 5, 1, 1)
Flux.PixelShuffle
— TypeRecurrent 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
— FunctionRNN(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.
Flux.LSTM
— FunctionLSTM(in::Integer, out::Integer)
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.
Flux.GRU
— FunctionGRU(in::Integer, out::Integer)
Gated Recurrent Unit layer. Behaves like an RNN but generally exhibits a longer memory span over sequences.
See this article for a good overview of the internals.
Flux.Recur
— TypeRecur(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
Flux.reset!
— Functionreset!(rnn)
Reset the hidden state of a recurrent layer back to its original value.
Assuming you have a Recur
layer rnn
, this is roughly equivalent to:
rnn.state = hidden(rnn.cell)
Other General Purpose Layers
These are marginally more obscure than the Basic Layers. But in contrast to the layers described in the other sections are not readily grouped around a particular purpose (e.g. CNNs or RNNs).
Flux.Maxout
— TypeMaxout(over)
The Maxout layer has a number of internal layers which all receive the same input. It returns the elementwise maximum of the internal layers' outputs.
Maxout over linear dense layers satisfies the univeral approximation theorem.
Flux.SkipConnection
— TypeSkipConnection(layer, connection)
Create a skip connection which consists of a layer or Chain
of consecutive layers and a shortcut connection linking the block's input to the output through a user-supplied 2-argument callable. The first argument to the callable will be propagated through the given layer
while the second is the unchanged, "skipped" input.
The simplest "ResNet"-type connection is just SkipConnection(layer, +)
. Here is a more complicated example:
julia> m = Conv((3,3), 4 => 7, pad=(1,1));
julia> x = ones(Float32, 5, 5, 4, 10);
julia> size(m(x)) == (5, 5, 7, 10)
true
julia> sm = SkipConnection(m, (mx, x) -> cat(mx, x, dims=3));
julia> size(sm(x)) == (5, 5, 11, 10)
true
Flux.Parallel
— TypeParallel(connection, layers...)
Create a 'Parallel' layer that passes an input array to each path in layers
, reducing the output with connection
.
Called with one input x
, this is equivalent to reduce(connection, [l(x) for l in layers])
. If called with multiple inputs, they are zip
ped with the layers, thus Parallel(+, f, g)(x, y) = f(x) + g(y)
.
Examples
julia> model = Chain(Dense(3, 5),
Parallel(vcat, Dense(5, 4), Chain(Dense(5, 7), Dense(7, 4))),
Dense(8, 17));
julia> size(model(rand(3)))
(17,)
julia> model = Parallel(+, Dense(10, 2), Dense(5, 2))
Parallel(+, Dense(10, 2), Dense(5, 2))
julia> size(model(rand(10), rand(5)))
(2,)
Flux.Bilinear
— TypeBilinear(in1, in2, out, σ=identity; bias=true, init=glorot_uniform)
Bilinear(W::AbstractArray, [bias, σ])
Creates a Bilinear layer, which operates on two inputs at the same time. Its output, given vectors x
& y
, is another vector z
with, for all i ∈ 1:out
:
z[i] = σ(x' * W[i,:,:] * y + bias[i])
If x
and y
are matrices, then each column of the output z = B(x, y)
is of this form, with B
a Bilinear layer.
If y
is not given, it is taken to be equal to x
, i.e. B(x) == B(x, x)
The two inputs may also be provided as a tuple, B((x, y)) == B(x, y)
, which is accepted as the input to a Chain
.
The initialisation works as for Dense
layer, with W = init(out, in1, in2)
. By default the bias vector is zeros(Float32, out)
, option bias=false
will switch off trainable bias. Either of these may be provided explicitly.
Examples
julia> x, y = randn(Float32, 5, 32), randn(Float32, 5, 32);
julia> B = Flux.Bilinear(5, 5, 7);
julia> B(x) |> size # interactions based on one input
(7, 32)
julia> B(x,y) == B((x,y)) # two inputs, may be given as a tuple
true
julia> sc = SkipConnection(
Chain(Dense(5, 20, tanh), Dense(20, 9, tanh)),
Flux.Bilinear(9, 5, 3, bias=false),
); # used as the recombinator, with skip as the second input
julia> sc(x) |> size
(3, 32)
julia> Flux.Bilinear(rand(4,8,16), false, tanh) # first dim of weight is the output
Bilinear(8, 16, 4, tanh, bias=false)
Flux.Diagonal
— TypeDiagonal(α, β)
Diagonal(size::Integer...)
Create an element-wise linear layer, which performs
y = α .* x .+ β
The learnable arrays are initialised α = ones(Float32, size)
and β = zeros(Float32, size)
.
Used by LayerNorm
.
Normalisation & Regularisation
These layers don't affect the structure of the network but may improve training times or reduce overfitting.
Flux.normalise
— Functionnormalise(x; dims=ndims(x), ϵ=1e-5)
Normalise x
to mean 0 and standard deviation 1 across the dimension(s) given by dims
. Per default, dims
is the last dimension. ϵ
is a small additive factor added to the denominator for numerical stability.
Flux.BatchNorm
— TypeBatchNorm(channels::Integer, λ=identity;
initβ=zeros, initγ=ones,
ϵ=1f-5, momentum= 0.1f0)
Batch Normalization layer. channels
should be the size of the channel dimension in your data (see below).
Given an array with N
dimensions, call the N-1
th the channel dimension. For a batch of feature vectors this is just the data dimension, for WHCN
images it's the usual channel dimension.
BatchNorm
computes the mean and variance for each D_1×...×D_{N-2}×1×D_N
input slice and normalises the input accordingly.
If affine=true
, it also applies a shift and a rescale to the input through to learnable per-channel bias β and scale γ parameters.
After normalisation, elementwise activation λ
is applied.
If track_stats=true
, accumulates mean and var statistics in training phase that will be used to renormalize the input in test phase.
Use testmode!
during inference.
Examples
m = Chain(
Dense(28^2, 64),
BatchNorm(64, relu),
Dense(64, 10),
BatchNorm(10),
softmax)
Flux.dropout
— Functiondropout(x, p; dims=:, active=true)
The dropout function. If active
is true
, for each input, either sets that input to 0
(with probability p
) or scales it by 1 / (1 - p)
. dims
specifies the unbroadcasted dimensions, e.g. dims=1
applies dropout along columns and dims=2
along rows. This is used as a regularisation, i.e. it reduces overfitting during training.
If active
is false
, it just returns the input x
.
Warning: when using this function, you have to manually manage the activation state. Usually in fact, dropout is used while training but is deactivated in the inference phase. This can be automatically managed using the Dropout
layer instead of the dropout
function.
The Dropout
layer is what you should use in most scenarios.
Flux.Dropout
— TypeDropout(p; dims=:)
Dropout layer. In the forward pass, apply the Flux.dropout
function on the input.
To apply dropout along certain dimension(s), specify the dims
keyword. e.g. Dropout(p; dims = 3)
will randomly zero out entire channels on WHCN input (also called 2D dropout).
Does nothing to the input once Flux.testmode!
is true
.
Flux.AlphaDropout
— TypeAlphaDropout(p)
A dropout layer. Used in Self-Normalizing Neural Networks. The AlphaDropout layer ensures that mean and variance of activations remain the same as before.
Does nothing to the input once testmode!
is true.
Flux.LayerNorm
— TypeLayerNorm(sz, λ=identity; affine=true, ϵ=1fe-5)
A normalisation layer designed to be used with recurrent hidden states. The argument sz
should be an integer or a tuple of integers. In the forward pass, the layer normalises the mean and standard deviation of the input, the applied the elementwise activation λ
. The input is normalised along the first length(sz)
dimensions for tuple sz
, along the first dimension for integer sz
. The input is expected to have first dimensions' size equal to sz
.
If affine=true
also applies a learnable shift and rescaling as in the Diagonal
layer.
Se also BatchNorm
, InstanceNorm
, GroupNorm
, and normalise
.
Flux.InstanceNorm
— TypeInstanceNorm(channels::Integer, λ=identity;
initβ=zeros, initγ=ones,
affine=false, track_stats=false,
ϵ=1f-5, momentum=0.1f0)
Instance Normalization layer. channels
should be the size of the channel dimension in your data (see below).
Given an array with N > 2
dimensions, call the N-1
th the channel dimension. For WHCN
images it's the usual channel dimension.
InstanceNorm
computes the mean and variance for each D_1×...×D_{N-2}×1×1
input slice and normalises the input accordingly.
If affine=true
, it also applies a shift and a rescale to the input through to learnable per-channel bias β
and scale γ
parameters.
If track_stats=true
, accumulates mean and var statistics in training phase that will be used to renormalize the input in test phase.
Warning: the defaults for affine
and track_stats
used to be true
in previous Flux versions (< v0.12).
Flux.GroupNorm
— TypeGroupNorm(channels::Integer, G::Integer, λ=identity;
initβ = (i) -> zeros(Float32, i),
initγ = (i) -> ones(Float32, i),
affine=true, track_stats=false,
ϵ=1f-5, momentum=0.1f0)
Group Normalization layer.
chs
is the number of channels, the channel dimension of your input. For an array of N dimensions, the N-1
th index is the channel dimension.
G
is the number of groups along which the statistics are computed. The number of channels must be an integer multiple of the number of groups.
channels
should be the size of the channel dimension in your data (see below).
Given an array with N > 2
dimensions, call the N-1
th the channel dimension. For WHCN
images it's the usual channel dimension.
If affine=true
, it also applies a shift and a rescale to the input through to learnable per-channel bias β
and scale γ
parameters.
If track_stats=true
, accumulates mean and var statistics in training phase that will be used to renormalize the input in test phase.
Testmode
Many normalisation layers behave differently under training and inference (testing). By default, Flux will automatically determine when a layer evaluation is part of training or inference. Still, depending on your use case, it may be helpful to manually specify when these layers should be treated as being trained or not. For this, Flux provides Flux.testmode!
. When called on a model (e.g. a layer or chain of layers), this function will place the model into the mode specified.
Flux.testmode!
— Functiontestmode!(m, mode = true)
Set a layer or model's test mode (see below). Using :auto
mode will treat any gradient computation as training.
Note: if you manually set a model into test mode, you need to manually place it back into train mode during training phase.
Possible values include:
false
for trainingtrue
for testing:auto
ornothing
for Flux to detect the mode automatically
Flux.trainmode!
— Functiontrainmode!(m, mode = true)
Set a layer of model's train mode (see below). Symmetric to testmode!
(i.e. trainmode!(m, mode) == testmode!(m, !mode)
).
Note: if you manually set a model into train mode, you need to manually place it into test mode during testing phase.
Possible values include:
true
for trainingfalse
for testing:auto
ornothing
for Flux to detect the mode automatically