From 058b5b70b20ed323a9cb2dee42d514024ea0ebea Mon Sep 17 00:00:00 2001 From: GitLab CI Date: Thu, 16 Oct 2025 20:25:06 +0000 Subject: [PATCH] chore: Regenerate all playbooks --- README.md | 2 + nvidia/cuda-x-data-science/README.md | 82 + .../assets/cudf_pandas_demo.ipynb | 939 +++++++ .../assets/cuml_sklearn_demo.ipynb | 2311 +++++++++++++++++ nvidia/vibe-coding/README.md | 187 ++ nvidia/vllm/README.md | 2 +- 6 files changed, 3522 insertions(+), 1 deletion(-) create mode 100644 nvidia/cuda-x-data-science/README.md create mode 100644 nvidia/cuda-x-data-science/assets/cudf_pandas_demo.ipynb create mode 100644 nvidia/cuda-x-data-science/assets/cuml_sklearn_demo.ipynb create mode 100644 nvidia/vibe-coding/README.md diff --git a/README.md b/README.md index bd7e866..27897b7 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,7 @@ Each playbook includes prerequisites, step-by-step instructions, troubleshooting - [Comfy UI](nvidia/comfy-ui/) - [Set Up Local Network Access](nvidia/connect-to-your-spark/) - [Connect Two Sparks](nvidia/connect-two-sparks/) +- [CUDA-X Data Science](nvidia/cuda-x-data-science/) - [DGX Dashboard](nvidia/dgx-dashboard/) - [FLUX.1 Dreambooth LoRA Fine-tuning](nvidia/flux-finetuning/) - [Optimized JAX](nvidia/jax/) @@ -43,6 +44,7 @@ Each playbook includes prerequisites, step-by-step instructions, troubleshooting - [TRT LLM for Inference](nvidia/trt-llm/) - [Text to Knowledge Graph](nvidia/txt2kg/) - [Unsloth on DGX Spark](nvidia/unsloth/) +- [Vibe Coding in VS Code](nvidia/vibe-coding/) - [Install and Use vLLM for Inference](nvidia/vllm/) - [Vision-Language Model Fine-tuning](nvidia/vlm-finetuning/) - [VS Code](nvidia/vscode/) diff --git a/nvidia/cuda-x-data-science/README.md b/nvidia/cuda-x-data-science/README.md new file mode 100644 index 0000000..f936cf2 --- /dev/null +++ b/nvidia/cuda-x-data-science/README.md @@ -0,0 +1,82 @@ +# CUDA-X Data Science + +> Install and use NVIDIA cuML and NVIDIA cuDF to accelerate UMAP, HDBSCAN, pandas and more with zero code changes + +## Table of Contents + +- [Overview](#overview) +- [Instructions](#instructions) + +--- + +## Overview + +## Basic idea +This playbook includes two example notebooks that demonstrate the acceleration of key machine learning algorithms and core pandas operations using CUDA-X Data Science libraries: + +- **NVIDIA cuDF:** Accelerates operations for data preparation and core data processing of 8GB of strings data, with no code changes. +- **NVIDIA cuML:** Accelerates popular, compute intensive machine learning algorithms in sci-kit learn (LinearSVC), UMAP, and HDBSCAN, with no code changes. + +CUDA-X Data Science (formally RAPIDS) is an open-source library collection that accelerates the data science and data processing ecosystem. These libraries accelerate popular Python tools like scikit-learn and pandas with zero code changes. On DGX Spark, these libraries maximize performance at your desk with your existing code. + +## What you'll accomplish +You will accelerate popular machine learning algorithms and data analytics operations GPU. You will understand how to accelerate popular Python tools, and the value of running data science workflows on your DGX Spark. + +## Prerequisites +- Familiarity with pandas, scikit-learn, machine learning algorithms, such as support vector machine, clustering, and dimensionality reduction algorithms. +- Install conda +- Generate a Kaggle API key + +## Time & risk +* **Duration:** 20-30 minutes setup time and 2-3 minutes to run each notebook. +* **Risk level:** + * Data download slowness or failure due to network issues + * Kaggle API generation failure requiring retries +* **Rollback:** No permanent system changes made during normal usage. + +## Instructions + +## Step 1. Verify system requirements +- Verify the system has CUDA 13 installed using `nvcc --version` or `nvidia-smi` +- Install conda using [these instructions](https://docs.anaconda.com/miniconda/install/) +- Create Kaggle API key using [these instructions](https://www.kaggle.com/discussions/general/74235) and place the **kaggle.json** file in the same folder as the notebook + +## Step 2. Installing Data Science libraries +- Use the following command to install the CUDA-X libraries (this will create a new conda environment) + ```bash + conda create -n rapids-test -c rapidsai-nightly -c conda-forge -c nvidia \ + rapids=25.10 python=3.12 'cuda-version=13.0' \ + jupyter hdbscan umap-learn + ``` +## Step 3. Activate the conda environment +- Activate the conda environment + ```bash + conda activate rapids-test + ``` +## Step 4. Cloning the playbook repository +- Clone the github repository and go the assets folder place in cuda-x-data-science folder + ```bash + git clone https://github.com/NVIDIA/dgx-spark-playbooks + ``` +- Place the **kaggle.json** created in Step 1 in the assets folder + +## Step 5. Run the notebooks +There are two notebooks in the GitHub repository. +One runs an example of a large strings data processing workflow with pandas code on GPU. +- Run the cudf_pandas_demo.ipynb notebook and use `localhost:8888` in your browser to access the notebook + ```bash + jupyter notebook cudf_pandas_demo.ipynb + ``` +The other goes over an example of machine learning algorithms including UMAP and HDBSCAN. +- Run the cuml_sklearn_demo.ipynb notebook and use `localhost:8888` in your browser to access the notebook + ```bash + jupyter notebook cuml_sklearn_demo.ipynb + ``` +If you are remotely accessing your DGX-Spark then make sure to forward the necesary port to access the notebook in your local browser. Use the below instruction for port fowarding +```bash + ssh -N -L YYYY:localhost:XXXX username@remote_host +``` +- `YYYY`: The local port you want to use (e.g. 8888) +- `XXXX`: The port you specified when starting Jupyter Notebook on the remote machine (e.g. 8888) +- `-N`: Prevents SSH from executing a remote command +- `-L`: Spcifies local port forwarding diff --git a/nvidia/cuda-x-data-science/assets/cudf_pandas_demo.ipynb b/nvidia/cuda-x-data-science/assets/cudf_pandas_demo.ipynb new file mode 100644 index 0000000..e55bb42 --- /dev/null +++ b/nvidia/cuda-x-data-science/assets/cudf_pandas_demo.ipynb @@ -0,0 +1,939 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "84635d55-68a2-468b-ac09-9029ebdab55f", + "metadata": { + "id": "84635d55-68a2-468b-ac09-9029ebdab55f" + }, + "source": [ + "# Accelerating large string data processing with cudf pandas accelerator mode (cudf.pandas)\n", + "cuDF is a Python GPU DataFrame library (built on the Apache Arrow columnar memory format) for loading, joining, aggregating, filtering, and otherwise manipulating tabular data using a DataFrame style API in the style of pandas.\n", + "\n", + "cuDF now provides a pandas accelerator mode (`cudf.pandas`), allowing you to bring accelerated computing to your pandas workflows without requiring any code change.\n", + "\n", + "This notebook demonstrates how cuDF pandas accelerator mode can help accelerate processing of datasets with large string fields (4 GB+) processing by simply adding a `%load_ext` command. We have introduced this feature as part of our Rapids 24.08 release.\n", + "\n", + "**Author:** Allison Ding, Mitesh Patel
\n", + "**Date:** October 3, 2025" + ] + }, + { + "cell_type": "markdown", + "id": "bb8fe7ab-c055-40e9-897d-c62c72f28a16", + "metadata": { + "id": "bb8fe7ab-c055-40e9-897d-c62c72f28a16" + }, + "source": [ + "# ⚠️ Verify your setup\n", + "\n", + "First, we'll verify that you are running with an NVIDIA GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a88b8586-cfdd-4d31-9b4d-9be8508f7ba0", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "a88b8586-cfdd-4d31-9b4d-9be8508f7ba0", + "outputId": "18525b64-b34b-40e3-ed3a-1ad56ae794b5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fri Oct 3 23:16:52 2025 \n", + "+-----------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 580.82.09 Driver Version: 580.82.09 CUDA Version: 13.0 |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+========================+======================|\n", + "| 0 NVIDIA GB10 Off | 0000000F:01:00.0 Off | N/A |\n", + "| N/A 44C P0 10W / N/A | Not Supported | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + "\n", + "+-----------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=========================================================================================|\n", + "| 0 N/A N/A 3405 G /usr/lib/xorg/Xorg 242MiB |\n", + "| 0 N/A N/A 3562 G /usr/bin/gnome-shell 53MiB |\n", + "| 0 N/A N/A 214921 C .../envs/rapids-25.10/bin/python 196MiB |\n", + "+-----------------------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi # this should display information about available GPUs" + ] + }, + { + "cell_type": "markdown", + "id": "5cd58071-4371-428b-8a02-9cd66e6cb91f", + "metadata": { + "id": "5cd58071-4371-428b-8a02-9cd66e6cb91f" + }, + "source": [ + "# Download the data" + ] + }, + { + "cell_type": "markdown", + "id": "9eb67713-7cf4-415a-bce7-ff4695862faa", + "metadata": { + "id": "9eb67713-7cf4-415a-bce7-ff4695862faa" + }, + "source": [ + "## Overview\n", + "The data we'll be working with summarizes job postings data that a developer working at a job listing firm might analyze to understand posting trends.\n", + "\n", + "We'll need to download a curated copy of this [Kaggle dataset](https://www.kaggle.com/datasets/asaniczka/1-3m-linkedin-jobs-and-skills-2024/data?select=job_summary.csv) directly from the kaggle API. \n", + "\n", + "**Data License and Terms**
\n", + "As this dataset originates from a Kaggle dataset, it's governed by that dataset's license and terms of use, which is the Open Data Commons license. Review here:https://opendatacommons.org/licenses/by/1-0/index.html. For each dataset an user elects to use, the user is responsible for checking if the dataset license is fit for the intended purpose.\n", + "\n", + "**Are there restrictions on how I can use this data?
**\n", + "For each dataset an user elects to use, the user is responsible for checking if the dataset license is fit for the intended purpose.\n", + "\n", + "## Get the Data\n", + "First, [please follow these instructions from Kaggle to download and/or updating your Kaggle API token to get acces the dataset](https://www.kaggle.com/discussions/general/74235). \n", + "\n", + "Once generated, make sure to have the **kaggle.json** file in the same folder as the notebook\n", + "\n", + "Next, run this code below, which should also take 1-2 minutes:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "406838c6-267c-423e-82ab-ea13d5fa9c90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: kaggle in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (1.7.4.5)\n", + "Requirement already satisfied: bleach in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (6.2.0)\n", + "Requirement already satisfied: certifi>=14.05.14 in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (2025.8.3)\n", + "Requirement already satisfied: charset-normalizer in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (3.4.3)\n", + "Requirement already satisfied: idna in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (3.10)\n", + "Requirement already satisfied: protobuf in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (6.32.1)\n", + "Requirement already satisfied: python-dateutil>=2.5.3 in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (2.9.0.post0)\n", + "Requirement already satisfied: python-slugify in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (8.0.4)\n", + "Requirement already satisfied: requests in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (2.32.5)\n", + "Requirement already satisfied: setuptools>=21.0.0 in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (80.9.0)\n", + "Requirement already satisfied: six>=1.10 in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (1.17.0)\n", + "Requirement already satisfied: text-unidecode in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (1.3)\n", + "Requirement already satisfied: tqdm in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (4.67.1)\n", + "Requirement already satisfied: urllib3>=1.15.1 in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (2.5.0)\n", + "Requirement already satisfied: webencodings in /home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages (from kaggle) (0.5.1)\n" + ] + } + ], + "source": [ + "!pip install kaggle\n", + "!mkdir -p ~/.kaggle\n", + "!cp kaggle.json ~/.kaggle/\n", + "!chmod 600 ~/.kaggle/kaggle.json" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3efacb3c-5f3d-4ff0-b32a-76bbb80b5f74", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3efacb3c-5f3d-4ff0-b32a-76bbb80b5f74", + "outputId": "5fe4a878-cf57-44f9-e40e-ed413035b150" + }, + "outputs": [], + "source": [ + "# Download the dataset through kaggle API-\n", + "!kaggle datasets download -d asaniczka/1-3m-linkedin-jobs-and-skills-2024\n", + "#unzip the file to access contents\n", + "!unzip 1-3m-linkedin-jobs-and-skills-2024.zip" + ] + }, + { + "cell_type": "markdown", + "id": "2__ZMVe6LaBJ", + "metadata": { + "id": "2__ZMVe6LaBJ" + }, + "source": [ + "# Analysis with cuDF Pandas" + ] + }, + { + "cell_type": "markdown", + "id": "df47f304-2b30-4380-afd5-0613b63d103d", + "metadata": {}, + "source": [ + "The magic command `%load_ext cudf.pandas` enables GPU acceleration for pandas data processing in a Jupyter notebook, allowing most pandas operations to automatically execute on NVIDIA GPUs for improved performance. \n", + "\n", + "With this extension loaded before importing pandas, your code can use standard pandas syntax while gaining the benefits of GPU speedup, automatically falling back to CPU execution for operations not supported on the GPU. This provides a seamless way to accelerate existing pandas workflows with zero code changes, especially for large data analytics tasks or machine learning preprocessing." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e5cd2520-30a6-41c1-b7c5-5abe0eb90d82", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext cudf.pandas" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "eadb8d77-cb45-4c7c-ae9f-77e47a4f29b3", + "metadata": { + "id": "eadb8d77-cb45-4c7c-ae9f-77e47a4f29b3" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "196268f2-6169-4ed7-a9e6-db9078caa6ab", + "metadata": { + "id": "196268f2-6169-4ed7-a9e6-db9078caa6ab" + }, + "source": [ + "We'll run a piece of code to get a feel what GPU-acceleration brings to pandas workflows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae3b6a16-ff72-4421-b43c-06c33f57ec12", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ae3b6a16-ff72-4421-b43c-06c33f57ec12", + "outputId": "656acbf7-078f-42b3-832d-ad4e84e01c70" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 185 ms, sys: 2.08 s, total: 2.27 s\n", + "Wall time: 2.95 s\n", + "Dataset Size (in GB): 4.76\n" + ] + } + ], + "source": [ + "%%time \n", + "job_summary_df = pd.read_csv(\"job_summary.csv\", dtype=('str'))\n", + "print(\"Dataset Size (in GB):\",round(job_summary_df.memory_usage(\n", + " deep=True).sum()/(1024**3),2))" + ] + }, + { + "cell_type": "markdown", + "id": "01c506e1-f135-4afb-8fc7-23e72c05d73c", + "metadata": { + "id": "01c506e1-f135-4afb-8fc7-23e72c05d73c" + }, + "source": [ + "The same dataset takes about around 1.5 minutes to load with pandas. That's around **5x speedup** with no changes to the code!" + ] + }, + { + "cell_type": "markdown", + "id": "d9d0a0e1-1d74-494d-bd12-b829f11eeede", + "metadata": { + "id": "d9d0a0e1-1d74-494d-bd12-b829f11eeede" + }, + "source": [ + "Let's load the remaining two datasets as well:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "12e4cf7e-8824-4822-9d30-46b81ba2acd7", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "12e4cf7e-8824-4822-9d30-46b81ba2acd7", + "outputId": "5ca1be17-09e3-40ab-928b-82176bf597bf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 45.3 ms, sys: 199 ms, total: 244 ms\n", + "Wall time: 354 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "job_skills_df = pd.read_csv(\"job_skills.csv\", dtype=('str'))\n", + "job_postings_df = pd.read_csv(\"linkedin_job_postings.csv\", dtype=('str'))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "13c8f9da-121f-4311-8a79-274425363e5e", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 276 + }, + "id": "13c8f9da-121f-4311-8a79-274425363e5e", + "outputId": "a73599c1-05b2-4f56-a190-c69c017bb330" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 4.46 ms, sys: 3.1 ms, total: 7.56 ms\n", + "Wall time: 46.3 ms\n" + ] + }, + { + "data": { + "text/plain": [ + "0 957\n", + "1 3816\n", + "2 5314\n", + "3 2774\n", + "4 2749\n", + "Name: summary_length, dtype: int32" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "job_summary_df['summary_length'] = job_summary_df['job_summary'].str.len()\n", + "job_summary_df['summary_length'].head()" + ] + }, + { + "cell_type": "markdown", + "id": "67b68792-5c64-4ebd-9d80-cf6ff55baeef", + "metadata": { + "id": "67b68792-5c64-4ebd-9d80-cf6ff55baeef" + }, + "source": [ + "That was lightning fast! We went from around 10+ (with pandas) to a few milliseconds." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "31e1cc84-debb-4da7-bc20-5c7139f786f7", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 504 + }, + "id": "31e1cc84-debb-4da7-bc20-5c7139f786f7", + "outputId": "2d89fc49-7e5b-41db-c25b-441d54480711" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 39.8 ms, sys: 30 ms, total: 69.8 ms\n", + "Wall time: 211 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
job_linklast_processed_timegot_summarygot_neris_being_workedjob_titlecompanyjob_locationfirst_seensearch_citysearch_countrysearch_positionjob_leveljob_typejob_summarysummary_length
0https://www.linkedin.com/jobs/view/account-exe...2024-01-21 07:12:29.00256+00ttfAccount Executive - Dispensing (NorCal/Norther...BDSan Diego, CA2024-01-15CoronadoUnited StatesColor MakerMid seniorOnsiteResponsibilities\\nJob Description Summary\\nJob...4602
1https://www.linkedin.com/jobs/view/registered-...2024-01-21 07:39:58.88137+00ttfRegistered Nurse - RN Care ManagerTrinity Health MINorton Shores, MI2024-01-14Grand HavenUnited StatesDirector Nursing ServiceMid seniorOnsiteEmployment Type:\\nFull time\\nShift:\\nDescripti...2950
2https://www.linkedin.com/jobs/view/restaurant-...2024-01-21 07:40:00.251126+00ttfRESTAURANT SUPERVISOR - THE FORKLIFTWasatch Adaptive SportsSandy, UT2024-01-14TooeleUnited StatesStand-InMid seniorOnsiteJob Details\\nDescription\\nWhat You'll Do\\nAs a...4571
3https://www.linkedin.com/jobs/view/independent...2024-01-21 07:40:00.308133+00ttfIndependent Real Estate AgentHoward Hanna | Rand RealtyEnglewood Cliffs, NJ2024-01-16PinehurstUnited StatesReal-Estate ClerkMid seniorOnsiteWho We Are\\nRand Realty is a family-owned brok...3944
4https://www.linkedin.com/jobs/view/group-unit-...2024-01-19 09:45:09.215838+00fffGroup/Unit Supervisor (Systems Support Manager...IRS, Office of Chief CounselChamblee, GA2024-01-17GadsdenUnited StatesSupervisor Travel-Information CenterMid seniorOnsiteNone<NA>
\n", + "
" + ], + "text/plain": [ + " job_link \\\n", + "0 https://www.linkedin.com/jobs/view/account-exe... \n", + "1 https://www.linkedin.com/jobs/view/registered-... \n", + "2 https://www.linkedin.com/jobs/view/restaurant-... \n", + "3 https://www.linkedin.com/jobs/view/independent... \n", + "4 https://www.linkedin.com/jobs/view/group-unit-... \n", + "\n", + " last_processed_time got_summary got_ner is_being_worked \\\n", + "0 2024-01-21 07:12:29.00256+00 t t f \n", + "1 2024-01-21 07:39:58.88137+00 t t f \n", + "2 2024-01-21 07:40:00.251126+00 t t f \n", + "3 2024-01-21 07:40:00.308133+00 t t f \n", + "4 2024-01-19 09:45:09.215838+00 f f f \n", + "\n", + " job_title \\\n", + "0 Account Executive - Dispensing (NorCal/Norther... \n", + "1 Registered Nurse - RN Care Manager \n", + "2 RESTAURANT SUPERVISOR - THE FORKLIFT \n", + "3 Independent Real Estate Agent \n", + "4 Group/Unit Supervisor (Systems Support Manager... \n", + "\n", + " company job_location first_seen \\\n", + "0 BD San Diego, CA 2024-01-15 \n", + "1 Trinity Health MI Norton Shores, MI 2024-01-14 \n", + "2 Wasatch Adaptive Sports Sandy, UT 2024-01-14 \n", + "3 Howard Hanna | Rand Realty Englewood Cliffs, NJ 2024-01-16 \n", + "4 IRS, Office of Chief Counsel Chamblee, GA 2024-01-17 \n", + "\n", + " search_city search_country search_position \\\n", + "0 Coronado United States Color Maker \n", + "1 Grand Haven United States Director Nursing Service \n", + "2 Tooele United States Stand-In \n", + "3 Pinehurst United States Real-Estate Clerk \n", + "4 Gadsden United States Supervisor Travel-Information Center \n", + "\n", + " job_level job_type job_summary \\\n", + "0 Mid senior Onsite Responsibilities\\nJob Description Summary\\nJob... \n", + "1 Mid senior Onsite Employment Type:\\nFull time\\nShift:\\nDescripti... \n", + "2 Mid senior Onsite Job Details\\nDescription\\nWhat You'll Do\\nAs a... \n", + "3 Mid senior Onsite Who We Are\\nRand Realty is a family-owned brok... \n", + "4 Mid senior Onsite None \n", + "\n", + " summary_length \n", + "0 4602 \n", + "1 2950 \n", + "2 4571 \n", + "3 3944 \n", + "4 " + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "df_merged=pd.merge(job_postings_df, job_summary_df, how=\"left\", on=\"job_link\")\n", + "df_merged.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "0160a559-2b17-40a6-ad9d-34ce746236d0", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 490 + }, + "id": "0160a559-2b17-40a6-ad9d-34ce746236d0", + "outputId": "e397c28b-a90d-42d2-8a9a-4c6260c45b38" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 33.2 ms, sys: 17.3 ms, total: 50.6 ms\n", + "Wall time: 120 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
summary_length
companyjob_title
ClickJobs.ioAdolescent Behavioral Health Therapist - Substance Use Specialty (Entry Senior Level) Psychiatry23748.0
Mt. San Antonio CollegeChief, Police and Campus Safety22998.0
CareerBeaconAirside/Groundside Project Manager [Halifax International Airport Authority]22938.0
Tacoma Community CollegeAnthropology Professor - Part-time22790.0
IRS, Office of Chief CounselProgram Analyst (12-Month Roster)22774.0
.........
鴻海精密工業股份有限公司HR Specialist - Payroll & Benefit0.0
Material Planner0.0
RFQ Specialist0.0
Supply Chain Program Manager0.0
🌟Daniel-Scott Recruitment Ltd🌟IT Manager0.0
\n", + "

801276 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " summary_length\n", + "company job_title \n", + "ClickJobs.io Adolescent Behavioral Health Therapist - Substa... 23748.0\n", + "Mt. San Antonio College Chief, Police and Campus Safety 22998.0\n", + "CareerBeacon Airside/Groundside Project Manager [Halifax Int... 22938.0\n", + "Tacoma Community College Anthropology Professor - Part-time 22790.0\n", + "IRS, Office of Chief Counsel Program Analyst (12-Month Roster) 22774.0\n", + "... ...\n", + "鴻海精密工業股份有限公司 HR Specialist - Payroll & Benefit 0.0\n", + " Material Planner 0.0\n", + " RFQ Specialist 0.0\n", + " Supply Chain Program Manager 0.0\n", + "🌟Daniel-Scott Recruitment Ltd🌟 IT Manager 0.0\n", + "\n", + "[801276 rows x 1 columns]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "df_merged.groupby(['company',\"job_title\"]).agg({\n", + " \"summary_length\":\"mean\"}).sort_values(by='summary_length', ascending = False).fillna(0)" + ] + }, + { + "cell_type": "markdown", + "id": "IME4urGYQ3qS", + "metadata": { + "id": "IME4urGYQ3qS" + }, + "source": [ + "We went down from around 5 seconds to less than a second here. This is in line with our speedups on other operations!" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "adc00726-f151-41f4-8731-a1ce1f83eea2", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 458 + }, + "id": "adc00726-f151-41f4-8731-a1ce1f83eea2", + "outputId": "46423696-b167-4ffe-bb3b-9de7f3e6d668" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 13.7 ms, sys: 20.3 ms, total: 34 ms\n", + "Wall time: 156 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
job_titlejob_locationsummary_length
0🔥Nurse Manager, Patient Services - Operating RoomLake George, NY7342.0
1🔥Behavioral Health RN 3 12sGlens Falls, NY2787.0
2🔥 Surgical Technologist - EveningsLake George, NY2920.0
3🔥 Physician Practice Clinical Lead RNSaratoga Springs, NY2945.0
4🔥 Physican Practice LPN - GreenLake George, NY2969.0
............
1104106\"Attorney\" (Gov Appt/Non-Merit) JobsKentucky, United States2427.0
1104107\"Accountant\"Shavano Park, TX1497.0
1104108\"Accountant\"Basking Ridge, NJ1073.0
1104109\"Accountant\"Austin, TX1993.0
1104110\"A\" Softball Coach - Central Middle SchoolEast Corinth, ME718.0
\n", + "

1104111 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " job_title \\\n", + "0 🔥Nurse Manager, Patient Services - Operating Room \n", + "1 🔥Behavioral Health RN 3 12s \n", + "2 🔥 Surgical Technologist - Evenings \n", + "3 🔥 Physician Practice Clinical Lead RN \n", + "4 🔥 Physican Practice LPN - Green \n", + "... ... \n", + "1104106 \"Attorney\" (Gov Appt/Non-Merit) Jobs \n", + "1104107 \"Accountant\" \n", + "1104108 \"Accountant\" \n", + "1104109 \"Accountant\" \n", + "1104110 \"A\" Softball Coach - Central Middle School \n", + "\n", + " job_location summary_length \n", + "0 Lake George, NY 7342.0 \n", + "1 Glens Falls, NY 2787.0 \n", + "2 Lake George, NY 2920.0 \n", + "3 Saratoga Springs, NY 2945.0 \n", + "4 Lake George, NY 2969.0 \n", + "... ... ... \n", + "1104106 Kentucky, United States 2427.0 \n", + "1104107 Shavano Park, TX 1497.0 \n", + "1104108 Basking Ridge, NJ 1073.0 \n", + "1104109 Austin, TX 1993.0 \n", + "1104110 East Corinth, ME 718.0 \n", + "\n", + "[1104111 rows x 3 columns]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "# Group by company, job_title, and month, and calculate the mean of summary_length\n", + "grouped_df = df_merged.groupby(['job_title', 'job_location']).agg({'summary_length': 'mean'})\n", + "\n", + "# Reset index to sort by job_title and month\n", + "grouped_df = grouped_df.reset_index()\n", + "\n", + "# Sort by job_title and month\n", + "sorted_df = grouped_df.sort_values(by=['job_title', 'job_location','summary_length'],\n", + " ascending=False).reset_index(drop=True).fillna(0)\n", + "sorted_df" + ] + }, + { + "cell_type": "markdown", + "id": "08c97b81-64c5-48fb-8fe0-d36789cf3deb", + "metadata": { + "id": "08c97b81-64c5-48fb-8fe0-d36789cf3deb" + }, + "source": [ + "The acceleration is consistently 10x+ for complex aggregations and sorting that involve multiple columns." + ] + }, + { + "cell_type": "markdown", + "id": "9bcc719b-666a-4bc9-97d6-16f448b5c707", + "metadata": { + "id": "9bcc719b-666a-4bc9-97d6-16f448b5c707" + }, + "source": [ + "# Summary\n", + "\n", + "With cudf.pandas, you can keep using pandas as your primary dataframe library. When things start to get a little slow, just load the `cudf.pandas` extension and enjoy the incredible speedups.\n", + "\n", + "To learn more about cudf.pandas, we encourage you to visit https://rapids.ai/cudf-pandas." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/nvidia/cuda-x-data-science/assets/cuml_sklearn_demo.ipynb b/nvidia/cuda-x-data-science/assets/cuml_sklearn_demo.ipynb new file mode 100644 index 0000000..ec0e15c --- /dev/null +++ b/nvidia/cuda-x-data-science/assets/cuml_sklearn_demo.ipynb @@ -0,0 +1,2311 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "ZhTWAPo7X5-I" + }, + "source": [ + "# Getting Started with cuML's accelerator mode (cuml.accel)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BinKvOgMYOCp" + }, + "source": [ + "cuML is a Python GPU library for accelerating machine learning models using a scikit-learn-like API.\n", + "\n", + "cuML now has an accelerator mode (cuml.accel) which allows you to bring accelerated computing to existing workflows with zero code changes required. In addition to scikit-learn, cuml.accel also provides acceleration to algorithms found in umap-learn (UMAP) and hdbscan (HDBSCAN).\n", + "\n", + "This notebook is a brief introduction to cuml.accel.\n", + "\n", + "**Author:** Mitesh Patel, Allison Ding
\n", + "**Date:** October 3, 2025" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ylUzZjM-mRMH" + }, + "source": [ + "# ⚠️ Verify your setup" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e_AtDRMEZQd-" + }, + "source": [ + "First, we'll verfiy that we are running on an NVIDIA GPU:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sun Oct 5 21:26:06 2025 \n", + "+-----------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 580.82.09 Driver Version: 580.82.09 CUDA Version: 13.0 |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+========================+======================|\n", + "| 0 NVIDIA GB10 Off | 0000000F:01:00.0 Off | N/A |\n", + "| N/A 38C P0 5W / N/A | Not Supported | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + "\n", + "+-----------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=========================================================================================|\n", + "| 0 N/A N/A 3405 G /usr/lib/xorg/Xorg 242MiB |\n", + "| 0 N/A N/A 3562 G /usr/bin/gnome-shell 50MiB |\n", + "+-----------------------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qC3fevZecnns" + }, + "source": [ + "With classical machine learning, there is a wide range of interesting problems we can explore. In this tutorial we'll examine 3 of the more popular use cases: classification, clustering, and dimensionality reduction." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GPU-Accelerated Machine Learning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The notebook magic command `%load_ext cuml.accel` enables automatic GPU acceleration for machine learning code written with libraries like UMAP and HDBSCAN, so models can train and run on NVIDIA GPUs without code changes or manual conversions. \n", + "\n", + "After activating this extension, supported estimators and algorithms are dispatched to the GPU for faster computation, and any operations not yet accelerated will seamlessly fall back to CPU execution. This approach is ideal for accelerating existing workflows in Jupyter or IPython environments, allowing significant speedups with minimal effort" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext cuml.accel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Classification" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's load a dataset and see how we can use scikit-learn to classify that data. For this example we'll use the Coverage Type dataset, which contains a number of features that can be used to predict forest cover type, such as elevation, aspect, slope, and soil-type.\n", + "\n", + "More information on this dataset can be found at https://archive.ics.uci.edu/dataset/31/covertype." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.svm import SVC, LinearSVC\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import classification_report, accuracy_score" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/covtype/covtype.data.gz\"\n", + "\n", + "# Column names for the dataset (from UCI Covertype description)\n", + "columns = ['Elevation', 'Aspect', 'Slope', 'Horizontal_Distance_To_Hydrology', 'Vertical_Distance_To_Hydrology',\n", + " 'Horizontal_Distance_To_Roadways', 'Hillshade_9am', 'Hillshade_Noon', 'Hillshade_3pm',\n", + " 'Horizontal_Distance_To_Fire_Points', 'Wilderness_Area1', 'Wilderness_Area2', 'Wilderness_Area3',\n", + " 'Wilderness_Area4', 'Soil_Type1', 'Soil_Type2', 'Soil_Type3', 'Soil_Type4', 'Soil_Type5', 'Soil_Type6',\n", + " 'Soil_Type7', 'Soil_Type8', 'Soil_Type9', 'Soil_Type10', 'Soil_Type11', 'Soil_Type12', 'Soil_Type13',\n", + " 'Soil_Type14', 'Soil_Type15', 'Soil_Type16', 'Soil_Type17', 'Soil_Type18', 'Soil_Type19', 'Soil_Type20',\n", + " 'Soil_Type21', 'Soil_Type22', 'Soil_Type23', 'Soil_Type24', 'Soil_Type25', 'Soil_Type26', 'Soil_Type27',\n", + " 'Soil_Type28', 'Soil_Type29', 'Soil_Type30', 'Soil_Type31', 'Soil_Type32', 'Soil_Type33', 'Soil_Type34',\n", + " 'Soil_Type35', 'Soil_Type36', 'Soil_Type37', 'Soil_Type38', 'Soil_Type39', 'Soil_Type40', 'Cover_Type']\n", + "\n", + "data = pd.read_csv(url, header=None)\n", + "data.columns=columns" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(581012, 55)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we'll separate out the classification variable (Cover_Type) from the rest of the data. This is what we will aim to predict with our classification model. We can also split our dataset into training and test data using the scikit-learn train_test_split function." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = data.drop('Cover_Type', axis=1), data['Cover_Type']\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have our dataset split, we're ready to run a model. To start, we will just run the model using the sklearn library with a starting max depth of 5 and all of the features. Note that we can set n_jobs=-1 to utilize all available CPU cores for fitting the trees -- this will ensure we get the best performance possible on our system's CPU." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "clf = LinearSVC()\n", + "clf.fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In about 2 minutes, we were able to fit our tree model using scikit-learn. This is not bad! Let's use the model we just trained to predict coverage types in our test dataset and take a look at the accuracy of our model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "y_pred = clf.predict(X_test)\n", + "accuracy_score(y_test, y_pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also print out a full classification report to better understand how we predicted different Coverage_Type categories." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 1 0.39 0.28 0.33 42371\n", + " 2 0.54 0.75 0.63 56772\n", + " 3 0.65 0.61 0.63 7146\n", + " 4 0.00 0.00 0.00 546\n", + " 5 0.00 0.00 0.00 1907\n", + " 6 0.00 0.00 0.00 3454\n", + " 7 0.00 0.00 0.00 4007\n", + "\n", + " accuracy 0.51 116203\n", + " macro avg 0.23 0.23 0.23 116203\n", + "weighted avg 0.45 0.51 0.46 116203\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages/sklearn/metrics/_classification.py:1731: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", result.shape[0])\n", + "/home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages/sklearn/metrics/_classification.py:1731: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", result.shape[0])\n", + "/home/nvidia/miniconda3/envs/rapids-25.10/lib/python3.12/site-packages/sklearn/metrics/_classification.py:1731: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", result.shape[0])\n" + ] + } + ], + "source": [ + "\n", + "print(classification_report(y_test, y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With scikit-learn, we built a model that was able to be trained in just a couple minutes. From the accuracy report, we can see that we predicted the correct class around 70% of the time, which is not bad but could certainly be improved.\n", + "\n", + "Often we want to run several different random forest models in order to optimize our hyperparameters. For example, we may want to increase the number of estimators, or modify the maximum depth of our tree. When running dozens or hundreds of different hyperparameter combinations, things start to become quite slow and iteration takes a lot longer.\n", + "\n", + "We provide some sample code utilizing GridSearchCV below to show what this process might look like. All of these combinations would take a LONG time to run if we spend 2 minutes fitting each model." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nfrom sklearn.model_selection import GridSearchCV\\n\\n# Define the parameter grid to search over\\nparam_grid = {\\n 'n_estimators': [50, 100, 200],\\n 'max_depth': [None, 10, 20, 30],\\n 'min_samples_split': [2, 5, 10],\\n 'min_samples_leaf': [1, 2, 4],\\n 'max_features': ['auto', 'sqrt', 'log2'],\\n 'bootstrap': [True, False]\\n}\\n\\ngrid_search = GridSearchCV(estimator=clf, param_grid=param_grid, cv=5)\\ngrid_search.fit(X_train, y_train)\\n\"" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "# Define the parameter grid to search over\n", + "param_grid = {\n", + " 'n_estimators': [50, 100, 200],\n", + " 'max_depth': [None, 10, 20, 30],\n", + " 'min_samples_split': [2, 5, 10],\n", + " 'min_samples_leaf': [1, 2, 4],\n", + " 'max_features': ['auto', 'sqrt', 'log2'],\n", + " 'bootstrap': [True, False]\n", + "}\n", + "\n", + "grid_search = GridSearchCV(estimator=clf, param_grid=param_grid, cv=5)\n", + "grid_search.fit(X_train, y_train)\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With a model that runs in just seconds, we can perform hyperparameter optimization using a method like the grid search shown above, and have results in just minutes instead of hours." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CPU Fallback" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are some algorithms and functionality from scikit-learn, UMAP, and HDBSCAN that are *not* implemented in cuML. For cases where the underlying functionality is not supported on GPU, the cuML accelerator will gracefully fall back and execute on the CPU instead." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.neighbors import KernelDensity\n", + "import numpy as np\n", + "\n", + "X = np.concatenate((np.random.normal(0, 1, 10000),\n", + " np.random.normal(5, 1, 10000)))[:, np.newaxis]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
KernelDensity(bandwidth=0.5)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "KernelDensity(bandwidth=0.5)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "kde = KernelDensity(kernel='gaussian', bandwidth=0.5)\n", + "kde.fit(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-2.03555686 -1.81195669 -1.78476911 ... -3.20381041 -1.73643757\n", + " -2.82360998]\n" + ] + } + ], + "source": [ + "print(kde.score_samples(X))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9Ql7UCNUW1AO" + }, + "source": [ + "We'll now take a look at a clustering example using HDBSCAN." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pdjvwlZ-DaoW" + }, + "source": [ + "# Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "70sdcTIdfzkK" + }, + "source": [ + "Clustering is an important data science workflow because it helps uncover hidden patterns and structures within data without requiring labeled outcomes. In practice, with high dimensional data it can be difficult to discern whether the clusters we've chosen are good or not. One way to determine the quality of our clustering is with sklearn's [silhouette score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.silhouette_score.html#sklearn.metrics.silhouette_score), which we'll examine shortly.\n", + "\n", + "HDBSCAN is a popular density-based clustering algorithm that is highly flexible. We'll load a toy sklearn dataset to illustrate how HDBSCAN can be accelerated with cuml.accel." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "oIlRPHZ1DZ7q" + }, + "outputs": [], + "source": [ + "import hdbscan\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.datasets import make_blobs\n", + "from sklearn.metrics import silhouette_score" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "RqXkNWRjDZ9n", + "outputId": "57435e6c-a303-4531-d64b-87ba14cce410" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "N = 20000\n", + "K = 100\n", + "\n", + "X, y = make_blobs(\n", + " n_samples=N,\n", + " n_features=K,\n", + " centers=5,\n", + " cluster_std=[3,1,2,1.5,0.5],\n", + " random_state=42\n", + ")\n", + "\n", + "plt.scatter(X[:, 0], X[:, 1], c=y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 184 + }, + "id": "536jWwBWg1Ou", + "outputId": "c589e021-e14e-4848-d8b5-2302c00d4ef7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 213 ms, sys: 208 ms, total: 421 ms\n", + "Wall time: 597 ms\n" + ] + }, + { + "data": { + "text/html": [ + "
HDBSCAN()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "HDBSCAN()" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "clusterer = hdbscan.HDBSCAN()\n", + "clusterer.fit(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wrAzGgqrxHtY", + "outputId": "05493c84-d6cf-469a-e533-db36558c76ec" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7352694189002873\n" + ] + } + ], + "source": [ + "print(silhouette_score(X, clusterer.labels_))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "93qD18LqDiOj" + }, + "source": [ + "# Dimensionality Reduction" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n0mwvzC0rdq4" + }, + "source": [ + "UMAP is a popular dimensionality reduction technique that is used for both data visualization and as preprocessing for downstream modeling due to its ability to balance preserving both local and global structure of high-dimensional data. To learn more about how it works, visit the [UMAP documentation](https://umap-learn.readthedocs.io/en/latest/).\n", + "\n", + "To explore how cuML can accelerate UMAP, let's load in another dataset from UCI. We'll use the Human Activity Recognition (HAR) dataset, which was created from recordings of 30 subjects performing activities of daily living (ADL) while carrying a waist-mounted smartphone with embedded inertial sensors." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JOeW2dt9D2IZ", + "outputId": "3f687e7c-8652-4b8e-bfc3-43cd1b291531" + }, + "outputs": [], + "source": [ + "!wget https://archive.ics.uci.edu/ml/machine-learning-databases/00240/UCI%20HAR%20Dataset.zip -O /tmp/HAR_data.zip" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TR78I9VuEGlu", + "outputId": "aad52a74-9c40-4be5-dc30-d6cda2b0f971" + }, + "outputs": [], + "source": [ + "!unzip /tmp/HAR_data.zip -d /tmp/HAR_data/" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "QjGw0WDwCu2_" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:3: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:4: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:5: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:6: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:7: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:3: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:4: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:5: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:6: SyntaxWarning: invalid escape sequence '\\s'\n", + "<>:7: SyntaxWarning: invalid escape sequence '\\s'\n", + "/tmp/ipykernel_238331/4099239257.py:3: SyntaxWarning: invalid escape sequence '\\s'\n", + " X_train = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/train/X_train.txt\", sep=\"\\s+\", header=None)\n", + "/tmp/ipykernel_238331/4099239257.py:4: SyntaxWarning: invalid escape sequence '\\s'\n", + " y_train = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/train/y_train.txt\", sep=\"\\s+\", header=None)\n", + "/tmp/ipykernel_238331/4099239257.py:5: SyntaxWarning: invalid escape sequence '\\s'\n", + " X_test = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/test/X_test.txt\", sep=\"\\s+\", header=None)\n", + "/tmp/ipykernel_238331/4099239257.py:6: SyntaxWarning: invalid escape sequence '\\s'\n", + " y_test = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/test/y_test.txt\", sep=\"\\s+\", header=None)\n", + "/tmp/ipykernel_238331/4099239257.py:7: SyntaxWarning: invalid escape sequence '\\s'\n", + " labels = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/activity_labels.txt\", sep=\"\\s+\", header=None)\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "X_train = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/train/X_train.txt\", sep=\"\\s+\", header=None)\n", + "y_train = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/train/y_train.txt\", sep=\"\\s+\", header=None)\n", + "X_test = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/test/X_test.txt\", sep=\"\\s+\", header=None)\n", + "y_test = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/test/y_test.txt\", sep=\"\\s+\", header=None)\n", + "labels = pd.read_csv(\"/tmp/HAR_data/UCI HAR Dataset/activity_labels.txt\", sep=\"\\s+\", header=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oesYc97pQ1vr", + "outputId": "e7dca260-5abb-4f27-d61e-e336955b5271" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(7352, 561)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F5Cle6mGOH7S" + }, + "source": [ + "Let's take a look at the activity labels to better understand the data we're working with. We can see that the sensors have grouped activities into 6 different classes." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 238 + }, + "id": "22YYMRvXOUUz", + "outputId": "b15af6d7-8c52-474e-f102-f573dd7f2d2e" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01
01WALKING
12WALKING_UPSTAIRS
23WALKING_DOWNSTAIRS
34SITTING
45STANDING
56LAYING
\n", + "
" + ], + "text/plain": [ + " 0 1\n", + "0 1 WALKING\n", + "1 2 WALKING_UPSTAIRS\n", + "2 3 WALKING_DOWNSTAIRS\n", + "3 4 SITTING\n", + "4 5 STANDING\n", + "5 6 LAYING" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "8rA7SsEpCu5M" + }, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# Scale the data before applying UMAP\n", + "scaler = StandardScaler()\n", + "X_train_scaled = scaler.fit_transform(X_train)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_9ltJhG7tQt0" + }, + "source": [ + "Let's run UMAP with some basic parameters and explore a lower-dimensionality projection of this dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "id": "t4sR7x3sF_9a" + }, + "outputs": [], + "source": [ + "import umap\n", + "umap_model = umap.UMAP(n_neighbors=15, n_components=2, random_state=42, min_dist=0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cGD49PFVlyrz", + "outputId": "81f5a19c-d2c6-498c-c673-facc3ced964d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2025-10-05 21:26:31.169] [CUML] [info] build_algo set to brute_force_knn because random_state is given\n", + "CPU times: user 170 ms, sys: 61.5 ms, total: 232 ms\n", + "Wall time: 481 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "# Fit UMAP model to the data\n", + "X_train_umap = umap_model.fit_transform(X_train_scaled)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kwJC2woSl4U9" + }, + "source": [ + "It's often quite interesting to visualize the resulting projection of the embeddings created by UMAP. In this case, let's take a look at the now 2-dimensional dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 718 + }, + "id": "PDRxaBEdF__X", + "outputId": "2ddd2b8b-8b1a-48e4-e06b-b5ffe0245f27" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot the UMAP result\n", + "plt.figure(figsize=(10, 8))\n", + "plt.scatter(X_train_umap[:, 0], X_train_umap[:, 1], c=y_train.values.ravel(), cmap='Spectral', s=10)\n", + "plt.colorbar(label=\"Activity\")\n", + "plt.title(\"UMAP projection of the UCI HAR dataset\")\n", + "plt.xlabel(\"UMAP Component 1\")\n", + "plt.ylabel(\"UMAP Component 2\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gKFBLuE7mFrs" + }, + "source": [ + "It's interesting to see how our different categories are grouped in relation to one another.\n", + "\n", + "We can look at the trustworthiness score to better understand how well the structure of the original dataset was preserved by our 2D projection" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Say1EIdqMLoq", + "outputId": "3c3f1623-8ef2-4703-9dcb-1e2ba3e148d7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.9709711206340002)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.manifold import trustworthiness\n", + "trustworthiness(X_train, X_train_umap, n_neighbors=15)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1OzvVajcm2jX" + }, + "source": [ + "It looks like this projection is a great representation of our full dataset.\n", + "\n", + "Let's now run the same thing with the accelerator turned on." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "rapids-25.10", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/nvidia/vibe-coding/README.md b/nvidia/vibe-coding/README.md new file mode 100644 index 0000000..4658a79 --- /dev/null +++ b/nvidia/vibe-coding/README.md @@ -0,0 +1,187 @@ +# Vibe Coding in VS Code + +> Use DGX Spark as a local or remote Vibe Coding assistant with Ollama and Continue + +## Table of Contents + +- [Overview](#overview) + - [What You'll Accomplish](#what-youll-accomplish) + - [Prerequisites](#prerequisites) + - [Requirements](#requirements) +- [Instructions](#instructions) +- [Troubleshooting](#troubleshooting) + +--- + +## Overview + +## DGX Spark Vibe Coding + +This playbook walks you through setting up DGX Spark as a **Vibe Coding assistant** — locally or as a remote coding companion for VSCode with Continue.dev. +This guide uses **Ollama** with **GPT-OSS 120B** to provide easy deployment of a coding assistant to VSCode. Included is advanced instructions to allow DGX Spark and Ollama to provide the coding assistant to be available over your local network. This guide is also written on a **fresh installation* of the OS. If your OS is not freshly installed and you have issues, see the troubleshooting section at the bottom of the document. + +### What You'll Accomplish + +You'll have a fully configured DGX Spark system capable of: +- Running local code assistance through Ollama. +- Serving models remotely for Continue and VSCode integration. +- Hosting large LLMs like GPT-OSS 120B using unified memory. + +### Prerequisites + +- DGX Spark (128GB unified memory recommended) +- Internet access for model downloads +- Basic familiarity with the terminal +- Optional: firewall control for remote access configuration + +### Requirements + +- **Ollama** and an LLM of your choice (e.g., `gpt-oss:120b`) +- **VSCode** +- **Continue** VSCode extension +- Basic familiarity with opening the Linux terminal, copying and pasting commands. +- Having sudo access. + +## Instructions + +## Step 1. Install Ollama + +Install the latest version of Ollama using the following command: + +```bash +curl -fsSL https://ollama.com/install.sh | sh +``` +Once the service is running, pull the desired model: + +```bash +ollama pull gpt-oss:120b +``` + +## Step 2. (Optional) Enable Remote Access + +To allow remote connections (e.g., from a workstation using VSCode and Continue), modify the Ollama systemd service: + +```bash +sudo systemctl edit ollama +``` + +Add the following lines beneath the commented section: + +```ini +[Service] +Environment="OLLAMA_HOST=0.0.0.0:11434" +Environment="OLLAMA_ORIGINS=*" +``` + +Reload and restart the service: + +```bash +sudo systemctl daemon-reload +sudo systemctl restart ollama +``` + +If using a firewall, open port 11434: + +```bash +sudo ufw allow 11434/tcp +``` + +Verify that the workstation can connect to your DGX Spark's Ollama server: + + ```bash + curl -v http://YOUR_SPARK_IP:11434/api/version + ``` + Replace YOUR_SPARK_IP with your DGX Spark's IP address. + If the connection fails please see the troubleshooting section at the bottom of this document. + +## Step 3. Install VSCode + +For DGX Spark (ARM-based), download and install VSCode: + Navigate to https://code.visualstudio.com/download and download the Linux ARM64 version of VSCode. After + the download completes note the downloaded package name. Use it in the next command in place of DOWNLOADED_PACKAGE_NAME. +```bash +sudo dpkg -i DOWNLOADED_PACKAGE_NAME +``` + +If using a remote workstation, **install VSCode appropriate for your system architecture**. + +## Step 4. Install Continue.dev Extension + +Open VSCode and install **Continue.dev** from the Marketplace. +After installation, click the Continue icon on the right-hand bar. + + +## Step 5. Local Inference Setup +- Click Select **Or, configure your own models** +- Click **Click here to view more providers** +- Choose **Ollama** as the provider. +- For **Model**, select **Autodetect**. +- Test inference by sending a test prompt. + +Your downloaded model will now be the default (e.g., `gpt-oss:120b`) for inference. + +## Step 6. Setting up a Workstation to Connect to the DGX Spark' Ollama Server + +To connect a workstation running VSCode to a remote DGX Spark instance the following must be completed on that workstation: + - Install Continue from the marketplace. + - Click on the Continue icon on the left pane. + - Click ***Or, configure your own models*** + - Click **Click here to view more providers. + - Select ***Ollama*** from the provider list. + - Select ***Autodetect*** as the model. + +Continue **wil** fail to detect the model as it is attempting to connect to a locally hosted Ollama server. + - Find the **gear** icon in the upper right corner of the chat window and click on it. + - On the left pane, click **Models** + - Next to the first dropdown menu under **Chat** click the gear icon. + - Continue's config.yaml will open. Take note of your DGX Spark's IP address. + - Replace the configuration with the following. **YOUR_SPARK_IP** should be replaced with your DGX Spark's IP. + + +```yaml +name: Config +version: 1.0.0 +schema: v1 + +assistants: + - name: default + model: OllamaSpark + +models: + - name: OllamaSpark + provider: ollama + model: gpt-oss:120b + apiBase: http://YOUR_SPARK_IP:11434 + title: gpt-oss:120b + roles: + - chat + - edit + - autocomplete +``` + +Replace `YOUR_SPARK_IP` with the IP address of your DGX Spark. +Add additional model entries for any other Ollama models you wish to host remotely. + +## Troubleshooting + +## Common Issues + +**1. Ollama not starting** +- Verify Docker and GPU drivers are installed correctly. +- Run `ollama serve` on the DGX Spark to view Ollama logs. + +**2. Continue can't connect over the network** +- Ensure port 11434 is open and accessible from your workstation. + ```bash + ss -tuln | grep 11434 + ``` + If the output does not reflect " tcp LISTEN 0 4096 *:11434 *:* " + go back to step 2 and run the ufw command. + +**3. Continue can't detect a locally running Ollama model +- Check `OLLAMA_HOST` and `OLLAMA_ORIGINS` in `/etc/systemd/system/ollama.service.d/override.conf`. +- If `OLLAMA_HOST` and `OLLAMA_ORIGINS` are set correctly you should add these lines to your .bashrc. + +**4. High memory usage** +- Use smaller models such as `gpt-oss:20b` for lightweight usage. +- Confirm no other large models or containers are running with `nvidia-smi`. diff --git a/nvidia/vllm/README.md b/nvidia/vllm/README.md index ff17b8b..899a3af 100644 --- a/nvidia/vllm/README.md +++ b/nvidia/vllm/README.md @@ -118,7 +118,7 @@ sudo /usr/local/cuda-12.9/bin/cuda-uninstaller ## Step 1. Configure network connectivity -Follow the network setup instructions from the [Connect two Sparks](https://build.nvidia.com/spark/stack-sparks/stacked-sparks) playbook to establish connectivity between your DGX Spark nodes. +Follow the network setup instructions from the [Connect two Sparks](https://build.nvidia.com/spark/connect-two-sparks) playbook to establish connectivity between your DGX Spark nodes. This includes: - Physical QSFP cable connection