sigmoid.hpp

//=======================================================================
// 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

#include "etl/impl/cudnn/sigmoid.hpp"
#include "etl/impl/egblas/sigmoid.hpp"

namespace etl {

template <typename T>
struct sigmoid_unary_op {
    static constexpr bool linear      = true; 
    static constexpr bool thread_safe = true; 

    template <vector_mode_t V>
    static constexpr bool vectorizable =
        (V == vector_mode_t::SSE3 && !is_complex_t<T>) || (V == vector_mode_t::AVX && !is_complex_t<T>) || (intel_compiler && !is_complex_t<T>);

    template <typename E>
    static constexpr bool gpu_computable = is_floating<E>&& cudnn_enabled;

    static constexpr int complexity() {
        return 12;
    }

    template <typename V = default_vec>
    using vec_type = typename V::template vec_type<T>;

    static constexpr T apply(const T& x) {
        return math::logistic_sigmoid(x);
    }

    template <typename V = default_vec>
    static vec_type<V> load(const vec_type<V>& x) noexcept {
        auto one = V::set(T(1));

        auto t1 = V::minus(x);
        auto t2 = V::exp(t1);
        auto t3 = V::add(one, t2);
        return V::div(one, t3);
    }

    template <typename X, typename Y>
    static auto gpu_compute_hint(const X& x, Y& y) noexcept {
        decltype(auto) t1 = smart_gpu_compute_hint(x, y);

        auto t2 = force_temporary_gpu_dim_only(t1);

        auto n = etl::size(x);

        if (n < 8 * 1024 * 1024 && is_single_precision<Y> && impl::egblas::has_ssigmoid) {
            impl::egblas::sigmoid(n, 1, t1.gpu_memory(), 1, t2.gpu_memory(), 1);
        } else if (n < 1024 * 1024 && is_double_precision<Y> && impl::egblas::has_dsigmoid) {
            impl::egblas::sigmoid(n, 1, t1.gpu_memory(), 1, t2.gpu_memory(), 1);
        } else {
            impl::cudnn::sigmoid(t1, t2);
        }

        return t2;
    }
    template <typename X, typename Y>
    static Y& gpu_compute(const X& x, Y& y) noexcept {
        decltype(auto) t1 = select_smart_gpu_compute(x, y);

        auto n = etl::size(x);

        if (n < 8 * 1024 * 1024 && is_single_precision<Y> && impl::egblas::has_ssigmoid) {
            impl::egblas::sigmoid(n, 1, t1.gpu_memory(), 1, y.gpu_memory(), 1);

            y.validate_gpu();
            y.invalidate_cpu();
        } else if (n < 1024 * 1024 && is_double_precision<Y> && impl::egblas::has_dsigmoid) {
            impl::egblas::sigmoid(n, 1, t1.gpu_memory(), 1, y.gpu_memory(), 1);

            y.validate_gpu();
            y.invalidate_cpu();
        } else {
            impl::cudnn::sigmoid(t1, y);
        }

        return y;
    }

    static std::string desc() noexcept {
        return "sigmoid";
    }
};

template <typename T>
struct fast_sigmoid_unary_op {
    static constexpr bool linear      = true; 
    static constexpr bool thread_safe = true; 

    template <vector_mode_t V>
    static constexpr bool vectorizable = false;

    template <typename E>
    static constexpr bool gpu_computable = false;

    static constexpr int complexity() {
        return 4;
    }

    static T apply(const T& v) {
        auto x = 0.5 * v;

        T z;
        if (x >= 0) {
            if (x < 1.7) {
                z = (1.5 * x / (1 + x));
            } else if (x < 3) {
                z = (0.935409070603099 + 0.0458812946797165 * (x - 1.7));
            } else {
                z = 0.99505475368673;
            }
        } else {
            auto xx = -x;
            if (xx < 1.7) {
                z = (1.5 * xx / (1 + xx));
            } else if (xx < 3) {
                z = (0.935409070603099 + 0.0458812946797165 * (xx - 1.7));
            } else {
                z = 0.99505475368673;
            }
            z = -z;
        }

        return 0.5 * (z + 1.0);
    }

    static std::string desc() noexcept {
        return "fast_sigmoid";
    }
};

} //end of namespace etl