Namespaces
	Al

	callback

	cnpy_utils

	cufft

	data_packer

	dc

	details

	dnn_lib

	fft

	fftw

	file

	gpu

	gpu_lib

	graph

	internal

	kfac

	kfac_bn_util

	kfac_fc_conv_util

	kfac_gru_util

	lbann

	ltfb

	number_theory

	proto

	protobuf

	protobuf_utils

	stack_trace

	transform

	utils

	weights_details

Classes
class	AbsOperator
	Entrywise absolute value. More...

class	abstract_evaluation_layer
	Interface with objective function and metrics. More...

class	AccumulatingTimer
	Timer that accumulates mean and variance of timer durations as it goes. More...

class	adagrad

class	adam
	Adam optimizer. More...

class	argmax_layer
	Get index of maximum-value tensor entry. More...

class	argmin_layer
	Get index of minimum-value tensor entry. More...

struct	AsVirtualBase
	Declare `Base` to be a virtual base. More...

class	base_convolution_layer
	Computation kernels for convolution and deconvolution layers. More...

class	batch_functional_inference_algorithm
	Class for LBANN batch inference algorithms. More...

class	batch_normalization_layer
	Channel-wise batch normalization, including scale/bias. More...

class	BatchTerminationCriteria
	Stop SGD based on a fixed batch count. More...

class	batchwise_reduce_sum_layer
	Sum of tensor entries along batch dimension. More...

class	bernoulli_layer
	Random tensor with Bernoulli distribution. More...

class	beta_distribution

class	bilinear_resize_layer
	Resize image with bilinear interpolation. More...

class	buffered_data_coordinator

class	callback_base
	Base class for callbacks during training/testing. More...

class	categorical_accuracy_layer
	0-1 loss function More...

class	categorical_random_layer
	Random categorical outputs. More...

class	channelwise_fully_connected_layer
	Apply affine transformation to tensor channels. More...

class	channelwise_mean_layer

class	channelwise_scale_bias_layer
	Apply per-channel scale and bias. More...

class	channelwise_softmax_layer
	Apply softmax to tensor channels. More...

class	cifar10_reader

class	ClampOperator
	Constrain values to a range. More...

class	Cloneable
	Inject polymorphic clone functions into hierarchies. More...

class	Cloneable< HasAbstractFunction< T > >
	Specialization of Cloneable to handle the top of hierarchies. More...

class	Cloneable< HasAbstractFunction< T >, Base >

class	Cloneable< HasAbstractFunction< T >, Base... >
	Specialization of Cloneable for intermediate classes. More...

class	Cloneable< T >
	Specialization of Cloneable to handle stand-alone classes. More...

class	Cloneable< T, Base >

class	composite_image_transformation_layer
	Rotate a image clockwise around its center, then shear , then translate. More...

class	concatenate_layer
	Concatenate tensors along specified dimension. More...

class	constant_initializer
	Fill weights with a single constant value. More...

class	constant_layer
	Output tensor filled with a single value. More...

class	convolution_layer
	Convolution. More...

class	covariance_layer
	Estimate covariance. More...

class	crop_layer
	Extract crop from tensor at a position. More...

class	cross_entropy_layer
	Cross entropy between probability vectors. More...

class	cross_grid_sum_layer

class	cross_grid_sum_slice_layer

class	csv_reader

struct	CUDATypeT

struct	CUDATypeT< __half >

struct	CUDATypeT< double >

struct	CUDATypeT< El::Complex< double > >

struct	CUDATypeT< El::Complex< float > >

struct	CUDATypeT< float >

class	cuTENSOR_PermuteImpl
	cuTENSOR-based implementation of tensor permute. More...

class	cutout_layer
	Cutout a square from an image. More...

class	cuTT_PermuteImpl
	cuTT-based implementation of tensor permute. More...

class	data_buffer

class	data_coordinator

class	data_reader_jag_conduit

class	data_reader_merge_features

class	data_reader_merge_samples

class	data_reader_nci

class	data_reader_sample_list

class	data_reader_synthetic

class	data_store_conduit

class	data_type_distconv_adapter

class	data_type_layer

class	data_type_optimizer

class	data_type_weights

class	data_type_weights_initializer
	Scheme for initializing weight values. More...

struct	DataReaderMetaData
	Data structure containing metadata from the data readers. More...

class	dataset

class	deconvolution_layer
	Convolution transpose. More...

struct	default_key_error_policy

class	Describable
	A class that can generate self-descriptions. More...

class	description
	Generates nicely formatted description messages. More...

class	discrete_random_layer
	Random output from discrete distribution. More...

class	distconv_adapter

class	dropout
	Probabilistically drop layer outputs. More...

class	dummy_layer
	Placeholder layer with no child layers. More...

class	ElementwiseOperator
	Element-wise specific tensor operation sub-class. More...

class	elu_layer
	Exponential linear unit. More...

class	embedding_layer
	Lookup table to vectors of fixed size. More...

class	entrywise_batch_normalization_layer
	Entry-wise batch normalization, including scale/bias. More...

class	entrywise_scale_bias_layer
	Apply entry-wise scale and bias. More...

struct	enum_hash
	Hash function for enumeration type. More...

class	enum_iterator
	Create an iterator that goes over a contiguous (unit-step) enum class. More...

class	EpochTerminationCriteria

class	evaluation_layer

class	exception
	The base exception for LBANN errors. More...

class	ExecutionContext

struct	False
	Template that always has a 'value' field that evaluates to 'false'. More...

class	fully_connected_layer
	Affine transformation. More...

class	gather_layer
	Gather values from specified tensor indices. More...

class	gaussian_layer
	Random tensor with Gaussian/normal distribution. More...

struct	GenerateBuilderType_struct
	A helper struct for creating builder signatures. More...

class	generic_compound_data_reader

class	generic_data_reader

class	glorot_initializer
	Fill weights with variance of 2 / (fan-in + fan-out). More...

class	gru_layer
	Stacked gated recurrent unit. More...

class	hadamard_layer
	Entry-wise tensor product. More...

struct	HasAbstractFunction
	Declare that `T` has unimplemented virtual functions. More...

class	hdf5_data_reader

class	hdf5_reader

class	he_initializer
	Fill weights with variance of 2 / fan-in. More...

class	hypergradient_adam
	Hypergradient Adam optimizer. More...

class	identity_layer
	Output the input tensor. More...

class	identity_zero_layer
	Output tensor filled with a single value. More...

class	image_data_reader

class	imagenet_reader

class	in_top_k_layer
	One-hot vector indicating top-k entries. More...

class	input_layer
	Interface with data reader. More...

class	instance_norm_layer
	Normalize over data channels. More...

struct	interpret_as_byte_if_needed

struct	interpret_as_byte_if_needed< true, T >
	Use type T as is if Elemental has instantiated MPI wrappers for type T. More...

struct	interpret_as_byte_if_needed< true, void >
	For void pointers. More...

struct	io_rng_t

struct	is_instantiated_El_mpi_type
	By default, assume no instantiation for the type T in El::mpi. More...

struct	is_instantiated_El_mpi_type< T, void_t< typename std::enable_if< std::is_same< T, El::byte >::value\|\|std::is_same< T, short >::value\|\|std::is_same< T, int >::value\|\|std::is_same< T, unsigned >::value\|\|std::is_same< T, long int >::value\|\|std::is_same< T, unsigned long >::value\|\|std::is_same< T, float >::value\|\|std::is_same< T, double >::value\|\|std::is_same< T, El::Complex< float > >::value\|\|std::is_same< T, El::Complex< double > >::value >::type > >

struct	is_same

struct	IsCloneablePtrT

struct	IsCloneablePtrT< std::shared_ptr< T > >

struct	IsCloneablePtrT< std::unique_ptr< T, DeleterT > >

struct	IsCloneablePtrT< T * >

struct	IsCloneableT
	Predicate testing for Cloneable interface. More...

class	KFAC
	An implementation of the KFAC second-order optimization algorithm. More...

class	kfac_block

class	kfac_block_bn

class	kfac_block_channelwise_fc

class	kfac_block_fc_conv

class	kfac_block_gru

class	l1_norm_layer
	L1 vector norm. More...

class	l2_norm2_layer
	Square of L2 vector norm. More...

class	l2_weight_regularization
	Apply L2 regularization to a set of weights. More...

class	Layer
	Neural network tensor operation. More...

class	layer_metric

class	layer_norm_layer
	Normalize over data samples. More...

class	layer_term

class	lbann_comm

class	lbann_summary

class	leaky_relu_layer

class	lecun_initializer
	Fill weights with variance of 1 / fan-in. More...

class	local_response_normalization_layer
	Local response normalization. More...

struct	locked_io_rng_ref

class	log_sigmoid_layer
	Logarithm of sigmoid function. More...

class	log_softmax_layer
	Logarithm of softmax function. More...

class	LTFB
	An implementation of the LTFB training algorithm. More...

struct	make_void

class	matmul_layer
	Matrix multiplication. More...

class	mean_absolute_error_layer
	Mean absolute error. More...

class	mean_squared_error_layer
	Mean squared error. More...

class	mesh_reader

class	metric

struct	metric_statistics

class	mini_batch_index_layer
	Mini-batch index. More...

class	mini_batch_size_layer
	Mini-batch size. More...

class	mnist_reader

class	model
	Abstract base class for neural network models. More...

class	NamedVector

class	NonexistentArchiveFile

class	normal_initializer
	Draw weights values from a normal random distribution. More...

class	nullptr_key_error_policy
	Policy returning a nullptr if the id is unknown. More...

struct	NumericalTraits

class	numpy_initializer
	Fill weights with values from a NumPy file. More...

class	numpy_npz_conduit_reader

class	numpy_npz_reader

class	numpy_reader

class	objective_function

class	objective_function_term

class	one_hot_layer
	Convert index to a one-hot vector. More...

class	openmp_backend
	DNN library backend for hand-rolled, OMP-based implementations. More...

class	Operator
	Neural network tensor operation. More...

class	OperatorLayer
	Layer composed of one or more operator objects. More...

struct	OperatorTraits

struct	OperatorTraits< Operator< InputT, OutputT, D > >

class	optimizer
	Abstract base class for gradient-based optimization algorithms. More...

struct	pair_hash
	Hash function for `std::pair`. More...

struct	ParallelStrategy

struct	path_delimiter

class	PermuteLayer
	Permute the indices of a tensor. More...

class	persist

class	pilot2_molecular_reader

class	pooling_layer

class	ProfRegion
	RAII class for a prof region. More...

class	ProtobufSerializable
	Represents a class that is describable in LBANN's protobuf specification. More...

struct	prototext_fn_triple

class	ras_lipid_conduit_data_reader

class	reduction_layer
	Reduce tensor to scalar. More...

class	relu_layer
	Rectified linear unit. More...

class	reshape_layer
	Reinterpret tensor with new dimensions. More...

class	rmsprop

class	rng

class	RootedInputArchiveAdaptor

class	RootedOutputArchiveAdaptor

class	rotation_layer
	Rotate a image clockwise around its center. More...

class	rowwise_weights_norms_layer
	L2 norm of each row of a weights matrix. More...

class	RunningStats
	Accumulate mean, stddev, min, and max over a streaming data set. More...

class	sample_list

class	sample_list_conduit_io_handle

class	sample_list_hdf5

struct	sample_list_header

class	sample_list_ifstream

class	sample_list_open_files

class	scatter_layer
	Scatter values to specified tensor indices. More...

class	ScopeTimer

class	SecondsTerminationCriteria

class	SelectOperator

class	selu_dropout
	Scaled dropout for use with SELU activations. More...

class	selu_layer
	Scaled exponential rectified linear unit. More...

class	sgd
	Stochastic gradient descent optimizer. More...

class	SGDExecutionContext
	SGD Uses the step to track the Current mini-batch step for execution mode. More...

class	SGDTerminationCriteria
	Base class for SGD stopping. More...

class	SGDTrainingAlgorithm
	Base class for LBANN SGD-family training algorithms. More...

class	sigmoid_layer
	Special case of logistic function. More...

struct	size_t_pair_hash

class	slice_layer
	Slice tensor along a specified dimension. More...

class	smiles_data_reader

class	softmax_layer

class	softplus_layer
	Smooth approximation to ReLU function. More...

class	softsign_layer
	Smooth approximation to sign function. More...

class	sort_layer
	Sort tensor entries. More...

class	split_layer
	Present input tensor to multiple outputs. More...

class	stop_gradient_layer
	Block error signals during back propagation. More...

class	sum_layer
	Add multiple tensors. More...

class	tensor_overlap_constraints

class	TerminationCriteria
	Specifies when to stop a training algorithm. More...

class	tessellate_layer
	Repeat a tensor until it matches specified dimensions. More...

class	thread_pool

class	thread_safe_queue
	A queue that is safe for multiple threads to push to or pull from "simultaneously". More...

class	Timer
	An exceedingly simple duration calculator. More...

class	TimerMap
	A nesting inclusive-timer. More...

struct	ToComplexT

struct	ToComplexT< El::Complex< T > >

class	top_k_categorical_accuracy_layer

struct	ToRealT

struct	ToRealT< El::Complex< T > >

class	trainer
	User-facing class that represents a set of compute resources. More...

class	TrainingAlgorithm
	Base class for LBANN training_algorithms. More...

class	type_erased_function
	A move-only callable type for wrapping functions. More...

struct	TypeTag

class	uniform_hash_layer
	Apply a hash function to get uniformly distributed values. More...

class	uniform_initializer
	Draw weights values from a uniform random distribution. More...

class	uniform_layer
	Random tensor with uniform distribution. More...

class	unpooling_layer
	Transpose of pooling layer. More...

class	value_initializer
	Fill weights with values from a list. More...

class	variance_layer
	Estimate variance. More...

class	variance_scaling_initializer
	Generalization of "Xavier" initialization. More...

class	vectorwrapbuf
	Allow streams to be constructed on an existing data buffer without copying. More...

struct	ViewIfPossibleOrCopy

struct	ViewIfPossibleOrCopy< DataType, DataType >

class	weighted_sum_layer
	Add tensors with scaling factors. More...

class	weights

class	weights_initializer
	Scheme for initializing weight values. More...

class	weights_layer
	Output a weights tensor. More...

class	WeightsProxy
	Proxy a weights object as a different data type. More...

Typedefs
template<typename CppType >
using	CUDAScalar = typename CUDATypeT< CppType >::scalar_type

template<typename IndexT >
using	RowMajorDims = NamedVector< IndexT, struct RowMajorDimsTag >

template<typename IndexT >
using	ColMajorDims = NamedVector< IndexT, struct ColMajorDimsTag >

template<typename IndexT >
using	RowMajorStrides = NamedVector< IndexT, struct RowMajorStridesTag >

template<typename IndexT >
using	ColMajorStrides = NamedVector< IndexT, struct ColMajorStridesTag >

using	RowMajorPerm = NamedVector< int, struct RowMajorPermTag >

using	ColMajorPerm = NamedVector< int, struct ColMajorPermTag >

template<typename T , El::Device D>
using	DataParallelMatrixType = El::DistMatrix< T, El::Dist::STAR, El::Dist::VC, El::DistWrap::ELEMENT, D >
	The data type for data-parallel computation. More...

template<typename T , El::Device D>
using	ModelParallelMatrixType = El::DistMatrix< T, El::Dist::MC, El::Dist::MR, El::DistWrap::ELEMENT, D >

template<typename OpT >
using	InputValueType = typename OperatorTraits< OpT >::input_value_type

template<typename OpT >
using	OutputValueType = typename OperatorTraits< OpT >::output_value_type

template<typename OpT >
using	BaseOperatorType = typename OperatorTraits< OpT >::base_type

template<typename OpT >
using	InputDataParallelMatType = typename OperatorTraits< OpT >::input_data_parallel_mat_type

template<typename OpT >
using	OutputDataParallelMatType = typename OperatorTraits< OpT >::output_data_parallel_mat_type

template<typename OpT >
using	InputModelParallelMatType = typename OperatorTraits< OpT >::input_model_parallel_mat_type

template<typename OpT >
using	OutputModelParallelMatType = typename OperatorTraits< OpT >::output_model_parallel_mat_type

template<typename OpT >
using	InputTensorType = typename OperatorTraits< OpT >::input_tensor_type

template<typename OpT >
using	OutputTensorType = typename OperatorTraits< OpT >::output_tensor_type

template<typename OpT >
using	InputConstTensorType = typename OperatorTraits< OpT >::input_const_tensor_type

template<typename OpT >
using	OutputConstTensorType = typename OperatorTraits< OpT >::output_const_tensor_type

template<typename T >
using	observer_ptr = typename std::add_pointer< T >::type
	Creating an observer_ptr to complement the unique_ptr and shared_ptr. More...

using	world_comm_ptr = std::unique_ptr< lbann_comm, std::function< void(lbann_comm *)> >

using	AbsMat = El::AbstractMatrix< DataType >

using	CPUMat = El::Matrix< DataType, El::Device::CPU >

using	AbsDistMat = El::AbstractDistMatrix< DataType >

using	BaseDistMat = El::BaseDistMatrix

using	EGrid = El::Grid

using	Grid = El::Grid

template<El::Device D>
using	DMat = El::Matrix< DataType, D >

template<El::Device D>
using	AbsDistMatReadProxy = El::AbstractDistMatrixReadDeviceProxy< DataType, D >

using	ElMat = El::ElementalMatrix< DataType >

using	BlockMat = El::BlockMatrix< DataType >

template<typename TensorDataType >
using	CPUMatDT = El::Matrix< TensorDataType, El::Device::CPU >

template<typename TensorDataType , El::Device D>
using	MCMRMatDT = El::DistMatrix< TensorDataType, El::MC, El::MR, El::ELEMENT, D >

template<typename TensorDataType , El::Device D>
using	CircMatDT = El::DistMatrix< TensorDataType, El::CIRC, El::CIRC, El::ELEMENT, D >

template<typename TensorDataType , El::Device D>
using	StarMatDT = El::DistMatrix< TensorDataType, El::STAR, El::STAR, El::ELEMENT, D >

template<typename TensorDataType , El::Device D>
using	StarVCMatDT = El::DistMatrix< TensorDataType, El::STAR, El::VC, El::ELEMENT, D >

template<typename TensorDataType , El::Device D>
using	VCStarMatDT = El::DistMatrix< TensorDataType, El::VC, El::STAR, El::ELEMENT, D >

template<typename TensorDataType , El::Device D>
using	MCStarMatDT = El::DistMatrix< TensorDataType, El::MC, El::STAR, El::ELEMENT, D >
	ColSumStarVCMat. More...

template<typename TensorDataType , El::Device D>
using	MRStarMatDT = El::DistMatrix< TensorDataType, El::MR, El::STAR, El::ELEMENT, D >
	RowSumMat. More...

template<typename TensorDataType , El::Device D>
using	StarMRMatDT = El::DistMatrix< TensorDataType, El::STAR, El::MR, El::ELEMENT, D >
	ColSumMat. More...

template<typename TensorDataType >
using	DistMatDT = MCMRMatDT< TensorDataType, El::Device::CPU >

template<El::Device D>
using	MCMRMat = MCMRMatDT< DataType, D >

template<El::Device D>
using	CircMat = CircMatDT< DataType, D >

template<El::Device D>
using	StarMat = StarMatDT< DataType, D >

template<El::Device D>
using	StarVCMat = StarVCMatDT< DataType, D >

template<El::Device D>
using	VCStarMat = VCStarMatDT< DataType, D >

template<El::Device D>
using	MCStarMat = MCStarMatDT< DataType, D >
	ColSumStarVCMat. More...

template<El::Device D>
using	MRStarMat = MRStarMatDT< DataType, D >
	RowSumMat. More...

template<El::Device D>
using	StarMRMat = StarMRMatDT< DataType, D >
	ColSumMat. More...

using	DistMat = MCMRMat< El::Device::CPU >

using	Mat = El::Matrix< DataType, El::Device::CPU >

using	EvalType = double

using	execution_mode_iterator = enum_iterator< execution_mode, execution_mode::training, execution_mode::invalid >

using	TargetModeDimMap = std::unordered_map< data_reader_target_mode, std::vector< El::Int > >
	Map from target modes to dimension maps. More...

using	data_reader_target_mode_iterator = enum_iterator< data_reader_target_mode, data_reader_target_mode::CLASSIFICATION, data_reader_target_mode::NA >

using	data_field_dim_map_type = std::unordered_map< data_field_type, std::vector< El::Int > >
	Map from data_field_type to dimension maps. More...

using	SPModeSlicePoints = std::unordered_map< slice_points_mode, std::vector< El::Int > >
	Map from slice points modes to slice points. More...

using	slice_points_mode_iterator = enum_iterator< slice_points_mode, slice_points_mode::INDEPENDENT, slice_points_mode::NA >

using	data_field_type = std::string

template<typename... Ts>
using	void_t = typename make_void< Ts... >::type
	Alternative to c++17 std::void_t for older compilers. More...

using	TrainingAlgorithmFactory = generic_factory< TrainingAlgorithm, std::string, generate_builder_type< TrainingAlgorithm, google::protobuf::Message const & > >
	Factory for constructing training algorithms from protobuf messages. More...

using	TrainingAlgorithmBuilder = typename TrainingAlgorithmFactory::builder_type
	The builder type used to create a new training algorithm. More...

using	TrainingAlgorithmKey = typename TrainingAlgorithmFactory::id_type
	The trainining algorithm factory key. More...

using	persist_type_iterator = enum_iterator< persist_type, persist_type::train, persist_type::validation_context >

using	supported_layer_data_type = h2::meta::TL< float, double >

using	ViewingWeightsPtr = std::weak_ptr< weights >
	Smart pointer to reference a weights object. More...

using	OwningLayerPtr = std::shared_ptr< Layer >
	Smart pointer to manage ownership of a layer object. More...

using	ViewingLayerPtr = std::weak_ptr< Layer >
	Smart pointer to reference a layer object. More...

typedef Layer (	external_layer_setup_t) (lbann_data::DataType datatype, data_layout layout, El::Device device, lbann_comm *comm)

template<typename T , data_layout L, El::Device D>
using	dropout_layer = dropout< T, L, D >

using	OwningWeightsPtr = std::shared_ptr< weights >
	Smart pointer to manage ownership of a weights object. More...

using	supported_operator_data_type = h2::meta::TL< float, double, El::Complex< float >, El::Complex< double > >

using	default_arg_parser_type = utils::argument_parser< utils::strict_parsing >

template<typename T >
using	NonLeafClass = HasAbstractFunction< T >
	Alias for HasAbstractFunction. More...

template<typename T , typename... Bases>
using	AbstractCloneableBase = Cloneable< HasAbstractFunction< T >, Bases... >
	Helper metafunction for describing the top of a hierarchy that's cloneable. More...

using	Description = description
	Non-intrusive capitalization fix. More...

using	lbann_exception = exception

template<class BaseT , typename KeyT , typename BuilderT = std::function<std::unique_ptr<BaseT>()>, template< typename, class > class KeyErrorPolicy = default_key_error_policy>
using	generic_factory = h2::factory::ObjectFactory< BaseT, KeyT, BuilderT, KeyErrorPolicy >
	Generic factory template. More...

template<typename OutT , typename... Args>
using	generate_builder_type = typename GenerateBuilderType_struct< OutT, Args... >::type
	A helper typedef for wrapping builder signatures. More...

template<typename T >
using	ToReal = typename ToRealT< T >::type

template<typename T >
using	ToComplex = typename ToComplexT< T >::type

using	rng_gen = std::mt19937

using	fast_rng_gen = std::minstd_rand

template<typename T , typename U >
using	BiggerOf = typename std::conditional<(sizeof(T) > sizeof(U)), T, U >::type

using	visitor_hook_iterator = enum_iterator< visitor_hook, visitor_hook::setup_begin, visitor_hook::invalid >

template<typename TensorDataType >
using	weights_proxy = WeightsProxy< TensorDataType >

Enumerations
enum	matrix_format { matrix_format::MC_MR, matrix_format::CIRC_CIRC, matrix_format::STAR_STAR, matrix_format::STAR_VC, matrix_format::MC_STAR, matrix_format::invalid }
	Distributed matrix format. More...

enum	BackpropRequirements { PROPAGATE_NOTHING = 0, ERROR_SIGNALS = 1, PREV_ACTIVATIONS = 2, ACTIVATIONS = 4, WEIGHTS = 8 }
	Backpropagation requirements from a layer or operator. More...

enum	data_layout { data_layout::MODEL_PARALLEL, data_layout::DATA_PARALLEL, data_layout::invalid }
	Data layout that is optimized for different modes of parallelism. More...

enum	execution_mode { execution_mode::training, execution_mode::validation, execution_mode::testing, execution_mode::prediction, execution_mode::tournament, execution_mode::inference, execution_mode::invalid }
	Neural network execution mode. More...

enum	GridType { GridType::NO_GRID = 0, GridType::PRIMARY_GRID = 1, GridType::SECONDARY_GRID = 2 }

enum	data_reader_target_mode { data_reader_target_mode::CLASSIFICATION, data_reader_target_mode::REGRESSION, data_reader_target_mode::RECONSTRUCTION, data_reader_target_mode::LABEL_RECONSTRUCTION, data_reader_target_mode::INPUT, data_reader_target_mode::NA }

enum	slice_points_mode { slice_points_mode::INDEPENDENT, slice_points_mode::DEPENDENT, slice_points_mode::NA }

enum	persist_type { persist_type::train, persist_type::model, persist_type::metrics, persist_type::validate, persist_type::testing, persist_type::inference_context, persist_type::prediction_context, persist_type::training_context, persist_type::testing_context, persist_type::tournament_context, persist_type::validation_context }

enum	callback_type { callback_type::model_only, callback_type::weights_only, callback_type::execution_context_only, callback_type::full_checkpoint, callback_type::invalid }

enum	SubGraphCommunication { PT2PT = 0, COLL = 10, COLL_OPT = 2 }

enum	batch_normalization_stats_aggregation { batch_normalization_stats_aggregation::local, batch_normalization_stats_aggregation::node_local, batch_normalization_stats_aggregation::global }

enum	reduction_mode { reduction_mode::INVALID, reduction_mode::SUM, reduction_mode::AVERAGE }

enum	optimizer_gradient_status { optimizer_gradient_status::ready, optimizer_gradient_status::cleared, optimizer_gradient_status::allreduce_needed, optimizer_gradient_status::allreduce_started }
	Status of values in objective function gradient. More...

enum	fwd_conv_alg { fwd_conv_alg::IMPLICIT_GEMM, fwd_conv_alg::IMPLICIT_PRECOMP_GEMM, fwd_conv_alg::GEMM, fwd_conv_alg::DIRECT, fwd_conv_alg::FFT, fwd_conv_alg::FFT_TILING, fwd_conv_alg::WINOGRAD, fwd_conv_alg::WINOGRAD_NONFUSED }
	Which forward convolution algorithm to use. More...

enum	bwd_data_conv_alg { bwd_data_conv_alg::CUDNN_ALGO_0, bwd_data_conv_alg::CUDNN_ALGO_1, bwd_data_conv_alg::FFT, bwd_data_conv_alg::FFT_TILING, bwd_data_conv_alg::WINOGRAD, bwd_data_conv_alg::WINOGRAD_NONFUSED, bwd_data_conv_alg::IMPLICIT_GEMM }
	Which backward convolution algorithm to use. More...

enum	bwd_filter_conv_alg { bwd_filter_conv_alg::CUDNN_ALGO_0, bwd_filter_conv_alg::CUDNN_ALGO_1, bwd_filter_conv_alg::FFT, bwd_filter_conv_alg::CUDNN_ALGO_3, bwd_filter_conv_alg::WINOGRAD, bwd_filter_conv_alg::WINOGRAD_NONFUSED, bwd_filter_conv_alg::FFT_TILING, bwd_filter_conv_alg::IMPLICIT_GEMM }
	Which backward convolution filter algorithm to use. More...

enum	lrn_mode { lrn_mode::CROSS_CHANNEL_DIM1 }
	Internal LBANN names for supported LRN layer modes. More...

enum	pooling_mode { pooling_mode::MAX, pooling_mode::AVERAGE_COUNT_INCLUDE_PADDING, pooling_mode::AVERAGE_COUNT_EXCLUDE_PADDING, pooling_mode::MAX_DETERMINISTIC }
	Which pooling mode to use. More...

enum	softmax_mode { softmax_mode::INVALID, softmax_mode::INSTANCE, softmax_mode::CHANNEL }
	Which tensor dimensions to apply softmax over. More...

enum	softmax_alg { softmax_alg::FAST, softmax_alg::ACCURATE, softmax_alg::LOG }
	Internal LBANN names for supported softmax algorithms. More...

enum	probability_distribution { probability_distribution::invalid, probability_distribution::gaussian, probability_distribution::bernoulli, probability_distribution::uniform }

enum	visitor_hook { visitor_hook::setup_begin, visitor_hook::setup_end, visitor_hook::phase_end, visitor_hook::epoch_begin, visitor_hook::epoch_end, visitor_hook::optimize_begin, visitor_hook::optimize_end, visitor_hook::execution_mode_begin, visitor_hook::execution_mode_end, visitor_hook::execution_mode_batch_begin, visitor_hook::execution_mode_batch_end, visitor_hook::execution_mode_forward_prop_begin, visitor_hook::execution_mode_forward_prop_end, visitor_hook::execution_mode_backward_prop_begin, visitor_hook::execution_mode_backward_prop_end, visitor_hook::invalid }
	Neural network execution mode. More...

Functions
static cutensorHandle_t	make_handle ()

static cutensorHandle_t *	get_handle_ptr ()

template<typename IndexT >
void	convert (RowMajorDims< IndexT > const &src, ColMajorDims< IndexT > &tgt)

template<typename IndexT >
void	convert (ColMajorDims< IndexT > const &src, RowMajorDims< IndexT > &tgt)

template<typename IndexT >
void	convert (RowMajorStrides< IndexT > const &src, ColMajorStrides< IndexT > &tgt)

template<typename IndexT >
void	convert (ColMajorStrides< IndexT > const &src, RowMajorStrides< IndexT > &tgt)

void	switch_perm_majorness (std::vector< int > const &in, std::vector< int > &out)

void	convert (RowMajorPerm const &src, ColMajorPerm &tgt)

void	convert (ColMajorPerm const &src, RowMajorPerm &tgt)

template<typename OutT , typename InT >
auto	vec_convert (std::vector< InT > const &in)
	Copy the input vector to a new type. More...

world_comm_ptr	initialize (int &argc, char **&argv)

std::unique_ptr< lbann_comm >	initialize_lbann (int argc, char **argv)
	Initialize LBANN for use with external applcations. More...

std::unique_ptr< lbann_comm >	initialize_lbann (MPI_Comm c)
	Initialize LBANN for use with external applcations. More...

std::unique_ptr< lbann_comm >	initialize_lbann (El::mpi::Comm &&c)
	Initialize LBANN for use with external applcations. More...

void	finalize_lbann (lbann_comm *comm=nullptr)
	Destroy LBANN communicator for external application. More...

void	finalize (lbann_comm *comm=nullptr)

std::string	to_string (El::Device const &d)

El::Device	device_from_string (std::string const &str)

matrix_format	data_layout_to_matrix_format (data_layout layout)

std::string	to_string (data_layout const &dl)

data_layout	data_layout_from_string (std::string const &str)

std::string	to_string (execution_mode m)

execution_mode	exec_mode_from_string (std::string const &str)
	Convert a string to an execution_mode. More...

bool	endsWith (const std::string mainStr, const std::string &toMatch)

void	print_matrix_dims (AbsDistMat m, const char name)
	Print the dimensions and name of a Elemental matrix. More...

void	print_local_matrix_dims (AbsMat m, const char name)
	Print the dimensions and name of a Elemental matrix. More...

void	lbann_mpi_err_handler (MPI_Comm comm, int err_code,...)

int	get_rank_in_world ()

template<>
void	lbann_comm::broadcast< std::string > (int root, std::string &str, const El::mpi::Comm &c) const
	Broadcast std::string over an arbitrary communicator. More...

	PROTO (float)

	PROTO (double)

template<typename T >
void	set_minibatch_item (Mat &M, const int mb_idx, const T *const ptr, const size_t count)

bool	is_hdf5_metadata_key_valid (std::string const &key)

bool	is_hdf5_field_channels_last (conduit::Node const &field)

bool	does_hdf5_field_require_repack_to_channels_first (conduit::Node const &metadata)

std::string	conduit_to_string (conduit::Node const &field)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (int8_t, conduit::DataType::INT8_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (int16_t, conduit::DataType::INT16_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (int32_t, conduit::DataType::INT32_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (int64_t, conduit::DataType::INT64_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (uint8_t, conduit::DataType::UINT8_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (uint16_t, conduit::DataType::UINT16_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (uint32_t, conduit::DataType::UINT32_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (uint64_t, conduit::DataType::UINT64_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (float, conduit::DataType::FLOAT32_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (double, conduit::DataType::FLOAT64_ID)

	_LBANN_CONDUIT_DTYPE_INSTANTIATION_ (char *, conduit::DataType::CHAR8_STR_ID)

template<typename TN >
bool	is_same_type (const conduit::DataType::TypeID dt)

std::string	to_string (data_reader_target_mode m)

std::string	to_string (const slice_points_mode m)

slice_points_mode	slice_points_mode_from_string (const std::string &m)

void	handle_mpi_error (int ierr)

template<typename T >
T	uninitialized_sample_name ()

template<>
conduit::relay::io::IOHandle *	uninitialized_file_handle< conduit::relay::io::IOHandle * > ()

template<>
hid_t	uninitialized_file_handle< hid_t > ()

template<>
std::ifstream *	uninitialized_file_handle< std::ifstream * > ()

template<typename T >
std::string	to_string (const T val)

template<>
std::string	to_string (const std::string val)

template<typename sample_name_t >
auto	to_sample_name_t (const std::string &sn_str) -> decltype(sample_name_t())

template<>
int	to_sample_name_t< int > (const std::string &sn_str)

template<>
long	to_sample_name_t< long > (const std::string &sn_str)

template<>
unsigned long	to_sample_name_t< unsigned long > (const std::string &sn_str)

template<>
long long	to_sample_name_t< long long > (const std::string &sn_str)

template<>
unsigned long long	to_sample_name_t< unsigned long long > (const std::string &sn_str)

template<>
float	to_sample_name_t< float > (const std::string &sn_str)

template<>
double	to_sample_name_t< double > (const std::string &sn_str)

template<>
long double	to_sample_name_t< long double > (const std::string &sn_str)

template<>
std::string	to_sample_name_t< std::string > (const std::string &sn_str)

template<>
size_t	uninitialized_sample_name< size_t > ()

template<>
std::string	uninitialized_sample_name< std::string > ()

template<typename sample_name_t >
sample_name_t	uninitialized_sample_name ()

template<typename T >
T	uninitialized_file_handle ()

void	register_new_training_algorithm (TrainingAlgorithmKey key, TrainingAlgorithmBuilder builder)
	Register a new training algorithm with the default factory. More...

template<>
std::unique_ptr< ltfb::MetaLearningStrategy >	make_abstract< ltfb::MetaLearningStrategy > (const google::protobuf::Message &msg)

template<>
std::unique_ptr< SGDTrainingAlgorithm >	make< SGDTrainingAlgorithm > (google::protobuf::Message const &params)

int	makedir (const char *dirname)

int	exists (const char *filename)

int	openread (const char *filename)

int	closeread (int fd, const char *filename)

int	openwrite (const char *filename)

int	closewrite (int fd, const char *filename)

persist_type	execution_mode_to_persist_type (execution_mode m)

std::string	to_string (persist_type pt)

bool	write_bytes (int fd, const char name, const void buf, size_t size)

bool	read_bytes (int fd, const char name, void buf, size_t size)

bool	write_string (int fd, const char name, const char buf, size_t size)

bool	read_string (int fd, const char name, char buf, size_t size)

template<typename C >
void	write_cereal_archive (C &obj, const std::string &filename)

template<typename C >
void	write_cereal_archive (C &obj, persist &p, const std::string &filename)

template<typename C >
void	write_cereal_archive (C &obj, persist &p, persist_type pt, const std::string &suffix)

template<typename C >
void	write_cereal_archive (C &obj, persist &p, execution_mode mode, const std::string &suffix)

template<typename C >
void	read_cereal_archive (C &obj, const std::string &filename)

template<typename C >
void	read_cereal_archive (C &obj, persist &p, const std::string &filename)

template<typename C >
void	read_cereal_archive (C &obj, persist &p, persist_type pt, const std::string &suffix)

template<typename C >
void	read_cereal_archive (C &obj, persist &p, execution_mode mode, const std::string &suffix)

template<typename C >
std::string	create_cereal_archive_binary_string (C &obj)

template<typename C >
void	unpack_cereal_archive_binary_string (C &obj, const std::string &buf)

template<typename C >
void	load_from_shared_cereal_archive (C &obj, lbann_comm &comm, const std::string &filename)

template<typename C >
void	load_from_shared_cereal_archive (C &obj, persist &p, lbann_comm &comm, const std::string &filename)

template<typename C >
void	load_from_shared_cereal_archive (C &obj, persist &p, persist_type pt, lbann_comm &comm, const std::string &suffix)

template<typename C >
void	load_from_shared_cereal_archive (C &obj, persist &p, execution_mode mode, lbann_comm &comm, const std::string &suffix)

	LBANN_DEFINE_LAYER_BUILDER (elu)

	LBANN_DEFINE_LAYER_BUILDER (identity)

	LBANN_DEFINE_LAYER_BUILDER (leaky_relu)

	LBANN_DEFINE_LAYER_BUILDER (log_softmax)

	LBANN_DEFINE_LAYER_BUILDER (relu)

	LBANN_DEFINE_LAYER_BUILDER (softmax)

	LBANN_DEFINE_LAYER_BUILDER (bilinear_resize)

	LBANN_DEFINE_LAYER_BUILDER (composite_image_transformation)

	LBANN_DEFINE_LAYER_BUILDER (rotation)

	LBANN_DEFINE_LAYER_BUILDER (cutout)

	LBANN_DEFINE_LAYER_BUILDER (input)

std::ostream &	operator<< (std::ostream &os, const ParallelStrategy &ps)

std::ostream &	print_parallel_strategy_header (std::ostream &os)

	LBANN_DEFINE_LAYER_BUILDER (channelwise_fully_connected)

	LBANN_DEFINE_LAYER_BUILDER (channelwise_scale_bias)

	LBANN_DEFINE_LAYER_BUILDER (convolution)

	LBANN_DEFINE_LAYER_BUILDER (deconvolution)

	LBANN_DEFINE_LAYER_BUILDER (embedding)

	LBANN_DEFINE_LAYER_BUILDER (entrywise_scale_bias)

	LBANN_DEFINE_LAYER_BUILDER (fully_connected)

	LBANN_DEFINE_LAYER_BUILDER (gru)

	LBANN_DEFINE_LAYER_BUILDER (categorical_accuracy)

	LBANN_DEFINE_LAYER_BUILDER (cross_entropy)

	LBANN_DEFINE_LAYER_BUILDER (l1_norm)

	LBANN_DEFINE_LAYER_BUILDER (l2_norm2)

	LBANN_DEFINE_LAYER_BUILDER (mean_absolute_error)

	LBANN_DEFINE_LAYER_BUILDER (mean_squared_error)

	LBANN_DEFINE_LAYER_BUILDER (top_k_categorical_accuracy)

	LBANN_DEFINE_LAYER_BUILDER (matmul)

external_layer_setup_t	load_external_library (const std::string &filename, const std::string &layer_name)
	Create layer from an external library. More...

	LBANN_DEFINE_LAYER_BUILDER (argmax)

	LBANN_DEFINE_LAYER_BUILDER (argmin)

	LBANN_DEFINE_LAYER_BUILDER (channelwise_mean)

	LBANN_DEFINE_LAYER_BUILDER (channelwise_softmax)

	LBANN_DEFINE_LAYER_BUILDER (covariance)

	LBANN_DEFINE_LAYER_BUILDER (dft_abs)

	LBANN_DEFINE_LAYER_BUILDER (dist_embedding)

	LBANN_DEFINE_LAYER_BUILDER (external)

	LBANN_DEFINE_LAYER_BUILDER (mini_batch_index)

	LBANN_DEFINE_LAYER_BUILDER (mini_batch_size)

	LBANN_DEFINE_LAYER_BUILDER (one_hot)

	LBANN_DEFINE_LAYER_BUILDER (rowwise_weights_norms)

	LBANN_DEFINE_LAYER_BUILDER (uniform_hash)

	LBANN_DEFINE_LAYER_BUILDER (variance)

template<typename InputT , typename OutputT , data_layout Layout, El ::Device Device>
std::unique_ptr< Layer >	build_operator_layer_from_pbuf (lbann_comm *, lbann_data::Layer const &)

	LBANN_DEFINE_LAYER_BUILDER (batch_normalization)

	LBANN_DEFINE_LAYER_BUILDER (dropout)

	LBANN_DEFINE_LAYER_BUILDER (entrywise_batch_normalization)

	LBANN_DEFINE_LAYER_BUILDER (instance_norm)

	LBANN_DEFINE_LAYER_BUILDER (layer_norm)

	LBANN_DEFINE_LAYER_BUILDER (local_response_normalization)

	LBANN_DEFINE_LAYER_BUILDER (selu_dropout)

template<typename TensorDataType , El::Device Device>
void	bp_setup_gradient_wrt_inputs_impl (concatenate_layer< TensorDataType, data_layout::MODEL_PARALLEL, Device > &l)

template<typename TensorDataType , El::Device Device>
void	bp_setup_gradient_wrt_inputs_impl (concatenate_layer< TensorDataType, data_layout::DATA_PARALLEL, Device > &l)

pooling_mode	to_pool_mode (std::string m)

template<typename TensorDataType , El::Device Device>
void	fp_setup_outputs_impl (slice_layer< TensorDataType, data_layout::MODEL_PARALLEL, Device > &l)

template<typename TensorDataType , El::Device Device>
void	fp_setup_outputs_impl (slice_layer< TensorDataType, data_layout::DATA_PARALLEL, Device > &l)

	LBANN_DEFINE_LAYER_BUILDER (batchwise_reduce_sum)

	LBANN_DEFINE_LAYER_BUILDER (bernoulli)

	LBANN_DEFINE_LAYER_BUILDER (categorical_random)

	LBANN_DEFINE_LAYER_BUILDER (concatenate)

	LBANN_DEFINE_LAYER_BUILDER (constant)

	LBANN_DEFINE_LAYER_BUILDER (crop)

	LBANN_DEFINE_LAYER_BUILDER (cross_grid_sum)

	LBANN_DEFINE_LAYER_BUILDER (cross_grid_sum_slice)

	LBANN_DEFINE_LAYER_BUILDER (discrete_random)

	LBANN_DEFINE_LAYER_BUILDER (dummy)

	LBANN_DEFINE_LAYER_BUILDER (evaluation)

	LBANN_DEFINE_LAYER_BUILDER (gather)

	LBANN_DEFINE_LAYER_BUILDER (gaussian)

	LBANN_DEFINE_LAYER_BUILDER (hadamard)

	LBANN_DEFINE_LAYER_BUILDER (identity_zero)

	LBANN_DEFINE_LAYER_BUILDER (in_top_k)

	LBANN_DEFINE_LAYER_BUILDER (permute)

	LBANN_DEFINE_LAYER_BUILDER (pooling)

	LBANN_DEFINE_LAYER_BUILDER (reduction)

	LBANN_DEFINE_LAYER_BUILDER (scatter)

	LBANN_DEFINE_LAYER_BUILDER (slice)

	LBANN_DEFINE_LAYER_BUILDER (sort)

	LBANN_DEFINE_LAYER_BUILDER (split)

	LBANN_DEFINE_LAYER_BUILDER (stop_gradient)

	LBANN_DEFINE_LAYER_BUILDER (sum)

	LBANN_DEFINE_LAYER_BUILDER (tessellate)

	LBANN_DEFINE_LAYER_BUILDER (uniform)

	LBANN_DEFINE_LAYER_BUILDER (unpooling)

	LBANN_DEFINE_LAYER_BUILDER (weighted_sum)

	LBANN_DEFINE_LAYER_BUILDER (weights)

	LBANN_DECLARE_OPERATOR_BUILDER (log_sigmoid)

	LBANN_DECLARE_OPERATOR_BUILDER (selu)

	LBANN_DECLARE_OPERATOR_BUILDER (sigmoid)

	LBANN_DECLARE_OPERATOR_BUILDER (softplus)

	LBANN_DECLARE_OPERATOR_BUILDER (softsign)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (LogSigmoid, "log sigmoid", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Selu, "SELU", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Sigmoid, "sigmoid", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Softplus, "softplus", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Softsign, "softsign", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (BinaryCrossEntropy, "binary cross entropy", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (SigmoidBinaryCrossEntropy, "sigmoid binary cross entropy", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (BooleanAccuracy, "Boolean accuracy", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (BooleanFalseNegative, "Boolean false negative rate", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (BooleanFalsePositive, "Boolean false positive rate", false)

	LBANN_DECLARE_OPERATOR_BUILDER (binary_cross_entropy)

	LBANN_DECLARE_OPERATOR_BUILDER (boolean_accuracy)

	LBANN_DECLARE_OPERATOR_BUILDER (boolean_false_negative)

	LBANN_DECLARE_OPERATOR_BUILDER (boolean_false_positive)

	LBANN_DECLARE_OPERATOR_BUILDER (sigmoid_binary_cross_entropy)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Add, "add", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Subtract, "subtract", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Multiply, "multiply", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Divide, "divide", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Mod, "modulo", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Pow, "power", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (SafeDivide, "safe divide", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (SquaredDifference, "squared difference", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Max, "maximum", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Min, "minimum", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Equal, "equal", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (NotEqual, "not equal", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Less, "less than", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (LessEqual, "less than or equal", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Greater, "greater than", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (GreaterEqual, "greater than or equal", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (LogicalAnd, "logical and", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (LogicalOr, "logical or", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (LogicalXor, "logical xor", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (AddConstant, "add constant", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (Scale, "scale", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (SubtractConstant, "subtract constant", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (ConstantSubtract, "subtract from constant", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (MaxConstant, "max constant", true)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (MinConstant, "min constant", true)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (EqualConstant, "equals constant", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (NotEqualConstant, "not equals constant", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (LessEqualConstant, "less-equals constant", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (LessConstant, "less than constant", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (GreaterEqualConstant, "greater-equals constant", false)

	LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR (GreaterConstant, "greater than constant", false)

template<typename DataT , El::Device D>
std::unique_ptr< Operator< DataT, El::Base< DataT >, D > >	build_abs_operator (lbann_data::Operator const &op)

	LBANN_DECLARE_OPERATOR_BUILDER (acos)

	LBANN_DECLARE_OPERATOR_BUILDER (acosh)

	LBANN_DECLARE_OPERATOR_BUILDER (add)

	LBANN_DECLARE_OPERATOR_BUILDER (add_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (asin)

	LBANN_DECLARE_OPERATOR_BUILDER (asinh)

	LBANN_DECLARE_OPERATOR_BUILDER (atan)

	LBANN_DECLARE_OPERATOR_BUILDER (atanh)

	LBANN_DECLARE_OPERATOR_BUILDER (ceil)

	LBANN_DECLARE_OPERATOR_BUILDER (clamp)

	LBANN_DECLARE_OPERATOR_BUILDER (constant_subtract)

	LBANN_DECLARE_OPERATOR_BUILDER (cos)

	LBANN_DECLARE_OPERATOR_BUILDER (cosh)

	LBANN_DECLARE_OPERATOR_BUILDER (divide)

	LBANN_DECLARE_OPERATOR_BUILDER (equal)

	LBANN_DECLARE_OPERATOR_BUILDER (equal_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (erf)

	LBANN_DECLARE_OPERATOR_BUILDER (erfinv)

	LBANN_DECLARE_OPERATOR_BUILDER (exp)

	LBANN_DECLARE_OPERATOR_BUILDER (expm1)

	LBANN_DECLARE_OPERATOR_BUILDER (floor)

	LBANN_DECLARE_OPERATOR_BUILDER (gelu)

	LBANN_DECLARE_OPERATOR_BUILDER (greater)

	LBANN_DECLARE_OPERATOR_BUILDER (greater_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (greater_equal)

	LBANN_DECLARE_OPERATOR_BUILDER (greater_equal_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (less)

	LBANN_DECLARE_OPERATOR_BUILDER (less_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (less_equal)

	LBANN_DECLARE_OPERATOR_BUILDER (less_equal_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (log)

	LBANN_DECLARE_OPERATOR_BUILDER (log1p)

	LBANN_DECLARE_OPERATOR_BUILDER (logical_and)

	LBANN_DECLARE_OPERATOR_BUILDER (logical_not)

	LBANN_DECLARE_OPERATOR_BUILDER (logical_or)

	LBANN_DECLARE_OPERATOR_BUILDER (logical_xor)

	LBANN_DECLARE_OPERATOR_BUILDER (max)

	LBANN_DECLARE_OPERATOR_BUILDER (max_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (min)

	LBANN_DECLARE_OPERATOR_BUILDER (min_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (mod)

	LBANN_DECLARE_OPERATOR_BUILDER (multiply)

	LBANN_DECLARE_OPERATOR_BUILDER (negative)

	LBANN_DECLARE_OPERATOR_BUILDER (not_equal)

	LBANN_DECLARE_OPERATOR_BUILDER (not_equal_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (pow)

	LBANN_DECLARE_OPERATOR_BUILDER (reciprocal)

	LBANN_DECLARE_OPERATOR_BUILDER (round)

	LBANN_DECLARE_OPERATOR_BUILDER (rsqrt)

	LBANN_DECLARE_OPERATOR_BUILDER (safe_divide)

	LBANN_DECLARE_OPERATOR_BUILDER (safe_reciprocal)

	LBANN_DECLARE_OPERATOR_BUILDER (scale)

	LBANN_DECLARE_OPERATOR_BUILDER (select)

	LBANN_DECLARE_OPERATOR_BUILDER (sign)

	LBANN_DECLARE_OPERATOR_BUILDER (sin)

	LBANN_DECLARE_OPERATOR_BUILDER (sinh)

	LBANN_DECLARE_OPERATOR_BUILDER (sqrt)

	LBANN_DECLARE_OPERATOR_BUILDER (square)

	LBANN_DECLARE_OPERATOR_BUILDER (squared_difference)

	LBANN_DECLARE_OPERATOR_BUILDER (subtract)

	LBANN_DECLARE_OPERATOR_BUILDER (subtract_constant)

	LBANN_DECLARE_OPERATOR_BUILDER (tan)

	LBANN_DECLARE_OPERATOR_BUILDER (tanh)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (LogicalNot, "logical not", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Negative, "negative", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Sign, "sign", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Round, "round", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Ceil, "ceil", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Floor, "floor", false)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Reciprocal, "reciprocal", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Square, "square", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Sqrt, "square root", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Rsqrt, "reciprocal square root", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (SafeReciprocal, "safe reciprocal", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Exp, "exponential", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Expm1, "expm1", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Log, "natural logarithm", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Log1p, "log1p", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Cos, "cosine", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Sin, "sine", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Tan, "tangent", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Acos, "arccosine", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Asin, "arcsine", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Atan, "arctangent", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Cosh, "hyperbolic cosine", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Sinh, "hyperbolic sine", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Tanh, "hyperbolic tangent", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Acosh, "hyperbolic arccosine", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Asinh, "hyperbolic arcsine", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Atanh, "hyperbolic arctangent", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Erf, "error function", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (ErfInv, "inverse error function", true)

	LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR (Gelu, "gaussian error linear unit", true)

template<typename TensorDataType >
std::unique_ptr< optimizer >	build_adagrad_optimizer_from_pbuf (google::protobuf::Message const &)

template<typename TensorDataType >
std::unique_ptr< optimizer >	build_adam_optimizer_from_pbuf (google::protobuf::Message const &)

template<typename TensorDataType >
std::unique_ptr< optimizer >	build_hypergradient_adam_optimizer_from_pbuf (google::protobuf::Message const &)

std::string	to_string (optimizer_gradient_status status)
	Human-readable string for status of gradient in optimizer. More...

template<typename TensorDataType >
std::unique_ptr< optimizer >	build_rmsprop_optimizer_from_pbuf (google::protobuf::Message const &)

template<typename TensorDataType >
std::unique_ptr< optimizer >	build_sgd_optimizer_from_pbuf (google::protobuf::Message const &)

void	init_image_data_reader (const lbann_data::Reader &pb_readme, const lbann_data::DataSetMetaData &pb_metadata, const bool master, generic_data_reader *&reader)

void	init_org_image_data_reader (const lbann_data::Reader &pb_readme, const bool master, generic_data_reader *&reader)

void	customize_data_readers_sample_list (const lbann_comm &comm, ::lbann_data::LbannPB &p)
	Customize the name of the sample list. More...

void	init_data_readers (lbann_comm comm, const ::lbann_data::LbannPB &p, std::map< execution_mode, generic_data_reader > &data_readers)
	instantiates one or more generic_data_readers and inserts them in &data_readers More...

void	set_num_parallel_readers (const lbann_comm &comm, ::lbann_data::LbannPB &p)
	adjusts the number of parallel data readers More...

void	get_cmdline_overrides (const lbann_comm &comm, ::lbann_data::LbannPB &p)
	adjusts the values in p by querying the options db More...

void	print_parameters (const lbann_comm &comm, ::lbann_data::LbannPB &p, std::vector< int > &root_random_seeds, std::vector< int > &random_seeds, std::vector< int > &data_seq_random_seeds)
	print various params (learn_rate, etc) to cout More...

void	save_session (const lbann_comm &comm, const int argc, char const argv, ::lbann_data::LbannPB &p)
	prints prototext file, cmd line, etc to file More...

void	read_prototext_file (const std::string &fn, ::lbann_data::LbannPB &pb, const bool master)
	Read prototext from a file into a protobuf message. More...

void	read_prototext_string (const std::string &contents, lbann_data::LbannPB &pb, const bool master)
	Read prototext from a string into a protobuf message. More...

bool	write_prototext_file (const std::string &fn, ::lbann_data::LbannPB &pb)
	Write a protobuf message into a prototext file. More...

std::string	trim (std::string const &str)
	Trim leading and trailing whitespace from a string. More...

template<typename T = std::string>
std::vector< T >	parse_list (std::string const &str)
	Parse a space-separated list. More...

template<typename T = std::string>
std::set< T >	parse_set (std::string const &str)
	Parse a space-separated set. More...

trainer &	get_trainer ()
	Get a reference to the global trainer visible to this rank. More...

trainer const &	get_const_trainer ()
	Get a const reference to the global trainer visible to this rank. More...

default_arg_parser_type &	global_argument_parser ()

template<typename CharT , typename RealType >
std::basic_ostream< CharT > &	operator<< (std::basic_ostream< CharT > &os, const beta_distribution< RealType > &d)

template<typename CharT , typename RealType >
std::basic_istream< CharT > &	operator>> (std::basic_istream< CharT > &is, beta_distribution< RealType > &d)

template<typename T >
constexpr bool	IsCloneable_v ()

template<typename T >
constexpr bool	IsCloneablePtr_v ()

template<typename CloneablePtrT , h2::meta::EnableWhen< IsCloneablePtr< CloneablePtrT >, int > = 1>
auto	clone_all (std::vector< CloneablePtrT > const &things)

std::ostream &	operator<< (std::ostream &os, Describable const &obj)

template<typename Out , typename In >
auto	get_linear_size_as (std::vector< In > const &dims)
	Compute the linear size of the given dimensions with a specific type. More...

template<typename Out , typename In >
auto	get_linear_size_as (size_t ndims, In const *dims)

template<typename T >
auto	get_linear_size (std::vector< T > const &dims)

template<typename T >
auto	get_linear_size (size_t ndims, T const *dims)

template<typename T >
auto	get_strides (size_t ndims, T const *dims, T const &lowest_stride)

template<typename T >
auto	get_strides (std::vector< T > const &dims, T const &lowest_stride)

template<typename T >
auto	get_packed_strides (size_t ndims, T const *dims)

template<typename T >
auto	get_packed_strides (std::vector< T > const &dims)

template<typename To , typename From >
auto	vector_cast (std::vector< From > const &from)

template<typename... ArgTs>
std::vector< size_t >	splice_dims (ArgTs &&... args)

template<template< typename > class Op, typename TensorDataType >
void	apply_entrywise_unary_operator (const El::AbstractMatrix< TensorDataType > &input, El::AbstractMatrix< TensorDataType > &output)

template<template< typename > class Op, typename TensorDataType >
void	apply_entrywise_binary_operator (const El::AbstractMatrix< TensorDataType > &input1, const El::AbstractMatrix< TensorDataType > &input2, El::AbstractMatrix< TensorDataType > &output)

template<template< typename > class Op, typename TensorDataType >
void	apply_entrywise_unary_operator (const El::AbstractDistMatrix< TensorDataType > &input, El::AbstractDistMatrix< TensorDataType > &output)

template<template< typename > class Op, typename TensorDataType >
void	apply_entrywise_binary_operator (const El::AbstractDistMatrix< TensorDataType > &input1, const El::AbstractDistMatrix< TensorDataType > &input2, El::AbstractDistMatrix< TensorDataType > &output)

template<typename... Args>
std::string	build_string (Args &&... args)
	Build a string from the arguments. More...

std::vector< int >	get_tokens (std::string str, const std::vector< char > delims)

std::vector< std::string >	get_tokens (const std::string str, const std::string delims=" :;\\)
	Tokenize a string into substrings by set of delimiter characters. More...

bool	parse_path (const std::string &path, std::string &dir, std::string &basename)

std::string	get_ext_name (const std::string file_name)

std::string	get_basename_without_ext (const std::string file_name)

std::string	add_delimiter (const std::string dir)

std::string	modify_file_name (const std::string file_name, const std::string tag, const std::string new_ext="")

bool	check_if_file_exists (const std::string &filename)

bool	check_if_dir_exists (const std::string &dirname)

bool	create_dir (const std::string output_dir)

bool	load_file (const std::string filename, std::vector< char > &buf, bool append=false)

void	__swapEndianInt (unsigned int &ui)

template<typename T >
std::basic_string< T >	pad (const std::basic_string< T > &s, typename std::basic_string< T >::size_type n, T c)

std::vector< std::string >	glob (const std::string &pattern)

template<class T , class Hash = std::hash<T>>
std::size_t	hash_combine (std::size_t seed, const T &val)
	Combine two hash values. More...

template<typename TensorDataType >
void	im2col (const CPUMatDT< TensorDataType > &im, CPUMatDT< TensorDataType > &col, int num_channels, int im_num_dims, const int im_dims, const int im_pads, const int window_dims, const int window_strides)
	Rearrange image blocks into matrix columns. More...

std::pair< size_t, size_t >	get_im2col_output_size (const int num_samples, const int num_channels, const int im_num_dims, const int im_dims, const int im_pads, const int window_dims, const int window_strides)

template<typename TensorDataType >
void	col2im (const CPUMatDT< TensorDataType > &col, CPUMatDT< TensorDataType > &im, int num_channels, int im_num_dims, const int im_dims, const int im_pads, const int window_dims, const int window_strides)
	Rearrange matrix columns into image blocks. More...

template<typename TensorDataType >
void	col2im (const CPUMatDT< TensorDataType > &col, CPUMatDT< TensorDataType > &im, int num_channels, int im_num_dims, const int im_dims, const int im_pads, const int window_dims, const int window_strides, std::function< TensorDataType(const TensorDataType &, const TensorDataType &)> reduction_op)
	Rearrange matrix columns into image blocks. More...

template<typename TensorDataType >
void	im2col_1x1 (const TensorDataType input_buffer, TensorDataType output_buffer, int num_channels, int num_input_dims, const int *input_dims)
	Rearrange 1x1 image blocks into matrix columns. More...

template<typename TensorDataType >
void	im2col_2d (const TensorDataType __restrict__ input_buffer, TensorDataType __restrict__ output_buffer, int input_dim_x, int input_dim_y, int input_pad_x, int input_pad_y, int num_channels, int window_dim_x, int window_dim_y, int offset_stride_x, int offset_stride_y)
	Rearrange 2D image blocks into matrix columns. More...

template<typename TensorDataType >
void	col2im_1x1 (const TensorDataType input_buffer, TensorDataType output_buffer, const int num_channels, const int num_output_dims, const int *output_dims)
	Rearrange matrix columns into 1x1 image blocks. More...

template<typename TensorDataType >
void	col2im_2d (const TensorDataType __restrict__ input_buffer, TensorDataType __restrict__ output_buffer, int output_dim_x, int output_dim_y, int output_pad_x, int output_pad_y, int num_channels, int window_dim_x, int window_dim_y, int offset_stride_x, int offset_stride_y)
	Rearrange matrix columns into 2D image blocks. More...

void	load_image (const std::string &filename, El::Matrix< uint8_t > &dst, std::vector< size_t > &dims)
	Load an image from filename. More...

void	decode_image (El::Matrix< uint8_t > &src, El::Matrix< uint8_t > &dst, std::vector< size_t > &dims)
	Decode an image from buf. More...

void	save_image (const std::string &filename, El::Matrix< uint8_t > &src, const std::vector< size_t > &dims)
	Save an image to filename. More...

void	save_image (const std::string &filename, const CPUMat &src, const std::vector< size_t > &dims)
	Save an image to filename. More...

El::Matrix< uint8_t >	get_uint8_t_image (const CPUMat &image, const std::vector< size_t > &dims)
	Convert image from El::Matrix<DataType> to El::Matrix<uint8_t> More...

std::string	encode_image (const El::Matrix< uint8_t > &image, const std::vector< size_t > &dims, std::string const &img_format)
	Encodes image to given format. More...

void	read_filelist (lbann_comm *comm, const std::string &fn, std::vector< std::string > &filelist_out)

std::unique_ptr< model >	load_inference_model (lbann_comm *lc, std::string cp_dir, int mbs, std::vector< int > input_dims, std::vector< int > output_dims)
	Loads a trained model from checkpoint for inference only. More...

template<typename DataT , El::Dist CDist, El::Dist RDist, El::DistWrap DistView, El::Device Device>
El::Matrix< int, El::Device::CPU >	infer (observer_ptr< model > model, El::DistMatrix< DataT, CDist, RDist, DistView, Device > const &samples, size_t mbs)
	Creates execution algorithm and infers on samples using a model. More...

int	allocate_trainer_resources (lbann_comm *comm)

trainer &	construct_trainer (lbann_comm comm, lbann_data::Trainer pb_trainer, lbann_data::LbannPB &pb)

std::unique_ptr< thread_pool >	construct_io_thread_pool (lbann_comm *comm, bool serialized_io)

std::unique_ptr< model >	build_model_from_prototext (int argc, char *argv, const lbann_data::Trainer pb_trainer, lbann_data::LbannPB &pb, lbann_comm *comm, thread_pool &io_thread_pool, std::vector< std::shared_ptr< callback_base >> &shared_callbacks)

void	print_lbann_configuration (lbann_comm *comm, int io_threads_per_process, int io_threads_offset)

template<class BaseClass >
std::unique_ptr< BaseClass >	make_abstract (google::protobuf::Message const &msg)
	Fallback implementation of general factory function template. More...

template<class ConcreteClass >
std::unique_ptr< ConcreteClass >	make (google::protobuf::Message const &msg)
	Fallback implementation of general builder function template. More...

template<typename T >
std::unique_ptr< T >	to_unique_ptr (T *ptr)
	Convert the raw pointer to a unique_ptr. More...

int	get_num_pus ()

int	get_affinity (uint8_t cpus, uint8_t count)

void	th_print_affinity (int rank, int np, char *host)

void	print_affinity (int rank, int np, char *host)

int	get_env_var (const char *id)

int	get_sleep_sec ()

void	print_affinity_subset (int rank, int np, char *host)

void	display_omp_setup ()

void	construct_std_options ()

void	construct_datastore_options ()

void	construct_datareader_options ()

void	construct_jag_options ()

void	construct_all_options ()

bool	is_good_terminal (std::ostream &os) noexcept
	Roughly determines if the stream points to a nice terminal (is a terminal, supports color). More...

std::pair< unsigned short, unsigned short >	get_window_size (std::ostream &os) noexcept
	Gets the dimensions of the terminal, if available. More...

std::string	truncate_to_width (std::string const &str, size_t max_len)
	A simple utility to replace the tail end of a long string with an ellipsis. More...

std::string	strip_ansi_csis (std::string const &input)
	Remove ANSI CSIs from the string. More...

std::ostream &	black (std::ostream &)
	Turn the ANSI foreground color output black. More...

std::ostream &	red (std::ostream &)
	Turn the ANSI foreground color output red. More...

std::ostream &	green (std::ostream &)
	Turn the ANSI foreground color output green. More...

std::ostream &	yellow (std::ostream &)
	Turn the ANSI foreground color output yellow. More...

std::ostream &	blue (std::ostream &)
	Turn the ANSI foreground color output blue. More...

std::ostream &	magenta (std::ostream &)
	Turn the ANSI foreground color output magenta. More...

std::ostream &	cyan (std::ostream &)
	Turn the ANSI foreground color output cyan. More...

std::ostream &	white (std::ostream &)
	Turn the ANSI foreground color output white. More...

std::ostream &	bgblack (std::ostream &)
	Turn the ANSI background color output black. More...

std::ostream &	bgred (std::ostream &)
	Turn the ANSI background color output red. More...

std::ostream &	bggreen (std::ostream &)
	Turn the ANSI background color output green. More...

std::ostream &	bgyellow (std::ostream &)
	Turn the ANSI background color output yellow. More...

std::ostream &	bgblue (std::ostream &)
	Turn the ANSI background color output blue. More...

std::ostream &	bgmagenta (std::ostream &)
	Turn the ANSI background color output magenta. More...

std::ostream &	bgcyan (std::ostream &)
	Turn the ANSI background color output cyan. More...

std::ostream &	bgwhite (std::ostream &)
	Turn the ANSI background color output white. More...

std::ostream &	nocolor (std::ostream &)
	Reset the ANSI color to the default. More...

std::ostream &	clearline (std::ostream &)
	Clear remaining characters in the line. More...

template<class KEY_T , class VAL_T , class CMP_T = std::less<KEY_T>>
VAL_T	peek_map (const std::map< KEY_T, VAL_T, CMP_T > &map_to_peek, KEY_T idx, bool &found)

template<class KEY_T , class VAL_T , class CMP_T = std::less<KEY_T>>
VAL_T	peek_map (const std::map< KEY_T, VAL_T, CMP_T > &map_to_peek, KEY_T idx)

template<class KEY_T , class VAL_T , class HASH_T = std::hash<KEY_T>, class KEYeq_T = std::equal_to<KEY_T>>
VAL_T	peek_map (const std::unordered_map< KEY_T, VAL_T, HASH_T, KEYeq_T > &map_to_peek, KEY_T idx, bool &found)

template<class KEY_T , class VAL_T , class HASH_T = std::hash<KEY_T>, class KEYeq_T = std::equal_to<KEY_T>>
VAL_T	peek_map (const std::unordered_map< KEY_T, VAL_T, HASH_T, KEYeq_T > &map_to_peek, KEY_T idx)

void	prof_start ()

void	prof_stop ()

void	prof_region_begin (const char *s, int c, bool sync)

void	prof_region_end (const char *s, bool sync)

template<typename Generator , typename T >
T	fast_rand_int (Generator &g, T max)

template<typename Generator , typename T >
T	fast_rand_int_pow2 (Generator &g, T max)

template<typename T , typename Generator >
T	random_uniform (Generator &g)
	Generate uniform random value in the range [0, 1). More...

template<typename TensorDataType >
void	gaussian_fill (El::AbstractDistMatrix< TensorDataType > &mat, El::Int m, El::Int n, TensorDataType mean=0.0, TensorDataType stddev=1.0)

template<typename TensorDataType >
void	bernoulli_fill (El::AbstractDistMatrix< TensorDataType > &mat, El::Int m, El::Int n, double p=0.5)

template<typename TensorDataType >
void	uniform_fill (El::AbstractDistMatrix< TensorDataType > &mat, El::Int m, El::Int n, TensorDataType center=0.0, TensorDataType radius=1.0)

template<typename TensorDataType >
void	gaussian_fill_procdet (El::AbstractDistMatrix< TensorDataType > &mat, El::Int m, El::Int n, TensorDataType mean=0.0, TensorDataType stddev=1.0)

template<typename TensorDataType >
void	bernoulli_fill_procdet (El::AbstractDistMatrix< TensorDataType > &mat, El::Int m, El::Int n, double p=0.5)

template<typename TensorDataType >
void	uniform_fill_procdet (El::AbstractDistMatrix< TensorDataType > &mat, El::Int m, El::Int n, TensorDataType center=0.0, TensorDataType radius=1.0)

template<typename TensorDataType >
void	gaussian_fill_parallel (El::AbstractDistMatrix< TensorDataType > &mat, El::Int m, El::Int n, TensorDataType mean=0.0, TensorDataType stddev=1.0)

bool	save_rng_to_checkpoint_shared (persist &p, lbann_comm *comm)

bool	save_rng_to_checkpoint_distributed (persist &p, lbann_comm *comm)

bool	load_rng_from_checkpoint (persist &p, const lbann_comm *comm)

template<typename DType = DataType>
void	rng_bernoulli (const float p, DistMat *m)

rng_gen &	get_generator ()

fast_rng_gen &	get_fast_generator ()

fast_rng_gen &	get_ltfb_generator ()

rng_gen &	get_data_seq_generator ()

int	get_num_io_generators ()
	Returns the number of provisioned I/O generators. More...

locked_io_rng_ref	set_io_generators_local_index (size_t idx)
	Sets the local index for a thread to access the correct I/O RNGs. More...

rng_gen &	get_io_generator ()

fast_rng_gen &	get_fast_io_generator ()

void	init_random (int seed=-1, int num_io_RNGs=1, lbann_comm *comm=nullptr)
	Initialize the random number generator (with optional seed). More...

void	init_data_seq_random (int seed=-1)

void	init_ltfb_random (int seed=-1)

void	init_io_random (int seed=-1, int num_io_RNGs=1)

void	entrywise_mean_and_stdev (const Mat &data, DataType &mean, DataType &stdev)
	Compute mean and standard deviation over matrix entries. More...

void	entrywise_mean_and_stdev (const AbsDistMat &data, DataType &mean, DataType &stdev)
	Compute mean and standard deviation over matrix entries. More...

void	columnwise_mean_and_stdev (const Mat &data, Mat &means, Mat &stdevs)
	Compute column-wise means and standard deviations. More...

void	columnwise_mean_and_stdev (const AbsDistMat &data, AbsDistMat &means, AbsDistMat &stdevs)
	Compute column-wise means and standard deviations. More...

void	columnwise_sums_and_sqsums (const AbsDistMat &data, AbsDistMat &sums, AbsDistMat &sqsums)
	Compute column-wise sum and sqsum. More...

void	rowwise_mean_and_stdev (const Mat &data, Mat &means, Mat &stdevs)
	Compute row-wise means and standard deviations. More...

void	rowwise_sums_and_sqsums (const AbsDistMat &data, AbsDistMat &sums, AbsDistMat &sqsums)
	Compute row-wise sum and sum of squares. More...

void	rowwise_mean_and_stdev (const AbsDistMat &data, AbsDistMat &means, AbsDistMat &stdevs)
	Compute row-wise means and standard deviations. More...

void	columnwise_covariance (const AbsDistMat &data1, const AbsDistMat &data2, const AbsDistMat &means1, const AbsDistMat &means2, AbsDistMat &cov)
	Compute column-wise covariances. More...

template<El::Device D, El::Device... Ds>
auto	force (El::MultiSync< D, Ds... > const &x) -> El::SyncInfo< D > const &
	Force the MultiSync to the master SyncInfo. More...

template<typename TDT >
void	do_tensor_copy (const BaseDistMat &src, El::AbstractDistMatrix< TDT > &tgt)
	Function to efficiently select the best method for copying between two distributed tensors. Enable selection between synchronous and asynchronous copies based on tensor distribution and pre-processing macros. More...

template<typename TDT >
void	view_or_copy_tensor (const BaseDistMat &src, El::AbstractDistMatrix< TDT > &tgt, bool locked_view=true)
	If distributed tensors have the same distribution setup the target to use a view to the source tensor, otherwise copy the src to target. More...

int	num_free_cores_per_process (const lbann_comm *comm)

int	free_core_offset (const lbann_comm *comm)

double	get_time ()
	Return time in fractional seconds since an epoch. More...

template<typename TimerT >
auto	time_scope (TimerT &timer, std::string const &scope_name)

template<typename T >
std::string	TypeName ()

bool	is_execution_mode_hook (visitor_hook hook)

std::string	to_string (visitor_hook hook)

std::string	to_string (visitor_hook hook, execution_mode mode)

void	visitor_hook_from_string (std::string const &str, visitor_hook &hook, execution_mode &mode)
	Convert a string to an execution_mode. More...

std::istream &	operator>> (std::istream &os, visitor_hook &e)
	Extract an execution_mode from a stream. More...

template<typename TensorDataType >
std::unique_ptr< weights_initializer >	build_constant_initializer_from_pbuf (google::protobuf::Message const &msg)

template<typename TensorDataType >
std::unique_ptr< weights_initializer >	build_value_initializer_from_pbuf (google::protobuf::Message const &msg)

template<typename TensorDataType >
std::unique_ptr< weights_initializer >	build_numpy_initializer_from_pbuf (google::protobuf::Message const &msg)

template<typename TensorDataType >
std::unique_ptr< weights_initializer >	build_uniform_initializer_from_pbuf (google::protobuf::Message const &msg)

template<typename TensorDataType >
std::unique_ptr< weights_initializer >	build_normal_initializer_from_pbuf (google::protobuf::Message const &msg)

void	set_fan_in (weights_initializer &initializer, double value)

void	set_fan_out (weights_initializer &initializer, double value)

template<typename TensorDataType >
std::unique_ptr< weights_initializer >	build_glorot_initializer_from_pbuf (google::protobuf::Message const &msg)

template<typename TensorDataType >
std::unique_ptr< weights_initializer >	build_he_initializer_from_pbuf (google::protobuf::Message const &msg)

template<typename TensorDataType >
std::unique_ptr< weights_initializer >	build_lecun_initializer_from_pbuf (google::protobuf::Message const &msg)

Factory functions with type deduction
template<typename IndexT >
auto	RowMajor (std::vector< IndexT > &&ds)

template<typename IndexT >
auto	RowMajor (std::vector< IndexT > const &ds)

template<typename IndexT >
auto	RowMajor (ColMajorDims< IndexT > const &dims)

template<typename IndexT >
auto	RowMajor (RowMajorDims< IndexT > const &dims)

template<typename IndexT >
auto	RowMajor (RowMajorDims< IndexT > &&dims)

template<typename IndexT >
auto	ColMajor (std::vector< IndexT > &&ds)

template<typename IndexT >
auto	ColMajor (std::vector< IndexT > const &ds)

template<typename IndexT >
auto	ColMajor (RowMajorDims< IndexT > const &dims)

template<typename IndexT >
auto	ColMajor (ColMajorDims< IndexT > const &dims)

template<typename IndexT >
auto	ColMajor (ColMajorDims< IndexT > &&dims)

Computing (packed) stride information.
template<typename StrideT , typename DimT >
auto	get_strides_as (ColMajorDims< DimT > const &dims)
	Compute packed strides of the given dimensions. More...

template<typename DimT >
auto	get_strides (ColMajorDims< DimT > const &dims)
	Compute packed strides of the given dimensions. More...

Permutation helper functions
template<typename T >
bool	check_perm_impl (std::vector< T > perm)
	Checks that the permutation is valid. More...

template<typename T >
auto	invert_perm_impl (std::vector< T > const &perm)
	Returns the inverse of the given permutation. More...

template<typename IndexT , typename PermT >
auto	permute_impl (std::vector< IndexT > const &in, std::vector< PermT > const &perm)

Public interface for permutation arrays
bool	is_valid (RowMajorPerm const &perm)

bool	is_valid (ColMajorPerm const &perm)

RowMajorPerm	invert (RowMajorPerm const &in)

ColMajorPerm	invert (ColMajorPerm const &in)

Permuting dimensions
template<typename IndexT >
auto	permute_dims (RowMajorDims< IndexT > const &in, RowMajorPerm const &perm)

template<typename IndexT >
auto	permute_dims (ColMajorDims< IndexT > const &in, ColMajorPerm const &perm)

Builder functions
template<>
std::unique_ptr< ltfb::RandomPairwiseExchange >	make (google::protobuf::Message const &)
	Concrete builder for RandomPairwiseExchange. More...

template<>
std::unique_ptr< ltfb::RegularizedEvolution >	make (google::protobuf::Message const &)
	Concrete builder for RegularizedEvolution. More...

template<>
std::unique_ptr< ltfb::TruncationSelectionExchange >	make (google::protobuf::Message const &)
	Concrete builder for TruncationSelectionExchange. More...

SyncInfo extractors.
template<typename TensorDataType , El::Device D>
El::SyncInfo< D >	get_sync_info (El::Matrix< TensorDataType, D > const &m) noexcept
	Get a SyncInfo from an Matrix. More...

template<typename TensorDataType , El::Dist RowDist, El::Dist ColDist, El::Device D>
El::SyncInfo< D >	get_sync_info (El::DistMatrix< TensorDataType, RowDist, ColDist, El::ELEMENT, D > const &m) noexcept
	Get a SyncInfo from a DistMatrix. More...

Variables
template<typename CppType >
constexpr auto	CUDAType = CUDATypeT<CppType>::value

template<typename CppType >
constexpr auto	CUDAScalarType = CUDATypeT<CUDAScalar<CppType>>::value

template<typename OpT >
constexpr El::Device	Device = OperatorTraits<OpT>::device

static std::set< std::string > const	hdf5_metadata_valid_keys

static const std::string	multi_sample_exclusion = "MULTI-SAMPLE_EXCLUSION"

static const std::string	multi_sample_inclusion = "MULTI-SAMPLE_INCLUSION"

static const std::string	single_sample = "SINGLE-SAMPLE"

static const std::string	multi_sample_inclusion_v2

static const std::string	conduit_hdf5_exclusion = "CONDUIT_HDF5_EXCLUSION"

static const std::string	conduit_hdf5_inclusion = "CONDUIT_HDF5_INCLUSION"

template<typename T >
constexpr bool	IsCloneable = IsCloneable_v<T>()

template<typename T >
constexpr bool	IsCloneablePtr = IsCloneablePtr_v<T>()

const int	lbann_default_random_seed = 42

constexpr int	num_prof_colors = 20

constexpr int	prof_colors [num_prof_colors]

Detailed Description

Design docs: num_parallel_readers - used by the partitioned io buffer to control how many ranks will access data. Can be set by either the user, or by the size of the mini-batch????

IO buffers should go away and be rolled into the data coordinator.

Buffered data coordinator knows about the native data size / for the data reader and how to store it

input layer should take responsibility for the "distribute from local matrix code. That should be the copy out of the data coordinator into the input layer.

num children layers for the IO buffers is a property of the data reader there should be one input layer for each type of data to read.

Todo:: Remove this file.

Todo:: Rename this file to file.hpp

Todo:: Rename this file to file.hpp

Typedef Documentation

◆ AbsDistMat

using lbann::AbsDistMat = typedef El::AbstractDistMatrix<DataType>

Definition at line 120 of file base.hpp.

◆ AbsDistMatReadProxy

template<El::Device D>

using lbann::AbsDistMatReadProxy = typedef El::AbstractDistMatrixReadDeviceProxy<DataType, D>

Definition at line 130 of file base.hpp.

◆ AbsMat

using lbann::AbsMat = typedef El::AbstractMatrix<DataType>

Definition at line 115 of file base.hpp.

◆ AbstractCloneableBase

template<typename T , typename... Bases>

using lbann::AbstractCloneableBase = typedef Cloneable<HasAbstractFunction<T>, Bases...>

Helper metafunction for describing the top of a hierarchy that's cloneable.

Definition at line 290 of file cloneable.hpp.

◆ BaseDistMat

using lbann::BaseDistMat = typedef El::BaseDistMatrix

Definition at line 121 of file base.hpp.

◆ BaseOperatorType

template<typename OpT >

using lbann::BaseOperatorType = typedef typename OperatorTraits<OpT>::base_type

Definition at line 70 of file OperatorTraits.hpp.

◆ BiggerOf

template<typename T , typename U >

using lbann::BiggerOf = typedef typename std::conditional<(sizeof(T) > sizeof(U)), T, U>::type

Definition at line 44 of file utils/summary.hpp.

◆ BlockMat

using lbann::BlockMat = typedef El::BlockMatrix<DataType>

Definition at line 132 of file base.hpp.

◆ CircMat

template<El::Device D>

using lbann::CircMat = typedef CircMatDT<DataType, D>

Definition at line 170 of file base.hpp.

◆ CircMatDT

template<typename TensorDataType , El::Device D>

using lbann::CircMatDT = typedef El::DistMatrix<TensorDataType, El::CIRC, El::CIRC, El::ELEMENT, D>

Definition at line 142 of file base.hpp.

◆ ColMajorDims

template<typename IndexT >

using lbann::ColMajorDims = typedef NamedVector<IndexT, struct ColMajorDimsTag>

Definition at line 82 of file tensor_dims_utils.hpp.

◆ ColMajorPerm

using lbann::ColMajorPerm = typedef NamedVector<int, struct ColMajorPermTag>

Definition at line 92 of file tensor_dims_utils.hpp.

◆ ColMajorStrides

template<typename IndexT >

using lbann::ColMajorStrides = typedef NamedVector<IndexT, struct ColMajorStridesTag>

Definition at line 88 of file tensor_dims_utils.hpp.

◆ CPUMat

using lbann::CPUMat = typedef El::Matrix<DataType, El::Device::CPU>

Definition at line 116 of file base.hpp.

◆ CPUMatDT

template<typename TensorDataType >

using lbann::CPUMatDT = typedef El::Matrix<TensorDataType, El::Device::CPU>

Definition at line 135 of file base.hpp.

◆ CUDAScalar

template<typename CppType >

using lbann::CUDAScalar = typedef typename CUDATypeT<CppType>::scalar_type

Definition at line 87 of file cutensor_support.hpp.

◆ data_field_dim_map_type

using lbann::data_field_dim_map_type = typedef std::unordered_map<data_field_type, std::vector<El::Int> >

Map from data_field_type to dimension maps.

Definition at line 64 of file metadata.hpp.

◆ data_field_type

using lbann::data_field_type = typedef std::string

Definition at line 34 of file input_data_type.hpp.

◆ data_reader_target_mode_iterator

using lbann::data_reader_target_mode_iterator = typedef enum_iterator<data_reader_target_mode, data_reader_target_mode::CLASSIFICATION, data_reader_target_mode::NA>

Definition at line 60 of file metadata.hpp.

◆ DataParallelMatrixType

template<typename T , El::Device D>

using lbann::DataParallelMatrixType = typedef El::DistMatrix<T, El::Dist::STAR, El::Dist::VC, El::DistWrap::ELEMENT, D>

The data type for data-parallel computation.

Definition at line 36 of file OperatorTraits.hpp.

◆ default_arg_parser_type

using lbann::default_arg_parser_type = typedef utils::argument_parser<utils::strict_parsing>

Definition at line 819 of file argument_parser.hpp.

◆ Description

using lbann::Description = typedef description

Non-intrusive capitalization fix.

Definition at line 34 of file describable.hpp.

◆ DistMat

using lbann::DistMat = typedef MCMRMat<El::Device::CPU>

Definition at line 183 of file base.hpp.

◆ DistMatDT

template<typename TensorDataType >

using lbann::DistMatDT = typedef MCMRMatDT<TensorDataType, El::Device::CPU>

Definition at line 165 of file base.hpp.

◆ DMat

template<El::Device D>

using lbann::DMat = typedef El::Matrix<DataType, D>

Definition at line 128 of file base.hpp.

◆ dropout_layer

template<typename T , data_layout L, El::Device D>

using lbann::dropout_layer = typedef dropout<T, L, D>

Definition at line 247 of file layers/regularizers/dropout.hpp.

◆ EGrid

using lbann::EGrid = typedef El::Grid

Todo:: Remove

Definition at line 125 of file base.hpp.

◆ ElMat

using lbann::ElMat = typedef El::ElementalMatrix<DataType>

Definition at line 131 of file base.hpp.

◆ EvalType

using lbann::EvalType = typedef double

Definition at line 189 of file base.hpp.

◆ execution_mode_iterator

using lbann::execution_mode_iterator = typedef enum_iterator<execution_mode, execution_mode::training, execution_mode::invalid>

Definition at line 242 of file base.hpp.

◆ external_layer_setup_t

typedef Layer*(* lbann::external_layer_setup_t) (lbann_data::DataType datatype, data_layout layout, El::Device device, lbann_comm *comm)

Definition at line 36 of file external.hpp.

◆ fast_rng_gen

using lbann::fast_rng_gen = typedef std::minstd_rand

Definition at line 39 of file random_number_generators.hpp.

◆ generate_builder_type

template<typename OutT , typename... Args>

using lbann::generate_builder_type = typedef typename GenerateBuilderType_struct<OutT, Args...>::type

A helper typedef for wrapping builder signatures.

Definition at line 81 of file utils/factory.hpp.

◆ generic_factory

template<class BaseT , typename KeyT , typename BuilderT = std::function<std::unique_ptr<BaseT>()>, template< typename, class > class KeyErrorPolicy = default_key_error_policy>

using lbann::generic_factory = typedef h2::factory::ObjectFactory<BaseT, KeyT, BuilderT, KeyErrorPolicy>

Generic factory template.

This is a generic factory that should be suitable for constructing objects of a particular base type. The goal is maximum reuse:

using layer_factory
  = generic_factory<layer, string, layer_builder_type>;
using callback_factory
  = generic_factory<lbann_callback, string, callback_builder_type>;

The default behavior for id errors is to throw an exception.

Template Parameters

BaseT	The base class of the types being constructed.
IdT	The index type used to differentiate concrete types.
BuilderT	The functor type that builds concrete types.
ErrorPolicy	The policy for handling id errors.

Definition at line 60 of file utils/factory.hpp.

◆ Grid

using lbann::Grid = typedef El::Grid

Definition at line 126 of file base.hpp.

◆ InputConstTensorType

template<typename OpT >

using lbann::InputConstTensorType = typedef typename OperatorTraits<OpT>::input_const_tensor_type

Definition at line 93 of file OperatorTraits.hpp.

◆ InputDataParallelMatType

template<typename OpT >

using lbann::InputDataParallelMatType = typedef typename OperatorTraits<OpT>::input_data_parallel_mat_type

Definition at line 74 of file OperatorTraits.hpp.

◆ InputModelParallelMatType

template<typename OpT >

using lbann::InputModelParallelMatType = typedef typename OperatorTraits<OpT>::input_model_parallel_mat_type

Definition at line 81 of file OperatorTraits.hpp.

◆ InputTensorType

template<typename OpT >

using lbann::InputTensorType = typedef typename OperatorTraits<OpT>::input_tensor_type

Definition at line 87 of file OperatorTraits.hpp.

◆ InputValueType

template<typename OpT >

using lbann::InputValueType = typedef typename OperatorTraits<OpT>::input_value_type

Definition at line 65 of file OperatorTraits.hpp.

◆ lbann_exception

using lbann::lbann_exception = typedef exception

Definition at line 145 of file exception.hpp.

◆ Mat

using lbann::Mat = typedef El::Matrix<DataType, El::Device::CPU>

Definition at line 185 of file base.hpp.

◆ MCMRMat

template<El::Device D>

using lbann::MCMRMat = typedef MCMRMatDT<DataType, D>

Definition at line 168 of file base.hpp.

◆ MCMRMatDT

template<typename TensorDataType , El::Device D>

using lbann::MCMRMatDT = typedef El::DistMatrix<TensorDataType, El::MC, El::MR, El::ELEMENT, D>

Definition at line 139 of file base.hpp.

◆ MCStarMat

template<El::Device D>

using lbann::MCStarMat = typedef MCStarMatDT<DataType, D>

ColSumStarVCMat.

Definition at line 178 of file base.hpp.

◆ MCStarMatDT

template<typename TensorDataType , El::Device D>

using lbann::MCStarMatDT = typedef El:: DistMatrix<TensorDataType, El::MC, El::STAR, El::ELEMENT, D>

ColSumStarVCMat.

Definition at line 157 of file base.hpp.

◆ ModelParallelMatrixType

template<typename T , El::Device D>

using lbann::ModelParallelMatrixType = typedef El::DistMatrix<T, El::Dist::MC, El::Dist::MR, El::DistWrap::ELEMENT, D>

Definition at line 39 of file OperatorTraits.hpp.

◆ MRStarMat

template<El::Device D>

using lbann::MRStarMat = typedef MRStarMatDT<DataType, D>

RowSumMat.

Definition at line 180 of file base.hpp.

◆ MRStarMatDT

template<typename TensorDataType , El::Device D>

using lbann::MRStarMatDT = typedef El:: DistMatrix<TensorDataType, El::MR, El::STAR, El::ELEMENT, D>

RowSumMat.

Definition at line 160 of file base.hpp.

◆ NonLeafClass

template<typename T >

using lbann::NonLeafClass = typedef HasAbstractFunction<T>

Alias for HasAbstractFunction.

Good OO practice suggests that non-leaf classes should be abstract – that is, have at least one unimplemented virtual function. LBANN fits this paradigm, so this alias is appropriate.

Definition at line 81 of file cloneable.hpp.

◆ observer_ptr

template<typename T >

using lbann::observer_ptr = typedef typename std::add_pointer<T>::type

Creating an observer_ptr to complement the unique_ptr and shared_ptr.

Definition at line 54 of file base.hpp.

◆ OutputConstTensorType

template<typename OpT >

using lbann::OutputConstTensorType = typedef typename OperatorTraits<OpT>::output_const_tensor_type

Definition at line 96 of file OperatorTraits.hpp.

◆ OutputDataParallelMatType

template<typename OpT >

using lbann::OutputDataParallelMatType = typedef typename OperatorTraits<OpT>::output_data_parallel_mat_type

Definition at line 77 of file OperatorTraits.hpp.

◆ OutputModelParallelMatType

template<typename OpT >

using lbann::OutputModelParallelMatType = typedef typename OperatorTraits<OpT>::output_model_parallel_mat_type

Definition at line 84 of file OperatorTraits.hpp.

◆ OutputTensorType

template<typename OpT >

using lbann::OutputTensorType = typedef typename OperatorTraits<OpT>::output_tensor_type

Definition at line 89 of file OperatorTraits.hpp.

◆ OutputValueType

template<typename OpT >

using lbann::OutputValueType = typedef typename OperatorTraits<OpT>::output_value_type

Definition at line 67 of file OperatorTraits.hpp.

◆ OwningLayerPtr

typedef std::shared_ptr< Layer > lbann::OwningLayerPtr

Smart pointer to manage ownership of a layer object.

This should be treated exactly like a std::unique_ptr<Layer> , i.e. there should be exactly one instance per pointer and the copy constructor and copy-assignment operators should never be used. Using this like a std::shared_ptr may lead to unexpected behavior.

The only reason this is not a std::unique_ptr is because Cereal cannot natively serialize raw pointers, making it hard to serialize the layer graph. However, it can accommodate std::weak_ptr . In an ideal world, Cereal would support a non-owning smart pointer to an object in std::unique_ptr (possibly the experimental observer_ptr ), but we can make do by managing layers with std::shared_ptr .

Todo:: Replace with std::unique_ptr<Layer> when C++ and Cereal support std::observer_ptr .

Definition at line 125 of file layer.hpp.

◆ OwningWeightsPtr

using lbann::OwningWeightsPtr = typedef std::shared_ptr<weights>

Smart pointer to manage ownership of a weights object.

This should be treated exactly like a std::unique_ptr<weights> , i.e. there should be exactly one instance per pointer and the copy constructor and copy-assignment operators should never be used. Using this like a std::shared_ptr may lead to unexpected behavior.

The only reason this is not a std::unique_ptr is because Cereal cannot natively serialize raw pointers. However, it can accommodate std::weak_ptr . In an ideal world, Cereal would support a non-owning smart pointer to an object in std::unique_ptr (possibly the experimental observer_ptr ), but we can make do by managing weights with std::shared_ptr .

Todo:: Replace with std::unique_ptr<weights> when C++ and Cereal support std::observer_ptr .

Definition at line 77 of file model.hpp.

◆ persist_type_iterator

using lbann::persist_type_iterator = typedef enum_iterator<persist_type, persist_type::train, persist_type::validation_context>

Definition at line 56 of file persist.hpp.

◆ rng_gen

using lbann::rng_gen = typedef std::mt19937

Definition at line 38 of file random_number_generators.hpp.

◆ RowMajorDims

template<typename IndexT >

using lbann::RowMajorDims = typedef NamedVector<IndexT, struct RowMajorDimsTag>

Definition at line 79 of file tensor_dims_utils.hpp.

◆ RowMajorPerm

using lbann::RowMajorPerm = typedef NamedVector<int, struct RowMajorPermTag>

Definition at line 90 of file tensor_dims_utils.hpp.

◆ RowMajorStrides

template<typename IndexT >

using lbann::RowMajorStrides = typedef NamedVector<IndexT, struct RowMajorStridesTag>

Definition at line 85 of file tensor_dims_utils.hpp.

◆ slice_points_mode_iterator

using lbann::slice_points_mode_iterator = typedef enum_iterator<slice_points_mode, slice_points_mode::INDEPENDENT, slice_points_mode::NA>

Definition at line 79 of file metadata.hpp.

◆ SPModeSlicePoints

using lbann::SPModeSlicePoints = typedef std::unordered_map<slice_points_mode, std::vector<El::Int> >

Map from slice points modes to slice points.

Definition at line 76 of file metadata.hpp.

◆ StarMat

template<El::Device D>

using lbann::StarMat = typedef StarMatDT<DataType, D>

Definition at line 172 of file base.hpp.

◆ StarMatDT

template<typename TensorDataType , El::Device D>

using lbann::StarMatDT = typedef El::DistMatrix<TensorDataType, El::STAR, El::STAR, El::ELEMENT, D>

Definition at line 145 of file base.hpp.

◆ StarMRMat

template<El::Device D>

using lbann::StarMRMat = typedef StarMRMatDT<DataType, D>

ColSumMat.

Definition at line 182 of file base.hpp.

◆ StarMRMatDT

template<typename TensorDataType , El::Device D>

using lbann::StarMRMatDT = typedef El::DistMatrix<TensorDataType, El::STAR, El::MR, El::ELEMENT, D>

ColSumMat.

Definition at line 163 of file base.hpp.

◆ StarVCMat

template<El::Device D>

using lbann::StarVCMat = typedef StarVCMatDT<DataType, D>

Definition at line 174 of file base.hpp.

◆ StarVCMatDT

template<typename TensorDataType , El::Device D>

using lbann::StarVCMatDT = typedef El::DistMatrix<TensorDataType, El::STAR, El::VC, El::ELEMENT, D>

Definition at line 148 of file base.hpp.

◆ supported_layer_data_type

using lbann::supported_layer_data_type = typedef h2::meta::TL< float, double>

Definition at line 65 of file data_type_layer.hpp.

◆ supported_operator_data_type

using lbann::supported_operator_data_type = typedef h2::meta::TL< float, double, El::Complex<float>, El::Complex<double> >

Definition at line 61 of file operator.hpp.

◆ TargetModeDimMap

using lbann::TargetModeDimMap = typedef std::unordered_map<data_reader_target_mode, std::vector<El::Int> >

Map from target modes to dimension maps.

Definition at line 56 of file metadata.hpp.

◆ ToComplex

template<typename T >

using lbann::ToComplex = typedef typename ToComplexT<T>::type

Definition at line 65 of file fft_common.hpp.

◆ ToReal

template<typename T >

using lbann::ToReal = typedef typename ToRealT<T>::type

Definition at line 50 of file fft_common.hpp.

◆ TrainingAlgorithmBuilder

using lbann::TrainingAlgorithmBuilder = typedef typename TrainingAlgorithmFactory::builder_type

The builder type used to create a new training algorithm.

Definition at line 52 of file execution_algorithms/factory.hpp.

◆ TrainingAlgorithmFactory

using lbann::TrainingAlgorithmFactory = typedef generic_factory< TrainingAlgorithm, std::string, generate_builder_type<TrainingAlgorithm, google::protobuf::Message const&> >

Factory for constructing training algorithms from protobuf messages.

Definition at line 47 of file execution_algorithms/factory.hpp.

◆ TrainingAlgorithmKey

using lbann::TrainingAlgorithmKey = typedef typename TrainingAlgorithmFactory::id_type

The trainining algorithm factory key.

Definition at line 55 of file execution_algorithms/factory.hpp.

◆ VCStarMat

template<El::Device D>

using lbann::VCStarMat = typedef VCStarMatDT<DataType, D>

Definition at line 176 of file base.hpp.

◆ VCStarMatDT

template<typename TensorDataType , El::Device D>

using lbann::VCStarMatDT = typedef El::DistMatrix<TensorDataType, El::VC, El::STAR, El::ELEMENT, D>

Definition at line 154 of file base.hpp.

◆ ViewingLayerPtr

typedef std::weak_ptr< Layer > lbann::ViewingLayerPtr

Smart pointer to reference a layer object.

See OwningLayerPtr

Todo:: Replace with std::observer_ptr<Layer> when supported by C++ and Cereal.

Definition at line 133 of file layer.hpp.

◆ ViewingWeightsPtr

typedef std::weak_ptr< weights > lbann::ViewingWeightsPtr

Smart pointer to reference a weights object.

See OwningWeightsPtr

Todo:: Replace with std::observer_ptr<Weights> when supported by C++ and Cereal.

Definition at line 89 of file layer.hpp.

◆ visitor_hook_iterator

using lbann::visitor_hook_iterator = typedef enum_iterator<visitor_hook, visitor_hook::setup_begin, visitor_hook::invalid>

Definition at line 65 of file visitor_hooks.hpp.

◆ void_t

template<typename... Ts>

using lbann::void_t = typedef typename make_void<Ts...>::type

Alternative to c++17 std::void_t for older compilers.

Definition at line 46 of file detect_El_mpi.hpp.

◆ weights_proxy

template<typename TensorDataType >

using lbann::weights_proxy = typedef WeightsProxy<TensorDataType>

Definition at line 346 of file weights_proxy.hpp.

◆ world_comm_ptr

using lbann::world_comm_ptr = typedef std::unique_ptr<lbann_comm, std::function<void(lbann_comm*)> >

Definition at line 60 of file base.hpp.

Enumeration Type Documentation

◆ BackpropRequirements

enum lbann::BackpropRequirements

Backpropagation requirements from a layer or operator.

Enumerator
PROPAGATE_NOTHING
ERROR_SIGNALS
PREV_ACTIVATIONS
ACTIVATIONS
WEIGHTS

Definition at line 203 of file base.hpp.

◆ batch_normalization_stats_aggregation

enum lbann::batch_normalization_stats_aggregation

strong

Enumerator
local	Statistics are aggregated only within a single rank.
node_local	Statistics are aggregated among every rank in a single node.
global	Statistics are aggregated among every rank in the model.

Definition at line 42 of file batch_normalization.hpp.

◆ bwd_data_conv_alg

enum lbann::bwd_data_conv_alg

strong

Which backward convolution algorithm to use.

Enumerator
CUDNN_ALGO_0
CUDNN_ALGO_1
FFT
FFT_TILING
WINOGRAD
WINOGRAD_NONFUSED
IMPLICIT_GEMM

Definition at line 45 of file dnn_enums.hpp.

◆ bwd_filter_conv_alg

enum lbann::bwd_filter_conv_alg

strong

Which backward convolution filter algorithm to use.

Enumerator
CUDNN_ALGO_0
CUDNN_ALGO_1
FFT
CUDNN_ALGO_3
WINOGRAD
WINOGRAD_NONFUSED
FFT_TILING
IMPLICIT_GEMM

Definition at line 57 of file dnn_enums.hpp.

◆ callback_type

enum lbann::callback_type

strong

Todo:: Fix the callback types to properly track execution phases

Enumerator
model_only
weights_only
execution_context_only
full_checkpoint
invalid

Definition at line 63 of file persist.hpp.

◆ data_layout

enum lbann::data_layout

strong

Data layout that is optimized for different modes of parallelism.

Enumerator
MODEL_PARALLEL
DATA_PARALLEL
invalid

Definition at line 218 of file base.hpp.

◆ data_reader_target_mode

enum lbann::data_reader_target_mode

strong

Enumerator
CLASSIFICATION
REGRESSION
RECONSTRUCTION
LABEL_RECONSTRUCTION
INPUT
NA

Definition at line 44 of file metadata.hpp.

◆ execution_mode

enum lbann::execution_mode

strong

Neural network execution mode.

Enumerator
training
validation
testing
prediction
tournament
inference
invalid

Definition at line 229 of file base.hpp.

◆ fwd_conv_alg

enum lbann::fwd_conv_alg

strong

Which forward convolution algorithm to use.

Enumerator
IMPLICIT_GEMM
IMPLICIT_PRECOMP_GEMM
GEMM
DIRECT
FFT
FFT_TILING
WINOGRAD
WINOGRAD_NONFUSED

Definition at line 32 of file dnn_enums.hpp.

◆ GridType

enum lbann::GridType

strong

Grid types in sub-grid parallelism (2nd order)

Enumerator
NO_GRID
PRIMARY_GRID
SECONDARY_GRID

Definition at line 55 of file comm.hpp.

◆ lrn_mode

enum lbann::lrn_mode

strong

Internal LBANN names for supported LRN layer modes.

Enumerator
CROSS_CHANNEL_DIM1

Definition at line 72 of file dnn_enums.hpp.

◆ matrix_format

enum lbann::matrix_format

strong

Distributed matrix format.

Enumerator
MC_MR
CIRC_CIRC
STAR_STAR
STAR_VC
MC_STAR
invalid

Definition at line 192 of file base.hpp.

◆ optimizer_gradient_status

enum lbann::optimizer_gradient_status

strong

Status of values in objective function gradient.

Enumerator
ready	Values can be accessed immediately.
cleared	Values have been cleared. Buffer must be zeroed out before accessing.
allreduce_needed	Allreduce is needed before accessing values.
allreduce_started	Allreduce on values is in progress. Non-blocking allreduce must be synchronized before accessing.

Definition at line 52 of file optimizer.hpp.

◆ persist_type

enum lbann::persist_type

strong

Enumerator
train
model
metrics
validate
testing
inference_context
prediction_context
training_context
testing_context
tournament_context
validation_context

Definition at line 39 of file persist.hpp.

◆ pooling_mode

enum lbann::pooling_mode

strong

Which pooling mode to use.

Enumerator
MAX
AVERAGE_COUNT_INCLUDE_PADDING
AVERAGE_COUNT_EXCLUDE_PADDING
MAX_DETERMINISTIC

Definition at line 78 of file dnn_enums.hpp.

◆ probability_distribution

enum lbann::probability_distribution

strong

Probability distributions.

Enumerator
invalid
gaussian
bernoulli
uniform

Definition at line 39 of file random.hpp.

◆ reduction_mode

enum lbann::reduction_mode

strong

Enumerator
INVALID
SUM
AVERAGE

Definition at line 34 of file reduction.hpp.

◆ slice_points_mode

enum lbann::slice_points_mode

strong

Enumerator
INDEPENDENT
DEPENDENT
NA

Definition at line 66 of file metadata.hpp.

◆ softmax_alg

enum lbann::softmax_alg

strong

Internal LBANN names for supported softmax algorithms.

Enumerator
FAST
ACCURATE
LOG

Definition at line 110 of file dnn_enums.hpp.

◆ softmax_mode

enum lbann::softmax_mode

strong

Which tensor dimensions to apply softmax over.

Enumerator

INVALID

INSTANCE

Sample-wise softmax.

Slice tensor along the sample dimension (assuming data in NCHW format) and apply softmax independently to each slice (once per sample).

CHANNEL

Position-wise softmax.

Split tensor along all but the channel dimension (assuming data in NCHW format) and apply softmax independently to each piece (once per spatial position per sample).

This is not to be confused with channelwise_softmax, which slices along the sample and channel dimensions.

Definition at line 87 of file dnn_enums.hpp.

◆ SubGraphCommunication

enum lbann::SubGraphCommunication

Enumerator
PT2PT
COLL
COLL_OPT

Definition at line 261 of file layer.hpp.

◆ visitor_hook

enum lbann::visitor_hook

strong

Neural network execution mode.

Enumerator
setup_begin
setup_end
phase_end
epoch_begin
epoch_end
optimize_begin
optimize_end
execution_mode_begin	Special visitor hooks that execute in conjunction with the execution mode.
execution_mode_end
execution_mode_batch_begin
execution_mode_batch_end
execution_mode_forward_prop_begin
execution_mode_forward_prop_end
execution_mode_backward_prop_begin
execution_mode_backward_prop_end
invalid

Definition at line 39 of file visitor_hooks.hpp.

Function Documentation

◆ __swapEndianInt()

void lbann::__swapEndianInt ( unsigned int & ui )

inline

Definition at line 85 of file file_utils.hpp.

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [1/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	int8_t	,
		conduit::DataType::INT8_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [2/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	int16_t	,
		conduit::DataType::INT16_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [3/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	int32_t	,
		conduit::DataType::INT32_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [4/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	int64_t	,
		conduit::DataType::INT64_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [5/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	uint8_t	,
		conduit::DataType::UINT8_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [6/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	uint16_t	,
		conduit::DataType::UINT16_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [7/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	uint32_t	,
		conduit::DataType::UINT32_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [8/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	uint64_t	,
		conduit::DataType::UINT64_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [9/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	float	,
		conduit::DataType::FLOAT32_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [10/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	double	,
		conduit::DataType::FLOAT64_ID
	)

◆ _LBANN_CONDUIT_DTYPE_INSTANTIATION_() [11/11]

lbann::_LBANN_CONDUIT_DTYPE_INSTANTIATION_	(	char *	,
		conduit::DataType::CHAR8_STR_ID
	)

◆ add_delimiter()

std::string lbann::add_delimiter ( const std::string dir )

Here is the caller graph for this function:

◆ allocate_trainer_resources()

int lbann::allocate_trainer_resources ( lbann_comm * comm )

Here is the caller graph for this function:

◆ apply_entrywise_binary_operator() [1/2]

template<template< typename > class Op, typename TensorDataType >

void lbann::apply_entrywise_binary_operator	(	const El::AbstractMatrix< TensorDataType > &	input1,
		const El::AbstractMatrix< TensorDataType > &	input2,
		El::AbstractMatrix< TensorDataType > &	output
	)

Apply an entry-wise binary operator to CPU data. The input and output data must be on CPU and must have the same dimensions.

Definition at line 91 of file entrywise_operator.hpp.

Here is the caller graph for this function:

◆ apply_entrywise_binary_operator() [2/2]

template<template< typename > class Op, typename TensorDataType >

void lbann::apply_entrywise_binary_operator	(	const El::AbstractDistMatrix< TensorDataType > &	input1,
		const El::AbstractDistMatrix< TensorDataType > &	input2,
		El::AbstractDistMatrix< TensorDataType > &	output
	)

Apply an entry-wise binary operator to GPU data. The input and output data must be on GPU, have the same dimensions, and be aligned.

Definition at line 186 of file entrywise_operator.hpp.

◆ apply_entrywise_unary_operator() [1/2]

template<template< typename > class Op, typename TensorDataType >

void lbann::apply_entrywise_unary_operator	(	const El::AbstractMatrix< TensorDataType > &	input,
		El::AbstractMatrix< TensorDataType > &	output
	)

Apply an entry-wise unary operator to CPU data. The input and output data must be on CPU and must have the same dimensions.

Definition at line 40 of file entrywise_operator.hpp.

Here is the caller graph for this function:

◆ apply_entrywise_unary_operator() [2/2]

template<template< typename > class Op, typename TensorDataType >

void lbann::apply_entrywise_unary_operator	(	const El::AbstractDistMatrix< TensorDataType > &	input,
		El::AbstractDistMatrix< TensorDataType > &	output
	)

Apply an entry-wise unary operator to CPU data. The input and output data must be on CPU, have the same dimensions, and be aligned.

Definition at line 157 of file entrywise_operator.hpp.

◆ bernoulli_fill()

template<typename TensorDataType >

void lbann::bernoulli_fill	(	El::AbstractDistMatrix< TensorDataType > &	mat,
		El::Int	m,
		El::Int	n,
		double	p = `0.5`
	)

Make mat into an m x n matrix where each entry is an indepenent Bernoulli random variable with parameter p. This makes the same guarantees as gaussian_fill.

Here is the caller graph for this function:

◆ bernoulli_fill_procdet()

template<typename TensorDataType >

void lbann::bernoulli_fill_procdet	(	El::AbstractDistMatrix< TensorDataType > &	mat,
		El::Int	m,
		El::Int	n,
		double	p = `0.5`
	)

Make mat into an m x n matrix where each entry is an independent Bernoulli random variable with parameter p. This makes the same guarantees as gaussian_fill_procdet.

Here is the caller graph for this function:

◆ bp_setup_gradient_wrt_inputs_impl() [1/2]

template<typename TensorDataType , El::Device Device>

void lbann::bp_setup_gradient_wrt_inputs_impl ( concatenate_layer< TensorDataType, data_layout::MODEL_PARALLEL, Device > & l )

Definition at line 421 of file concatenate.hpp.

Here is the call graph for this function:

◆ bp_setup_gradient_wrt_inputs_impl() [2/2]

template<typename TensorDataType , El::Device Device>

void lbann::bp_setup_gradient_wrt_inputs_impl ( concatenate_layer< TensorDataType, data_layout::DATA_PARALLEL, Device > & l )

Definition at line 447 of file concatenate.hpp.

Here is the call graph for this function:

◆ build_abs_operator()

template<typename DataT , El::Device D>

std::unique_ptr<Operator<DataT, El::Base<DataT>, D> > lbann::build_abs_operator ( lbann_data::Operator const & op )

◆ build_adagrad_optimizer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<optimizer> lbann::build_adagrad_optimizer_from_pbuf ( google::protobuf::Message const & )

◆ build_adam_optimizer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<optimizer> lbann::build_adam_optimizer_from_pbuf ( google::protobuf::Message const & )

◆ build_constant_initializer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<weights_initializer> lbann::build_constant_initializer_from_pbuf ( google::protobuf::Message const & msg )

◆ build_glorot_initializer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<weights_initializer> lbann::build_glorot_initializer_from_pbuf ( google::protobuf::Message const & msg )

Here is the caller graph for this function:

◆ build_he_initializer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<weights_initializer> lbann::build_he_initializer_from_pbuf ( google::protobuf::Message const & msg )

Here is the caller graph for this function:

◆ build_hypergradient_adam_optimizer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<optimizer> lbann::build_hypergradient_adam_optimizer_from_pbuf ( google::protobuf::Message const & )

◆ build_lecun_initializer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<weights_initializer> lbann::build_lecun_initializer_from_pbuf ( google::protobuf::Message const & msg )

Here is the caller graph for this function:

◆ build_model_from_prototext()

std::unique_ptr<model> lbann::build_model_from_prototext	(	int	argc,
		char **	argv,
		const lbann_data::Trainer *	pb_trainer,
		lbann_data::LbannPB &	pb,
		lbann_comm *	comm,
		thread_pool &	io_thread_pool,
		std::vector< std::shared_ptr< callback_base >> &	shared_callbacks
	)

Here is the caller graph for this function:

◆ build_normal_initializer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<weights_initializer> lbann::build_normal_initializer_from_pbuf ( google::protobuf::Message const & msg )

◆ build_numpy_initializer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<weights_initializer> lbann::build_numpy_initializer_from_pbuf ( google::protobuf::Message const & msg )

◆ build_operator_layer_from_pbuf()

template<typename InputT , typename OutputT , data_layout Layout, El ::Device Device>

std::unique_ptr<Layer> lbann::build_operator_layer_from_pbuf	(	lbann_comm *	,
		lbann_data::Layer const &
	)

Here is the caller graph for this function:

◆ build_rmsprop_optimizer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<optimizer> lbann::build_rmsprop_optimizer_from_pbuf ( google::protobuf::Message const & )

◆ build_sgd_optimizer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<optimizer> lbann::build_sgd_optimizer_from_pbuf ( google::protobuf::Message const & )

◆ build_string()

template<typename... Args>

std::string lbann::build_string ( Args &&... args )

Build a string from the arguments.

The arguments must be stream-outputable (have operator<<(ostream&, T) defined). It will be a static error if this fails.

Template Parameters

Args	(Inferred) The types of the arguments.

Parameters

[in] args The things to be stringified.

Definition at line 157 of file exception.hpp.

Here is the caller graph for this function:

◆ build_uniform_initializer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<weights_initializer> lbann::build_uniform_initializer_from_pbuf ( google::protobuf::Message const & msg )

◆ build_value_initializer_from_pbuf()

template<typename TensorDataType >

std::unique_ptr<weights_initializer> lbann::build_value_initializer_from_pbuf ( google::protobuf::Message const & msg )

◆ check_if_dir_exists()

bool lbann::check_if_dir_exists ( const std::string & dirname )

Todo:: Deprecated. Use lbann::file::directory_exists instead.

Here is the caller graph for this function:

◆ check_if_file_exists()

bool lbann::check_if_file_exists ( const std::string & filename )

Todo:: Deprecated. Use lbann::file::file_exists instead.

Here is the caller graph for this function:

◆ check_perm_impl()

template<typename T >

bool lbann::check_perm_impl ( std::vector< T > perm )

Checks that the permutation is valid.

A valid permutation uses every index in [0, ndims) exactly once.

Definition at line 264 of file tensor_dims_utils.hpp.

Here is the caller graph for this function:

◆ clone_all()

template<typename CloneablePtrT , h2::meta::EnableWhen< IsCloneablePtr< CloneablePtrT >, int > = 1>

auto lbann::clone_all ( std::vector< CloneablePtrT > const & things )

Definition at line 294 of file cloneable.hpp.

◆ closeread()

int lbann::closeread	(	int	fd,
		const char *	filename
	)

Todo:: Deprecated.

◆ closewrite()

int lbann::closewrite	(	int	fd,
		const char *	filename
	)

Todo:: Deprecated.

◆ col2im() [1/2]

template<typename TensorDataType >

void lbann::col2im	(	const CPUMatDT< TensorDataType > &	col,
		CPUMatDT< TensorDataType > &	im,
		int	num_channels,
		int	im_num_dims,
		const int *	im_dims,
		const int *	im_pads,
		const int *	window_dims,
		const int *	window_strides
	)

Rearrange matrix columns into image blocks.

This is approximately the inverse of im2col. The output tensor im is produced from the input matrix col by shifting a window across im. Each column of col is matched with the corresponding window position and corresponding entries are added to im.

Parameters

col	col matrix. Height should be equal to window size and width equal to number of window shifts. Data should be contiguous.
im	im tensor, represented as a column vector.
num_channels	Number of channels in im tensor.
im_num_dims	Number of dimensions in im tensor.
im_dims	im tensor dimensions.
im_pads	Zero pads for im tensor.
window_dims	Dimensions of window.
window_strides	Window shift strides.

◆ col2im() [2/2]

template<typename TensorDataType >

void lbann::col2im	(	const CPUMatDT< TensorDataType > &	col,
		CPUMatDT< TensorDataType > &	im,
		int	num_channels,
		int	im_num_dims,
		const int *	im_dims,
		const int *	im_pads,
		const int *	window_dims,
		const int *	window_strides,
		std::function< TensorDataType(const TensorDataType &, const TensorDataType &)>	reduction_op
	)

Rearrange matrix columns into image blocks.

This is approximately the inverse of im2col. The output tensor im is produced from the input matrix col by shifting a window across im. Each column of col is matched with the corresponding window position and corresponding entries are reduced to im.

Parameters

col	col matrix. Height should be equal to window size and width equal to number of window shifts. Data should be contiguous.
im	im tensor, represented as a column vector.
num_channels	Number of channels in im tensor.
im_num_dims	Number of dimensions in im tensor.
im_dims	im tensor dimensions.
im_pads	Zero pads for im tensor.
window_dims	Dimensions of window.
window_strides	Window shift strides.
reduction_op	Reduction operation.

◆ col2im_1x1()

template<typename TensorDataType >

void lbann::col2im_1x1	(	const TensorDataType *	input_buffer,
		TensorDataType *	output_buffer,
		const int	num_channels,
		const int	num_output_dims,
		const int *	output_dims
	)

Rearrange matrix columns into 1x1 image blocks.

This is an optimized implementation of col2im when the window has a size of one, there is no padding, and the window stride is one. col2im will automatically call this routine if it detects a 1x1 col2im.

◆ col2im_2d()

template<typename TensorDataType >

void lbann::col2im_2d	(	const TensorDataType *__restrict__	input_buffer,
		TensorDataType *__restrict__	output_buffer,
		int	output_dim_x,
		int	output_dim_y,
		int	output_pad_x,
		int	output_pad_y,
		int	num_channels,
		int	window_dim_x,
		int	window_dim_y,
		int	offset_stride_x,
		int	offset_stride_y
	)

Rearrange matrix columns into 2D image blocks.

This is an optimized implementation of col2im for 2D data. col2im will automatically call this routine if it detects 2D data.

◆ ColMajor() [1/5]

template<typename IndexT >

auto lbann::ColMajor ( std::vector< IndexT > && ds )

Definition at line 188 of file tensor_dims_utils.hpp.

Here is the caller graph for this function:

◆ ColMajor() [2/5]

template<typename IndexT >

auto lbann::ColMajor ( std::vector< IndexT > const & ds )

Definition at line 194 of file tensor_dims_utils.hpp.

◆ ColMajor() [3/5]

template<typename IndexT >

auto lbann::ColMajor ( RowMajorDims< IndexT > const & dims )

Definition at line 200 of file tensor_dims_utils.hpp.

◆ ColMajor() [4/5]

template<typename IndexT >

auto lbann::ColMajor ( ColMajorDims< IndexT > const & dims )

Definition at line 206 of file tensor_dims_utils.hpp.

◆ ColMajor() [5/5]

template<typename IndexT >

auto lbann::ColMajor ( ColMajorDims< IndexT > && dims )

Definition at line 212 of file tensor_dims_utils.hpp.

◆ columnwise_covariance()

void lbann::columnwise_covariance	(	const AbsDistMat &	data1,
		const AbsDistMat &	data2,
		const AbsDistMat &	means1,
		const AbsDistMat &	means2,
		AbsDistMat &	cov
	)

Compute column-wise covariances.

Parameters

data1	Input matrix in U,V format.
data2	Input matrix in U,V format.
means1	Column-wise mean vector for data1 in STAR,V format.
means2	Column-wise mean vector for data2 in STAR,V format.
cov	Covariance vector in STAR,V format. Output as a row vector with same number of columns as 'data1'.

◆ columnwise_mean_and_stdev() [1/2]

void lbann::columnwise_mean_and_stdev	(	const Mat &	data,
		Mat &	means,
		Mat &	stdevs
	)

Compute column-wise means and standard deviations.

Parameters

data	Input matrix.
means	Mean vector. Output as a row vector with same number of columns as 'data'.
stdevs	Standard deviation vector. Output as a row vector with same number of columns as 'data'.

◆ columnwise_mean_and_stdev() [2/2]

void lbann::columnwise_mean_and_stdev	(	const AbsDistMat &	data,
		AbsDistMat &	means,
		AbsDistMat &	stdevs
	)

Compute column-wise means and standard deviations.

Parameters

data	Input matrix in U,V format.
means	Mean vector in STAR,V format. Output as a row vector with same number of columns as 'data'.
stdevs	Standard deviation vector in STAR,V format. Output as a row vector with same number of columns as 'data'.

◆ columnwise_sums_and_sqsums()

void lbann::columnwise_sums_and_sqsums	(	const AbsDistMat &	data,
		AbsDistMat &	sums,
		AbsDistMat &	sqsums
	)

Compute column-wise sum and sqsum.

Parameters

data	Input matrix in U,V format.
sums	Sum vector in STAR,V format. Output as a row vector with same number of columns as 'data'.
sqsums	Sum of squared vector in STAR,V format. Output as a row vector with same number of columns as 'data'.

◆ conduit_to_string()

std::string lbann::conduit_to_string ( conduit::Node const & field )

For some reason conduit includes quotes around the string, even when they're not in the json file – so need to strip them off

◆ construct_all_options()

void lbann::construct_all_options ( )

Here is the caller graph for this function:

◆ construct_datareader_options()

void lbann::construct_datareader_options ( )

◆ construct_datastore_options()

void lbann::construct_datastore_options ( )

◆ construct_io_thread_pool()

std::unique_ptr<thread_pool> lbann::construct_io_thread_pool	(	lbann_comm *	comm,
		bool	serialized_io
	)

Here is the caller graph for this function:

◆ construct_jag_options()

void lbann::construct_jag_options ( )

◆ construct_std_options()

void lbann::construct_std_options ( )

◆ construct_trainer()

trainer& lbann::construct_trainer	(	lbann_comm *	comm,
		lbann_data::Trainer *	pb_trainer,
		lbann_data::LbannPB &	pb
	)

Here is the caller graph for this function:

◆ convert() [1/6]

template<typename IndexT >

void lbann::convert	(	RowMajorDims< IndexT > const &	src,
		ColMajorDims< IndexT > &	tgt
	)

Definition at line 98 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ convert() [2/6]

template<typename IndexT >

void lbann::convert	(	ColMajorDims< IndexT > const &	src,
		RowMajorDims< IndexT > &	tgt
	)

Definition at line 104 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ convert() [3/6]

template<typename IndexT >

void lbann::convert	(	RowMajorStrides< IndexT > const &	src,
		ColMajorStrides< IndexT > &	tgt
	)

Definition at line 111 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ convert() [4/6]

template<typename IndexT >

void lbann::convert	(	ColMajorStrides< IndexT > const &	src,
		RowMajorStrides< IndexT > &	tgt
	)

Definition at line 117 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ convert() [5/6]

void lbann::convert	(	RowMajorPerm const &	src,
		ColMajorPerm &	tgt
	)

inline

Definition at line 134 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ convert() [6/6]

void lbann::convert	(	ColMajorPerm const &	src,
		RowMajorPerm &	tgt
	)

inline

Definition at line 139 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ create_cereal_archive_binary_string()

template<typename C >

std::string lbann::create_cereal_archive_binary_string ( C & obj )

Definition at line 177 of file persist_impl.hpp.

Here is the caller graph for this function:

◆ create_dir()

bool lbann::create_dir ( const std::string output_dir )

Todo:: Deprecated. Use lbann::file::make_directory instead.

Here is the caller graph for this function:

◆ customize_data_readers_sample_list()

void lbann::customize_data_readers_sample_list	(	const lbann_comm &	comm,
		::lbann_data::LbannPB &	p
	)

Customize the name of the sample list.

The following options are available

trainer ID
model name

The format for the naming convention if the provided name is <sample list> is:

<sample list> == <basename>.<extension>
<model name>_t<ID>_<basename>.<extension>

◆ data_layout_from_string()

data_layout lbann::data_layout_from_string ( std::string const & str )

◆ data_layout_to_matrix_format()

matrix_format lbann::data_layout_to_matrix_format ( data_layout layout )

◆ decode_image()

void lbann::decode_image	(	El::Matrix< uint8_t > &	src,
		El::Matrix< uint8_t > &	dst,
		std::vector< size_t > &	dims
	)

Decode an image from buf.

Parameters

src	A buffer containing image data to be decoded.
dst	Image will be loaded into this matrix, in OpenCV format.
dims	Will contain the dimensions of the image as {channels, height, width}.

◆ device_from_string()

El::Device lbann::device_from_string ( std::string const & str )

◆ display_omp_setup()

void lbann::display_omp_setup ( )

◆ do_tensor_copy()

template<typename TDT >

void lbann::do_tensor_copy	(	const BaseDistMat &	src,
		El::AbstractDistMatrix< TDT > &	tgt
	)

Function to efficiently select the best method for copying between two distributed tensors. Enable selection between synchronous and asynchronous copies based on tensor distribution and pre-processing macros.

Definition at line 39 of file tensor_impl.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ does_hdf5_field_require_repack_to_channels_first()

bool lbann::does_hdf5_field_require_repack_to_channels_first ( conduit::Node const & metadata )

◆ encode_image()

std::string lbann::encode_image	(	const El::Matrix< uint8_t > &	image,
		const std::vector< size_t > &	dims,
		std::string const &	img_format
	)

Encodes image to given format.

Parameters

image	The image to convert
dims	The dimensions of the image.
img_format	The export format.

Returns: Returns image in std::string format (byte-string)

◆ endsWith()

bool lbann::endsWith	(	const std::string	mainStr,
		const std::string &	toMatch
	)

◆ entrywise_mean_and_stdev() [1/2]

void lbann::entrywise_mean_and_stdev	(	const Mat &	data,
		DataType &	mean,
		DataType &	stdev
	)

Compute mean and standard deviation over matrix entries.

Parameters

data	Input matrix.
mean	Mean value (output).
stdev	Standard deviation (output).

◆ entrywise_mean_and_stdev() [2/2]

void lbann::entrywise_mean_and_stdev	(	const AbsDistMat &	data,
		DataType &	mean,
		DataType &	stdev
	)

Compute mean and standard deviation over matrix entries.

Parameters

data	Input matrix.
mean	Mean value (output).
stdev	Standard deviation (output).

◆ exec_mode_from_string()

execution_mode lbann::exec_mode_from_string ( std::string const & str )

Convert a string to an execution_mode.

◆ execution_mode_to_persist_type()

persist_type lbann::execution_mode_to_persist_type ( execution_mode m )

inline

Definition at line 38 of file persist_impl.hpp.

Here is the caller graph for this function:

◆ exists()

int lbann::exists ( const char * filename )

Todo:: Deprecated.

◆ fast_rand_int()

template<typename Generator , typename T >

T lbann::fast_rand_int	(	Generator &	g,
		T	max
	)

inline

Return random integers uniformly distributed in [0, max).

Parameters

g	C++ uniform random bit generator.
max	Upper bound on the distribution.

Note: It turns out that the GCC std::uniform_int_distribution is really slow. That implementation is used by most compilers. This implementation is roughly five times faster than that one.

Definition at line 56 of file random.hpp.

Here is the caller graph for this function:

◆ fast_rand_int_pow2()

template<typename Generator , typename T >

T lbann::fast_rand_int_pow2	(	Generator &	g,
		T	max
	)

inline

Faster variant of fast_rand_int in the case that max is a power of 2. Do not call this if max is not a power of 2.

Definition at line 75 of file random.hpp.

◆ finalize()

void lbann::finalize ( lbann_comm * comm = nullptr )

Destroy LBANN communicator.

Finalizes Elemental, which in turn finalizes MPI, Aluminum, and CUDA.

Here is the caller graph for this function:

◆ finalize_lbann()

void lbann::finalize_lbann ( lbann_comm * comm = nullptr )

Destroy LBANN communicator for external application.

Parameters

[in] comm LBANN communicator

◆ force()

template<El::Device D, El::Device... Ds>

auto lbann::force ( El::MultiSync< D, Ds... > const & x ) -> El::SyncInfo<D> const&

inline

Force the MultiSync to the master SyncInfo.

This is a short-hand for static_casting for cases in which implicit conversion clashes with template deduction, for example.

Definition at line 67 of file sync_info_helpers.hpp.

Here is the caller graph for this function:

◆ fp_setup_outputs_impl() [1/2]

template<typename TensorDataType , El::Device Device>

void lbann::fp_setup_outputs_impl ( slice_layer< TensorDataType, data_layout::MODEL_PARALLEL, Device > & l )

Definition at line 211 of file slice.hpp.

Here is the call graph for this function:

◆ fp_setup_outputs_impl() [2/2]

template<typename TensorDataType , El::Device Device>

void lbann::fp_setup_outputs_impl ( slice_layer< TensorDataType, data_layout::DATA_PARALLEL, Device > & l )

Definition at line 232 of file slice.hpp.

Here is the call graph for this function:

◆ free_core_offset()

int lbann::free_core_offset ( const lbann_comm * comm )

◆ gaussian_fill()

template<typename TensorDataType >

void lbann::gaussian_fill	(	El::AbstractDistMatrix< TensorDataType > &	mat,
		El::Int	m,
		El::Int	n,
		TensorDataType	mean = `0.0`,
		TensorDataType	stddev = `1.0`
	)

Make mat into an m x n matrix where each entry is independently drawn from a Gaussian distribution with given mean and standard deviation. Unless selected so at compile-time, this ensures the entries of the matrix do not change as the grid it is distributed over changes; that is, it will have the same entries when mat spans any number of processes.

Here is the caller graph for this function:

◆ gaussian_fill_parallel()

template<typename TensorDataType >

void lbann::gaussian_fill_parallel	(	El::AbstractDistMatrix< TensorDataType > &	mat,
		El::Int	m,
		El::Int	n,
		TensorDataType	mean = `0.0`,
		TensorDataType	stddev = `1.0`
	)

Make mat into an m x n matrix where each entry is independently drawn from a Gaussian distribution with given mean and standard deviation. Entries are generated in parallel, so there are no guarantees of thread/process indendence.

Here is the caller graph for this function:

◆ gaussian_fill_procdet()

template<typename TensorDataType >

void lbann::gaussian_fill_procdet	(	El::AbstractDistMatrix< TensorDataType > &	mat,
		El::Int	m,
		El::Int	n,
		TensorDataType	mean = `0.0`,
		TensorDataType	stddev = `1.0`
	)

Make mat into an m x n matrix where each entry is independently drawn from a Gaussian distribution with given mean and standard deviation. This always ensures that the entries of the matrix do not change as the grid it is distributed over changes.

Here is the caller graph for this function:

◆ get_affinity()

int lbann::get_affinity	(	uint8_t *	cpus,
		uint8_t *	count
	)

◆ get_basename_without_ext()

std::string lbann::get_basename_without_ext ( const std::string file_name )

Here is the caller graph for this function:

◆ get_cmdline_overrides()

void lbann::get_cmdline_overrides	(	const lbann_comm &	comm,
		::lbann_data::LbannPB &	p
	)

adjusts the values in p by querying the options db

◆ get_const_trainer()

trainer const& lbann::get_const_trainer ( )

Get a const reference to the global trainer visible to this rank.

Here is the caller graph for this function:

◆ get_data_seq_generator()

rng_gen& lbann::get_data_seq_generator ( )

Return a reference to the global LBANN random number generator used for shuffling the data samples within each mini-batch

Note: This is stored in a thread_local variable.

Here is the caller graph for this function:

◆ get_env_var()

int lbann::get_env_var ( const char * id )

◆ get_ext_name()

std::string lbann::get_ext_name ( const std::string file_name )

Here is the caller graph for this function:

◆ get_fast_generator()

fast_rng_gen& lbann::get_fast_generator ( )

Return a reference to a possibly-faster global LBANN random number generator. Compared to get_generator, this should be slightly faster.

Note: If compiling with OpenMP, this is stored in a threadprivate variable.

Here is the caller graph for this function:

◆ get_fast_io_generator()

fast_rng_gen& lbann::get_fast_io_generator ( )

Return a reference to the fast global LBANN random number generator used for the I/O threads

Note: This is stored in a thread_local variable.

Here is the caller graph for this function:

◆ get_generator()

rng_gen& lbann::get_generator ( )

Return a reference to the global LBANN random number generator.

Note: If compiling with OpenMP, this is stored in a threadprivate variable.

Here is the caller graph for this function:

◆ get_handle_ptr()

static cutensorHandle_t* lbann::get_handle_ptr ( )

static

Definition at line 98 of file cutensor_support.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_im2col_output_size()

std::pair<size_t, size_t> lbann::get_im2col_output_size	(	const int	num_samples,
		const int	num_channels,
		const int	im_num_dims,
		const int *	im_dims,
		const int *	im_pads,
		const int *	window_dims,
		const int *	window_strides
	)

Get the height and the width of col matrix.

◆ get_io_generator()

rng_gen& lbann::get_io_generator ( )

Return a reference to the global LBANN random number generator used for shuffling the data samples within each mini-batch

Note: This is stored in a thread_local variable.

Here is the caller graph for this function:

◆ get_linear_size() [1/2]

template<typename T >

auto lbann::get_linear_size ( std::vector< T > const & dims )

Definition at line 59 of file dim_helpers.hpp.

Here is the caller graph for this function:

◆ get_linear_size() [2/2]

template<typename T >

auto lbann::get_linear_size	(	size_t	ndims,
		T const *	dims
	)

Definition at line 65 of file dim_helpers.hpp.

◆ get_linear_size_as() [1/2]

template<typename Out , typename In >

auto lbann::get_linear_size_as ( std::vector< In > const & dims )

Compute the linear size of the given dimensions with a specific type.

The accumulation is done at the "Out" type. This can be used to accumulate to a wider type than the dimensions may use.

Definition at line 41 of file dim_helpers.hpp.

◆ get_linear_size_as() [2/2]

template<typename Out , typename In >

auto lbann::get_linear_size_as	(	size_t	ndims,
		In const *	dims
	)

Definition at line 51 of file dim_helpers.hpp.

◆ get_ltfb_generator()

fast_rng_gen& lbann::get_ltfb_generator ( )

Return a reference to a global LBANN random number generator for LTFB.

Note: If compiling with OpenMP, this is stored in a threadprivate variable.

Here is the caller graph for this function:

◆ get_num_io_generators()

int lbann::get_num_io_generators ( )

Returns the number of provisioned I/O generators.

Here is the caller graph for this function:

◆ get_num_pus()

int lbann::get_num_pus ( )

◆ get_packed_strides() [1/2]

template<typename T >

auto lbann::get_packed_strides	(	size_t	ndims,
		T const *	dims
	)

Definition at line 91 of file dim_helpers.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_packed_strides() [2/2]

template<typename T >

auto lbann::get_packed_strides ( std::vector< T > const & dims )

Definition at line 97 of file dim_helpers.hpp.

Here is the call graph for this function:

◆ get_rank_in_world()

int lbann::get_rank_in_world ( )

Get the current rank within MPI_COMM_WORLD. This function is safe to call even if MPI has not initialized or has been finalized. In either case it returns a negative value.

Here is the caller graph for this function:

◆ get_sleep_sec()

int lbann::get_sleep_sec ( )

◆ get_strides() [1/3]

template<typename T >

auto lbann::get_strides	(	size_t	ndims,
		T const *	dims,
		T const &	lowest_stride
	)

Definition at line 71 of file dim_helpers.hpp.

◆ get_strides() [2/3]

template<typename T >

auto lbann::get_strides	(	std::vector< T > const &	dims,
		T const &	lowest_stride
	)

Definition at line 85 of file dim_helpers.hpp.

Here is the call graph for this function:

◆ get_strides() [3/3]

template<typename DimT >

auto lbann::get_strides ( ColMajorDims< DimT > const & dims )

Compute packed strides of the given dimensions.

This assumes that the tensor in question is packed with its dimensions represented in a column-major ordering. The strides are represented in the same type as the input dimensions.

Definition at line 248 of file tensor_dims_utils.hpp.

Here is the caller graph for this function:

◆ get_strides_as()

template<typename StrideT , typename DimT >

auto lbann::get_strides_as ( ColMajorDims< DimT > const & dims )

Compute packed strides of the given dimensions.

This assumes that the tensor in question is packed with its dimensions represented in a column-major ordering. This allows for type-converting the accumulating stride.

Definition at line 228 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ get_sync_info() [1/2]

template<typename TensorDataType , El::Device D>

El::SyncInfo<D> lbann::get_sync_info ( El::Matrix< TensorDataType, D > const & m )

noexcept

Get a SyncInfo from an Matrix.

Definition at line 39 of file sync_info_helpers.hpp.

Here is the caller graph for this function:

◆ get_sync_info() [2/2]

template<typename TensorDataType , El::Dist RowDist, El::Dist ColDist, El::Device D>

El::SyncInfo<D> lbann::get_sync_info ( El::DistMatrix< TensorDataType, RowDist, ColDist, El::ELEMENT, D > const & m )

noexcept

Get a SyncInfo from a DistMatrix.

This saves a dynamic_cast over the AbstractDistMatrix version.

Definition at line 52 of file sync_info_helpers.hpp.

◆ get_time()

double lbann::get_time ( )

inline

Return time in fractional seconds since an epoch.

Definition at line 37 of file utils/timer.hpp.

Here is the caller graph for this function:

◆ get_tokens() [1/2]

std::vector<int> lbann::get_tokens	(	std::string	str,
		const std::vector< char >	delims
	)

Tokenize a string into integers by an ordered sequence of delimiter characters.

Here is the caller graph for this function:

◆ get_tokens() [2/2]

std::vector<std::string> lbann::get_tokens ( const std::string str )

Tokenize a string into substrings by set of delimiter characters.

◆ get_trainer()

trainer& lbann::get_trainer ( )

Get a reference to the global trainer visible to this rank.

◆ get_uint8_t_image()

El::Matrix<uint8_t> lbann::get_uint8_t_image	(	const CPUMat &	image,
		const std::vector< size_t > &	dims
	)

Convert image from El::Matrix<DataType> to El::Matrix<uint8_t>

Parameters

image	The image to convert.
dims	The dimensions of the image.

Returns: El::Matrix<uint8_t> Returns image in El::Matrix<uint8_t> format

◆ get_window_size()

std::pair<unsigned short, unsigned short> lbann::get_window_size ( std::ostream & os )

noexcept

Gets the dimensions of the terminal, if available.

If the stream can be determined to be using the terminal for output, this will further try to determine the dimensions in characters of the the terminal window. The method for determining this is unspecified and likely to not be generally portable.

If the stream cannot be determined to be a terminal, or if its dimensions cannot be resolved, the returned size is {0,0}.

Note that the dimensions are returned as {num_rows, num_cols}.

◆ glob()

std::vector<std::string> lbann::glob ( const std::string & pattern )

inline

Wrapper around glob, which searches for paths matching pattern according to the shell. Note this does not do tilde expansion.

Definition at line 42 of file glob.hpp.

◆ global_argument_parser()

default_arg_parser_type& lbann::global_argument_parser ( )

Here is the caller graph for this function:

◆ handle_mpi_error()

void lbann::handle_mpi_error ( int ierr )

◆ hash_combine()

template<class T , class Hash = std::hash<T>>

std::size_t lbann::hash_combine	(	std::size_t	seed,
		const T &	val
	)

Combine two hash values.

A hash function is applied to an object and the resulting hash value is mixed with another hash value. See https://www.boost.org/doc/libs/1_55_0/doc/html/hash/reference.html#boost.hash_combine.

Parameters

seed	Hash value.
val	Input to hash function.

Template Parameters

Hash	Hash function for type `T`.

Definition at line 47 of file hash.hpp.

◆ im2col()

template<typename TensorDataType >

void lbann::im2col	(	const CPUMatDT< TensorDataType > &	im,
		CPUMatDT< TensorDataType > &	col,
		int	num_channels,
		int	im_num_dims,
		const int *	im_dims,
		const int *	im_pads,
		const int *	window_dims,
		const int *	window_strides
	)

Rearrange image blocks into matrix columns.

The 'col' matrix is generated from the 'im' tensor im by shifting a window across im. Each column of col is produced by positioning the window, extracting entries from im, and flattening.

Parameters

im	im tensor, represented as a column vector.
col	col matrix. Height should be equal to window size and width equal to number of window shifts. Data should be contiguous.
num_channels	Number of channels in im tensor.
im_num_dims	Number of dimensions in im tensor.
im_dims	im tensor dimensions.
im_pads	Zero pads for im tensor.
window_dims	Dimensions of window.
window_strides	Window shift strides.

◆ im2col_1x1()

template<typename TensorDataType >

void lbann::im2col_1x1	(	const TensorDataType *	input_buffer,
		TensorDataType *	output_buffer,
		int	num_channels,
		int	num_input_dims,
		const int *	input_dims
	)

Rearrange 1x1 image blocks into matrix columns.

This is an optimized implementation of im2col when the window has a size of one, there is no padding, and the window stride is one. im2col will automatically call this routine if it detects a 1x1 im2col.

◆ im2col_2d()

template<typename TensorDataType >

void lbann::im2col_2d	(	const TensorDataType *__restrict__	input_buffer,
		TensorDataType *__restrict__	output_buffer,
		int	input_dim_x,
		int	input_dim_y,
		int	input_pad_x,
		int	input_pad_y,
		int	num_channels,
		int	window_dim_x,
		int	window_dim_y,
		int	offset_stride_x,
		int	offset_stride_y
	)

Rearrange 2D image blocks into matrix columns.

This is an optimized implementation of im2col for 2D data. im2col will automatically call this routine if it detects 2D data.

◆ infer()

template<typename DataT , El::Dist CDist, El::Dist RDist, El::DistWrap DistView, El::Device Device>

El::Matrix<int, El::Device::CPU> lbann::infer	(	observer_ptr< model >	model,
		El::DistMatrix< DataT, CDist, RDist, DistView, Device > const &	samples,
		size_t	mbs
	)

Creates execution algorithm and infers on samples using a model.

Parameters

[in]	model	A trained model
[in]	samples	A distributed matrix containing samples for model input
[in]	mbs	The max mini-batch size

Returns: Matrix of predicted labels

Definition at line 64 of file lbann_library.hpp.

Here is the call graph for this function:

◆ init_data_readers()

void lbann::init_data_readers	(	lbann_comm *	comm,
		const ::lbann_data::LbannPB &	p,
		std::map< execution_mode, generic_data_reader *> &	data_readers
	)

instantiates one or more generic_data_readers and inserts them in &data_readers

◆ init_data_seq_random()

void lbann::init_data_seq_random ( int seed = -1 )

Initialize a random number generator (with optional seed) that is specifically used for sequencing the training / testing data samples. Using a separate RNG for the data sequences helps provide a stable training result that does not vary with how much I/O parallelism is applied.

Here is the caller graph for this function:

◆ init_image_data_reader()

void lbann::init_image_data_reader	(	const lbann_data::Reader &	pb_readme,
		const lbann_data::DataSetMetaData &	pb_metadata,
		const bool	master,
		generic_data_reader *&	reader
	)

◆ init_io_random()

void lbann::init_io_random	(	int	seed = `-1`,
		int	num_io_RNGs = `1`
	)

Initialize a random number generator (with optional seed) that is specifically used by the I/O threads for tasks such as data preprocessing, etc. Includes the number of I/O RNGs required.

Called from init_random

Here is the caller graph for this function:

◆ init_ltfb_random()

void lbann::init_ltfb_random ( int seed = -1 )

Initialize a random number generator (with optional seed) that is specifically used for LTFB tournament pairing. This has to be symmetric across all trainers.

Here is the caller graph for this function:

◆ init_org_image_data_reader()

void lbann::init_org_image_data_reader	(	const lbann_data::Reader &	pb_readme,
		const bool	master,
		generic_data_reader *&	reader
	)

◆ init_random()

void lbann::init_random	(	int	seed = `-1`,
		int	num_io_RNGs = `1`,
		lbann_comm *	comm = `nullptr`
	)

Initialize the random number generator (with optional seed).

Parameters

seed	Seed value for the random number generator
num_io_RNGs	The number of RNGs for I/O.
comm	If present, mixes the process's rank within the trainer into the seed; if not, uses the MPI world rank.

Here is the caller graph for this function:

◆ initialize()

world_comm_ptr lbann::initialize	(	int &	argc,
		char **&	argv
	)

Create LBANN communicator.

Initializes Elemental, which in turn initializes MPI, Aluminum, and CUDA. The LBANN communicator is initialized with one trainer (which can be changed by calling lbann_comm::split_trainers afterward).

Parameters

argc	Command line arguments.
argv	Number of command line arguments.

Returns: LBANN communicator corresponding to MPI_COMM_WORLD.

Here is the caller graph for this function:

◆ initialize_lbann() [1/3]

std::unique_ptr<lbann_comm> lbann::initialize_lbann	(	int	argc,
		char **	argv
	)

Initialize LBANN for use with external applcations.

Parameters

argc	Command line arguments.
argv	Number of command line arguments.

Returns: LBANN communicator

◆ initialize_lbann() [2/3]

std::unique_ptr<lbann_comm> lbann::initialize_lbann ( MPI_Comm c )

Initialize LBANN for use with external applcations.

Parameters

[in] c MPI communicator

Returns: LBANN communicator using provided MPI comm

◆ initialize_lbann() [3/3]

std::unique_ptr<lbann_comm> lbann::initialize_lbann ( El::mpi::Comm && c )

Initialize LBANN for use with external applcations.

Parameters

[in] c Hydrogen MPI communicator

Returns: LBANN communicator using provided Hydrogen comm

◆ invert() [1/2]

RowMajorPerm lbann::invert ( RowMajorPerm const & in )

inline

Definition at line 326 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invert() [2/2]

ColMajorPerm lbann::invert ( ColMajorPerm const & in )

inline

Definition at line 331 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ invert_perm_impl()

template<typename T >

auto lbann::invert_perm_impl ( std::vector< T > const & perm )

Returns the inverse of the given permutation.

Definition at line 276 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_execution_mode_hook()

bool lbann::is_execution_mode_hook ( visitor_hook hook )

◆ is_good_terminal()

bool lbann::is_good_terminal ( std::ostream & os )

noexcept

Roughly determines if the stream points to a nice terminal (is a terminal, supports color).

◆ is_hdf5_field_channels_last()

bool lbann::is_hdf5_field_channels_last ( conduit::Node const & field )

◆ is_hdf5_metadata_key_valid()

bool lbann::is_hdf5_metadata_key_valid ( std::string const & key )

◆ is_same_type()

template<typename TN >

bool lbann::is_same_type ( const conduit::DataType::TypeID dt )

inline

Check if type identified by the conduit dtype id is the same type as the type given as the template parameter

Definition at line 528 of file data_reader_jag_conduit.hpp.

◆ is_valid() [1/2]

bool lbann::is_valid ( RowMajorPerm const & perm )

inline

Definition at line 316 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_valid() [2/2]

bool lbann::is_valid ( ColMajorPerm const & perm )

inline

Definition at line 321 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ IsCloneable_v()

template<typename T >

constexpr bool lbann::IsCloneable_v ( )

Definition at line 248 of file cloneable.hpp.

◆ IsCloneablePtr_v()

template<typename T >

constexpr bool lbann::IsCloneablePtr_v ( )

Definition at line 278 of file cloneable.hpp.

◆ lbann_comm::broadcast< std::string >()

template<>

void lbann::lbann_comm::broadcast< std::string >	(	int	root,
		std::string &	str,
		const El::mpi::Comm &	c
	)		const

Broadcast std::string over an arbitrary communicator.

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [1/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	AddConstant	,
		"add constant"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [2/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	Scale	,
		"scale"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [3/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	SubtractConstant	,
		"subtract constant"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [4/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	ConstantSubtract	,
		"subtract from constant"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [5/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	MaxConstant	,
		"max constant"	,
		true
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [6/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	MinConstant	,
		"min constant"	,
		true
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [7/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	EqualConstant	,
		"equals constant"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [8/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	NotEqualConstant	,
		"not equals constant"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [9/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	LessEqualConstant	,
		"less-equals constant"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [10/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	LessConstant	,
		"less than constant"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [11/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	GreaterEqualConstant	,
		"greater-equals constant"	,
		false
	)

◆ LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR() [12/12]

lbann::LBANN_DECLARE_BINARY_WITH_CONSTANT_OPERATOR	(	GreaterConstant	,
		"greater than constant"	,
		false
	)

◆ LBANN_DECLARE_OPERATOR_BUILDER() [1/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( log_sigmoid )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [2/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( selu )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [3/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( sigmoid )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [4/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( softplus )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [5/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( softsign )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [6/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( binary_cross_entropy )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [7/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( boolean_accuracy )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [8/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( boolean_false_negative )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [9/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( acos )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [10/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( boolean_false_positive )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [11/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( acosh )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [12/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( sigmoid_binary_cross_entropy )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [13/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( add )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [14/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( add_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [15/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( asin )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [16/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( asinh )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [17/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( atan )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [18/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( atanh )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [19/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( ceil )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [20/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( clamp )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [21/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( constant_subtract )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [22/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( cos )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [23/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( cosh )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [24/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( divide )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [25/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( equal )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [26/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( equal_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [27/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( erf )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [28/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( erfinv )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [29/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( exp )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [30/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( expm1 )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [31/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( floor )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [32/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( gelu )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [33/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( greater )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [34/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( greater_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [35/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( greater_equal )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [36/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( greater_equal_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [37/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( less )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [38/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( less_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [39/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( less_equal )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [40/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( less_equal_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [41/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( log )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [42/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( log1p )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [43/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( logical_and )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [44/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( logical_not )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [45/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( logical_or )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [46/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( logical_xor )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [47/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( max )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [48/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( max_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [49/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( min )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [50/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( min_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [51/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( mod )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [52/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( multiply )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [53/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( negative )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [54/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( not_equal )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [55/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( not_equal_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [56/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( pow )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [57/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( reciprocal )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [58/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( round )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [59/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( rsqrt )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [60/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( safe_divide )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [61/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( safe_reciprocal )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [62/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( scale )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [63/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( select )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [64/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( sign )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [65/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( sin )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [66/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( sinh )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [67/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( sqrt )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [68/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( square )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [69/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( squared_difference )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [70/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( subtract )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [71/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( subtract_constant )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [72/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( tan )

◆ LBANN_DECLARE_OPERATOR_BUILDER() [73/73]

lbann::LBANN_DECLARE_OPERATOR_BUILDER ( tanh )

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [1/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	BinaryCrossEntropy	,
		"binary cross entropy"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [2/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Add	,
		"add"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [3/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Subtract	,
		"subtract"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [4/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	LogicalNot	,
		"logical not"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [5/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Multiply	,
		"multiply"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [6/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	SigmoidBinaryCrossEntropy	,
		"sigmoid binary cross entropy"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [7/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Divide	,
		"divide"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [8/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Mod	,
		"modulo"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [9/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Negative	,
		"negative"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [10/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	LogSigmoid	,
		"log sigmoid"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [11/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Pow	,
		"power"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [12/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Sign	,
		"sign"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [13/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	SafeDivide	,
		"safe divide"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [14/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	SquaredDifference	,
		"squared difference"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [15/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	BooleanAccuracy	,
		"Boolean accuracy"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [16/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Round	,
		"round"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [17/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Ceil	,
		"ceil"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [18/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Floor	,
		"floor"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [19/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	BooleanFalseNegative	,
		"Boolean false negative rate"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [20/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Max	,
		"maximum"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [21/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Min	,
		"minimum"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [22/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Reciprocal	,
		"reciprocal"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [23/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	BooleanFalsePositive	,
		"Boolean false positive rate"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [24/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Equal	,
		"equal"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [25/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Square	,
		"square"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [26/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	NotEqual	,
		"not equal"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [27/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Sqrt	,
		"square root"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [28/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Less	,
		"less than"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [29/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Rsqrt	,
		"reciprocal square root"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [30/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	LessEqual	,
		"less than or equal"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [31/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	SafeReciprocal	,
		"safe reciprocal"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [32/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Greater	,
		"greater than"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [33/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	GreaterEqual	,
		"greater than or equal"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [34/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Selu	,
		"SELU"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [35/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Exp	,
		"exponential"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [36/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Expm1	,
		"expm1"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [37/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	LogicalAnd	,
		"logical and"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [38/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	LogicalOr	,
		"logical or"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [39/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Log	,
		"natural logarithm"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [40/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Log1p	,
		"log1p"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [41/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	LogicalXor	,
		"logical xor"	,
		false
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [42/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Cos	,
		"cosine"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [43/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Sin	,
		"sine"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [44/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Sigmoid	,
		"sigmoid"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [45/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Tan	,
		"tangent"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [46/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Acos	,
		"arccosine"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [47/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Asin	,
		"arcsine"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [48/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Atan	,
		"arctangent"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [49/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Cosh	,
		"hyperbolic cosine"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [50/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Sinh	,
		"hyperbolic sine"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [51/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Tanh	,
		"hyperbolic tangent"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [52/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Acosh	,
		"hyperbolic arccosine"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [53/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Softplus	,
		"softplus"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [54/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Asinh	,
		"hyperbolic arcsine"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [55/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Atanh	,
		"hyperbolic arctangent"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [56/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Erf	,
		"error function"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [57/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	ErfInv	,
		"inverse error function"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [58/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Softsign	,
		"softsign"	,
		true
	)

◆ LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR() [59/59]

lbann::LBANN_DECLARE_STATELESS_ELEMENTWISE_OPERATOR	(	Gelu	,
		"gaussian error linear unit"	,
		true
	)

◆ LBANN_DEFINE_LAYER_BUILDER() [1/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( matmul )

◆ LBANN_DEFINE_LAYER_BUILDER() [2/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( bilinear_resize )

◆ LBANN_DEFINE_LAYER_BUILDER() [3/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( categorical_accuracy )

◆ LBANN_DEFINE_LAYER_BUILDER() [4/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( argmax )

◆ LBANN_DEFINE_LAYER_BUILDER() [5/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( batchwise_reduce_sum )

◆ LBANN_DEFINE_LAYER_BUILDER() [6/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( elu )

Here is the caller graph for this function:

◆ LBANN_DEFINE_LAYER_BUILDER() [7/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( composite_image_transformation )

◆ LBANN_DEFINE_LAYER_BUILDER() [8/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( cross_entropy )

◆ LBANN_DEFINE_LAYER_BUILDER() [9/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( argmin )

◆ LBANN_DEFINE_LAYER_BUILDER() [10/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( identity )

◆ LBANN_DEFINE_LAYER_BUILDER() [11/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( bernoulli )

◆ LBANN_DEFINE_LAYER_BUILDER() [12/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( leaky_relu )

◆ LBANN_DEFINE_LAYER_BUILDER() [13/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( rotation )

◆ LBANN_DEFINE_LAYER_BUILDER() [14/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( channelwise_mean )

◆ LBANN_DEFINE_LAYER_BUILDER() [15/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( l1_norm )

◆ LBANN_DEFINE_LAYER_BUILDER() [16/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( categorical_random )

◆ LBANN_DEFINE_LAYER_BUILDER() [17/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( log_softmax )

◆ LBANN_DEFINE_LAYER_BUILDER() [18/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( channelwise_softmax )

◆ LBANN_DEFINE_LAYER_BUILDER() [19/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( l2_norm2 )

◆ LBANN_DEFINE_LAYER_BUILDER() [20/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( concatenate )

◆ LBANN_DEFINE_LAYER_BUILDER() [21/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( cutout )

◆ LBANN_DEFINE_LAYER_BUILDER() [22/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( mean_absolute_error )

◆ LBANN_DEFINE_LAYER_BUILDER() [23/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( covariance )

◆ LBANN_DEFINE_LAYER_BUILDER() [24/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( constant )

◆ LBANN_DEFINE_LAYER_BUILDER() [25/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( relu )

◆ LBANN_DEFINE_LAYER_BUILDER() [26/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( softmax )

◆ LBANN_DEFINE_LAYER_BUILDER() [27/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( mean_squared_error )

◆ LBANN_DEFINE_LAYER_BUILDER() [28/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( dft_abs )

◆ LBANN_DEFINE_LAYER_BUILDER() [29/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( crop )

◆ LBANN_DEFINE_LAYER_BUILDER() [30/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( dist_embedding )

◆ LBANN_DEFINE_LAYER_BUILDER() [31/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( top_k_categorical_accuracy )

◆ LBANN_DEFINE_LAYER_BUILDER() [32/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( cross_grid_sum )

◆ LBANN_DEFINE_LAYER_BUILDER() [33/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( external )

◆ LBANN_DEFINE_LAYER_BUILDER() [34/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( cross_grid_sum_slice )

◆ LBANN_DEFINE_LAYER_BUILDER() [35/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( mini_batch_index )

◆ LBANN_DEFINE_LAYER_BUILDER() [36/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( discrete_random )

◆ LBANN_DEFINE_LAYER_BUILDER() [37/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( mini_batch_size )

◆ LBANN_DEFINE_LAYER_BUILDER() [38/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( dummy )

◆ LBANN_DEFINE_LAYER_BUILDER() [39/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( one_hot )

◆ LBANN_DEFINE_LAYER_BUILDER() [40/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( evaluation )

◆ LBANN_DEFINE_LAYER_BUILDER() [41/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( rowwise_weights_norms )

◆ LBANN_DEFINE_LAYER_BUILDER() [42/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( gather )

◆ LBANN_DEFINE_LAYER_BUILDER() [43/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( uniform_hash )

◆ LBANN_DEFINE_LAYER_BUILDER() [44/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( gaussian )

◆ LBANN_DEFINE_LAYER_BUILDER() [45/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( variance )

◆ LBANN_DEFINE_LAYER_BUILDER() [46/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( hadamard )

◆ LBANN_DEFINE_LAYER_BUILDER() [47/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( identity_zero )

◆ LBANN_DEFINE_LAYER_BUILDER() [48/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( in_top_k )

◆ LBANN_DEFINE_LAYER_BUILDER() [49/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( permute )

◆ LBANN_DEFINE_LAYER_BUILDER() [50/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( pooling )

◆ LBANN_DEFINE_LAYER_BUILDER() [51/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( reduction )

◆ LBANN_DEFINE_LAYER_BUILDER() [52/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( scatter )

◆ LBANN_DEFINE_LAYER_BUILDER() [53/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( slice )

◆ LBANN_DEFINE_LAYER_BUILDER() [54/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( sort )

◆ LBANN_DEFINE_LAYER_BUILDER() [55/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( split )

◆ LBANN_DEFINE_LAYER_BUILDER() [56/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( stop_gradient )

◆ LBANN_DEFINE_LAYER_BUILDER() [57/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( sum )

◆ LBANN_DEFINE_LAYER_BUILDER() [58/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( tessellate )

◆ LBANN_DEFINE_LAYER_BUILDER() [59/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( uniform )

◆ LBANN_DEFINE_LAYER_BUILDER() [60/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( unpooling )

◆ LBANN_DEFINE_LAYER_BUILDER() [61/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( weighted_sum )

◆ LBANN_DEFINE_LAYER_BUILDER() [62/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( weights )

◆ LBANN_DEFINE_LAYER_BUILDER() [63/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( instance_norm )

◆ LBANN_DEFINE_LAYER_BUILDER() [64/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( selu_dropout )

◆ LBANN_DEFINE_LAYER_BUILDER() [65/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( deconvolution )

◆ LBANN_DEFINE_LAYER_BUILDER() [66/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( convolution )

◆ LBANN_DEFINE_LAYER_BUILDER() [67/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( fully_connected )

◆ LBANN_DEFINE_LAYER_BUILDER() [68/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( channelwise_fully_connected )

◆ LBANN_DEFINE_LAYER_BUILDER() [69/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( entrywise_scale_bias )

◆ LBANN_DEFINE_LAYER_BUILDER() [70/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( channelwise_scale_bias )

◆ LBANN_DEFINE_LAYER_BUILDER() [71/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( input )

◆ LBANN_DEFINE_LAYER_BUILDER() [72/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( entrywise_batch_normalization )

◆ LBANN_DEFINE_LAYER_BUILDER() [73/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( gru )

◆ LBANN_DEFINE_LAYER_BUILDER() [74/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( dropout )

◆ LBANN_DEFINE_LAYER_BUILDER() [75/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( embedding )

◆ LBANN_DEFINE_LAYER_BUILDER() [76/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( layer_norm )

◆ LBANN_DEFINE_LAYER_BUILDER() [77/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( batch_normalization )

◆ LBANN_DEFINE_LAYER_BUILDER() [78/78]

lbann::LBANN_DEFINE_LAYER_BUILDER ( local_response_normalization )

◆ lbann_mpi_err_handler()

void lbann::lbann_mpi_err_handler	(	MPI_Comm *	comm,
		int *	err_code,
			...
	)

◆ load_external_library()

external_layer_setup_t lbann::load_external_library	(	const std::string &	filename,
		const std::string &	layer_name
	)

Create layer from an external library.

Expects any number of input tensors. Invokes a shared object (e.g., .so file) to call the layer.

◆ load_file()

bool lbann::load_file	(	const std::string	filename,
		std::vector< char > &	buf,
		bool	append = `false`
	)

Here is the caller graph for this function:

◆ load_from_shared_cereal_archive() [1/4]

template<typename C >

void lbann::load_from_shared_cereal_archive	(	C &	obj,
		lbann_comm &	comm,
		const std::string &	filename
	)

Definition at line 198 of file persist_impl.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_from_shared_cereal_archive() [2/4]

template<typename C >

void lbann::load_from_shared_cereal_archive	(	C &	obj,
		persist &	p,
		lbann_comm &	comm,
		const std::string &	filename
	)

Definition at line 225 of file persist_impl.hpp.

Here is the call graph for this function:

◆ load_from_shared_cereal_archive() [3/4]

template<typename C >

void lbann::load_from_shared_cereal_archive	(	C &	obj,
		persist &	p,
		persist_type	pt,
		lbann_comm &	comm,
		const std::string &	suffix
	)

Definition at line 234 of file persist_impl.hpp.

Here is the call graph for this function:

◆ load_from_shared_cereal_archive() [4/4]

template<typename C >

void lbann::load_from_shared_cereal_archive	(	C &	obj,
		persist &	p,
		execution_mode	mode,
		lbann_comm &	comm,
		const std::string &	suffix
	)

Definition at line 244 of file persist_impl.hpp.

Here is the call graph for this function:

◆ load_image()

void lbann::load_image	(	const std::string &	filename,
		El::Matrix< uint8_t > &	dst,
		std::vector< size_t > &	dims
	)

Load an image from filename.

Parameters

filename	The path to the image to load.
dst	Image will be loaded into this matrix, in OpenCV format.
dims	Will contain the dimensions of the image as {channels, height, width}.

◆ load_inference_model()

std::unique_ptr<model> lbann::load_inference_model	(	lbann_comm *	lc,
		std::string	cp_dir,
		int	mbs,
		std::vector< int >	input_dims,
		std::vector< int >	output_dims
	)

Loads a trained model from checkpoint for inference only.

Parameters

[in]	lc	An LBANN Communicator
[in]	cp_dir	The model checkpoint directory
[in]	mbs	The max mini-batch size
[in]	input_dims	The dimension of the input tensor
[in]	output_dims	The dimension of the output tensor

Returns: Model loaded from checkpoint

◆ load_rng_from_checkpoint()

bool lbann::load_rng_from_checkpoint	(	persist &	p,
		const lbann_comm *	comm
	)

Here is the caller graph for this function:

◆ make() [1/4]

template<class ConcreteClass >

std::unique_ptr<ConcreteClass> lbann::make ( google::protobuf::Message const & msg )

Fallback implementation of general builder function template.

Concrete builder for TruncationSelectionExchange.

Concrete builder for RegularizedEvolution.

Concrete builder for RandomPairwiseExchange.

Template Parameters

ConcreteClass

Parameters

[in] msg The protobuf message describing the object.

Definition at line 62 of file make_abstract.hpp.

◆ make() [2/4]

template<>

std::unique_ptr<ltfb::RegularizedEvolution> lbann::make ( google::protobuf::Message const & msg )

Concrete builder for RegularizedEvolution.

Concrete builder for RandomPairwiseExchange.

Template Parameters

ConcreteClass

Parameters

[in] msg The protobuf message describing the object.

Definition at line 62 of file make_abstract.hpp.

◆ make() [3/4]

template<>

std::unique_ptr<ltfb::TruncationSelectionExchange> lbann::make ( google::protobuf::Message const & msg )

Concrete builder for TruncationSelectionExchange.

Concrete builder for RegularizedEvolution.

Concrete builder for RandomPairwiseExchange.

Template Parameters

ConcreteClass

Parameters

[in] msg The protobuf message describing the object.

Definition at line 62 of file make_abstract.hpp.

◆ make() [4/4]

template<>

std::unique_ptr<ltfb::RandomPairwiseExchange> lbann::make ( google::protobuf::Message const & msg )

Concrete builder for RandomPairwiseExchange.

Template Parameters

ConcreteClass

Parameters

[in] msg The protobuf message describing the object.

Definition at line 62 of file make_abstract.hpp.

◆ make< SGDTrainingAlgorithm >()

template<>

std::unique_ptr<SGDTrainingAlgorithm> lbann::make< SGDTrainingAlgorithm > ( google::protobuf::Message const & params )

◆ make_abstract()

template<class BaseClass >

std::unique_ptr<BaseClass> lbann::make_abstract ( google::protobuf::Message const & msg )

Fallback implementation of general factory function template.

Template Parameters

BaseClass

Parameters

[in] msg The protobuf message describing the object.

Definition at line 50 of file make_abstract.hpp.

◆ make_abstract< ltfb::MetaLearningStrategy >()

template<>

std::unique_ptr<ltfb::MetaLearningStrategy> lbann::make_abstract< ltfb::MetaLearningStrategy > ( const google::protobuf::Message & msg )

◆ make_handle()

static cutensorHandle_t lbann::make_handle ( )

static

Definition at line 92 of file cutensor_support.hpp.

Here is the caller graph for this function:

◆ makedir()

int lbann::makedir ( const char * dirname )

Todo:: Deprecated.

◆ modify_file_name()

std::string lbann::modify_file_name	(	const std::string	file_name,
		const std::string	tag,
		const std::string	new_ext = `""`
	)

Here is the caller graph for this function:

◆ num_free_cores_per_process()

int lbann::num_free_cores_per_process ( const lbann_comm * comm )

◆ openread()

int lbann::openread ( const char * filename )

Todo:: Deprecated.

◆ openwrite()

int lbann::openwrite ( const char * filename )

Todo:: Deprecated.

◆ operator<<() [1/3]

std::ostream& lbann::operator<<	(	std::ostream &	os,
		Describable const &	obj
	)

inline

Definition at line 45 of file describable.hpp.

Here is the call graph for this function:

◆ operator<<() [2/3]

std::ostream& lbann::operator<<	(	std::ostream &	os,
		const ParallelStrategy &	ps
	)

inline

Definition at line 191 of file layer.hpp.

◆ operator<<() [3/3]

template<typename CharT , typename RealType >

std::basic_ostream<CharT>& lbann::operator<<	(	std::basic_ostream< CharT > &	os,
		const beta_distribution< RealType > &	d
	)

Definition at line 228 of file beta.hpp.

Here is the call graph for this function:

◆ operator>>() [1/2]

std::istream& lbann::operator>>	(	std::istream &	os,
		visitor_hook &	e
	)

Extract an execution_mode from a stream.

◆ operator>>() [2/2]

template<typename CharT , typename RealType >

std::basic_istream<CharT>& lbann::operator>>	(	std::basic_istream< CharT > &	is,
		beta_distribution< RealType > &	d
	)

Definition at line 236 of file beta.hpp.

Here is the call graph for this function:

◆ pad()

template<typename T >

std::basic_string<T> lbann::pad	(	const std::basic_string< T > &	s,
		typename std::basic_string< T >::size_type	n,
		T	c
	)

Definition at line 93 of file file_utils.hpp.

◆ parse_list()

template<typename T = std::string>

std::vector<T> lbann::parse_list ( std::string const & str )

Parse a space-separated list.

Definition at line 159 of file proto_common.hpp.

Here is the call graph for this function:

◆ parse_path()

bool lbann::parse_path	(	const std::string &	path,
		std::string &	dir,
		std::string &	basename
	)

Todo:: Deprecated. Use lbann::file::extract_parent_directory and lbann::file::extract_base_name instead.

Here is the caller graph for this function:

◆ parse_set()

template<typename T = std::string>

std::set<T> lbann::parse_set ( std::string const & str )

Parse a space-separated set.

Definition at line 169 of file proto_common.hpp.

Here is the call graph for this function:

◆ peek_map() [1/4]

template<class KEY_T , class VAL_T , class CMP_T = std::less<KEY_T>>

VAL_T lbann::peek_map	(	const std::map< KEY_T, VAL_T, CMP_T > &	map_to_peek,
		KEY_T	idx,
		bool &	found
	)

A utility function to peek into a std::map without the side effect of adding the default value when a key is not found. It has the the template parameter list as std::map does except the allocator. Searches 'idx' in std::map 'map_to_peek', and returns the matching value if found or the default otherwise. 'found' is set to true when the key 'idx' is found, or false when not.

Definition at line 49 of file peek_map.hpp.

◆ peek_map() [2/4]

template<class KEY_T , class VAL_T , class CMP_T = std::less<KEY_T>>

VAL_T lbann::peek_map	(	const std::map< KEY_T, VAL_T, CMP_T > &	map_to_peek,
		KEY_T	idx
	)

Same as the other peek_map interface but does not require the third argument that indicates the success of searching.

Definition at line 71 of file peek_map.hpp.

◆ peek_map() [3/4]

template<class KEY_T , class VAL_T , class HASH_T = std::hash<KEY_T>, class KEYeq_T = std::equal_to<KEY_T>>

VAL_T lbann::peek_map	(	const std::unordered_map< KEY_T, VAL_T, HASH_T, KEYeq_T > &	map_to_peek,
		KEY_T	idx,
		bool &	found
	)

A utility function to peek into a std::unordered_map without the side effect of adding the default value when a key is not found. It has the the template parameter list as std::unordered_map does except the allocator. Searches 'idx' in std::unordered_map 'map_to_peek', and returns the matching value if found or the default otherwise. 'found' is set to true when the key 'idx' is found, or false when not.

Definition at line 94 of file peek_map.hpp.

◆ peek_map() [4/4]

template<class KEY_T , class VAL_T , class HASH_T = std::hash<KEY_T>, class KEYeq_T = std::equal_to<KEY_T>>

VAL_T lbann::peek_map	(	const std::unordered_map< KEY_T, VAL_T, HASH_T, KEYeq_T > &	map_to_peek,
		KEY_T	idx
	)

Same as the other peek_map interface but does not require the third argument that indicates the success of searching.

Definition at line 118 of file peek_map.hpp.

◆ permute_dims() [1/2]

template<typename IndexT >

auto lbann::permute_dims	(	RowMajorDims< IndexT > const &	in,
		RowMajorPerm const &	perm
	)

Definition at line 341 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ permute_dims() [2/2]

template<typename IndexT >

auto lbann::permute_dims	(	ColMajorDims< IndexT > const &	in,
		ColMajorPerm const &	perm
	)

Definition at line 347 of file tensor_dims_utils.hpp.

Here is the call graph for this function:

◆ permute_impl()

template<typename IndexT , typename PermT >

auto lbann::permute_impl	(	std::vector< IndexT > const &	in,
		std::vector< PermT > const &	perm
	)

Definition at line 294 of file tensor_dims_utils.hpp.

Here is the caller graph for this function:

◆ print_affinity()

void lbann::print_affinity	(	int	rank,
		int	np,
		char *	host
	)

◆ print_affinity_subset()

void lbann::print_affinity_subset	(	int	rank,
		int	np,
		char *	host
	)

◆ print_lbann_configuration()

void lbann::print_lbann_configuration	(	lbann_comm *	comm,
		int	io_threads_per_process,
		int	io_threads_offset
	)

Here is the caller graph for this function:

◆ print_local_matrix_dims()

void lbann::print_local_matrix_dims	(	AbsMat *	m,
		const char *	name
	)

Print the dimensions and name of a Elemental matrix.

◆ print_matrix_dims()

void lbann::print_matrix_dims	(	AbsDistMat *	m,
		const char *	name
	)

Print the dimensions and name of a Elemental matrix.

◆ print_parallel_strategy_header()

std::ostream& lbann::print_parallel_strategy_header ( std::ostream & os )

inline

Definition at line 207 of file layer.hpp.

◆ print_parameters()

void lbann::print_parameters	(	const lbann_comm &	comm,
		::lbann_data::LbannPB &	p,
		std::vector< int > &	root_random_seeds,
		std::vector< int > &	random_seeds,
		std::vector< int > &	data_seq_random_seeds
	)

print various params (learn_rate, etc) to cout

◆ prof_region_begin()

void lbann::prof_region_begin	(	const char *	s,
		int	c,
		bool	sync
	)

◆ prof_region_end()

void lbann::prof_region_end	(	const char *	s,
		bool	sync
	)

◆ prof_start()

void lbann::prof_start ( )

◆ prof_stop()

void lbann::prof_stop ( )

◆ PROTO() [1/2]

lbann::PROTO ( float )

◆ PROTO() [2/2]

lbann::PROTO ( double )

◆ random_uniform()

template<typename T , typename Generator >

T lbann::random_uniform ( Generator & g )

inline

Generate uniform random value in the range [0, 1).

Definition at line 131 of file random.hpp.

Here is the call graph for this function:

◆ read_bytes()

bool lbann::read_bytes	(	int	fd,
		const char *	name,
		void *	buf,
		size_t	size
	)

Here is the caller graph for this function:

◆ read_cereal_archive() [1/4]

template<typename C >

void lbann::read_cereal_archive	(	C &	obj,
		const std::string &	filename
	)

Definition at line 137 of file persist_impl.hpp.

Here is the caller graph for this function:

◆ read_cereal_archive() [2/4]

template<typename C >

void lbann::read_cereal_archive	(	C &	obj,
		persist &	p,
		const std::string &	filename
	)

Definition at line 152 of file persist_impl.hpp.

Here is the call graph for this function:

◆ read_cereal_archive() [3/4]

template<typename C >

void lbann::read_cereal_archive	(	C &	obj,
		persist &	p,
		persist_type	pt,
		const std::string &	suffix
	)

Definition at line 158 of file persist_impl.hpp.

Here is the call graph for this function:

◆ read_cereal_archive() [4/4]

template<typename C >

void lbann::read_cereal_archive	(	C &	obj,
		persist &	p,
		execution_mode	mode,
		const std::string &	suffix
	)

Definition at line 167 of file persist_impl.hpp.

Here is the call graph for this function:

◆ read_filelist()

void lbann::read_filelist	(	lbann_comm *	comm,
		const std::string &	fn,
		std::vector< std::string > &	filelist_out
	)

◆ read_prototext_file()

void lbann::read_prototext_file	(	const std::string &	fn,
		::lbann_data::LbannPB &	pb,
		const bool	master
	)

Read prototext from a file into a protobuf message.

◆ read_prototext_string()

void lbann::read_prototext_string	(	const std::string &	contents,
		lbann_data::LbannPB &	pb,
		const bool	master
	)

Read prototext from a string into a protobuf message.

◆ read_string()

bool lbann::read_string	(	int	fd,
		const char *	name,
		char *	buf,
		size_t	size
	)

Here is the caller graph for this function:

◆ register_new_training_algorithm()

void lbann::register_new_training_algorithm	(	TrainingAlgorithmKey	key,
		TrainingAlgorithmBuilder	builder
	)

Register a new training algorithm with the default factory.

Parameters

[in]	key	The identifier for the training algorithm.
[in]	builder	The builder for the training algorithm.

◆ rng_bernoulli()

template<typename DType = DataType>

void lbann::rng_bernoulli	(	const float	p,
		DistMat *	m
	)

Multiply entries of distributed matrix with a multiplier generated according to bernoulli_distribution

the scale for undropped inputs at training time given as $ 1 / (1 - p) $

Definition at line 242 of file random.hpp.

Here is the call graph for this function:

◆ RowMajor() [1/5]

template<typename IndexT >

auto lbann::RowMajor ( std::vector< IndexT > && ds )

Definition at line 158 of file tensor_dims_utils.hpp.

Here is the caller graph for this function:

◆ RowMajor() [2/5]

template<typename IndexT >

auto lbann::RowMajor ( std::vector< IndexT > const & ds )

Definition at line 164 of file tensor_dims_utils.hpp.

◆ RowMajor() [3/5]

template<typename IndexT >

auto lbann::RowMajor ( ColMajorDims< IndexT > const & dims )

Definition at line 170 of file tensor_dims_utils.hpp.

◆ RowMajor() [4/5]

template<typename IndexT >

auto lbann::RowMajor ( RowMajorDims< IndexT > const & dims )

Definition at line 176 of file tensor_dims_utils.hpp.

◆ RowMajor() [5/5]

template<typename IndexT >

auto lbann::RowMajor ( RowMajorDims< IndexT > && dims )

Definition at line 182 of file tensor_dims_utils.hpp.

◆ rowwise_mean_and_stdev() [1/2]

void lbann::rowwise_mean_and_stdev	(	const Mat &	data,
		Mat &	means,
		Mat &	stdevs
	)

Compute row-wise means and standard deviations.

Parameters

data	Input matrix.
means	Mean vector. Output as a column vector with same number of rows as 'data'.
stdevs	Standard deviation vector. Output as a column vector with same number of rows as 'data'.

◆ rowwise_mean_and_stdev() [2/2]

void lbann::rowwise_mean_and_stdev	(	const AbsDistMat &	data,
		AbsDistMat &	means,
		AbsDistMat &	stdevs
	)

Compute row-wise means and standard deviations.

Parameters

data	Input matrix in U,V format.
means	Mean vector in U,STAR format. Output as a column vector with same number of rows as 'data'.
stdevs	Standard deviation vector in U,STAR format. Output as a column vector with same number of rows as 'data'.

◆ rowwise_sums_and_sqsums()

void lbann::rowwise_sums_and_sqsums	(	const AbsDistMat &	data,
		AbsDistMat &	sums,
		AbsDistMat &	sqsums
	)

Compute row-wise sum and sum of squares.

Parameters

data	Input matrix in U,V format.
sums	Sum vector in U,STAR format. Output as a column vector with same number of rows as 'data'.
sqsums	Sum of squared in U,STAR format. Output as a column vector with same number of rows as 'data'.

◆ save_image() [1/2]

void lbann::save_image	(	const std::string &	filename,
		El::Matrix< uint8_t > &	src,
		const std::vector< size_t > &	dims
	)

Save an image to filename.

Parameters

filename	The path to the image to write.
src	The image to save. This is in OpenCV format.
dims	The dimensions of the image.

◆ save_image() [2/2]

void lbann::save_image	(	const std::string &	filename,
		const CPUMat &	src,
		const std::vector< size_t > &	dims
	)

Save an image to filename.

Parameters

filename	The path to the image to write.
src	The image to save. This is in standard LBANN format, and will be converted to a uint8_t matrix, interpolating between the min and max values in it.
dims	The dimensions of the image.

◆ save_rng_to_checkpoint_distributed()

bool lbann::save_rng_to_checkpoint_distributed	(	persist &	p,
		lbann_comm *	comm
	)

Here is the caller graph for this function:

◆ save_rng_to_checkpoint_shared()

bool lbann::save_rng_to_checkpoint_shared	(	persist &	p,
		lbann_comm *	comm
	)

Here is the caller graph for this function:

◆ save_session()

void lbann::save_session	(	const lbann_comm &	comm,
		const int	argc,
		char const	argv,
		::lbann_data::LbannPB &	p
	)

prints prototext file, cmd line, etc to file

◆ set_fan_in()

void lbann::set_fan_in	(	weights_initializer &	initializer,
		double	value
	)

◆ set_fan_out()

void lbann::set_fan_out	(	weights_initializer &	initializer,
		double	value
	)

◆ set_io_generators_local_index()

locked_io_rng_ref lbann::set_io_generators_local_index ( size_t idx )

Sets the local index for a thread to access the correct I/O RNGs.

Here is the caller graph for this function:

◆ set_minibatch_item()

template<typename T >

void lbann::set_minibatch_item	(	Mat &	M,
		const int	mb_idx,
		const T *const	ptr,
		const size_t	count
	)

inline

Definition at line 842 of file data_reader.hpp.

Here is the call graph for this function:

◆ set_num_parallel_readers()

void lbann::set_num_parallel_readers	(	const lbann_comm &	comm,
		::lbann_data::LbannPB &	p
	)

adjusts the number of parallel data readers

◆ slice_points_mode_from_string()

slice_points_mode lbann::slice_points_mode_from_string ( const std::string & m )

◆ splice_dims()

template<typename... ArgTs>

std::vector<size_t> lbann::splice_dims ( ArgTs &&... args )

Definition at line 142 of file dim_helpers.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ switch_perm_majorness()

void lbann::switch_perm_majorness	(	std::vector< int > const &	in,
		std::vector< int > &	out
	)

inline

Definition at line 124 of file tensor_dims_utils.hpp.

Here is the caller graph for this function:

◆ th_print_affinity()

void lbann::th_print_affinity	(	int	rank,
		int	np,
		char *	host
	)

◆ time_scope()

template<typename TimerT >

auto lbann::time_scope	(	TimerT &	timer,
		std::string const &	scope_name
	)

Definition at line 86 of file timer_map.hpp.

Here is the call graph for this function:

◆ to_pool_mode()

pooling_mode lbann::to_pool_mode ( std::string m )

inline

Definition at line 51 of file layers/transform/pooling.hpp.

◆ to_sample_name_t()

template<typename sample_name_t >

auto lbann::to_sample_name_t ( const std::string & sn_str ) -> decltype(sample_name_t())

inline

Definition at line 72 of file sample_list_impl.hpp.

◆ to_sample_name_t< double >()

template<>

double lbann::to_sample_name_t< double > ( const std::string & sn_str )

inline

Definition at line 118 of file sample_list_impl.hpp.

◆ to_sample_name_t< float >()

template<>

float lbann::to_sample_name_t< float > ( const std::string & sn_str )

inline

Definition at line 112 of file sample_list_impl.hpp.

◆ to_sample_name_t< int >()

template<>

int lbann::to_sample_name_t< int > ( const std::string & sn_str )

inline

Definition at line 81 of file sample_list_impl.hpp.

◆ to_sample_name_t< long >()

template<>

long lbann::to_sample_name_t< long > ( const std::string & sn_str )

inline

Definition at line 87 of file sample_list_impl.hpp.

◆ to_sample_name_t< long double >()

template<>

long double lbann::to_sample_name_t< long double > ( const std::string & sn_str )

inline

Definition at line 124 of file sample_list_impl.hpp.

◆ to_sample_name_t< long long >()

template<>

long long lbann::to_sample_name_t< long long > ( const std::string & sn_str )

inline

Definition at line 99 of file sample_list_impl.hpp.

◆ to_sample_name_t< std::string >()

template<>

std::string lbann::to_sample_name_t< std::string > ( const std::string & sn_str )

inline

Definition at line 130 of file sample_list_impl.hpp.

◆ to_sample_name_t< unsigned long >()

template<>

unsigned long lbann::to_sample_name_t< unsigned long > ( const std::string & sn_str )

inline

Definition at line 93 of file sample_list_impl.hpp.

◆ to_sample_name_t< unsigned long long >()

template<>

unsigned long long lbann::to_sample_name_t< unsigned long long > ( const std::string & sn_str )

inline

Definition at line 106 of file sample_list_impl.hpp.

◆ to_string() [1/11]

std::string lbann::to_string ( data_reader_target_mode m )

◆ to_string() [2/11]

std::string lbann::to_string ( persist_type pt )

inline

Definition at line 59 of file persist_impl.hpp.

◆ to_string() [3/11]

template<typename T >

std::string lbann::to_string ( const T val )

inline

Definition at line 60 of file sample_list_impl.hpp.

Here is the call graph for this function:

◆ to_string() [4/11]

std::string lbann::to_string ( visitor_hook hook )

◆ to_string() [5/11]

std::string lbann::to_string	(	visitor_hook	hook,
		execution_mode	mode
	)

◆ to_string() [6/11]

template<>

std::string lbann::to_string ( const std::string val )

inline

Definition at line 66 of file sample_list_impl.hpp.

Here is the caller graph for this function:

◆ to_string() [7/11]

std::string lbann::to_string ( optimizer_gradient_status status )

Human-readable string for status of gradient in optimizer.

◆ to_string() [8/11]

std::string lbann::to_string ( const slice_points_mode m )

◆ to_string() [9/11]

std::string lbann::to_string ( El::Device const & d )

Todo:: This should move to hydrogen

Here is the caller graph for this function:

◆ to_string() [10/11]

std::string lbann::to_string ( data_layout const & dl )

◆ to_string() [11/11]

std::string lbann::to_string ( execution_mode m )

◆ to_unique_ptr()

template<typename T >

std::unique_ptr<T> lbann::to_unique_ptr ( T * ptr )

Convert the raw pointer to a unique_ptr.

Definition at line 38 of file memory.hpp.

Here is the caller graph for this function:

◆ trim()

std::string lbann::trim ( std::string const & str )

Trim leading and trailing whitespace from a string.

Here is the caller graph for this function:

◆ truncate_to_width()

std::string lbann::truncate_to_width	(	std::string const &	str,
		size_t	max_len
	)

A simple utility to replace the tail end of a long string with an ellipsis.

◆ TypeName()

template<typename T >

std::string lbann::TypeName ( )

Definition at line 44 of file typename.hpp.

Here is the call graph for this function:

◆ uniform_fill()

template<typename TensorDataType >

void lbann::uniform_fill	(	El::AbstractDistMatrix< TensorDataType > &	mat,
		El::Int	m,
		El::Int	n,
		TensorDataType	center = `0.0`,
		TensorDataType	radius = `1.0`
	)

Make mat into an m x n matrix where each entry is independently uniformly sampled from a ball with the given center and radius. This makes the same guarantees as gaussian_fill.

Here is the caller graph for this function:

◆ uniform_fill_procdet()

template<typename TensorDataType >

void lbann::uniform_fill_procdet	(	El::AbstractDistMatrix< TensorDataType > &	mat,
		El::Int	m,
		El::Int	n,
		TensorDataType	center = `0.0`,
		TensorDataType	radius = `1.0`
	)

Make mat into an m x n matrix where each entry is independently uniformly sampled from a ball with the given center and radius. This makes the same guarantees as gaussian_fill_procdet.

Here is the caller graph for this function:

◆ uninitialized_file_handle()

template<typename T >

T lbann::uninitialized_file_handle ( )

inline

◆ uninitialized_file_handle< conduit::relay::io::IOHandle * >()

template<>

conduit::relay::io::IOHandle* lbann::uninitialized_file_handle< conduit::relay::io::IOHandle *> ( )

inline

Definition at line 128 of file sample_list_conduit_io_handle.hpp.

◆ uninitialized_file_handle< hid_t >()

template<>

hid_t lbann::uninitialized_file_handle< hid_t > ( )

inline

Definition at line 114 of file sample_list_hdf5.hpp.

Here is the caller graph for this function:

◆ uninitialized_file_handle< std::ifstream * >()

template<>

std::ifstream* lbann::uninitialized_file_handle< std::ifstream *> ( )

inline

Definition at line 132 of file sample_list_ifstream.hpp.

◆ uninitialized_sample_name() [1/2]

template<typename T >

T lbann::uninitialized_sample_name ( )

inline

Definition at line 937 of file sample_list_impl.hpp.

Here is the caller graph for this function:

◆ uninitialized_sample_name() [2/2]

template<typename sample_name_t >

sample_name_t lbann::uninitialized_sample_name ( )

inline

Definition at line 937 of file sample_list_impl.hpp.

Here is the caller graph for this function:

◆ uninitialized_sample_name< size_t >()

template<>

size_t lbann::uninitialized_sample_name< size_t > ( )

inline

Definition at line 925 of file sample_list_impl.hpp.

◆ uninitialized_sample_name< std::string >()

template<>

std::string lbann::uninitialized_sample_name< std::string > ( )

inline

Definition at line 931 of file sample_list_impl.hpp.

◆ unpack_cereal_archive_binary_string()

template<typename C >

void lbann::unpack_cereal_archive_binary_string	(	C &	obj,
		const std::string &	buf
	)

Definition at line 188 of file persist_impl.hpp.

Here is the caller graph for this function:

◆ vec_convert()

template<typename OutT , typename InT >

auto lbann::vec_convert ( std::vector< InT > const & in )

Copy the input vector to a new type.

The types must implicitly convert.

Definition at line 149 of file tensor_dims_utils.hpp.

◆ vector_cast()

template<typename To , typename From >

auto lbann::vector_cast ( std::vector< From > const & from )

Definition at line 103 of file dim_helpers.hpp.

Here is the call graph for this function:

◆ view_or_copy_tensor()

template<typename TDT >

void lbann::view_or_copy_tensor	(	const BaseDistMat &	src,
		El::AbstractDistMatrix< TDT > &	tgt,
		bool	locked_view = `true`
	)

If distributed tensors have the same distribution setup the target to use a view to the source tensor, otherwise copy the src to target.

Definition at line 154 of file tensor_impl.hpp.

Here is the call graph for this function:

◆ visitor_hook_from_string()

void lbann::visitor_hook_from_string	(	std::string const &	str,
		visitor_hook &	hook,
		execution_mode &	mode
	)

Convert a string to an execution_mode.

◆ write_bytes()

bool lbann::write_bytes	(	int	fd,
		const char *	name,
		const void *	buf,
		size_t	size
	)

Here is the caller graph for this function:

◆ write_cereal_archive() [1/4]

template<typename C >

void lbann::write_cereal_archive	(	C &	obj,
		const std::string &	filename
	)

Definition at line 97 of file persist_impl.hpp.

Here is the caller graph for this function:

◆ write_cereal_archive() [2/4]

template<typename C >

void lbann::write_cereal_archive	(	C &	obj,
		persist &	p,
		const std::string &	filename
	)

Definition at line 112 of file persist_impl.hpp.

Here is the call graph for this function:

◆ write_cereal_archive() [3/4]

template<typename C >

void lbann::write_cereal_archive	(	C &	obj,
		persist &	p,
		persist_type	pt,
		const std::string &	suffix
	)

Definition at line 118 of file persist_impl.hpp.

Here is the call graph for this function:

◆ write_cereal_archive() [4/4]

template<typename C >

void lbann::write_cereal_archive	(	C &	obj,
		persist &	p,
		execution_mode	mode,
		const std::string &	suffix
	)

Definition at line 127 of file persist_impl.hpp.

Here is the call graph for this function:

◆ write_prototext_file()

bool lbann::write_prototext_file	(	const std::string &	fn,
		::lbann_data::LbannPB &	pb
	)

Write a protobuf message into a prototext file.

◆ write_string()

bool lbann::write_string	(	int	fd,
		const char *	name,
		const char *	buf,
		size_t	size
	)

Here is the caller graph for this function:

Variable Documentation

◆ conduit_hdf5_exclusion

const std::string lbann::conduit_hdf5_exclusion = "CONDUIT_HDF5_EXCLUSION"

static

Definition at line 47 of file sample_list.hpp.

◆ conduit_hdf5_inclusion

const std::string lbann::conduit_hdf5_inclusion = "CONDUIT_HDF5_INCLUSION"

static

Definition at line 48 of file sample_list.hpp.

◆ CUDAScalarType

template<typename CppType >

constexpr auto lbann::CUDAScalarType = CUDATypeT<CUDAScalar<CppType>>::value

Definition at line 90 of file cutensor_support.hpp.

◆ CUDAType

template<typename CppType >

constexpr auto lbann::CUDAType = CUDATypeT<CppType>::value

Definition at line 84 of file cutensor_support.hpp.

◆ Device

template<typename OpT >

constexpr El::Device lbann::Device = OperatorTraits<OpT>::device

Definition at line 62 of file OperatorTraits.hpp.

◆ hdf5_metadata_valid_keys

std::set<std::string> const lbann::hdf5_metadata_valid_keys

static

Initial value:

= {
  HDF5_METADATA_KEY_DIMS,
  HDF5_METADATA_KEY_CHANNELS,
  HDF5_METADATA_KEY_ORDERING,
  HDF5_METADATA_KEY_SCALE,
  HDF5_METADATA_KEY_BIAS,
  HDF5_METADATA_KEY_LAYOUT,
  HDF5_METADATA_KEY_TRANSPOSE,
  HDF5_METADATA_KEY_COERCE,
  HDF5_METADATA_KEY_PACK,
}

Definition at line 71 of file data_reader_HDF5.hpp.

◆ IsCloneable

template<typename T >

constexpr bool lbann::IsCloneable = IsCloneable_v<T>()

inline

Definition at line 254 of file cloneable.hpp.

◆ IsCloneablePtr

template<typename T >

constexpr bool lbann::IsCloneablePtr = IsCloneablePtr_v<T>()

inline

Definition at line 284 of file cloneable.hpp.

◆ lbann_default_random_seed

const int lbann::lbann_default_random_seed = 42

Definition at line 36 of file lbann_library.hpp.

◆ multi_sample_exclusion

const std::string lbann::multi_sample_exclusion = "MULTI-SAMPLE_EXCLUSION"

static

Definition at line 42 of file sample_list.hpp.

◆ multi_sample_inclusion

const std::string lbann::multi_sample_inclusion = "MULTI-SAMPLE_INCLUSION"

static

Definition at line 43 of file sample_list.hpp.

◆ multi_sample_inclusion_v2

const std::string lbann::multi_sample_inclusion_v2

static

Initial value:

=

"MULTI-SAMPLE_INCLUSION_V2"

Definition at line 45 of file sample_list.hpp.

◆ num_prof_colors

constexpr int lbann::num_prof_colors = 20

Definition at line 72 of file profiling.hpp.

◆ prof_colors

constexpr int lbann::prof_colors[num_prof_colors]

Initial value:

= {
  0x3366CC, 0xDC3912, 0xFF9900, 0x109618, 0x990099, 0x3B3EAC, 0x0099C6,
  0xDD4477, 0x66AA00, 0xB82E2E, 0x316395, 0x994499, 0x22AA99, 0xAAAA11,
  0x6633CC, 0xE67300, 0x8B0707, 0x329262, 0x5574A6, 0x3B3EAC}

Definition at line 74 of file profiling.hpp.

◆ single_sample

const std::string lbann::single_sample = "SINGLE-SAMPLE"

static

Definition at line 44 of file sample_list.hpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ AbsDistMat

◆ AbsDistMatReadProxy

◆ AbsMat

◆ AbstractCloneableBase

◆ BaseDistMat

◆ BaseOperatorType

◆ BiggerOf

◆ BlockMat

◆ CircMat

◆ CircMatDT

◆ ColMajorDims

◆ ColMajorPerm

◆ ColMajorStrides

◆ CPUMat

◆ CPUMatDT

◆ CUDAScalar

◆ data_field_dim_map_type

◆ data_field_type

◆ data_reader_target_mode_iterator

◆ DataParallelMatrixType

◆ default_arg_parser_type

◆ Description

◆ DistMat

◆ DistMatDT

◆ DMat

◆ dropout_layer

◆ EGrid

◆ ElMat

◆ EvalType

◆ execution_mode_iterator

◆ external_layer_setup_t

◆ fast_rng_gen

◆ generate_builder_type

◆ generic_factory

◆ Grid

◆ InputConstTensorType

◆ InputDataParallelMatType

◆ InputModelParallelMatType

◆ InputTensorType

◆ InputValueType

◆ lbann_exception

◆ Mat

◆ MCMRMat

◆ MCMRMatDT

◆ MCStarMat

◆ MCStarMatDT

◆ ModelParallelMatrixType

◆ MRStarMat

◆ MRStarMatDT

◆ NonLeafClass

◆ observer_ptr

◆ OutputConstTensorType

◆ OutputDataParallelMatType

◆ OutputModelParallelMatType

◆ OutputTensorType

◆ OutputValueType

◆ OwningLayerPtr

◆ OwningWeightsPtr

◆ persist_type_iterator

◆ rng_gen

◆ RowMajorDims

◆ RowMajorPerm

◆ RowMajorStrides

◆ slice_points_mode_iterator

◆ SPModeSlicePoints

◆ StarMat

◆ StarMatDT

◆ StarMRMat

◆ StarMRMatDT

◆ StarVCMat

◆ StarVCMatDT

◆ supported_layer_data_type