Struct opencv::dnn::GRULayer

pub struct GRULayer { /* private fields */ }

GRU recurrent one-layer

Accepts input sequence and computes the final hidden state for each element in the batch.

• input[0] containing the features of the input sequence. input[0] should have shape [T, N, data_dims] where T is sequence length, N is batch size, data_dims is input size
• output would have shape [T, N, D * hidden_size] where D = 2 if layer is bidirectional otherwise D = 1

Depends on the following attributes:

• hidden_size - Number of neurons in the hidden layer
• direction - RNN could be bidirectional or forward

The final hidden state @f$ h_t @f$ computes by the following formulas:

@f{eqnarray*}{ r_t = \sigma(W_{ir} x_t + b_{ir} + W_{hr} h_{(t-1)} + b_{hr}) \ z_t = \sigma(W_{iz} x_t + b_{iz} + W_{hz} h_{(t-1)} + b_{hz}) \ n_t = \tanh(W_{in} x_t + b_{in} + r_t \odot (W_{hn} h_{(t-1)}+ b_{hn})) \ h_t = (1 - z_t) \odot n_t + z_t \odot h_{(t-1)} \ @f} Where @f$x_t@f$ is current input, @f$h_{(t-1)}@f$ is previous or initial hidden state.

@f$W_{x?}@f$, @f$W_{h?}@f$ and @f$b_{?}@f$ are learned weights represented as matrices: @f$W_{x?} \in R^{N_h \times N_x}@f$, @f$W_{h?} \in R^{N_h \times N_h}@f$, @f$b_? \in R^{N_h}@f$.

@f$\odot@f$ is per-element multiply operation.

Implementations

impl GRULayer

pub fn create(params: &LayerParams) -> Result<Ptr<GRULayer>>

Creates instance of GRU layer

Trait Implementations

impl AlgorithmTrait for GRULayer

fn as_raw_mut_Algorithm(&mut self) -> *mut c_void

fn clear(&mut self) -> Result<()>

Clears the algorithm state

fn read(&mut self, fn_: &FileNode) -> Result<()>

Reads algorithm parameters from a file storage

impl AlgorithmTraitConst for GRULayer

fn as_raw_Algorithm(&self) -> *const c_void

fn write(&self, fs: &mut FileStorage) -> Result<()>

Stores algorithm parameters in a file storage

fn write_with_name(&self, fs: &Ptr<FileStorage>, name: &str) -> Result<()>

simplified API for language bindings Stores algorithm parameters in a file storage

fn empty(&self) -> Result<bool>

Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

fn save(&self, filename: &str) -> Result<()>

Saves the algorithm to a file. In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

fn get_default_name(&self) -> Result<String>

Returns the algorithm string identifier. This string is used as top level xml/yml node tag when the object is saved to a file or string.

impl Boxed for GRULayer

unsafe fn from_raw(ptr: *mut c_void) -> Self

Wrap the specified raw pointer

fn into_raw(self) -> *mut c_void

Return an the underlying raw pointer while consuming this wrapper.

fn as_raw(&self) -> *const c_void

Return the underlying raw pointer.

fn as_raw_mut(&mut self) -> *mut c_void

Return the underlying mutable raw pointer

impl Drop for GRULayer

fn drop(&mut self)

Executes the destructor for this type.

impl From<GRULayer> for Algorithm

fn from(s: GRULayer) -> Self

Converts to this type from the input type.

impl From<GRULayer> for Layer

fn from(s: GRULayer) -> Self

Converts to this type from the input type.

impl GRULayerTrait for GRULayer

fn as_raw_mut_GRULayer(&mut self) -> *mut c_void

impl GRULayerTraitConst for GRULayer

fn as_raw_GRULayer(&self) -> *const c_void

impl LayerTrait for GRULayer

fn as_raw_mut_Layer(&mut self) -> *mut c_void

fn set_blobs(&mut self, val: Vector<Mat>)

List of learned parameters must be stored here to allow read them by using Net::getParam().

fn set_name(&mut self, val: &str)

Name of the layer instance, can be used for logging or other internal purposes.

fn set_type(&mut self, val: &str)

Type name which was used for creating layer by layer factory.

fn set_preferable_target(&mut self, val: i32)

prefer target for layer forwarding

fn finalize(
    &mut self,
    inputs: &dyn ToInputArray,
    outputs: &mut dyn ToOutputArray
) -> Result<()>

Computes and sets internal parameters according to inputs, outputs and blobs.

fn forward_mat(
    &mut self,
    input: &mut Vector<Mat>,
    output: &mut Vector<Mat>,
    internals: &mut Vector<Mat>
) -> Result<()>

👎Deprecated:

Use Layer::forward(InputArrayOfArrays, OutputArrayOfArrays, OutputArrayOfArrays) instead

Given the @p input blobs, computes the output @p blobs.

fn forward(
    &mut self,
    inputs: &dyn ToInputArray,
    outputs: &mut dyn ToOutputArray,
    internals: &mut dyn ToOutputArray
) -> Result<()>

Given the @p input blobs, computes the output @p blobs.

fn try_quantize(
    &mut self,
    scales: &Vector<Vector<f32>>,
    zeropoints: &Vector<Vector<i32>>,
    params: &mut LayerParams
) -> Result<bool>

Tries to quantize the given layer and compute the quantization parameters required for fixed point implementation.

fn forward_fallback(
    &mut self,
    inputs: &dyn ToInputArray,
    outputs: &mut dyn ToOutputArray,
    internals: &mut dyn ToOutputArray
) -> Result<()>

Given the @p input blobs, computes the output @p blobs.

fn finalize_mat_to(
    &mut self,
    inputs: &Vector<Mat>,
    outputs: &mut Vector<Mat>
) -> Result<()>

👎Deprecated:

Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

Computes and sets internal parameters according to inputs, outputs and blobs.

fn finalize_mat(&mut self, inputs: &Vector<Mat>) -> Result<Vector<Mat>>

👎Deprecated:

Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

Computes and sets internal parameters according to inputs, outputs and blobs.

fn run(
    &mut self,
    inputs: &Vector<Mat>,
    outputs: &mut Vector<Mat>,
    internals: &mut Vector<Mat>
) -> Result<()>

👎Deprecated:

This method will be removed in the future release.

Allocates layer and computes output.

fn input_name_to_index(&mut self, input_name: &str) -> Result<i32>

Returns index of input blob into the input array.

fn output_name_to_index(&mut self, output_name: &str) -> Result<i32>

Returns index of output blob in output array.

fn support_backend(&mut self, backend_id: i32) -> Result<bool>

Ask layer if it support specific backend for doing computations.

fn init_halide(
    &mut self,
    inputs: &Vector<Ptr<dyn BackendWrapper>>
) -> Result<Ptr<BackendNode>>

Returns Halide backend node.

fn init_ngraph(
    &mut self,
    inputs: &Vector<Ptr<dyn BackendWrapper>>,
    nodes: &Vector<Ptr<BackendNode>>
) -> Result<Ptr<BackendNode>>

fn init_vk_com(
    &mut self,
    inputs: &Vector<Ptr<dyn BackendWrapper>>
) -> Result<Ptr<BackendNode>>

fn init_webnn(
    &mut self,
    inputs: &Vector<Ptr<dyn BackendWrapper>>,
    nodes: &Vector<Ptr<BackendNode>>
) -> Result<Ptr<BackendNode>>

unsafe fn init_cuda(
    &mut self,
    context: *mut c_void,
    inputs: &Vector<Ptr<dyn BackendWrapper>>,
    outputs: &Vector<Ptr<dyn BackendWrapper>>
) -> Result<Ptr<BackendNode>>

Returns a CUDA backend node

unsafe fn init_tim_vx(
    &mut self,
    tim_vx_info: *mut c_void,
    inputs_wrapper: &Vector<Ptr<dyn BackendWrapper>>,
    outputs_wrapper: &Vector<Ptr<dyn BackendWrapper>>,
    is_last: bool
) -> Result<Ptr<BackendNode>>

Returns a TimVX backend node

fn try_attach(&mut self, node: &Ptr<BackendNode>) -> Result<Ptr<BackendNode>>

Implement layers fusing.

fn set_activation(&mut self, layer: &Ptr<ActivationLayer>) -> Result<bool>

Tries to attach to the layer the subsequent activation layer, i.e. do the layer fusion in a partial case.

fn try_fuse(&mut self, top: &mut Ptr<Layer>) -> Result<bool>

Try to fuse current layer with a next one

fn unset_attached(&mut self) -> Result<()>

“Detaches” all the layers, attached to particular layer.

fn update_memory_shapes(&mut self, inputs: &Vector<MatShape>) -> Result<bool>

fn set_params_from(&mut self, params: &LayerParams) -> Result<()>

impl LayerTraitConst for GRULayer

fn as_raw_Layer(&self) -> *const c_void

fn blobs(&self) -> Vector<Mat>

List of learned parameters must be stored here to allow read them by using Net::getParam().

fn name(&self) -> String

Name of the layer instance, can be used for logging or other internal purposes.

fn typ(&self) -> String

Type name which was used for creating layer by layer factory.

fn preferable_target(&self) -> i32

prefer target for layer forwarding

fn apply_halide_scheduler(
    &self,
    node: &mut Ptr<BackendNode>,
    inputs: &Vector<Mat>,
    outputs: &Vector<Mat>,
    target_id: i32
) -> Result<()>

Automatic Halide scheduling based on layer hyper-parameters.

fn get_scale_shift(&self, scale: &mut Mat, shift: &mut Mat) -> Result<()>

Returns parameters of layers with channel-wise multiplication and addition.

fn get_scale_zeropoint(&self, scale: &mut f32, zeropoint: &mut i32) -> Result<()>

Returns scale and zeropoint of layers

fn get_memory_shapes(
    &self,
    inputs: &Vector<MatShape>,
    required_outputs: i32,
    outputs: &mut Vector<MatShape>,
    internals: &mut Vector<MatShape>
) -> Result<bool>

fn get_flops(
    &self,
    inputs: &Vector<MatShape>,
    outputs: &Vector<MatShape>
) -> Result<i64>

impl TryFrom<Layer> for GRULayer

type Error = Error

The type returned in the event of a conversion error.

fn try_from(s: Layer) -> Result<Self>

Performs the conversion.

impl Send for GRULayer