[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7DCE0ERZ2MCH1ANEBTC1Y40":3,"skill-same:01M7DCE0ERZ2MCH1ANEBTC1Y40":59},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":18,"linkOnly":19,"markdownContent":20,"markdownBody":21,"frontMatter":22,"refName":23,"commitSha":24,"skillDirectory":25,"forksCount":26,"repositoryHtmlUrl":27,"repositoryHomepageUrl":28,"ownerHtmlUrl":29,"ownerBlogUrl":30,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M7DCE0ERZ2MCH1ANEBTC1Y40","solve-nonsmooth-problem",null,"Use this skill whenever the user wants to solve an inverse problem on PyLops operators with a non-smooth, constrained or non-convex term - load it before writing the objective, choosing a solver or writing optimisation code, even when a SciPy bounded solver or a hand-written FISTA\u002FADMM loop would also work. Covers total variation, L1\u002Fsparsity in a transform, joint sparsity across signals sharing the same components, bounds\u002Fpositivity\u002Fball\u002Faffine constraints, low-rank matrix completion (nuclear norm) and plug-and-play priors with a denoiser (median filter, BM3D), solved with PyProximal (ProximalGradient, ADMM, PrimalDual, ...), step sizes from operator norms. E.g. \"add TV regularisation\", \"keep the model within physical bounds\", \"recover several signals that share their components\", \"fill in missing entries of a low-rank matrix\", \"use PyProximal\". Not for purely quadratic regularisation (Tikhonov, damping, derivative smoothing), which is plain least squares - use the pylops skill solve-inverse-problem.","PyLops\u002Fpylops-agent-skills","PyLops","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F74298005?v=4","01M7DCC0YV3FVDPP4GR6V7F43H","01M7DCC0ZTN5K09ZH48X951TBX",1,"LGPL-2.1","https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpyproximal\u002Fskills\u002Fsolve-nonsmooth-problem\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: solve-nonsmooth-problem\ndescription: Use this skill whenever the user wants to solve an inverse problem on PyLops operators with a non-smooth, constrained or non-convex term - load it before writing the objective, choosing a solver or writing optimisation code, even when a SciPy bounded solver or a hand-written FISTA\u002FADMM loop would also work. Covers total variation, L1\u002Fsparsity in a transform, joint sparsity across signals sharing the same components, bounds\u002Fpositivity\u002Fball\u002Faffine constraints, low-rank matrix completion (nuclear norm) and plug-and-play priors with a denoiser (median filter, BM3D), solved with PyProximal (ProximalGradient, ADMM, PrimalDual, ...), step sizes from operator norms. E.g. \"add TV regularisation\", \"keep the model within physical bounds\", \"recover several signals that share their components\", \"fill in missing entries of a low-rank matrix\", \"use PyProximal\". Not for purely quadratic regularisation (Tikhonov, damping, derivative smoothing), which is plain least squares - use the pylops skill solve-inverse-problem.\n---\n\nGoal: a runnable script that solves the user's non-smooth problem with a\nformulation written down explicitly, provably valid step sizes, and a convergence\ncheck. Do not modify the installed `pyproximal` \u002F `pylops` packages.\n\nIf the problem is a plain (Tikhonov-)regularised least squares, or L1 with an\northogonal transform, PyLops alone is simpler: use the `pylops` plugin skill\n`solve-inverse-problem` instead.\n\n## 0. Check the environment\n\n- Use the project's Python runner; check\n  `python -c \"import pyproximal, pylops; print(pyproximal.__version__, pylops.__version__)\"`.\n  PyProximal requires a recent PyLops (≥ 2.4 for 0.12); ask before installing or\n  upgrading.\n- Signatures and return values of solvers changed across versions (e.g.\n  `AcceleratedProximalGradient` → `ProximalGradient(acceleration=...)`,\n  `DouglasRachfordSplitting` roles of x\u002Fy): inspect the installed ones.\n  `reference\u002Fsolver_guide.md` summarises PyProximal 0.12.\n\n## 1. Write the objective\n\nWrite the problem in the form **`min_x f(x) + g(K x)`** (or `f(x) + ε g(x)`)\nbefore coding, and show it to the user:\n\n- data term: usually `f = ½‖Op x − y‖²` → `pyproximal.L2(Op=Op, b=y)` (smooth, has\n  `.grad`), or `L2(b=y)` applied to `K = Op` inside a stack;\n- regulariser\u002Fconstraint: `L1`, `L21` (+ `pylops.Gradient` = isotropic TV),\n  `Box`, `EuclideanBall`, `L1Ball`, `AffineSet`, `Nuclear`, … (table in the guide);\n- `K`: a PyLops operator (`Gradient`, a transform, `Op`, or\n  `pylops.VStack([...])` with `pyproximal.VStack([...], nn=[...])` for several\n  terms at once);\n- weights: scale proxes with floats (`lam * pyproximal.L21(ndim=2)` with\n  `lam = float(...)`): an integer (`2 * f`) silently yields `None` instead of a\n  scaled operator.\n\n## 2. Pick the solver\n\n| Structure | Solver |\n|---|---|\n| `f` smooth (e.g. L2 data) + simple `g` on `x` (L1, Box) | `ProximalGradient(proxf, proxg, x0, epsg, tau, acceleration=\"fista\")` |\n| `f` + `g(Kx)` with `K` non-trivial (TV, analysis L1 with non-orthogonal transform) | `PrimalDual(proxf, proxg, K, x0, tau, mu)` or `LinearizedADMM(proxf, proxg, K, x0, tau, mu)` |\n| several signals sharing a sparse support (joint \u002F group sparsity) | one joint problem: stack the coefficients (`BlockDiag` of the per-signal operators), `g = L21(ndim=n_signals)` in `ProximalGradient`; not one L1 problem per signal |\n| low-rank matrix from partially observed entries | `ProximalGradient` with `L2(Op=Restriction(...), b=y)` and `Nuclear((n, m))`; `‖Restriction‖ = 1`, so `tau = 1` |\n| `½‖Op x − b‖² + g(Ax)` with a good inner least-squares solver | `ADMML2(proxg, Op, b, A, x0, tau)` |\n| `f(x) + g(x)` both non-smooth with cheap proxes | `ADMM` or `DouglasRachfordSplitting` |\n| constraints + data + regulariser | `PrimalDual` with `f = Box(...)`, `g = VStack([L2(b=y), lam*L21])`, `K = VStack([Op, Gradient])` |\n| many terms | `GeneralizedProximalGradient`, `PPXA`, `ConsensusADMM` |\n| denoiser as prior (median filter, BM3D, network) | `pnp.PlugAndPlay(proxf, denoiser, dims, x0, solver=ProximalGradient or ADMM, tau=...)`; `denoiser(x, tau)` receives `x` reshaped to `dims` and runs at every iteration (applying it once to an `lsqr` result is post-processing, not PnP) |\n\nState the choice and why.\n\nUse the PyProximal solver and proximal operators from the table; do not\nhand-write the iteration (gradient + clip, SVT loops, \"median filter then\nlsqr\" alternations) or switch to scipy\u002Fcvxpy. If the first formulation does\nnot work after one or two attempts, go back to the table and use the row that\nmatches the problem structure instead of trying variants of the same approach.\n\n## 3. Step sizes and parameters\n\n- Compute operator norms, do not guess: `L = ‖K‖²` with\n  `pylops.optimization.eigs.power_iteration(K.H @ K, niter=100)[0]` (inflate ~5 %)\n  or `(K.H @ K).eigs(neigs=1)` (ARPACK may raise `ArpackNoConvergence` – raise\n  `niter` or use power iteration).\n- ProximalGradient: `tau ≤ 1\u002FL` with `L = ‖Op‖²` for `½‖Op x − b‖²` (or\n  `tau=None` for backtracking); PrimalDual: `tau * mu * ‖K‖² \u003C 1` (e.g.\n  `tau = mu = 0.95\u002Fsqrt(L)`); LinearizedADMM: `mu ≤ tau \u002F ‖K‖²`.\n- Inner solves: `L2(Op=..., niter=...)` needs an inner iterative solve at every\n  prox; keep `niter` small (10–30) with `warm=True`, or move `Op` into `K` and use\n  `L2(b=y)` instead.\n- Choose every free parameter (regularisation weight, threshold, `tau`\u002F`mu` for ADMM\u002FPnP, rank, `niter`, denoiser strength) with a criterion that does not use the true model: discrepancy principle (residual ≈ noise level), held-out observed data, L-curve, or a stated scale argument. Never pick a value because it gives the best SNR against the true model; that is an oracle, and it will not transfer to real data. The same applies to information that is only known from how the synthetic was built (the true support, number of components or rank).\n\n## 4. Write, run, verify\n\nAdapt `reference\u002Ftv_template.py` (TV deblurring with and without box\nconstraints via `PrimalDual`):\n\n- a `callback` storing the objective value per iteration; plot it (log scale);\n- stop criterion: relative change of the objective \u002F model below a tolerance, or\n  a fixed `niter` shown to be enough by the cost curve;\n- check constraints are satisfied (e.g. bounds), and compare with the\n  unconstrained \u002F L2 solution to show what the non-smooth term changes;\n-  use a synthetic with known model first when possible, but only to *evaluate* the result (`pylops.utils.metrics.snr` of the final model); the true model must not feed into the solve or into choosing its parameters. A table of SNR vs parameter can be shown as a diagnostic, next to the parameter picked by the truth-free criterion.\n\nIf the cost oscillates or diverges, the step sizes violate the conditions above\n(recompute `‖K‖²`), or `K` fails the dot-test\n(`pylops.utils.dottest`).\n\n## 5. Hand off\n\nReport, with numbers from the run: the objective as written, the proxes\u002Fsolver chosen and why, the step\nsizes and how they were derived, how each free parameter was chosen (the truth-free criterion used), convergence evidence as the iterations used and the cost at the start and end (from the callback, not only the `niter` you set), the result compared with a baseline, and parameters left to tune.\n","Goal: a runnable script that solves the user's non-smooth problem with a\nformulation written down explicitly, provably valid step sizes, and a convergence\ncheck. Do not modify the installed `pyproximal` \u002F `pylops` packages.\n\nIf the problem is a plain (Tikhonov-)regularised least squares, or L1 with an\northogonal transform, PyLops alone is simpler: use the `pylops` plugin skill\n`solve-inverse-problem` instead.\n\n## 0. Check the environment\n\n- Use the project's Python runner; check\n  `python -c \"import pyproximal, pylops; print(pyproximal.__version__, pylops.__version__)\"`.\n  PyProximal requires a recent PyLops (≥ 2.4 for 0.12); ask before installing or\n  upgrading.\n- Signatures and return values of solvers changed across versions (e.g.\n  `AcceleratedProximalGradient` → `ProximalGradient(acceleration=...)`,\n  `DouglasRachfordSplitting` roles of x\u002Fy): inspect the installed ones.\n  `reference\u002Fsolver_guide.md` summarises PyProximal 0.12.\n\n## 1. Write the objective\n\nWrite the problem in the form **`min_x f(x) + g(K x)`** (or `f(x) + ε g(x)`)\nbefore coding, and show it to the user:\n\n- data term: usually `f = ½‖Op x − y‖²` → `pyproximal.L2(Op=Op, b=y)` (smooth, has\n  `.grad`), or `L2(b=y)` applied to `K = Op` inside a stack;\n- regulariser\u002Fconstraint: `L1`, `L21` (+ `pylops.Gradient` = isotropic TV),\n  `Box`, `EuclideanBall`, `L1Ball`, `AffineSet`, `Nuclear`, … (table in the guide);\n- `K`: a PyLops operator (`Gradient`, a transform, `Op`, or\n  `pylops.VStack([...])` with `pyproximal.VStack([...], nn=[...])` for several\n  terms at once);\n- weights: scale proxes with floats (`lam * pyproximal.L21(ndim=2)` with\n  `lam = float(...)`): an integer (`2 * f`) silently yields `None` instead of a\n  scaled operator.\n\n## 2. Pick the solver\n\n| Structure | Solver |\n|---|---|\n| `f` smooth (e.g. L2 data) + simple `g` on `x` (L1, Box) | `ProximalGradient(proxf, proxg, x0, epsg, tau, acceleration=\"fista\")` |\n| `f` + `g(Kx)` with `K` non-trivial (TV, analysis L1 with non-orthogonal transform) | `PrimalDual(proxf, proxg, K, x0, tau, mu)` or `LinearizedADMM(proxf, proxg, K, x0, tau, mu)` |\n| several signals sharing a sparse support (joint \u002F group sparsity) | one joint problem: stack the coefficients (`BlockDiag` of the per-signal operators), `g = L21(ndim=n_signals)` in `ProximalGradient`; not one L1 problem per signal |\n| low-rank matrix from partially observed entries | `ProximalGradient` with `L2(Op=Restriction(...), b=y)` and `Nuclear((n, m))`; `‖Restriction‖ = 1`, so `tau = 1` |\n| `½‖Op x − b‖² + g(Ax)` with a good inner least-squares solver | `ADMML2(proxg, Op, b, A, x0, tau)` |\n| `f(x) + g(x)` both non-smooth with cheap proxes | `ADMM` or `DouglasRachfordSplitting` |\n| constraints + data + regulariser | `PrimalDual` with `f = Box(...)`, `g = VStack([L2(b=y), lam*L21])`, `K = VStack([Op, Gradient])` |\n| many terms | `GeneralizedProximalGradient`, `PPXA`, `ConsensusADMM` |\n| denoiser as prior (median filter, BM3D, network) | `pnp.PlugAndPlay(proxf, denoiser, dims, x0, solver=ProximalGradient or ADMM, tau=...)`; `denoiser(x, tau)` receives `x` reshaped to `dims` and runs at every iteration (applying it once to an `lsqr` result is post-processing, not PnP) |\n\nState the choice and why.\n\nUse the PyProximal solver and proximal operators from the table; do not\nhand-write the iteration (gradient + clip, SVT loops, \"median filter then\nlsqr\" alternations) or switch to scipy\u002Fcvxpy. If the first formulation does\nnot work after one or two attempts, go back to the table and use the row that\nmatches the problem structure instead of trying variants of the same approach.\n\n## 3. Step sizes and parameters\n\n- Compute operator norms, do not guess: `L = ‖K‖²` with\n  `pylops.optimization.eigs.power_iteration(K.H @ K, niter=100)[0]` (inflate ~5 %)\n  or `(K.H @ K).eigs(neigs=1)` (ARPACK may raise `ArpackNoConvergence` – raise\n  `niter` or use power iteration).\n- ProximalGradient: `tau ≤ 1\u002FL` with `L = ‖Op‖²` for `½‖Op x − b‖²` (or\n  `tau=None` for backtracking); PrimalDual: `tau * mu * ‖K‖² \u003C 1` (e.g.\n  `tau = mu = 0.95\u002Fsqrt(L)`); LinearizedADMM: `mu ≤ tau \u002F ‖K‖²`.\n- Inner solves: `L2(Op=..., niter=...)` needs an inner iterative solve at every\n  prox; keep `niter` small (10–30) with `warm=True`, or move `Op` into `K` and use\n  `L2(b=y)` instead.\n- Choose every free parameter (regularisation weight, threshold, `tau`\u002F`mu` for ADMM\u002FPnP, rank, `niter`, denoiser strength) with a criterion that does not use the true model: discrepancy principle (residual ≈ noise level), held-out observed data, L-curve, or a stated scale argument. Never pick a value because it gives the best SNR against the true model; that is an oracle, and it will not transfer to real data. The same applies to information that is only known from how the synthetic was built (the true support, number of components or rank).\n\n## 4. Write, run, verify\n\nAdapt `reference\u002Ftv_template.py` (TV deblurring with and without box\nconstraints via `PrimalDual`):\n\n- a `callback` storing the objective value per iteration; plot it (log scale);\n- stop criterion: relative change of the objective \u002F model below a tolerance, or\n  a fixed `niter` shown to be enough by the cost curve;\n- check constraints are satisfied (e.g. bounds), and compare with the\n  unconstrained \u002F L2 solution to show what the non-smooth term changes;\n-  use a synthetic with known model first when possible, but only to *evaluate* the result (`pylops.utils.metrics.snr` of the final model); the true model must not feed into the solve or into choosing its parameters. A table of SNR vs parameter can be shown as a diagnostic, next to the parameter picked by the truth-free criterion.\n\nIf the cost oscillates or diverges, the step sizes violate the conditions above\n(recompute `‖K‖²`), or `K` fails the dot-test\n(`pylops.utils.dottest`).\n\n## 5. Hand off\n\nReport, with numbers from the run: the objective as written, the proxes\u002Fsolver chosen and why, the step\nsizes and how they were derived, how each free parameter was chosen (the truth-free criterion used), convergence evidence as the iterations used and the cost at the start and end (from the callback, not only the `niter` you set), the result compared with a baseline, and parameters left to tune.\n",{"name":5,"description":7},"main","a0aead16681bea6df74af88096782ad6ab4eddfb","plugins\u002Fpyproximal\u002Fskills\u002Fsolve-nonsmooth-problem",0,"https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills","https:\u002F\u002Fpylops.github.io\u002Fpylops-agent-skills\u002F","https:\u002F\u002Fgithub.com\u002FPyLops","https:\u002F\u002Fpylops.github.io","Matrix-Free linear algebra and optimization in Python","2026-11-02 05:28:21",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add PyLops\u002Fpylops-agent-skills --skill solve-nonsmooth-problem",{"tool":39,"command":40},"bunx","bunx skills add PyLops\u002Fpylops-agent-skills --skill solve-nonsmooth-problem",{"tool":42,"command":43},"pnpm","pnpm dlx skills add PyLops\u002Fpylops-agent-skills --skill solve-nonsmooth-problem","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpyproximal\u002Fskills\u002Fsolve-nonsmooth-problem\u002FSKILL.md",true,[47,53],{"path":48,"resourceType":49,"resourceTypeDesc":50,"sizeBytes":51,"sourceHtmlUrl":52},"reference\u002Fsolver_guide.md","REFERENCE","参考文档",4160,"https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpyproximal\u002Fskills\u002Fsolve-nonsmooth-problem\u002Freference\u002Fsolver_guide.md",{"path":54,"resourceType":55,"resourceTypeDesc":56,"sizeBytes":57,"sourceHtmlUrl":58},"reference\u002Ftv_template.py","SCRIPT","脚本",4200,"https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpyproximal\u002Fskills\u002Fsolve-nonsmooth-problem\u002Freference\u002Ftv_template.py",[60,67,74,81,88,95],{"skillNo":61,"name":62,"nameZh":6,"description":63,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":18},"01M7DCDT6XDJPE8W9JPVAAX50X","wrap-operator","Wrap a user's own forward model as a PyLops linear operator inside their project (not inside the PyLops library), with a verified adjoint, a dot-test and a small test suite. Use when the user wants to turn existing forward\u002Fadjoint code, a script at a URL, or a mathematical description into a PyLops operator they can pass to PyLops solvers (e.g. \"make my blurring function a PyLops operator\", \"wrap this forward model so I can invert it with lsqr\", \"I have a forward and adjoint, plug them into PyLops\").","https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpylops\u002Fskills\u002Fwrap-operator\u002FSKILL.md",[],[],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":73,"publishedAt":18},"01M7DCDKBBA8PJA706HD1W3AVR","tune-regularization","Choose regularisation weights and thresholds for a PyLops inversion (epsRs in regularized_inversion, damp in cgls\u002Flsqr, eps in ista\u002Ffista, epsRL1s in splitbregman, sigma\u002Ftau in spgl1, niter as implicit regularisation) with a principled, reproducible sweep - L-curve, discrepancy principle, GCV for small problems, or a synthetic test with a known model. Use when the user asks \"how do I choose epsilon \u002F lambda \u002F damping\", \"my inversion is too smooth \u002F too noisy\", \"make an L-curve\", or after solve-inverse-problem produced a working but untuned inversion.","https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpylops\u002Fskills\u002Ftune-regularization\u002FSKILL.md",[],[],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":18},"01M7DCDBNA6XGWDZQ1A15CG1S6","solve-inverse-problem","Use this skill whenever the user has (or can build) a PyLops operator and data and wants to invert it - load it before choosing a solver or writing any inversion code, even when the right solver or regularisation seems obvious. It sets up and runs the inversion in the user's project - choose the solver (lsqr, cgls, cg, regularized_inversion, preconditioned_inversion, fista, spgl1, omp, irls, splitbregman), the regularisation and the stopping parameters, and write a runnable script that reports convergence. E.g. \"invert my data with this operator\", \"which PyLops solver should I use\", \"add Tikhonov \u002F smoothness \u002F sparsity regularisation to my inversion\", \"solve y = Op x\". Not for an inversion that already misbehaves (use debug-inversion) or for choosing regularisation weights with an L-curve or sweep (use tune-regularization).","https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpylops\u002Fskills\u002Fsolve-inverse-problem\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":18},"01M7DCD5Q5P09A2R28QWWVSPGM","sliding-patch-processing","Set up PyLops windowed operators - Sliding1D, Sliding2D, Sliding3D, Patch2D, Patch3D - to apply a local transform or operator over overlapping windows of 1-D\u002F2-D\u002F3-D data, choosing window size, overlap, taper and model size with the *_design and *_pad_to_next helpers, checking coverage and the dot-test, and using them for local denoising, interpolation or inversion. Use when the user asks \"apply FFT\u002FRadon\u002Fany operator in overlapping windows\", \"local transform \u002F patching with PyLops\", \"Patch2D gives artefacts at the edges\", \"how do I pick nwin, nover, nop\".","https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpylops\u002Fskills\u002Fsliding-patch-processing\u002FSKILL.md",[],[],{"skillNo":89,"name":90,"nameZh":6,"description":91,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":92,"categories":93,"keywords":94,"publishedAt":18},"01M7DCCXVMV97MEBGWSTETYPYJ","pick-sparsifying-transform","Choose a sparsifying transform for a signal or image in a PyLops sparsity-promoting inversion (FFT\u002FFFT2D\u002FFFTND, DCT, DWT\u002FDWT2D\u002FDWTND, DTCWT, Seislet, curvelets via UDCT, Radon\u002FFourierRadon\u002FChirpRadon, windowed versions with Sliding\u002FPatch), check its optional dependencies and frame properties, compare candidates quantitatively with a best-k-term compressibility test, and wire the winner into fista\u002Fspgl1 in synthesis or analysis form. Use when the user asks \"which transform should I use for sparsity\", \"wavelets or curvelets for my data\", \"make my model sparse for fista\u002Fspgl1\", \"compressive sensing \u002F interpolation with PyLops\".","https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpylops\u002Fskills\u002Fpick-sparsifying-transform\u002FSKILL.md",[],[],{"skillNo":96,"name":97,"nameZh":6,"description":98,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":99,"categories":100,"keywords":101,"publishedAt":18},"01M7DCCNBV43MY51NMRKC9K7J3","debug-inversion","Use this skill whenever a user shares PyLops code or results that misbehave and asks what is wrong - load it first, before running the user's code, testing a hypothesis or answering, even when the bug looks obvious from the code. Covers a crash or traceback (dtype\u002Fcasting errors, shape mismatches), a solver (lsqr, cgls, cg, fista, ista, spgl1, regularized_inversion, splitbregman) that stalls, diverges, returns NaNs, zeros, ringing or a wrong model, one dataset or block being ignored in a stacked\u002Fjoint inversion, or a custom FunctionOperator\u002FLinearOperator that may have a wrong adjoint. Diagnoses with evidence (block-by-block dot-tests incl. complex, dtype and dims checks, operator\u002Fdata scaling, solver and eps\u002Fdamp choice), then proposes the smallest fix and verifies it. Not for choosing a solver for a new, working setup (use solve-inverse-problem) or picking regularisation weights (use tune-regularization).","https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpylops\u002Fskills\u002Fdebug-inversion\u002FSKILL.md",[],[]]