use crate::module::{Module, ModuleError};
use coeus_autograd::Var;
use coeus_core::{Float, Scalar};
#[inline]
pub fn relu<T: Scalar, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::relu(input)
}
#[derive(Clone, Debug, Default)]
pub struct ReLU;
impl<T: Scalar, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for ReLU {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(relu(input)?)
}
}
#[inline]
pub fn sigmoid<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::sigmoid(input)
}
#[derive(Clone, Debug, Default)]
pub struct Sigmoid;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for Sigmoid {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(sigmoid(input)?)
}
}
#[inline]
pub fn tanh<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::tanh(input)
}
#[derive(Clone, Debug, Default)]
pub struct Tanh;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for Tanh {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(tanh(input)?)
}
}
#[inline]
pub fn gelu<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::gelu(input)
}
#[derive(Clone, Debug, Default)]
pub struct GeLU;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for GeLU {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(gelu(input)?)
}
}
#[inline]
pub fn silu<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::silu(input)
}
#[derive(Clone, Debug, Default)]
pub struct SiLU;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for SiLU {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(silu(input)?)
}
}
#[inline]
pub fn mish<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::mish(input)
}
#[derive(Clone, Debug, Default)]
pub struct Mish;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for Mish {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(mish(input)?)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct HardsigmoidOp;
impl HardsigmoidOp {
pub const OP_NAME: &'static str = "hardsigmoid";
}
#[inline]
pub fn hardsigmoid<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::hardsigmoid(input)
}
#[derive(Clone, Debug, Default)]
pub struct Hardsigmoid;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for Hardsigmoid {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(hardsigmoid(input)?)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct HardswishOp;
impl HardswishOp {
pub const OP_NAME: &'static str = "hardswish";
}
#[inline]
pub fn hardswish<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::hardswish(input)
}
#[derive(Clone, Debug, Default)]
pub struct Hardswish;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for Hardswish {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(hardswish(input)?)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SoftsignOp;
impl SoftsignOp {
pub const OP_NAME: &'static str = "softsign";
}
#[inline]
pub fn softsign<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::softsign(input)
}
#[derive(Clone, Debug, Default)]
pub struct Softsign;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for Softsign {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(softsign(input)?)
}
}
#[inline]
pub fn softplus<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::softplus(input)
}
#[derive(Clone, Debug, Default)]
pub struct Softplus;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for Softplus {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(softplus(input)?)
}
}
#[inline]
pub fn log_sigmoid<T: Float, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::neg(&coeus_autograd::softplus(&coeus_autograd::neg(input)?)?)
}
#[derive(Clone, Debug, Default)]
pub struct LogSigmoid;
impl<T: Float, B: coeus_ops::BackendOps<T> + Default> Module<T, B> for LogSigmoid {
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(log_sigmoid(input)?)
}
}
#[inline]
pub fn tanhshrink<T: Float + coeus_cpu::RealScalar, B: coeus_ops::BackendOps<T> + Default>(
input: &Var<T, B>,
) -> Result<Var<T, B>, B::Error> {
coeus_autograd::sub(input, &coeus_autograd::tanh(input)?)
}
#[derive(Clone, Debug, Default)]
pub struct Tanhshrink;
impl<T: Float + coeus_cpu::RealScalar, B: coeus_ops::BackendOps<T> + Default> Module<T, B>
for Tanhshrink
{
#[inline]
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
#[inline]
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
Ok(tanhshrink(input)?)
}
}