layers.tensor.RightBlockBatch

layers.tensor.RightBlockBatch(self, data, leg_names, name='R')

Right blocks for batch are calculated recursively as follows:

\[ \mathcal{R}^{[f]}_{\beta_{f-1}} = \sum_{i_f} W^{[f]}_{\beta_{f-1}i_f} \phi_{i_f}^{[f]} \] \[ \mathcal{R}^{[p]}_{\beta_{p-1}} = \sum_{\beta_p} \sum_{i_{p}} W^{[p]}_{\beta_{p-1} i_{p} \beta_{p}} \phi_{i_{p}}^{[p]} \mathcal{R}^{[p+1]}_{\beta_{p}} \]

Note

The batch dimension "D" must be the first index.

Methods

Name	Description
as_basis_batch	Convert to BasisBatch
as_core	Convert to Core
as_core_basis_batch	Convert to CoreBasisBatch
as_left_block_batch	Convert to LeftBlockBatch
as_ndarray	Convert to jax.Array (Array)
as_right_block_batch	Convert to RightBlockBatch
as_tensor	Convert to Tensor
as_twodot_core	Convert to TwodotCore
normalize	Normalize tensor
scale_to	Scale maximum abs element of the tensor to the given scale

as_basis_batch

layers.tensor.RightBlockBatch.as_basis_batch(name='Phi')

Convert to BasisBatch

Returns

Name	Type	Description
BasisBatch	BasisBatch	BasisBatch tensor

as_core

layers.tensor.RightBlockBatch.as_core(name='W')

Convert to Core

Returns

Name	Type	Description
Core	Core	Core tensor

as_core_basis_batch

layers.tensor.RightBlockBatch.as_core_basis_batch(name='WPhi')

Convert to CoreBasisBatch

Returns

Name	Type	Description
CoreBasisBatch	CoreBasisBatch	CoreBasisBatch tensor

as_left_block_batch

layers.tensor.RightBlockBatch.as_left_block_batch(name='L')

Convert to LeftBlockBatch

Returns

Name	Type	Description
LeftBlockBatch	LeftBlockBatch	LeftBlockBatch tensor

as_ndarray

layers.tensor.RightBlockBatch.as_ndarray()

Convert to jax.Array (Array)

Returns

Name	Type	Description
Array	Array	Array tensor

as_right_block_batch

layers.tensor.RightBlockBatch.as_right_block_batch(name='R')

Convert to RightBlockBatch

Returns

Name	Type	Description
RightBlockBatch	RightBlockBatch	RightBlockBatch tensor

as_tensor

layers.tensor.RightBlockBatch.as_tensor(name='T')

Convert to Tensor

Returns

Name	Type	Description
Tensor	Tensor	Tensor tensor

as_twodot_core

layers.tensor.RightBlockBatch.as_twodot_core(name='B')

Convert to TwodotCore

Returns

Name	Type	Description
TwodotCore	TwodotCore	TwodotCore tensor

normalize

layers.tensor.RightBlockBatch.normalize()

Normalize tensor

Tensor is normalized and return the norm of the tensor.

Returns

Name	Type	Description
Array	Array	norm of the tensor before normalization

scale_to

layers.tensor.RightBlockBatch.scale_to(scale=None, ord='fro')

Scale maximum abs element of the tensor to the given scale

Parameters

Name	Type	Description	Default
scale	float \| Array	scale factor. Defaults to jnp.array(1.0).	`None`
ord	str	norm type to scale either “fro” or “max”. Defaults to “fro” (Frobenius norm). “fro” : Frobenius norm “max” : maximum absolute value	`'fro'`

Returns

Name	Type	Description
Array	Array	multiplication factor to scale the tensor

# layers.tensor.RightBlockBatch { #pompon.layers.tensor.RightBlockBatch } ```python layers.tensor.RightBlockBatch(self, data, leg_names, name='R') ``` Right blocks for batch are calculated recursively as follows: $$ \mathcal{R}^{[f]}_{\beta_{f-1}} = \sum_{i_f} W^{[f]}_{\beta_{f-1}i_f} \phi_{i_f}^{[f]} $$ $$ \mathcal{R}^{[p]}_{\beta_{p-1}} = \sum_{\beta_p} \sum_{i_{p}} W^{[p]}_{\beta_{p-1} i_{p} \beta_{p}} \phi_{i_{p}}^{[p]} \mathcal{R}^{[p+1]}_{\beta_{p}} $$ ::: {.callout-note} The batch dimension ``"D"`` must be the first index. ::: ## Methods | Name | Description | | --- | --- | | [as_basis_batch](#pompon.layers.tensor.RightBlockBatch.as_basis_batch) | Convert to BasisBatch | | [as_core](#pompon.layers.tensor.RightBlockBatch.as_core) | Convert to Core | | [as_core_basis_batch](#pompon.layers.tensor.RightBlockBatch.as_core_basis_batch) | Convert to CoreBasisBatch | | [as_left_block_batch](#pompon.layers.tensor.RightBlockBatch.as_left_block_batch) | Convert to LeftBlockBatch | | [as_ndarray](#pompon.layers.tensor.RightBlockBatch.as_ndarray) | Convert to jax.Array (Array) | | [as_right_block_batch](#pompon.layers.tensor.RightBlockBatch.as_right_block_batch) | Convert to RightBlockBatch | | [as_tensor](#pompon.layers.tensor.RightBlockBatch.as_tensor) | Convert to Tensor | | [as_twodot_core](#pompon.layers.tensor.RightBlockBatch.as_twodot_core) | Convert to TwodotCore | | [normalize](#pompon.layers.tensor.RightBlockBatch.normalize) | Normalize tensor | | [scale_to](#pompon.layers.tensor.RightBlockBatch.scale_to) | Scale maximum abs element of the tensor to the given scale | ### as_basis_batch { #pompon.layers.tensor.RightBlockBatch.as_basis_batch } ```python layers.tensor.RightBlockBatch.as_basis_batch(name='Phi') ``` Convert to BasisBatch #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |------------|-------------------------------------------------|-------------------| | BasisBatch | [BasisBatch](`pompon.layers.tensor.BasisBatch`) | BasisBatch tensor | ### as_core { #pompon.layers.tensor.RightBlockBatch.as_core } ```python layers.tensor.RightBlockBatch.as_core(name='W') ``` Convert to Core #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |--------|-------------------------------------|---------------| | Core | [Core](`pompon.layers.tensor.Core`) | Core tensor | ### as_core_basis_batch { #pompon.layers.tensor.RightBlockBatch.as_core_basis_batch } ```python layers.tensor.RightBlockBatch.as_core_basis_batch(name='WPhi') ``` Convert to CoreBasisBatch #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |----------------|---------------------------------------------------------|-----------------------| | CoreBasisBatch | [CoreBasisBatch](`pompon.layers.tensor.CoreBasisBatch`) | CoreBasisBatch tensor | ### as_left_block_batch { #pompon.layers.tensor.RightBlockBatch.as_left_block_batch } ```python layers.tensor.RightBlockBatch.as_left_block_batch(name='L') ``` Convert to LeftBlockBatch #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |----------------|---------------------------------------------------------|-----------------------| | LeftBlockBatch | [LeftBlockBatch](`pompon.layers.tensor.LeftBlockBatch`) | LeftBlockBatch tensor | ### as_ndarray { #pompon.layers.tensor.RightBlockBatch.as_ndarray } ```python layers.tensor.RightBlockBatch.as_ndarray() ``` Convert to jax.Array (Array) #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |--------|----------------------|---------------| | Array | [Array](`jax.Array`) | Array tensor | ### as_right_block_batch { #pompon.layers.tensor.RightBlockBatch.as_right_block_batch } ```python layers.tensor.RightBlockBatch.as_right_block_batch(name='R') ``` Convert to RightBlockBatch #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |-----------------|-----------------------------------------------------------|------------------------| | RightBlockBatch | [RightBlockBatch](`pompon.layers.tensor.RightBlockBatch`) | RightBlockBatch tensor | ### as_tensor { #pompon.layers.tensor.RightBlockBatch.as_tensor } ```python layers.tensor.RightBlockBatch.as_tensor(name='T') ``` Convert to Tensor #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |--------|-----------------------------------------|---------------| | Tensor | [Tensor](`pompon.layers.tensor.Tensor`) | Tensor tensor | ### as_twodot_core { #pompon.layers.tensor.RightBlockBatch.as_twodot_core } ```python layers.tensor.RightBlockBatch.as_twodot_core(name='B') ``` Convert to TwodotCore #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |------------|-------------------------------------------------|-------------------| | TwodotCore | [TwodotCore](`pompon.layers.tensor.TwodotCore`) | TwodotCore tensor | ### normalize { #pompon.layers.tensor.RightBlockBatch.normalize } ```python layers.tensor.RightBlockBatch.normalize() ``` Normalize tensor Tensor is normalized and return the norm of the tensor. #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |--------|----------------------|-----------------------------------------| | Array | [Array](`jax.Array`) | norm of the tensor before normalization | ### scale_to { #pompon.layers.tensor.RightBlockBatch.scale_to } ```python layers.tensor.RightBlockBatch.scale_to(scale=None, ord='fro') ``` Scale maximum abs element of the tensor to the given scale #### Parameters {.doc-section .doc-section-parameters} | Name | Type | Description | Default | |--------|------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------|-----------| | scale | [float](`float`) \| [Array](`jax.Array`) | scale factor. Defaults to jnp.array(1.0). | `None` | | ord | [str](`str`) | norm type to scale either "fro" or "max". Defaults to "fro" (Frobenius norm). "fro" : Frobenius norm "max" : maximum absolute value | `'fro'` | #### Returns {.doc-section .doc-section-returns} | Name | Type | Description | |--------|----------------------|-------------------------------------------| | Array | [Array](`jax.Array`) | multiplication factor to scale the tensor |