Struct RowPrecisionPriorPenalty 

pub struct RowPrecisionPriorPenalty {
    pub lambda_per_row: Array3<f64>,
    pub weight: f64,
    pub n_eff: usize,
    pub learnable_weight: bool,
    pub rho_index: usize,
    pub target: PsiSlice,
    pub weight_schedule: Option<ScalarWeightSchedule>,
}

Fixed zero-mean Gaussian row-precision prior on the latent block.

Evaluates the row-wise precision energy ½ μ Σ_n t_nᵀ Λ_n t_n, with the ρ-dependent Gaussian precision normalizer when μ is learnable. Callers pass one positive-definite precision matrix per row. This is not the iVAE conditional-mean gauge ½ μ ||t - h(u)||²; use LatentIdMode::AuxPrior for the ridge/linear projection-residual gauge.

Fields

lambda_per_row: Array3<f64>

weight: f64

Base strength. If learnable_weight is true, the resolved strength is weight * exp(rho[rho_index]); otherwise it is fixed at weight.

n_eff: usize

Number of rows in the row-major matrix-valued latent block.

learnable_weight: bool

rho_index: usize

target: PsiSlice

weight_schedule: Option<ScalarWeightSchedule>

Implementations

impl RowPrecisionPriorPenalty

pub fn new( target: PsiSlice, lambda_per_row: Array3<f64>, weight: f64, n_eff: usize, learnable_weight: bool, ) -> Result<Self, String>

pub fn with_weight_schedule(self, schedule: ScalarWeightSchedule) -> Self

Attach a scalar weight schedule, seeding the current weight from the schedule’s stored iteration counter.

pub fn diag_target( &self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>, ) -> Array1<f64>

pub fn as_dense( &self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>, ) -> Array2<f64>

Materialize the row-block-diagonal Hessian for exact spectral paths.

pub fn log_det_plus_lambda_i( &self, rho: ArrayView1<'_, f64>, lambda: f64, ) -> Result<f64, String>

Trait Implementations

impl AnalyticPenalty for RowPrecisionPriorPenalty

fn tier(&self) -> PenaltyTier

Tier the target lives in (β or ext-coord).

fn value(&self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>) -> f64

Scalar penalty contribution P(target; ρ). The strength factor exp(ρ) (or whatever parameterization the penalty uses) is folded in.

fn grad_target( &self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>, ) -> Array1<f64>

Gradient ∂P/∂target, same length as target.

fn hessian_diag( &self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>, ) -> Option<Array1<f64>>

Diagonal of the Hessian diag(∂²P/∂target²) when the Hessian is block-diagonal. Returns None for penalties whose Hessian is dense (Isometry); those implement Self::hvp instead. The default signals “no closed-form diagonal” by returning None for any non-empty target — concrete penalties either override with their own analytic diagonal or rely on the matrix-free hvp path.

fn hvp( &self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>, v: ArrayView1<'_, f64>, ) -> Array1<f64>

Hessian-vector product H v = (∂²P/∂target²) v, in closed form.

fn grad_rho( &self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>, ) -> Array1<f64>

Gradient of the penalty value w.r.t. each owned ρ-axis. Length equals Self::rho_count.

fn rho_count(&self) -> usize

Number of REML-selectable hyperparameter axes this penalty contributes to the outer ρ vector.

fn name(&self) -> &str

Human-readable identifier for diagnostics / logging.

fn apply_schedule(&mut self, iter: usize)

Update any attached scalar weight schedule at the given REML outer iteration. Penalties without schedules keep their stored weight.

fn psd_majorizer_diag( &self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>, ) -> Option<Array1<f64>>

Diagonal of a PSD majorizer of the Hessian — the positive re-weighted-ℓ₂ / MM surrogate diag(B(target; ρ)) with B ⪰ ∂²P/∂target² everywhere and B ⪰ 0. This is a different operator from Self::hessian_diag: for nonconvex penalties (log sparsity, JumpReLU) the exact Hessian is indefinite, but the inner Newton / PIRLS solve and the log-det / preconditioner pipeline require a PSD curvature block. For convex penalties the majorizer coincides with the exact Hessian, so the default simply delegates to Self::hessian_diag; nonconvex penalties override.

fn psd_majorizer_hvp( &self, target: ArrayView1<'_, f64>, rho: ArrayView1<'_, f64>, v: ArrayView1<'_, f64>, ) -> Array1<f64>

Matrix-vector product against the PSD majorizer B(target; ρ) v (see Self::psd_majorizer_diag). For convex penalties this is the exact Hessian-vector product, so the default delegates to Self::hvp; nonconvex penalties override to return their PSD surrogate instead of the indefinite true Hessian.

impl Clone for RowPrecisionPriorPenalty

fn clone(&self) -> RowPrecisionPriorPenalty

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RowPrecisionPriorPenalty

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

Formats the value using the given formatter.

impl PenaltyManifest for RowPrecisionPriorPenalty

const KIND_TAG: &'static str = "row_precision_prior"

const PYTHON_WRAPPER: &'static str = "AuxConditionalPriorPenalty"

const ROW_BLOCK_DIAGONAL: bool = true

fn dispatch_tier(&self) -> PenaltyTier