Struct ciphercore_base::ops::pwl::approx_sigmoid::ApproxSigmoid

pub struct ApproxSigmoid {
    pub precision: u64,
}

A structure that defines the custom operation ApproxSigmoid that computes an approximate Sigmoid(x / (2 ** precision)) * (2 ** precision) using piecewise-linear approximation.

Sigmoid is a very commonly used function in ML: Sigmoid(x) = 1 / (1 + exp(-x)). So far this operation supports only INT64 scalar type.

Custom operation arguments

• Node containing a signed 64-bit array or scalar to compute the sigmoid

Custom operation returns

New ApproxSigmoid node

Example

let c = create_context().unwrap();
let g = c.create_graph().unwrap();
let t = array_type(vec![3], INT64);
let x = g.input(t.clone()).unwrap();
let n = g.custom_op(CustomOperation::new(ApproxSigmoid {precision: 4}), vec![x]).unwrap();

Fields

precision: u64

Assume that we’re operating in fixed precision arithmetic with denominator 2 ** precision.

Trait Implementations

impl CustomOperationBody for ApproxSigmoid

fn instantiate( &self, context: Context, arguments_types: Vec<Type> ) -> Result<Graph>

Defines the logic of a custom operation.

fn get_name(&self) -> String

Specifies and returns the name of this custom operation.

impl Debug for ApproxSigmoid

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ApproxSigmoid

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ApproxSigmoid

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<ApproxSigmoid> for ApproxSigmoid

fn eq(&self, other: &ApproxSigmoid) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ApproxSigmoid

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ApproxSigmoid

impl StructuralEq for ApproxSigmoid

impl StructuralPartialEq for ApproxSigmoid