function_expression_builder.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

#pragma once

namespace etl {

template <etl_expr E>
auto sqrt(E&& value) -> detail::unary_helper<E, sqrt_unary_op> {
    return detail::unary_helper<E, sqrt_unary_op>{value};
}

template <etl_expr E>
auto invsqrt(E&& value) -> detail::unary_helper<E, invsqrt_unary_op> {
    return detail::unary_helper<E, invsqrt_unary_op>{value};
}

template <etl_expr E>
auto cbrt(E&& value) -> detail::unary_helper<E, cbrt_unary_op> {
    return detail::unary_helper<E, cbrt_unary_op>{value};
}

template <etl_expr E>
auto invcbrt(E&& value) -> detail::unary_helper<E, invcbrt_unary_op> {
    return detail::unary_helper<E, invcbrt_unary_op>{value};
}

template <etl_expr E>
auto log(E&& value) -> detail::unary_helper<E, log_unary_op> {
    return detail::unary_helper<E, log_unary_op>{value};
}

template <etl_expr E>
auto log2(E&& value) -> detail::unary_helper<E, log2_unary_op> {
    return detail::unary_helper<E, log2_unary_op>{value};
}

template <etl_expr E>
auto log10(E&& value) -> detail::unary_helper<E, log10_unary_op> {
    return detail::unary_helper<E, log10_unary_op>{value};
}

template <etl_expr E>
auto tan(E&& value) -> detail::unary_helper<E, tan_unary_op> {
    return detail::unary_helper<E, tan_unary_op>{value};
}

template <etl_expr E>
auto cos(E&& value) -> detail::unary_helper<E, cos_unary_op> {
    return detail::unary_helper<E, cos_unary_op>{value};
}

template <etl_expr E>
auto sin(E&& value) -> detail::unary_helper<E, sin_unary_op> {
    return detail::unary_helper<E, sin_unary_op>{value};
}

template <etl_expr E>
auto tanh(E&& value) -> detail::unary_helper<E, tanh_unary_op> {
    return detail::unary_helper<E, tanh_unary_op>{value};
}

template <etl_expr E>
auto cosh(E&& value) -> detail::unary_helper<E, cosh_unary_op> {
    return detail::unary_helper<E, cosh_unary_op>{value};
}

template <etl_expr E>
auto sinh(E&& value) -> detail::unary_helper<E, sinh_unary_op> {
    return detail::unary_helper<E, sinh_unary_op>{value};
}

template <etl_expr E>
auto exp(E&& value) -> detail::unary_helper<E, exp_unary_op> {
    return detail::unary_helper<E, exp_unary_op>{value};
}

template <etl_expr E>
auto sign(E&& value) -> detail::unary_helper<E, sign_unary_op> {
    return detail::unary_helper<E, sign_unary_op>{value};
}

template <typename E>
decltype(auto) identity(E&& value) {
    return std::forward<E>(value);
}

template <typename E>
auto identity_derivative([[maybe_unused]] E&& value) {
    return 1.0;
}

//Note: Use of decltype here should not be necessary, but g++ does
//not like it without it for some reason

template <etl_expr E>
auto sigmoid(const E& value) -> detail::unary_helper<E, sigmoid_unary_op> {
    return detail::unary_helper<E, sigmoid_unary_op>{value};
}

template <etl_expr E>
auto relu(const E& value) -> detail::unary_helper<E, relu_unary_op> {
    return detail::unary_helper<E, relu_unary_op>{value};
}

template <etl_expr E>
auto sigmoid_derivative(E&& value) -> decltype(sigmoid(value) >> (1.0 - sigmoid(value))) {
    return sigmoid(value) >> (1.0 - sigmoid(value));
}

template <etl_expr E>
auto fast_sigmoid(const E& value) -> detail::unary_helper<E, fast_sigmoid_unary_op> {
    return detail::unary_helper<E, fast_sigmoid_unary_op>{value};
}

template <etl_expr E>
auto hard_sigmoid(E&& x) -> decltype(etl::clip(x * 0.2 + 0.5, 0.0, 1.0)) {
    return etl::clip(x * 0.2 + 0.5, 0.0, 1.0);
}

template <etl_expr E>
auto softmax(E&& e) {
    if constexpr (etl::is_1d<E>) {
        return exp(e) / sum(exp(e));
    } else {
        return batch_softmax_expr<detail::build_type<E>, false>{e};
    }
}

template <etl_expr E>
auto stable_softmax(E&& e) {
    if constexpr (etl::is_1d<E>) {
        auto m = max(e);
        return exp(e - m) / sum(exp(e - m));
    } else {
        return batch_softmax_expr<detail::build_type<E>, true>{e};
    }
}

template <typename E>
auto softmax_derivative([[maybe_unused]] E&& e) {
    return 1.0;
}

template <etl_expr E>
auto softplus(E&& value) -> detail::unary_helper<E, softplus_unary_op> {
    return detail::unary_helper<E, softplus_unary_op>{value};
}

template <etl_expr E>
auto bernoulli(const E& value) -> detail::unary_helper<E, bernoulli_unary_op> {
    return detail::unary_helper<E, bernoulli_unary_op>{value};
}

template <typename E, typename G>
auto bernoulli(G& g, E&& value) {
    return detail::make_stateful_unary_expr<E, bernoulli_unary_g_op<G, value_t<E>>>(value, g);
}

template <etl_expr E>
auto state_bernoulli(const E& value) {
    return detail::make_stateful_unary_expr<E, state_bernoulli_unary_op<value_t<E>>>(value);
}

template <etl_expr E>
auto state_bernoulli(const E& value, const std::shared_ptr<void*> & states) {
    return detail::make_stateful_unary_expr<E, state_bernoulli_unary_op<value_t<E>>>(value, states);
}

template <etl_expr E, typename G>
auto state_bernoulli(G& g, E&& value) {
    return detail::make_stateful_unary_expr<E, state_bernoulli_unary_g_op<G, value_t<E>>>(value, g);
}

template <etl_expr E, typename G>
auto state_bernoulli(G& g, E&& value, const std::shared_ptr<void*> & states) {
    return detail::make_stateful_unary_expr<E, state_bernoulli_unary_g_op<G, value_t<E>>>(value, g, states);
}

template <etl_expr E>
auto r_bernoulli(const E& value) -> detail::unary_helper<E, reverse_bernoulli_unary_op> {
    return detail::unary_helper<E, reverse_bernoulli_unary_op>{value};
}

template <etl_expr E, typename G>
auto r_bernoulli(G& g, E&& value) {
    return detail::make_stateful_unary_expr<E, reverse_bernoulli_unary_g_op<G, value_t<E>>>(value, g);
}

template <etl_expr E>
auto tanh_derivative(E&& value) -> decltype(1.0 - (tanh(value) >> tanh(value))) {
    return 1.0 - (tanh(value) >> tanh(value));
}

template <etl_expr E>
auto relu_derivative(const E& value) -> detail::unary_helper<E, relu_derivative_op> {
    return detail::unary_helper<E, relu_derivative_op>{value};
}

} //end of namespace etl