Moose::LibtorchArtificialNeuralNet Class Reference

Simple feed-forward neural net with optional affine input and output scaling. More...

#include <LibtorchArtificialNeuralNet.h>

Inheritance diagram for Moose::LibtorchArtificialNeuralNet:

Public Member Functions
	LibtorchArtificialNeuralNet (const std::string name, const unsigned int num_inputs, const unsigned int num_outputs, const std::vector< unsigned int > &num_neurons_per_layer, const std::vector< std::string > &activation_function={"relu"}, const torch::DeviceType device_type=torch::kCPU, const torch::ScalarType scalar_type=torch::kDouble, const bool build_on_construct=true, const std::vector< Real > &input_shift_factors={}, const std::vector< Real > &input_scaling_factors={}, const std::vector< Real > &output_scaling_factors={})
	Build a plain feed-forward neural network.
	LibtorchArtificialNeuralNet (const Moose::LibtorchArtificialNeuralNet &nn, const bool build_on_construct=true)
	Copy-construct a feed-forward neural network.
virtual void	addLayer (const std::string &layer_name, const std::unordered_map< std::string, unsigned int > &parameters)
	Add one linear layer to the network.
virtual torch::Tensor	forward (const torch::Tensor &x) override
	Run a forward pass through the network.
const std::string &	name () const
	Return the name of the neural network.
unsigned int	numInputs () const
	Return the number of neurons on the input layer.
unsigned int	numOutputs () const
	Return the number of neurons on the output layer.
unsigned int	numHiddenLayers () const
	Return the number of hidden layers.
const std::vector< unsigned int > &	numNeuronsPerLayer () const
	Return the hidden layer architecture.
const MultiMooseEnum &	activationFunctions () const
	Return the multi enum containing the activation functions.
torch::DeviceType	deviceType () const
	Return the device used by this neural network.
torch::ScalarType	dataType () const
	Return the data type used by this neural network.
const std::vector< Real > &	inputShiftFactors () const
	Return the affine input shift factors used before evaluation.
const std::vector< Real > &	inputScalingFactors () const
	Return the affine input scaling factors used before evaluation.
const std::vector< Real > &	outputScalingFactors () const
	Return the output scaling factors applied after evaluation.
virtual void	constructNeuralNetwork ()
	Construct the neural network.
void	synchronizeAffineFactorsFromBuffers ()
	Update cached affine metadata vectors from the registered libtorch buffers.
Real	determineGain (const std::string &activation)
	Map an activation name to the orthogonal-initialization gain we want to use.
virtual void	initializeNeuralNetwork (c10::optional< at::Generator > generator=c10::nullopt)
	Initialize the trainable weights and biases.
void	store (nlohmann::json &json) const
	Store the network architecture in a JSON object for debugging or visualization.

Protected Member Functions
void	initializeAffineBuffers ()
	Initialize the registered affine metadata buffers used by serialization.
virtual torch::Tensor	preprocessInput (const torch::Tensor &x) const
	Apply affine preprocessing to the raw input tensor.
virtual torch::Tensor	scaleOutput (const torch::Tensor &y) const
	Apply the configured output scaling to a network output tensor.

Static Protected Member Functions
static std::vector< Real >	setAffineFactors (const std::vector< Real > &factors, unsigned int expected_size, Real default_value, const std::string &factor_name)
	Set affine metadata by either accepting the user values or filling defaults.

Protected Attributes
const std::string	_name
	Name of the neural network.
std::vector< torch::nn::Linear >	_weights
	Submodules that hold linear operations and the corresponding weights and biases (y = W * x + b)
const unsigned int	_num_inputs
	Number of neurons on the input layer.
const unsigned int	_num_outputs
	Number of neurons on the output layer.
const std::vector< unsigned int >	_num_neurons_per_layer
	Hidden layer architecture.
MultiMooseEnum	_activation_function
	Activation functions (either one for all hidden layers or one for every layer separately)
const torch::DeviceType	_device_type
	The device type used for this neural network.
const torch::ScalarType	_data_type
	The data type used in this neural network.
std::vector< Real >	_input_shift_factors
	Affine preprocessing applied to the flattened input.
std::vector< Real >	_input_scaling_factors
	Multiplicative affine preprocessing applied after shifting the input.
std::vector< Real >	_output_scaling_factors
	Multiplicative scaling applied after the network output is formed.
torch::Tensor	_input_shift_tensor
	Registered libtorch buffer holding the affine input shifts.
torch::Tensor	_input_scale_tensor
	Registered libtorch buffer holding the affine input scaling factors.
torch::Tensor	_output_scale_tensor
	Registered libtorch buffer holding the output scaling factors.

Detailed Description

Simple feed-forward neural net with optional affine input and output scaling.

Definition at line 29 of file LibtorchArtificialNeuralNet.h.

Constructor & Destructor Documentation

LibtorchArtificialNeuralNet() [1/2]

Moose::LibtorchArtificialNeuralNet::LibtorchArtificialNeuralNet	(	const std::string	name,
		const unsigned int	num_inputs,
		const unsigned int	num_outputs,
		const std::vector< unsigned int > &	num_neurons_per_layer,
		const std::vector< std::string > &	activation_function = {"relu"},
		const torch::DeviceType	device_type = torch::kCPU,
		const torch::ScalarType	scalar_type = torch::kDouble,
		const bool	build_on_construct = true,
		const std::vector< Real > &	input_shift_factors = {},
		const std::vector< Real > &	input_scaling_factors = {},
		const std::vector< Real > &	output_scaling_factors = {}
	)

Build a plain feed-forward neural network.

Parameters

name	Name of the neural network module.
num_inputs	Number of input neurons or parameters.
num_outputs	Number of output neurons.
num_neurons_per_layer	Hidden-layer widths.
activation_function	Hidden-layer activation names.
device_type	Torch device used by the module.
scalar_type	Torch scalar type used by the module.
build_on_construct	Whether to build the torch modules right away.
input_shift_factors	Optional affine input shifts.
input_scaling_factors	Optional affine input scales.
output_scaling_factors	Optional output scaling factors.

Definition at line 198 of file LibtorchArtificialNeuralNet.C.

  : _name(name),
    _num_inputs(num_inputs),
    _num_outputs(num_outputs),
    _num_neurons_per_layer(num_neurons_per_layer),
    _activation_function(MultiMooseEnum("relu sigmoid elu gelu linear tanh", "relu")),
    _device_type(device_type),
    _data_type(data_type),
    _input_shift_factors(
        setAffineFactors(input_shift_factors, num_inputs, 0.0, "input_shift_factors")),
    _input_scaling_factors(
        setAffineFactors(input_scaling_factors, num_inputs, 1.0, "input_scaling_factors")),
    _output_scaling_factors(
        setAffineFactors(output_scaling_factors, num_outputs, 1.0, "output_scaling_factors"))
{
  _activation_function = activation_function;
  initializeAffineBuffers();
 
  // Check if the number of activation functions matches the number of hidden layers
  if ((_activation_function.size() != 1) &&
      (_activation_function.size() != _num_neurons_per_layer.size()))
    mooseError("The number of activation functions should be either one or the same as the number "
               "of hidden layers");
 
  if (build_on_construct)
    constructNeuralNetwork();
}

LibtorchArtificialNeuralNet() [2/2]

Moose::LibtorchArtificialNeuralNet::LibtorchArtificialNeuralNet	(	const Moose::LibtorchArtificialNeuralNet &	nn,
		const bool	build_on_construct = true
	)

Copy-construct a feed-forward neural network.

Parameters

nn	Neural network to copy.
build_on_construct	Whether to rebuild the module structure during the copy.

Definition at line 237 of file LibtorchArtificialNeuralNet.C.

  : torch::nn::Module(),
    _name(nn.name()),
    _num_inputs(nn.numInputs()),
    _num_outputs(nn.numOutputs()),
    _num_neurons_per_layer(nn.numNeuronsPerLayer()),
    _activation_function(nn.activationFunctions()),
    _device_type(nn.deviceType()),
    _data_type(nn.dataType()),
    _input_shift_factors(nn.inputShiftFactors()),
    _input_scaling_factors(nn.inputScalingFactors()),
    _output_scaling_factors(nn.outputScalingFactors())
{
  initializeAffineBuffers();
 
  // We construct the NN architecture
  if (build_on_construct)
  {
    constructNeuralNetwork();
    // We fill it up with the current parameter values
    const auto & from_params = nn.named_parameters();
    auto to_params = this->named_parameters();
    for (unsigned int param_i : make_range(from_params.size()))
      to_params[param_i].value().data() = from_params[param_i].value().data().clone();
 
    const auto & from_buffers = nn.named_buffers();
    auto to_buffers = this->named_buffers();
    for (unsigned int buffer_i : make_range(from_buffers.size()))
      to_buffers[buffer_i].value().data() = from_buffers[buffer_i].value().data().clone();
  }
}

Member Function Documentation

activationFunctions()

const MultiMooseEnum & Moose::LibtorchArtificialNeuralNet::activationFunctions ( ) const

inline

Return the multi enum containing the activation functions.

Definition at line 103 of file LibtorchArtificialNeuralNet.h.

{ return _activation_function; }

addLayer()

void Moose::LibtorchArtificialNeuralNet::addLayer ( const std::string &  layer_name, const std::unordered_map< std::string, unsigned int > &  parameters  )

virtual

Add one linear layer to the network.

Parameters

layer_name	Name of the layer to add.
parameters	Small parameter map that describes the layer shape.

Definition at line 412 of file LibtorchArtificialNeuralNet.C.

{
  auto it = parameters.find("inp_neurons");
  if (it == parameters.end())
    ::mooseError("Number of input neurons not found during the construction of "
                 "LibtorchArtificialNeuralNet!");
  unsigned int inp_neurons = it->second;
 
  it = parameters.find("out_neurons");
  if (it == parameters.end())
    ::mooseError("Number of output neurons not found during the construction of "
                 "LibtorchArtificialNeuralNet!");
  unsigned int out_neurons = it->second;
 
  _weights.push_back(register_module(layer_name, torch::nn::Linear(inp_neurons, out_neurons)));
}

Referenced by constructNeuralNetwork().

constructNeuralNetwork()

void Moose::LibtorchArtificialNeuralNet::constructNeuralNetwork ( )

virtual

Construct the neural network.

Definition at line 346 of file LibtorchArtificialNeuralNet.C.

{
  // Adding hidden layers
  unsigned int inp_neurons = _num_inputs;
  for (unsigned int i = 0; i < numHiddenLayers(); ++i)
  {
    std::unordered_map<std::string, unsigned int> parameters = {
        {"inp_neurons", inp_neurons}, {"out_neurons", _num_neurons_per_layer[i]}};
    addLayer("hidden_layer_" + std::to_string(i + 1), parameters);
 
    // Necessary to retain double precision (and error-free runs)
    _weights[i]->to(_device_type, _data_type);
    inp_neurons = _num_neurons_per_layer[i];
  }
  // Adding output layer
  std::unordered_map<std::string, unsigned int> parameters = {{"inp_neurons", inp_neurons},
                                                              {"out_neurons", _num_outputs}};
  addLayer("output_layer_", parameters);
  _weights.back()->to(_device_type, _data_type);
}

Referenced by LibtorchArtificialNeuralNet(), and LibtorchArtificialNeuralNet().

dataType()

torch::ScalarType Moose::LibtorchArtificialNeuralNet::dataType ( ) const

inline

Return the data type used by this neural network.

Definition at line 111 of file LibtorchArtificialNeuralNet.h.

{ return _data_type; }

determineGain()

Real Moose::LibtorchArtificialNeuralNet::determineGain

(

const std::string &

activation

)

Map an activation name to the orthogonal-initialization gain we want to use.

Parameters

activation

Activation name to look up.

Definition at line 271 of file LibtorchArtificialNeuralNet.C.

{
  if (activation == "relu")
    return std::sqrt(2);
  if (activation == "tanh")
    return 5.0 / 3.0;
 
  return 1.0;
}

Referenced by initializeNeuralNetwork().

deviceType()

torch::DeviceType Moose::LibtorchArtificialNeuralNet::deviceType ( ) const

inline

Return the device used by this neural network.

Definition at line 107 of file LibtorchArtificialNeuralNet.h.

{ return _device_type; }

forward()

torch::Tensor Moose::LibtorchArtificialNeuralNet::forward ( const torch::Tensor &  x )

overridevirtual

Run a forward pass through the network.

Parameters

x	Input tensor for the evaluation.

Implements Moose::LibtorchNeuralNetBase.

Definition at line 386 of file LibtorchArtificialNeuralNet.C.

{
  torch::Tensor output = preprocessInput(x);
 
  for (unsigned int i = 0; i < _weights.size() - 1; ++i)
  {
    std::string activation =
        _activation_function.size() > 1 ? _activation_function[i] : _activation_function[0];
    if (activation == "relu")
      output = torch::relu(_weights[i]->forward(output));
    else if (activation == "sigmoid")
      output = torch::sigmoid(_weights[i]->forward(output));
    else if (activation == "tanh")
      output = torch::tanh(_weights[i]->forward(output));
    else if (activation == "elu")
      output = torch::elu(_weights[i]->forward(output));
    else if (activation == "gelu")
      output = torch::gelu(_weights[i]->forward(output));
    else if (activation == "linear")
      output = _weights[i]->forward(output);
  }
 
  return scaleOutput(_weights[_weights.size() - 1]->forward(output));
}

Referenced by forward().

initializeAffineBuffers()

void Moose::LibtorchArtificialNeuralNet::initializeAffineBuffers ( )

protected

Initialize the registered affine metadata buffers used by serialization.

Definition at line 313 of file LibtorchArtificialNeuralNet.C.

{
  auto input_shift = _input_shift_factors;
  LibtorchUtils::vectorToTensor(input_shift, _input_shift_tensor);
  _input_shift_tensor = register_buffer(
      "input_shift", _input_shift_tensor.transpose(0, 1).to(_data_type).to(_device_type));
 
  auto input_scale = _input_scaling_factors;
  LibtorchUtils::vectorToTensor(input_scale, _input_scale_tensor);
  _input_scale_tensor = register_buffer(
      "input_scale", _input_scale_tensor.transpose(0, 1).to(_data_type).to(_device_type));
 
  auto output_scale = _output_scaling_factors;
  LibtorchUtils::vectorToTensor(output_scale, _output_scale_tensor);
  _output_scale_tensor = register_buffer(
      "output_scale", _output_scale_tensor.transpose(0, 1).to(_data_type).to(_device_type));
}

Referenced by LibtorchArtificialNeuralNet(), and LibtorchArtificialNeuralNet().

initializeNeuralNetwork()

void Moose::LibtorchArtificialNeuralNet::initializeNeuralNetwork ( c10::optional< at::Generator >  generator = c10::nullopt )

virtual

Initialize the trainable weights and biases.

Parameters

generator

Optional torch random-number generator used for reproducible initialization.

Definition at line 282 of file LibtorchArtificialNeuralNet.C.

{
  for (const auto i : make_range(numHiddenLayers()))
  {
    const auto & activation =
        _activation_function.size() > 1 ? _activation_function[i] : _activation_function[0];
    const Real gain = determineGain(activation);
    Moose::orthogonalInitializeTensor(_weights[i]->weight, gain, generator);
    torch::nn::init::zeros_(_weights[i]->bias);
  }
 
  Moose::orthogonalInitializeTensor(_weights.back()->weight, 1.0, generator);
  torch::nn::init::zeros_(_weights.back()->bias);
}

inputScalingFactors()

const std::vector< Real > & Moose::LibtorchArtificialNeuralNet::inputScalingFactors ( ) const

inline

Return the affine input scaling factors used before evaluation.

Definition at line 119 of file LibtorchArtificialNeuralNet.h.

{ return _input_scaling_factors; }

inputShiftFactors()

const std::vector< Real > & Moose::LibtorchArtificialNeuralNet::inputShiftFactors ( ) const

inline

Return the affine input shift factors used before evaluation.

Definition at line 115 of file LibtorchArtificialNeuralNet.h.

{ return _input_shift_factors; }

name()

const std::string & Moose::LibtorchArtificialNeuralNet::name ( ) const

inline

Return the name of the neural network.

Definition at line 83 of file LibtorchArtificialNeuralNet.h.

{ return _name; }

numHiddenLayers()

unsigned int Moose::LibtorchArtificialNeuralNet::numHiddenLayers ( ) const

inline

Return the number of hidden layers.

Definition at line 95 of file LibtorchArtificialNeuralNet.h.

{ return _num_neurons_per_layer.size(); }

Referenced by constructNeuralNetwork(), and initializeNeuralNetwork().

numInputs()

unsigned int Moose::LibtorchArtificialNeuralNet::numInputs ( ) const

inline

Return the number of neurons on the input layer.

Definition at line 87 of file LibtorchArtificialNeuralNet.h.

{ return _num_inputs; }

numNeuronsPerLayer()

const std::vector< unsigned int > & Moose::LibtorchArtificialNeuralNet::numNeuronsPerLayer ( ) const

inline

Return the hidden layer architecture.

Definition at line 99 of file LibtorchArtificialNeuralNet.h.

{ return _num_neurons_per_layer; }

numOutputs()

unsigned int Moose::LibtorchArtificialNeuralNet::numOutputs ( ) const

inline

Return the number of neurons on the output layer.

Definition at line 91 of file LibtorchArtificialNeuralNet.h.

{ return _num_outputs; }

outputScalingFactors()

const std::vector< Real > & Moose::LibtorchArtificialNeuralNet::outputScalingFactors ( ) const

inline

Return the output scaling factors applied after evaluation.

Definition at line 123 of file LibtorchArtificialNeuralNet.h.

{ return _output_scaling_factors; }

preprocessInput()

torch::Tensor Moose::LibtorchArtificialNeuralNet::preprocessInput ( const torch::Tensor &  x ) const

protectedvirtual

Apply affine preprocessing to the raw input tensor.

Parameters

x	Raw input tensor.

Definition at line 368 of file LibtorchArtificialNeuralNet.C.

{
  torch::Tensor input(x);
  if (_data_type != input.scalar_type())
    input = input.to(_data_type);
  if (_device_type != input.device().type())
    input = input.to(_device_type);
 
  return (input - _input_shift_tensor) * _input_scale_tensor;
}

Referenced by forward().

scaleOutput()

torch::Tensor Moose::LibtorchArtificialNeuralNet::scaleOutput ( const torch::Tensor &  y ) const

protectedvirtual

Apply the configured output scaling to a network output tensor.

Parameters

y	Raw network output tensor.

Definition at line 380 of file LibtorchArtificialNeuralNet.C.

{
  return y * _output_scale_tensor;
}

Referenced by forward().

setAffineFactors()

std::vector< Real > Moose::LibtorchArtificialNeuralNet::setAffineFactors ( const std::vector< Real > &  factors, unsigned int  expected_size, Real  default_value, const std::string &  factor_name  )

staticprotected

Set affine metadata by either accepting the user values or filling defaults.

Parameters

factors	User-provided affine factors.
expected_size	Expected number of entries.
default_value	Default value used when the vector is empty.
factor_name	Name used in error messages.

Definition at line 298 of file LibtorchArtificialNeuralNet.C.

{
  const auto resolved_factors =
      factors.empty() ? std::vector<Real>(expected_size, default_value) : factors;
 
  if (resolved_factors.size() != expected_size)
    mooseError("The number of ", factor_name, " entries must match ", expected_size, ".");
 
  return resolved_factors;
}

store()

void Moose::LibtorchArtificialNeuralNet::store

(

nlohmann::json &

json

)

const

Store the network architecture in a JSON object for debugging or visualization.

Parameters

json	JSON object that receives the network architecture.

Definition at line 432 of file LibtorchArtificialNeuralNet.C.

{
  const auto & named_params = this->named_parameters();
  for (const auto & param_i : make_range(named_params.size()))
  {
    // We cast the parameters into a 1D vector
    json[named_params[param_i].key()] = std::vector<Real>(
        named_params[param_i].value().data_ptr<Real>(),
        named_params[param_i].value().data_ptr<Real>() + named_params[param_i].value().numel());
  }
 
  json["input_shift_factors"] = _input_shift_factors;
  json["input_scaling_factors"] = _input_scaling_factors;
  json["output_scaling_factors"] = _output_scaling_factors;
}

Referenced by Moose::to_json().

synchronizeAffineFactorsFromBuffers()

void Moose::LibtorchArtificialNeuralNet::synchronizeAffineFactorsFromBuffers

(

)

Update cached affine metadata vectors from the registered libtorch buffers.

Definition at line 332 of file LibtorchArtificialNeuralNet.C.

{
  auto input_shift = _input_shift_tensor.detach().reshape({-1}).to(torch::kCPU).to(torch::kDouble);
  LibtorchUtils::tensorToVector(input_shift, _input_shift_factors);
 
  auto input_scale = _input_scale_tensor.detach().reshape({-1}).to(torch::kCPU).to(torch::kDouble);
  LibtorchUtils::tensorToVector(input_scale, _input_scaling_factors);
 
  auto output_scale =
      _output_scale_tensor.detach().reshape({-1}).to(torch::kCPU).to(torch::kDouble);
  LibtorchUtils::tensorToVector(output_scale, _output_scaling_factors);
}

Member Data Documentation

_activation_function

MultiMooseEnum Moose::LibtorchArtificialNeuralNet::_activation_function

protected

Activation functions (either one for all hidden layers or one for every layer separately)

Definition at line 195 of file LibtorchArtificialNeuralNet.h.

Referenced by activationFunctions(), forward(), initializeNeuralNetwork(), and LibtorchArtificialNeuralNet().

_data_type

const torch::ScalarType Moose::LibtorchArtificialNeuralNet::_data_type

protected

The data type used in this neural network.

Definition at line 199 of file LibtorchArtificialNeuralNet.h.

Referenced by constructNeuralNetwork(), dataType(), initializeAffineBuffers(), and preprocessInput().

_device_type

const torch::DeviceType Moose::LibtorchArtificialNeuralNet::_device_type

protected

The device type used for this neural network.

Definition at line 197 of file LibtorchArtificialNeuralNet.h.

Referenced by constructNeuralNetwork(), deviceType(), initializeAffineBuffers(), and preprocessInput().

_input_scale_tensor

torch::Tensor Moose::LibtorchArtificialNeuralNet::_input_scale_tensor

protected

Registered libtorch buffer holding the affine input scaling factors.

Definition at line 209 of file LibtorchArtificialNeuralNet.h.

Referenced by initializeAffineBuffers(), preprocessInput(), and synchronizeAffineFactorsFromBuffers().

_input_scaling_factors

std::vector<Real> Moose::LibtorchArtificialNeuralNet::_input_scaling_factors

protected

Multiplicative affine preprocessing applied after shifting the input.

Definition at line 203 of file LibtorchArtificialNeuralNet.h.

Referenced by initializeAffineBuffers(), inputScalingFactors(), store(), and synchronizeAffineFactorsFromBuffers().

_input_shift_factors

std::vector<Real> Moose::LibtorchArtificialNeuralNet::_input_shift_factors

protected

Affine preprocessing applied to the flattened input.

Definition at line 201 of file LibtorchArtificialNeuralNet.h.

Referenced by initializeAffineBuffers(), inputShiftFactors(), store(), and synchronizeAffineFactorsFromBuffers().

_input_shift_tensor

torch::Tensor Moose::LibtorchArtificialNeuralNet::_input_shift_tensor

protected

Registered libtorch buffer holding the affine input shifts.

Definition at line 207 of file LibtorchArtificialNeuralNet.h.

Referenced by initializeAffineBuffers(), preprocessInput(), and synchronizeAffineFactorsFromBuffers().

_name

const std::string Moose::LibtorchArtificialNeuralNet::_name

protected

Name of the neural network.

Definition at line 183 of file LibtorchArtificialNeuralNet.h.

Referenced by name().

_num_inputs

const unsigned int Moose::LibtorchArtificialNeuralNet::_num_inputs

protected

Number of neurons on the input layer.

Definition at line 188 of file LibtorchArtificialNeuralNet.h.

Referenced by constructNeuralNetwork(), and numInputs().

_num_neurons_per_layer

const std::vector<unsigned int> Moose::LibtorchArtificialNeuralNet::_num_neurons_per_layer

protected

Hidden layer architecture.

Definition at line 192 of file LibtorchArtificialNeuralNet.h.

Referenced by constructNeuralNetwork(), LibtorchArtificialNeuralNet(), numHiddenLayers(), and numNeuronsPerLayer().

_num_outputs

const unsigned int Moose::LibtorchArtificialNeuralNet::_num_outputs

protected

Number of neurons on the output layer.

Definition at line 190 of file LibtorchArtificialNeuralNet.h.

Referenced by constructNeuralNetwork(), and numOutputs().

_output_scale_tensor

torch::Tensor Moose::LibtorchArtificialNeuralNet::_output_scale_tensor

protected

Registered libtorch buffer holding the output scaling factors.

Definition at line 211 of file LibtorchArtificialNeuralNet.h.

Referenced by initializeAffineBuffers(), scaleOutput(), and synchronizeAffineFactorsFromBuffers().

_output_scaling_factors

std::vector<Real> Moose::LibtorchArtificialNeuralNet::_output_scaling_factors

protected

Multiplicative scaling applied after the network output is formed.

Definition at line 205 of file LibtorchArtificialNeuralNet.h.

Referenced by initializeAffineBuffers(), outputScalingFactors(), store(), and synchronizeAffineFactorsFromBuffers().

_weights

std::vector<torch::nn::Linear> Moose::LibtorchArtificialNeuralNet::_weights

protected

Submodules that hold linear operations and the corresponding weights and biases (y = W * x + b)

Definition at line 186 of file LibtorchArtificialNeuralNet.h.

Referenced by addLayer(), constructNeuralNetwork(), forward(), and initializeNeuralNetwork().

---

The documentation for this class was generated from the following files:

• include/libtorch/utils/LibtorchArtificialNeuralNet.h
• src/libtorch/utils/LibtorchArtificialNeuralNet.C