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:

Define a NetGraph that does the same computation as Normalize:

Get the layer equivalent to Standardize:

Get a NetGraph equivalent to some custom standardization:

Get the NetGraph corresponding to different distances:

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 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}:

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:

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

Call the net to get the values:

EchoTiming is not supported: