dlib C++ Library - tensor_tools.cpp

// Copyright (C) 2015 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_TeNSOR_TOOLS_CPP_
#define DLIB_TeNSOR_TOOLS_CPP_
#include "tensor_tools.h"
#include "../string.h"
#include <atomic>
namespace dlib
{
 namespace
 {
 std::atomic<bool>& dnn_prefer_fastest_algo (
 )
 {
 static std::atomic<bool> var(true);
 return var;
 }
 }
 bool dnn_prefer_fastest_algorithms (
 )
 {
 return dnn_prefer_fastest_algo();
 }
 void set_dnn_prefer_fastest_algorithms(
 )
 {
 dnn_prefer_fastest_algo() = true;
 }
 void set_dnn_prefer_smallest_algorithms(
 )
 {
 dnn_prefer_fastest_algo() = false;
 }
}
namespace dlib { namespace tt
{
// ----------------------------------------------------------------------------------------
 void inverse_norms (
 resizable_tensor& invnorms,
 const tensor& data,
 const double eps
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::inverse_norms(invnorms, data, eps);
#else
 invnorms = reciprocal(sqrt(sum_cols(squared(mat(data))) + eps));
#endif
 }
 void dot_prods (
 resizable_tensor& out,
 const tensor& lhs,
 const tensor& rhs
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::dot_prods(out, lhs, rhs);
#else
 out = sum_cols(pointwise_multiply(mat(lhs), mat(rhs))); 
#endif
 }
 void dot_prods (
 bool add_to,
 tensor& out,
 const tensor& lhs,
 const tensor& rhs
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::dot_prods(add_to, out, lhs, rhs);
#else
 if (add_to)
 out += sum_cols(pointwise_multiply(mat(lhs), mat(rhs))); 
 else
 out = sum_cols(pointwise_multiply(mat(lhs), mat(rhs))); 
#endif
 }
 void scale_columns (
 tensor& out,
 const tensor& m,
 const tensor& v
 )
 {
 DLIB_CASSERT(have_same_dimensions(out,m));
 DLIB_CASSERT(is_vector(v));
 if (m.size() == 0 && v.size() == 0)
 return;
 DLIB_CASSERT(m.size() != 0);
 DLIB_CASSERT(m.size()/m.num_samples() == v.size());
#ifdef DLIB_USE_CUDA
 cuda::scale_columns(out, m, v);
#else
 out = scale_columns(mat(m), mat(v));
#endif
 }
 void scale_rows (
 tensor& out,
 const tensor& m,
 const tensor& v
 )
 {
 DLIB_CASSERT(have_same_dimensions(out,m));
 DLIB_CASSERT(is_vector(v));
 if (m.size() == 0 && v.size() == 0)
 return;
 DLIB_CASSERT(m.size() != 0);
 DLIB_CASSERT(m.num_samples() == static_cast<long long>(v.size()));
#ifdef DLIB_USE_CUDA
 cuda::scale_rows(out, m, v);
#else
 out = scale_rows(mat(m), mat(v));
#endif
 }
 void scale_rows2 (
 float beta, 
 tensor& out,
 const tensor& m1,
 const tensor& m2,
 const tensor& v1,
 const tensor& v2
 )
 {
 DLIB_CASSERT(have_same_dimensions(out,m1));
 DLIB_CASSERT(have_same_dimensions(out,m2));
 DLIB_CASSERT(have_same_dimensions(v1,v2));
 DLIB_CASSERT(is_vector(mat(v1))); 
 DLIB_CASSERT(static_cast<long long>(v1.size()) == m1.num_samples());
#ifdef DLIB_USE_CUDA
 cuda::scale_rows2(beta, out, m1, m2, v1, v2);
#else
 if (beta == 0)
 out = scale_rows(mat(m1) - scale_rows(mat(m2),mat(v1)), mat(v2));
 else
 out = beta*mat(out) + scale_rows(mat(m1) - scale_rows(mat(m2),mat(v1)), mat(v2));
#endif
 }
// ----------------------------------------------------------------------------------------
 void exp (
 tensor& dest,
 const tensor& src
 )
 {
 DLIB_CASSERT(dest.size() == src.size());
#ifdef DLIB_USE_CUDA
 cuda::exp(dest,src);
#else
 dest = exp(mat(src));
#endif
 }
// ----------------------------------------------------------------------------------------
 void log (
 tensor& dest,
 const tensor& src
 )
 {
 DLIB_CASSERT(dest.size() == src.size());
#ifdef DLIB_USE_CUDA
 cuda::log(dest,src);
#else
 dest = log(mat(src));
#endif
 }
// ----------------------------------------------------------------------------------------
 void log10 (
 tensor& dest,
 const tensor& src
 )
 {
 DLIB_CASSERT(dest.size() == src.size());
#ifdef DLIB_USE_CUDA
 cuda::log10(dest,src);
#else
 dest = log10(mat(src));
#endif
 }
// ----------------------------------------------------------------------------------------
 void gemm (
 float beta,
 tensor& dest,
 float alpha,
 const tensor& lhs,
 bool trans_lhs,
 const tensor& rhs,
 bool trans_rhs,
 operation_mode mode
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::gemm(beta, dest, alpha, lhs, trans_lhs, rhs, trans_rhs, mode);
#else
 if (mode == operation_mode::CHANNEL_WISE)
 {
 if (beta != 0)
 {
 if (trans_lhs && trans_rhs)
 dest = alpha * trans(mat(lhs)) * trans(mat(rhs)) + beta * mat(dest);
 else if (!trans_lhs && trans_rhs)
 dest = alpha * mat(lhs) * trans(mat(rhs)) + beta * mat(dest);
 else if (trans_lhs && !trans_rhs)
 dest = alpha * trans(mat(lhs)) * mat(rhs) + beta * mat(dest);
 else
 dest = alpha * mat(lhs) * mat(rhs) + beta * mat(dest);
 }
 else
 {
 if (trans_lhs && trans_rhs)
 dest = alpha * trans(mat(lhs)) * trans(mat(rhs));
 else if (!trans_lhs && trans_rhs)
 dest = alpha * mat(lhs) * trans(mat(rhs));
 else if (trans_lhs && !trans_rhs)
 dest = alpha * trans(mat(lhs)) * mat(rhs);
 else
 dest = alpha * mat(lhs) * mat(rhs);
 }
 }
 else if (mode == operation_mode::PLANE_WISE)
 {
 auto is_matrix = [](const auto& tensor) {
 return ((tensor.num_samples() * tensor.k() == 1 && tensor.nr() * tensor.nc() > 1) ||
 (tensor.num_samples() * tensor.k() > 1 && tensor.nr() * tensor.nc() == 1));
 };
 long num_samples = std::min({ lhs.num_samples(), rhs.num_samples(), dest.num_samples() });
 long num_channels = std::min({ lhs.k(), rhs.k(), dest.k() });
 const bool lhs_is_matrix = is_matrix(lhs), rhs_is_matrix = is_matrix(rhs), dest_is_matrix = is_matrix(dest);
 if (lhs_is_matrix && rhs_is_matrix && dest_is_matrix) {
 num_samples = num_channels = 1;
 }
 long lhs_rows = (lhs_is_matrix && lhs.num_samples() > 1) ? lhs.num_samples() : lhs.nr();
 long lhs_cols = (lhs_is_matrix && lhs.k() > 1) ? lhs.k() : lhs.nc();
 long rhs_rows = (rhs_is_matrix && rhs.num_samples() > 1) ? rhs.num_samples() : rhs.nr();
 long rhs_cols = (rhs_is_matrix && rhs.k() > 1) ? rhs.k() : rhs.nc();
 long dest_rows = (dest_is_matrix && dest.num_samples() > 1) ? dest.num_samples() : dest.nr();
 long dest_cols = (dest_is_matrix && dest.k() > 1) ? dest.k() : dest.nc();
 const size_t lhs_plane_size = lhs_rows * lhs_cols;
 const size_t rhs_plane_size = rhs_rows * rhs_cols;
 const size_t dest_plane_size = dest_rows * dest_cols;
 for (long b = 0; b < num_samples; ++b)
 {
 for (long c = 0; c < num_channels; ++c)
 {
 auto lhs_slice = lhs_is_matrix ? alias_tensor(lhs_rows, lhs_cols)(lhs, 0) :
 alias_tensor(lhs_rows, lhs_cols)(lhs, (b * num_channels + c) * lhs_plane_size);
 auto rhs_slice = rhs_is_matrix ? alias_tensor(rhs_rows, rhs_cols)(rhs, 0) :
 alias_tensor(rhs_rows, rhs_cols)(rhs, (b * num_channels + c) * rhs_plane_size);
 auto dest_slice = dest_is_matrix ? alias_tensor(dest_rows, dest_cols)(dest, 0) :
 alias_tensor(dest_rows, dest_cols)(dest, (b * num_channels + c) * dest_plane_size);
 if (beta != 0)
 {
 if (trans_lhs && trans_rhs)
 dest_slice = alpha * trans(mat(lhs_slice)) * trans(mat(rhs_slice)) + beta * mat(dest_slice);
 else if (!trans_lhs && trans_rhs)
 dest_slice = alpha * mat(lhs_slice) * trans(mat(rhs_slice)) + beta * mat(dest_slice);
 else if (trans_lhs && !trans_rhs)
 dest_slice = alpha * trans(mat(lhs_slice)) * mat(rhs_slice) + beta * mat(dest_slice);
 else
 dest_slice = alpha * mat(lhs_slice) * mat(rhs_slice) + beta * mat(dest_slice);
 }
 else
 {
 if (trans_lhs && trans_rhs)
 dest_slice = alpha * trans(mat(lhs_slice)) * trans(mat(rhs_slice));
 else if (!trans_lhs && trans_rhs)
 dest_slice = alpha * mat(lhs_slice) * trans(mat(rhs_slice));
 else if (trans_lhs && !trans_rhs)
 dest_slice = alpha * trans(mat(lhs_slice)) * mat(rhs_slice);
 else
 dest_slice = alpha * mat(lhs_slice) * mat(rhs_slice);
 }
 }
 }
 }
#endif
 }
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
 tensor_rand::
 tensor_rand(
 unsigned long long seed
 ) 
#ifdef DLIB_USE_CUDA
 :rnd(seed){}
#else
 {rnd.set_seed(cast_to_string(seed)); }
#endif
 void tensor_rand::
 fill_gaussian (
 tensor& data,
 float mean,
 float stddev
 )
 {
 DLIB_CASSERT(data.size()%2 == 0);
#ifdef DLIB_USE_CUDA
 rnd.fill_gaussian(data, mean, stddev);
#else
 for (auto& x : data) 
 x = rnd.get_random_gaussian()*stddev + mean;
#endif
 }
 void tensor_rand::
 fill_uniform (
 tensor& data
 )
 {
#ifdef DLIB_USE_CUDA
 rnd.fill_uniform(data);
#else
 for (auto& x : data) 
 x = rnd.get_random_float();
#endif
 }
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
 void multiply (
 bool add_to,
 tensor& dest,
 const tensor& src1,
 const tensor& src2
 )
 {
 DLIB_CASSERT(dest.k() == src1.k() && src1.k() == src2.k() &&
 dest.nr() == src1.nr() && src1.nr() == src2.nr() &&
 dest.nc() == src1.nc() && src1.nc() == src2.nc() );
 const long MD = std::max(std::max(dest.num_samples(),src1.num_samples()),src2.num_samples());
 DLIB_CASSERT((dest.num_samples()==1 || dest.num_samples()==MD) &&
 (src1.num_samples()==1 || src1.num_samples()==MD) &&
 (src2.num_samples()==1 || src2.num_samples()==MD) );
#ifdef DLIB_USE_CUDA
 cuda::multiply(add_to, dest, src1, src2);
#else
 cpu::multiply(add_to, dest, src1, src2);
#endif
 }
 void scale_channels (
 bool add_to,
 tensor& dest,
 const tensor& src,
 const tensor& scales
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::scale_channels(add_to, dest, src, scales);
#else
 cpu::scale_channels(add_to, dest, src, scales);
#endif
 }
 void multiply_conv (
 bool add_to,
 tensor& dest,
 const tensor& src1,
 const tensor& src2
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::multiply_conv(add_to, dest, src1, src2);
#else
 cpu::multiply_conv(add_to, dest, src1, src2);
#endif
 }
 void multiply_zero_padded (
 bool add_to,
 tensor& dest,
 const tensor& src1,
 const tensor& src2
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::multiply_zero_padded(add_to, dest, src1, src2);
#else
 cpu::multiply_zero_padded(add_to, dest, src1, src2);
#endif
 }
// ----------------------------------------------------------------------------------------
 void affine_transform(
 tensor& dest,
 const tensor& src,
 const float A,
 const float B
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform(dest,src,A,B);
#else
 cpu::affine_transform(dest,src,A,B);
#endif
 }
 void affine_transform(
 tensor& dest,
 const tensor& src,
 const float A
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform(dest,src,A);
#else
 cpu::affine_transform(dest,src,A,0);
#endif
 }
 void affine_transform(
 tensor& dest,
 const tensor& src1,
 const tensor& src2,
 const float A,
 const float B,
 const float C
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform(dest,src1,src2,A,B,C);
#else
 cpu::affine_transform(dest,src1,src2,A,B,C);
#endif
 }
 void affine_transform(
 tensor& dest,
 const tensor& src1,
 const tensor& src2,
 const float A,
 const float B
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform(dest,src1,src2,A,B);
#else
 cpu::affine_transform(dest,src1,src2,A,B,0);
#endif
 }
 void affine_transform(
 tensor& dest,
 const tensor& src1,
 const tensor& src2,
 const tensor& src3,
 const float A,
 const float B,
 const float C,
 const float D
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform(dest,src1,src2,src3,A,B,C,D);
#else
 cpu::affine_transform(dest,src1,src2,src3,A,B,C,D);
#endif
 }
 void affine_transform_range(
 size_t begin,
 size_t end,
 tensor& dest,
 const tensor& src1,
 const tensor& src2,
 const tensor& src3,
 const float A,
 const float B,
 const float C
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform_range(begin, end, dest,src1,src2,src3,A,B,C);
#else
 cpu::affine_transform_range(begin, end, dest,src1,src2,src3,A,B,C);
#endif
 }
 void affine_transform(
 const rectangle& rect,
 tensor& dest, 
 const tensor& src1, 
 const tensor& src2, 
 const tensor& src3, 
 float A, 
 float B,
 float C
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform(rect, dest,src1,src2,src3,A,B,C);
#else
 cpu::affine_transform(rect, dest,src1,src2,src3,A,B,C);
#endif
 }
 void affine_transform(
 tensor& dest,
 const tensor& src1,
 const tensor& src2,
 const tensor& src3,
 const float A,
 const float B,
 const float C
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform_range(0,dest.size(),dest,src1,src2,src3,A,B,C);
#else
 cpu::affine_transform_range(0,dest.size(),dest,src1,src2,src3,A,B,C);
#endif
 }
// ----------------------------------------------------------------------------------------
 void affine_transform(
 tensor& dest,
 const tensor& src,
 const tensor& A,
 const tensor& B
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform(dest,src,A,B);
#else
 cpu::affine_transform(dest,src,A,B);
#endif
 }
// ----------------------------------------------------------------------------------------
 void affine_transform_conv(
 tensor& dest,
 const tensor& src,
 const tensor& A,
 const tensor& B
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::affine_transform_conv(dest,src,A,B);
#else
 cpu::affine_transform_conv(dest,src,A,B);
#endif
 }
// ----------------------------------------------------------------------------------------
 void compute_adam_update (
 size_t begin,
 size_t end,
 tensor& s,
 tensor& m,
 tensor& v,
 const float t,
 const float learning_rate,
 const float weight_decay,
 const float momentum1,
 const float momentum2,
 const tensor& params,
 const tensor& params_grad
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::compute_adam_update(begin, end, s, m, v, t, learning_rate, weight_decay, momentum1,
 momentum2, params, params_grad);
#else
 cpu::compute_adam_update(begin, end, s, m, v, t, learning_rate, weight_decay, momentum1,
 momentum2, params, params_grad);
#endif
 }
// ----------------------------------------------------------------------------------------
 void batch_normalize_inference (
 const double eps,
 resizable_tensor& dest,
 const tensor& src,
 const tensor& gamma, 
 const tensor& beta,
 const tensor& running_means,
 const tensor& running_variances
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::batch_normalize_inference(eps,dest,src,gamma,beta,running_means,running_variances);
#else
 cpu::batch_normalize_inference(eps,dest,src,gamma,beta,running_means,running_variances);
#endif
 }
 void batch_normalize (
 const double eps,
 resizable_tensor& dest,
 resizable_tensor& means,
 resizable_tensor& vars,
 const double averaging_factor,
 resizable_tensor& running_means,
 resizable_tensor& running_variances,
 const tensor& src,
 const tensor& gamma, 
 const tensor& beta 
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::batch_normalize(eps,dest,means,vars,averaging_factor,running_means,running_variances,src,gamma,beta);
#else
 cpu::batch_normalize(eps,dest,means,vars,averaging_factor,running_means,running_variances,src,gamma,beta);
#endif
 }
 void batch_normalize_gradient (
 const double eps,
 const tensor& gradient_input,
 const tensor& means,
 const tensor& invstds,
 const tensor& src,
 const tensor& gamma,
 tensor& src_grad,
 tensor& gamma_grad, 
 tensor& beta_grad 
 )
 {
 
#ifdef DLIB_USE_CUDA
 cuda::batch_normalize_gradient(eps,gradient_input, means, invstds, src, gamma, src_grad, gamma_grad, beta_grad);
#else
 cpu::batch_normalize_gradient(eps,gradient_input, means, invstds, src, gamma, src_grad, gamma_grad, beta_grad);
#endif
 }
// ----------------------------------------------------------------------------------------
 void batch_normalize_conv_inference (
 const double eps,
 resizable_tensor& dest,
 const tensor& src,
 const tensor& gamma, 
 const tensor& beta,
 const tensor& running_means,
 const tensor& running_variances
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::batch_normalize_conv_inference(eps,dest,src,gamma,beta,running_means,running_variances);
#else
 cpu::batch_normalize_conv_inference(eps,dest,src,gamma,beta,running_means,running_variances);
#endif
 }
 void batch_normalize_conv (
 const double eps,
 resizable_tensor& dest,
 resizable_tensor& means,
 resizable_tensor& vars,
 const double averaging_factor,
 resizable_tensor& running_means,
 resizable_tensor& running_variances,
 const tensor& src,
 const tensor& gamma, 
 const tensor& beta 
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::batch_normalize_conv(eps,dest,means,vars,averaging_factor,running_means,running_variances,src,gamma,beta);
#else
 cpu::batch_normalize_conv(eps,dest,means,vars,averaging_factor,running_means,running_variances,src,gamma,beta);
#endif
 }
 void batch_normalize_conv_gradient (
 const double eps,
 const tensor& gradient_input,
 const tensor& means,
 const tensor& invstds,
 const tensor& src,
 const tensor& gamma,
 tensor& src_grad,
 tensor& gamma_grad, 
 tensor& beta_grad 
 )
 {
 
#ifdef DLIB_USE_CUDA
 cuda::batch_normalize_conv_gradient(eps,gradient_input, means, invstds, src, gamma, src_grad, gamma_grad, beta_grad);
#else
 cpu::batch_normalize_conv_gradient(eps,gradient_input, means, invstds, src, gamma, src_grad, gamma_grad, beta_grad);
#endif
 }
// ----------------------------------------------------------------------------------------
 void layer_normalize (
 const double eps,
 resizable_tensor& dest,
 resizable_tensor& means,
 resizable_tensor& vars,
 const tensor& src,
 const tensor& gamma,
 const tensor& beta
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::layer_normalize(eps, dest, means, vars, src, gamma, beta);
#else
 cpu::layer_normalize(eps, dest, means, vars, src, gamma, beta);
#endif
 }
 void layer_normalize_gradient (
 const double eps,
 const tensor& gradient_input,
 const tensor& means,
 const tensor& invstds,
 const tensor& src,
 const tensor& gamma,
 tensor& src_grad,
 tensor& gamma_grad,
 tensor& beta_grad,
 resizable_tensor& dmeans,
 resizable_tensor& dvars
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::layer_normalize_gradient(eps, gradient_input, means, invstds, src, gamma, src_grad, gamma_grad, beta_grad, dmeans, dvars);
#else
 cpu::layer_normalize_gradient(eps, gradient_input, means, invstds, src, gamma, src_grad, gamma_grad, beta_grad, dmeans, dvars);
#endif
 }
// ----------------------------------------------------------------------------------------
 void rms_normalize(
 const double eps,
 resizable_tensor& dest,
 resizable_tensor& scale,
 const tensor& src,
 const tensor& gamma
 )
 { 
#ifdef DLIB_USE_CUDA
 cuda::rms_normalize(eps, dest, scale, src, gamma);
#else
 cpu::rms_normalize(eps, dest, scale, src, gamma);
#endif
 }
 void rms_normalize_gradient(
 const tensor& gradient_input,
 const tensor& scale,
 const tensor& src,
 const tensor& gamma,
 tensor& src_grad,
 tensor& gamma_grad,
 resizable_tensor& dscale
 )
 { 
#ifdef DLIB_USE_CUDA
 cuda::rms_normalize_gradient(gradient_input, scale, src, gamma, src_grad, gamma_grad, dscale);
#else
 cpu::rms_normalize_gradient(gradient_input, scale, src, gamma, src_grad, gamma_grad, dscale);
#endif
 }
// ----------------------------------------------------------------------------------------
 void threshold (
 tensor& data,
 float thresh
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::threshold(data,thresh);
#else
 cpu::threshold(data,thresh);
#endif
 }
 void dot (
 const tensor& a,
 const tensor& b,
 tensor& result,
 size_t idx
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::dot(a,b,result,idx);
#else
 cpu::dot(a,b,result,idx);
#endif
 }
// ----------------------------------------------------------------------------------------
 void add(
 float beta,
 tensor& dest,
 float alpha,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::add(beta,dest,alpha,src);
#else
 cpu::add(beta,dest,alpha,src);
#endif
 }
// ----------------------------------------------------------------------------------------
 void add (
 tensor& dest,
 const tensor& src1,
 const tensor& src2
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::add(dest, src1, src2);
#else
 cpu::add(dest, src1, src2);
#endif
 }
// ----------------------------------------------------------------------------------------
 void assign_conv_bias_gradient (
 tensor& grad,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::assign_conv_bias_gradient(grad,gradient_input);
#else
 cpu::assign_conv_bias_gradient(grad,gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void assign_bias_gradient (
 tensor& grad,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::assign_bias_gradient(grad,gradient_input);
#else
 cpu::assign_bias_gradient(grad,gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void softmax(
 tensor& dest,
 const tensor& src,
 operation_mode mode
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::softmax(dest, src, mode);
#else
 cpu::softmax(dest, src, mode);
#endif
 }
 void softmax_gradient(
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input,
 operation_mode mode
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::softmax_gradient(grad, dest, gradient_input, mode);
#else
 cpu::softmax_gradient(grad, dest, gradient_input, mode);
#endif
 }
// ----------------------------------------------------------------------------------------
 void softmax_all (
 tensor& dest,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::softmax_all(dest,src);
#else
 cpu::softmax_all(dest,src);
#endif
 }
 void softmax_all_gradient (
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::softmax_all_gradient(grad, dest, gradient_input);
#else
 cpu::softmax_all_gradient(grad, dest, gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void sigmoid (
 tensor& dest,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::sigmoid(dest,src);
#else
 cpu::sigmoid(dest,src);
#endif
 }
 void sigmoid_gradient (
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::sigmoid_gradient(grad, dest, gradient_input);
#else
 cpu::sigmoid_gradient(grad, dest, gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void mish (
 tensor& dest,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::mish(dest,src);
#else
 cpu::mish(dest,src);
#endif
 }
 void mish_gradient (
 tensor& grad,
 const tensor& src,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::mish_gradient(grad, src, gradient_input);
#else
 cpu::mish_gradient(grad, src, gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void relu (
 tensor& dest,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::relu(dest,src);
#else
 cpu::relu(dest,src);
#endif
 }
 void relu_gradient (
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::relu_gradient(grad, dest, gradient_input);
#else
 cpu::relu_gradient(grad, dest, gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void prelu (
 tensor& dest,
 const tensor& src,
 const tensor& param
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::prelu(dest, src, param);
#else
 cpu::prelu(dest, src, param);
#endif
 }
 void prelu_gradient (
 tensor& grad,
 const tensor& src,
 const tensor& gradient_input,
 const tensor& param,
 tensor& params_grad 
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::prelu_gradient(grad, src, gradient_input, param, params_grad);
#else
 cpu::prelu_gradient(grad, src, gradient_input, param, params_grad);
#endif
 }
// ----------------------------------------------------------------------------------------
 void leaky_relu (
 tensor& dest,
 const tensor& src,
 const float alpha
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::leaky_relu(dest, src, alpha);
#else
 cpu::leaky_relu(dest, src, alpha);
#endif
 }
 void leaky_relu_gradient (
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input,
 const float alpha
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::leaky_relu_gradient(grad, dest, gradient_input, alpha);
#else
 cpu::leaky_relu_gradient(grad, dest, gradient_input, alpha);
#endif
 }
// ----------------------------------------------------------------------------------------
 void tanh (
 tensor& dest,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::tanh(dest,src);
#else
 cpu::tanh(dest,src);
#endif
 }
 void tanh_gradient (
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::tanh_gradient(grad, dest, gradient_input);
#else
 cpu::tanh_gradient(grad, dest, gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void clipped_relu (
 tensor& dest,
 const tensor& src,
 const float ceiling
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::clipped_relu(dest, src, ceiling);
#else
 cpu::clipped_relu(dest, src, ceiling);
#endif
 }
 void clipped_relu_gradient (
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input,
 const float ceiling
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::clipped_relu_gradient(grad, dest, gradient_input, ceiling);
#else
 cpu::clipped_relu_gradient(grad, dest, gradient_input, ceiling);
#endif
 }
// ----------------------------------------------------------------------------------------
 void elu (
 tensor& dest,
 const tensor& src,
 const float alpha
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::elu(dest, src, alpha);
#else
 cpu::elu(dest, src, alpha);
#endif
 }
 void elu_gradient (
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input,
 const float alpha
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::elu_gradient(grad, dest, gradient_input, alpha);
#else
 cpu::elu_gradient(grad, dest, gradient_input, alpha);
#endif
 }
// ----------------------------------------------------------------------------------------
 void gelu (
 tensor& dest,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::gelu(dest,src);
#else
 cpu::gelu(dest,src);
#endif
 }
 void gelu_gradient (
 tensor& grad,
 const tensor& src,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::gelu_gradient(grad, src, gradient_input);
#else
 cpu::gelu_gradient(grad, src, gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void smelu (
 tensor& dest,
 const tensor& src,
 const float beta
 )
 {
 DLIB_CASSERT(beta > 0);
#ifdef DLIB_USE_CUDA
 cuda::smelu(dest, src, beta);
#else
 cpu::smelu(dest, src, beta);
#endif
 }
 void smelu_gradient (
 tensor& grad,
 const tensor& dest,
 const tensor& gradient_input,
 const float beta
 )
 {
 DLIB_CASSERT(beta > 0);
#ifdef DLIB_USE_CUDA
 cuda::smelu_gradient(grad, dest, gradient_input, beta);
#else
 cpu::smelu_gradient(grad, dest, gradient_input, beta);
#endif
 }
// ----------------------------------------------------------------------------------------
 void silu (
 tensor& dest,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::silu(dest,src);
#else
 cpu::silu(dest,src);
#endif
 }
 void silu_gradient (
 tensor& grad,
 const tensor& src,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::silu_gradient(grad, src, gradient_input);
#else
 cpu::silu_gradient(grad, src, gradient_input);
#endif
 }
// ----------------------------------------------------------------------------------------
 void resize_bilinear (
 tensor& dest,
 long dest_row_stride,
 long dest_channel_stride,
 const tensor& src,
 long src_row_stride,
 long src_channel_stride
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::resize_bilinear(dest,dest_row_stride,dest_channel_stride, src,src_row_stride,src_channel_stride);
#else
 cpu::resize_bilinear(dest,dest_row_stride,dest_channel_stride, src,src_row_stride,src_channel_stride);
#endif
 }
 void resize_bilinear_gradient (
 tensor& grad,
 long grad_row_stride,
 long grad_channel_stride,
 const tensor& gradient_input,
 long gradient_input_row_stride,
 long gradient_input_channel_stride
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::resize_bilinear_gradient(grad,grad_row_stride,grad_channel_stride, gradient_input,gradient_input_row_stride,gradient_input_channel_stride);
#else
 cpu::resize_bilinear_gradient(grad,grad_row_stride,grad_channel_stride, gradient_input,gradient_input_row_stride,gradient_input_channel_stride);
#endif
 }
// ------------------------------------------------------------------------------------
 void reorg (
 bool add_to,
 tensor& dest,
 const int row_stride,
 const int col_stride,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::reorg(add_to, dest, row_stride, col_stride, src);
#else
 cpu::reorg(add_to, dest, row_stride, col_stride, src);
#endif
 }
 void reorg_gradient (
 bool add_to,
 tensor& grad,
 const int row_stride,
 const int col_stride,
 const tensor& gradient_input
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::reorg_gradient(add_to, grad, row_stride, col_stride, gradient_input);
#else
 cpu::reorg_gradient(add_to, grad, row_stride, col_stride, gradient_input);
#endif
 }
// ------------------------------------------------------------------------------------
 void copy_tensor(
 bool add_to,
 tensor& dest,
 size_t dest_k_offset,
 const tensor& src,
 size_t src_k_offset,
 size_t count_k
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::copy_tensor(add_to, dest, dest_k_offset, src, src_k_offset, count_k);
#else
 cpu::copy_tensor(add_to, dest, dest_k_offset, src, src_k_offset, count_k);
#endif
 }
// ----------------------------------------------------------------------------------------
 void copy_tensor(
 bool add_to,
 tensor& dest,
 size_t dk, size_t dnr, size_t dnc,
 const tensor& src,
 size_t sk, size_t snr, size_t snc,
 size_t k, size_t nr, size_t nc
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::copy_tensor(add_to, dest, dk, dnr, dnc , src, sk, snr, snc, k, nr, nc);
#else
 cpu::copy_tensor(add_to, dest, dk, dnr, dnc, src, sk, snr, snc, k, nr, nc);
#endif
 }
// ----------------------------------------------------------------------------------------
 void inv::
 operator() (
 const tensor& m,
 resizable_tensor& out
 )
 {
#ifdef DLIB_USE_CUDA
 finv(m,out);
#else
 out = dlib::inv(mat(m));
#endif
 }
// ----------------------------------------------------------------------------------------
 void transpose(
 bool add_to,
 tensor& dest,
 const tensor& src
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::transpose(add_to, dest, src);
#else
 cpu::transpose(add_to, dest, src);
#endif
 }
// ----------------------------------------------------------------------------------------
 void embeddings(
 resizable_tensor& dest,
 const tensor& src,
 const tensor& embs
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::embeddings(dest, src, embs);
#else
 cpu::embeddings(dest, src, embs);
#endif
 }
 void embeddings_gradient(
 const tensor& prev,
 const tensor& gradient_input,
 tensor& grads,
 const tensor& freqs,
 float learning_rate,
 bool scale
 )
 {
#ifdef DLIB_USE_CUDA
 cuda::embeddings_gradient(prev, gradient_input, grads, freqs, learning_rate, scale);
#else
 cpu::embeddings_gradient(prev, gradient_input, grads, freqs, learning_rate, scale);
#endif
 }
// ----------------------------------------------------------------------------------------
}}
#endif // DLIB_TeNSOR_TOOLS_CPP_