opennn Namespace Reference

Namespaces
namespace	opennn
namespace	profiler

Classes
struct	__half
struct	__nv_bfloat16
struct	Activation
class	AdaptiveMomentEstimation
	Adam optimizer (Kingma & Ba, 2014). More...
struct	Add
class	Addition
	Elementwise tensor addition layer (residual / skip connections). More...
class	ApproximationNetwork
	Standard regression (function approximation) MLP. More...
struct	Attention
struct	AugmentationSettings
	Optional data-augmentation transforms applied at training time. More...
class	AutoAssociationNetwork
	Standard auto-encoder for outlier and novelty detection. More...
class	Backend
struct	BackPropagation
struct	BackPropagationLM
	Scratch state used by LevenbergMarquardtAlgorithm. More...
struct	BackwardEdge
struct	Batch
	Owns the host-side and (optional) device-side buffers for one mini-batch of dataset samples. More...
struct	BatchNorm
struct	Bound
class	Bounding
	Per-feature output-clamping layer. More...
struct	BoxPlot
struct	Buffer
class	ClassificationNetwork
	Standard tabular classification MLP. More...
struct	Combination
class	Configuration
struct	Convolution
class	Convolutional
	2D convolutional layer: y = activation(BN(conv(x, kernels) + bias)). More...
class	ConvolutionalRelu
	2D convolution + ReLU fused into a single forward op on GPU. More...
struct	Correlation
struct	cudnnTensorStruct
class	Dataset
	Base data container with samples, variables and per-variable metadata. More...
class	Dense
	Fully-connected layer: y = activation(BN(x * W + b)) with optional dropout. More...
class	DenseRelu
	Dense + ReLU fused into a single forward op. More...
struct	Descriptives
struct	Dropout
class	Embedding
	Token-id-to-vector lookup layer used in language models. More...
struct	EmbeddingLookup
struct	EnumMap
struct	EpochStats
	Aggregate metrics produced for a single training or evaluation epoch. More...
struct	Flat
class	Flatten
	Reshape layer that collapses every input axis into a single feature axis. More...
class	ForecastingNetwork
	Standard time-series forecasting MLP. More...
struct	ForwardPropagation
class	GeneticAlgorithm
	Genetic-algorithm based input feature selection. More...
class	GrowingInputs
	Forward-selection of input features driven by feature-target correlation. More...
class	GrowingNeurons
	Forward-selection of hidden-layer size. More...
struct	Histogram
class	ImageClassificationNetwork
	Standard convolutional image classifier. More...
class	ImageDataset
	Dataset specialization for image data. More...
class	InputsSelection
	Abstract base class for input feature selection methods. More...
struct	InputsSelectionResults
	Outcome of an InputsSelection run. More...
class	Json
class	JsonDocument
class	JsonWriter
class	KMeans
class	LanguageDataset
	Dataset specialization for tokenized text. More...
class	Layer
	Abstract base class for every layer in an OpenNN NeuralNetwork. More...
struct	LayerNorm
class	LevenbergMarquardtAlgorithm
	Levenberg-Marquardt optimizer with adaptive damping. More...
class	Loss
	Trainable loss function attached to a NeuralNetwork and a Dataset. More...
class	ModelExpression
class	ModelSelection
	Searches for the best generalizing architecture for a model. More...
class	MultiHeadAttention
	Scaled dot-product attention with multiple heads and learned linear projections. More...
struct	MultiHeadProjection
class	NeuralNetwork
	Stack of Layers forming a trainable model. More...
class	NeuronSelection
	Abstract base class for hidden-layer-size selection methods. More...
struct	NeuronsSelectionResults
	Outcome of a NeuronSelection run. More...
class	Normalization3d
	Layer normalization across the embedding dimension of rank-2 inputs. More...
struct	Operator
class	Optimizer
	Abstract base class for every training algorithm in OpenNN. More...
struct	OptimizerData
	Per-optimizer scratch state shared across iterations. More...
struct	Pool
struct	Pool3d
class	Pooling
	2D pooling layer (max or average). More...
class	Pooling3d
	Sequence-pooling layer for rank-2 inputs (sequence_length, features). More...
class	QuasiNewtonMethod
	BFGS quasi-Newton optimizer with line search. More...
class	Recurrent
	Plain (Elman-style) recurrent layer over fixed-length sequences. More...
class	Registry
class	ResponseOptimization
struct	Scale
class	Scaling
	Per-feature input normalization layer. More...
struct	Shape
class	SimpleResNet
	Compact residual network for image classification. More...
class	StochasticGradientDescent
	Mini-batch SGD with optional momentum, Nesterov acceleration and learning-rate decay. More...
class	TabularDataset
struct	TensorView
class	TestingAnalysis
	Computes diagnostic metrics for a trained network on testing data. More...
class	TextClassificationNetwork
	Standard text classification model. More...
class	ThreadSafeQueue
class	TimeSeriesDataset
	Dataset specialization for time series with explicit past / future windows. More...
struct	TrainingResults
	Per-epoch error history and final summary produced by Optimizer::train(). More...
class	TrainingStrategy
	Coordinates the training of a NeuralNetwork on a Dataset. More...
class	Transformer
	Encoder-decoder Transformer (Vaswani et al., 2017) for sequence-to-sequence modeling. More...
struct	TypeInfo
struct	TypeInfo< Type::BF16 >
struct	TypeInfo< Type::FP32 >
struct	TypeInfo< Type::INT8 >
struct	Unscale
class	Unscaling
	Per-output inverse normalization layer. More...
struct	Variable
class	VGG16
	VGG-16 architecture (Simonyan & Zisserman, 2014) for image classification. More...

Typedefs
using	cudaStream_t = void*
using	cudaEvent_t = void*
using	cublasHandle_t = void*
using	cublasLtHandle_t = void*
using	cudnnHandle_t = void*
using	cudnnTensorDescriptor_t = cudnnTensorStruct*
using	cudnnFilterDescriptor_t = void*
using	cudnnConvolutionDescriptor_t = void*
using	cudnnPoolingDescriptor_t = void*
using	cudnnActivationDescriptor_t = void*
using	cudnnDropoutDescriptor_t = void*
using	cudnnOpTensorDescriptor_t = void*
using	MatrixR = Matrix<float, Dynamic, Dynamic, Layout>
using	MatrixI = Matrix<Index, Dynamic, Dynamic, Layout>
using	MatrixB = Matrix<bool, Dynamic, Dynamic, Layout>
using	VectorR = Matrix<float, Dynamic, 1>
using	VectorI = Matrix<Index, Dynamic, 1>
using	VectorB = Matrix<bool, Dynamic, 1>
using	VectorMap = Map<VectorR, AlignedMax>
using	MatrixMap = Map<MatrixR, Layout | AlignedMax>
using	Tensor0 = Tensor<float, 0, Layout | AlignedMax>
using	Tensor2 = Tensor<float, 2, Layout | AlignedMax>
using	Tensor3 = Tensor<float, 3, Layout | AlignedMax>
using	Tensor4 = Tensor<float, 4, Layout | AlignedMax>
template<int Rank>
using	TensorR = Tensor<float, Rank, Layout | AlignedMax>
using	TensorMap2 = TensorMap<Tensor<float, 2, Layout | AlignedMax>, AlignedMax>
using	TensorMap3 = TensorMap<Tensor<float, 3, Layout | AlignedMax>, AlignedMax>
using	TensorMap4 = TensorMap<Tensor<float, 4, Layout | AlignedMax>, AlignedMax>
template<int Rank>
using	TensorMapR = TensorMap<Tensor<float, Rank, Layout | AlignedMax>, AlignedMax>
template<typename T, size_t N>
using	array = Eigen::array<T, N>

Enumerations
enum class	Device { Auto , CPU , CUDA }
enum class	Type { Auto , FP32 , BF16 , INT8 }
enum class	SampleRole { Training , Validation , Testing , None }
	Role of a sample within a dataset partition. More...
enum class	LayerType {   Addition , Bounding , Convolutional , ConvolutionalRelu ,   Dense , DenseRelu , Embedding , Flatten ,   MultiHeadAttention , Normalization3d , Pooling , Pooling3d ,   Recurrent , Scaling , Unscaling }
	Identifier for every concrete Layer subclass supported by OpenNN. More...
enum	cudaDataType_t {   CUDA_R_32F = 0 , CUDA_R_16F = 2 , CUDA_R_8I = 3 , CUDA_R_32I = 10 ,   CUDA_R_16BF = 14 }
enum	cublasComputeType_t { CUBLAS_COMPUTE_32F = 0 , CUBLAS_COMPUTE_32F_FAST_16BF = 65 , CUBLAS_COMPUTE_32F_FAST_TF32 = 68 }
enum	cublasOperation_t { CUBLAS_OP_N = 0 , CUBLAS_OP_T = 1 }
enum	cublasLtEpilogue_t { CUBLASLT_EPILOGUE_DEFAULT = 1 , CUBLASLT_EPILOGUE_BIAS = 4 , CUBLASLT_EPILOGUE_RELU_BIAS = 132 }
enum	cudnnDataType_t {   CUDNN_DATA_FLOAT = 0 , CUDNN_DATA_HALF = 2 , CUDNN_DATA_INT8 = 3 , CUDNN_DATA_INT32 = 4 ,   CUDNN_DATA_BFLOAT16 = 14 }
enum	cudnnActivationMode_t {   CUDNN_ACTIVATION_IDENTITY = 0 , CUDNN_ACTIVATION_SIGMOID = 1 , CUDNN_ACTIVATION_RELU = 2 , CUDNN_ACTIVATION_TANH = 3 ,   CUDNN_ACTIVATION_ELU = 4 }
enum	cudnnPoolingMode_t { CUDNN_POOLING_MAX = 0 }
enum	cudnnBatchNormMode_t { CUDNN_BATCHNORM_PER_ACTIVATION = 0 }
enum	cudnnConvolutionFwdAlgo_t { CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM = 0 }
enum	cudnnConvolutionBwdDataAlgo_t { CUDNN_CONVOLUTION_BWD_DATA_ALGO_0 = 0 }
enum	cudnnConvolutionBwdFilterAlgo_t { CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0 = 0 }
enum class	PoolingMethod { MaxPooling , AveragePooling }
	Reduction strategy applied within each pooling window. More...
enum	DateFormat { AUTO , DMY , MDY , YMD }
enum class	VariableType {   None , Numeric , Binary , Categorical ,   DateTime , Constant }
enum class	ScalerMethod {   None , MinimumMaximum , MeanStandardDeviation , StandardDeviation ,   Logarithm , ImageMinMax }
enum class	VariableRole {   None , Input , Target , Decoder ,   InputTarget , Time }

Functions
template<Type... Supported, typename F>
void	visit_type (Type t, F &&f)
template<Type... Supported, typename F>
void	visit_type_pair (Type t_in, Type t_out, F &&f)
cudnnDataType_t	to_cudnn (Type type) noexcept
cudaDataType_t	to_cuda (Type type) noexcept
Index	type_bytes (Type type) noexcept
Correlation	linear_correlation (const VectorR &, const VectorR &)
Correlation	logarithmic_correlation (const VectorR &, const VectorR &)
Correlation	exponential_correlation (const VectorR &, const VectorR &)
Correlation	power_correlation (const VectorR &, const VectorR &)
Correlation	logistic_correlation (const VectorR &, const VectorR &)
Correlation	logistic_correlation (const VectorR &, const MatrixR &)
Correlation	logistic_correlation (const MatrixR &, const VectorR &)
Correlation	logistic_correlation (const MatrixR &, const MatrixR &)
Correlation	point_biserial_correlation (const VectorR &, const VectorR &)
Correlation	eta_squared_correlation (const VectorR &, const MatrixR &)
Correlation	correlation (const MatrixR &, const MatrixR &)
Correlation	linear_correlation_spearman (const VectorR &, const VectorR &)
VectorR	calculate_spearman_ranks (const VectorR &)
Correlation	logistic_correlation_spearman (const VectorR &, const VectorR &)
Correlation	correlation_spearman (const MatrixR &, const MatrixR &)
float	r_correlation_to_z_correlation (const float)
float	z_correlation_to_r_correlation (const float)
pair< float, float >	confidence_interval_z_correlation (const float, Index)
VectorR	autocorrelations (const VectorR &, Index=10)
VectorR	cross_correlations (const VectorR &, const VectorR &, Index)
MatrixR	get_correlation_values (const Tensor< Correlation, 2 > &)
const EnumMap< SampleRole > &	sample_role_map ()
	Returns the string<->enum mapping for SampleRole values.
const string &	sample_role_to_string (SampleRole role)
	Converts a SampleRole to its canonical string name.
SampleRole	string_to_sample_role (const string &name)
	Parses a SampleRole from string.
void	mean_squared_error (const TensorView &input, const TensorView &target, float &error, float *workspace_device)
void	mean_squared_error_gradient (const TensorView &input, const TensorView &target, TensorView &input_delta)
void	normalized_squared_error (const TensorView &input, const TensorView &target, float coefficient, float &error, float *workspace_device)
void	normalized_squared_error_gradient (const TensorView &input, const TensorView &target, float coefficient, TensorView &input_delta)
void	weighted_squared_error (const TensorView &input, const TensorView &target, float pos_w, float neg_w, float &error, float *workspace_device)
void	weighted_squared_error_gradient (const TensorView &input, const TensorView &target, float pos_w, float neg_w, float coefficient, TensorView &input_delta)
void	binary_cross_entropy (const TensorView &input, const TensorView &target, float &error, float *workspace_device)
void	categorical_cross_entropy (const TensorView &input, const TensorView &target, float &error, float *workspace_device)
void	cross_entropy_gradient (const TensorView &input, const TensorView &target, TensorView &input_delta)
void	minkowski_error (const TensorView &input, const TensorView &target, float power, float &error, float *workspace_device)
void	minkowski_error_gradient (const TensorView &input, const TensorView &target, float power, TensorView &input_delta)
void	cross_entropy_3d (const TensorView &input, const TensorView &target, float &error, Index &active_tokens_out, Index &correct_tokens_out, float *errors_device=nullptr)
void	cross_entropy_3d_gradient (const TensorView &input, const TensorView &target, TensorView &input_delta, Index active_tokens_count)
void	l1_regularization (const TensorView &parameters, float lambda, float &penalty)
void	l1_regularization_gradient (const TensorView &parameters, float lambda, TensorView &gradient)
void	l2_regularization (const TensorView &parameters, float lambda, float &penalty)
void	l2_regularization_gradient (const TensorView &parameters, float lambda, TensorView &gradient)
Tensor3	load_image (const filesystem::path &)
Tensor3	resize_image (const Tensor3 &, Index, Index)
void	reflect_image_horizontal (Tensor3 &)
void	reflect_image_vertical (Tensor3 &)
void	rotate_image (const Tensor3 &, Tensor3 &, float)
void	translate_image_x (const Tensor3 &, Tensor3 &, Index)
void	translate_image_y (const Tensor3 &, Tensor3 &, Index)
void	add_json_field (JsonWriter &writer, const std::string &name, const std::string &value)
void	write_json (JsonWriter &writer, std::initializer_list< std::pair< const char *, std::string > > props)
float	read_json_type (const Json *root, const std::string &field)
long	read_json_index (const Json *root, const std::string &field)
bool	read_json_bool (const Json *root, const std::string &field)
std::string	read_json_string (const Json *root, const std::string &field)
std::string	read_json_string_fallback (const Json *root, std::initializer_list< std::string > names)
const Json *	require_json_field (const Json *root, const std::string &field)
template<typename Func>
void	for_json_items (const Json *parent, const char *tag, long count, Func func)
JsonDocument	load_json_file (const std::filesystem::path &file_name)
const Json *	get_json_root (const JsonDocument &document, const std::string &tag)
const EnumMap< LayerType > &	layer_type_map ()
	Returns the singleton string<->enum mapping for LayerType values.
const string &	layer_type_to_string (LayerType type)
	Converts a LayerType to its canonical string name.
LayerType	string_to_layer_type (const string &name)
	Parses a LayerType from its canonical string name.
vector< Shape >	spec_shapes (const vector< pair< Shape, Type > > &specs)
	Extracts the shape component from a list of (Shape, Type) specs.
vector< Type >	spec_dtypes (const vector< pair< Shape, Type > > &specs)
	Extracts the dtype component from a list of (Shape, Type) specs.
void	pad (const TensorView &input, TensorView &output)
void	bound (const TensorView &input, const TensorView &lower_bounds, const TensorView &upper_bounds, TensorView &output)
void	bound_cpu (const TensorView &input, const TensorView &lower_bounds, const TensorView &upper_bounds, TensorView &output)
void	scale (const TensorView &input, const TensorView &minimums, const TensorView &maximums, const TensorView &means, const TensorView &standard_deviations, const TensorView &scalers, float min_range, float max_range, TensorView &output)
void	scale_cpu (const TensorView &input, const TensorView &minimums, const TensorView &maximums, const TensorView &means, const TensorView &standard_deviations, const TensorView &scalers, float min_range, float max_range, TensorView &output)
void	unscale (const TensorView &input, const TensorView &minimums, const TensorView &maximums, const TensorView &means, const TensorView &standard_deviations, const TensorView &scalers, float min_range, float max_range, TensorView &output)
void	unscale_cpu (const TensorView &input, const TensorView &minimums, const TensorView &maximums, const TensorView &means, const TensorView &standard_deviations, const TensorView &scalers, float min_range, float max_range, TensorView &output)
void	copy (const TensorView &source, TensorView &destination)
void	copy_cpu (const TensorView &source, TensorView &destination)
void	add (const TensorView &input_1, const TensorView &input_2, TensorView &output)
void	add_cpu (const TensorView &input_1, const TensorView &input_2, TensorView &output)
void	multiply (const TensorView &input_a, bool transpose_a, const TensorView &input_b, bool transpose_b, TensorView &output, float alpha=1.0f, float beta=0.0f)
void	multiply_cpu (const TensorView &input_a, bool transpose_a, const TensorView &input_b, bool transpose_b, TensorView &output, float alpha=1.0f, float beta=0.0f)
void	softmax (TensorView &output)
void	softmax_cpu (TensorView &output)
void	max_pooling_3d_forward (const TensorView &input, TensorView &output, TensorView &maximal_indices, bool is_training)
void	max_pooling_3d_forward_cpu (const TensorView &input, TensorView &output, TensorView &maximal_indices, bool is_training)
void	average_pooling_3d_forward (const TensorView &input, TensorView &output)
void	average_pooling_3d_forward_cpu (const TensorView &input, TensorView &output)
void	max_pooling_3d_backward (const TensorView &maximal_indices, const TensorView &output_delta, TensorView &input_delta)
void	max_pooling_3d_backward_cpu (const TensorView &maximal_indices, const TensorView &output_delta, TensorView &input_delta)
void	average_pooling_3d_backward (const TensorView &input, const TensorView &output_delta, TensorView &input_delta)
void	average_pooling_3d_backward_cpu (const TensorView &input, const TensorView &output_delta, TensorView &input_delta)
void	split_heads (const TensorView &source, TensorView &destination)
void	split_heads_cpu (const TensorView &source, TensorView &destination)
void	merge_heads (const TensorView &source, TensorView &destination)
void	merge_heads_cpu (const TensorView &source, TensorView &destination)
void	sort_string_vector (vector< string > &)
vector< string >	concatenate_string_vectors (const vector< string > &, const vector< string > &)
string	formatNumber (float, int)
float	round_to_precision (float, const int &)
template<typename T>
ostream &	operator<< (ostream &os, const vector< T > &vec)
const string &	pooling_method_to_string (PoolingMethod method)
	Converts a PoolingMethod to its canonical string name.
PoolingMethod	string_to_pooling_method (const string &name)
	Parses a PoolingMethod from its canonical string name.
void	set_seed (unsigned seed)
long long	get_seed ()
float	random_uniform (float=-1, float=1)
Index	random_integer (Index, Index)
bool	random_bool (float=0.5)
void	set_random_uniform (MatrixR &, float=-0.1, float=0.1)
void	set_random_uniform (VectorMap, float=-0.1, float=0.1)
void	set_random_normal (MatrixMap, float=0, float=1)
void	set_random_integer (MatrixR &, Index, Index)
void	shuffle (VectorB &vector_to_shuffle)
template<typename T>
void	shuffle_vector (vector< T > &)
void	shuffle_vector_blocks (vector< Index > &, size_t=20)
Index	get_random_element (const vector< Index > &)
void	register_classes ()
void	scale_mean_standard_deviation (MatrixMap, Index, const Descriptives &)
void	scale_standard_deviation (MatrixMap, Index, const Descriptives &)
void	scale_minimum_maximum (MatrixMap, Index, const Descriptives &, float=-1.0f, float=1.0f)
void	scale_logarithmic (MatrixMap, Index)
void	unscale_minimum_maximum (MatrixMap, Index, const Descriptives &, float=-1.0f, float=1.0f)
void	unscale_mean_standard_deviation (MatrixMap, Index, const Descriptives &)
void	unscale_standard_deviation (MatrixMap, Index, const Descriptives &)
void	unscale_logarithmic (MatrixMap, Index)
void	unscale_image_minimum_maximum (MatrixMap, Index)
float	minimum (const MatrixR &)
float	minimum (const VectorR &)
float	minimum (const VectorR &, const vector< Index > &)
VectorR	column_minimums (const Tensor2 &, const vector< Index > &=vector< Index >(), const vector< Index > &=vector< Index >())
float	maximum (const MatrixR &)
float	maximum (const VectorR &)
float	maximum (const VectorR &, const vector< Index > &)
VectorR	column_maximums (const Tensor2 &, const vector< Index > &=vector< Index >(), const vector< Index > &=vector< Index >())
float	range (const VectorR &)
float	mean (const VectorR &)
float	mean (const MatrixR &, Index)
VectorR	mean (const MatrixR &)
VectorR	mean (const MatrixR &, const vector< Index > &, const vector< Index > &)
float	median (const VectorR &)
float	median (const MatrixR &, Index)
VectorR	median (const MatrixR &)
VectorR	median (const MatrixR &, const vector< Index > &)
VectorR	median (const MatrixR &, const vector< Index > &, const vector< Index > &)
float	variance (const VectorR &)
float	variance (const VectorR &, const VectorI &)
float	standard_deviation (const VectorR &)
VectorR	standard_deviation (const VectorR &, Index)
VectorR	quartiles (const VectorR &)
VectorR	quartiles (const VectorR &, const vector< Index > &)
BoxPlot	box_plot (const VectorR &)
BoxPlot	box_plot (const VectorR &, const vector< Index > &)
Descriptives	vector_descriptives (const VectorR &)
vector< Descriptives >	descriptives (const MatrixR &)
vector< Descriptives >	descriptives (const MatrixR &, const vector< Index > &, const vector< Index > &)
Histogram	histogram (const VectorR &, Index=10)
Histogram	histogram_centered (const VectorR &, float=0.0f, Index=10)
Histogram	histogram (const VectorB &)
Histogram	histogram (const VectorI &, Index=10)
vector< Histogram >	histograms (const MatrixR &, Index=10)
VectorI	total_frequencies (const vector< Histogram > &)
Index	minimal_index (const VectorR &)
VectorI	minimal_indices (const VectorR &, Index)
VectorI	minimal_indices (const MatrixR &)
Index	maximal_index (const VectorR &)
VectorI	maximal_indices (const VectorR &, Index)
VectorI	maximal_indices (const MatrixR &)
bool	row_finite (const VectorR &values, Index i)
bool	row_finite (const MatrixR &matrix, Index i)
VectorR	slice_rows (const VectorR &values, const vector< Index > &indices)
MatrixR	slice_rows (const MatrixR &matrix, const vector< Index > &indices)
VectorR	filter_missing_values (const VectorR &)
template<typename X, typename Y>
pair< X, Y >	filter_missing_values (const X &x, const Y &y)
void	shuffle_rows (MatrixR &matrix)
bool	is_contiguous (const vector< Index > &indices)
template<typename T>
bool	is_binary (const T &tensor)
MatrixR	append_rows (const MatrixR &, const MatrixR &)
template<typename T>
vector< T >	gather_by_index (const vector< T > &data, const vector< Index > &indices)
vector< Index >	build_feasible_rows_mask (const MatrixR &outputs, const VectorR &minimums, const VectorR &maximums)
template<typename T>
bool	is_constant (const T &tensor)
vector< Index >	get_true_indices (const VectorB &flags)
VectorI	calculate_rank (const VectorR &, bool ascending=true)
vector< Index >	get_elements_greater_than (const vector< Index > &, Index)
VectorI	get_nearest_points (const MatrixR &, const VectorR &, int=1)
void	fill_tensor_data (const MatrixR &, const vector< Index > &, const vector< Index > &, float *, bool=true, int contiguous=-1)
VectorR	perform_Householder_QR_decomposition (const MatrixR &, const VectorR &)
VectorMap	vector_map (const MatrixR &, Index)
void	prepare_line (string &)
Index	count_non_empty_lines (const filesystem::path &)
Index	count_tokens (const string &, const string &)
vector< string >	get_tokens (const string &, const string &)
vector< string >	tokenize (const string &)
vector< string >	convert_string_vector (const vector< vector< string > > &, const string &)
VectorR	to_type_vector (const string &, const string &)
bool	is_numeric_string (const string &)
bool	is_date_time_string (const string &)
time_t	date_to_timestamp (const string &, Index=0, const DateFormat &format=AUTO)
void	replace_all_appearances (string &, const string &, const string &)
void	replace_all_word_appearances (string &, const string &, const string &)
void	trim (string &)
void	normalize_csv_line (string &)
void	erase (string &, char)
void	replace_first_and_last_char_with_missing_label (string &, char, const string &, const string &)
string	get_trimmed (const string &)
bool	has_numbers (const vector< string > &)
void	replace (string &, const string &, const string &)
void	replace_double_char_with_label (string &, const string &, const string &)
void	replace_substring_within_quotes (string &, const string &, const string &)
void	display_progress_bar (const int &, const int &)
string	get_time (float)
string	get_first_word (const string &)
template<typename T>
string	vector_to_string (const vector< T > &values, const string &separator=" ")
template<typename Derived>
string	vector_to_string (const Eigen::DenseBase< Derived > &values, const string &separator=" ")
void	string_to_vector (const string &input, VectorR &values)
template<typename T, size_t Rank>
string	tensor_to_string (const TensorR< Rank > &values, const string &separator=" ")
template<typename T, size_t Rank>
void	string_to_tensor (const string &input, TensorR< Rank > &values)
bool	contains (const vector< string > &, const string &)
int	to_int (Index value)
float	to_type (Index value)
Index	align_up (Index value, Index alignment)
Index	get_aligned_size (Index size)
Index	get_aligned_bytes (Index n_bytes)
template<typename Container>
Index	ssize (const Container &container) noexcept
bool	is_aligned (const void *ptr)
Index	aligned_total_elements (const vector< Shape > &shapes)
Index	aligned_total_elements (const vector< vector< Shape > > &nested)
Index	aligned_total_bytes (const vector< Shape > &shapes, const vector< Type > &dtypes)
Index	aligned_total_bytes (const vector< vector< Shape > > &nested, const vector< vector< Type > > &dtypes)
Index	aligned_total_bytes (const vector< Shape > &shapes, Type dtype)
string	shape_to_string (const Shape &, const string &=" ")
Shape	string_to_shape (const string &, const string &=" ")
template<typename... Vs>
size_t	hash_combine (const Vs &... values)
ThreadPoolDevice &	get_device ()
const EnumMap< ScalerMethod > &	scaler_method_map ()
const string &	scaler_method_to_string (ScalerMethod method)
ScalerMethod	string_to_scaler_method (const string &name)
const EnumMap< VariableRole > &	variable_role_map ()
const string &	variable_role_to_string (VariableRole role)
VariableRole	string_to_variable_role (const string &name)
bool	role_matches (VariableRole actual, VariableRole query)

Variables
constexpr int	Layout = Eigen::RowMajor
constexpr float	EPSILON = numeric_limits<float>::epsilon()
constexpr float	MAX = numeric_limits<float>::max()
constexpr float	NEG_INFINITY = -numeric_limits<float>::infinity()
constexpr float	QUIET_NAN = numeric_limits<float>::quiet_NaN()
constexpr float	SOFTMAX_MASK_VALUE = float(-1e9f)
static constexpr Index	ALIGN_BYTES = EIGEN_MAX_ALIGN_BYTES
static constexpr Index	ALIGN_ELEMENTS = ALIGN_BYTES / sizeof(float)
constexpr cudaDataType_t	CUDA_REDUCTION_DTYPE = CUDA_R_32F
constexpr cublasComputeType_t	CUBLAS_COMPUTE_DTYPE = CUBLAS_COMPUTE_32F_FAST_TF32

Typedef Documentation

array

template<typename T, size_t N>

using opennn::array = Eigen::array<T, N>

cublasHandle_t

using opennn::cublasHandle_t = void*

cublasLtHandle_t

using opennn::cublasLtHandle_t = void*

cudaEvent_t

using opennn::cudaEvent_t = void*

cudaStream_t

using opennn::cudaStream_t = void*

cudnnActivationDescriptor_t

using opennn::cudnnActivationDescriptor_t = void*

cudnnConvolutionDescriptor_t

using opennn::cudnnConvolutionDescriptor_t = void*

cudnnDropoutDescriptor_t

using opennn::cudnnDropoutDescriptor_t = void*

cudnnFilterDescriptor_t

using opennn::cudnnFilterDescriptor_t = void*

cudnnHandle_t

using opennn::cudnnHandle_t = void*

cudnnOpTensorDescriptor_t

using opennn::cudnnOpTensorDescriptor_t = void*

cudnnPoolingDescriptor_t

using opennn::cudnnPoolingDescriptor_t = void*

cudnnTensorDescriptor_t

using opennn::cudnnTensorDescriptor_t = cudnnTensorStruct*

MatrixB

using opennn::MatrixB = Matrix<bool, Dynamic, Dynamic, Layout>

MatrixI

using opennn::MatrixI = Matrix<Index, Dynamic, Dynamic, Layout>

MatrixMap

using opennn::MatrixMap = Map<MatrixR, Layout | AlignedMax>

MatrixR

using opennn::MatrixR = Matrix<float, Dynamic, Dynamic, Layout>

Tensor0

using opennn::Tensor0 = Tensor<float, 0, Layout | AlignedMax>

Tensor2

using opennn::Tensor2 = Tensor<float, 2, Layout | AlignedMax>

Tensor3

using opennn::Tensor3 = Tensor<float, 3, Layout | AlignedMax>

Tensor4

using opennn::Tensor4 = Tensor<float, 4, Layout | AlignedMax>

TensorMap2

using opennn::TensorMap2 = TensorMap<Tensor<float, 2, Layout | AlignedMax>, AlignedMax>

TensorMap3

using opennn::TensorMap3 = TensorMap<Tensor<float, 3, Layout | AlignedMax>, AlignedMax>

TensorMap4

using opennn::TensorMap4 = TensorMap<Tensor<float, 4, Layout | AlignedMax>, AlignedMax>

TensorMapR

template<int Rank>

using opennn::TensorMapR = TensorMap<Tensor<float, Rank, Layout | AlignedMax>, AlignedMax>

TensorR

template<int Rank>

using opennn::TensorR = Tensor<float, Rank, Layout | AlignedMax>

VectorB

using opennn::VectorB = Matrix<bool, Dynamic, 1>

VectorI

using opennn::VectorI = Matrix<Index, Dynamic, 1>

VectorMap

using opennn::VectorMap = Map<VectorR, AlignedMax>

VectorR

using opennn::VectorR = Matrix<float, Dynamic, 1>

Enumeration Type Documentation

cublasComputeType_t

enum opennn::cublasComputeType_t

Enumerator
CUBLAS_COMPUTE_32F
CUBLAS_COMPUTE_32F_FAST_16BF
CUBLAS_COMPUTE_32F_FAST_TF32

cublasLtEpilogue_t

enum opennn::cublasLtEpilogue_t

Enumerator
CUBLASLT_EPILOGUE_DEFAULT
CUBLASLT_EPILOGUE_BIAS
CUBLASLT_EPILOGUE_RELU_BIAS

cublasOperation_t

enum opennn::cublasOperation_t

Enumerator
CUBLAS_OP_N
CUBLAS_OP_T

cudaDataType_t

enum opennn::cudaDataType_t

Enumerator
CUDA_R_32F
CUDA_R_16F
CUDA_R_8I
CUDA_R_32I
CUDA_R_16BF

cudnnActivationMode_t

enum opennn::cudnnActivationMode_t

Enumerator
CUDNN_ACTIVATION_IDENTITY
CUDNN_ACTIVATION_SIGMOID
CUDNN_ACTIVATION_RELU
CUDNN_ACTIVATION_TANH
CUDNN_ACTIVATION_ELU

cudnnBatchNormMode_t

enum opennn::cudnnBatchNormMode_t

Enumerator
CUDNN_BATCHNORM_PER_ACTIVATION

cudnnConvolutionBwdDataAlgo_t

enum opennn::cudnnConvolutionBwdDataAlgo_t

Enumerator
CUDNN_CONVOLUTION_BWD_DATA_ALGO_0

cudnnConvolutionBwdFilterAlgo_t

enum opennn::cudnnConvolutionBwdFilterAlgo_t

Enumerator
CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0

cudnnConvolutionFwdAlgo_t

enum opennn::cudnnConvolutionFwdAlgo_t

Enumerator
CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM

cudnnDataType_t

enum opennn::cudnnDataType_t

Enumerator
CUDNN_DATA_FLOAT
CUDNN_DATA_HALF
CUDNN_DATA_INT8
CUDNN_DATA_INT32
CUDNN_DATA_BFLOAT16

cudnnPoolingMode_t

enum opennn::cudnnPoolingMode_t

Enumerator
CUDNN_POOLING_MAX

DateFormat

enum opennn::DateFormat

Enumerator
AUTO
DMY
MDY
YMD

Device

enum class opennn::Device

strong

Enumerator
Auto
CPU
CUDA

LayerType

enum class opennn::LayerType

strong

Identifier for every concrete Layer subclass supported by OpenNN.

Used for serialization, runtime type queries and the registry-based factory that rebuilds layers from XML/JSON.

Enumerator
Addition
Bounding
Convolutional
ConvolutionalRelu
Dense
DenseRelu
Embedding
Flatten
MultiHeadAttention
Normalization3d
Pooling
Pooling3d
Recurrent
Scaling
Unscaling

PoolingMethod

enum class opennn::PoolingMethod

strong

Reduction strategy applied within each pooling window.

Enumerator
MaxPooling	Take the maximum value of the window.
AveragePooling	Take the arithmetic mean of the window.

SampleRole

enum class opennn::SampleRole

strong

Role of a sample within a dataset partition.

• Training: used to fit the network parameters.
• Validation: used to monitor generalization during training.
• Testing: held out for the final evaluation.
• None: the sample is ignored (e.g. dropped due to missing values).

Enumerator
Training
Validation
Testing
None

ScalerMethod

enum class opennn::ScalerMethod

strong

Enumerator
None
MinimumMaximum
MeanStandardDeviation
StandardDeviation
Logarithm
ImageMinMax

Type

enum class opennn::Type

strong

Enumerator
Auto
FP32
BF16
INT8

VariableRole

enum class opennn::VariableRole

strong

Enumerator
None
Input
Target
Decoder
InputTarget
Time

VariableType

enum class opennn::VariableType

strong

Enumerator
None
Numeric
Binary
Categorical
DateTime
Constant

Function Documentation

add()

void opennn::add	(	const TensorView &	input_1,
		const TensorView &	input_2,
		TensorView &	output )

add_cpu()

void opennn::add_cpu	(	const TensorView &	input_1,
		const TensorView &	input_2,
		TensorView &	output )

add_json_field()

void opennn::add_json_field	(	JsonWriter &	writer,
		const std::string &	name,
		const std::string &	value )

align_up()

Index opennn::align_up ( Index value, Index alignment )

inline

aligned_total_bytes() [1/3]

Index opennn::aligned_total_bytes ( const vector< Shape > & shapes, const vector< Type > & dtypes )

inline

aligned_total_bytes() [2/3]

Index opennn::aligned_total_bytes ( const vector< Shape > & shapes, Type dtype )

inline

aligned_total_bytes() [3/3]

Index opennn::aligned_total_bytes ( const vector< vector< Shape > > & nested, const vector< vector< Type > > & dtypes )

inline

aligned_total_elements() [1/2]

Index opennn::aligned_total_elements ( const vector< Shape > & shapes )

inline

aligned_total_elements() [2/2]

Index opennn::aligned_total_elements ( const vector< vector< Shape > > & nested )

inline

append_rows()

MatrixR opennn::append_rows	(	const MatrixR &	,
		const MatrixR &	)

autocorrelations()

VectorR opennn::autocorrelations	(	const VectorR &	,
		Index	= 10 )

average_pooling_3d_backward()

void opennn::average_pooling_3d_backward	(	const TensorView &	input,
		const TensorView &	output_delta,
		TensorView &	input_delta )

average_pooling_3d_backward_cpu()

void opennn::average_pooling_3d_backward_cpu	(	const TensorView &	input,
		const TensorView &	output_delta,
		TensorView &	input_delta )

average_pooling_3d_forward()

void opennn::average_pooling_3d_forward	(	const TensorView &	input,
		TensorView &	output )

average_pooling_3d_forward_cpu()

void opennn::average_pooling_3d_forward_cpu	(	const TensorView &	input,
		TensorView &	output )

binary_cross_entropy()

void opennn::binary_cross_entropy	(	const TensorView &	input,
		const TensorView &	target,
		float &	error,
		float *	workspace_device )

bound()

void opennn::bound	(	const TensorView &	input,
		const TensorView &	lower_bounds,
		const TensorView &	upper_bounds,
		TensorView &	output )

bound_cpu()

void opennn::bound_cpu	(	const TensorView &	input,
		const TensorView &	lower_bounds,
		const TensorView &	upper_bounds,
		TensorView &	output )

box_plot() [1/2]

BoxPlot opennn::box_plot

(

const VectorR &

)

box_plot() [2/2]

BoxPlot opennn::box_plot	(	const VectorR &	,
		const vector< Index > &	)

build_feasible_rows_mask()

vector< Index > opennn::build_feasible_rows_mask	(	const MatrixR &	outputs,
		const VectorR &	minimums,
		const VectorR &	maximums )

calculate_rank()

VectorI opennn::calculate_rank	(	const VectorR &	,
		bool	ascending = true )

calculate_spearman_ranks()

VectorR opennn::calculate_spearman_ranks

(

const VectorR &

)

categorical_cross_entropy()

void opennn::categorical_cross_entropy	(	const TensorView &	input,
		const TensorView &	target,
		float &	error,
		float *	workspace_device )

column_maximums()

VectorR opennn::column_maximums	(	const Tensor2 &	,
		const vector< Index > &	= vector< Index >(),
		const vector< Index > &	= vector< Index >() )

column_minimums()

VectorR opennn::column_minimums	(	const Tensor2 &	,
		const vector< Index > &	= vector< Index >(),
		const vector< Index > &	= vector< Index >() )

concatenate_string_vectors()

vector< string > opennn::concatenate_string_vectors	(	const vector< string > &	,
		const vector< string > &	)

confidence_interval_z_correlation()

pair< float, float > opennn::confidence_interval_z_correlation	(	const float	,
		Index	)

contains()

bool opennn::contains	(	const vector< string > &	,
		const string &	)

convert_string_vector()

vector< string > opennn::convert_string_vector	(	const vector< vector< string > > &	,
		const string &	)

copy()

void opennn::copy	(	const TensorView &	source,
		TensorView &	destination )

copy_cpu()

void opennn::copy_cpu	(	const TensorView &	source,
		TensorView &	destination )

correlation()

Correlation opennn::correlation	(	const MatrixR &	,
		const MatrixR &	)

correlation_spearman()

Correlation opennn::correlation_spearman	(	const MatrixR &	,
		const MatrixR &	)

count_non_empty_lines()

Index opennn::count_non_empty_lines

(

const filesystem::path &

)

count_tokens()

Index opennn::count_tokens	(	const string &	,
		const string &	)

cross_correlations()

VectorR opennn::cross_correlations	(	const VectorR &	,
		const VectorR &	,
		Index	)

cross_entropy_3d()

void opennn::cross_entropy_3d	(	const TensorView &	input,
		const TensorView &	target,
		float &	error,
		Index &	active_tokens_out,
		Index &	correct_tokens_out,
		float *	errors_device = nullptr )

cross_entropy_3d_gradient()

void opennn::cross_entropy_3d_gradient	(	const TensorView &	input,
		const TensorView &	target,
		TensorView &	input_delta,
		Index	active_tokens_count )

cross_entropy_gradient()

void opennn::cross_entropy_gradient	(	const TensorView &	input,
		const TensorView &	target,
		TensorView &	input_delta )

date_to_timestamp()

time_t opennn::date_to_timestamp	(	const string &	,
		Index	= 0,
		const DateFormat &	format = AUTO )

descriptives() [1/2]

vector< Descriptives > opennn::descriptives

(

const MatrixR &

)

descriptives() [2/2]

vector< Descriptives > opennn::descriptives	(	const MatrixR &	,
		const vector< Index > &	,
		const vector< Index > &	)

display_progress_bar()

void opennn::display_progress_bar	(	const int &	,
		const int &	)

erase()

void opennn::erase	(	string &	,
		char	)

eta_squared_correlation()

Correlation opennn::eta_squared_correlation	(	const VectorR &	,
		const MatrixR &	)

exponential_correlation()

Correlation opennn::exponential_correlation	(	const VectorR &	,
		const VectorR &	)

fill_tensor_data()

void opennn::fill_tensor_data	(	const MatrixR &	,
		const vector< Index > &	,
		const vector< Index > &	,
		float *	,
		bool	= true,
		int	contiguous = -1 )

filter_missing_values() [1/2]

VectorR opennn::filter_missing_values

(

const VectorR &

)

filter_missing_values() [2/2]

template<typename X, typename Y>

pair< X, Y > opennn::filter_missing_values	(	const X &	x,
		const Y &	y )

for_json_items()

template<typename Func>

void opennn::for_json_items	(	const Json *	parent,
		const char *	tag,
		long	count,
		Func	func )

formatNumber()

string opennn::formatNumber	(	float	,
		int	)

gather_by_index()

template<typename T>

vector< T > opennn::gather_by_index	(	const vector< T > &	data,
		const vector< Index > &	indices )

get_aligned_bytes()

Index opennn::get_aligned_bytes ( Index n_bytes )

inline

get_aligned_size()

Index opennn::get_aligned_size ( Index size )

inline

get_correlation_values()

MatrixR opennn::get_correlation_values

(

const Tensor< Correlation, 2 > &

)

get_device()

ThreadPoolDevice & opennn::get_device ( )

inline

get_elements_greater_than()

vector< Index > opennn::get_elements_greater_than	(	const vector< Index > &	,
		Index	)

get_first_word()

string opennn::get_first_word

(

const string &

)

get_json_root()

const Json * opennn::get_json_root	(	const JsonDocument &	document,
		const std::string &	tag )

get_nearest_points()

VectorI opennn::get_nearest_points	(	const MatrixR &	,
		const VectorR &	,
		int	= 1 )

get_random_element()

Index opennn::get_random_element

(

const vector< Index > &

)

get_seed()

long long opennn::get_seed

(

)

get_time()

string opennn::get_time

(

float

)

get_tokens()

vector< string > opennn::get_tokens	(	const string &	,
		const string &	)

get_trimmed()

string opennn::get_trimmed

(

const string &

)

get_true_indices()

vector< Index > opennn::get_true_indices ( const VectorB & flags )

inline

has_numbers()

bool opennn::has_numbers

(

const vector< string > &

)

hash_combine()

template<typename... Vs>

size_t opennn::hash_combine

(

const Vs &...

values

)

histogram() [1/3]

Histogram opennn::histogram

(

const VectorB &

)

histogram() [2/3]

Histogram opennn::histogram	(	const VectorI &	,
		Index	= 10 )

histogram() [3/3]

Histogram opennn::histogram	(	const VectorR &	,
		Index	= 10 )

histogram_centered()

Histogram opennn::histogram_centered	(	const VectorR &	,
		float	= 0.0f,
		Index	= 10 )

histograms()

vector< Histogram > opennn::histograms	(	const MatrixR &	,
		Index	= 10 )

is_aligned()

bool opennn::is_aligned ( const void * ptr )

inline

is_binary()

template<typename T>

bool opennn::is_binary ( const T & tensor )

inline

is_constant()

template<typename T>

bool opennn::is_constant ( const T & tensor )

inline

is_contiguous()

bool opennn::is_contiguous ( const vector< Index > & indices )

inline

is_date_time_string()

bool opennn::is_date_time_string

(

const string &

)

is_numeric_string()

bool opennn::is_numeric_string

(

const string &

)

l1_regularization()

void opennn::l1_regularization	(	const TensorView &	parameters,
		float	lambda,
		float &	penalty )

l1_regularization_gradient()

void opennn::l1_regularization_gradient	(	const TensorView &	parameters,
		float	lambda,
		TensorView &	gradient )

l2_regularization()

void opennn::l2_regularization	(	const TensorView &	parameters,
		float	lambda,
		float &	penalty )

l2_regularization_gradient()

void opennn::l2_regularization_gradient	(	const TensorView &	parameters,
		float	lambda,
		TensorView &	gradient )

layer_type_map()

const EnumMap< LayerType > & opennn::layer_type_map ( )

inline

Returns the singleton string<->enum mapping for LayerType values.

Returns

Reference to a process-wide EnumMap initialized on first call.

layer_type_to_string()

const string & opennn::layer_type_to_string ( LayerType type )

inline

Converts a LayerType to its canonical string name.

Parameters

type	Layer type value.

Returns

Reference to the canonical string (e.g. "Dense", "Convolutional").

linear_correlation()

Correlation opennn::linear_correlation	(	const VectorR &	,
		const VectorR &	)

linear_correlation_spearman()

Correlation opennn::linear_correlation_spearman	(	const VectorR &	,
		const VectorR &	)

load_image()

Tensor3 opennn::load_image

(

const filesystem::path &

)

load_json_file()

JsonDocument opennn::load_json_file

(

const std::filesystem::path &

file_name

)

logarithmic_correlation()

Correlation opennn::logarithmic_correlation	(	const VectorR &	,
		const VectorR &	)

logistic_correlation() [1/4]

Correlation opennn::logistic_correlation	(	const MatrixR &	,
		const MatrixR &	)

logistic_correlation() [2/4]

Correlation opennn::logistic_correlation	(	const MatrixR &	,
		const VectorR &	)

logistic_correlation() [3/4]

Correlation opennn::logistic_correlation	(	const VectorR &	,
		const MatrixR &	)

logistic_correlation() [4/4]

Correlation opennn::logistic_correlation	(	const VectorR &	,
		const VectorR &	)

logistic_correlation_spearman()

Correlation opennn::logistic_correlation_spearman	(	const VectorR &	,
		const VectorR &	)

max_pooling_3d_backward()

void opennn::max_pooling_3d_backward	(	const TensorView &	maximal_indices,
		const TensorView &	output_delta,
		TensorView &	input_delta )

max_pooling_3d_backward_cpu()

void opennn::max_pooling_3d_backward_cpu	(	const TensorView &	maximal_indices,
		const TensorView &	output_delta,
		TensorView &	input_delta )

max_pooling_3d_forward()

void opennn::max_pooling_3d_forward	(	const TensorView &	input,
		TensorView &	output,
		TensorView &	maximal_indices,
		bool	is_training )

max_pooling_3d_forward_cpu()

void opennn::max_pooling_3d_forward_cpu	(	const TensorView &	input,
		TensorView &	output,
		TensorView &	maximal_indices,
		bool	is_training )

maximal_index()

Index opennn::maximal_index

(

const VectorR &

)

maximal_indices() [1/2]

VectorI opennn::maximal_indices

(

const MatrixR &

)

maximal_indices() [2/2]

VectorI opennn::maximal_indices	(	const VectorR &	,
		Index	)

maximum() [1/3]

float opennn::maximum

(

const MatrixR &

)

maximum() [2/3]

float opennn::maximum

(

const VectorR &

)

maximum() [3/3]

float opennn::maximum	(	const VectorR &	,
		const vector< Index > &	)

mean() [1/4]

VectorR opennn::mean

(

const MatrixR &

)

mean() [2/4]

VectorR opennn::mean	(	const MatrixR &	,
		const vector< Index > &	,
		const vector< Index > &	)

mean() [3/4]

float opennn::mean	(	const MatrixR &	,
		Index	)

mean() [4/4]

float opennn::mean

(

const VectorR &

)

mean_squared_error()

void opennn::mean_squared_error	(	const TensorView &	input,
		const TensorView &	target,
		float &	error,
		float *	workspace_device )

mean_squared_error_gradient()

void opennn::mean_squared_error_gradient	(	const TensorView &	input,
		const TensorView &	target,
		TensorView &	input_delta )

median() [1/5]

VectorR opennn::median

(

const MatrixR &

)

median() [2/5]

VectorR opennn::median	(	const MatrixR &	,
		const vector< Index > &	)

median() [3/5]

VectorR opennn::median	(	const MatrixR &	,
		const vector< Index > &	,
		const vector< Index > &	)

median() [4/5]

float opennn::median	(	const MatrixR &	,
		Index	)

median() [5/5]

float opennn::median

(

const VectorR &

)

merge_heads()

void opennn::merge_heads	(	const TensorView &	source,
		TensorView &	destination )

merge_heads_cpu()

void opennn::merge_heads_cpu	(	const TensorView &	source,
		TensorView &	destination )

minimal_index()

Index opennn::minimal_index

(

const VectorR &

)

minimal_indices() [1/2]

VectorI opennn::minimal_indices

(

const MatrixR &

)

minimal_indices() [2/2]

VectorI opennn::minimal_indices	(	const VectorR &	,
		Index	)

minimum() [1/3]

float opennn::minimum

(

const MatrixR &

)

minimum() [2/3]

float opennn::minimum

(

const VectorR &

)

minimum() [3/3]

float opennn::minimum	(	const VectorR &	,
		const vector< Index > &	)

minkowski_error()

void opennn::minkowski_error	(	const TensorView &	input,
		const TensorView &	target,
		float	power,
		float &	error,
		float *	workspace_device )

minkowski_error_gradient()

void opennn::minkowski_error_gradient	(	const TensorView &	input,
		const TensorView &	target,
		float	power,
		TensorView &	input_delta )

multiply()

void opennn::multiply	(	const TensorView &	input_a,
		bool	transpose_a,
		const TensorView &	input_b,
		bool	transpose_b,
		TensorView &	output,
		float	alpha = 1.0f,
		float	beta = 0.0f )

multiply_cpu()

void opennn::multiply_cpu	(	const TensorView &	input_a,
		bool	transpose_a,
		const TensorView &	input_b,
		bool	transpose_b,
		TensorView &	output,
		float	alpha = 1.0f,
		float	beta = 0.0f )

normalize_csv_line()

void opennn::normalize_csv_line

(

string &

)

normalized_squared_error()

void opennn::normalized_squared_error	(	const TensorView &	input,
		const TensorView &	target,
		float	coefficient,
		float &	error,
		float *	workspace_device )

normalized_squared_error_gradient()

void opennn::normalized_squared_error_gradient	(	const TensorView &	input,
		const TensorView &	target,
		float	coefficient,
		TensorView &	input_delta )

operator<<()

template<typename T>

ostream & opennn::operator<<	(	ostream &	os,
		const vector< T > &	vec )

pad()

void opennn::pad	(	const TensorView &	input,
		TensorView &	output )

perform_Householder_QR_decomposition()

VectorR opennn::perform_Householder_QR_decomposition	(	const MatrixR &	,
		const VectorR &	)

point_biserial_correlation()

Correlation opennn::point_biserial_correlation	(	const VectorR &	,
		const VectorR &	)

pooling_method_to_string()

const string & opennn::pooling_method_to_string ( PoolingMethod method )

inline

Converts a PoolingMethod to its canonical string name.

Parameters

method

Pooling method value.

Returns

Reference to the canonical string ("MaxPooling" or "AveragePooling").

power_correlation()

Correlation opennn::power_correlation	(	const VectorR &	,
		const VectorR &	)

prepare_line()

void opennn::prepare_line

(

string &

)

quartiles() [1/2]

VectorR opennn::quartiles

(

const VectorR &

)

quartiles() [2/2]

VectorR opennn::quartiles	(	const VectorR &	,
		const vector< Index > &	)

r_correlation_to_z_correlation()

float opennn::r_correlation_to_z_correlation

(

const float

)

random_bool()

bool opennn::random_bool

(

float

= 0.5

)

random_integer()

Index opennn::random_integer	(	Index	,
		Index	)

random_uniform()

float opennn::random_uniform	(	float	= -1,
		float	= 1 )

range()

float opennn::range

(

const VectorR &

)

read_json_bool()

bool opennn::read_json_bool	(	const Json *	root,
		const std::string &	field )

read_json_index()

long opennn::read_json_index	(	const Json *	root,
		const std::string &	field )

read_json_string()

std::string opennn::read_json_string	(	const Json *	root,
		const std::string &	field )

read_json_string_fallback()

std::string opennn::read_json_string_fallback	(	const Json *	root,
		std::initializer_list< std::string >	names )

read_json_type()

float opennn::read_json_type	(	const Json *	root,
		const std::string &	field )

reflect_image_horizontal()

void opennn::reflect_image_horizontal

(

Tensor3 &

)

reflect_image_vertical()

void opennn::reflect_image_vertical

(

Tensor3 &

)

register_classes()

void opennn::register_classes

(

)

replace()

void opennn::replace	(	string &	,
		const string &	,
		const string &	)

replace_all_appearances()

void opennn::replace_all_appearances	(	string &	,
		const string &	,
		const string &	)

replace_all_word_appearances()

void opennn::replace_all_word_appearances	(	string &	,
		const string &	,
		const string &	)

replace_double_char_with_label()

void opennn::replace_double_char_with_label	(	string &	,
		const string &	,
		const string &	)

replace_first_and_last_char_with_missing_label()

void opennn::replace_first_and_last_char_with_missing_label	(	string &	,
		char	,
		const string &	,
		const string &	)

replace_substring_within_quotes()

void opennn::replace_substring_within_quotes	(	string &	,
		const string &	,
		const string &	)

require_json_field()

const Json * opennn::require_json_field	(	const Json *	root,
		const std::string &	field )

resize_image()

Tensor3 opennn::resize_image	(	const Tensor3 &	,
		Index	,
		Index	)

role_matches()

bool opennn::role_matches ( VariableRole actual, VariableRole query )

inline

rotate_image()

void opennn::rotate_image	(	const Tensor3 &	,
		Tensor3 &	,
		float	)

round_to_precision()

float opennn::round_to_precision	(	float	,
		const int &	)

row_finite() [1/2]

bool opennn::row_finite ( const MatrixR & matrix, Index i )

inline

row_finite() [2/2]

bool opennn::row_finite ( const VectorR & values, Index i )

inline

sample_role_map()

const EnumMap< SampleRole > & opennn::sample_role_map ( )

inline

Returns the string<->enum mapping for SampleRole values.

Returns

Singleton EnumMap initialized once.

sample_role_to_string()

const string & opennn::sample_role_to_string ( SampleRole role )

inline

Converts a SampleRole to its canonical string name.

Parameters

role	The sample role.

Returns

Canonical string ("Training", "Validation", "Testing", "None").

scale()

void opennn::scale	(	const TensorView &	input,
		const TensorView &	minimums,
		const TensorView &	maximums,
		const TensorView &	means,
		const TensorView &	standard_deviations,
		const TensorView &	scalers,
		float	min_range,
		float	max_range,
		TensorView &	output )

scale_cpu()

void opennn::scale_cpu	(	const TensorView &	input,
		const TensorView &	minimums,
		const TensorView &	maximums,
		const TensorView &	means,
		const TensorView &	standard_deviations,
		const TensorView &	scalers,
		float	min_range,
		float	max_range,
		TensorView &	output )

scale_logarithmic()

void opennn::scale_logarithmic	(	MatrixMap	,
		Index	)

scale_mean_standard_deviation()

void opennn::scale_mean_standard_deviation	(	MatrixMap	,
		Index	,
		const Descriptives &	)

scale_minimum_maximum()

void opennn::scale_minimum_maximum	(	MatrixMap	,
		Index	,
		const Descriptives &	,
		float	= -1.0f,
		float	= 1.0f )

scale_standard_deviation()

void opennn::scale_standard_deviation	(	MatrixMap	,
		Index	,
		const Descriptives &	)

scaler_method_map()

const EnumMap< ScalerMethod > & opennn::scaler_method_map ( )

inline

scaler_method_to_string()

const string & opennn::scaler_method_to_string ( ScalerMethod method )

inline

set_random_integer()

void opennn::set_random_integer	(	MatrixR &	,
		Index	,
		Index	)

set_random_normal()

void opennn::set_random_normal	(	MatrixMap	,
		float	= 0,
		float	= 1 )

set_random_uniform() [1/2]

void opennn::set_random_uniform	(	MatrixR &	,
		float	= -0.1,
		float	= 0.1 )

set_random_uniform() [2/2]

void opennn::set_random_uniform	(	VectorMap	,
		float	= -0.1,
		float	= 0.1 )

set_seed()

void opennn::set_seed

(

unsigned

seed

)

shape_to_string()

string opennn::shape_to_string	(	const Shape &	,
		const string &	= " " )

shuffle()

void opennn::shuffle

(

VectorB &

vector_to_shuffle

)

shuffle_rows()

void opennn::shuffle_rows

(

MatrixR &

matrix

)

shuffle_vector()

template<typename T>

void opennn::shuffle_vector

(

vector< T > &

)

shuffle_vector_blocks()

void opennn::shuffle_vector_blocks	(	vector< Index > &	,
		size_t	= 20 )

slice_rows() [1/2]

MatrixR opennn::slice_rows ( const MatrixR & matrix, const vector< Index > & indices )

inline

slice_rows() [2/2]

VectorR opennn::slice_rows ( const VectorR & values, const vector< Index > & indices )

inline

softmax()

void opennn::softmax

(

TensorView &

output

)

softmax_cpu()

void opennn::softmax_cpu

(

TensorView &

output

)

sort_string_vector()

void opennn::sort_string_vector

(

vector< string > &

)

spec_dtypes()

vector< Type > opennn::spec_dtypes ( const vector< pair< Shape, Type > > & specs )

inline

Extracts the dtype component from a list of (Shape, Type) specs.

Parameters

specs

Vector of buffer specifications.

Returns

Vector of the dtypes, in the same order as specs.

spec_shapes()

vector< Shape > opennn::spec_shapes ( const vector< pair< Shape, Type > > & specs )

inline

Extracts the shape component from a list of (Shape, Type) specs.

Parameters

specs

Vector of buffer specifications.

Returns

Vector of the shapes, in the same order as specs.

split_heads()

void opennn::split_heads	(	const TensorView &	source,
		TensorView &	destination )

split_heads_cpu()

void opennn::split_heads_cpu	(	const TensorView &	source,
		TensorView &	destination )

ssize()

template<typename Container>

Index opennn::ssize ( const Container & container )

inlinenoexcept

standard_deviation() [1/2]

float opennn::standard_deviation

(

const VectorR &

)

standard_deviation() [2/2]

VectorR opennn::standard_deviation	(	const VectorR &	,
		Index	)

string_to_layer_type()

LayerType opennn::string_to_layer_type ( const string & name )

inline

Parses a LayerType from its canonical string name.

Parameters

name	String to parse (case sensitive, must match a canonical name).

Returns

Matching LayerType; throws if the string is unrecognized.

string_to_pooling_method()

PoolingMethod opennn::string_to_pooling_method ( const string & name )

inline

Parses a PoolingMethod from its canonical string name.

Parameters

name	String to parse ("MaxPooling" or "AveragePooling").

Returns

Matching PoolingMethod; throws if the string is unrecognized.

string_to_sample_role()

SampleRole opennn::string_to_sample_role ( const string & name )

inline

Parses a SampleRole from string.

Accepts both the canonical names and the numeric encodings ("0", "1", "2", "3").

Parameters

name	String to parse.

Returns

Matching SampleRole; throws if the string is unrecognized.

string_to_scaler_method()

ScalerMethod opennn::string_to_scaler_method ( const string & name )

inline

string_to_shape()

Shape opennn::string_to_shape	(	const string &	,
		const string &	= " " )

string_to_tensor()

template<typename T, size_t Rank>

void opennn::string_to_tensor	(	const string &	input,
		TensorR< Rank > &	values )

string_to_variable_role()

VariableRole opennn::string_to_variable_role ( const string & name )

inline

string_to_vector()

void opennn::string_to_vector	(	const string &	input,
		VectorR &	values )

tensor_to_string()

template<typename T, size_t Rank>

string opennn::tensor_to_string	(	const TensorR< Rank > &	values,
		const string &	separator = " " )

to_cuda()

cudaDataType_t opennn::to_cuda ( Type type )

inlinenoexcept

to_cudnn()

cudnnDataType_t opennn::to_cudnn ( Type type )

inlinenoexcept

to_int()

int opennn::to_int ( Index value )

inline

to_type()

float opennn::to_type ( Index value )

inline

to_type_vector()

VectorR opennn::to_type_vector	(	const string &	,
		const string &	)

tokenize()

vector< string > opennn::tokenize

(

const string &

)

total_frequencies()

VectorI opennn::total_frequencies

(

const vector< Histogram > &

)

translate_image_x()

void opennn::translate_image_x	(	const Tensor3 &	,
		Tensor3 &	,
		Index	)

translate_image_y()

void opennn::translate_image_y	(	const Tensor3 &	,
		Tensor3 &	,
		Index	)

trim()

void opennn::trim

(

string &

)

type_bytes()

Index opennn::type_bytes ( Type type )

inlinenoexcept

unscale()

void opennn::unscale	(	const TensorView &	input,
		const TensorView &	minimums,
		const TensorView &	maximums,
		const TensorView &	means,
		const TensorView &	standard_deviations,
		const TensorView &	scalers,
		float	min_range,
		float	max_range,
		TensorView &	output )

unscale_cpu()

void opennn::unscale_cpu	(	const TensorView &	input,
		const TensorView &	minimums,
		const TensorView &	maximums,
		const TensorView &	means,
		const TensorView &	standard_deviations,
		const TensorView &	scalers,
		float	min_range,
		float	max_range,
		TensorView &	output )

unscale_image_minimum_maximum()

void opennn::unscale_image_minimum_maximum	(	MatrixMap	,
		Index	)

unscale_logarithmic()

void opennn::unscale_logarithmic	(	MatrixMap	,
		Index	)

unscale_mean_standard_deviation()

void opennn::unscale_mean_standard_deviation	(	MatrixMap	,
		Index	,
		const Descriptives &	)

unscale_minimum_maximum()

void opennn::unscale_minimum_maximum	(	MatrixMap	,
		Index	,
		const Descriptives &	,
		float	= -1.0f,
		float	= 1.0f )

unscale_standard_deviation()

void opennn::unscale_standard_deviation	(	MatrixMap	,
		Index	,
		const Descriptives &	)

variable_role_map()

const EnumMap< VariableRole > & opennn::variable_role_map ( )

inline

variable_role_to_string()

const string & opennn::variable_role_to_string ( VariableRole role )

inline

variance() [1/2]

float opennn::variance

(

const VectorR &

)

variance() [2/2]

float opennn::variance	(	const VectorR &	,
		const VectorI &	)

vector_descriptives()

Descriptives opennn::vector_descriptives

(

const VectorR &

)

vector_map()

VectorMap opennn::vector_map	(	const MatrixR &	,
		Index	)

vector_to_string() [1/2]

template<typename Derived>

string opennn::vector_to_string ( const Eigen::DenseBase< Derived > & values, const string & separator = " " )

inline

vector_to_string() [2/2]

template<typename T>

string opennn::vector_to_string	(	const vector< T > &	values,
		const string &	separator = " " )

visit_type()

template<Type... Supported, typename F>

void opennn::visit_type	(	Type	t,
		F &&	f )

visit_type_pair()

template<Type... Supported, typename F>

void opennn::visit_type_pair	(	Type	t_in,
		Type	t_out,
		F &&	f )

weighted_squared_error()

void opennn::weighted_squared_error	(	const TensorView &	input,
		const TensorView &	target,
		float	pos_w,
		float	neg_w,
		float &	error,
		float *	workspace_device )

weighted_squared_error_gradient()

void opennn::weighted_squared_error_gradient	(	const TensorView &	input,
		const TensorView &	target,
		float	pos_w,
		float	neg_w,
		float	coefficient,
		TensorView &	input_delta )

write_json()

void opennn::write_json	(	JsonWriter &	writer,
		std::initializer_list< std::pair< const char *, std::string > >	props )

z_correlation_to_r_correlation()

float opennn::z_correlation_to_r_correlation

(

const float

)

Variable Documentation

ALIGN_BYTES

Index opennn::ALIGN_BYTES = EIGEN_MAX_ALIGN_BYTES

staticconstexpr

ALIGN_ELEMENTS

Index opennn::ALIGN_ELEMENTS = ALIGN_BYTES / sizeof(float)

staticconstexpr

CUBLAS_COMPUTE_DTYPE

cublasComputeType_t opennn::CUBLAS_COMPUTE_DTYPE = CUBLAS_COMPUTE_32F_FAST_TF32

constexpr

CUDA_REDUCTION_DTYPE

cudaDataType_t opennn::CUDA_REDUCTION_DTYPE = CUDA_R_32F

constexpr

EPSILON

float opennn::EPSILON = numeric_limits<float>::epsilon()

constexpr

Layout

int opennn::Layout = Eigen::RowMajor

constexpr

MAX

float opennn::MAX = numeric_limits<float>::max()

constexpr

NEG_INFINITY

float opennn::NEG_INFINITY = -numeric_limits<float>::infinity()

constexpr

QUIET_NAN

float opennn::QUIET_NAN = numeric_limits<float>::quiet_NaN()

constexpr

SOFTMAX_MASK_VALUE

float opennn::SOFTMAX_MASK_VALUE = float(-1e9f)

constexpr