[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-nvidia-accelerated-computing-cudf":3,"mdc-kmspck-key":34,"related-org-nvidia-accelerated-computing-cudf":1348,"related-repo-nvidia-accelerated-computing-cudf":1508},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":23,"repoUrl":24,"updatedAt":25,"license":26,"forks":27,"topics":28,"repo":29,"sourceUrl":32,"mdContent":33},"accelerated-computing-cudf","accelerate data processing with cuDF","Official NVIDIA-authored guidance for NVIDIA cuDF GPU DataFrames, pandas acceleration, dask-cuDF, ETL, joins, groupby, CSV\u002FParquet I\u002FO, nullable semantics, and multi-GPU DataFrame workloads.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},"nvidia","NVIDIA","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Fnvidia.png",[12,16,19,22],{"name":13,"slug":14,"type":15},"Performance","performance","tag",{"name":17,"slug":18,"type":15},"Data Engineering","data-engineering",{"name":20,"slug":21,"type":15},"Data Analysis","data-analysis",{"name":9,"slug":8,"type":15},2473,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fskills","2026-07-14T05:28:43.176466","CC-BY-4.0 AND Apache-2.0",281,[],{"repoUrl":24,"stars":23,"forks":27,"topics":30,"description":31},[],"AI agent skills published by NVIDIA","https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fskills\u002Ftree\u002FHEAD\u002Fskills\u002Faccelerated-computing-cudf","---\nname: accelerated-computing-cudf\ndescription: Official NVIDIA-authored guidance for NVIDIA cuDF GPU DataFrames, pandas acceleration, dask-cuDF, ETL, joins, groupby, CSV\u002FParquet I\u002FO, nullable semantics, and multi-GPU DataFrame workloads.\nlicense: CC-BY-4.0 AND Apache-2.0\nmetadata:\n  author: NVIDIA\n  tags:\n    - cudf\n    - dataframes\n    - pandas\n    - dask-cudf\n    - etl\n---\n\n# cuDF & dask-cuDF Implementer's Guide\n\n## Compatibility\n\n- Release tracked by this skill: 26.04.\n- Requires NVIDIA Volta or newer on CUDA 12, or Turing or newer on CUDA 13. Release 26.04 supports CUDA 12.2-12.9 with driver 535+ or CUDA 13.0-13.1 with driver 580+, and Python 3.11-3.14. cuDF sweet spot: >100K rows.\n\n## Naming\n\nUse NVIDIA library-first wording in user-facing answers. Keep literal RAPIDS\u002Frapidsai URLs, package names, and release metadata when citing sources.\n\n## Role\n\nYou are a cuDF expert helping an implementer work with GPU DataFrames. The user understands pandas and their data — your job is to get them to correct, fast GPU code with minimal friction. Choose the path from the user's intent: `cudf.pandas` for broad compatibility or minimal-change acceleration, explicit cuDF for named DataFrame migrations, hot ETL paths, and parity-sensitive work. Treat source schema, row counts, null placement, ordering, and numeric tolerances as user-visible behavior.\n\n## Critical Rules\n\n1. **Choose the right cuDF path.** Use `cudf.pandas` for broad compatibility or minimal-change acceleration. Use explicit cuDF when the user asks to migrate DataFrame code, inspect parity, optimize a visible ETL hot path, or control unsupported operations.\n2. **Size gate: 100K rows minimum.** Below that, GPU transfer overhead usually beats the speedup; use small data for correctness and benchmark larger working sets for performance.\n3. **Keep conversions at boundaries.** Use `.to_pandas()`, `.values`, or `.numpy()` for display, plotting, CPU-only libraries, or final output boundaries. Keep intermediate ETL data on GPU.\n4. **Float32 is your friend.** cuDF operations on float64 are slower; cast early when precision allows.\n5. **Validate semantics on representative slices.** For null handling, joins, time series, reshape, or grouped logic, keep a small pandas reference path and compare shape, labels, null counts, ordering, and representative values before claiming parity.\n6. **For data > GPU memory**, move to dask-cuDF with `enable_cudf_spill=True`. See `references\u002Fdask-cudf-patterns.md`.\n\n## Three Paths to GPU DataFrames\n\n### Path 1: cudf.pandas Accelerator (Compatibility \u002F Minimal Change)\n\nUse when the user needs a small code change, third-party pandas compatibility,\nor one code path that can keep running while unsupported operations fall back.\n\n**Jupyter\u002FIPython:**\n```python\n%load_ext cudf.pandas\nimport pandas as pd   # now GPU-backed; falls back silently for unsupported ops\n```\n\n**Script:**\n```bash\npython -m cudf.pandas my_script.py\n```\n\n**With multiprocessing:**\n```python\nimport cudf.pandas\ncudf.pandas.install()   # must come BEFORE pandas import, before Pool creation\nfrom multiprocessing import Pool\n```\n\nConfirm acceleration with the cudf.pandas profiler before claiming speedup.\nFor notebook, CLI, and stats examples, read\n`references\u002Fcudf-pandas-accelerator.md`. If the profile shows the hot path\nrunning on CPU, use Path 2 for explicit cuDF control.\n\n### Path 2: Explicit cuDF API\n\nFor full control, hot-path optimization, named DataFrame migrations, and\nparity-sensitive operations:\n\n```python\nimport cudf\n\n# Read data directly to GPU\ndf = cudf.read_parquet(\"data.parquet\")\n\n# Operations mirror pandas\nresult = df.groupby(\"key\")[\"value\"].sum()\nmerged = df.merge(lookup, on=\"id\", how=\"left\")\nfiltered = df[df[\"amount\"] > 1000]\n\n# String operations\ndf[\"clean\"] = df[\"name\"].str.strip().str.lower()\n\n# To check API coverage before committing to migration:\n# See references\u002Fapi-patterns.md for known gaps and workarounds\n```\n\n**Keep data on GPU end-to-end.** Only call `.to_pandas()` at the very end for display or CPU or non-GPU handoff.\n\nPrefer explicit cuDF for tasks involving `read_csv`\u002F`read_parquet`, joins,\ngroupby, reshape, nullable types, `fillna`\u002F`where`, time buckets, rolling\nwindows, or CPU\u002FGPU parity checks. Add a small CPU\u002FGPU validation path when\nsemantics matter instead of relying on successful execution alone.\n\nFor pandas code with null handling, reshape, or time-series behavior, read\n`references\u002Fapi-patterns.md` for the relevant semantic checklist before\nrewriting. A `cudf.pandas` bootstrap is enough for a minimal-change request; an\nimplementation request should make the hot path explicit and observable.\n\nFor reshape-heavy pandas code (`pivot_table`, `melt`, `stack`\u002F`unstack`,\n`crosstab`), keep the source schema as part of the contract: index labels,\ncolumn labels or levels, `fill_value`, `aggfunc`, margins, and normalization.\nUse explicit cuDF where the equivalent is supported; use `cudf.pandas` or a\nnarrow compatibility boundary when exact pandas reshape semantics matter more\nthan rewriting every operation. Add a small pandas-reference parity check for\nshape, labels, and representative values before finalizing. See\n`references\u002Fapi-patterns.md`.\n\n### Path 3: dask-cuDF (Multi-GPU \u002F Large Data)\n\nWhen dataset exceeds GPU memory. See `references\u002Fdask-cudf-patterns.md` for full patterns.\n\n```python\nfrom dask_cuda import LocalCUDACluster\nfrom dask.distributed import Client\nimport dask_cudf\n\ncluster = LocalCUDACluster(enable_cudf_spill=True)  # one worker per GPU\nclient = Client(cluster)\n\nddf = dask_cudf.read_parquet(\"s3:\u002F\u002Fbucket\u002Fdata\u002F*.parquet\")\nresult = ddf.groupby(\"key\").agg({\"value\": \"sum\"}).compute()\n```\n\n## Memory Management\n\n**Enable spill before OOM happens** (not after):\n```python\nimport cudf\ncudf.set_option(\"spill\", True)   # spill to host RAM when GPU is full\n```\n\n**RMM pool allocator** (reduces cudaMalloc overhead in pipelines with many allocations):\n```python\nimport rmm\nrmm.set_current_device_resource(rmm.mr.CudaAsyncMemoryResource())\n# Must be called BEFORE any cuDF operations\n```\n\n| GPU Free vs Dataset | Strategy |\n|---|---|\n| Free > 2× dataset | Single GPU cuDF |\n| Free 1–2× dataset | cuDF + `cudf.set_option(\"spill\", True)` |\n| Dataset > GPU mem | dask-cuDF |\n| Dataset > node mem | dask-cuDF + multi-node (see accelerated-computing-mpf) |\n\n## Troubleshooting\n\n**No speedup vs pandas:**\n- Data \u003C 100K rows? GPU overhead dominates, so treat the run as correctness validation and measure speedup on a larger working set.\n- Run `%%cudf.pandas.profile` — high CPU % means many fallbacks. Identify and fix those ops.\n- Check `references\u002Fapi-patterns.md` for known gaps.\n\n**OOM (CUDA out of memory):**\n1. Enable spill: `cudf.set_option(\"spill\", True)`\n2. If allocator fragmentation or repeated allocation overhead is visible, use the `accelerated-computing-rmm` memory-resource setup guidance before GPU allocations\n3. Still failing: move to dask-cuDF\n\n**AttributeError \u002F NotImplementedError:**\n- Check `references\u002Fapi-patterns.md` for the specific operation\n- Keep that one operation on CPU at a narrow boundary and continue the supported pipeline on GPU\n- Use `.to_pandas()` only for the unsupported op, then `.from_pandas()` back\n\n**Wrong results vs pandas:**\n- Null\u002FNaN handling differs: cuDF uses `\u003CNA>` (nullable) by default, pandas uses `NaN`. See `references\u002Fapi-patterns.md`.\n- Sort stability: cuDF sort is not guaranteed stable unless `stable=True` is passed\n- If the difference is due to floating point differences, try casting to higher precision floats (e.g. `float64` instead of `float32`). If the results are still different, stop. GPU and CPU algorithms will always produce different results on floating point numbers due to the non-associativity of floating point arithmetic and that cannot be fixed.\n\n## Nullable and Fill Semantics\n\nWhen the user explicitly cares about pandas nullable dtypes, `fillna`,\n`where`\u002F`mask`, or grouped null behavior, treat parity checks as part of the\nimplementation. See `references\u002Fapi-patterns.md` for nullable dtype examples.\n\n- Preserve nullable integer\u002Fstring columns instead of filling them with sentinel\n  values unless the source code already did that.\n- Keep `where`\u002F`mask` semantics when they encode a condition. Use broad\n  `fillna` only when the condition is exactly null-only.\n- Compare with `to_pandas(nullable=True)` when the pandas reference uses\n  nullable extension dtypes.\n- Put the parity check in a reusable helper next to the GPU path, so future\n  changes exercise the same nullable conversion and aggregation checks.\n- Validate row counts, null counts, mask truth tables, grouped aggregates, and\n  representative dtypes before claiming semantic parity.\n\n## Reference Files\n\n- `references\u002Fcudf-pandas-accelerator.md` — Profiling, fallback detection, cudf.pandas deep dive\n- `references\u002Fapi-patterns.md` — Known API gaps, workarounds, semantic differences\n- `references\u002Fdask-cudf-patterns.md` — Multi-GPU patterns, best practices, partition tuning\n\n## External Documentation\n\nUse WebFetch to retrieve detailed API signatures, parameter descriptions, and examples on demand.\n\n- **cuDF Documentation:** https:\u002F\u002Fdocs.rapids.ai\u002Fapi\u002Fcudf\u002Fstable\u002F\n- **dask-cuDF API Reference:** https:\u002F\u002Fdocs.rapids.ai\u002Fapi\u002Fdask-cudf\u002Fstable\u002Fapi\u002F\n- **GitHub:** https:\u002F\u002Fgithub.com\u002Frapidsai\u002Fcudf\n- **CHANGELOG:** https:\u002F\u002Fgithub.com\u002Frapidsai\u002Fcudf\u002Fblob\u002Fmain\u002FCHANGELOG.md\n",{"data":35,"body":43},{"name":4,"description":6,"license":26,"metadata":36},{"author":9,"tags":37},[38,39,40,41,42],"cudf","dataframes","pandas","dask-cudf","etl",{"type":44,"children":45},"root",[46,55,62,77,83,89,95,109,115,226,232,239,244,252,283,291,324,332,364,377,383,388,525,542,578,598,668,674,686,763,769,779,801,811,842,928,934,942,975,983,1014,1022,1061,1069,1132,1138,1170,1226,1232,1265,1271,1276,1342],{"type":47,"tag":48,"props":49,"children":51},"element","h1",{"id":50},"cudf-dask-cudf-implementers-guide",[52],{"type":53,"value":54},"text","cuDF & dask-cuDF Implementer's Guide",{"type":47,"tag":56,"props":57,"children":59},"h2",{"id":58},"compatibility",[60],{"type":53,"value":61},"Compatibility",{"type":47,"tag":63,"props":64,"children":65},"ul",{},[66,72],{"type":47,"tag":67,"props":68,"children":69},"li",{},[70],{"type":53,"value":71},"Release tracked by this skill: 26.04.",{"type":47,"tag":67,"props":73,"children":74},{},[75],{"type":53,"value":76},"Requires NVIDIA Volta or newer on CUDA 12, or Turing or newer on CUDA 13. Release 26.04 supports CUDA 12.2-12.9 with driver 535+ or CUDA 13.0-13.1 with driver 580+, and Python 3.11-3.14. cuDF sweet spot: >100K rows.",{"type":47,"tag":56,"props":78,"children":80},{"id":79},"naming",[81],{"type":53,"value":82},"Naming",{"type":47,"tag":84,"props":85,"children":86},"p",{},[87],{"type":53,"value":88},"Use NVIDIA library-first wording in user-facing answers. Keep literal RAPIDS\u002Frapidsai URLs, package names, and release metadata when citing sources.",{"type":47,"tag":56,"props":90,"children":92},{"id":91},"role",[93],{"type":53,"value":94},"Role",{"type":47,"tag":84,"props":96,"children":97},{},[98,100,107],{"type":53,"value":99},"You are a cuDF expert helping an implementer work with GPU DataFrames. The user understands pandas and their data — your job is to get them to correct, fast GPU code with minimal friction. Choose the path from the user's intent: ",{"type":47,"tag":101,"props":102,"children":104},"code",{"className":103},[],[105],{"type":53,"value":106},"cudf.pandas",{"type":53,"value":108}," for broad compatibility or minimal-change acceleration, explicit cuDF for named DataFrame migrations, hot ETL paths, and parity-sensitive work. Treat source schema, row counts, null placement, ordering, and numeric tolerances as user-visible behavior.",{"type":47,"tag":56,"props":110,"children":112},{"id":111},"critical-rules",[113],{"type":53,"value":114},"Critical Rules",{"type":47,"tag":116,"props":117,"children":118},"ol",{},[119,137,147,180,190,200],{"type":47,"tag":67,"props":120,"children":121},{},[122,128,130,135],{"type":47,"tag":123,"props":124,"children":125},"strong",{},[126],{"type":53,"value":127},"Choose the right cuDF path.",{"type":53,"value":129}," Use ",{"type":47,"tag":101,"props":131,"children":133},{"className":132},[],[134],{"type":53,"value":106},{"type":53,"value":136}," for broad compatibility or minimal-change acceleration. Use explicit cuDF when the user asks to migrate DataFrame code, inspect parity, optimize a visible ETL hot path, or control unsupported operations.",{"type":47,"tag":67,"props":138,"children":139},{},[140,145],{"type":47,"tag":123,"props":141,"children":142},{},[143],{"type":53,"value":144},"Size gate: 100K rows minimum.",{"type":53,"value":146}," Below that, GPU transfer overhead usually beats the speedup; use small data for correctness and benchmark larger working sets for performance.",{"type":47,"tag":67,"props":148,"children":149},{},[150,155,156,162,164,170,172,178],{"type":47,"tag":123,"props":151,"children":152},{},[153],{"type":53,"value":154},"Keep conversions at boundaries.",{"type":53,"value":129},{"type":47,"tag":101,"props":157,"children":159},{"className":158},[],[160],{"type":53,"value":161},".to_pandas()",{"type":53,"value":163},", ",{"type":47,"tag":101,"props":165,"children":167},{"className":166},[],[168],{"type":53,"value":169},".values",{"type":53,"value":171},", or ",{"type":47,"tag":101,"props":173,"children":175},{"className":174},[],[176],{"type":53,"value":177},".numpy()",{"type":53,"value":179}," for display, plotting, CPU-only libraries, or final output boundaries. Keep intermediate ETL data on GPU.",{"type":47,"tag":67,"props":181,"children":182},{},[183,188],{"type":47,"tag":123,"props":184,"children":185},{},[186],{"type":53,"value":187},"Float32 is your friend.",{"type":53,"value":189}," cuDF operations on float64 are slower; cast early when precision allows.",{"type":47,"tag":67,"props":191,"children":192},{},[193,198],{"type":47,"tag":123,"props":194,"children":195},{},[196],{"type":53,"value":197},"Validate semantics on representative slices.",{"type":53,"value":199}," For null handling, joins, time series, reshape, or grouped logic, keep a small pandas reference path and compare shape, labels, null counts, ordering, and representative values before claiming parity.",{"type":47,"tag":67,"props":201,"children":202},{},[203,208,210,216,218,224],{"type":47,"tag":123,"props":204,"children":205},{},[206],{"type":53,"value":207},"For data > GPU memory",{"type":53,"value":209},", move to dask-cuDF with ",{"type":47,"tag":101,"props":211,"children":213},{"className":212},[],[214],{"type":53,"value":215},"enable_cudf_spill=True",{"type":53,"value":217},". See ",{"type":47,"tag":101,"props":219,"children":221},{"className":220},[],[222],{"type":53,"value":223},"references\u002Fdask-cudf-patterns.md",{"type":53,"value":225},".",{"type":47,"tag":56,"props":227,"children":229},{"id":228},"three-paths-to-gpu-dataframes",[230],{"type":53,"value":231},"Three Paths to GPU DataFrames",{"type":47,"tag":233,"props":234,"children":236},"h3",{"id":235},"path-1-cudfpandas-accelerator-compatibility-minimal-change",[237],{"type":53,"value":238},"Path 1: cudf.pandas Accelerator (Compatibility \u002F Minimal Change)",{"type":47,"tag":84,"props":240,"children":241},{},[242],{"type":53,"value":243},"Use when the user needs a small code change, third-party pandas compatibility,\nor one code path that can keep running while unsupported operations fall back.",{"type":47,"tag":84,"props":245,"children":246},{},[247],{"type":47,"tag":123,"props":248,"children":249},{},[250],{"type":53,"value":251},"Jupyter\u002FIPython:",{"type":47,"tag":253,"props":254,"children":259},"pre",{"className":255,"code":256,"language":257,"meta":258,"style":258},"language-python shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","%load_ext cudf.pandas\nimport pandas as pd   # now GPU-backed; falls back silently for unsupported ops\n","python","",[260],{"type":47,"tag":101,"props":261,"children":262},{"__ignoreMap":258},[263,274],{"type":47,"tag":264,"props":265,"children":268},"span",{"class":266,"line":267},"line",1,[269],{"type":47,"tag":264,"props":270,"children":271},{},[272],{"type":53,"value":273},"%load_ext cudf.pandas\n",{"type":47,"tag":264,"props":275,"children":277},{"class":266,"line":276},2,[278],{"type":47,"tag":264,"props":279,"children":280},{},[281],{"type":53,"value":282},"import pandas as pd   # now GPU-backed; falls back silently for unsupported ops\n",{"type":47,"tag":84,"props":284,"children":285},{},[286],{"type":47,"tag":123,"props":287,"children":288},{},[289],{"type":53,"value":290},"Script:",{"type":47,"tag":253,"props":292,"children":296},{"className":293,"code":294,"language":295,"meta":258,"style":258},"language-bash shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","python -m cudf.pandas my_script.py\n","bash",[297],{"type":47,"tag":101,"props":298,"children":299},{"__ignoreMap":258},[300],{"type":47,"tag":264,"props":301,"children":302},{"class":266,"line":267},[303,308,314,319],{"type":47,"tag":264,"props":304,"children":306},{"style":305},"--shiki-light:#E2931D;--shiki-default:#FFCB6B;--shiki-dark:#FFCB6B",[307],{"type":53,"value":257},{"type":47,"tag":264,"props":309,"children":311},{"style":310},"--shiki-light:#91B859;--shiki-default:#C3E88D;--shiki-dark:#C3E88D",[312],{"type":53,"value":313}," -m",{"type":47,"tag":264,"props":315,"children":316},{"style":310},[317],{"type":53,"value":318}," cudf.pandas",{"type":47,"tag":264,"props":320,"children":321},{"style":310},[322],{"type":53,"value":323}," my_script.py\n",{"type":47,"tag":84,"props":325,"children":326},{},[327],{"type":47,"tag":123,"props":328,"children":329},{},[330],{"type":53,"value":331},"With multiprocessing:",{"type":47,"tag":253,"props":333,"children":335},{"className":255,"code":334,"language":257,"meta":258,"style":258},"import cudf.pandas\ncudf.pandas.install()   # must come BEFORE pandas import, before Pool creation\nfrom multiprocessing import Pool\n",[336],{"type":47,"tag":101,"props":337,"children":338},{"__ignoreMap":258},[339,347,355],{"type":47,"tag":264,"props":340,"children":341},{"class":266,"line":267},[342],{"type":47,"tag":264,"props":343,"children":344},{},[345],{"type":53,"value":346},"import cudf.pandas\n",{"type":47,"tag":264,"props":348,"children":349},{"class":266,"line":276},[350],{"type":47,"tag":264,"props":351,"children":352},{},[353],{"type":53,"value":354},"cudf.pandas.install()   # must come BEFORE pandas import, before Pool creation\n",{"type":47,"tag":264,"props":356,"children":358},{"class":266,"line":357},3,[359],{"type":47,"tag":264,"props":360,"children":361},{},[362],{"type":53,"value":363},"from multiprocessing import Pool\n",{"type":47,"tag":84,"props":365,"children":366},{},[367,369,375],{"type":53,"value":368},"Confirm acceleration with the cudf.pandas profiler before claiming speedup.\nFor notebook, CLI, and stats examples, read\n",{"type":47,"tag":101,"props":370,"children":372},{"className":371},[],[373],{"type":53,"value":374},"references\u002Fcudf-pandas-accelerator.md",{"type":53,"value":376},". If the profile shows the hot path\nrunning on CPU, use Path 2 for explicit cuDF control.",{"type":47,"tag":233,"props":378,"children":380},{"id":379},"path-2-explicit-cudf-api",[381],{"type":53,"value":382},"Path 2: Explicit cuDF API",{"type":47,"tag":84,"props":384,"children":385},{},[386],{"type":53,"value":387},"For full control, hot-path optimization, named DataFrame migrations, and\nparity-sensitive operations:",{"type":47,"tag":253,"props":389,"children":391},{"className":255,"code":390,"language":257,"meta":258,"style":258},"import cudf\n\n# Read data directly to GPU\ndf = cudf.read_parquet(\"data.parquet\")\n\n# Operations mirror pandas\nresult = df.groupby(\"key\")[\"value\"].sum()\nmerged = df.merge(lookup, on=\"id\", how=\"left\")\nfiltered = df[df[\"amount\"] > 1000]\n\n# String operations\ndf[\"clean\"] = df[\"name\"].str.strip().str.lower()\n\n# To check API coverage before committing to migration:\n# See references\u002Fapi-patterns.md for known gaps and workarounds\n",[392],{"type":47,"tag":101,"props":393,"children":394},{"__ignoreMap":258},[395,403,412,420,429,437,446,455,464,473,481,490,499,507,516],{"type":47,"tag":264,"props":396,"children":397},{"class":266,"line":267},[398],{"type":47,"tag":264,"props":399,"children":400},{},[401],{"type":53,"value":402},"import cudf\n",{"type":47,"tag":264,"props":404,"children":405},{"class":266,"line":276},[406],{"type":47,"tag":264,"props":407,"children":409},{"emptyLinePlaceholder":408},true,[410],{"type":53,"value":411},"\n",{"type":47,"tag":264,"props":413,"children":414},{"class":266,"line":357},[415],{"type":47,"tag":264,"props":416,"children":417},{},[418],{"type":53,"value":419},"# Read data directly to GPU\n",{"type":47,"tag":264,"props":421,"children":423},{"class":266,"line":422},4,[424],{"type":47,"tag":264,"props":425,"children":426},{},[427],{"type":53,"value":428},"df = cudf.read_parquet(\"data.parquet\")\n",{"type":47,"tag":264,"props":430,"children":432},{"class":266,"line":431},5,[433],{"type":47,"tag":264,"props":434,"children":435},{"emptyLinePlaceholder":408},[436],{"type":53,"value":411},{"type":47,"tag":264,"props":438,"children":440},{"class":266,"line":439},6,[441],{"type":47,"tag":264,"props":442,"children":443},{},[444],{"type":53,"value":445},"# Operations mirror pandas\n",{"type":47,"tag":264,"props":447,"children":449},{"class":266,"line":448},7,[450],{"type":47,"tag":264,"props":451,"children":452},{},[453],{"type":53,"value":454},"result = df.groupby(\"key\")[\"value\"].sum()\n",{"type":47,"tag":264,"props":456,"children":458},{"class":266,"line":457},8,[459],{"type":47,"tag":264,"props":460,"children":461},{},[462],{"type":53,"value":463},"merged = df.merge(lookup, on=\"id\", how=\"left\")\n",{"type":47,"tag":264,"props":465,"children":467},{"class":266,"line":466},9,[468],{"type":47,"tag":264,"props":469,"children":470},{},[471],{"type":53,"value":472},"filtered = df[df[\"amount\"] > 1000]\n",{"type":47,"tag":264,"props":474,"children":476},{"class":266,"line":475},10,[477],{"type":47,"tag":264,"props":478,"children":479},{"emptyLinePlaceholder":408},[480],{"type":53,"value":411},{"type":47,"tag":264,"props":482,"children":484},{"class":266,"line":483},11,[485],{"type":47,"tag":264,"props":486,"children":487},{},[488],{"type":53,"value":489},"# String operations\n",{"type":47,"tag":264,"props":491,"children":493},{"class":266,"line":492},12,[494],{"type":47,"tag":264,"props":495,"children":496},{},[497],{"type":53,"value":498},"df[\"clean\"] = df[\"name\"].str.strip().str.lower()\n",{"type":47,"tag":264,"props":500,"children":502},{"class":266,"line":501},13,[503],{"type":47,"tag":264,"props":504,"children":505},{"emptyLinePlaceholder":408},[506],{"type":53,"value":411},{"type":47,"tag":264,"props":508,"children":510},{"class":266,"line":509},14,[511],{"type":47,"tag":264,"props":512,"children":513},{},[514],{"type":53,"value":515},"# To check API coverage before committing to migration:\n",{"type":47,"tag":264,"props":517,"children":519},{"class":266,"line":518},15,[520],{"type":47,"tag":264,"props":521,"children":522},{},[523],{"type":53,"value":524},"# See references\u002Fapi-patterns.md for known gaps and workarounds\n",{"type":47,"tag":84,"props":526,"children":527},{},[528,533,535,540],{"type":47,"tag":123,"props":529,"children":530},{},[531],{"type":53,"value":532},"Keep data on GPU end-to-end.",{"type":53,"value":534}," Only call ",{"type":47,"tag":101,"props":536,"children":538},{"className":537},[],[539],{"type":53,"value":161},{"type":53,"value":541}," at the very end for display or CPU or non-GPU handoff.",{"type":47,"tag":84,"props":543,"children":544},{},[545,547,553,555,561,563,569,570,576],{"type":53,"value":546},"Prefer explicit cuDF for tasks involving ",{"type":47,"tag":101,"props":548,"children":550},{"className":549},[],[551],{"type":53,"value":552},"read_csv",{"type":53,"value":554},"\u002F",{"type":47,"tag":101,"props":556,"children":558},{"className":557},[],[559],{"type":53,"value":560},"read_parquet",{"type":53,"value":562},", joins,\ngroupby, reshape, nullable types, ",{"type":47,"tag":101,"props":564,"children":566},{"className":565},[],[567],{"type":53,"value":568},"fillna",{"type":53,"value":554},{"type":47,"tag":101,"props":571,"children":573},{"className":572},[],[574],{"type":53,"value":575},"where",{"type":53,"value":577},", time buckets, rolling\nwindows, or CPU\u002FGPU parity checks. Add a small CPU\u002FGPU validation path when\nsemantics matter instead of relying on successful execution alone.",{"type":47,"tag":84,"props":579,"children":580},{},[581,583,589,591,596],{"type":53,"value":582},"For pandas code with null handling, reshape, or time-series behavior, read\n",{"type":47,"tag":101,"props":584,"children":586},{"className":585},[],[587],{"type":53,"value":588},"references\u002Fapi-patterns.md",{"type":53,"value":590}," for the relevant semantic checklist before\nrewriting. A ",{"type":47,"tag":101,"props":592,"children":594},{"className":593},[],[595],{"type":53,"value":106},{"type":53,"value":597}," bootstrap is enough for a minimal-change request; an\nimplementation request should make the hot path explicit and observable.",{"type":47,"tag":84,"props":599,"children":600},{},[601,603,609,610,616,617,623,624,630,632,638,640,646,647,653,655,660,662,667],{"type":53,"value":602},"For reshape-heavy pandas code (",{"type":47,"tag":101,"props":604,"children":606},{"className":605},[],[607],{"type":53,"value":608},"pivot_table",{"type":53,"value":163},{"type":47,"tag":101,"props":611,"children":613},{"className":612},[],[614],{"type":53,"value":615},"melt",{"type":53,"value":163},{"type":47,"tag":101,"props":618,"children":620},{"className":619},[],[621],{"type":53,"value":622},"stack",{"type":53,"value":554},{"type":47,"tag":101,"props":625,"children":627},{"className":626},[],[628],{"type":53,"value":629},"unstack",{"type":53,"value":631},",\n",{"type":47,"tag":101,"props":633,"children":635},{"className":634},[],[636],{"type":53,"value":637},"crosstab",{"type":53,"value":639},"), keep the source schema as part of the contract: index labels,\ncolumn labels or levels, ",{"type":47,"tag":101,"props":641,"children":643},{"className":642},[],[644],{"type":53,"value":645},"fill_value",{"type":53,"value":163},{"type":47,"tag":101,"props":648,"children":650},{"className":649},[],[651],{"type":53,"value":652},"aggfunc",{"type":53,"value":654},", margins, and normalization.\nUse explicit cuDF where the equivalent is supported; use ",{"type":47,"tag":101,"props":656,"children":658},{"className":657},[],[659],{"type":53,"value":106},{"type":53,"value":661}," or a\nnarrow compatibility boundary when exact pandas reshape semantics matter more\nthan rewriting every operation. Add a small pandas-reference parity check for\nshape, labels, and representative values before finalizing. See\n",{"type":47,"tag":101,"props":663,"children":665},{"className":664},[],[666],{"type":53,"value":588},{"type":53,"value":225},{"type":47,"tag":233,"props":669,"children":671},{"id":670},"path-3-dask-cudf-multi-gpu-large-data",[672],{"type":53,"value":673},"Path 3: dask-cuDF (Multi-GPU \u002F Large Data)",{"type":47,"tag":84,"props":675,"children":676},{},[677,679,684],{"type":53,"value":678},"When dataset exceeds GPU memory. See ",{"type":47,"tag":101,"props":680,"children":682},{"className":681},[],[683],{"type":53,"value":223},{"type":53,"value":685}," for full patterns.",{"type":47,"tag":253,"props":687,"children":689},{"className":255,"code":688,"language":257,"meta":258,"style":258},"from dask_cuda import LocalCUDACluster\nfrom dask.distributed import Client\nimport dask_cudf\n\ncluster = LocalCUDACluster(enable_cudf_spill=True)  # one worker per GPU\nclient = Client(cluster)\n\nddf = dask_cudf.read_parquet(\"s3:\u002F\u002Fbucket\u002Fdata\u002F*.parquet\")\nresult = ddf.groupby(\"key\").agg({\"value\": \"sum\"}).compute()\n",[690],{"type":47,"tag":101,"props":691,"children":692},{"__ignoreMap":258},[693,701,709,717,724,732,740,747,755],{"type":47,"tag":264,"props":694,"children":695},{"class":266,"line":267},[696],{"type":47,"tag":264,"props":697,"children":698},{},[699],{"type":53,"value":700},"from dask_cuda import LocalCUDACluster\n",{"type":47,"tag":264,"props":702,"children":703},{"class":266,"line":276},[704],{"type":47,"tag":264,"props":705,"children":706},{},[707],{"type":53,"value":708},"from dask.distributed import Client\n",{"type":47,"tag":264,"props":710,"children":711},{"class":266,"line":357},[712],{"type":47,"tag":264,"props":713,"children":714},{},[715],{"type":53,"value":716},"import dask_cudf\n",{"type":47,"tag":264,"props":718,"children":719},{"class":266,"line":422},[720],{"type":47,"tag":264,"props":721,"children":722},{"emptyLinePlaceholder":408},[723],{"type":53,"value":411},{"type":47,"tag":264,"props":725,"children":726},{"class":266,"line":431},[727],{"type":47,"tag":264,"props":728,"children":729},{},[730],{"type":53,"value":731},"cluster = LocalCUDACluster(enable_cudf_spill=True)  # one worker per GPU\n",{"type":47,"tag":264,"props":733,"children":734},{"class":266,"line":439},[735],{"type":47,"tag":264,"props":736,"children":737},{},[738],{"type":53,"value":739},"client = Client(cluster)\n",{"type":47,"tag":264,"props":741,"children":742},{"class":266,"line":448},[743],{"type":47,"tag":264,"props":744,"children":745},{"emptyLinePlaceholder":408},[746],{"type":53,"value":411},{"type":47,"tag":264,"props":748,"children":749},{"class":266,"line":457},[750],{"type":47,"tag":264,"props":751,"children":752},{},[753],{"type":53,"value":754},"ddf = dask_cudf.read_parquet(\"s3:\u002F\u002Fbucket\u002Fdata\u002F*.parquet\")\n",{"type":47,"tag":264,"props":756,"children":757},{"class":266,"line":466},[758],{"type":47,"tag":264,"props":759,"children":760},{},[761],{"type":53,"value":762},"result = ddf.groupby(\"key\").agg({\"value\": \"sum\"}).compute()\n",{"type":47,"tag":56,"props":764,"children":766},{"id":765},"memory-management",[767],{"type":53,"value":768},"Memory Management",{"type":47,"tag":84,"props":770,"children":771},{},[772,777],{"type":47,"tag":123,"props":773,"children":774},{},[775],{"type":53,"value":776},"Enable spill before OOM happens",{"type":53,"value":778}," (not after):",{"type":47,"tag":253,"props":780,"children":782},{"className":255,"code":781,"language":257,"meta":258,"style":258},"import cudf\ncudf.set_option(\"spill\", True)   # spill to host RAM when GPU is full\n",[783],{"type":47,"tag":101,"props":784,"children":785},{"__ignoreMap":258},[786,793],{"type":47,"tag":264,"props":787,"children":788},{"class":266,"line":267},[789],{"type":47,"tag":264,"props":790,"children":791},{},[792],{"type":53,"value":402},{"type":47,"tag":264,"props":794,"children":795},{"class":266,"line":276},[796],{"type":47,"tag":264,"props":797,"children":798},{},[799],{"type":53,"value":800},"cudf.set_option(\"spill\", True)   # spill to host RAM when GPU is full\n",{"type":47,"tag":84,"props":802,"children":803},{},[804,809],{"type":47,"tag":123,"props":805,"children":806},{},[807],{"type":53,"value":808},"RMM pool allocator",{"type":53,"value":810}," (reduces cudaMalloc overhead in pipelines with many allocations):",{"type":47,"tag":253,"props":812,"children":814},{"className":255,"code":813,"language":257,"meta":258,"style":258},"import rmm\nrmm.set_current_device_resource(rmm.mr.CudaAsyncMemoryResource())\n# Must be called BEFORE any cuDF operations\n",[815],{"type":47,"tag":101,"props":816,"children":817},{"__ignoreMap":258},[818,826,834],{"type":47,"tag":264,"props":819,"children":820},{"class":266,"line":267},[821],{"type":47,"tag":264,"props":822,"children":823},{},[824],{"type":53,"value":825},"import rmm\n",{"type":47,"tag":264,"props":827,"children":828},{"class":266,"line":276},[829],{"type":47,"tag":264,"props":830,"children":831},{},[832],{"type":53,"value":833},"rmm.set_current_device_resource(rmm.mr.CudaAsyncMemoryResource())\n",{"type":47,"tag":264,"props":835,"children":836},{"class":266,"line":357},[837],{"type":47,"tag":264,"props":838,"children":839},{},[840],{"type":53,"value":841},"# Must be called BEFORE any cuDF operations\n",{"type":47,"tag":843,"props":844,"children":845},"table",{},[846,865],{"type":47,"tag":847,"props":848,"children":849},"thead",{},[850],{"type":47,"tag":851,"props":852,"children":853},"tr",{},[854,860],{"type":47,"tag":855,"props":856,"children":857},"th",{},[858],{"type":53,"value":859},"GPU Free vs Dataset",{"type":47,"tag":855,"props":861,"children":862},{},[863],{"type":53,"value":864},"Strategy",{"type":47,"tag":866,"props":867,"children":868},"tbody",{},[869,883,902,915],{"type":47,"tag":851,"props":870,"children":871},{},[872,878],{"type":47,"tag":873,"props":874,"children":875},"td",{},[876],{"type":53,"value":877},"Free > 2× dataset",{"type":47,"tag":873,"props":879,"children":880},{},[881],{"type":53,"value":882},"Single GPU cuDF",{"type":47,"tag":851,"props":884,"children":885},{},[886,891],{"type":47,"tag":873,"props":887,"children":888},{},[889],{"type":53,"value":890},"Free 1–2× dataset",{"type":47,"tag":873,"props":892,"children":893},{},[894,896],{"type":53,"value":895},"cuDF + ",{"type":47,"tag":101,"props":897,"children":899},{"className":898},[],[900],{"type":53,"value":901},"cudf.set_option(\"spill\", True)",{"type":47,"tag":851,"props":903,"children":904},{},[905,910],{"type":47,"tag":873,"props":906,"children":907},{},[908],{"type":53,"value":909},"Dataset > GPU mem",{"type":47,"tag":873,"props":911,"children":912},{},[913],{"type":53,"value":914},"dask-cuDF",{"type":47,"tag":851,"props":916,"children":917},{},[918,923],{"type":47,"tag":873,"props":919,"children":920},{},[921],{"type":53,"value":922},"Dataset > node mem",{"type":47,"tag":873,"props":924,"children":925},{},[926],{"type":53,"value":927},"dask-cuDF + multi-node (see accelerated-computing-mpf)",{"type":47,"tag":56,"props":929,"children":931},{"id":930},"troubleshooting",[932],{"type":53,"value":933},"Troubleshooting",{"type":47,"tag":84,"props":935,"children":936},{},[937],{"type":47,"tag":123,"props":938,"children":939},{},[940],{"type":53,"value":941},"No speedup vs pandas:",{"type":47,"tag":63,"props":943,"children":944},{},[945,950,963],{"type":47,"tag":67,"props":946,"children":947},{},[948],{"type":53,"value":949},"Data \u003C 100K rows? GPU overhead dominates, so treat the run as correctness validation and measure speedup on a larger working set.",{"type":47,"tag":67,"props":951,"children":952},{},[953,955,961],{"type":53,"value":954},"Run ",{"type":47,"tag":101,"props":956,"children":958},{"className":957},[],[959],{"type":53,"value":960},"%%cudf.pandas.profile",{"type":53,"value":962}," — high CPU % means many fallbacks. Identify and fix those ops.",{"type":47,"tag":67,"props":964,"children":965},{},[966,968,973],{"type":53,"value":967},"Check ",{"type":47,"tag":101,"props":969,"children":971},{"className":970},[],[972],{"type":53,"value":588},{"type":53,"value":974}," for known gaps.",{"type":47,"tag":84,"props":976,"children":977},{},[978],{"type":47,"tag":123,"props":979,"children":980},{},[981],{"type":53,"value":982},"OOM (CUDA out of memory):",{"type":47,"tag":116,"props":984,"children":985},{},[986,996,1009],{"type":47,"tag":67,"props":987,"children":988},{},[989,991],{"type":53,"value":990},"Enable spill: ",{"type":47,"tag":101,"props":992,"children":994},{"className":993},[],[995],{"type":53,"value":901},{"type":47,"tag":67,"props":997,"children":998},{},[999,1001,1007],{"type":53,"value":1000},"If allocator fragmentation or repeated allocation overhead is visible, use the ",{"type":47,"tag":101,"props":1002,"children":1004},{"className":1003},[],[1005],{"type":53,"value":1006},"accelerated-computing-rmm",{"type":53,"value":1008}," memory-resource setup guidance before GPU allocations",{"type":47,"tag":67,"props":1010,"children":1011},{},[1012],{"type":53,"value":1013},"Still failing: move to dask-cuDF",{"type":47,"tag":84,"props":1015,"children":1016},{},[1017],{"type":47,"tag":123,"props":1018,"children":1019},{},[1020],{"type":53,"value":1021},"AttributeError \u002F NotImplementedError:",{"type":47,"tag":63,"props":1023,"children":1024},{},[1025,1036,1041],{"type":47,"tag":67,"props":1026,"children":1027},{},[1028,1029,1034],{"type":53,"value":967},{"type":47,"tag":101,"props":1030,"children":1032},{"className":1031},[],[1033],{"type":53,"value":588},{"type":53,"value":1035}," for the specific operation",{"type":47,"tag":67,"props":1037,"children":1038},{},[1039],{"type":53,"value":1040},"Keep that one operation on CPU at a narrow boundary and continue the supported pipeline on GPU",{"type":47,"tag":67,"props":1042,"children":1043},{},[1044,1046,1051,1053,1059],{"type":53,"value":1045},"Use ",{"type":47,"tag":101,"props":1047,"children":1049},{"className":1048},[],[1050],{"type":53,"value":161},{"type":53,"value":1052}," only for the unsupported op, then ",{"type":47,"tag":101,"props":1054,"children":1056},{"className":1055},[],[1057],{"type":53,"value":1058},".from_pandas()",{"type":53,"value":1060}," back",{"type":47,"tag":84,"props":1062,"children":1063},{},[1064],{"type":47,"tag":123,"props":1065,"children":1066},{},[1067],{"type":53,"value":1068},"Wrong results vs pandas:",{"type":47,"tag":63,"props":1070,"children":1071},{},[1072,1098,1111],{"type":47,"tag":67,"props":1073,"children":1074},{},[1075,1077,1083,1085,1091,1092,1097],{"type":53,"value":1076},"Null\u002FNaN handling differs: cuDF uses ",{"type":47,"tag":101,"props":1078,"children":1080},{"className":1079},[],[1081],{"type":53,"value":1082},"\u003CNA>",{"type":53,"value":1084}," (nullable) by default, pandas uses ",{"type":47,"tag":101,"props":1086,"children":1088},{"className":1087},[],[1089],{"type":53,"value":1090},"NaN",{"type":53,"value":217},{"type":47,"tag":101,"props":1093,"children":1095},{"className":1094},[],[1096],{"type":53,"value":588},{"type":53,"value":225},{"type":47,"tag":67,"props":1099,"children":1100},{},[1101,1103,1109],{"type":53,"value":1102},"Sort stability: cuDF sort is not guaranteed stable unless ",{"type":47,"tag":101,"props":1104,"children":1106},{"className":1105},[],[1107],{"type":53,"value":1108},"stable=True",{"type":53,"value":1110}," is passed",{"type":47,"tag":67,"props":1112,"children":1113},{},[1114,1116,1122,1124,1130],{"type":53,"value":1115},"If the difference is due to floating point differences, try casting to higher precision floats (e.g. ",{"type":47,"tag":101,"props":1117,"children":1119},{"className":1118},[],[1120],{"type":53,"value":1121},"float64",{"type":53,"value":1123}," instead of ",{"type":47,"tag":101,"props":1125,"children":1127},{"className":1126},[],[1128],{"type":53,"value":1129},"float32",{"type":53,"value":1131},"). If the results are still different, stop. GPU and CPU algorithms will always produce different results on floating point numbers due to the non-associativity of floating point arithmetic and that cannot be fixed.",{"type":47,"tag":56,"props":1133,"children":1135},{"id":1134},"nullable-and-fill-semantics",[1136],{"type":53,"value":1137},"Nullable and Fill Semantics",{"type":47,"tag":84,"props":1139,"children":1140},{},[1141,1143,1148,1149,1154,1155,1161,1163,1168],{"type":53,"value":1142},"When the user explicitly cares about pandas nullable dtypes, ",{"type":47,"tag":101,"props":1144,"children":1146},{"className":1145},[],[1147],{"type":53,"value":568},{"type":53,"value":631},{"type":47,"tag":101,"props":1150,"children":1152},{"className":1151},[],[1153],{"type":53,"value":575},{"type":53,"value":554},{"type":47,"tag":101,"props":1156,"children":1158},{"className":1157},[],[1159],{"type":53,"value":1160},"mask",{"type":53,"value":1162},", or grouped null behavior, treat parity checks as part of the\nimplementation. See ",{"type":47,"tag":101,"props":1164,"children":1166},{"className":1165},[],[1167],{"type":53,"value":588},{"type":53,"value":1169}," for nullable dtype examples.",{"type":47,"tag":63,"props":1171,"children":1172},{},[1173,1178,1203,1216,1221],{"type":47,"tag":67,"props":1174,"children":1175},{},[1176],{"type":53,"value":1177},"Preserve nullable integer\u002Fstring columns instead of filling them with sentinel\nvalues unless the source code already did that.",{"type":47,"tag":67,"props":1179,"children":1180},{},[1181,1183,1188,1189,1194,1196,1201],{"type":53,"value":1182},"Keep ",{"type":47,"tag":101,"props":1184,"children":1186},{"className":1185},[],[1187],{"type":53,"value":575},{"type":53,"value":554},{"type":47,"tag":101,"props":1190,"children":1192},{"className":1191},[],[1193],{"type":53,"value":1160},{"type":53,"value":1195}," semantics when they encode a condition. Use broad\n",{"type":47,"tag":101,"props":1197,"children":1199},{"className":1198},[],[1200],{"type":53,"value":568},{"type":53,"value":1202}," only when the condition is exactly null-only.",{"type":47,"tag":67,"props":1204,"children":1205},{},[1206,1208,1214],{"type":53,"value":1207},"Compare with ",{"type":47,"tag":101,"props":1209,"children":1211},{"className":1210},[],[1212],{"type":53,"value":1213},"to_pandas(nullable=True)",{"type":53,"value":1215}," when the pandas reference uses\nnullable extension dtypes.",{"type":47,"tag":67,"props":1217,"children":1218},{},[1219],{"type":53,"value":1220},"Put the parity check in a reusable helper next to the GPU path, so future\nchanges exercise the same nullable conversion and aggregation checks.",{"type":47,"tag":67,"props":1222,"children":1223},{},[1224],{"type":53,"value":1225},"Validate row counts, null counts, mask truth tables, grouped aggregates, and\nrepresentative dtypes before claiming semantic parity.",{"type":47,"tag":56,"props":1227,"children":1229},{"id":1228},"reference-files",[1230],{"type":53,"value":1231},"Reference Files",{"type":47,"tag":63,"props":1233,"children":1234},{},[1235,1245,1255],{"type":47,"tag":67,"props":1236,"children":1237},{},[1238,1243],{"type":47,"tag":101,"props":1239,"children":1241},{"className":1240},[],[1242],{"type":53,"value":374},{"type":53,"value":1244}," — Profiling, fallback detection, cudf.pandas deep dive",{"type":47,"tag":67,"props":1246,"children":1247},{},[1248,1253],{"type":47,"tag":101,"props":1249,"children":1251},{"className":1250},[],[1252],{"type":53,"value":588},{"type":53,"value":1254}," — Known API gaps, workarounds, semantic differences",{"type":47,"tag":67,"props":1256,"children":1257},{},[1258,1263],{"type":47,"tag":101,"props":1259,"children":1261},{"className":1260},[],[1262],{"type":53,"value":223},{"type":53,"value":1264}," — Multi-GPU patterns, best practices, partition tuning",{"type":47,"tag":56,"props":1266,"children":1268},{"id":1267},"external-documentation",[1269],{"type":53,"value":1270},"External Documentation",{"type":47,"tag":84,"props":1272,"children":1273},{},[1274],{"type":53,"value":1275},"Use WebFetch to retrieve detailed API signatures, parameter descriptions, and examples on demand.",{"type":47,"tag":63,"props":1277,"children":1278},{},[1279,1297,1312,1327],{"type":47,"tag":67,"props":1280,"children":1281},{},[1282,1287,1289],{"type":47,"tag":123,"props":1283,"children":1284},{},[1285],{"type":53,"value":1286},"cuDF Documentation:",{"type":53,"value":1288}," ",{"type":47,"tag":1290,"props":1291,"children":1295},"a",{"href":1292,"rel":1293},"https:\u002F\u002Fdocs.rapids.ai\u002Fapi\u002Fcudf\u002Fstable\u002F",[1294],"nofollow",[1296],{"type":53,"value":1292},{"type":47,"tag":67,"props":1298,"children":1299},{},[1300,1305,1306],{"type":47,"tag":123,"props":1301,"children":1302},{},[1303],{"type":53,"value":1304},"dask-cuDF API Reference:",{"type":53,"value":1288},{"type":47,"tag":1290,"props":1307,"children":1310},{"href":1308,"rel":1309},"https:\u002F\u002Fdocs.rapids.ai\u002Fapi\u002Fdask-cudf\u002Fstable\u002Fapi\u002F",[1294],[1311],{"type":53,"value":1308},{"type":47,"tag":67,"props":1313,"children":1314},{},[1315,1320,1321],{"type":47,"tag":123,"props":1316,"children":1317},{},[1318],{"type":53,"value":1319},"GitHub:",{"type":53,"value":1288},{"type":47,"tag":1290,"props":1322,"children":1325},{"href":1323,"rel":1324},"https:\u002F\u002Fgithub.com\u002Frapidsai\u002Fcudf",[1294],[1326],{"type":53,"value":1323},{"type":47,"tag":67,"props":1328,"children":1329},{},[1330,1335,1336],{"type":47,"tag":123,"props":1331,"children":1332},{},[1333],{"type":53,"value":1334},"CHANGELOG:",{"type":53,"value":1288},{"type":47,"tag":1290,"props":1337,"children":1340},{"href":1338,"rel":1339},"https:\u002F\u002Fgithub.com\u002Frapidsai\u002Fcudf\u002Fblob\u002Fmain\u002FCHANGELOG.md",[1294],[1341],{"type":53,"value":1338},{"type":47,"tag":1343,"props":1344,"children":1345},"style",{},[1346],{"type":53,"value":1347},"html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"items":1349,"total":1507},[1350,1368,1385,1396,1408,1422,1435,1449,1462,1473,1487,1496],{"slug":1351,"name":1351,"fn":1352,"description":1353,"org":1354,"tags":1355,"stars":1365,"repoUrl":1366,"updatedAt":1367},"nemoclaw-user-guide","retrieve NemoClaw documentation and configuration","Guides human users' AI agents to the NemoClaw docs MCP server and canonical Fern documentation in Markdown form. Use when users ask how to install, configure, operate, troubleshoot, secure, or learn NemoClaw with an AI coding assistant. Trigger keywords - nemoclaw docs, use nemoclaw with ai agent, nemoclaw mcp docs, nemoclaw install help, nemoclaw quickstart, nemoclaw markdown docs, llms.txt, agent skills.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1356,1359,1362],{"name":1357,"slug":1358,"type":15},"Documentation","documentation",{"name":1360,"slug":1361,"type":15},"MCP","mcp",{"name":1363,"slug":1364,"type":15},"Search","search",21777,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FNemoClaw","2026-07-20T06:00:01.461044",{"slug":1369,"name":1369,"fn":1370,"description":1371,"org":1372,"tags":1373,"stars":1382,"repoUrl":1383,"updatedAt":1384},"mcore-build-and-dependency","manage Megatron-LM development environments","Container-based dev environment setup and dependency management for Megatron-LM. Covers acquiring and launching the CI container, uv package management, and updating uv.lock.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1374,1377,1380],{"name":1375,"slug":1376,"type":15},"Containers","containers",{"name":1378,"slug":1379,"type":15},"Deployment","deployment",{"name":1381,"slug":257,"type":15},"Python",17049,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FMegatron-LM","2026-07-27T06:06:11.249662",{"slug":1386,"name":1386,"fn":1387,"description":1388,"org":1389,"tags":1390,"stars":1382,"repoUrl":1383,"updatedAt":1395},"mcore-bump-base-image","update NVIDIA PyTorch base images","Bump the NVIDIA PyTorch base image (`nvcr.io\u002Fnvidia\u002Fpytorch:YY.MM-py3`) used by Megatron-LM CI. Covers the two pin sites (GitHub CI in `docker\u002F.ngc_version.dev` and GitLab CI in `.gitlab\u002Fstages\u002F01.build.yml`), the post-bump CI loop (re-run functional tests, refresh golden values, mark broken tests), and the gotchas that bit PRs",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1391,1394],{"name":1392,"slug":1393,"type":15},"CI\u002FCD","ci-cd",{"name":1378,"slug":1379,"type":15},"2026-07-14T05:25:59.97109",{"slug":1397,"name":1397,"fn":1398,"description":1399,"org":1400,"tags":1401,"stars":1382,"repoUrl":1383,"updatedAt":1407},"mcore-cicd","manage CI\u002FCD pipelines for Megatron-LM","CI\u002FCD reference for Megatron-LM. Covers CI pipeline structure, PR scope labels, triggering internal GitLab CI (which force-pushes the current branch to a pull-request\u002FBRANCH ref — always dry-run and verify the destination first; never run against shared or protected branches), and CI failure investigation.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1402,1403,1404],{"name":1392,"slug":1393,"type":15},{"name":1378,"slug":1379,"type":15},{"name":1405,"slug":1406,"type":15},"GitHub","github","2026-07-27T06:06:12.278222",{"slug":1409,"name":1409,"fn":1410,"description":1411,"org":1412,"tags":1413,"stars":1382,"repoUrl":1383,"updatedAt":1421},"mcore-create-issue","investigate CI failures and create issues","Investigate a failing GitHub Actions run or job and create a GitHub issue for the failure.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1414,1417,1418],{"name":1415,"slug":1416,"type":15},"Debugging","debugging",{"name":1405,"slug":1406,"type":15},{"name":1419,"slug":1420,"type":15},"Triage","triage","2026-07-14T05:25:57.442089",{"slug":1423,"name":1423,"fn":1424,"description":1425,"org":1426,"tags":1427,"stars":1382,"repoUrl":1383,"updatedAt":1434},"mcore-linting-and-formatting","lint and format Megatron-LM code","Linting and formatting for Megatron-LM. Covers running autoformat.sh, tools (ruff, black, isort, pylint, mypy), and code style rules.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1428,1431],{"name":1429,"slug":1430,"type":15},"Best Practices","best-practices",{"name":1432,"slug":1433,"type":15},"Code Analysis","code-analysis","2026-07-14T05:25:56.18433",{"slug":1436,"name":1436,"fn":1437,"description":1438,"org":1439,"tags":1440,"stars":1382,"repoUrl":1383,"updatedAt":1448},"mcore-migrate-gpt-to-hybrid","migrate Megatron-LM models to HybridModel","Migration guide for moving Megatron Core GPTModel checkpoints, model providers, training commands, and layer mappings to HybridModel.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1441,1444,1447],{"name":1442,"slug":1443,"type":15},"Machine Learning","machine-learning",{"name":1445,"slug":1446,"type":15},"Migration","migration",{"name":9,"slug":8,"type":15},"2026-07-17T06:07:11.777011",{"slug":1450,"name":1450,"fn":1451,"description":1452,"org":1453,"tags":1454,"stars":1382,"repoUrl":1383,"updatedAt":1461},"mcore-onboard-gb200-1node-tests","onboard functional tests for GB200","Onboard 1-node GitHub MR functional tests for GB200 from existing mr-scoped 2-node tests.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1455,1458],{"name":1456,"slug":1457,"type":15},"QA","qa",{"name":1459,"slug":1460,"type":15},"Testing","testing","2026-07-14T05:25:53.673039",{"slug":1463,"name":1463,"fn":1464,"description":1465,"org":1466,"tags":1467,"stars":1382,"repoUrl":1383,"updatedAt":1472},"mcore-run-on-slurm","launch distributed training jobs on SLURM","How to launch distributed Megatron-LM training jobs on a SLURM cluster. Covers a minimal sbatch skeleton, environment-variable setup for torch.distributed.run, CUDA_DEVICE_MAX_CONNECTIONS rules across hardware and parallelism modes, container conventions, monitoring, and per-rank failure diagnosis.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1468,1469],{"name":1378,"slug":1379,"type":15},{"name":1470,"slug":1471,"type":15},"Infrastructure","infrastructure","2026-07-14T05:25:49.362534",{"slug":1474,"name":1474,"fn":1475,"description":1476,"org":1477,"tags":1478,"stars":1382,"repoUrl":1383,"updatedAt":1486},"mcore-split-pr","split pull requests to reduce review load","Split a PR into multiple PRs to reduce the number of required CODEOWNERS reviewer groups.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1479,1482,1483],{"name":1480,"slug":1481,"type":15},"Code Review","code-review",{"name":1405,"slug":1406,"type":15},{"name":1484,"slug":1485,"type":15},"Pull Requests","pull-requests","2026-07-14T05:26:01.226578",{"slug":1488,"name":1488,"fn":1489,"description":1490,"org":1491,"tags":1492,"stars":1382,"repoUrl":1383,"updatedAt":1495},"mcore-testing","run and manage Megatron-LM tests","Test system for Megatron-LM. Covers test layout, recipe YAML structure, adding and running unit and functional tests, golden values, marker filters, and CI parity.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1493,1494],{"name":1456,"slug":1457,"type":15},{"name":1459,"slug":1460,"type":15},"2026-07-14T05:25:54.928983",{"slug":1497,"name":1497,"fn":1498,"description":1499,"org":1500,"tags":1501,"stars":1382,"repoUrl":1383,"updatedAt":1506},"nightly-sync","manage nightly main-to-dev sync workflows","Domain knowledge for the nightly main-to-dev sync workflow. Covers merge strategy, CI architecture, failure investigation, and known issues.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1502,1505],{"name":1503,"slug":1504,"type":15},"Automation","automation",{"name":1392,"slug":1393,"type":15},"2026-07-30T05:29:03.275638",496,{"items":1509,"total":1595},[1510,1517,1527,1541,1551,1566,1581],{"slug":4,"name":4,"fn":5,"description":6,"org":1511,"tags":1512,"stars":23,"repoUrl":24,"updatedAt":25},{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1513,1514,1515,1516],{"name":20,"slug":21,"type":15},{"name":17,"slug":18,"type":15},{"name":9,"slug":8,"type":15},{"name":13,"slug":14,"type":15},{"slug":1518,"name":1518,"fn":1519,"description":1520,"org":1521,"tags":1522,"stars":23,"repoUrl":24,"updatedAt":1526},"aiq-deploy","deploy and manage NVIDIA AI-Q infrastructure","Use when asked to install, deploy, run, validate, troubleshoot, or stop NVIDIA AI-Q Blueprint infrastructure.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1523,1524,1525],{"name":1378,"slug":1379,"type":15},{"name":1470,"slug":1471,"type":15},{"name":9,"slug":8,"type":15},"2026-07-14T05:29:06.667109",{"slug":1528,"name":1528,"fn":1529,"description":1530,"org":1531,"tags":1532,"stars":23,"repoUrl":24,"updatedAt":1540},"aiq-research","conduct deep research with AI-Q","Use when asked to run deep research or AI-Q research through a reachable NVIDIA AI-Q Blueprint backend.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1533,1536,1537],{"name":1534,"slug":1535,"type":15},"Agents","agents",{"name":9,"slug":8,"type":15},{"name":1538,"slug":1539,"type":15},"Research","research","2026-07-14T05:28:06.816956",{"slug":1542,"name":1542,"fn":1543,"description":1544,"org":1545,"tags":1546,"stars":23,"repoUrl":24,"updatedAt":1550},"amc-run-sample-calibration","run AMC sample dataset calibration","Run end-to-end calibration on the shipped sample dataset (sdg_08_2_sample_data_010926.zip) against a running AMC microservice. Use when user says 'test sample dataset', 'run sample calibration', 'verify AMC install', or 'launch and test'.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1547,1548,1549],{"name":20,"slug":21,"type":15},{"name":9,"slug":8,"type":15},{"name":1459,"slug":1460,"type":15},"2026-07-17T05:29:03.913266",{"slug":1552,"name":1552,"fn":1553,"description":1554,"org":1555,"tags":1556,"stars":23,"repoUrl":24,"updatedAt":1565},"amc-run-video-calibration","calibrate video datasets with AutoMagicCalib","Calibrate a new dataset from pre-recorded video files via the AutoMagicCalib REST API. Use when user has local MP4s and says 'calibrate my videos', 'run AMC on these videos', or similar. For RTSP\u002Flive streams, use amc-run-rtsp-calibration instead.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1557,1558,1561,1562],{"name":1503,"slug":1504,"type":15},{"name":1559,"slug":1560,"type":15},"Imaging","imaging",{"name":9,"slug":8,"type":15},{"name":1563,"slug":1564,"type":15},"Video","video","2026-07-17T05:28:53.905004",{"slug":1567,"name":1567,"fn":1568,"description":1569,"org":1570,"tags":1571,"stars":23,"repoUrl":24,"updatedAt":1580},"amc-setup-calibration-stack","deploy AutoMagicCalib microservice with Docker","Launch AutoMagicCalib microservice and web UI from NGC release images via Docker Compose. Use when user says 'deploy auto calibration', 'launch auto calibration', 'launch AMC', 'start MS+UI', or 'set up auto-magic-calib'. Requires NGC API key.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1572,1573,1576,1577],{"name":1378,"slug":1379,"type":15},{"name":1574,"slug":1575,"type":15},"Docker","docker",{"name":9,"slug":8,"type":15},{"name":1578,"slug":1579,"type":15},"Operations","operations","2026-07-17T05:28:56.913999",{"slug":1582,"name":1582,"fn":1583,"description":1584,"org":1585,"tags":1586,"stars":23,"repoUrl":24,"updatedAt":1594},"cudaq-guide","develop quantum applications with CUDA-Q","CUDA-Q onboarding guide for installation, test programs, GPU simulation, QPU hardware, and quantum applications.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1587,1588,1591],{"name":9,"slug":8,"type":15},{"name":1589,"slug":1590,"type":15},"Quantum Computing","quantum-computing",{"name":1592,"slug":1593,"type":15},"Simulation","simulation","2026-07-14T05:26:58.898253",305]