[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7DCCFEZ8QE2FNQKM5TH27RH":3,"skill-same:01M7DCCFEZ8QE2FNQKM5TH27RH":53},{"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},"01M7DCCFEZ8QE2FNQKM5TH27RH","accelerate-on-gpu",null,"Move an existing PyLops workflow (operators, custom LinearOperators and solvers) from NumPy on CPU to GPU with CuPy, or to JAX, and benchmark it against the CPU version. Covers backend-agnostic custom operators, dtype choice, host\u002Fdevice transfers, operators without GPU support, mixed CPU\u002FGPU setups with ToCupy, and correct GPU timing. Use when the user asks \"run my PyLops inversion on GPU\", \"use cupy with pylops\", \"my PyLops code is too slow\", \"port this operator to JAX\".","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\u002Fpylops\u002Fskills\u002Faccelerate-on-gpu\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: accelerate-on-gpu\ndescription: Move an existing PyLops workflow (operators, custom LinearOperators and solvers) from NumPy on CPU to GPU with CuPy, or to JAX, and benchmark it against the CPU version. Covers backend-agnostic custom operators, dtype choice, host\u002Fdevice transfers, operators without GPU support, mixed CPU\u002FGPU setups with ToCupy, and correct GPU timing. Use when the user asks \"run my PyLops inversion on GPU\", \"use cupy with pylops\", \"my PyLops code is too slow\", \"port this operator to JAX\".\n---\n\nGoal: the user's workflow runs on the GPU (CuPy) or with JAX, gives the same\nresult as on CPU (within dtype precision), and a benchmark shows whether it is\nactually faster. Do not modify the installed `pylops` package.\n\n## 0. Check the environment\n\n- Use the project's Python runner. Check `pylops.__version__`, and whether a GPU\n  and backend are usable:\n  - CuPy: `python -c \"import cupy as cp; print(cp.__version__, cp.cuda.runtime.getDeviceCount())\"`\n  - JAX: `python -c \"import jax; print(jax.__version__, jax.devices())\"`\n- PyLops detects CuPy\u002FJAX **at import time**: they must be installed before (or\n  alongside) PyLops, and `CUPY_PYLOPS=0` \u002F `JAX_PYLOPS=0` in the environment\n  disable them. If `import pylops` fails after installing CuPy\u002FJAX, check versions\n  against the PyLops installation docs. Ask before installing anything; the CuPy\n  wheel must match the CUDA version (`cupy-cuda12x`, `cupy-cuda13x`, or PyLops\n  extras `pylops[gpu-cu12]`\u002F`pylops[gpu-cu13]`).\n- If no GPU is available, still make the code backend-agnostic and test it on\n  CPU with NumPy (and with JAX on CPU if installed); say clearly that GPU\n  performance was not measured.\n\n## 1. Inventory the workflow\n\nList every operator in the chain and check GPU support in the PyLops GPU page\n(https:\u002F\u002Fpylops.readthedocs.io\u002Fen\u002Fstable\u002Fgpu.html) or the table below. Summary\nfor PyLops 2.x:\n\n- **Work on CuPy and JAX**: basic operators (`MatrixMult`, `Diagonal`,\n  `Identity`, `Restriction`, `VStack`\u002F`HStack`\u002F`BlockDiag`, `Kronecker`,\n  `Transpose`, `Roll`, `Pad`, …), all derivatives, `FFT`\u002F`FFT2D`\u002F`FFTND`,\n  `Shift`, `Convolve2D\u002FND`, `Fredholm1`, `Interp`, `ChirpRadon2D\u002F3D`,\n  `MDC`, `UpDownComposition2D\u002F3D`, `Blending*`, `PoststackLinearModelling`,\n  `AVOLinearModelling`.\n- **CuPy only** (not JAX): `Sliding*`, `Patch*`, `Bilinear`,\n  `NonStationaryConvolve2D`, `FourierRadon2D\u002F3D` (`engine=\"cuda\"`);\n  `Convolve1D` and `PrestackLinearModelling` are partial on JAX.\n- **CPU only**: `DWT*`, `DCT`, `Seislet`, `UDCT`, `Radon2D\u002F3D`, `Spread`,\n  `PWSprayer2D`, `PWSmoother2D`, `Kirchhoff` (its `engine=\"cuda\"` is Numba-CUDA, not\n  CuPy arrays), `AcousticWave2D`; `LinearOperator.eigs`, `.cond`, `.trace`,\n  `.tosparse`.\n- Solvers in `pylops.optimization` work with CuPy\u002FJAX arrays. Wrappers that\n  default to SciPy (`regularized_inversion`, `preconditioned_inversion`,\n  `normal_equations_inversion`, `irls`, `omp`, `splitbregman`) switch to the\n  PyLops inner solver for non-NumPy arrays, so their `kwargs_solver` must then use\n  PyLops names (`niter`, not SciPy's `iter_lim`): pass `engine=\"pylops\"` explicitly\n  so CPU and GPU runs take the same arguments. `spgl1` is CPU only.\n\nThe installed version is authoritative: when unsure, try the operator on a small\nCuPy array and compare with NumPy.\n\n## 2. Port\n\n- **One switch**: introduce a backend variable (`xp = cupy` or `numpy`, or a\n  `backend=\"numpy\"|\"cupy\"|\"jax\"` argument) and create every array the operators\n  hold (matrices, filters, wavelets, masks, diagonals) and the data\u002F`x0` with it.\n  PyLops picks the backend from the arrays: an operator built with NumPy arrays\n  applied to CuPy data fails or silently copies.\n  `pylops.utils.backend.get_module(backend)` returns the module.\n- **dtype**: prefer `float32`\u002F`complex64` on GPU (consumer GPUs are much slower in\n  double precision); pass `dtype=` to operators consistently. Check the accuracy\n  impact against the `float64` CPU run.\n- **Custom operators** (`LinearOperator` subclasses written by the user): replace\n  `np.` calls on inputs with `ncp = get_array_module(x)` and `ncp.`; move stored\n  parameters to the input's device with `to_cupy_conditional(x, self.param)`; avoid\n  `np.asarray`, `.tolist()`, Python loops over elements and SciPy functions on\n  CuPy arrays (use `cupyx.scipy` equivalents). Re-run the dot-test with\n  `dottest(..., backend=\"cupy\")`.\n- **JAX**: wrap the final operator in `pylops.JaxOperator(Op)` (JIT-compiles\n  `matvec`\u002F`rmatvec`); `Op.rmatvecad(x, y)` gives an autodiff adjoint to test a\n  hand-written one. JAX arrays are immutable: replace in-place assignments\n  (`x[idx] = v`) in the user's setup code with NumPy construction followed by\n  `jnp.asarray`, or with `x.at[idx].set(v)`. `ToCupy`\u002F`inoutengine` mixed setups\n  are not available with JAX.\n- **Unsupported operators**: keep them on CPU and sandwich GPU parts with\n  `pylops.ToCupy` (`Top1.H @ GpuOp @ Top`), or use `VStack`\u002F`BlockDiag` with\n  `inoutengine=(\"numpy\", \"cupy\")` when the model fits on GPU but the data does\n  not. This is also the pattern when the full data do not fit in GPU memory.\n- **Transfers**: move data to the GPU once (`cp.asarray`) and results back once\n  (`cp.asnumpy` or `pylops.utils.backend.to_numpy`) – not inside callbacks or\n  loops. Plotting needs NumPy arrays.\n- `LinearOperator.eigs` \u002F `cond` are CPU only. `ista`\u002F`fista` with `alpha=None`\n  already switch to `pylops.optimization.eigs.power_iteration` for non-NumPy\n  arrays, but `eigsdict` keys then go to `power_iteration` (`niter`, `tol`) instead\n  of `eigs`; for your own estimates call\n  `power_iteration(Op.H @ Op, niter=..., dtype=..., backend=\"cupy\")`, or compute\n  `alpha` once on CPU and pass it.\n\n## 3. Verify and benchmark\n\nAdapt `reference\u002Fbenchmark_template.py`:\n\n- compare forward, adjoint and final inversion result CPU vs GPU\n  (`np.allclose` with a tolerance matching the dtype, e.g. `rtol=1e-4` for float32);\n- time `matvec`, `rmatvec` and the full solve after a **warm-up** call\n  (CuPy compiles kernels and JAX JIT-compiles on first use) and with\n  **synchronisation** (`cp.cuda.Device().synchronize()`,\n  `jax.block_until_ready`) – otherwise GPU timings are meaningless;\n- repeat several times and report median; try at least two problem sizes\n  (small problems are often faster on CPU).\n\n## 4. Hand off\n\nReport: what changed (backend switch, custom-operator edits, operators kept on\nCPU), the accuracy check, the timing table (CPU vs GPU, per size), and remaining\nbottlenecks (CPU-only operators, transfers).\n","Goal: the user's workflow runs on the GPU (CuPy) or with JAX, gives the same\nresult as on CPU (within dtype precision), and a benchmark shows whether it is\nactually faster. Do not modify the installed `pylops` package.\n\n## 0. Check the environment\n\n- Use the project's Python runner. Check `pylops.__version__`, and whether a GPU\n  and backend are usable:\n  - CuPy: `python -c \"import cupy as cp; print(cp.__version__, cp.cuda.runtime.getDeviceCount())\"`\n  - JAX: `python -c \"import jax; print(jax.__version__, jax.devices())\"`\n- PyLops detects CuPy\u002FJAX **at import time**: they must be installed before (or\n  alongside) PyLops, and `CUPY_PYLOPS=0` \u002F `JAX_PYLOPS=0` in the environment\n  disable them. If `import pylops` fails after installing CuPy\u002FJAX, check versions\n  against the PyLops installation docs. Ask before installing anything; the CuPy\n  wheel must match the CUDA version (`cupy-cuda12x`, `cupy-cuda13x`, or PyLops\n  extras `pylops[gpu-cu12]`\u002F`pylops[gpu-cu13]`).\n- If no GPU is available, still make the code backend-agnostic and test it on\n  CPU with NumPy (and with JAX on CPU if installed); say clearly that GPU\n  performance was not measured.\n\n## 1. Inventory the workflow\n\nList every operator in the chain and check GPU support in the PyLops GPU page\n(https:\u002F\u002Fpylops.readthedocs.io\u002Fen\u002Fstable\u002Fgpu.html) or the table below. Summary\nfor PyLops 2.x:\n\n- **Work on CuPy and JAX**: basic operators (`MatrixMult`, `Diagonal`,\n  `Identity`, `Restriction`, `VStack`\u002F`HStack`\u002F`BlockDiag`, `Kronecker`,\n  `Transpose`, `Roll`, `Pad`, …), all derivatives, `FFT`\u002F`FFT2D`\u002F`FFTND`,\n  `Shift`, `Convolve2D\u002FND`, `Fredholm1`, `Interp`, `ChirpRadon2D\u002F3D`,\n  `MDC`, `UpDownComposition2D\u002F3D`, `Blending*`, `PoststackLinearModelling`,\n  `AVOLinearModelling`.\n- **CuPy only** (not JAX): `Sliding*`, `Patch*`, `Bilinear`,\n  `NonStationaryConvolve2D`, `FourierRadon2D\u002F3D` (`engine=\"cuda\"`);\n  `Convolve1D` and `PrestackLinearModelling` are partial on JAX.\n- **CPU only**: `DWT*`, `DCT`, `Seislet`, `UDCT`, `Radon2D\u002F3D`, `Spread`,\n  `PWSprayer2D`, `PWSmoother2D`, `Kirchhoff` (its `engine=\"cuda\"` is Numba-CUDA, not\n  CuPy arrays), `AcousticWave2D`; `LinearOperator.eigs`, `.cond`, `.trace`,\n  `.tosparse`.\n- Solvers in `pylops.optimization` work with CuPy\u002FJAX arrays. Wrappers that\n  default to SciPy (`regularized_inversion`, `preconditioned_inversion`,\n  `normal_equations_inversion`, `irls`, `omp`, `splitbregman`) switch to the\n  PyLops inner solver for non-NumPy arrays, so their `kwargs_solver` must then use\n  PyLops names (`niter`, not SciPy's `iter_lim`): pass `engine=\"pylops\"` explicitly\n  so CPU and GPU runs take the same arguments. `spgl1` is CPU only.\n\nThe installed version is authoritative: when unsure, try the operator on a small\nCuPy array and compare with NumPy.\n\n## 2. Port\n\n- **One switch**: introduce a backend variable (`xp = cupy` or `numpy`, or a\n  `backend=\"numpy\"|\"cupy\"|\"jax\"` argument) and create every array the operators\n  hold (matrices, filters, wavelets, masks, diagonals) and the data\u002F`x0` with it.\n  PyLops picks the backend from the arrays: an operator built with NumPy arrays\n  applied to CuPy data fails or silently copies.\n  `pylops.utils.backend.get_module(backend)` returns the module.\n- **dtype**: prefer `float32`\u002F`complex64` on GPU (consumer GPUs are much slower in\n  double precision); pass `dtype=` to operators consistently. Check the accuracy\n  impact against the `float64` CPU run.\n- **Custom operators** (`LinearOperator` subclasses written by the user): replace\n  `np.` calls on inputs with `ncp = get_array_module(x)` and `ncp.`; move stored\n  parameters to the input's device with `to_cupy_conditional(x, self.param)`; avoid\n  `np.asarray`, `.tolist()`, Python loops over elements and SciPy functions on\n  CuPy arrays (use `cupyx.scipy` equivalents). Re-run the dot-test with\n  `dottest(..., backend=\"cupy\")`.\n- **JAX**: wrap the final operator in `pylops.JaxOperator(Op)` (JIT-compiles\n  `matvec`\u002F`rmatvec`); `Op.rmatvecad(x, y)` gives an autodiff adjoint to test a\n  hand-written one. JAX arrays are immutable: replace in-place assignments\n  (`x[idx] = v`) in the user's setup code with NumPy construction followed by\n  `jnp.asarray`, or with `x.at[idx].set(v)`. `ToCupy`\u002F`inoutengine` mixed setups\n  are not available with JAX.\n- **Unsupported operators**: keep them on CPU and sandwich GPU parts with\n  `pylops.ToCupy` (`Top1.H @ GpuOp @ Top`), or use `VStack`\u002F`BlockDiag` with\n  `inoutengine=(\"numpy\", \"cupy\")` when the model fits on GPU but the data does\n  not. This is also the pattern when the full data do not fit in GPU memory.\n- **Transfers**: move data to the GPU once (`cp.asarray`) and results back once\n  (`cp.asnumpy` or `pylops.utils.backend.to_numpy`) – not inside callbacks or\n  loops. Plotting needs NumPy arrays.\n- `LinearOperator.eigs` \u002F `cond` are CPU only. `ista`\u002F`fista` with `alpha=None`\n  already switch to `pylops.optimization.eigs.power_iteration` for non-NumPy\n  arrays, but `eigsdict` keys then go to `power_iteration` (`niter`, `tol`) instead\n  of `eigs`; for your own estimates call\n  `power_iteration(Op.H @ Op, niter=..., dtype=..., backend=\"cupy\")`, or compute\n  `alpha` once on CPU and pass it.\n\n## 3. Verify and benchmark\n\nAdapt `reference\u002Fbenchmark_template.py`:\n\n- compare forward, adjoint and final inversion result CPU vs GPU\n  (`np.allclose` with a tolerance matching the dtype, e.g. `rtol=1e-4` for float32);\n- time `matvec`, `rmatvec` and the full solve after a **warm-up** call\n  (CuPy compiles kernels and JAX JIT-compiles on first use) and with\n  **synchronisation** (`cp.cuda.Device().synchronize()`,\n  `jax.block_until_ready`) – otherwise GPU timings are meaningless;\n- repeat several times and report median; try at least two problem sizes\n  (small problems are often faster on CPU).\n\n## 4. Hand off\n\nReport: what changed (backend switch, custom-operator edits, operators kept on\nCPU), the accuracy check, the timing table (CPU vs GPU, per size), and remaining\nbottlenecks (CPU-only operators, transfers).\n",{"name":5,"description":7},"main","a0aead16681bea6df74af88096782ad6ab4eddfb","plugins\u002Fpylops\u002Fskills\u002Faccelerate-on-gpu",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 accelerate-on-gpu",{"tool":39,"command":40},"bunx","bunx skills add PyLops\u002Fpylops-agent-skills --skill accelerate-on-gpu",{"tool":42,"command":43},"pnpm","pnpm dlx skills add PyLops\u002Fpylops-agent-skills --skill accelerate-on-gpu","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpylops\u002Fskills\u002Faccelerate-on-gpu\u002FSKILL.md",true,[47],{"path":48,"resourceType":49,"resourceTypeDesc":50,"sizeBytes":51,"sourceHtmlUrl":52},"reference\u002Fbenchmark_template.py","SCRIPT","脚本",3919,"https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpylops\u002Fskills\u002Faccelerate-on-gpu\u002Freference\u002Fbenchmark_template.py",[54,61,68,75,82,89],{"skillNo":55,"name":56,"nameZh":6,"description":57,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":58,"categories":59,"keywords":60,"publishedAt":18},"01M7DCE0ERZ2MCH1ANEBTC1Y40","solve-nonsmooth-problem","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.","https:\u002F\u002Fgithub.com\u002FPyLops\u002Fpylops-agent-skills\u002Fblob\u002Fmain\u002Fplugins\u002Fpyproximal\u002Fskills\u002Fsolve-nonsmooth-problem\u002FSKILL.md",[],[],{"skillNo":62,"name":63,"nameZh":6,"description":64,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":65,"categories":66,"keywords":67,"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":69,"name":70,"nameZh":6,"description":71,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":72,"categories":73,"keywords":74,"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":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"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":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"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":90,"name":91,"nameZh":6,"description":92,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":93,"categories":94,"keywords":95,"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",[],[]]