dpnp-quickstart
NumPy-compatible array operations optimized for Intel hardware. Use when the user wants to migrate or port NumPy code to dpnp, asks whether a NumPy hot path can run on an Intel CPU or GPU, needs to check dpnp installation or SYCL device selection with dpctl, hits a NumPy API dpnp does not implement, or wants to compare dpnp against NumPy. Covers install, device control, fallback patterns, and profiling.
intel · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add intel/skills --skill dpnp-quickstartAbout this skill
name: dpnp-quickstart description: >- NumPy-compatible array operations optimized for Intel hardware. Use when the user wants to migrate or port NumPy code to dpnp, asks whether a NumPy hot path can run on an Intel CPU or GPU, needs to check dpnp installation or SYCL device selection with dpctl, hits a NumPy API dpnp does not implement, or wants to compare dpnp against NumPy. Covers install, device control, fallback patterns, and profiling. license: Apache-2.0 compatibility: "Requires dpnp and dpctl. GPU execution requires the Intel GPU driver stack and a SYCL-visible device." metadata: intel-skill-type: "tool-skill" version: "1.0"
dpnp quickstart
Purpose
Runs NumPy-style array operations on Intel CPUs and GPUs through dpnp, which
mirrors the NumPy API over SYCL device memory. Covers installation, SYCL device
selection with dpctl, migrating existing NumPy code, falling back to NumPy for
unimplemented APIs, and measuring whether the move actually paid off.
Prefer this over plain NumPy when the arrays are large and the work is math-heavy
on Intel hardware. Prefer plain NumPy when the arrays are small — dpnp has
dispatch overhead that a small array cannot amortize.
When to Use This Skill
Use this skill when:
- The user is migrating or porting NumPy code to Intel CPU or GPU execution.
- The user asks whether a NumPy hot path can run on an Intel GPU.
- The user needs to check a
dpnpinstall, or which SYCL device will be used. - The user hit a NumPy API that
dpnpdoes not implement. - The user wants to compare
dpnpagainst NumPy.
Use dpnp for:
- Large arrays (>10,000 elements)
- Math-heavy operations (linear algebra, FFT, reductions)
- Intel CPU/GPU acceleration
Do not use this skill — stick with NumPy — for:
- Small arrays (<1,000 elements)
- I/O operations
- APIs not yet implemented in dpnp
Quick Start
Run this first to confirm the environment before changing any user code.
# Conda (officially recommended)
conda install -c https://software.repos.intel.com/python/conda -c conda-forge --override-channels dpnp
# Alternative: pip (may have native dependency issues)
pip install dpnp
# verify installation
python -c "import dpnp; print(dpnp.__version__)"
Then confirm which device the arrays will actually land on:
import dpctl
import dpnp as np
print(dpctl.select_default_device())
x = np.arange(100_000)
print(x.sycl_device)
Report what this prints. Do not claim GPU execution if the output shows a CPU device — the default SYCL device is the GPU only when one is visible.
Implementation Guide
-
Confirm the environment — install and print the device, as in Quick Start.
-
Swap the import.
dpnpis a drop-in NumPy replacement for the covered API:# Drop-in NumPy replacement import dpnp as np # Create arrays x = np.array([1, 2, 3, 4]) y = np.arange(1000000) # Operations work like NumPy result = np.sum(y) dot_product = np.dot(x, x) -
Port the hot path. Array creation, reductions, and linear algebra keep their NumPy spelling:
import dpnp as np # Array creation a = np.zeros((100, 100)) b = np.ones(1000) c = np.linspace(0, 10, 100) # Math operations sum_val = np.sum(a) mean_val = np.mean(b) std_val = np.std(c) # Linear algebra mat = np.random.randn(100, 100) result = np.dot(mat, mat.T) -
Add fallbacks for uncovered APIs.
dpnpimplements a subset of NumPy, and coverage is per-parameter, not just per-function. Check withdir(dpnp)or the documentation, and guard the call:import dpnp import numpy as np def safe_unique(x): try: return dpnp.unique(x) except (NotImplementedError, TypeError): host_x = dpnp.asnumpy(x) if isinstance(x, dpnp.ndarray) else x return np.unique(host_x) -
Convert at API boundaries, not inside loops. Use
dpnp.asnumpy()when a downstream library needs a NumPy array. Pandas, scikit-learn, and many NumPy-based libraries usually expect NumPy arrays: usedpnpfor the numeric hot path, then convert once withasnumpy()before calling host-oriented libraries. Repeated device-to-host copies inside tight loops can erase acceleration gains. -
Constrain the device when the code must be portable. There is no ambient current-device setting and no context manager to enter — placement is an argument at construction. Inspect what is visible with
dpctl, then pin allocation withdevice=or by reusing an existing array's queue, when the same code runs across workstations, containers, and cloud VMs with different SYCL devices:import dpctl import dpnp print([d.filter_string for d in dpctl.get_devices()]) # what is actually there x = dpnp.arange(100_000, device="cpu") # pin this array print(x.sycl_device) y = dpnp.zeros(x.size, sycl_queue=x.sycl_queue) # keep the next one beside it -
Validate, then measure. Compare against NumPy with
numpy.testing.assert_allclose()for critical math before making any performance claim.
Performance
No verified benchmark numbers ship with this skill yet. Do not state a speedup that measurement in the user's own environment does not support.
To measure:
- Warm up once before timing, to avoid measuring first-run compilation.
- Compare against NumPy with the same inputs and dtype.
- Profile end-to-end pipelines, including conversions and host-library calls.
Gotchas & Limitations
- First run is slow: JIT compilation happens on first execution. Time the second run.
- Not all NumPy APIs available: Check compatibility with
dir(dpnp)or documentation. - Data transfer cost: Converting between dpnp and NumPy arrays has overhead. Avoid in tight loops.
- Small arrays slower: dpnp has dispatch overhead. Use NumPy for s