joanrue
commented
6 months ago Hi @Hierakonpolis ,
Thanks for reaching out, your problem can indeed be handled with Pyxu. Let me rewrite it to have a clearer mapping between your cost functional to Pyxu operators.
$$ \hat{\mathbf{\alpha}} = \arg\min{\mathbf{\alpha}\in\mathbb{R}^{W\times L}} \frac{1}{2}\Vert \mathbf{y} - Q(\mathbf{\alpha})\Vert{2}^{2} + \phi( \mathbf{\alpha})$$
Where $\phi(\mathbf{\alpha})= \Vert \mathbf{\alpha} \Vert{21} + \Vert\mathbf{\alpha} \Vert{1}$
In Pyxu you can define the first term as:
import numpy as np
from pyxu.operator import SquaredL2Norm
from pyxu.abc.operator import LinOp
T, W, L = 10, 4, 5
y = np.random.randn(T)
X_c = np.random.randn(T, W, L)
q = LinOp.from_array(A=X_c, dim_rank=2)
likelihood = SquaredL2Norm(dim_shape=T).argshift(-y) * qFor your $\phi(\mathbf{\alpha})$ function, since the sum of two proximable functions doesn't generally have a closed form solution for the proximity operator, you'll need to create your own ProxFunc and define its prox(arr, tau) method with Equation 6 in the paper you shared. You can get inspired from existing ProxFuncs. For example:
import pyxu.abc as pxa
class PhiRegularizer(pxa.ProxFunc):
def __init__(self, dim_shape: pxt.NDArrayShape):
pass
@pxrt.enforce_precision(i="arr")
def apply(self, arr: pxt.NDArray) -> pxt.NDArray:
pass
@pxrt.enforce_precision(i=("arr", "tau"))
def prox(self, arr: pxt.NDArray, tau: pxt.Real) -> pxt.NDArray:
pass
prior = PhiRegularizer(W, L)Which then you can use in PGD for example:
solver = PGD(f=likelihood, g=prior)
alpha0 = np.random.randn(W, L)
solver(x0=alpha0)
alpha_hat = solver.solution()I hope that helps!
Hierakonpolis
The problem I'm trying to solve is stated as such, from Cury et al.:
With y being a 1d vector of targets, one for each t in T, X shaped (T, W, L) and alpha shaped (W, L). The function q is the sum of the elements of the element-wise products between X and alpha, what in numpy would be np.sum(X * alpha, (1,2)).
To vectorize the problem over T, the way I would be temped to do it if it was e.g. pytorch would be to set alpha as requiring gradient and either rely on broadcasting or convolve X with alpha as the kernel.
I am entirely new to pyxu, but to implement this my guess would be I would need
SquaredL2Norm(dim=y.size).asloss(y.ravel()) * [X convolved with alpha]And optimize this (plus the phi function, which is just the sum of L21Norm and L1Norm) for alpha. I'm not quite sure how to implement this here, or if this would be supported at all. Could anyone point me in the right direction?