Namespaces
namespace	cudnn_frontend

namespace	detail

namespace	device

namespace	logging

namespace	matmul

namespace	memory_debug

namespace	network_detail

namespace	profiler

namespace	yolo_detail

Classes
class	Activation

struct	ActivationOperator

class	Adam

class	Addition

struct	AdditionOperator

struct	AffineMap

class	ApproximationNetwork

struct	AttentionOperator

class	Autoencoder

struct	BackPropagation

struct	BackPropagationLM

struct	Batch

struct	BatchNormalizationOperator

struct	BatchPools

struct	BatchPrefetchSession

struct	BatchSlot

class	Bert

class	BertForSequenceClassification

struct	BoxPlot

struct	Buffer

class	BytePairTokenizer

class	C2PSA

struct	C2PSAOperator

struct	CandidateEvaluation

struct	ChatDelta

struct	ChatMessage

struct	ChatOptions

struct	ChatResponse

class	ChatSession

class	ChatTemplate

class	Clamping

struct	ClampingOperator

class	ClassificationNetwork

struct	CombinationOperator

struct	CompiledExpression

class	Concatenation

struct	ConcatenationOperator

class	Configuration

class	Convolutional

struct	ConvolutionOperator

struct	Correlation

class	CsvReader

struct	CudnnDescriptor

struct	CudnnRnnConfig

struct	CudnnRnnShapeSlot

struct	CudnnRnnState

class	Dataset

class	Dense

struct	Descriptives

class	Detection

class	DetectionHeadEndpoint

struct	DetectionHeadMetadata

struct	DetectionOperator

class	DetectionV8

struct	DetectionV8Operator

struct	DeviceGather

class	DomainContraction

struct	DropoutOperator

struct	EffectiveConfig

class	Embedding

struct	EmbeddingLookupOperator

class	EnumMap

class	Evaluation

struct	ExpressionOp

struct	ExpressionProgram

struct	FeatureScaling

class	FeatureScalingEndpoint

struct	FeatureSelection

class	FileMapping

class	FileReader

class	FileWriter

class	Flatten

struct	FoldEvaluation

struct	FoldScope

class	ForecastingLstmNetwork

class	ForecastingNetwork

struct	ForwardPropagation

class	GenerationParser

struct	GenerationParserSpec

class	GeneticAlgorithm

class	GeneticResponse

class	GroupedQueryAttention

struct	GroupedQueryAttentionOperator

class	GrowingInputs

class	GrowingNeurons

struct	Histogram

struct	ImageAugmentationPolicy

class	ImageClassificationNetwork

class	ImageDataset

struct	InferenceShapePolicy

class	InputSelection

struct	InputSelectionResult

class	Json

class	JsonDocument

class	JsonWriter

class	Layer

struct	LayerNormalizationOperator

class	LevenbergMarquardt

struct	LinearBackwardOptions

class	Loss

class	LSTM

struct	LSTMOperator

struct	MemoryPoolEntry

struct	MemoryPoolPlan

class	ModelExpression

class	ModelSelection

class	MultiHeadAttention

struct	MultiHeadProjectionOperator

class	Network

struct	NeuronsSelectionResult

class	NonMaxSuppression

struct	NonMaxSuppressionOperator

class	Normalization3d

struct	NumberFormat

struct	NumberFormatVotes

struct	OnnxModel

struct	Operator

class	Optimizer

struct	OptimizerData

struct	ParameterSnapshot

struct	Pool3dOperator

class	Pooling

class	Pooling3d

struct	PoolOperator

struct	PrecisionPlan

class	QuasiNewton

class	Qwen3

class	Qwen3ChatTemplate

class	Qwen3Tokenizer

class	Recurrent

struct	RecurrentOperator

class	ResNet

class	ResponseOptimization

struct	SamplingConfig

struct	ScaleOperator

class	Scaling

class	ScopeExit

class	SelectionAlgorithm

struct	SequenceLengths

class	SGD

struct	Shape

struct	StoppingCheck

struct	SwiGLUOperator

class	TabularDataset

struct	TensorSpec

struct	TensorView

class	TextClassificationNetwork

class	TextDataset

class	TextGenerationNetwork

class	ThreadSafeQueue

class	Tokenizer

class	TokenizerOperator

class	Training

class	TrainingArenaPlan

struct	TrainingContext

struct	TrainingResult

class	Transformer

struct	TransparentStringHash

struct	TypeInfo

struct	TypeInfo< Type::BF16 >

struct	TypeInfo< Type::FP32 >

struct	TypeInfo< Type::INT8 >

class	Unscaling

class	Upsampling

struct	UpsamplingOperator

struct	Variable

class	WordLevelTokenizer

class	WordPieceTokenizer

class	Yolo

class	YoloDataset

struct	YoloDetection

struct	YoloFpnHead

struct	YoloLambdas

Concepts
concept	RawStorable

Typedefs
using	DeviceStream = cudaStream_t

using	DeviceEvent = cudaEvent_t

using	DeviceGraph = cudaGraph_t

using	DeviceGraphExec = cudaGraphExec_t

using	BlasHandle = cublasHandle_t

using	BlasLtHandle = cublasLtHandle_t

using	DnnHandle = cudnnHandle_t

using	DnnOpTensorDescriptor = cudnnOpTensorDescriptor_t

using	DnnDataType = cudnnDataType_t

using	DnnStatus = cudnnStatus_t

using	DnnTensorDescriptor = cudnnTensorDescriptor_t

using	DnnRNNDataDescriptor = cudnnRNNDataDescriptor_t

using	DnnRNNDescriptor = cudnnRNNDescriptor_t

using	DnnDropoutDescriptor = cudnnDropoutDescriptor_t

using	DnnPoolingDescriptor = cudnnPoolingDescriptor_t

using	DnnRNNMode = cudnnRNNMode_t

using	BlasComputeType = cublasComputeType_t

using	BlasPointerMode = cublasPointerMode_t

using	BlasMathMode = cublasMath_t

using	BlasOperation = cublasOperation_t

using	DeviceDataType = cudaDataType_t

using	bfloat16 = __nv_bfloat16

using	type = float

template<typename Value>
using	StringMap = unordered_map<string, Value, TransparentStringHash, equal_to<>>

template<typename T, size_t N>
using	array = Eigen::array<T, N>

using	ChatCallback = function<void(const ChatDelta&)>

Enumerations
enum class	Device { Auto , CPU , CUDA }

enum class	Type { Auto , FP32 , BF16 , INT8 }

enum class	Blas { Eigen , Mkl }

enum class	ActivationFunction { Identity , Sigmoid , Tanh , ReLU , Softmax , LeakyReLU , GELU , GELUTanh , SiLU }

enum class	LinearEpilogue { Default , Relu , Bias , ReluBias , ReluAuxBias , DRelu , GeluAuxBias , BiasGradient }

enum class	MemoryPoolStrategy { Chronological , Compact , ChronologicalLargestFirst , EarliestEndFirst , LatestEndFirst , LongestLifetimeFirst , ShortestLifetimeFirst }

enum class	Transpose { No , Yes }

enum class	ColumnContiguity { Unknown , NonContiguous , Contiguous }

enum class	VariableType { None , Numeric , Binary , Integer , Categorical , DateTime , Constant }

enum class	ScalerMethod { None , MinimumMaximum , MeanStandardDeviation , StandardDeviation , Logarithm , ImageMinMax }

enum class	VariableRole { None , Input , Target , Decoder , InputTarget , Time , Evaluation }

enum class	FillMode { Training , Validation , Inference }

enum class	SampleRole { Training , Validation , Testing , None }

enum class	Shuffle { No , Yes }

enum	DateFormat { Auto , Dmy , Mdy , Ymd }

enum class	ConfusionCell { TruePositive , FalsePositive , FalseNegative , TrueNegative }

enum class	ReasoningMode { Automatic , Enabled , Disabled }

enum class	GenerationChannel { Reasoning , Content }

enum class	FinishReason { Stop , MaximumTokens , ContextLimit }

enum class	ChatRole { System , User , Assistant }

enum class	DetectionHeadKind { AnchorBased , AnchorFree }

enum class	DetectionClassActivation { Softmax , Sigmoid }

enum class	ForwardPropagationMode { Training , Inference }

enum class	ForwardSlotKind { Pooled , Transient , TrainingOnly }

enum class	BatchNormalization { No , Yes }

enum class	Trainability { Frozen , Trainable }

enum class	LayerType { Activation , Addition , Clamping , Concatenation , Convolutional , Dense , Detection , DetectionV8 , Embedding , Flatten , LSTM , MultiHeadAttention , Normalization3d , GroupedQueryAttention , NonMaxSuppression , Pooling , Pooling3d , Recurrent , Scaling , Tokenizer , Unscaling , Upsampling , C2PSA , Count }

enum class	PoolingMethod { MaxPooling , AveragePooling , FirstToken }

enum class	NetworkTask { Generic , Approximation , Classification , Forecasting , AnomalyDetection , ImageClassification , ObjectDetection , TextClassification , LanguageModeling }

enum class	CausalMask { No , Yes }

enum class	NormalizationMethod { LayerNorm , RMS }

enum class	ExpressionLinearity { Linear , Nonlinear }

enum class	StoppingCondition { LossGoal , MinimumLossDecrease , MaximumValidationErrorIncreases , MaximumTime , MaximumEpochsNumber }

Functions
constexpr PrecisionPlan	make_precision_plan (const Type type) noexcept

Type	activation_dtype (Type type)

ThreadPoolDevice &	get_device ()

void	set_threads_number (int)

void *	ensure_workspace_bytes (device::GraphWorkspaceKind, Index bytes)

template<typename T>
T *	ensure_workspace (device::GraphWorkspaceKind kind, Index count)

bfloat16 *	ensure_bf16_gradient_workspace (Index n)

bfloat16 *	ensure_int8_dequant_workspace (Index n)

float *	ensure_bf16_to_fp32_workspace (Index n)

void *	ensure_shared_scratch (size_t bytes)

float *	ensure_flash_attention_workspace (Index n)

void	release_thread_workspaces ()

const void *	data_for_gemm_dtype (const TensorView &, Type)

const void *	bias_for_gemm_bf16 (const TensorView &)

void	run_lt_matmul_cached (int, int, int, BlasOperation transA, BlasOperation transB, LinearEpilogue epilogue, const void , const void , void , const void , DeviceDataType dtype_a=CUDA_R_32F, DeviceDataType dtype_b=CUDA_R_32F, DeviceDataType out_dtype=CUDA_R_32F, const void aux_pointer=nullptr, const void addend=nullptr, float alpha=1.0f, float beta=0.0f, int lda=0, int ldb=0, int ldd=0)

void	gemm_strided_batched_cuda (BlasOperation transa, BlasOperation transb, int, int, int, const void , DeviceDataType Atype, int, long long stride_a, const void , DeviceDataType Btype, int, long long stride_b, void *, DeviceDataType Ctype, int, long long stride_c, int, float alpha=1.0f, float beta=0.0f)

void	download_if_missing (const filesystem::path &, const string &)

void	download_files_if_missing (const filesystem::path &directory, string_view base_url, const vector< string_view > &filenames)

string	read_text_file (const filesystem::path &)

vector< filesystem::path >	list_files (const filesystem::path &directory, std::function< bool(const filesystem::path &)> predicate)

vector< filesystem::path >	list_directories (const filesystem::path &directory, std::function< bool(const filesystem::path &)> predicate)

bool	is_file_current (const filesystem::path &file, const vector< filesystem::path > &sources, uintmax_t expected_size=0)

void	read_int32_batch (const FileReader &, const vector< Index > &sample_indices, Index samples_number, uint64_t record_values, Index source_offset, Index values_number, span< float > output, Index output_stride, Index output_offset, string_view context)

bool	read_binary_value (istream &stream, RawStorable auto &value)

bool	read_binary_values (istream &stream, RawStorable auto &... values)

void	write_binary_value (FileWriter &writer, const RawStorable auto &value)

bool	read_binary_string (istream &stream, string &value)

void	write_binary_string (FileWriter &writer, const string &value)

template<typename Value>
void	add_json_field (JsonWriter &writer, std::string_view name, Value &&value)

void	save_json_file (const std::filesystem::path &, const JsonWriter &)

template<typename Serializable>
void	save_json_file (const std::filesystem::path &file_name, const Serializable &serializable)

void	write_json (JsonWriter &, std::initializer_list< std::pair< const char *, Json > >)

float	read_json_float (const Json *, std::string_view)

long long	read_json_index (const Json *, std::string_view)

bool	read_json_bool (const Json *, std::string_view)

std::string	read_json_string (const Json *, std::string_view)

std::vector< std::string >	read_json_strings (const Json *, std::string_view)

float	read_json_float (const Json *, std::string_view, float fallback)

long long	read_json_index (const Json *, std::string_view, long long fallback)

bool	read_json_bool (const Json *, std::string_view, bool fallback)

std::string	read_json_string (const Json *, std::string_view, std::string_view fallback)

std::string	read_json_string_fallback (const Json *, std::initializer_list< std::string_view >)

const Json *	require_json_field (const Json *, std::string_view)

template<typename Range>
Json	json_array (const Range &values)

template<typename Func>
void	for_json_items (const Json parent, const char tag, std::size_t count, Func func)

JsonDocument	load_json_file (const std::filesystem::path &)

const Json *	get_json_root (const JsonDocument &, std::string_view)

constexpr Index	backward_step (Index layers_number, Index layer) noexcept

MemoryPoolPlan	plan_memory_pool (const vector< MemoryPoolEntry > &, MemoryPoolStrategy=MemoryPoolStrategy::Chronological)

MemoryPoolPlan	plan_memory_pool_best (const vector< MemoryPoolEntry > &)

Index	find_memory_pool_overlay (const vector< MemoryPoolEntry > &, const MemoryPoolPlan &, Index bytes, Index first_step, Index second_step)

float	bfloat16_to_float_host (const uint16_t value)

uint16_t	float_to_bfloat16_host (const float value)

void	float_2_bfloat16_host (const Index count, const float source, uint16_t destination)

template<typename T, typename... Candidates>
constexpr bool	is_one_of (const T &value, const Candidates &... candidates)

template<typename F>
	ScopeExit (F) -> ScopeExit< F >

template<typename T>
ostream &	operator<< (ostream &os, const vector< T > &vec)

bool	use_parallel_algorithm (ptrdiff_t size) noexcept

template<typename Iterator, typename Compare = less<>>
void	sort_parallel_if_large (Iterator first, Iterator last, Compare compare={})

template<typename Iterator, typename Compare = less<>>
void	stable_sort_parallel_if_large (Iterator first, Iterator last, Compare compare={})

template<typename Iterator, typename Compare = less<>>
void	nth_element_parallel_if_large (Iterator first, Iterator nth, Iterator last, Compare compare={})

void	set_seed (unsigned seed)

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

float	random_normal (float=0, 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_bernoulli (span< uint8_t >, float)

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

void	set_random_orthogonal (MatrixMap)

void	set_random_integer (MatrixR &, Index, Index)

void	shuffle (VectorB &)

template<typename T>
void	shuffle_vector (vector< T > &)

template<typename T>
void	shuffle_vector_seeded (vector< T > &, unsigned seed)

template<typename T>
void	partial_shuffle (vector< T > &v, Index count)

bool	draw_k_hot (Index, Index, const vector< char > &, const vector< char > &, vector< float > &)

Index	get_random_element (const vector< Index > &)

float	glorot_limit (Index fan_in, Index fan_out)

template<typename X>
auto	scale_minimum_maximum_formula (const X &x, const Descriptives &d, float min_range, float max_range)

template<typename X>
auto	scale_mean_standard_deviation_formula (const X &x, const Descriptives &d)

template<typename X>
auto	unscale_minimum_maximum_formula (const X &x, const Descriptives &d, float min_range, float max_range)

template<typename X>
auto	unscale_mean_standard_deviation_formula (const X &x, const Descriptives &d)

float	scale_value (ScalerMethod method, const Descriptives &desc, float value, float min_range=-1.0f, float max_range=1.0f)

AffineMap	scaling_affine (ScalerMethod scaler, const Descriptives &descriptives, float min_range, float max_range)

AffineMap	unscaling_affine (ScalerMethod scaler, const Descriptives &descriptives, float min_range, float max_range)

VectorR	descriptives_field (const vector< Descriptives > &descriptives, float Descriptives::*member)

float	minimum (const MatrixR &)

float	minimum (const VectorR &)

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

float	maximum (const MatrixR &)

float	maximum (const VectorR &)

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

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 &, const vector< Index > &, const vector< Index > &)

float	variance (const VectorR &)

float	variance (const VectorR &, const VectorI &)

float	standard_deviation (const VectorR &)

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)

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

Index	minimal_index (const VectorR &)

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	filter_missing_values (const VectorR &)

template<typename InputType, typename TargetType>
pair< InputType, TargetType >	filter_missing_values (const InputType &x, const TargetType &y)

template<typename T>
bool	is_binary (const T &tensor)

template<typename T>
bool	is_constant (const T &tensor)

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

vector< Index >	ranked_indices (const VectorR &)

VectorR	minmax_score (const VectorR &, bool invert=false)

MatrixR	minmax_score (const MatrixR &)

vector< Index >	extreme_indices (const MatrixR &)

vector< VectorI >	nearest_neighbors (const MatrixR &, Index)

VectorR	neighbor_distances (const MatrixR &, Index)

VectorR	local_outlier_factor (const MatrixR &, Index)

void	farthest_point_fill (const MatrixR &distances, vector< Index > &selection, Index quota)

vector< string >	get_tokens (string_view, string_view)

vector< string_view >	get_token_views (string_view, char)

void	split_views (string_view, char, vector< string_view > &)

vector< string_view >	get_token_views_maybe_quoted (string_view line, char separator, bool file_has_quotes, string &scratch)

void	get_token_views_maybe_quoted (string_view line, char separator, bool file_has_quotes, string &scratch, vector< string_view > &out)

string_view	first_token_maybe_quoted (string_view line, char separator, bool file_has_quotes, string &scratch)

string_view	trim_view (string_view)

void	ascii_lowercase_in_place (string &) noexcept

string	ascii_lowercase (string_view)

void	append_utf8 (string &, uint32_t)

vector< string >	tokenize (const string &)

vector< string_view >	tokenize_views (string_view)

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

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

string	join_strings (span< const string >, string_view=" ")

template<typename T>
T	parse_number (string_view text, string_view context, string_view value_kind="numeric")

template<typename T>
vector< T >	parse_number_list (string_view text, string_view context, char separator=' ')

float	parse_float (string_view, string_view)

int	parse_int (string_view, string_view)

long	parse_long (string_view, string_view)

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

void	display_progress_bar (Index, Index)

float	get_elapsed_time (chrono::steady_clock::time_point start)

string	get_time (float)

string	get_first_word (const string &)

template<typename T>
string	vector_to_string (const vector< T > &values, const string &separator=" ")

string	vector_to_string (const vector< string > &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 &, VectorR &)

bool	contains (const vector< string > &, string_view)

bool	contains (initializer_list< string_view >, string_view)

bool	starts_with_any (string_view, initializer_list< string_view >)

bool	env_flag_enabled (const char *) noexcept

bool	env_flag_enabled (const char *, bool default_value) noexcept

long long	env_int_or (const char *, long long default_value) noexcept

float	gelu_value (float x)

float	gelu_tanh_value (float x)

float	silu_value (float x)

float	gelu_derivative (float x)

float	gelu_tanh_derivative (float x)

float	silu_derivative (float x)

const EnumMap< ActivationFunction > &	activation_function_map ()

const string &	activation_function_to_string (ActivationFunction)

ActivationFunction	activation_function_from_string (const string &)

bool	activation_needs_input (ActivationFunction function)

bool	blas_mkl_available ()

float	activation_forward_value (ActivationFunction function, float x)

float	activation_derivative_from_output_value (ActivationFunction function, float y)

template<typename TensorType>
TensorType::PlainObject	activation_forward_values (ActivationFunction function, const TensorType &values)

template<typename TensorType>
TensorType::PlainObject	activation_derivative_from_output_values (ActivationFunction function, const TensorType &values)

void	copy (const TensorView &, TensorView &)

void	add (const TensorView &, const TensorView &, TensorView &)

void	multiply (const TensorView &, Transpose, const TensorView &, Transpose, TensorView &, float alpha=1.0f, float beta=0.0f)

void	softmax (TensorView &)

void	softmax_backward (const TensorView &, TensorView &, float alpha=1.0f)

void	activation_forward (TensorView &, ActivationFunction)

void	activation_backward (const TensorView &, TensorView &, ActivationFunction)

void	linear_forward (const TensorView &, const TensorView &, const TensorView &, TensorView &, LinearEpilogue epilogue=LinearEpilogue::Bias, TensorView *pre_activation=nullptr, const TensorView &weight_scale={}, ActivationFunction fused_activation=ActivationFunction::Identity)

void	linear_backward (const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, TensorView &, bool accumulate_input_delta=false, const LinearBackwardOptions &options={})

void	linear_forward_transposed (const TensorView &input, const TensorView &embed_weight, TensorView &output, const TensorView &weight_scale={})

MatrixR	append_rows (const MatrixR &, const MatrixR &)

MatrixR	append_columns (const MatrixR &, const MatrixR &)

pair< MatrixR, MatrixR >	append_rows (const pair< MatrixR, MatrixR > &, const pair< MatrixR, MatrixR > &)

MatrixR	append_columns (const pair< MatrixR, MatrixR > &)

VectorR	slice_rows (const VectorR &, const vector< Index > &)

MatrixR	slice_rows (const MatrixR &, const vector< Index > &)

pair< MatrixR, MatrixR >	slice_rows (const pair< MatrixR, MatrixR > &, const vector< Index > &)

MatrixR	calculate_distances (const MatrixR &)

VectorI	get_nearest_points (const MatrixR &, const VectorR &, Index=1)

bool	row_dominates (const MatrixR &, Index, Index)

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)

template<typename F>
auto	with_type_info (Type type, const char *caller, F &&f)

DnnDataType	to_cudnn (Type type)

DeviceDataType	to_cuda (Type type)

Index	type_bytes (Type type)

int	to_int (Index value)

float	to_type (Index value)

Index	align_up (Index value, Index alignment)

Index	ceil_div (Index value, Index divisor)

Index	get_aligned_size (Index size)

Index	get_aligned_bytes (Index n_bytes)

Index	get_aligned_bytes (Index count, Type dtype)

bool	is_aligned (const void *ptr)

Index	get_aligned_size (const vector< TensorSpec > &specs)

Index	get_aligned_size (const vector< vector< TensorSpec > > &specs)

Index	get_aligned_bytes (const TensorSpec &spec)

Index	get_aligned_bytes (const vector< TensorSpec > &specs)

Index	get_aligned_bytes (const vector< vector< TensorSpec > > &specs)

Index	get_aligned_bytes (const vector< Shape > &shapes, Type dtype)

Index	get_aligned_bytes (const vector< TensorSpec > &specs, Type dtype)

Index	get_aligned_bytes (const vector< vector< TensorSpec > > &specs, Type dtype)

TensorView &	slot_or (vector< TensorView > &views, const vector< size_t > &slot_indices, size_t i, TensorView &fallback)

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

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

bool	is_contiguous (const vector< Index > &indices)

ColumnContiguity	classify_column_contiguity (const vector< Index > &indices)

bool	resolve_column_contiguity (ColumnContiguity column_contiguity, const vector< Index > &indices)

void	fill_tensor_data (const MatrixR &, const vector< Index > &, const vector< Index > &, span< float >, ColumnContiguity=ColumnContiguity::Unknown)

template<typename... Vs>
size_t	hash_combine (const Vs &... values)

void	copy_device_to_host_float (const void , Type, Index, float , DeviceStream stream)

void	copy_device_to_host_float (const void , Type, Index, float , DeviceStream stream, vector< uint16_t > &bf16_staging)

const EnumMap< VariableType > &	variable_type_map ()

const string &	variable_type_to_string (VariableType type)

VariableType	string_to_variable_type (string_view name)

const EnumMap< ScalerMethod > &	scaler_method_map ()

const string &	scaler_method_to_string (ScalerMethod method)

ScalerMethod	string_to_scaler_method (string_view name)

const EnumMap< VariableRole > &	variable_role_map ()

const string &	variable_role_to_string (VariableRole role)

VariableRole	string_to_variable_role (string_view name)

bool	role_applies_to (VariableRole actual, VariableRole query)

vector< string >	get_variable_feature_names (const vector< Variable > &)

vector< pair< string, Index > >	get_variable_columns (const vector< Variable > &)

vector< pair< Index, Index > >	get_categorical_blocks (const vector< Variable > &)

vector< Index >	get_feature_dimensions (const vector< Variable > &variables)

Index	get_features_number (const vector< Variable > &variables)

bool	bf16_host_input_cast_enabled () 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 MatrixR &, const MatrixR &)

Correlation	correlation (const MatrixR &, const MatrixR &)

Correlation	correlation_spearman (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 &)

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 ()

const string &	sample_role_to_string (SampleRole role)

SampleRole	string_to_sample_role (string_view name)

void	vote_number_format (string_view, NumberFormatVotes &)

NumberFormat	decide_number_format (const NumberFormatVotes &)

string	number_format_name (char)

char	number_format_separator (const string &, string_view)

bool	parse_real (string_view, float &, const NumberFormat &={})

bool	parse_real (string_view, double &, const NumberFormat &={})

bool	is_numeric_string (string_view, const NumberFormat &={})

bool	is_date_time_string (string_view)

DateFormat	detect_date_format (string_view)

time_t	date_to_timestamp (string_view, Index=0, DateFormat format=Auto)

Tensor3	load_image (const filesystem::path &)

bool	is_supported_image_file (const filesystem::path &)

void	load_image (const filesystem::path &, float *, Index, Index, Index)

Tensor3	resize_image (const Tensor3 &, Index, Index)

template<typename Pixel>
float	bilinear_blend (Pixel v00, Pixel v01, Pixel v10, Pixel v11, float dx, float dy)

void	reflect_image_horizontal (TensorMap3 &)

void	reflect_image_vertical (TensorMap3 &)

void	rotate_image (const TensorMap3 &, TensorMap3 &, float)

void	translate_image_x (TensorMap3 &, Index)

void	translate_image_y (TensorMap3 &, Index)

vector< YoloDetection >	decode_yolo_detections (span< const float >, Index, Index, Index, Index)

vector< YoloDetection >	decode_yolo_fpn_detections (const vector< YoloFpnHead > &, Index, Index, Index, Index, float confidence_threshold=0.25f, float iou_threshold=0.45f)

vector< YoloDetection >	decode_yolo_v8_fpn_detections (const vector< YoloFpnHead > &, Index, Index, Index, Index, float confidence_threshold=0.25f, float iou_threshold=0.45f, Index reg_max=1)

vector< vector< Index > >	build_fold_partition (Training *training, Index folds_number, Index folds_seed=0)

FoldEvaluation	evaluate_folds (Training *training, const vector< vector< Index > > &fold_partition)

void	refit_final_model_on_development (Training *training, Index folds_number, Index folds_seed=0)

unique_ptr< InputSelection >	create_input_selection (const string &name)

void	validate_selection_training (const Training *, Index folds_number, string_view algorithm)

CandidateEvaluation	evaluate_candidate (Training , Network , Index folds_number, const vector< vector< Index > > &fold_partition, Index trials_number, bool use_validation_history_minimum, const function< void(Index, float, float, bool)> &on_trial, const function< void(Index)> &initialize_trial={})

FeatureScaling	capture_input_scaling (Dataset *)

void	apply_input_scaling (Network *, FeatureScaling)

ParameterSnapshot	capture_parameter_snapshot (Network *)

void	seed_parameters_from_snapshot (Network *, const ParameterSnapshot &, const vector< Index > &input_row_map={})

void	finalize_selected_model (Training , Network , const VectorR &optimal_parameters, Index folds_number, bool display, const char *selected_label)

float	read_json_float_alias (const Json *, string_view primary, string_view legacy)

long long	read_json_index_alias (const Json *, string_view primary, string_view legacy)

template<typename Condition>
optional< Condition >	first_stopping_condition (const bool display, initializer_list< StoppingCheck< Condition > > checks)

Index	load_darknet_backbone (Network &, const filesystem::path &, Index)

Index	load_darknet_backbone_v11 (Network &, const filesystem::path &)

Index	load_yolov8s_onnx (Network &, const filesystem::path &onnx_path, Index n_classes)

Index	sample_token (VectorR &probabilities, const SamplingConfig &, const vector< Index > &history)

float	yolo_box_iou (const std::array< float, 6 > &a, const std::array< float, 6 > &b)

float	dfl_decode (const float *logits, Index reg_max)

template<size_t... Kind>
array< Buffer, sizeof...(Kind)>	cuda_workspace_buffers (index_sequence< Kind... >)

bool	is_training (ForwardPropagationMode pass) noexcept

void	apply_clamping (const TensorView &, const TensorView &, const TensorView &, TensorView &)

void	rotary_build_tables (TensorView &, TensorView &, Index sequence_length, Index rotary_dim, float base)

void	rotary_forward (const TensorView &, const TensorView &, const TensorView &, TensorView &, Index head_dim, Index rotary_dim, Index position_offset)

void	grouped_attention_forward (const TensorView &query, const TensorView &key, const TensorView &value, TensorView &output, Index n_query_heads, Index n_kv_heads, Index head_dim, bool causal, float scale, Index query_position_offset=0, float decode_partials=nullptr, const int position_device=nullptr)

Index	grouped_attention_decode_scratch_floats (Index n_query_heads, Index head_dim)

void	qk_rope_cache_append (const TensorView &qkv_row, const TensorView &q_norm_weight, const TensorView &k_norm_weight, const TensorView &cos_table, const TensorView &sin_table, TensorView &q_out, TensorView &key_cache, TensorView &value_cache, Index n_query_heads, Index n_kv_heads, Index head_dim, float epsilon, const int *position_device)

void	qk_norm_forward (const TensorView &input, const TensorView &weight, TensorView &output, Index head_dim, float epsilon)

void	check_rank (const Shape &shape, initializer_list< int > allowed, const char layer, const char what)

const EnumMap< LayerType > &	layer_type_map ()

const std::string &	layer_type_to_string (LayerType)

LayerType	string_to_layer_type (const std::string &)

std::unique_ptr< Layer >	create_layer (const std::string &name)

void	pooling_2d_forward (const TensorView &, TensorView &, TensorView &, Index, Index, Index, Index, Index, Index, Index, Index, Index, bool max_pooling)

void	pooling_2d_backward (const TensorView &, const TensorView &, TensorView &, Index, Index, Index, Index, Index, Index, Index, Index, Index, bool max_pooling)

const string &	pooling_method_to_string (PoolingMethod)

PoolingMethod	string_to_pooling_method (const string &)

void	scale (const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, float, float, TensorView &)

void	unscale (const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, float, float, TensorView &)

OnnxModel	build_onnx_model (const Network &, const vector< string > &class_names={})

void	save_onnx_model (const Network &, const filesystem::path &, const vector< string > &class_names={})

bool	cudnn_rnn_supports_bf16 ()

void	dropout_forward (TensorView &, TensorView &, float)

void	dropout_backward (TensorView &, const TensorView &, float)

void	embedding_lookup_forward (const TensorView &, const TensorView &, const TensorView &, TensorView &, Index, Index, Index, bool scale_embedding, bool add_positional_encoding, const TensorView &weight_scale={})

void	embedding_lookup_backward (const TensorView &, const TensorView &, const TensorView &, const TensorView &, Index, Index, Index, bool scale_embedding)

void	compute_token_valid_lengths (const TensorView &, Index, vector< Index > &)

void	layer_normalization_forward (const TensorView &, const TensorView &, const TensorView &, TensorView &, TensorView &, TensorView &, TensorView &, float)

void	layer_normalization_add_forward (const TensorView &, const TensorView &, const TensorView &, const TensorView &, TensorView &, TensorView &, TensorView &, TensorView &, TensorView &, float)

void	layer_normalization_backward (const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, TensorView &, TensorView *=nullptr)

void	rms_normalization_forward (const TensorView &, const TensorView &, TensorView &, TensorView &, TensorView &, float)

void	rms_normalization_backward (const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, const TensorView &, TensorView &)

void	split_heads (const TensorView &, TensorView &)

void	concatenate_heads (const TensorView &, TensorView &)

bool	link_views (span< const TensorView > views, initializer_list< TensorView * > targets)

void	max_pooling_3d_forward (const TensorView &, TensorView &, TensorView &, bool is_training, SequenceLengths)

void	average_pooling_3d_forward (const TensorView &, TensorView &, SequenceLengths)

void	max_pooling_3d_backward (const TensorView &, const TensorView &, TensorView &)

void	average_pooling_3d_backward (const TensorView &, const TensorView &, TensorView &, SequenceLengths)

void	first_token_3d_forward (const TensorView &, TensorView &)

void	first_token_3d_backward (const TensorView &, TensorView &)

void	swiglu_forward (const TensorView &, const TensorView &, TensorView &)

void	swiglu_backward (const TensorView &, const TensorView &, const TensorView &, TensorView &, TensorView &)

vector< string >	make_vocabulary (const unordered_map< string_view, size_t > &, span< const string > reserved_tokens, Index maximum_size, Index minimum_frequency)

constexpr size_t	utf8_sequence_length (unsigned char lead) noexcept

constexpr bool	is_utf8_continuation (unsigned char byte) noexcept

unique_ptr< TokenizerOperator >	make_tokenizer_operator (string_view kind)

vector< string >	split_expression_list (const string &)

CompiledExpression	compile_expression (const string &, const vector< pair< string, Index > > &, const vector< pair< string, Index > > &)

CompiledExpression	compile_expression (const string &, const Network *, const string &role="Expression")

CompiledExpression	compile_elementary_symmetric (const vector< Index > &variables, const vector< float > &spans, Index order, float tolerance)

CompiledExpression	compile_integrality (const string &, const Network *)

CompiledExpression	compile_membership (const string &, const Network *, const vector< float > &allowed)

bool	is_output_coupled (const CompiledExpression &)

bool	is_univariate (const CompiledExpression &)

bool	is_bare_variable (const CompiledExpression &)

void	evaluate_input_gradient (const CompiledExpression &, const VectorR &point, const VectorR &output, VectorR &gradient)

VectorR	evaluate_input_gradient (const CompiledExpression &, const VectorR &point, const VectorR &output)

void	mean_squared_error (const TensorView &, const TensorView &, float &, float *)

void	mean_squared_error_gradient (const TensorView &, const TensorView &, const TensorView &)

void	mean_absolute_error (const TensorView &, const TensorView &, float &, float *)

void	mean_absolute_error_gradient (const TensorView &, const TensorView &, const TensorView &)

void	normalized_squared_error (const TensorView &, const TensorView &, float, float &, float *)

void	normalized_squared_error_gradient (const TensorView &, const TensorView &, float, const TensorView &)

void	weighted_squared_error (const TensorView &, const TensorView &, float, float, float &, float *)

void	weighted_squared_error_gradient (const TensorView &, const TensorView &, float, float, float, const TensorView &)

void	binary_cross_entropy (const TensorView &, const TensorView &, float &, float *)

void	binary_cross_entropy_logits (const TensorView &, const TensorView &, float &, float *)

void	binary_cross_entropy_logits_gradient (const TensorView &, const TensorView &, const TensorView &)

void	categorical_cross_entropy (const TensorView &, const TensorView &, float &, float *)

void	cross_entropy (const TensorView &, const TensorView &, float &, float *, bool)

void	cross_entropy_gradient (const TensorView &, const TensorView &, const TensorView &, bool)

void	minkowski_error (const TensorView &, const TensorView &, float, float &, float *)

void	minkowski_error_gradient (const TensorView &, const TensorView &, float, const TensorView &, bool on_gpu=false)

void	cross_entropy_3d (const TensorView &, const TensorView &, float &, Index &, Index &, float errors_device=nullptr, float reduction_device=nullptr)

void	cross_entropy_3d_gradient (const TensorView &, const TensorView &, const TensorView &, Index)

void	cross_entropy_3d_gradient_device_count (const TensorView &, const TensorView &, const TensorView &, const float *)

void	l1_regularization (const TensorView &, float, float &)

void	l1_regularization_gradient (const TensorView &, float, const TensorView &)

void	l2_regularization (const TensorView &, float, float &)

void	l2_regularization_gradient (const TensorView &, float, const TensorView &)

float	yolo_error_kernel (const TensorView &output, const TensorView &target, Index boxes_per_cell, Index classes_number, bool sigmoid_classes, YoloLambdas lam)

void	yolo_gradient_kernel (const TensorView &output, const TensorView &target, const TensorView &output_delta, Index boxes_per_cell, Index classes_number, bool sigmoid_classes, float inv_batch, YoloLambdas lam)

unique_ptr< Optimizer >	create_optimizer (const string &name)

Variables
constexpr float	LEAKY_RELU_SLOPE = 0.1f

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

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

constexpr float	POS_INFINITY = numeric_limits<float>::infinity()

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

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

constexpr float	SOFTMAX_MASK_VALUE = float(-1e9f)

constexpr ptrdiff_t	parallel_algorithm_min_size = 65536

constexpr float	INV_SQRT_2 = 0.70710678118654752440f

constexpr float	INV_SQRT_2_PI = 0.39894228040143267794f

constexpr float	SQRT_2_OVER_PI = 0.7978845608028654f

constexpr float	GELU_TANH_CUBIC = 0.044715f

static constexpr Index	ALIGN_BYTES = EIGEN_MAX_ALIGN_BYTES

static constexpr Index	ALIGN_ELEMENTS = ALIGN_BYTES / sizeof(float)

constexpr BlasComputeType	CUBLAS_COMPUTE_DTYPE = CUBLAS_COMPUTE_32F_FAST_TF32

const float	one = 1.0f

const float	zero = 0.0f

const vector< string >	positive_words

const vector< string >	negative_words

constexpr float	BN_EPSILON = 1e-5f

constexpr int	RNN_SHAPE_SLOTS = 3

constexpr float	GRADIENT_NORM_EPS = 1e-6f

Typedef Documentation

◆ array

template<typename T, size_t N>

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

◆ bfloat16

using opennn::bfloat16 = __nv_bfloat16

◆ BlasComputeType

using opennn::BlasComputeType = cublasComputeType_t

◆ BlasHandle

using opennn::BlasHandle = cublasHandle_t

◆ BlasLtHandle

using opennn::BlasLtHandle = cublasLtHandle_t

◆ BlasMathMode

using opennn::BlasMathMode = cublasMath_t

◆ BlasOperation

using opennn::BlasOperation = cublasOperation_t

◆ BlasPointerMode

using opennn::BlasPointerMode = cublasPointerMode_t

◆ ChatCallback

using opennn::ChatCallback = function<void(const ChatDelta&)>

◆ DeviceDataType

using opennn::DeviceDataType = cudaDataType_t

◆ DeviceEvent

using opennn::DeviceEvent = cudaEvent_t

◆ DeviceGraph

using opennn::DeviceGraph = cudaGraph_t

◆ DeviceGraphExec

using opennn::DeviceGraphExec = cudaGraphExec_t

◆ DeviceStream

using opennn::DeviceStream = cudaStream_t

◆ DnnDataType

using opennn::DnnDataType = cudnnDataType_t

◆ DnnDropoutDescriptor

using opennn::DnnDropoutDescriptor = cudnnDropoutDescriptor_t

◆ DnnHandle

using opennn::DnnHandle = cudnnHandle_t

◆ DnnOpTensorDescriptor

using opennn::DnnOpTensorDescriptor = cudnnOpTensorDescriptor_t

◆ DnnPoolingDescriptor

using opennn::DnnPoolingDescriptor = cudnnPoolingDescriptor_t

◆ DnnRNNDataDescriptor

using opennn::DnnRNNDataDescriptor = cudnnRNNDataDescriptor_t

◆ DnnRNNDescriptor

using opennn::DnnRNNDescriptor = cudnnRNNDescriptor_t

◆ DnnRNNMode

using opennn::DnnRNNMode = cudnnRNNMode_t

◆ DnnStatus

using opennn::DnnStatus = cudnnStatus_t

◆ DnnTensorDescriptor

using opennn::DnnTensorDescriptor = cudnnTensorDescriptor_t

◆ StringMap

template<typename Value>

using opennn::StringMap = unordered_map<string, Value, TransparentStringHash, equal_to<>>

◆ type

using opennn::type = float

Enumeration Type Documentation

◆ ActivationFunction

enum class opennn::ActivationFunction

strong

Enumerator
Identity
Sigmoid
Tanh
ReLU
Softmax
LeakyReLU
GELU
GELUTanh
SiLU

◆ BatchNormalization

enum class opennn::BatchNormalization

strong

Enumerator
No
Yes

◆ Blas

enum class opennn::Blas

strong

Enumerator
Eigen
Mkl

◆ CausalMask

enum class opennn::CausalMask

strong

Enumerator
No
Yes

◆ ChatRole

enum class opennn::ChatRole

strong

Enumerator
System
User
Assistant

◆ ColumnContiguity

enum class opennn::ColumnContiguity

strong

Enumerator
Unknown
NonContiguous
Contiguous

◆ ConfusionCell

enum class opennn::ConfusionCell

strong

Enumerator
TruePositive
FalsePositive
FalseNegative
TrueNegative

◆ DateFormat

enum opennn::DateFormat

Enumerator
Auto
Dmy
Mdy
Ymd

◆ DetectionClassActivation

enum class opennn::DetectionClassActivation

strong

Enumerator
Softmax
Sigmoid

◆ DetectionHeadKind

enum class opennn::DetectionHeadKind

strong

Enumerator
AnchorBased
AnchorFree

◆ Device

enum class opennn::Device

strong

Enumerator
Auto
CPU
CUDA

◆ ExpressionLinearity

enum class opennn::ExpressionLinearity

strong

Enumerator
Linear
Nonlinear

◆ FillMode

enum class opennn::FillMode

strong

Enumerator
Training
Validation
Inference

◆ FinishReason

enum class opennn::FinishReason

strong

Enumerator
Stop
MaximumTokens
ContextLimit

◆ ForwardPropagationMode

enum class opennn::ForwardPropagationMode

strong

Enumerator
Training
Inference

◆ ForwardSlotKind

enum class opennn::ForwardSlotKind

strong

Enumerator
Pooled
Transient
TrainingOnly

◆ GenerationChannel

enum class opennn::GenerationChannel

strong

Enumerator
Reasoning
Content

◆ LayerType

enum class opennn::LayerType

strong

Enumerator
Activation
Addition
Clamping
Concatenation
Convolutional
Dense
Detection
DetectionV8
Embedding
Flatten
LSTM
MultiHeadAttention
Normalization3d
GroupedQueryAttention
NonMaxSuppression
Pooling
Pooling3d
Recurrent
Scaling
Tokenizer
Unscaling
Upsampling
C2PSA
Count

◆ LinearEpilogue

enum class opennn::LinearEpilogue

strong

Enumerator
Default
Relu
Bias
ReluBias
ReluAuxBias
DRelu
GeluAuxBias
BiasGradient

◆ MemoryPoolStrategy

enum class opennn::MemoryPoolStrategy

strong

Enumerator
Chronological
Compact
ChronologicalLargestFirst
EarliestEndFirst
LatestEndFirst
LongestLifetimeFirst
ShortestLifetimeFirst

◆ NetworkTask

enum class opennn::NetworkTask

strong

Enumerator
Generic
Approximation
Classification
Forecasting
AnomalyDetection
ImageClassification
ObjectDetection
TextClassification
LanguageModeling

◆ NormalizationMethod

enum class opennn::NormalizationMethod

strong

Enumerator
LayerNorm
RMS

◆ PoolingMethod

enum class opennn::PoolingMethod

strong

Enumerator
MaxPooling
AveragePooling
FirstToken

◆ ReasoningMode

enum class opennn::ReasoningMode

strong

Enumerator
Automatic
Enabled
Disabled

◆ SampleRole

enum class opennn::SampleRole

strong

Enumerator
Training
Validation
Testing
None

◆ ScalerMethod

enum class opennn::ScalerMethod

strong

Enumerator
None
MinimumMaximum
MeanStandardDeviation
StandardDeviation
Logarithm
ImageMinMax

◆ Shuffle

enum class opennn::Shuffle

strong

Enumerator
No
Yes

◆ StoppingCondition

enum class opennn::StoppingCondition

strong

Enumerator
LossGoal
MinimumLossDecrease
MaximumValidationErrorIncreases
MaximumTime
MaximumEpochsNumber

◆ Trainability

enum class opennn::Trainability

strong

Enumerator
Frozen
Trainable

◆ Transpose

enum class opennn::Transpose

strong

Enumerator
No
Yes

◆ Type

enum class opennn::Type

strong

Enumerator
Auto
FP32
BF16
INT8

◆ VariableRole

enum class opennn::VariableRole

strong

Enumerator
None
Input
Target
Decoder
InputTarget
Time
Evaluation

◆ VariableType

enum class opennn::VariableType

strong

Enumerator
None
Numeric
Binary
Integer
Categorical
DateTime
Constant

Function Documentation

◆ activation_backward()

void opennn::activation_backward	(	const TensorView &	,
		TensorView &	,
		ActivationFunction	)

◆ activation_derivative_from_output_value()

float opennn::activation_derivative_from_output_value	(	ActivationFunction	function,
		float	y )

inline

◆ activation_derivative_from_output_values()

template<typename TensorType>

TensorType::PlainObject opennn::activation_derivative_from_output_values	(	ActivationFunction	function,
		const TensorType &	values )

◆ activation_dtype()

Type opennn::activation_dtype ( Type type )

inline

◆ activation_forward()

void opennn::activation_forward	(	TensorView &	,
		ActivationFunction	)

◆ activation_forward_value()

float opennn::activation_forward_value	(	ActivationFunction	function,
		float	x )

inline

◆ activation_forward_values()

template<typename TensorType>

TensorType::PlainObject opennn::activation_forward_values	(	ActivationFunction	function,
		const TensorType &	values )

◆ activation_function_from_string()

ActivationFunction opennn::activation_function_from_string ( const string & )

◆ activation_function_map()

const EnumMap< ActivationFunction > & opennn::activation_function_map ( )

◆ activation_function_to_string()

const string & opennn::activation_function_to_string ( ActivationFunction )

◆ activation_needs_input()

bool opennn::activation_needs_input ( ActivationFunction function )

◆ add()

void opennn::add	(	const TensorView &	,
		const TensorView &	,
		TensorView &	)

◆ add_json_field()

template<typename Value>

void opennn::add_json_field	(	JsonWriter &	writer,
		std::string_view	name,
		Value &&	value )

◆ align_up()

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

inline

◆ append_columns() [1/2]

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

◆ append_columns() [2/2]

MatrixR opennn::append_columns ( const pair< MatrixR, MatrixR > & )

◆ append_rows() [1/2]

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

◆ append_rows() [2/2]

pair< MatrixR, MatrixR > opennn::append_rows	(	const pair< MatrixR, MatrixR > &	,
		const pair< MatrixR, MatrixR > &	)

◆ append_utf8()

void opennn::append_utf8	(	string &	,
		uint32_t	)

◆ apply_clamping()

void opennn::apply_clamping	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	)

◆ apply_input_scaling()

void opennn::apply_input_scaling	(	Network *	,
		FeatureScaling	)

◆ ascii_lowercase()

string opennn::ascii_lowercase ( string_view )

◆ ascii_lowercase_in_place()

void opennn::ascii_lowercase_in_place ( string & )

noexcept

◆ autocorrelations()

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

◆ average_pooling_3d_backward()

void opennn::average_pooling_3d_backward	(	const TensorView &	,
		const TensorView &	,
		TensorView &	,
		SequenceLengths	)

◆ average_pooling_3d_forward()

void opennn::average_pooling_3d_forward	(	const TensorView &	,
		TensorView &	,
		SequenceLengths	)

◆ backward_step()

Index opennn::backward_step	(	Index	layers_number,
		Index	layer )

constexprnoexcept

◆ bf16_host_input_cast_enabled()

bool opennn::bf16_host_input_cast_enabled ( )

noexcept

◆ bfloat16_to_float_host()

float opennn::bfloat16_to_float_host ( const uint16_t value )

inline

◆ bias_for_gemm_bf16()

const void * opennn::bias_for_gemm_bf16 ( const TensorView & )

◆ bilinear_blend()

template<typename Pixel>

float opennn::bilinear_blend	(	Pixel	v00,
		Pixel	v01,
		Pixel	v10,
		Pixel	v11,
		float	dx,
		float	dy )

inline

◆ binary_cross_entropy()

void opennn::binary_cross_entropy	(	const TensorView &	,
		const TensorView &	,
		float &	,
		float *	)

◆ binary_cross_entropy_logits()

void opennn::binary_cross_entropy_logits	(	const TensorView &	,
		const TensorView &	,
		float &	,
		float *	)

◆ binary_cross_entropy_logits_gradient()

void opennn::binary_cross_entropy_logits_gradient	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	)

◆ blas_mkl_available()

bool opennn::blas_mkl_available ( )

◆ box_plot() [1/2]

BoxPlot opennn::box_plot ( const VectorR & )

◆ box_plot() [2/2]

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

◆ build_fold_partition()

vector< vector< Index > > opennn::build_fold_partition	(	Training *	training,
		Index	folds_number,
		Index	folds_seed = 0 )

◆ build_onnx_model()

OnnxModel opennn::build_onnx_model	(	const Network &	,
		const vector< string > &	class_names = {} )

◆ calculate_distances()

MatrixR opennn::calculate_distances ( const MatrixR & )

◆ calculate_rank()

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

◆ calculate_spearman_ranks()

VectorR opennn::calculate_spearman_ranks ( const VectorR & )

◆ capture_input_scaling()

FeatureScaling opennn::capture_input_scaling ( Dataset * )

◆ capture_parameter_snapshot()

ParameterSnapshot opennn::capture_parameter_snapshot ( Network * )

◆ categorical_cross_entropy()

void opennn::categorical_cross_entropy	(	const TensorView &	,
		const TensorView &	,
		float &	,
		float *	)

◆ ceil_div()

Index opennn::ceil_div	(	Index	value,
		Index	divisor )

inline

◆ check_rank()

void opennn::check_rank	(	const Shape &	shape,
		initializer_list< int >	allowed,
		const char *	layer,
		const char *	what )

inline

◆ classify_column_contiguity()

ColumnContiguity opennn::classify_column_contiguity ( const vector< Index > & indices )

inline

◆ compile_elementary_symmetric()

CompiledExpression opennn::compile_elementary_symmetric	(	const vector< Index > &	variables,
		const vector< float > &	spans,
		Index	order,
		float	tolerance )

◆ compile_expression() [1/2]

CompiledExpression opennn::compile_expression	(	const string &	,
		const Network *	,
		const string &	role = "Expression" )

◆ compile_expression() [2/2]

CompiledExpression opennn::compile_expression	(	const string &	,
		const vector< pair< string, Index > > &	,
		const vector< pair< string, Index > > &	)

◆ compile_integrality()

CompiledExpression opennn::compile_integrality	(	const string &	,
		const Network *	)

◆ compile_membership()

CompiledExpression opennn::compile_membership	(	const string &	,
		const Network *	,
		const vector< float > &	allowed )

◆ compute_token_valid_lengths()

void opennn::compute_token_valid_lengths	(	const TensorView &	,
		Index	,
		vector< Index > &	)

◆ concatenate_heads()

void opennn::concatenate_heads	(	const TensorView &	,
		TensorView &	)

◆ confidence_interval_z_correlation()

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

◆ contains() [1/2]

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

◆ contains() [2/2]

bool opennn::contains	(	initializer_list< string_view >	,
		string_view	)

◆ convert_string_vector()

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

◆ copy()

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

◆ copy_device_to_host_float() [1/2]

void opennn::copy_device_to_host_float	(	const void *	,
		Type	,
		Index	,
		float *	,
		DeviceStream	stream )

◆ copy_device_to_host_float() [2/2]

void opennn::copy_device_to_host_float	(	const void *	,
		Type	,
		Index	,
		float *	,
		DeviceStream	stream,
		vector< uint16_t > &	bf16_staging )

◆ correlation()

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

◆ correlation_spearman()

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

◆ create_input_selection()

unique_ptr< InputSelection > opennn::create_input_selection ( const string & name )

◆ create_layer()

std::unique_ptr< Layer > opennn::create_layer ( const std::string & name )

◆ create_optimizer()

unique_ptr< Optimizer > opennn::create_optimizer ( const string & name )

◆ cross_correlations()

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

◆ cross_entropy()

void opennn::cross_entropy	(	const TensorView &	,
		const TensorView &	,
		float &	,
		float *	,
		bool	)

◆ cross_entropy_3d()

void opennn::cross_entropy_3d	(	const TensorView &	,
		const TensorView &	,
		float &	,
		Index &	,
		Index &	,
		float *	errors_device = nullptr,
		float *	reduction_device = nullptr )

◆ cross_entropy_3d_gradient()

void opennn::cross_entropy_3d_gradient	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		Index	)

◆ cross_entropy_3d_gradient_device_count()

void opennn::cross_entropy_3d_gradient_device_count	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const float *	)

◆ cross_entropy_gradient()

void opennn::cross_entropy_gradient	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		bool	)

◆ cuda_workspace_buffers()

template<size_t... Kind>

array< Buffer, sizeof...(Kind)> opennn::cuda_workspace_buffers ( index_sequence< Kind... > )

◆ cudnn_rnn_supports_bf16()

bool opennn::cudnn_rnn_supports_bf16 ( )

◆ data_for_gemm_dtype()

const void * opennn::data_for_gemm_dtype	(	const TensorView &	,
		Type	)

◆ date_to_timestamp()

time_t opennn::date_to_timestamp	(	string_view	,
		Index	= 0,
		DateFormat	format = Auto )

◆ decide_number_format()

NumberFormat opennn::decide_number_format ( const NumberFormatVotes & )

◆ decode_yolo_detections()

vector< YoloDetection > opennn::decode_yolo_detections	(	span< const float >	,
		Index	,
		Index	,
		Index	,
		Index	)

◆ decode_yolo_fpn_detections()

vector< YoloDetection > opennn::decode_yolo_fpn_detections	(	const vector< YoloFpnHead > &	,
		Index	,
		Index	,
		Index	,
		Index	,
		float	confidence_threshold = 0.25f,
		float	iou_threshold = 0.45f )

◆ decode_yolo_v8_fpn_detections()

vector< YoloDetection > opennn::decode_yolo_v8_fpn_detections	(	const vector< YoloFpnHead > &	,
		Index	,
		Index	,
		Index	,
		Index	,
		float	confidence_threshold = 0.25f,
		float	iou_threshold = 0.45f,
		Index	reg_max = 1 )

◆ descriptives() [1/2]

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

◆ descriptives() [2/2]

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

◆ descriptives_field()

VectorR opennn::descriptives_field	(	const vector< Descriptives > &	descriptives,
		float Descriptives::*	member )

inline

◆ detect_date_format()

DateFormat opennn::detect_date_format ( string_view )

◆ dfl_decode()

float opennn::dfl_decode	(	const float *	logits,
		Index	reg_max )

inline

◆ display_progress_bar()

void opennn::display_progress_bar	(	Index	,
		Index	)

◆ download_files_if_missing()

void opennn::download_files_if_missing	(	const filesystem::path &	directory,
		string_view	base_url,
		const vector< string_view > &	filenames )

◆ download_if_missing()

void opennn::download_if_missing	(	const filesystem::path &	,
		const string &	)

◆ draw_k_hot()

bool opennn::draw_k_hot	(	Index	,
		Index	,
		const vector< char > &	,
		const vector< char > &	,
		vector< float > &	)

◆ dropout_backward()

void opennn::dropout_backward	(	TensorView &	,
		const TensorView &	,
		float	)

◆ dropout_forward()

void opennn::dropout_forward	(	TensorView &	,
		TensorView &	,
		float	)

◆ embedding_lookup_backward()

void opennn::embedding_lookup_backward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		Index	,
		Index	,
		Index	,
		bool	scale_embedding )

◆ embedding_lookup_forward()

void opennn::embedding_lookup_forward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	,
		Index	,
		Index	,
		Index	,
		bool	scale_embedding,
		bool	add_positional_encoding,
		const TensorView &	weight_scale = {} )

◆ ensure_bf16_gradient_workspace()

bfloat16 * opennn::ensure_bf16_gradient_workspace ( Index n )

inline

◆ ensure_bf16_to_fp32_workspace()

float * opennn::ensure_bf16_to_fp32_workspace ( Index n )

inline

◆ ensure_flash_attention_workspace()

float * opennn::ensure_flash_attention_workspace ( Index n )

inline

◆ ensure_int8_dequant_workspace()

bfloat16 * opennn::ensure_int8_dequant_workspace ( Index n )

inline

◆ ensure_shared_scratch()

void * opennn::ensure_shared_scratch ( size_t bytes )

inline

◆ ensure_workspace()

template<typename T>

T * opennn::ensure_workspace	(	device::GraphWorkspaceKind	kind,
		Index	count )

◆ ensure_workspace_bytes()

void * opennn::ensure_workspace_bytes	(	device::GraphWorkspaceKind	,
		Index	bytes )

◆ env_flag_enabled() [1/2]

bool opennn::env_flag_enabled ( const char * )

noexcept

◆ env_flag_enabled() [2/2]

bool opennn::env_flag_enabled	(	const char *	,
		bool	default_value )

noexcept

◆ env_int_or()

long long opennn::env_int_or	(	const char *	,
		long long	default_value )

noexcept

◆ evaluate_candidate()

CandidateEvaluation opennn::evaluate_candidate	(	Training *	,
		Network *	,
		Index	folds_number,
		const vector< vector< Index > > &	fold_partition,
		Index	trials_number,
		bool	use_validation_history_minimum,
		const function< void(Index, float, float, bool)> &	on_trial,
		const function< void(Index)> &	initialize_trial = {} )

◆ evaluate_folds()

FoldEvaluation opennn::evaluate_folds	(	Training *	training,
		const vector< vector< Index > > &	fold_partition )

◆ evaluate_input_gradient() [1/2]

VectorR opennn::evaluate_input_gradient	(	const CompiledExpression &	,
		const VectorR &	point,
		const VectorR &	output )

◆ evaluate_input_gradient() [2/2]

void opennn::evaluate_input_gradient	(	const CompiledExpression &	,
		const VectorR &	point,
		const VectorR &	output,
		VectorR &	gradient )

◆ exponential_correlation()

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

◆ extreme_indices()

vector< Index > opennn::extreme_indices ( const MatrixR & )

◆ farthest_point_fill()

void opennn::farthest_point_fill	(	const MatrixR &	distances,
		vector< Index > &	selection,
		Index	quota )

◆ fill_tensor_data()

void opennn::fill_tensor_data	(	const MatrixR &	,
		const vector< Index > &	,
		const vector< Index > &	,
		span< float >	,
		ColumnContiguity	= ColumnContiguity::Unknown )

◆ filter_missing_values() [1/2]

template<typename InputType, typename TargetType>

pair< InputType, TargetType > opennn::filter_missing_values	(	const InputType &	x,
		const TargetType &	y )

◆ filter_missing_values() [2/2]

VectorR opennn::filter_missing_values ( const VectorR & )

◆ finalize_selected_model()

void opennn::finalize_selected_model	(	Training *	,
		Network *	,
		const VectorR &	optimal_parameters,
		Index	folds_number,
		bool	display,
		const char *	selected_label )

◆ find_memory_pool_overlay()

Index opennn::find_memory_pool_overlay	(	const vector< MemoryPoolEntry > &	,
		const MemoryPoolPlan &	,
		Index	bytes,
		Index	first_step,
		Index	second_step )

◆ first_stopping_condition()

template<typename Condition>

optional< Condition > opennn::first_stopping_condition	(	const bool	display,
		initializer_list< StoppingCheck< Condition > >	checks )

◆ first_token_3d_backward()

void opennn::first_token_3d_backward	(	const TensorView &	,
		TensorView &	)

◆ first_token_3d_forward()

void opennn::first_token_3d_forward	(	const TensorView &	,
		TensorView &	)

◆ first_token_maybe_quoted()

string_view opennn::first_token_maybe_quoted	(	string_view	line,
		char	separator,
		bool	file_has_quotes,
		string &	scratch )

◆ float_2_bfloat16_host()

void opennn::float_2_bfloat16_host	(	const Index	count,
		const float *	source,
		uint16_t *	destination )

inline

◆ float_to_bfloat16_host()

uint16_t opennn::float_to_bfloat16_host ( const float value )

inline

◆ for_json_items()

template<typename Func>

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

◆ gelu_derivative()

float opennn::gelu_derivative ( float x )

inline

◆ gelu_tanh_derivative()

float opennn::gelu_tanh_derivative ( float x )

inline

◆ gelu_tanh_value()

float opennn::gelu_tanh_value ( float x )

inline

◆ gelu_value()

float opennn::gelu_value ( float x )

inline

◆ gemm_strided_batched_cuda()

void opennn::gemm_strided_batched_cuda	(	BlasOperation	transa,
		BlasOperation	transb,
		int	,
		int	,
		int	,
		const void *	,
		DeviceDataType	Atype,
		int	,
		long long	stride_a,
		const void *	,
		DeviceDataType	Btype,
		int	,
		long long	stride_b,
		void *	,
		DeviceDataType	Ctype,
		int	,
		long long	stride_c,
		int	,
		float	alpha = 1.0f,
		float	beta = 0.0f )

◆ get_aligned_bytes() [1/8]

Index opennn::get_aligned_bytes ( const TensorSpec & spec )

inline

◆ get_aligned_bytes() [2/8]

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

inline

◆ get_aligned_bytes() [3/8]

Index opennn::get_aligned_bytes ( const vector< TensorSpec > & specs )

inline

◆ get_aligned_bytes() [4/8]

Index opennn::get_aligned_bytes	(	const vector< TensorSpec > &	specs,
		Type	dtype )

inline

◆ get_aligned_bytes() [5/8]

Index opennn::get_aligned_bytes ( const vector< vector< TensorSpec > > & specs )

inline

◆ get_aligned_bytes() [6/8]

Index opennn::get_aligned_bytes	(	const vector< vector< TensorSpec > > &	specs,
		Type	dtype )

inline

◆ get_aligned_bytes() [7/8]

Index opennn::get_aligned_bytes	(	Index	count,
		Type	dtype )

inline

◆ get_aligned_bytes() [8/8]

Index opennn::get_aligned_bytes ( Index n_bytes )

inline

◆ get_aligned_size() [1/3]

Index opennn::get_aligned_size ( const vector< TensorSpec > & specs )

inline

◆ get_aligned_size() [2/3]

Index opennn::get_aligned_size ( const vector< vector< TensorSpec > > & specs )

inline

◆ get_aligned_size() [3/3]

Index opennn::get_aligned_size ( Index size )

inline

◆ get_categorical_blocks()

vector< pair< Index, Index > > opennn::get_categorical_blocks ( const vector< Variable > & )

◆ get_correlation_values()

MatrixR opennn::get_correlation_values ( const Tensor< Correlation, 2 > & )

◆ get_device()

ThreadPoolDevice & opennn::get_device ( )

◆ get_elapsed_time()

float opennn::get_elapsed_time ( chrono::steady_clock::time_point start )

◆ get_feature_dimensions()

vector< Index > opennn::get_feature_dimensions ( const vector< Variable > & variables )

inline

◆ get_features_number()

Index opennn::get_features_number ( const vector< Variable > & variables )

inline

◆ get_first_word()

string opennn::get_first_word ( const string & )

◆ get_json_root()

const Json * opennn::get_json_root	(	const JsonDocument &	,
		std::string_view	)

◆ get_nearest_points()

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

◆ get_random_element()

Index opennn::get_random_element ( const vector< Index > & )

◆ get_time()

string opennn::get_time ( float )

◆ get_token_views()

vector< string_view > opennn::get_token_views	(	string_view	,
		char	)

◆ get_token_views_maybe_quoted() [1/2]

vector< string_view > opennn::get_token_views_maybe_quoted	(	string_view	line,
		char	separator,
		bool	file_has_quotes,
		string &	scratch )

◆ get_token_views_maybe_quoted() [2/2]

void opennn::get_token_views_maybe_quoted	(	string_view	line,
		char	separator,
		bool	file_has_quotes,
		string &	scratch,
		vector< string_view > &	out )

◆ get_tokens()

vector< string > opennn::get_tokens	(	string_view	,
		string_view	)

◆ get_variable_columns()

vector< pair< string, Index > > opennn::get_variable_columns ( const vector< Variable > & )

◆ get_variable_feature_names()

vector< string > opennn::get_variable_feature_names ( const vector< Variable > & )

◆ glorot_limit()

float opennn::glorot_limit	(	Index	fan_in,
		Index	fan_out )

inline

◆ grouped_attention_decode_scratch_floats()

Index opennn::grouped_attention_decode_scratch_floats	(	Index	n_query_heads,
		Index	head_dim )

◆ grouped_attention_forward()

void opennn::grouped_attention_forward	(	const TensorView &	query,
		const TensorView &	key,
		const TensorView &	value,
		TensorView &	output,
		Index	n_query_heads,
		Index	n_kv_heads,
		Index	head_dim,
		bool	causal,
		float	scale,
		Index	query_position_offset = 0,
		float *	decode_partials = nullptr,
		const int *	position_device = nullptr )

◆ hash_combine()

template<typename... Vs>

size_t opennn::hash_combine ( const Vs &... values )

◆ histogram()

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_bare_variable()

bool opennn::is_bare_variable ( const CompiledExpression & )

◆ 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 ( string_view )

◆ is_file_current()

bool opennn::is_file_current	(	const filesystem::path &	file,
		const vector< filesystem::path > &	sources,
		uintmax_t	expected_size = 0 )

◆ is_numeric_string()

bool opennn::is_numeric_string	(	string_view	,
		const NumberFormat &	= {} )

◆ is_one_of()

template<typename T, typename... Candidates>

bool opennn::is_one_of	(	const T &	value,
		const Candidates &...	candidates )

constexpr

◆ is_output_coupled()

bool opennn::is_output_coupled ( const CompiledExpression & )

◆ is_supported_image_file()

bool opennn::is_supported_image_file ( const filesystem::path & )

◆ is_training()

bool opennn::is_training ( ForwardPropagationMode pass )

inlinenoexcept

◆ is_univariate()

bool opennn::is_univariate ( const CompiledExpression & )

◆ is_utf8_continuation()

bool opennn::is_utf8_continuation ( unsigned char byte )

inlineconstexprnoexcept

◆ join_strings()

string opennn::join_strings	(	span< const string >	,
		string_view	= " " )

◆ json_array()

template<typename Range>

Json opennn::json_array ( const Range & values )

◆ l1_regularization()

void opennn::l1_regularization	(	const TensorView &	,
		float	,
		float &	)

◆ l1_regularization_gradient()

void opennn::l1_regularization_gradient	(	const TensorView &	,
		float	,
		const TensorView &	)

◆ l2_regularization()

void opennn::l2_regularization	(	const TensorView &	,
		float	,
		float &	)

◆ l2_regularization_gradient()

void opennn::l2_regularization_gradient	(	const TensorView &	,
		float	,
		const TensorView &	)

◆ layer_normalization_add_forward()

void opennn::layer_normalization_add_forward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	,
		TensorView &	,
		TensorView &	,
		TensorView &	,
		TensorView &	,
		float	)

◆ layer_normalization_backward()

void opennn::layer_normalization_backward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	,
		TensorView *	= nullptr )

◆ layer_normalization_forward()

void opennn::layer_normalization_forward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	,
		TensorView &	,
		TensorView &	,
		TensorView &	,
		float	)

◆ layer_type_map()

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

◆ layer_type_to_string()

const std::string & opennn::layer_type_to_string ( LayerType )

◆ linear_backward()

void opennn::linear_backward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	,
		bool	accumulate_input_delta = false,
		const LinearBackwardOptions &	options = {} )

◆ linear_correlation()

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

◆ linear_correlation_spearman()

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

◆ linear_forward()

void opennn::linear_forward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	,
		LinearEpilogue	epilogue = LinearEpilogue::Bias,
		TensorView *	pre_activation = nullptr,
		const TensorView &	weight_scale = {},
		ActivationFunction	fused_activation = ActivationFunction::Identity )

◆ linear_forward_transposed()

void opennn::linear_forward_transposed	(	const TensorView &	input,
		const TensorView &	embed_weight,
		TensorView &	output,
		const TensorView &	weight_scale = {} )

◆ link_views()

bool opennn::link_views	(	span< const TensorView >	views,
		initializer_list< TensorView * >	targets )

inline

◆ list_directories()

vector< filesystem::path > opennn::list_directories	(	const filesystem::path &	directory,
		std::function< bool(const filesystem::path &)>	predicate )

◆ list_files()

vector< filesystem::path > opennn::list_files	(	const filesystem::path &	directory,
		std::function< bool(const filesystem::path &)>	predicate )

◆ load_darknet_backbone()

Index opennn::load_darknet_backbone	(	Network &	,
		const filesystem::path &	,
		Index	)

◆ load_darknet_backbone_v11()

Index opennn::load_darknet_backbone_v11	(	Network &	,
		const filesystem::path &	)

◆ load_image() [1/2]

Tensor3 opennn::load_image ( const filesystem::path & )

◆ load_image() [2/2]

void opennn::load_image	(	const filesystem::path &	,
		float *	,
		Index	,
		Index	,
		Index	)

◆ load_json_file()

JsonDocument opennn::load_json_file ( const std::filesystem::path & )

◆ load_yolov8s_onnx()

Index opennn::load_yolov8s_onnx	(	Network &	,
		const filesystem::path &	onnx_path,
		Index	n_classes )

◆ local_outlier_factor()

VectorR opennn::local_outlier_factor	(	const MatrixR &	,
		Index	)

◆ logarithmic_correlation()

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

◆ logistic_correlation() [1/2]

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

◆ logistic_correlation() [2/2]

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

◆ logistic_correlation_spearman()

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

◆ make_precision_plan()

PrecisionPlan opennn::make_precision_plan ( const Type type )

constexprnoexcept

◆ make_tokenizer_operator()

unique_ptr< TokenizerOperator > opennn::make_tokenizer_operator ( string_view kind )

◆ make_vocabulary()

vector< string > opennn::make_vocabulary	(	const unordered_map< string_view, size_t > &	,
		span< const string >	reserved_tokens,
		Index	maximum_size,
		Index	minimum_frequency )

◆ max_pooling_3d_backward()

void opennn::max_pooling_3d_backward	(	const TensorView &	,
		const TensorView &	,
		TensorView &	)

◆ max_pooling_3d_forward()

void opennn::max_pooling_3d_forward	(	const TensorView &	,
		TensorView &	,
		TensorView &	,
		bool	is_training,
		SequenceLengths	)

◆ 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_absolute_error()

void opennn::mean_absolute_error	(	const TensorView &	,
		const TensorView &	,
		float &	,
		float *	)

◆ mean_absolute_error_gradient()

void opennn::mean_absolute_error_gradient	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	)

◆ mean_squared_error()

void opennn::mean_squared_error	(	const TensorView &	,
		const TensorView &	,
		float &	,
		float *	)

◆ mean_squared_error_gradient()

void opennn::mean_squared_error_gradient	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	)

◆ median() [1/3]

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

◆ median() [2/3]

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

◆ median() [3/3]

float opennn::median ( const VectorR & )

◆ minimal_index()

Index opennn::minimal_index ( const VectorR & )

◆ 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 &	,
		const TensorView &	,
		float	,
		float &	,
		float *	)

◆ minkowski_error_gradient()

void opennn::minkowski_error_gradient	(	const TensorView &	,
		const TensorView &	,
		float	,
		const TensorView &	,
		bool	on_gpu = false )

◆ minmax_score() [1/2]

MatrixR opennn::minmax_score ( const MatrixR & )

◆ minmax_score() [2/2]

VectorR opennn::minmax_score	(	const VectorR &	,
		bool	invert = false )

◆ multiply()

void opennn::multiply	(	const TensorView &	,
		Transpose	,
		const TensorView &	,
		Transpose	,
		TensorView &	,
		float	alpha = 1.0f,
		float	beta = 0.0f )

◆ nearest_neighbors()

vector< VectorI > opennn::nearest_neighbors	(	const MatrixR &	,
		Index	)

◆ neighbor_distances()

VectorR opennn::neighbor_distances	(	const MatrixR &	,
		Index	)

◆ normalized_squared_error()

void opennn::normalized_squared_error	(	const TensorView &	,
		const TensorView &	,
		float	,
		float &	,
		float *	)

◆ normalized_squared_error_gradient()

void opennn::normalized_squared_error_gradient	(	const TensorView &	,
		const TensorView &	,
		float	,
		const TensorView &	)

◆ nth_element_parallel_if_large()

template<typename Iterator, typename Compare = less<>>

void opennn::nth_element_parallel_if_large	(	Iterator	first,
		Iterator	nth,
		Iterator	last,
		Compare	compare = {} )

◆ number_format_name()

string opennn::number_format_name ( char )

◆ number_format_separator()

char opennn::number_format_separator	(	const string &	,
		string_view	)

◆ operator<<()

template<typename T>

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

◆ parse_float()

float opennn::parse_float	(	string_view	,
		string_view	)

◆ parse_int()

int opennn::parse_int	(	string_view	,
		string_view	)

◆ parse_long()

long opennn::parse_long	(	string_view	,
		string_view	)

◆ parse_number()

template<typename T>

T opennn::parse_number	(	string_view	text,
		string_view	context,
		string_view	value_kind = "numeric" )

◆ parse_number_list()

template<typename T>

vector< T > opennn::parse_number_list	(	string_view	text,
		string_view	context,
		char	separator = ' ' )

◆ parse_real() [1/2]

bool opennn::parse_real	(	string_view	,
		double &	,
		const NumberFormat &	= {} )

◆ parse_real() [2/2]

bool opennn::parse_real	(	string_view	,
		float &	,
		const NumberFormat &	= {} )

◆ partial_shuffle()

template<typename T>

void opennn::partial_shuffle	(	vector< T > &	v,
		Index	count )

◆ plan_memory_pool()

MemoryPoolPlan opennn::plan_memory_pool	(	const vector< MemoryPoolEntry > &	,
		MemoryPoolStrategy	= MemoryPoolStrategy::Chronological )

◆ plan_memory_pool_best()

MemoryPoolPlan opennn::plan_memory_pool_best ( const vector< MemoryPoolEntry > & )

◆ pooling_2d_backward()

void opennn::pooling_2d_backward	(	const TensorView &	,
		const TensorView &	,
		TensorView &	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		bool	max_pooling )

◆ pooling_2d_forward()

void opennn::pooling_2d_forward	(	const TensorView &	,
		TensorView &	,
		TensorView &	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		Index	,
		bool	max_pooling )

◆ pooling_method_to_string()

const string & opennn::pooling_method_to_string ( PoolingMethod )

◆ power_correlation()

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

◆ qk_norm_forward()

void opennn::qk_norm_forward	(	const TensorView &	input,
		const TensorView &	weight,
		TensorView &	output,
		Index	head_dim,
		float	epsilon )

◆ qk_rope_cache_append()

void opennn::qk_rope_cache_append	(	const TensorView &	qkv_row,
		const TensorView &	q_norm_weight,
		const TensorView &	k_norm_weight,
		const TensorView &	cos_table,
		const TensorView &	sin_table,
		TensorView &	q_out,
		TensorView &	key_cache,
		TensorView &	value_cache,
		Index	n_query_heads,
		Index	n_kv_heads,
		Index	head_dim,
		float	epsilon,
		const int *	position_device )

◆ 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_normal()

float opennn::random_normal	(	float	= 0,
		float	= 1 )

◆ random_uniform()

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

◆ ranked_indices()

vector< Index > opennn::ranked_indices ( const VectorR & )

◆ read_binary_string()

bool opennn::read_binary_string	(	istream &	stream,
		string &	value )

inline

◆ read_binary_value()

bool opennn::read_binary_value	(	istream &	stream,
		RawStorable auto &	value )

◆ read_binary_values()

bool opennn::read_binary_values	(	istream &	stream,
		RawStorable auto &...	values )

◆ read_int32_batch()

void opennn::read_int32_batch	(	const FileReader &	,
		const vector< Index > &	sample_indices,
		Index	samples_number,
		uint64_t	record_values,
		Index	source_offset,
		Index	values_number,
		span< float >	output,
		Index	output_stride,
		Index	output_offset,
		string_view	context )

◆ read_json_bool() [1/2]

bool opennn::read_json_bool	(	const Json *	,
		std::string_view	)

◆ read_json_bool() [2/2]

bool opennn::read_json_bool	(	const Json *	,
		std::string_view	,
		bool	fallback )

◆ read_json_float() [1/2]

float opennn::read_json_float	(	const Json *	,
		std::string_view	)

◆ read_json_float() [2/2]

float opennn::read_json_float	(	const Json *	,
		std::string_view	,
		float	fallback )

◆ read_json_float_alias()

float opennn::read_json_float_alias	(	const Json *	,
		string_view	primary,
		string_view	legacy )

◆ read_json_index() [1/2]

long long opennn::read_json_index	(	const Json *	,
		std::string_view	)

◆ read_json_index() [2/2]

long long opennn::read_json_index	(	const Json *	,
		std::string_view	,
		long long	fallback )

◆ read_json_index_alias()

long long opennn::read_json_index_alias	(	const Json *	,
		string_view	primary,
		string_view	legacy )

◆ read_json_string() [1/2]

std::string opennn::read_json_string	(	const Json *	,
		std::string_view	)

◆ read_json_string() [2/2]

std::string opennn::read_json_string	(	const Json *	,
		std::string_view	,
		std::string_view	fallback )

◆ read_json_string_fallback()

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

◆ read_json_strings()

std::vector< std::string > opennn::read_json_strings	(	const Json *	,
		std::string_view	)

◆ read_text_file()

string opennn::read_text_file ( const filesystem::path & )

◆ refit_final_model_on_development()

void opennn::refit_final_model_on_development	(	Training *	training,
		Index	folds_number,
		Index	folds_seed = 0 )

◆ reflect_image_horizontal()

void opennn::reflect_image_horizontal ( TensorMap3 & )

◆ reflect_image_vertical()

void opennn::reflect_image_vertical ( TensorMap3 & )

◆ release_thread_workspaces()

void opennn::release_thread_workspaces ( )

◆ replace()

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

◆ replace_all_word_appearances()

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

◆ require_json_field()

const Json * opennn::require_json_field	(	const Json *	,
		std::string_view	)

◆ resize_image()

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

◆ resolve_column_contiguity()

bool opennn::resolve_column_contiguity	(	ColumnContiguity	column_contiguity,
		const vector< Index > &	indices )

inline

◆ rms_normalization_backward()

void opennn::rms_normalization_backward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	)

◆ rms_normalization_forward()

void opennn::rms_normalization_forward	(	const TensorView &	,
		const TensorView &	,
		TensorView &	,
		TensorView &	,
		TensorView &	,
		float	)

◆ role_applies_to()

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

inline

◆ rotary_build_tables()

void opennn::rotary_build_tables	(	TensorView &	,
		TensorView &	,
		Index	sequence_length,
		Index	rotary_dim,
		float	base )

◆ rotary_forward()

void opennn::rotary_forward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	,
		Index	head_dim,
		Index	rotary_dim,
		Index	position_offset )

◆ rotate_image()

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

◆ row_dominates()

bool opennn::row_dominates	(	const MatrixR &	,
		Index	,
		Index	)

◆ 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

◆ run_lt_matmul_cached()

void opennn::run_lt_matmul_cached	(	int	,
		int	,
		int	,
		BlasOperation	transA,
		BlasOperation	transB,
		LinearEpilogue	epilogue,
		const void *	,
		const void *	,
		void *	,
		const void *	,
		DeviceDataType	dtype_a = CUDA_R_32F,
		DeviceDataType	dtype_b = CUDA_R_32F,
		DeviceDataType	out_dtype = CUDA_R_32F,
		const void *	aux_pointer = nullptr,
		const void *	addend = nullptr,
		float	alpha = 1.0f,
		float	beta = 0.0f,
		int	lda = 0,
		int	ldb = 0,
		int	ldd = 0 )

◆ sample_role_map()

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

inline

◆ sample_role_to_string()

const string & opennn::sample_role_to_string ( SampleRole role )

inline

◆ sample_token()

Index opennn::sample_token	(	VectorR &	probabilities,
		const SamplingConfig &	,
		const vector< Index > &	history )

◆ save_json_file() [1/2]

void opennn::save_json_file	(	const std::filesystem::path &	,
		const JsonWriter &	)

◆ save_json_file() [2/2]

template<typename Serializable>

void opennn::save_json_file	(	const std::filesystem::path &	file_name,
		const Serializable &	serializable )

◆ save_onnx_model()

void opennn::save_onnx_model	(	const Network &	,
		const filesystem::path &	,
		const vector< string > &	class_names = {} )

◆ scale()

void opennn::scale	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		float	,
		float	,
		TensorView &	)

◆ scale_mean_standard_deviation_formula()

template<typename X>

auto opennn::scale_mean_standard_deviation_formula	(	const X &	x,
		const Descriptives &	d )

◆ scale_minimum_maximum_formula()

template<typename X>

auto opennn::scale_minimum_maximum_formula	(	const X &	x,
		const Descriptives &	d,
		float	min_range,
		float	max_range )

◆ scale_value()

float opennn::scale_value	(	ScalerMethod	method,
		const Descriptives &	desc,
		float	value,
		float	min_range = -1.0f,
		float	max_range = 1.0f )

inline

◆ 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

◆ scaling_affine()

AffineMap opennn::scaling_affine	(	ScalerMethod	scaler,
		const Descriptives &	descriptives,
		float	min_range,
		float	max_range )

inline

◆ ScopeExit()

template<typename F>

opennn::ScopeExit ( F ) -> ScopeExit< F >

◆ seed_parameters_from_snapshot()

void opennn::seed_parameters_from_snapshot	(	Network *	,
		const ParameterSnapshot &	,
		const vector< Index > &	input_row_map = {} )

◆ set_random_bernoulli()

void opennn::set_random_bernoulli	(	span< uint8_t >	,
		float	)

◆ 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_orthogonal()

void opennn::set_random_orthogonal ( MatrixMap )

◆ 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 )

◆ set_threads_number()

void opennn::set_threads_number ( int )

◆ shape_to_string()

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

◆ shuffle()

void opennn::shuffle ( VectorB & )

◆ shuffle_vector()

template<typename T>

void opennn::shuffle_vector ( vector< T > & )

◆ shuffle_vector_seeded()

template<typename T>

void opennn::shuffle_vector_seeded	(	vector< T > &	,
		unsigned	seed )

◆ silu_derivative()

float opennn::silu_derivative ( float x )

inline

◆ silu_value()

float opennn::silu_value ( float x )

inline

◆ slice_rows() [1/3]

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

◆ slice_rows() [2/3]

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

◆ slice_rows() [3/3]

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

◆ slot_or()

TensorView & opennn::slot_or	(	vector< TensorView > &	views,
		const vector< size_t > &	slot_indices,
		size_t	i,
		TensorView &	fallback )

inline

◆ softmax()

void opennn::softmax ( TensorView & )

◆ softmax_backward()

void opennn::softmax_backward	(	const TensorView &	,
		TensorView &	,
		float	alpha = 1.0f )

◆ sort_parallel_if_large()

template<typename Iterator, typename Compare = less<>>

void opennn::sort_parallel_if_large	(	Iterator	first,
		Iterator	last,
		Compare	compare = {} )

◆ split_expression_list()

vector< string > opennn::split_expression_list ( const string & )

◆ split_heads()

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

◆ split_views()

void opennn::split_views	(	string_view	,
		char	,
		vector< string_view > &	)

◆ stable_sort_parallel_if_large()

template<typename Iterator, typename Compare = less<>>

void opennn::stable_sort_parallel_if_large	(	Iterator	first,
		Iterator	last,
		Compare	compare = {} )

◆ standard_deviation()

float opennn::standard_deviation ( const VectorR & )

◆ starts_with_any()

bool opennn::starts_with_any	(	string_view	,
		initializer_list< string_view >	)

◆ string_to_layer_type()

LayerType opennn::string_to_layer_type ( const std::string & )

◆ string_to_pooling_method()

PoolingMethod opennn::string_to_pooling_method ( const string & )

◆ string_to_sample_role()

SampleRole opennn::string_to_sample_role ( string_view name )

inline

◆ string_to_scaler_method()

ScalerMethod opennn::string_to_scaler_method ( string_view name )

inline

◆ string_to_shape()

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

◆ string_to_variable_role()

VariableRole opennn::string_to_variable_role ( string_view name )

inline

◆ string_to_variable_type()

VariableType opennn::string_to_variable_type ( string_view name )

inline

◆ string_to_vector()

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

◆ swiglu_backward()

void opennn::swiglu_backward	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		TensorView &	,
		TensorView &	)

◆ swiglu_forward()

void opennn::swiglu_forward	(	const TensorView &	,
		const TensorView &	,
		TensorView &	)

◆ to_cuda()

DeviceDataType opennn::to_cuda ( Type type )

inline

◆ to_cudnn()

DnnDataType opennn::to_cudnn ( Type type )

inline

◆ to_int()

int opennn::to_int ( Index value )

inline

◆ to_type()

float opennn::to_type ( Index value )

inline

◆ tokenize()

vector< string > opennn::tokenize ( const string & )

◆ tokenize_views()

vector< string_view > opennn::tokenize_views ( string_view )

◆ translate_image_x()

void opennn::translate_image_x	(	TensorMap3 &	,
		Index	)

◆ translate_image_y()

void opennn::translate_image_y	(	TensorMap3 &	,
		Index	)

◆ trim_view()

string_view opennn::trim_view ( string_view )

◆ type_bytes()

Index opennn::type_bytes ( Type type )

inline

◆ unscale()

void opennn::unscale	(	const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		const TensorView &	,
		float	,
		float	,
		TensorView &	)

◆ unscale_mean_standard_deviation_formula()

template<typename X>

auto opennn::unscale_mean_standard_deviation_formula	(	const X &	x,
		const Descriptives &	d )

◆ unscale_minimum_maximum_formula()

template<typename X>

auto opennn::unscale_minimum_maximum_formula	(	const X &	x,
		const Descriptives &	d,
		float	min_range,
		float	max_range )

◆ unscaling_affine()

AffineMap opennn::unscaling_affine	(	ScalerMethod	scaler,
		const Descriptives &	descriptives,
		float	min_range,
		float	max_range )

inline

◆ use_parallel_algorithm()

bool opennn::use_parallel_algorithm ( ptrdiff_t size )

inlinenoexcept

◆ utf8_sequence_length()

size_t opennn::utf8_sequence_length ( unsigned char lead )

inlineconstexprnoexcept

◆ validate_selection_training()

void opennn::validate_selection_training	(	const Training *	,
		Index	folds_number,
		string_view	algorithm )

◆ 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

◆ variable_type_map()

const EnumMap< VariableType > & opennn::variable_type_map ( )

inline

◆ variable_type_to_string()

const string & opennn::variable_type_to_string ( VariableType type )

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_to_string() [1/3]

template<typename Derived>

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

inline

◆ vector_to_string() [2/3]

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

inline

◆ vector_to_string() [3/3]

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 )

◆ vote_number_format()

void opennn::vote_number_format	(	string_view	,
		NumberFormatVotes &	)

◆ weighted_squared_error()

void opennn::weighted_squared_error	(	const TensorView &	,
		const TensorView &	,
		float	,
		float	,
		float &	,
		float *	)

◆ weighted_squared_error_gradient()

void opennn::weighted_squared_error_gradient	(	const TensorView &	,
		const TensorView &	,
		float	,
		float	,
		float	,
		const TensorView &	)

◆ with_type_info()

template<typename F>

auto opennn::with_type_info	(	Type	type,
		const char *	caller,
		F &&	f )

inline

◆ write_binary_string()

void opennn::write_binary_string	(	FileWriter &	writer,
		const string &	value )

inline

◆ write_binary_value()

void opennn::write_binary_value	(	FileWriter &	writer,
		const RawStorable auto &	value )

◆ write_json()

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

◆ yolo_box_iou()

float opennn::yolo_box_iou	(	const std::array< float, 6 > &	a,
		const std::array< float, 6 > &	b )

inline

◆ yolo_error_kernel()

float opennn::yolo_error_kernel	(	const TensorView &	output,
		const TensorView &	target,
		Index	boxes_per_cell,
		Index	classes_number,
		bool	sigmoid_classes,
		YoloLambdas	lam )

◆ yolo_gradient_kernel()

void opennn::yolo_gradient_kernel	(	const TensorView &	output,
		const TensorView &	target,
		const TensorView &	output_delta,
		Index	boxes_per_cell,
		Index	classes_number,
		bool	sigmoid_classes,
		float	inv_batch,
		YoloLambdas	lam )

◆ 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

◆ BN_EPSILON

float opennn::BN_EPSILON = 1e-5f

inlineconstexpr

◆ CUBLAS_COMPUTE_DTYPE

BlasComputeType opennn::CUBLAS_COMPUTE_DTYPE = CUBLAS_COMPUTE_32F_FAST_TF32

constexpr

◆ EPSILON

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

constexpr

◆ GELU_TANH_CUBIC

float opennn::GELU_TANH_CUBIC = 0.044715f

inlineconstexpr

◆ GRADIENT_NORM_EPS

float opennn::GRADIENT_NORM_EPS = 1e-6f

inlineconstexpr

◆ INV_SQRT_2

float opennn::INV_SQRT_2 = 0.70710678118654752440f

inlineconstexpr

◆ INV_SQRT_2_PI

float opennn::INV_SQRT_2_PI = 0.39894228040143267794f

inlineconstexpr

◆ LEAKY_RELU_SLOPE

float opennn::LEAKY_RELU_SLOPE = 0.1f

inlineconstexpr

◆ MAX

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

constexpr

◆ NEG_INFINITY

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

constexpr

◆ negative_words

const vector<string> opennn::negative_words

extern

◆ one

const float opennn::one = 1.0f

inline

◆ parallel_algorithm_min_size

ptrdiff_t opennn::parallel_algorithm_min_size = 65536

inlineconstexpr

◆ POS_INFINITY

float opennn::POS_INFINITY = numeric_limits<float>::infinity()

constexpr

◆ positive_words

const vector<string> opennn::positive_words

extern

◆ QUIET_NAN

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

constexpr

◆ RNN_SHAPE_SLOTS

int opennn::RNN_SHAPE_SLOTS = 3

inlineconstexpr

◆ SOFTMAX_MASK_VALUE

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

constexpr

◆ SQRT_2_OVER_PI

float opennn::SQRT_2_OVER_PI = 0.7978845608028654f

inlineconstexpr

◆ zero

const float opennn::zero = 0.0f

inline

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ array

◆ bfloat16

◆ BlasComputeType

◆ BlasHandle

◆ BlasLtHandle

◆ BlasMathMode

◆ BlasOperation

◆ BlasPointerMode

◆ ChatCallback

◆ DeviceDataType

◆ DeviceEvent

◆ DeviceGraph

◆ DeviceGraphExec

◆ DeviceStream

◆ DnnDataType

◆ DnnDropoutDescriptor

◆ DnnHandle

◆ DnnOpTensorDescriptor

◆ DnnPoolingDescriptor

◆ DnnRNNDataDescriptor

◆ DnnRNNDescriptor

◆ DnnRNNMode

◆ DnnStatus

◆ DnnTensorDescriptor

◆ StringMap

◆ type

Enumeration Type Documentation

◆ ActivationFunction

◆ BatchNormalization

◆ Blas

◆ CausalMask

◆ ChatRole

◆ ColumnContiguity

◆ ConfusionCell

◆ DateFormat

◆ DetectionClassActivation

◆ DetectionHeadKind

◆ Device

◆ ExpressionLinearity

◆ FillMode

◆ FinishReason

◆ ForwardPropagationMode

◆ ForwardSlotKind

◆ GenerationChannel

◆ LayerType

◆ LinearEpilogue

◆ MemoryPoolStrategy

◆ NetworkTask

◆ NormalizationMethod

◆ PoolingMethod

◆ ReasoningMode

◆ SampleRole

◆ ScalerMethod

◆ Shuffle

◆ StoppingCondition

◆ Trainability

◆ Transpose

◆ Type

◆ VariableRole

◆ VariableType

Function Documentation

◆ activation_backward()

◆ activation_derivative_from_output_value()

◆ activation_derivative_from_output_values()

◆ activation_dtype()

◆ activation_forward()

◆ activation_forward_value()

◆ activation_forward_values()

◆ activation_function_from_string()

◆ activation_function_map()

◆ activation_function_to_string()

◆ activation_needs_input()