Namespaces
	ceras_private

	dataset

Classes
struct	complex

struct	is_complex

struct	is_complex< complex< Real_Ex, Imag_Ex > >

struct	constant
	Creates a constant expression from a tensor-like object. More...

struct	is_constant

struct	is_constant< constant< Tsor > >

struct	compiled_model

struct	model

struct	unary_operator

struct	binary_operator

struct	is_unary_operator

struct	is_unary_operator< unary_operator< Operator, Forward_Action, Backward_Action > >

struct	is_binary_operator

struct	is_binary_operator< binary_operator< Lhs_Operator, Rhs_Operator, Forward_Action, Backward_Action > >

struct	sgd

struct	adagrad

struct	rmsprop

struct	adadelta

struct	adam

struct	gradient_descent

struct	place_holder_state

struct	place_holder

struct	is_place_holder

struct	is_place_holder< place_holder< Tsor > >

struct	tensor

struct	is_tensor

struct	is_tensor< tensor< T, A > >

struct	view_1d

struct	view_2d

struct	view_3d

struct	view_4d

struct	view
	N-Dimentional view of 1D memory. More...

struct	view< T, 1 >

struct	view< T, 2 >

struct	view< T, 3 >

struct	view< T, 4 >

struct	value

struct	is_value

struct	is_value< value< T > >

struct	tensor_deduction

struct	variable_state

struct	regularizer

struct	variable

struct	is_variable

struct	is_variable< variable< Tsor > >

Typedefs
template<typename Loss , typename T >
using	ada_grad = adagrad< Loss, T >

template<typename Loss , typename T >
using	rms_prop = rmsprop< Loss, T >

template<typename Loss , typename T >
using	ada_delta = adadelta< Loss, T >

template<typename T >
using	default_allocator = std::allocator< T >

template<typename T >
using	array = view_1d< T >

template<typename T >
using	matrix = view_2d< T >

template<typename T >
using	cube = view_3d< T >

template<typename T >
using	tesseract = view_4d< T >

Functions
template<Expression Ex>
constexpr auto	softmax (Ex const &ex) noexcept
	Softmax activation function, an unary operator. More...

template<Expression Ex>
auto	selu (Ex const &ex) noexcept
	Scaled Exponential Linear Unit (SELU) activation function, an unary operator. If `x>0`, returns 1.0507 x; Otherwise, returns 1.673261.0507(exp(x)-1) More...

template<Expression Ex>
auto	softplus (Ex const &ex) noexcept
	Softplus function, an unary operator. Returns `log(exp(x)+1)`. More...

template<Expression Ex>
auto	softsign (Ex const &ex) noexcept
	Softsign function, an unary operator. Returns `x / (abs(x) + 1)`. More...

template<Expression Ex>
auto	sigmoid (Ex const &ex) noexcept
	Sigmoid function, an unary operator. Returns `1 / (exp(-x) + 1)`. More...

template<Expression Ex>
auto	relu (Ex const &ex) noexcept
	Relu function, an unary operator. Returns `x` if positive, `0` otherwise. More...

template<Expression Ex>
auto	relu6 (Ex const &ex) noexcept
	Rectified Linear 6 function, an unary operator. Returns `min(max(features, 0), 6)`. More...

template<typename T >
requires std::floating_point< T > auto	leaky_relu (T const factor=0.2) noexcept
	Leaky Rectified Linear function, an unary operator. Returns `x` if positive, `alpha x` otherwise. `alpha` defaults to 0.2. More...

template<Expression Ex>
auto	negative_relu (Ex const &ex) noexcept

template<typename T = float>
requires std::floating_point< T > auto	elu (T const alpha=1.0) noexcept
	Exponential Linear function, an unary operator. Returns `x` if positive, `alpha* (exp(x)-1)` otherwise. `alpha` defaults to 0.2. More...

template<Expression Ex>
auto	exponential (Ex const &ex) noexcept
	Exponential function, an unary operator. Returns `exp(x)`. More...

template<Expression Ex>
auto	hard_sigmoid (Ex const &ex) noexcept
	Hard Sigmoid function, an unary operator. Piecewise linear approximation of the sigmoid function. More...

template<Expression Ex>
auto	gelu (Ex const &ex) noexcept
	Gaussian Error function, an unary operator. GAUSSIAN ERROR LINEAR UNITS (GELUS) https://arxiv.org/pdf/1606.08415.pdf $f(x) = 0.5x (1 + tanh[\sqrt{2/\pi}(x + 0.044715x^3)])$ $df = x ( 1 + tanh[\sqrt{2/\pi}(x + 0.044715x^3)] ) + \sqrt(2/\pi) x sech^2[\sqrt(2/\pi) x (1+0.44715x^2) (1+0.134145x^2) ]$ where $sec^2(x) = 1 - tanh^2(x)$ derivative generated using service from https://www.symbolab.com/solver/derivative-calculator. More...

template<Expression Ex>
auto	swish (Ex const &ex) noexcept
	Swish activation function. More...

template<Expression Ex>
auto	silu (Ex const &ex) noexcept
	An alias name of activation swish. More...

template<Expression Ex>
auto	crelu (Ex const &ex) noexcept
	Concatenated Rectified Linear Units, an activation function which preserves both positive and negative phase information while enforcing non-saturated non-linearity. More...

template<Expression Ex>
auto	tank_shrink (Ex const &ex) noexcept
	Tank shrink function. More...

template<Expression Ex>
auto	mish (Ex const &ex) noexcept
	Mish function. More...

template<Expression Ex>
auto	lisht (Ex const &ex) noexcept
	Lisht function. More...

template<Expression Real_Ex, Expression Imag_Ex>
Real_Ex	real (complex< Real_Ex, Imag_Ex > const &c) noexcept

template<Expression Real_Ex, Expression Imag_Ex>
Imag_Ex	imag (complex< Real_Ex, Imag_Ex > const &c) noexcept

template<Complex C>
auto	abs (C const &c) noexcept
	Returns the magnitude of the complex expression. More...

template<Complex C>
auto	norm (C const &c) noexcept
	Returns the squared magnitude of the complex expression. More...

template<Complex C>
auto	conj (C const &c) noexcept
	Returns the conjugate of the complex expression. More...

template<Expression Em, Expression Ep>
auto	polar (Em const &em, Ep const &ep) noexcept
	Returns with given magnitude and phase angle. More...

template<Complex C>
auto	arg (C const &c) noexcept
	Calculates the phase angle (in radians) of the complex expression. More...

template<Complex C>
auto	operator+ (C const &c) noexcept
	Returns the complex expression. More...

template<Complex C>
auto	operator- (C const &c) noexcept
	Negatives the complex expression. More...

template<Complex Cl, Complex Cr>
auto	operator+ (Cl const &cl, Cr const &cr) noexcept
	Sums up two complex expressions. More...

template<Complex Cl, Complex Cr>
auto	operator- (Cl const &cl, Cr const &cr) noexcept
	Subtracts one complex expression from the other one. More...

template<Complex Cl, Complex Cr>
auto	operator* (Cl const &cl, Cr const &cr) noexcept
	Multiplies two complex expressions. Optimization here: (a+ib)(c+id) = (ac-bd) + i(ad+bc) = (ac-bd) + i( (a+b)(c+d)-ac-bd ) More...

template<Complex C, Expression E>
auto	operator+ (C const &c, E const &e) noexcept
	Sums up a complex expression and an expression. More...

template<Complex C, Expression E>
auto	operator+ (E const &e, C const &c) noexcept
	Sums up a complex expression and an expression. More...

template<Complex C, Expression E>
auto	operator- (C const &c, E const &e) noexcept
	Subtracts an expression from a compression expression. More...

template<Complex C, Expression E>
auto	operator- (E const &e, C const &c) noexcept
	Subtractsa complex expression from an expression. More...

template<Complex C, Expression E>
auto	operator* (C const &c, E const &e) noexcept
	Multiplies a complex expression with an expression. More...

template<Complex C, Expression E>
auto	operator* (E const &e, C const &c) noexcept
	Multiplies an expression with a compression expression. More...

auto	Input ()

auto	Conv2D (unsigned long output_channels, std::vector< unsigned long > const &kernel_size, std::vector< unsigned long > const &input_shape, std::string const &padding="valid", std::vector< unsigned long > const &strides={1, 1}, std::vector< unsigned long > const &dilations={1, 1}, bool use_bias=true, float kernel_regularizer_l1=0.0f, float kernel_regularizer_l2=0.0f, float bias_regularizer_l1=0.0f, float bias_regularizer_l2=0.0f)
	2D convolution layer. More...

auto	Dense (unsigned long output_size, unsigned long input_size, bool use_bias=true, float kernel_regularizer_l1=0.0f, float kernel_regularizer_l2=0.0f, float bias_regularizer_l1=0.0f, float bias_regularizer_l2=0.0f)
	Densly-connected layer. More...

auto	BatchNormalization (std::vector< unsigned long > const &shape, float threshold=0.95f, float kernel_regularizer_l1=0.0f, float kernel_regularizer_l2=0.0f, float bias_regularizer_l1=0.0f, float bias_regularizer_l2=0.0f)
	Applies a transformation that maintains the mean output close to 0 and the output standard deviation close to 1. More...

auto	BatchNormalization (float threshold, std::vector< unsigned long > const &shape, float kernel_regularizer_l1=0.0f, float kernel_regularizer_l2=0.0f, float bias_regularizer_l1=0.0f, float bias_regularizer_l2=0.0f)

auto	Concatenate (unsigned long axis=-1) noexcept

auto	Add () noexcept

auto	Subtract () noexcept

auto	Multiply () noexcept

template<Expression Ex>
auto	ReLU (Ex const &ex) noexcept

auto	Softmax () noexcept

template<typename T = float>
auto	LeakyReLU (T const factor=0.2) noexcept

template<typename T = float>
auto	ELU (T const factor=0.2) noexcept

auto	Reshape (std::vector< unsigned long > const &new_shape, bool include_batch_flag=true) noexcept

auto	Flatten () noexcept

auto	MaxPooling2D (unsigned long stride) noexcept

auto	UpSampling2D (unsigned long stride) noexcept

template<typename T >
auto	Dropout (T factor) noexcept

auto	AveragePooling2D (unsigned long stride) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	mean_squared_logarithmic_error (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	squared_loss (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	mean_squared_error (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	mse (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	abs_loss (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	mean_absolute_error (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	mae (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	cross_entropy (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	binary_cross_entropy_loss (Lhs_Expression const &ground_truth, Rhs_Expression const &prediction) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	cross_entropy_loss (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	hinge_loss (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Ex>
void	make_trainable (Ex &ex, bool t)

template<Expression Ex, Place_Holder Ph, Expression Ey>
auto	replace_placeholder_with_expression (Ex const &ex, Ph const &old_place_holder, Ey const &new_expression)

template<typename Model , typename Optimizer , typename Loss >
auto	make_compiled_model (Model const &m, Loss const &l, Optimizer const &o)

template<Expression Ex>
std::string	computation_graph (Ex const &ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	plus (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	operator+ (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Ex>
constexpr auto	operator+ (Ex const &ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
auto	operator* (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Ex>
constexpr auto	negative (Ex const &ex) noexcept

template<Expression Ex>
constexpr auto	operator- (Ex const &ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	elementwise_product (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	elementwise_multiply (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	hadamard_product (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Ex>
constexpr auto	sum_reduce (Ex const &ex) noexcept

template<Expression Ex>
constexpr auto	reduce_sum (Ex const &ex) noexcept

template<Expression Ex>
constexpr auto	mean_reduce (Ex const &ex) noexcept
	Computes the mean of elements across all dimensions of an expression. More...

template<Expression Ex>
constexpr auto	reduce_mean (Ex const &ex) noexcept
	An alias name of mean_reduce. More...

template<Expression Ex>
constexpr auto	mean (Ex const &ex) noexcept
	An alias name of mean_reduce. More...

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	minus (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Lhs_Expression, Expression Rhs_Expression>
constexpr auto	operator- (Lhs_Expression const &lhs_ex, Rhs_Expression const &rhs_ex) noexcept

template<Expression Ex>
constexpr auto	square (Ex const &ex) noexcept

template<Place_Holder Ph>
bool	operator== (Ph const &lhs, Ph const &rhs)

template<Place_Holder Ph>
bool	operator!= (Ph const &lhs, Ph const &rhs)

template<Place_Holder Ph>
bool	operator< (Ph const &lhs, Ph const &rhs)

template<Place_Holder Ph>
bool	operator> (Ph const &lhs, Ph const &rhs)

template<Place_Holder Ph>
bool	operator<= (Ph const &lhs, Ph const &rhs)

template<Place_Holder Ph>
bool	operator>= (Ph const &lhs, Ph const &rhs)

template<Tensor Tsor>
ceras_private::session< Tsor > &	get_default_session ()

template<typename T , typename A = default_allocator<T>>
constexpr tensor< T, A >	as_tensor (T val) noexcept

template<Tensor Tsor, typename CharT , typename Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os_, Tsor const &tsor)

template<typename T >
requires std::floating_point< T > void	gemm_cpu (T const A, bool a_transposed, T const B, bool b_transposed, unsigned long m, unsigned long n, unsigned long k, T *C)

void	update_cuda_gemm_threshold ()

template<typename T >
requires std::floating_point< T > void	gemm (T const A, bool a_transposed, T const B, bool b_transposed, unsigned long m, unsigned long n, unsigned long k, T *C)

template<typename T >
requires std::floating_point< T > void	gemm (view_2d< T > const &x, view_2d< T > const &y, view_2d< T > &ans)

template<Tensor Tsor>
Tsor	add (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator+ (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator+ (typename Tsor::value_type const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator+ (Tsor const &lhs, typename Tsor::value_type const &rhs) noexcept

template<Tensor Tsor>
Tsor	minus (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator- (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator- (typename Tsor::value_type const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator- (Tsor const &lhs, typename Tsor::value_type const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator* (typename Tsor::value_type const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator* (Tsor const &lhs, typename Tsor::value_type const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator/ (Tsor const &lhs, typename Tsor::value_type const &rhs) noexcept

template<Tensor Tsor>
Tsor	reshape (Tsor const &ts, std::vector< unsigned long > const &new_shape)

template<Tensor Tsor>
void	multiply (Tsor const &lhs, Tsor const &rhs, Tsor &ans) noexcept

template<Tensor Tsor>
Tsor	multiply (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	operator* (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	elementwise_product (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	hadamard_product (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	elementwise_divide (Tsor const &lhs, Tsor const &rhs) noexcept

template<Tensor Tsor>
Tsor	repeat (Tsor const &tsor, unsigned long n)

template<Tensor Tsor>
Tsor	reduce_sum (Tsor const &tsor)

template<Tensor Tsor>
Tsor	reduce_mean (Tsor const &tsor)

template<Tensor Tsor>
Tsor	clip (Tsor &tsor, typename Tsor::value_type lower=0, typename Tsor::value_type upper=1)

template<Tensor Tsor>
Tsor	squeeze (Tsor const &tsor)

template<typename T , typename A = default_allocator<T>>
tensor< T, A >	randn (std::vector< unsigned long > const &shape, T mean=T{0}, T stddev=T{1})

template<typename T , typename A = default_allocator<T>>
tensor< T, A >	truncated_normal (std::vector< unsigned long > const &shape, T mean=T{0}, T stddev=T{1}, T lower=T{0}, T upper=T{1})

template<typename T , typename A = default_allocator<T>>
tensor< T, A >	random (std::vector< unsigned long > const &shape, T min=T{0}, T max=T{1})

template<Tensor Tsor>
Tsor	random_like (Tsor const &tsor, typename Tsor::value_type min=0, typename Tsor::value_type max=1)

template<Tensor Tsor>
Tsor	randn_like (Tsor const &tsor, typename Tsor::value_type mean=0, typename Tsor::value_type stddev=1)

template<typename T , typename A = default_allocator<T>>
tensor< T, A >	glorot_uniform (std::initializer_list< unsigned long > shape)

template<Tensor Tsor>
Tsor	deep_copy (Tsor const &tsor)

template<Tensor Tsor>
Tsor	copy (Tsor const &tsor)

template<Tensor Tsor>
Tsor	concatenate (Tsor const &lhs, Tsor const &rhs, unsigned long axis=0) noexcept

template<Tensor Tsor>
Tsor	repmat (Tsor const &tsor, unsigned long row_rep, unsigned long col_rep)

template<Tensor Tsor>
constexpr bool	empty (Tsor const &tsor) noexcept

template<typename T , typename A = default_allocator<T>>
constexpr tensor< T, A >	zeros (std::vector< unsigned long > const &shape)

template<Tensor Tsor>
constexpr Tsor	zeros_like (Tsor const &tsor)

template<typename T , typename A = default_allocator<T>>
constexpr tensor< T, A >	ones (std::vector< unsigned long > const &shape)

template<Tensor Tsor>
constexpr Tsor	ones_like (Tsor const &tsor)

template<Tensor Tsor>
auto	max (Tsor const &tsor)

template<Tensor Tsor>
auto	amax (Tsor const &tsor)

template<Tensor Tsor>
auto	min (Tsor const &tsor)

template<Tensor Tsor>
auto	amin (Tsor const &tsor)

template<Tensor Tsor>
auto	sum (Tsor const &tsor)

template<Tensor Tsor>
auto	mean (Tsor const &tsor)

template<Tensor Tsor>
auto	norm (Tsor const &tsor)

template<Tensor Tsor>
Tsor	abs (Tsor const &tsor)

template<Tensor Tsor>
Tsor	softmax (Tsor const &tsor)

template<Tensor Tsor>
bool	has_nan (Tsor const &tsor)

template<Tensor Tsor>
bool	has_inf (Tsor const &tsor)

template<Tensor Tsor>
bool	is_valid (Tsor const &tsor)

template<Tensor Tsor, typename Function >
Tsor	reduce (Tsor const &ts, unsigned long axis, typename Tsor::value_type const &init, Function const &func, bool keepdims=false) noexcept

template<Tensor Tsor>
Tsor	sum (Tsor const &ts, unsigned long axis, bool keepdims=false) noexcept

template<Tensor Tsor>
requires std::floating_point< typename Tsor::value_type > Tsor	mean (Tsor const &ts, unsigned long axis, bool keepdims=false) noexcept

template<Tensor Tsor>
requires std::floating_point< typename Tsor::value_type > Tsor	variance (Tsor const &ts, unsigned long axis, bool keepdims=false) noexcept

template<Tensor Tsor>
requires std::floating_point< typename Tsor::value_type > Tsor	standard_deviation (Tsor const &ts, unsigned long axis, bool keepdims=false) noexcept

template<Tensor Tsor>
requires std::floating_point< typename Tsor::value_type > Tsor::value_type	var (Tsor const &ts) noexcept

template<Tensor Tsor>
requires std::floating_point< typename Tsor::value_type > Tsor::value_type	std (Tsor const &ts) noexcept

template<Tensor Tsor>
Tsor	max (Tsor const &ts, unsigned long axis, bool keepdims=false) noexcept

template<Tensor Tsor>
Tsor	min (Tsor const &ts, unsigned long axis, bool keepdims=false) noexcept

template<typename T , typename A = default_allocator<T>>
requires std::floating_point< T > tensor< T, A >	linspace (T start, T stop, unsigned long num, bool endpoint=true) noexcept

template<class _Tp , class _CharT , class _Traits , class _Alloc >
std::basic_istream< _CharT, _Traits > &	read_tensor (std::basic_istream< _CharT, _Traits > &__is, tensor< _Tp, _Alloc > &__x)

template<class _Tp , class _CharT , class _Traits , class _Alloc >
std::basic_ostream< _CharT, _Traits > &	write_tensor (std::basic_ostream< _CharT, _Traits > &__os, tensor< _Tp, _Alloc > const &__x)

template<typename T , typename A = default_allocator<T>>
tensor< T, A >	load_tensor (std::string const &file_name)

template<Tensor Tsor>
void	save_tensor (std::string const &file_name, Tsor const &tsor)

template<Variable Var>
bool	operator== (Var const &lhs, Var const &rhs) noexcept

Variables
template<typename T >
constexpr bool	is_complex_v = is_complex<T>::value

template<typename T >
concept	Complex = is_complex_v<T>
	A type that represents a complex expression. More...

template<class T >
constexpr bool	is_constant_v = is_constant<T>::value

template<typename T >
concept	Constant = is_constant_v<T>

auto	MeanSquaredError
	Computes the mean of squares of errors between labels and predictions. More...

auto	MSE
	An alias name of function MeanSquaredError. More...

auto	MeanAbsoluteError
	Computes the mean of absolute errors between labels and predictions. More...

auto	MAE
	An alias name of function MeanAbsoluteError. More...

auto	Hinge

auto	CategoricalCrossentropy

auto	CategoricalCrossEntropy

auto	BinaryCrossentropy

auto	BinaryCrossEntropy

static constexpr auto	make_unary_operator

static constexpr auto	make_binary_operator

template<class T >
constexpr bool	is_unary_operator_v = is_unary_operator<T>::value

template<typename T >
concept	Unary_Operator = is_unary_operator_v<T>
	A type that represents an unary operator. More...

template<class T >
constexpr bool	is_binary_operator_v = is_binary_operator<T>::value

template<typename T >
concept	Binary_Operator = is_binary_operator_v<T>
	A type that represents a binary operator. More...

template<typename T >
concept	Operator = Unary_Operator<T> \|\| Binary_Operator<T>
	A type that represents an unary or a binary operator. More...

template<typename T >
concept	Expression = Operator<T> \|\| Variable<T> \|\| Place_Holder<T> \|\| Constant<T> \|\| Value<T>
	A type that represents a unary operator, a binary operator, a variable, a place_holder, a constant or a value. More...

auto	Adam

auto	SGD

auto	Adagrad

auto	RMSprop

auto	Adadelta

template<class T >
constexpr bool	is_place_holder_v = is_place_holder<T>::value

template<typename T >
concept	Place_Holder = is_place_holder_v<T>

static unsigned long	random_seed = std::chrono::system_clock::now().time_since_epoch().count()

static std::mt19937	random_generator {random_seed}

template<class T >
constexpr bool	is_tensor_v = is_tensor<T>::value

template<typename T >
concept	Tensor = is_tensor_v<T>

template<class T >
constexpr bool	is_value_v = is_value<T>::value

template<typename T >
concept	Value = is_value_v<T>

template<class T >
constexpr bool	is_variable_v = is_variable<T>::value

template<typename T >
concept	Variable = is_variable_v<T>

Typedef Documentation

◆ ada_delta

template<typename Loss , typename T >

using ceras::ada_delta = typedef adadelta< Loss, T >

◆ ada_grad

template<typename Loss , typename T >

using ceras::ada_grad = typedef adagrad<Loss, T>

◆ array

template<typename T >

using ceras::array = typedef view_1d<T>

◆ cube

template<typename T >

using ceras::cube = typedef view_3d<T>

◆ default_allocator

template<typename T >

using ceras::default_allocator = typedef std::allocator<T>

◆ matrix

template<typename T >

using ceras::matrix = typedef view_2d<T>

◆ rms_prop

template<typename Loss , typename T >

using ceras::rms_prop = typedef rmsprop< Loss, T >

◆ tesseract

template<typename T >

using ceras::tesseract = typedef view_4d<T>

Function Documentation

◆ abs() [1/2]

template<Complex C>

auto ceras::abs ( C const & c )

noexcept

Returns the magnitude of the complex expression.

Parameters

c	Complex expression.

auto r = variable{ ... };
auto i = variable{ ... };
auto c = complex{ r, i };
auto a = abs( c );

◆ abs() [2/2]

template<Tensor Tsor>

Tsor ceras::abs ( Tsor const & tsor )

◆ abs_loss()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::abs_loss	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ Add()

auto ceras::Add ( )

inlinenoexcept

Layer that adds two layers

Example usage:

auto input = Input(); // (16, )
auto x1 = Dense( 8, 16 )( input );
auto x2 = Dense( 8, 16 )( input );
auto x3 = Add()( x1, x2 ); // equivalent to `x1 + x2`
auto m = model{ input, x3 };

◆ add()

template<Tensor Tsor>

Tsor ceras::add	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ amax()

template<Tensor Tsor>

auto ceras::amax ( Tsor const & tsor )

◆ amin()

template<Tensor Tsor>

auto ceras::amin ( Tsor const & tsor )

◆ arg()

template<Complex C>

auto ceras::arg ( C const & c )

noexcept

Calculates the phase angle (in radians) of the complex expression.

Parameters

c	Complex expression. Implemented as `atan2( imagec), real(c) )`.

auto r = variable{ ... };
auto i = variable{ ... };
auto c = complex{ r, i };
auto a = arg( c );

◆ as_tensor()

template<typename T , typename A = default_allocator<T>>

constexpr tensor<T, A> ceras::as_tensor ( T val )

constexprnoexcept

◆ AveragePooling2D()

auto ceras::AveragePooling2D ( unsigned long stride )

inlinenoexcept

Average pooling operation for spatial data.

◆ BatchNormalization() [1/2]

auto ceras::BatchNormalization	(	float	threshold,
		std::vector< unsigned long > const &	shape,
		float	kernel_regularizer_l1 = `0.0f`,
		float	kernel_regularizer_l2 = `0.0f`,
		float	bias_regularizer_l1 = `0.0f`,
		float	bias_regularizer_l2 = `0.0f`
	)

inline

◆ BatchNormalization() [2/2]

auto ceras::BatchNormalization	(	std::vector< unsigned long > const &	shape,
		float	threshold = `0.95f`,
		float	kernel_regularizer_l1 = `0.0f`,
		float	kernel_regularizer_l2 = `0.0f`,
		float	bias_regularizer_l1 = `0.0f`,
		float	bias_regularizer_l2 = `0.0f`
	)

inline

Applies a transformation that maintains the mean output close to 0 and the output standard deviation close to 1.

Parameters

shape	Dimensionality of the input shape.
threshold	Momentum for the moving average.
kernel_regularizer_l1	L1 regularizer for the kernel. Defaults to `0.0f`.
kernel_regularizer_l2	L2 regularizer for the kernel. Defaults to `0.0f`.
bias_regularizer_l1	L1 regularizer for the bias vector. Defaults to `0.0f`.
bias_regularizer_l2	L2 regularizer for the bias vector. Defaults to `0.0f`.

Example code:

auto a = variable{ random<float>( {12, 34, 56, 78} ) };

auto b = BatchNormalization( {34, 56, 78}, 0.8f )( a ); // note the leading dimension of `a` is intepretated as batch size, and only the rest 3 dimensions are required here.

ceras::BatchNormalization

auto BatchNormalization(std::vector< unsigned long > const &shape, float threshold=0.95f, float kernel_regularizer_l1=0.0f, float kernel_regularizer_l2=0.0f, float bias_regularizer_l1=0.0f, float bias_regularizer_l2=0.0f)

Applies a transformation that maintains the mean output close to 0 and the output standard deviation ...

Definition: layer.hpp:117

◆ binary_cross_entropy_loss()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::binary_cross_entropy_loss	(	Lhs_Expression const &	ground_truth,
		Rhs_Expression const &	prediction
	)

constexprnoexcept

◆ clip()

template<Tensor Tsor>

Tsor ceras::clip	(	Tsor &	tsor,
		typename Tsor::value_type	lower = `0`,
		typename Tsor::value_type	upper = `1`
	)

◆ computation_graph()

template<Expression Ex>

std::string ceras::computation_graph ( Ex const & ex )

inlinenoexcept

Generating the computation graph, in graph description language.

Parameters

ex	An expression.

Returns: A string describing the computation graph, in graph description language.

◆ concatenate()

template<Tensor Tsor>

Tsor ceras::concatenate	(	Tsor const &	lhs,
		Tsor const &	rhs,
		unsigned long	axis = `0`
	)

noexcept

◆ Concatenate()

auto ceras::Concatenate ( unsigned long axis = -1 )

inlinenoexcept

Layer that concatenates two layers.

Parameters

axis	The concatenation axis. Default to the last channel.

Example usage:

auto l1 = variable{ tensor<float>{ {12, 11, 3} } };
auto l2 = variable{ tensor<float>{ {12, 11, 4} } };
auto l12 = Concatenate()( l1, l2 ); // should be of shape (12, 11, 7)

◆ conj()

template<Complex C>

auto ceras::conj ( C const & c )

noexcept

Returns the conjugate of the complex expression.

Parameters

c	Complex expression.

auto r = variable{ ... };
auto i = variable{ ... };
auto c = complex{ r, i };
auto a = conj( c );

◆ Conv2D()

auto ceras::Conv2D	(	unsigned long	output_channels,
		std::vector< unsigned long > const &	kernel_size,
		std::vector< unsigned long > const &	input_shape,
		std::string const &	padding = `"valid"`,
		std::vector< unsigned long > const &	strides = `{1,1}`,
		std::vector< unsigned long > const &	dilations = `{1, 1}`,
		bool	use_bias = `true`,
		float	kernel_regularizer_l1 = `0.0f`,
		float	kernel_regularizer_l2 = `0.0f`,
		float	bias_regularizer_l1 = `0.0f`,
		float	bias_regularizer_l2 = `0.0f`
	)

inline

2D convolution layer.

Parameters

output_channels	Dimensionality of the output space.
kernel_size	The height and width of the convolutional window.
input_shape	Dimensionality of the input shape.
padding	`valid` or `same`. `valid` suggests no padding. `same` suggests zero padding. Defaults to `valid`.
strides	The strides along the height and width direction. Defaults to `(1, 1)`.
dilations	The dialation along the height and width direction. Defaults to `(1, 1)`.
use_bias	Wether or not use a bias vector. Defaults to `true`.
kernel_regularizer_l1	L1 regularizer for the kernel. Defaults to `0.0f`.
kernel_regularizer_l2	L2 regularizer for the kernel. Defaults to `0.0f`.
bias_regularizer_l1	L1 regularizer for the bias vector. Defaults to `0.0f`.
bias_regularizer_l2	L2 regularizer for the bias vector. Defaults to `0.0f`.

Example code:

auto x = Input{};
auto y = Conv2D( 32, {3, 3}, {28, 28, 1}, "same" )( x );
auto z = Flatten()( y );
auto u = Dense( 10, 28*28*32 )( z );
auto m = model{ x, u };

◆ copy()

template<Tensor Tsor>

Tsor ceras::copy ( Tsor const & tsor )

◆ crelu()

template<Expression Ex>

auto ceras::crelu ( Ex const & ex )

noexcept

Concatenated Rectified Linear Units, an activation function which preserves both positive and negative phase information while enforcing non-saturated non-linearity.

Reference: Shang, Wenling, Kihyuk Sohn, Diogo Almeida, and Honglak Lee. “Understanding and Improving Convolutional Neural Networks via Concatenated Rectified Linear Units.” ArXiv:1603.05201 [Cs], July 19, 2016. http://arxiv.org/abs/1603.05201.

auto v = variable{ random<float>{ 3, 3 } };

auto c = crelu( v );

ceras::crelu

auto crelu(Ex const &ex) noexcept

Concatenated Rectified Linear Units, an activation function which preserves both positive and negativ...

Definition: activation.hpp:565

◆ cross_entropy()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::cross_entropy	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ cross_entropy_loss()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::cross_entropy_loss	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ deep_copy()

template<Tensor Tsor>

Tsor ceras::deep_copy ( Tsor const & tsor )

◆ Dense()

auto ceras::Dense	(	unsigned long	output_size,
		unsigned long	input_size,
		bool	use_bias = `true`,
		float	kernel_regularizer_l1 = `0.0f`,
		float	kernel_regularizer_l2 = `0.0f`,
		float	bias_regularizer_l1 = `0.0f`,
		float	bias_regularizer_l2 = `0.0f`
	)

inline

Densly-connected layer.

Parameters

output_size	Dimensionality of output shape. The output shape is `(batch_size, output_size)`.
input_size	Dimensionality of input shape. The input shape is `(batch_size, input_size)`.
use_bias	Using a bias vector or not. Defaults to `true`.
kernel_regularizer_l1	L1 regularizer for the kernel. Defaults to `0.0f`.
kernel_regularizer_l2	L2 regularizer for the kernel. Defaults to `0.0f`.
bias_regularizer_l1	L1 regularizer for the bias vector. Defaults to `0.0f`.
bias_regularizer_l2	L2 regularizer for the bias vector. Defaults to `0.0f`.

Example code:

auto x = Input{};
auto y = Dense( 10, 28*28 )( x );
auto m = model{ x, y };

◆ Dropout()

template<typename T >

auto ceras::Dropout ( T factor )

inlinenoexcept

Applies Dropout to the input.

◆ elementwise_divide()

template<Tensor Tsor>

Tsor ceras::elementwise_divide	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ elementwise_multiply()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::elementwise_multiply	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ elementwise_product() [1/2]

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::elementwise_product	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ elementwise_product() [2/2]

template<Tensor Tsor>

Tsor ceras::elementwise_product	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ elu()

template<typename T = float>

requires std::floating_point<T> auto ceras::elu ( T const alpha = 1.0 )

noexcept

Exponential Linear function, an unary operator. Returns x if positive, alpha* (exp(x)-1) otherwise. alpha defaults to 0.2.

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = elu(0.1f)( y );

◆ ELU()

template<typename T = float>

auto ceras::ELU ( T const factor = 0.2 )

inlinenoexcept

Exponential Linear Unit.

◆ empty()

template<Tensor Tsor>

constexpr bool ceras::empty ( Tsor const & tsor )

constexprnoexcept

◆ exponential()

template<Expression Ex>

auto ceras::exponential ( Ex const & ex )

inlinenoexcept

Exponential function, an unary operator. Returns exp(x).

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = exponential( y );

◆ Flatten()

auto ceras::Flatten ( )

inlinenoexcept

Flattens the input. Does not affect the batch size.

◆ gelu()

template<Expression Ex>

auto ceras::gelu ( Ex const & ex )

inlinenoexcept

Gaussian Error function, an unary operator. GAUSSIAN ERROR LINEAR UNITS (GELUS) https://arxiv.org/pdf/1606.08415.pdf $f(x) = 0.5x (1 + tanh[\sqrt{2/\pi}(x + 0.044715x^3)])$ $df = x ( 1 + tanh[\sqrt{2/\pi}(x + 0.044715x^3)] ) + \sqrt(2/\pi) x sech^2[\sqrt(2/\pi) x (1+0.44715x^2) (1+0.134145x^2) ]$ where $sec^2(x) = 1 - tanh^2(x)$ derivative generated using service from https://www.symbolab.com/solver/derivative-calculator.

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = gelu( y );

◆ gemm() [1/2]

template<typename T >

requires std::floating_point<T> void ceras::gemm	(	T const *	A,
		bool	a_transposed,
		T const *	B,
		bool	b_transposed,
		unsigned long	m,
		unsigned long	n,
		unsigned long	k,
		T *	C
	)

◆ gemm() [2/2]

template<typename T >

requires std::floating_point<T> void ceras::gemm	(	view_2d< T > const &	x,
		view_2d< T > const &	y,
		view_2d< T > &	ans
	)

◆ gemm_cpu()

template<typename T >

requires std::floating_point<T> void ceras::gemm_cpu	(	T const *	A,
		bool	a_transposed,
		T const *	B,
		bool	b_transposed,
		unsigned long	m,
		unsigned long	n,
		unsigned long	k,
		T *	C
	)

◆ get_default_session()

template<Tensor Tsor>

ceras_private::session< Tsor > & ceras::get_default_session ( )

◆ glorot_uniform()

template<typename T , typename A = default_allocator<T>>

tensor<T,A> ceras::glorot_uniform ( std::initializer_list< unsigned long > shape )

◆ hadamard_product() [1/2]

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::hadamard_product	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ hadamard_product() [2/2]

template<Tensor Tsor>

Tsor ceras::hadamard_product	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ hard_sigmoid()

template<Expression Ex>

auto ceras::hard_sigmoid ( Ex const & ex )

inlinenoexcept

Hard Sigmoid function, an unary operator. Piecewise linear approximation of the sigmoid function.

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = hard_sigmoid( y );

◆ has_inf()

template<Tensor Tsor>

bool ceras::has_inf ( Tsor const & tsor )

◆ has_nan()

template<Tensor Tsor>

bool ceras::has_nan ( Tsor const & tsor )

◆ hinge_loss()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::hinge_loss	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ imag()

template<Expression Real_Ex, Expression Imag_Ex>

Imag_Ex ceras::imag ( complex< Real_Ex, Imag_Ex > const & c )

noexcept

@bref Returns the imaginary part of the complex expression.

Parameters

c	A complex expression.

◆ Input()

auto ceras::Input ( )

inline

◆ is_valid()

template<Tensor Tsor>

bool ceras::is_valid ( Tsor const & tsor )

◆ leaky_relu()

template<typename T >

requires std::floating_point<T> auto ceras::leaky_relu ( T const factor = 0.2 )

noexcept

Leaky Rectified Linear function, an unary operator. Returns x if positive, alpha x otherwise. alpha defaults to 0.2.

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = leaky_relu(0.1f)( y );

◆ LeakyReLU()

template<typename T = float>

auto ceras::LeakyReLU ( T const factor = 0.2 )

inlinenoexcept

leaky relu activation function.

◆ linspace()

template<typename T , typename A = default_allocator<T>>

requires std::floating_point<T> tensor<T,A> ceras::linspace	(	T	start,
		T	stop,
		unsigned long	num,
		bool	endpoint = `true`
	)

noexcept

◆ lisht()

template<Expression Ex>

auto ceras::lisht ( Ex const & ex )

noexcept

Lisht function.

auto v = variable{ random<float>{ 3, 3 } };

auto c = lisht( v );

ceras::lisht

auto lisht(Ex const &ex) noexcept

Lisht function.

Definition: activation.hpp:609

◆ load_tensor()

template<typename T , typename A = default_allocator<T>>

tensor<T,A> ceras::load_tensor ( std::string const & file_name )

◆ mae()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::mae	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ make_compiled_model()

template<typename Model , typename Optimizer , typename Loss >

auto ceras::make_compiled_model	(	Model const &	m,
		Loss const &	l,
		Optimizer const &	o
	)

inline

◆ make_trainable()

template<Expression Ex>

void ceras::make_trainable	(	Ex &	ex,
		bool	t
	)

Setting an expression's trainable flag

◆ max() [1/2]

template<Tensor Tsor>

Tsor ceras::max	(	Tsor const &	ts,
		unsigned long	axis,
		bool	keepdims = `false`
	)

noexcept

◆ max() [2/2]

template<Tensor Tsor>

auto ceras::max ( Tsor const & tsor )

◆ MaxPooling2D()

auto ceras::MaxPooling2D ( unsigned long stride )

inlinenoexcept

Max pooling operation for 2D spatial data.

◆ mean() [1/3]

template<Expression Ex>

constexpr auto ceras::mean ( Ex const & ex )

constexprnoexcept

An alias name of mean_reduce.

◆ mean() [2/3]

template<Tensor Tsor>

requires std::floating_point<typename Tsor::value_type> Tsor ceras::mean	(	Tsor const &	ts,
		unsigned long	axis,
		bool	keepdims = `false`
	)

noexcept

◆ mean() [3/3]

template<Tensor Tsor>

auto ceras::mean ( Tsor const & tsor )

◆ mean_absolute_error()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::mean_absolute_error	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ mean_reduce()

template<Expression Ex>

constexpr auto ceras::mean_reduce ( Ex const & ex )

constexprnoexcept

Computes the mean of elements across all dimensions of an expression.

Parameters

ex	Incoming expression.

Example code:

auto va = place_holder<tensor<float>>{};
auto vb = variable{ random<float>{ 3, 4} };
auto diff = mean_reduce( va, vb );

◆ mean_squared_error()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::mean_squared_error	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ mean_squared_logarithmic_error()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::mean_squared_logarithmic_error	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ min() [1/2]

template<Tensor Tsor>

Tsor ceras::min	(	Tsor const &	ts,
		unsigned long	axis,
		bool	keepdims = `false`
	)

noexcept

◆ min() [2/2]

template<Tensor Tsor>

auto ceras::min ( Tsor const & tsor )

◆ minus() [1/2]

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::minus	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ minus() [2/2]

template<Tensor Tsor>

Tsor ceras::minus	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ mish()

template<Expression Ex>

auto ceras::mish ( Ex const & ex )

noexcept

Mish function.

auto v = variable{ random<float>{ 3, 3 } };

auto c = mish( v );

ceras::mish

auto mish(Ex const &ex) noexcept

Mish function.

Definition: activation.hpp:594

◆ mse()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::mse	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ Multiply()

auto ceras::Multiply ( )

inlinenoexcept

Layer that elementwise multiplies two layers

Example usage:

auto input = Input(); // (16, )
auto x1 = Dense( 8, 16 )( input );
auto x2 = Dense( 8, 16 )( input );
auto x3 = Multiply()( x1, x2 ); // equivalent to `elementwise_multiply(x1, x2)`
auto m = model{ input, x3 };

◆ multiply() [1/2]

template<Tensor Tsor>

Tsor ceras::multiply	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ multiply() [2/2]

template<Tensor Tsor>

void ceras::multiply	(	Tsor const &	lhs,
		Tsor const &	rhs,
		Tsor &	ans
	)

noexcept

◆ negative()

template<Expression Ex>

constexpr auto ceras::negative ( Ex const & ex )

constexprnoexcept

◆ negative_relu()

template<Expression Ex>

auto ceras::negative_relu ( Ex const & ex )

noexcept

◆ norm() [1/2]

template<Complex C>

auto ceras::norm ( C const & c )

noexcept

Returns the squared magnitude of the complex expression.

Parameters

c	Complex expression.

auto r = variable{ ... };
auto i = variable{ ... };
auto c = complex{ r, i };
auto a = norm( c );

◆ norm() [2/2]

template<Tensor Tsor>

auto ceras::norm ( Tsor const & tsor )

◆ ones()

template<typename T , typename A = default_allocator<T>>

constexpr tensor<T,A> ceras::ones ( std::vector< unsigned long > const & shape )

constexpr

◆ ones_like()

template<Tensor Tsor>

constexpr Tsor ceras::ones_like ( Tsor const & tsor )

constexpr

◆ operator!=()

template<Place_Holder Ph>

bool ceras::operator!=	(	Ph const &	lhs,
		Ph const &	rhs
	)

◆ operator*() [1/7]

template<Complex C, Expression E>

auto ceras::operator*	(	C const &	c,
		E const &	e
	)

noexcept

Multiplies a complex expression with an expression.

◆ operator*() [2/7]

template<Complex Cl, Complex Cr>

auto ceras::operator*	(	Cl const &	cl,
		Cr const &	cr
	)

noexcept

Multiplies two complex expressions. Optimization here: (a+ib)*(c+id) = (ac-bd) + i(ad+bc) = (ac-bd) + i( (a+b)*(c+d)-ac-bd )

auto c1 = complex{ ..., ... };
auto c2 = complex{ ..., ... };
auto c12 = c1 * c2;

◆ operator*() [3/7]

template<Complex C, Expression E>

auto ceras::operator*	(	E const &	e,
		C const &	c
	)

noexcept

Multiplies an expression with a compression expression.

◆ operator*() [4/7]

template<Expression Lhs_Expression, Expression Rhs_Expression>

auto ceras::operator*	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

noexcept

◆ operator*() [5/7]

template<Tensor Tsor>

Tsor ceras::operator*	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ operator*() [6/7]

template<Tensor Tsor>

Tsor ceras::operator*	(	Tsor const &	lhs,
		typename Tsor::value_type const &	rhs
	)

noexcept

◆ operator*() [7/7]

template<Tensor Tsor>

Tsor ceras::operator*	(	typename Tsor::value_type const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ operator+() [1/9]

template<Complex C>

auto ceras::operator+ ( C const & c )

noexcept

Returns the complex expression.

◆ operator+() [2/9]

template<Complex C, Expression E>

auto ceras::operator+	(	C const &	c,
		E const &	e
	)

noexcept

Sums up a complex expression and an expression.

◆ operator+() [3/9]

template<Complex Cl, Complex Cr>

auto ceras::operator+	(	Cl const &	cl,
		Cr const &	cr
	)

noexcept

Sums up two complex expressions.

◆ operator+() [4/9]

template<Complex C, Expression E>

auto ceras::operator+	(	E const &	e,
		C const &	c
	)

noexcept

Sums up a complex expression and an expression.

◆ operator+() [5/9]

template<Expression Ex>

constexpr auto ceras::operator+ ( Ex const & ex )

constexprnoexcept

◆ operator+() [6/9]

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::operator+	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ operator+() [7/9]

template<Tensor Tsor>

Tsor ceras::operator+	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ operator+() [8/9]

template<Tensor Tsor>

Tsor ceras::operator+	(	Tsor const &	lhs,
		typename Tsor::value_type const &	rhs
	)

noexcept

◆ operator+() [9/9]

template<Tensor Tsor>

Tsor ceras::operator+	(	typename Tsor::value_type const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ operator-() [1/9]

template<Complex C>

auto ceras::operator- ( C const & c )

noexcept

Negatives the complex expression.

◆ operator-() [2/9]

template<Complex C, Expression E>

auto ceras::operator-	(	C const &	c,
		E const &	e
	)

noexcept

Subtracts an expression from a compression expression.

◆ operator-() [3/9]

template<Complex Cl, Complex Cr>

auto ceras::operator-	(	Cl const &	cl,
		Cr const &	cr
	)

noexcept

Subtracts one complex expression from the other one.

◆ operator-() [4/9]

template<Complex C, Expression E>

auto ceras::operator-	(	E const &	e,
		C const &	c
	)

noexcept

Subtractsa complex expression from an expression.

◆ operator-() [5/9]

template<Expression Ex>

constexpr auto ceras::operator- ( Ex const & ex )

constexprnoexcept

◆ operator-() [6/9]

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::operator-	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ operator-() [7/9]

template<Tensor Tsor>

Tsor ceras::operator-	(	Tsor const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ operator-() [8/9]

template<Tensor Tsor>

Tsor ceras::operator-	(	Tsor const &	lhs,
		typename Tsor::value_type const &	rhs
	)

noexcept

◆ operator-() [9/9]

template<Tensor Tsor>

Tsor ceras::operator-	(	typename Tsor::value_type const &	lhs,
		Tsor const &	rhs
	)

noexcept

◆ operator/()

template<Tensor Tsor>

Tsor ceras::operator/	(	Tsor const &	lhs,
		typename Tsor::value_type const &	rhs
	)

noexcept

◆ operator<()

template<Place_Holder Ph>

bool ceras::operator<	(	Ph const &	lhs,
		Ph const &	rhs
	)

◆ operator<<()

template<Tensor Tsor, typename CharT , typename Traits >

std::basic_ostream<CharT, Traits>& ceras::operator<<	(	std::basic_ostream< CharT, Traits > &	os_,
		Tsor const &	tsor
	)

◆ operator<=()

template<Place_Holder Ph>

bool ceras::operator<=	(	Ph const &	lhs,
		Ph const &	rhs
	)

◆ operator==() [1/2]

template<Place_Holder Ph>

bool ceras::operator==	(	Ph const &	lhs,
		Ph const &	rhs
	)

◆ operator==() [2/2]

template<Variable Var>

bool ceras::operator==	(	Var const &	lhs,
		Var const &	rhs
	)

noexcept

◆ operator>()

template<Place_Holder Ph>

bool ceras::operator>	(	Ph const &	lhs,
		Ph const &	rhs
	)

◆ operator>=()

template<Place_Holder Ph>

bool ceras::operator>=	(	Ph const &	lhs,
		Ph const &	rhs
	)

◆ plus()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::plus	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ polar()

template<Expression Em, Expression Ep>

auto ceras::polar	(	Em const &	em,
		Ep const &	ep
	)

noexcept

Returns with given magnitude and phase angle.

Parameters

em	Magnitude.
ep	Phase.

auto r = variable{ ... };
auto i = variable{ ... };
auto a = polar( r, i );

◆ randn()

template<typename T , typename A = default_allocator<T>>

tensor<T,A> ceras::randn	(	std::vector< unsigned long > const &	shape,
		T	mean = `T{0}`,
		T	stddev = `T{1}`
	)

◆ randn_like()

template<Tensor Tsor>

Tsor ceras::randn_like	(	Tsor const &	tsor,
		typename Tsor::value_type	mean = `0`,
		typename Tsor::value_type	stddev = `1`
	)

◆ random()

template<typename T , typename A = default_allocator<T>>

tensor<T,A> ceras::random	(	std::vector< unsigned long > const &	shape,
		T	min = `T{0}`,
		T	max = `T{1}`
	)

◆ random_like()

template<Tensor Tsor>

Tsor ceras::random_like	(	Tsor const &	tsor,
		typename Tsor::value_type	min = `0`,
		typename Tsor::value_type	max = `1`
	)

◆ read_tensor()

template<class _Tp , class _CharT , class _Traits , class _Alloc >

std::basic_istream<_CharT, _Traits>& ceras::read_tensor	(	std::basic_istream< _CharT, _Traits > &	__is,
		tensor< _Tp, _Alloc > &	__x
	)

◆ real()

template<Expression Real_Ex, Expression Imag_Ex>

Real_Ex ceras::real ( complex< Real_Ex, Imag_Ex > const & c )

noexcept

@bref Returns the real part of the complex expression.

Parameters

c	A complex expression.

◆ reduce()

template<Tensor Tsor, typename Function >

Tsor ceras::reduce	(	Tsor const &	ts,
		unsigned long	axis,
		typename Tsor::value_type const &	init,
		Function const &	func,
		bool	keepdims = `false`
	)

noexcept

◆ reduce_mean() [1/2]

template<Expression Ex>

constexpr auto ceras::reduce_mean ( Ex const & ex )

constexprnoexcept

An alias name of mean_reduce.

◆ reduce_mean() [2/2]

template<Tensor Tsor>

Tsor ceras::reduce_mean ( Tsor const & tsor )

◆ reduce_sum() [1/2]

template<Expression Ex>

constexpr auto ceras::reduce_sum ( Ex const & ex )

constexprnoexcept

◆ reduce_sum() [2/2]

template<Tensor Tsor>

Tsor ceras::reduce_sum ( Tsor const & tsor )

◆ relu()

template<Expression Ex>

auto ceras::relu ( Ex const & ex )

noexcept

Relu function, an unary operator. Returns x if positive, 0 otherwise.

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = relu( y );

◆ ReLU()

template<Expression Ex>

auto ceras::ReLU ( Ex const & ex )

inlinenoexcept

Rectified Linear Unit activation function.

◆ relu6()

template<Expression Ex>

auto ceras::relu6 ( Ex const & ex )

noexcept

Rectified Linear 6 function, an unary operator. Returns min(max(features, 0), 6).

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = relu6( y );

◆ repeat()

template<Tensor Tsor>

Tsor ceras::repeat	(	Tsor const &	tsor,
		unsigned long	n
	)

◆ replace_placeholder_with_expression()

template<Expression Ex, Place_Holder Ph, Expression Ey>

auto ceras::replace_placeholder_with_expression	(	Ex const &	ex,
		Ph const &	old_place_holder,
		Ey const &	new_expression
	)

Replacing a place_holder with an expression.

Parameters

ex	Can be a unary operator, binary operator, variable, place_holder, a constant or a value
old_place_holder	An place holder in `ex`
new_expression	An expression that will replace `old_place_holder` in `ex`.

Returns: A expression inheriting the topology of ex, but with old_place_holder replaced by new_expression

◆ repmat()

template<Tensor Tsor>

Tsor ceras::repmat	(	Tsor const &	tsor,
		unsigned long	row_rep,
		unsigned long	col_rep
	)

◆ Reshape()

auto ceras::Reshape	(	std::vector< unsigned long > const &	new_shape,
		bool	include_batch_flag = `true`
	)

inlinenoexcept

Reshapes inputs into the given shape.

◆ reshape()

template<Tensor Tsor>

Tsor ceras::reshape	(	Tsor const &	ts,
		std::vector< unsigned long > const &	new_shape
	)

◆ save_tensor()

template<Tensor Tsor>

void ceras::save_tensor	(	std::string const &	file_name,
		Tsor const &	tsor
	)

◆ selu()

template<Expression Ex>

auto ceras::selu ( Ex const & ex )

inlinenoexcept

Scaled Exponential Linear Unit (SELU) activation function, an unary operator. If x>0, returns 1.0507 x; Otherwise, returns 1.67326*1.0507*(exp(x)-1)

Parameters

ex	An input operator

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = selu( y );

◆ sigmoid()

template<Expression Ex>

auto ceras::sigmoid ( Ex const & ex )

inlinenoexcept

Sigmoid function, an unary operator. Returns 1 / (exp(-x) + 1).

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = sigmoid( y );

◆ silu()

template<Expression Ex>

auto ceras::silu ( Ex const & ex )

noexcept

An alias name of activation swish.

◆ Softmax()

auto ceras::Softmax ( )

inlinenoexcept

Softmax activation function.

◆ softmax() [1/2]

template<Expression Ex>

constexpr auto ceras::softmax ( Ex const & ex )

constexprnoexcept

Softmax activation function, an unary operator.

Parameters

ex	An input operator

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = softmax( y );

◆ softmax() [2/2]

template<Tensor Tsor>

Tsor ceras::softmax ( Tsor const & tsor )

◆ softplus()

template<Expression Ex>

auto ceras::softplus ( Ex const & ex )

inlinenoexcept

Softplus function, an unary operator. Returns log(exp(x)+1).

Parameters

ex	An input operator

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = softplus( y );

◆ softsign()

template<Expression Ex>

auto ceras::softsign ( Ex const & ex )

inlinenoexcept

Softsign function, an unary operator. Returns x / (abs(x) + 1).

Parameters

ex	An input operator.

auto x = Input();
auto y = Dense( 10, 28*28 )( x );
auto output = softsign( y );

◆ square()

template<Expression Ex>

constexpr auto ceras::square ( Ex const & ex )

constexprnoexcept

Returns the square of the input

Parameters

ex	The input operator.

Returns: An instance of a unary_operator that evaluate the squared value of the input operator.

Example code:

auto e = variable<tensor<float>>{ /*...*/ };

auto square = square(e);

ceras::square

constexpr auto square(Ex const &ex) noexcept

Definition: operation.hpp:563

◆ squared_loss()

template<Expression Lhs_Expression, Expression Rhs_Expression>

constexpr auto ceras::squared_loss	(	Lhs_Expression const &	lhs_ex,
		Rhs_Expression const &	rhs_ex
	)

constexprnoexcept

◆ squeeze()

template<Tensor Tsor>

Tsor ceras::squeeze ( Tsor const & tsor )

◆ standard_deviation()

template<Tensor Tsor>

requires std::floating_point<typename Tsor::value_type> Tsor ceras::standard_deviation	(	Tsor const &	ts,
		unsigned long	axis,
		bool	keepdims = `false`
	)

noexcept

◆ std()

template<Tensor Tsor>

requires std::floating_point<typename Tsor::value_type> Tsor::value_type ceras::std ( Tsor const & ts )

noexcept

◆ Subtract()

auto ceras::Subtract ( )

inlinenoexcept

Layer that subtracts two layers

Example usage:

auto input = Input(); // (16, )
auto x1 = Dense( 8, 16 )( input );
auto x2 = Dense( 8, 16 )( input );
auto x3 = Subtract()( x1, x2 ); // equivalent to `x1 - x2`
auto m = model{ input, x3 };

◆ sum() [1/2]

template<Tensor Tsor>

Tsor ceras::sum	(	Tsor const &	ts,
		unsigned long	axis,
		bool	keepdims = `false`
	)

noexcept

◆ sum() [2/2]

template<Tensor Tsor>

auto ceras::sum ( Tsor const & tsor )

◆ sum_reduce()

template<Expression Ex>

constexpr auto ceras::sum_reduce ( Ex const & ex )

constexprnoexcept

◆ swish()

template<Expression Ex>

auto ceras::swish ( Ex const & ex )

noexcept

Swish activation function.

Reference: Ramachandran, Prajit, Barret Zoph, and Quoc V. Le. “Searching for Activation Functions.” ArXiv:1710.05941 [Cs], October 16, 2017. http://arxiv.org/abs/1710.05941.

Parameters

ex	Input expression.

◆ tank_shrink()

template<Expression Ex>

auto ceras::tank_shrink ( Ex const & ex )

noexcept

Tank shrink function.

auto v = variable{ random<float>{ 3, 3 } };

auto c = tank_shrink( v );

ceras::tank_shrink

auto tank_shrink(Ex const &ex) noexcept

Tank shrink function.

Definition: activation.hpp:579

◆ truncated_normal()

template<typename T , typename A = default_allocator<T>>

tensor<T,A> ceras::truncated_normal	(	std::vector< unsigned long > const &	shape,
		T	mean = `T{0}`,
		T	stddev = `T{1}`,
		T	lower = `T{0}`,
		T	upper = `T{1}`
	)

◆ update_cuda_gemm_threshold()

void ceras::update_cuda_gemm_threshold ( )

inline

◆ UpSampling2D()

auto ceras::UpSampling2D ( unsigned long stride )

inlinenoexcept

Upsampling layer for 2D inputs.

◆ var()

template<Tensor Tsor>

requires std::floating_point<typename Tsor::value_type> Tsor::value_type ceras::var ( Tsor const & ts )

noexcept

◆ variance()

template<Tensor Tsor>

requires std::floating_point<typename Tsor::value_type> Tsor ceras::variance	(	Tsor const &	ts,
		unsigned long	axis,
		bool	keepdims = `false`
	)

noexcept

◆ write_tensor()

template<class _Tp , class _CharT , class _Traits , class _Alloc >

std::basic_ostream<_CharT, _Traits>& ceras::write_tensor	(	std::basic_ostream< _CharT, _Traits > &	__os,
		tensor< _Tp, _Alloc > const &	__x
	)

◆ zeros()

template<typename T , typename A = default_allocator<T>>

constexpr tensor<T,A> ceras::zeros ( std::vector< unsigned long > const & shape )

constexpr

◆ zeros_like()

template<Tensor Tsor>

constexpr Tsor ceras::zeros_like ( Tsor const & tsor )

constexpr

Variable Documentation

◆ Adadelta

auto ceras::Adadelta

inline

Initial value:

= []( auto ... args )
    {
        return [=]<Expression Ex>( Ex& loss )
        {
            return adadelta{loss, args...};
        };
    }

◆ Adagrad

auto ceras::Adagrad

inline

Initial value:

= []( auto ... args )
    {
        return [=]<Expression Ex>( Ex& loss )
        {
            return adagrad{loss, args...};
        };
    }

◆ Adam

auto ceras::Adam

inline

Initial value:

= []( auto ... args )
    {
        return [=]<Expression Ex>( Ex& loss )
        {
            return adam{loss, args...};
        };
    }

◆ Binary_Operator

template<typename T >

concept ceras::Binary_Operator = is_binary_operator_v<T>

A type that represents a binary operator.

@concept Binary_Operator<>

◆ BinaryCrossentropy

auto ceras::BinaryCrossentropy

inline

Initial value:

= []()
    {
        return []<Expression Ex >( Ex const& output )
        {
            return [=]<Place_Holder Ph>( Ph const& ground_truth )
            {
                return binary_cross_entropy_loss( ground_truth, output );
            };
        };
    }

◆ BinaryCrossEntropy

auto ceras::BinaryCrossEntropy

inline

Initial value:

= []()
    {
        return BinaryCrossentropy();
    }

◆ CategoricalCrossentropy

auto ceras::CategoricalCrossentropy

inline

Initial value:

= []()
    {
        return []<Expression Ex >( Ex const& output )
        {
            return [=]<Place_Holder Ph>( Ph const& ground_truth )
            {
                return cross_entropy_loss( ground_truth, output );
            };
        };
    }

◆ CategoricalCrossEntropy

auto ceras::CategoricalCrossEntropy

inline

Initial value:

= []()
    {
        return CategoricalCrossentropy();
    }

◆ Complex

template<typename T >

concept ceras::Complex = is_complex_v<T>

A type that represents a complex expression.

@concept Complex

◆ Constant

template<typename T >

concept ceras::Constant = is_constant_v<T>

◆ Expression

template<typename T >

concept ceras::Expression = Operator<T> || Variable<T> || Place_Holder<T> || Constant<T> || Value<T>

A type that represents a unary operator, a binary operator, a variable, a place_holder, a constant or a value.

@concept Expression<>

◆ Hinge

auto ceras::Hinge

inline

Initial value:

= []()
    {
        return []<Expression Ex >( Ex const& output )
        {
            return [=]<Place_Holder Ph>( Ph const& ground_truth )
            {
                return hinge_loss( ground_truth, output );
            };
        };
    }

◆ is_binary_operator_v

template<class T >

constexpr bool ceras::is_binary_operator_v = is_binary_operator<T>::value

inlineconstexpr

If T is an instance of a binary_operator, the constant value equals to true. Otherwise this value is false.

◆ is_complex_v

template<typename T >

constexpr bool ceras::is_complex_v = is_complex<T>::value

constexpr

◆ is_constant_v

template<class T >

constexpr bool ceras::is_constant_v = is_constant<T>::value

inlineconstexpr

◆ is_place_holder_v

template<class T >

constexpr bool ceras::is_place_holder_v = is_place_holder<T>::value

inlineconstexpr

◆ is_tensor_v

template<class T >

constexpr bool ceras::is_tensor_v = is_tensor<T>::value

inlineconstexpr

◆ is_unary_operator_v

template<class T >

constexpr bool ceras::is_unary_operator_v = is_unary_operator<T>::value

inlineconstexpr

If T is an instance of a unary_operator, the constant value equals to true. Otherwise this value is false.

◆ is_value_v

template<class T >

constexpr bool ceras::is_value_v = is_value<T>::value

inlineconstexpr

◆ is_variable_v

template<class T >

constexpr bool ceras::is_variable_v = is_variable<T>::value

inlineconstexpr

◆ MAE

auto ceras::MAE

inline

Initial value:

= []()
    {
        return MeanAbsoluteError();
    }

An alias name of function MeanAbsoluteError.

◆ make_binary_operator

constexpr auto ceras::make_binary_operator

staticconstexpr

Initial value:

= []( auto const& binary_forward_action, auto const& binary_backward_action, std::string const& name="Anonymous Binary Operator" ) noexcept
    {
        return [&binary_forward_action, &binary_backward_action, &name]( auto const& lhs_op, auto const& rhs_op ) noexcept
        {
            auto ans = binary_operator{ lhs_op, rhs_op, binary_forward_action, binary_backward_action };
            ans.name_ = name;
            return ans;
        };
    }

◆ make_unary_operator

constexpr auto ceras::make_unary_operator

staticconstexpr

Initial value:

= []( auto const& unary_forward_action, auto const& unary_backward_action, std::string const& name="Anonymous Unary Operator" ) noexcept
    {
        return [&unary_forward_action, &unary_backward_action, &name]( auto const& op ) noexcept
        {
            auto ans = unary_operator{ op, unary_forward_action, unary_backward_action };
            ans.name_ = name;
            return ans;
        };
    }

◆ MeanAbsoluteError

auto ceras::MeanAbsoluteError

inline

Initial value:

= []()
    {
        return []<Expression Ex >( Ex const& output )
        {
            return [=]<Place_Holder Ph>( Ph const& ground_truth )
            {
                return mean_absolute_error( ground_truth, output );
            };
        };
    }

Computes the mean of absolute errors between labels and predictions.

auto input = place_holder<tensor<float>>{};
auto v = variable<tensor<float>>{ ones<float>({12, 34}) };
auto output = input * v;
auto m = model{ input, output };
auto cm = m.compile( MeanAbsoluteError(), Adam(128/*batch size*/, 0.01f/*learning rate*/) );

◆ MeanSquaredError

auto ceras::MeanSquaredError

inline

Initial value:

= []()
    {
        return []<Expression Ex >( Ex const& output )
        {
            return [=]<Place_Holder Ph>( Ph const& ground_truth )
            {
                return mean_squared_error( ground_truth, output );
            };
        };
    }

Computes the mean of squares of errors between labels and predictions.

auto input = place_holder<tensor<float>>{};
auto v = variable<tensor<float>>{ ones<float>({12, 34}) };
auto output = input * v;
auto m = model{ input, output };
auto cm = m.compile( MeanSquareError(), Adam(128/*batch size*/, 0.01f/*learning rate*/) );

◆ MSE

auto ceras::MSE

inline

Initial value:

= []()
    {
        return MeanSquaredError();
    }

An alias name of function MeanSquaredError.

◆ Operator

template<typename T >

concept ceras::Operator = Unary_Operator<T> || Binary_Operator<T>

A type that represents an unary or a binary operator.

@concept Operator<>

◆ Place_Holder

template<typename T >

concept ceras::Place_Holder = is_place_holder_v<T>

◆ random_generator

std::mt19937 ceras::random_generator {random_seed}

static

◆ random_seed

unsigned long ceras::random_seed = std::chrono::system_clock::now().time_since_epoch().count()

static

◆ RMSprop

auto ceras::RMSprop

inline

Initial value:

= []( auto ... args )
    {
        return [=]<Expression Ex>( Ex& loss )
        {
            return rmsprop{loss, args...};
        };
    }

◆ SGD

auto ceras::SGD

inline

Initial value:

= []( auto ... args )
    {
        return [=]<Expression Ex>( Ex& loss )
        {
            return sgd{loss, args...};
        };
    }

◆ Tensor

template<typename T >

concept ceras::Tensor = is_tensor_v<T>

◆ Unary_Operator

template<typename T >

concept ceras::Unary_Operator = is_unary_operator_v<T>

A type that represents an unary operator.

@concept Unary_Operator<>

◆ Value

template<typename T >

concept ceras::Value = is_value_v<T>

◆ Variable

template<typename T >

concept ceras::Variable = is_variable_v<T>

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ ada_delta

◆ ada_grad

◆ array

◆ cube

◆ default_allocator

◆ matrix

◆ rms_prop

◆ tesseract

Function Documentation

◆ abs() [1/2]

◆ abs() [2/2]

◆ abs_loss()

◆ Add()

◆ add()

◆ amax()

◆ amin()

◆ arg()

◆ as_tensor()

◆ AveragePooling2D()

◆ BatchNormalization() [1/2]

◆ BatchNormalization() [2/2]

◆ binary_cross_entropy_loss()

◆ clip()

◆ computation_graph()

◆ concatenate()

◆ Concatenate()

◆ conj()

◆ Conv2D()

◆ copy()

◆ crelu()

◆ cross_entropy()

◆ cross_entropy_loss()

◆ deep_copy()

◆ Dense()

◆ Dropout()

◆ elementwise_divide()

◆ elementwise_multiply()

◆ elementwise_product() [1/2]

◆ elementwise_product() [2/2]

◆ elu()

◆ ELU()

◆ empty()

◆ exponential()

◆ Flatten()

◆ gelu()

◆ gemm() [1/2]

◆ gemm() [2/2]

◆ gemm_cpu()

◆ get_default_session()

◆ glorot_uniform()

◆ hadamard_product() [1/2]

◆ hadamard_product() [2/2]

◆ hard_sigmoid()

◆ has_inf()

◆ has_nan()

◆ hinge_loss()

◆ imag()

◆ Input()

◆ is_valid()

◆ leaky_relu()

◆ LeakyReLU()

◆ linspace()

◆ lisht()

◆ load_tensor()

◆ mae()

◆ make_compiled_model()

◆ make_trainable()

◆ max() [1/2]

◆ max() [2/2]

◆ MaxPooling2D()

◆ mean() [1/3]

◆ mean() [2/3]

◆ mean() [3/3]

◆ mean_absolute_error()