inverseNormalizationLayer
Description
An inverse normalization layer transforms predictions for neural networks trained using normalized targets.
If the training process uses normalized targets, then the neural network learns to make predictions that closely match the normalized targets. To make the neural network output predictions in the space of unnormalized values at prediction time, include an inverse normalization layer.
To normalize targets at training time, set the NormalizeTargets argument of the trainingOptions function to 1
(true).
Creation
Syntax
Description
layer = inverseNormalizationLayer creates an inverse
normalization layer that transforms data over the channel dimension.
layer = inverseNormalizationLayer(
specifies options using one or more name-value arguments in addition to any of the input
argument combinations in previous syntaxes. For example, Name=Value)Name="invnorm"
specifies the name "invnorm".
Example: inverseNormalizationLayer(Name="invnorm") creates an
inverse normalization layer with the name "invnorm".
Input Arguments
Name-Value Arguments
Properties
Examples
Create an inverse normalization layer.
layer = inverseNormalizationLayer
layer =
InverseNormalizationLayer with properties:
Name: ''
Normalization: 'zscore'
OperationDimension: 'channel'
State Parameters
Mean: []
StandardDeviation: []
Include an inverse normalization layer in a layer array.
layers = [
sequenceInputLayer(3,Normalization="zscore")
lstmLayer(100)
fullyConnectedLayer(3)
inverseNormalizationLayer]layers =
4×1 Layer array with layers:
1 '' Sequence Input Sequence input with 3 channels
2 '' LSTM LSTM with 100 hidden units
3 '' Fully Connected Fully connected layer with output size 3
4 '' Inverse Normalization Inverse "zscore" normalization
Create an inverse normalization layer that applies the inverse zero-center normalization operation over the third dimension of the data.
layer = inverseNormalizationLayer(3,Normalization="zerocenter")layer =
InverseNormalizationLayer with properties:
Name: ''
Normalization: 'zerocenter'
OperationDimension: 3
State Parameters
Mean: []
Train a regression neural network using normalized numeric targets.
Load the waveform data.
load WaveformDataSet aside data for validation and testing. Partition the data into a training set containing 80% of the data and a test set containing the remaining 20% of the data.
numObservations = numel(data); [idxTrain,idxTest] = trainingPartitions(numObservations, [0.8 0.2]); XTrain = data(idxTrain); XTest = data(idxTest); TTrain = freq(idxTrain); TTest = freq(idxTest);
Create an LSTM regression network.
Use a sequence input layer with an input size that matches the number of channels of the input data. Normalize the input data using -score normalization.
Use an LSTM layer with 100 hidden units that outputs the last time step of each sequence.
For regression, include a fully connected layer with an output size that matches the number of responses.
In this example, the training process uses normalized targets in the loss function. Using normalized targets results in training predictions that closely match the normalized targets. To make the neural network output predictions in the space of unnormalized values at prediction time, include an inverse normalization layer.
numChannels = size(XTrain{1},2);
numResponses = size(TTrain,2);
layers = [
sequenceInputLayer(numChannels,Normalization="zscore")
lstmLayer(100,OutputMode="last")
fullyConnectedLayer(numResponses)
inverseNormalizationLayer];Specify the training options.
Train using the Adam optimizer.
Normalize the training targets.
Train for 300 epochs.
Monitor the training progress in a plot.
Disable the verbose output.
options = trainingOptions("adam", ... NormalizeTargets=true, ... MaxEpochs=300, ... Shuffle="every-epoch", ... Plots="training-progress", ... Verbose=false);
Train the neural network using the trainnet function. For regression, use mean squared error (MSE) loss. By default, the trainnet function uses a GPU if one is available. Using a GPU requires a Parallel Computing Toolbox™ license and a supported GPU device. For information on supported devices, see GPU Computing Requirements (Parallel Computing Toolbox). Otherwise, the function uses the CPU. To select the execution environment manually, use the ExecutionEnvironment training option.
net = trainnet(XTrain,TTrain,layers,"mse",options);
Make predictions using the trained neural network with the test data.
YTest = minibatchpredict(net,XTest);
Compare the predicted values with the target values. Because the neural network has an inverse normalization layer, the predicted values do not fall in the normalized space.
figure scatter(YTest,TTest,"+") xlabel("Prediction") ylabel("Target")
Algorithms
Extended Capabilities
Version History
Introduced in R2026a
