Expression Templates Library (ETL)
cce.hpp
Go to the documentation of this file.
1 //=======================================================================
2 // Copyright (c) 2014-2023 Baptiste Wicht
3 // Distributed under the terms of the MIT License.
4 // (See accompanying file LICENSE or copy at
5 // http://opensource.org/licenses/MIT)
6 //=======================================================================
7 
16 #pragma once
17 
18 //Include the implementations
19 #include "etl/impl/std/cce.hpp"
20 #include "etl/impl/egblas/cce.hpp"
21 
22 namespace etl::detail {
23 
30 template <typename O, typename L>
31 constexpr etl::cce_impl select_cce_impl() {
32  if (impl::egblas::has_scce && impl::egblas::has_dcce) {
33  return etl::cce_impl::EGBLAS;
34  }
35 
36  return etl::cce_impl::STD;
37 }
38 
45 template <typename O, typename L>
46 constexpr etl::cce_impl select_cce_loss_impl() {
47  if (impl::egblas::has_cce_sloss && impl::egblas::has_cce_dloss) {
48  return etl::cce_impl::EGBLAS;
49  }
50 
51  return etl::cce_impl::STD;
52 }
53 
60 template <typename O, typename L>
61 constexpr etl::cce_impl select_cce_error_impl() {
62  if (impl::egblas::has_cce_serror && impl::egblas::has_cce_derror) {
63  return etl::cce_impl::EGBLAS;
64  }
65 
66  return etl::cce_impl::STD;
67 }
68 
72 struct cce_impl {
76  template <typename O, typename L>
77  static std::pair<value_t<O>, value_t<O>> apply(const O& output, const L& labels, value_t<O> alpha, value_t<O> beta) {
78  constexpr auto impl = select_cce_impl<O, L>();
79 
80  if constexpr (impl == etl::cce_impl::STD) {
81  etl::force(output);
82  etl::force(labels);
83 
84  return impl::standard::cce(output, labels, alpha, beta);
85  } else if constexpr (impl == etl::cce_impl::EGBLAS) {
86  decltype(auto) output_gpu = smart_forward_gpu(output);
87  decltype(auto) labels_gpu = smart_forward_gpu(labels);
88 
89  output_gpu.ensure_gpu_up_to_date();
90  labels_gpu.ensure_gpu_up_to_date();
91 
92  return impl::egblas::cce(etl::dim<0>(output), etl::dim<1>(output), alpha, beta, output_gpu.gpu_memory(), labels_gpu.gpu_memory());
93  } else {
94  cpp_unreachable("Invalid selection for CCE");
95  }
96  }
97 };
98 
102 struct cce_loss_impl {
106  template <typename O, typename L>
107  static value_t<O> apply(const O& output, const L& labels, value_t<O> scale) {
108  constexpr auto impl = select_cce_loss_impl<O, L>();
109 
110  if constexpr (impl == etl::cce_impl::STD) {
111  etl::force(output);
112  etl::force(labels);
113 
114  return impl::standard::cce_loss(output, labels, scale);
115  } else if constexpr (impl == etl::cce_impl::EGBLAS) {
116  decltype(auto) output_gpu = smart_forward_gpu(output);
117  decltype(auto) labels_gpu = smart_forward_gpu(labels);
118 
119  output_gpu.ensure_gpu_up_to_date();
120  labels_gpu.ensure_gpu_up_to_date();
121 
122  return impl::egblas::cce_loss(etl::size(output), scale, output_gpu.gpu_memory(), 1, labels_gpu.gpu_memory(), 1);
123  } else {
124  cpp_unreachable("Invalid selection for CCE");
125  }
126  }
127 };
128 
132 struct cce_error_impl {
136  template <typename O, typename L>
137  static value_t<O> apply(const O& output, const L& labels, value_t<O> scale) {
138  constexpr auto impl = select_cce_error_impl<O, L>();
139 
140  if constexpr (impl == etl::cce_impl::STD) {
141  etl::force(output);
142  etl::force(labels);
143 
144  return impl::standard::cce_error(output, labels, scale);
145  } else if constexpr (impl == etl::cce_impl::EGBLAS) {
146  decltype(auto) output_gpu = smart_forward_gpu(output);
147  decltype(auto) labels_gpu = smart_forward_gpu(labels);
148 
149  output_gpu.ensure_gpu_up_to_date();
150  labels_gpu.ensure_gpu_up_to_date();
151 
152  return impl::egblas::cce_error(etl::dim<0>(output), etl::dim<1>(output), scale, output_gpu.gpu_memory(), labels_gpu.gpu_memory());
153  } else {
154  cpp_unreachable("Invalid selection for CCE");
155  }
156  }
157 };
158 
159 } //end of namespace etl::detail
etl::detail::cce_impl::apply
static std::pair< value_t< O >, value_t< O > > apply(const O &output, const L &labels, value_t< O > alpha, value_t< O > beta)
Apply the functor to e.
Definition: cce.hpp:77
cce.hpp
EGBLAS wrappers for the cce operations.
etl::detail::select_cce_error_impl
constexpr etl::cce_impl select_cce_error_impl()
Select the CCE implementation for an expression of type E.
Definition: cce.hpp:61
etl::batch_softmax_impl::STD
Standard implementation.
etl::force
void force(Expr &&expr)
Force the internal evaluation of an expression.
Definition: evaluator.hpp:1292
etl::detail
Definition: expression_builder.hpp:699
etl::detail::cce_error_impl
Sum operation implementation.
Definition: cce.hpp:132
etl::bce_impl::EGBLAS
GPU implementation.
etl::detail::select_cce_impl
constexpr etl::cce_impl select_cce_impl()
Select the CCE implementation for an expression of type E.
Definition: cce.hpp:31
etl::cce_impl
cce_impl
Enumeration describing the different implementations of CCE.
Definition: cce_impl.hpp:20
etl::scale
auto scale(LE &&lhs, RE &&rhs)
Builds an expression representing the scalar multiplication of lhs and rhs.
Definition: binary_expression_builder.hpp:64
etl::detail::cce_loss_impl
Sum operation implementation.
Definition: cce.hpp:102
cce.hpp
Standard implementation of the Categorical Cross Entropy reduction.
etl::detail::select_cce_loss_impl
constexpr etl::cce_impl select_cce_loss_impl()
Select the CCE implementation for an expression of type E.
Definition: cce.hpp:46
etl::smart_forward_gpu
decltype(auto) smart_forward_gpu(E &expr)
Smart forwarding for a temporary expression that will be computed in GPU.
Definition: helpers.hpp:343
etl::size
constexpr size_t size(const E &expr) noexcept
Returns the size of the given ETL expression.
Definition: helpers.hpp:108
etl::detail::cce_error_impl::apply
static value_t< O > apply(const O &output, const L &labels, value_t< O > scale)
Apply the functor to e.
Definition: cce.hpp:137
etl::value_t
typename decay_traits< E >::value_type value_t
Traits to extract the value type out of an ETL type.
Definition: tmp.hpp:81
etl::detail::cce_impl
Sum operation implementation.
Definition: cce.hpp:72
etl::detail::cce_loss_impl::apply
static value_t< O > apply(const O &output, const L &labels, value_t< O > scale)
Apply the functor to e.
Definition: cce.hpp:107
Generated by   doxygen 1.8.13