# FunctionLayer

represents a net layer that applies function f to its input.

# Details and Options   • FunctionLayer is used to define neural nets from usual Wolfram Language code.
• FunctionLayer[f][x] behaves in the same way as f[x].
• The function f should involve only valid operations on arrays that produce an array or an association of arrays.
• Valid operations include arithmetic functions (Plus, Times, etc.), elementary functions (Exp, Sqrt, Sin, etc.), numerical functions (Min, Round, Ramp, etc.), array constructions (Table, ConstantArray, etc.), array operations (Dot, Det, Tr, etc.), descriptive statistics (Mean, StandardDeviation, etc.) and distance and similarities (EuclideanDistance, HammingDistance, etc.). It is also possible to use looping constructs (Map, NestList, FoldList, etc.) and list manipulation functions (Part, Reverse, etc.).
• Function f must take only one argument as input. The argument can be an array or an association of arrays.
• If the argument of f is a unique array, f can be defined by a pure function, a symbol or a composition of these. The resulting layer will have a unique input port called "Input".
• FunctionLayer[Sin[#]&] • If the argument of f is an association of arrays, f should be defined using named slots. The resulting layer will have ports named after the slots.
• FunctionLayer[#Foo+#Bar&] • FunctionLayer can also be given a multiple-argument function f using the syntax FunctionLayer[Apply[f]]. In this case, ports are named automatically.
• FunctionLayer[Apply[#1+#2&]] • The output of f must be a unique array (which corresponds to a unique port) or an association of arrays (which corresponds to multiple ports).
• FunctionLayer[<|"Foo"Sin[#],"Bar"#|>&] • FunctionLayer[f,"port"shape] can be used as in NetGraph to specify the shape, encoder or decoder of a given port.
• NetArray can be used inside the function f to define learnable parameters.
• The function f is internally converted into a net that can be a layer or a graph of layers. NetExtract can be used to extract layers and parameters from a function layer.
• NetGraph[FunctionLayer[]] converts the function layer into a NetGraph[].
• Information[FunctionLayer[]] gives a report about the layer.
• Information[FunctionLayer[],prop] gives the value of the property prop of . Possible properties are the same as for NetGraph.

# Examples

open allclose all

## Basic Examples(2)

Define a layer that computes the StandardDeviation on some array:

The layer evaluates the same values as the symbol:

Extract the original function:

Get a net layer that is equivalent to StandardDeviation:

Get a NetGraph that is equivalent to StandardDeviation:

FunctionLayer can be used inside NetChain and NetGraph:

## Scope(18)

### Input/Output(4)

Define a layer that computes a function that takes an input vector and yields an output vector:

Extract the original function:

Extract an equivalent NetGraph:

Convert into a net a function that takes an array and returns an association of arrays:

The net returns the same values as the function:

Convert into a net a function that takes an association of arrays:

Apply the net on an association of arrays:

Convert into a net a function that takes a list of arrays:

Apply the net on a list of numbers:

Apply the net on a list of arrays:

The original function gives the same result:

### Normalization(3)

Define a NetGraph that does the same computation as Normalize:

Get the layer equivalent to Standardize:

Get a NetGraph equivalent to some custom standardization:

### Distances(1)

Get the NetGraph corresponding to different distances:

### Structural(3)

Get the net layers that perform given structural operations on arrays:

Get the net layers that extract values at particular positions in arrays:

Create a FunctionLayer that computes the unit vector at a given position:

### Fixed and Learnable Arrays(1)

Fixed arrays can be specified with lists, and arrays of learnable parameters can be specified by NetArray:

The list {0.25,0.75} corresponds to a frozen NetArrayLayer with null LearningRateMultipliers:

NetArray[{2},"Array"{0.1,0.9}]] corresponds to a NetArrayLayer with a pair of learnable values initialized to {0.1,0.9}:

### Random Numbers(5)

Create a net that randomly chooses between two input arrays:

Repeat a random choice 10 times:

Create a net that adds a grayscale mask with a random value to an image:

Apply the net to an image:

Create a net that adds a mask with a random color to an image:

Apply the net to an image:

Create a net that adds random noise to the lines of pixels of an image:

Apply the net to an image:

Create a net that adds random noise to the pixels of an image:

Apply the net to an image:

### Debugging with Echo(1)

Connect some intermediate computations as an output port of a net:

Call the net to get the values:

EchoTiming is not supported: ## Possible Issues(1)

Functions mixing several arguments are not supported: Named inputs must be used to define a net layer with multiple inputs: