Struct intricate::layers::initializers::ConstantInitializer

pub struct ConstantInitializer {
    pub constant: f32,
}

A Initializer that pretty much just initializes all values of a parameter with a constat value provided by the new method

Fields

constant: f32

The constant that all the parameters will be

Implementations

impl ConstantInitializer

pub fn new(constant: f32) -> Self

Creates a new Constant initializer

Examples found in repository

src/layers/conv2d.rs (line 147)

    pub fn new_raw(inputs_size: (usize, usize), filter_size: (usize, usize)) -> Self {
        let mut initializers = HashMap::with_capacity(2);
        initializers.insert(
            "weights".to_string(),
            GlorotUniformInitializer::new().into(),
        );
        initializers.insert("biases".to_string(), ConstantInitializer::new(0.0).into());

        Conv2D {
            inputs_size,
            filter_size,
            weights: Vec::default(),
            biases: Vec::default(),
            initializers,
            weights_buff: None,
            biases_buff: None,
            last_inputs_buffer: None,
            last_outputs_buffer: None,
            opencl_state: None,
        }
    }

src/layers/dense.rs (line 135)

    pub fn new_raw(inputs_amount: usize, outputs_amount: usize) -> Dense<'a> {
        let mut initializers = HashMap::with_capacity(2);
        initializers.insert("weights".to_string(), GlorotUniformInitializer::new().into());
        initializers.insert("biases".to_string(), ConstantInitializer::new(0.0).into());

        Dense {
            inputs_amount,
            outputs_amount,

            initializers,

            weights: Vec::default(),
            biases: Vec::default(),

            weights_buffer: None,
            biases_buffer: None,

            last_inputs_buffer: None,
            last_outputs_buffer: None,

            opencl_state: None,
        }
        .into() // because ModelLayer implements From<Dense>
    }

Trait Implementations

impl Clone for ConstantInitializer

fn clone(&self) -> ConstantInitializer

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ConstantInitializer

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

Formats the value using the given formatter.

impl Deserialize for ConstantInitializer

fn deserialize(
    deserializer: &mut Deserializer<'_>
) -> Result<Self, SavefileError>

Deserialize and return an instance of Self from the given deserializer.

impl From<ConstantInitializer> for Initializer

fn from(v: ConstantInitializer) -> Self

Converts to this type from the input type.

impl InitializerTrait for ConstantInitializer

fn initialize_0d<'a>(&self, _: &dyn Layer<'a>) -> f32

Generates just one number based on the Initializer’s implementation

fn initialize_1d<'a>(&self, count: usize, layer: &dyn Layer<'a>) -> Vec<f32>

Generates a Vec of numbers initialized based on the Initializer’s implementation

fn initialize_2d<'a>(
    &self,
    shape: (usize, usize),
    layer: &dyn Layer<'a>
) -> Vec<Vec<f32>>

Generates a Matrix of numbers initialized based on the Initializer’s implementation

fn initialize_3d<'a>(
    &self,
    shape: (usize, usize, usize),
    layer: &dyn Layer<'a>
) -> Vec<Vec<Vec<f32>>>

Generates a 3D Matrix of Vec of numbers initialized based on the Initializer’s implementation

impl Introspect for ConstantInitializer

fn introspect_value(&self) -> String

Returns the value of the object, excluding children, as a string. Exactly what the value returned here is depends on the type. For some types, like a plain array, there isn’t much of a value, the entire information of object resides in the children. For other cases, like a department in an organisation, it might make sense to have the value be the name, and have all the other properties as children.

fn introspect_child(
    &self,
    index: usize
) -> Option<Box<dyn IntrospectItem<'_> + '_>>

Returns an the name and &dyn Introspect for the child with the given index, or if no child with that index exists, None. All the children should be indexed consecutively starting at 0 with no gaps, all though there isn’t really anything stopping the user of the trait to have any arbitrary index strategy, consecutive numbering 0, 1, 2, … etc is strongly encouraged.

fn introspect_len(&self) -> usize

Returns the total number of children. The default implementation calculates this by simply calling introspect_child with higher and higher indexes until it returns None. It gives up if the count reaches 10000. If your type can be bigger and you want to be able to introspect it, override this method.

impl Serialize for ConstantInitializer

fn serialize(&self, serializer: &mut Serializer<'_>) -> Result<(), SavefileError>

Serialize self into the given serializer.

impl WithSchema for ConstantInitializer

fn schema(version: u32) -> Schema

Returns a representation of the schema used by this Serialize implementation for the given version.