ActivationDispatch.h

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <deepity/utils/ActivationType.h>
#include <deepity/utils/activations/ActivationMacros.h>

 
namespace Deep
{
    using ActivationFn = void (*)(float *, size_t);
    using DerivativeFn = void (*)(float *, size_t, bool);
    // Two-buffer variant: reads from src, writes the derivative directly
    // into dst, in one pass. Eliminates the copy-then-derive pattern
    // (cblas_scopy + DerivativeFn) callers currently need when they can't
    // afford to mutate src in place -- src stays untouched throughout.
    using DerivativeFn2 = void (*)(float *RESTRICT, const float *RESTRICT, size_t);
 
    // Forward declarations only -- the real definitions (and their full
    // docs) live in the sibling Relu.h/Gelu.h/Tanh.h/Sigmoid.h/Linear.h,
    // one activation family per header. @copydoc isn't usable here: with
    // both this declaration and the real one in the same Deep namespace,
    // Doxygen resolves "Deep::relu" back to whichever declaration it's
    // attached to, so it self-references instead of finding the other one.

    static inline void relu(float *, size_t) noexcept;
    static inline void gelu(float *, size_t) noexcept;
    static inline void sigmoid(float *, size_t) noexcept;
    static inline void e_sigmoid(float *, size_t) noexcept;
    static inline void tanh(float *, size_t) noexcept;
    static inline void linear(float *, size_t) noexcept;

    static inline void dRelu(float *, size_t, bool) noexcept;
    static inline void dGelu(float *, size_t, bool) noexcept;
    static inline void dSigmoid(float *, size_t, bool) noexcept;
    static inline void d_eSigmoid(float *, size_t, bool) noexcept;
    static inline void dTanh(float *, size_t, bool) noexcept;
    static inline void dLinear(float *, size_t, bool) noexcept;

    static inline void dReluInto(float *RESTRICT, const float *RESTRICT, size_t) noexcept;
    static inline void dGeluInto(float *RESTRICT, const float *RESTRICT, size_t) noexcept;
    static inline void dSigmoidInto(float *RESTRICT, const float *RESTRICT, size_t) noexcept;
    static inline void d_eSigmoidInto(float *RESTRICT, const float *RESTRICT, size_t) noexcept;
    static inline void dTanhInto(float *RESTRICT, const float *RESTRICT, size_t) noexcept;
    static inline void dLinearInto(float *RESTRICT, const float *RESTRICT, size_t) noexcept;

    static inline ActivationFn To_Fn(ActivationType type)
    {
        switch (type)
        {
        case ActivationType::RELU:
            return relu;
        case ActivationType::GELU:
            return gelu;
        case ActivationType::SIGMOID:
            return sigmoid;
        case ActivationType::eSIGMOID:
            return e_sigmoid;
        case ActivationType::TANH:
            return tanh;
        case ActivationType::LINEAR:
            return linear;
        case ActivationType::NONE:
        default:
            return nullptr;
        }
    }

    static inline DerivativeFn To_dFn(ActivationType dType)
    {
        switch (dType)
        {
        case ActivationType::dRELU:
            return dRelu;
        case ActivationType::dGELU:
            return dGelu;
        case ActivationType::dSIGMOID:
            return dSigmoid;
        case ActivationType::d_eSIGMOID:
            return d_eSigmoid;
        case ActivationType::dTANH:
            return dTanh;
        case ActivationType::dLINEAR:
            return dLinear;
        case ActivationType::NONE:
        default:
            return nullptr;
        }
    }

    static inline DerivativeFn2 To_dFn2(ActivationType dType)
    {
        switch (dType)
        {
        case ActivationType::dRELU:
            return dReluInto;
        case ActivationType::dGELU:
            return dGeluInto;
        case ActivationType::dSIGMOID:
            return dSigmoidInto;
        case ActivationType::d_eSIGMOID:
            return d_eSigmoidInto;
        case ActivationType::dTANH:
            return dTanhInto;
        case ActivationType::dLINEAR:
            return dLinearInto;
        case ActivationType::NONE:
        default:
            return nullptr;
        }
    }

    static inline ActivationType To_AType(ActivationFn fn)
    {
        if (fn == relu)
            return ActivationType::RELU;
        if (fn == gelu)
            return ActivationType::GELU;
        if (fn == sigmoid)
            return ActivationType::SIGMOID;
        if (fn == e_sigmoid)
            return ActivationType::eSIGMOID;
        if (fn == tanh)
            return ActivationType::TANH;
        if (fn == linear)
            return ActivationType::LINEAR;
        return ActivationType::NONE;
    }

    static inline ActivationType To_AType(DerivativeFn dfn)
    {
        if (dfn == dRelu)
            return ActivationType::dRELU;
        if (dfn == dGelu)
            return ActivationType::dGELU;
        if (dfn == dSigmoid)
            return ActivationType::dSIGMOID;
        if (dfn == d_eSigmoid)
            return ActivationType::d_eSIGMOID;
        if (dfn == dTanh)
            return ActivationType::dTANH;
        if (dfn == dLinear)
            return ActivationType::dLINEAR;
        return ActivationType::NONE;
    }
} // namespace Deep