Forem: PEPPERCORN

[Day 3] I Had a Local LLM Analyze a Year of My Credit Card Statements

PEPPERCORN — Tue, 05 May 2026 22:52:50 +0000

[Day 3] I Had a Local LLM Analyze a Year of My Credit Card Statements

Intro

Day 3: I'm going to hand a year of credit card statements over to a local LLM and see what it can do.

This is experiment #3.

What I'm using today: DGX Spark + Ollama + Qwen2.5 (comparing 7B vs 72B). Ollama is the de-facto local-LLM runtime, and Qwen2.5 is a multilingual model from Alibaba (China) that handles Japanese reasonably well, apparently.

Today's setup

Data: 12 months of credit card statements from a single card.
Volume: 383 transactions, ¥2,761,555 in total spend.
Goal: get the AI to spot waste patterns and propose savings.
Comparison axes:
- Model size: 7B (light) vs 72B (heavy)
- Input format: raw CSV vs pandas-aggregated summary
- → 4 patterns total

Takeaway: "If you ask an AI to aggregate raw data, the numbers come out way off." / "If you pre-aggregate with a spreadsheet tool first and then feed the AI, you get fast and accurate results." A small but practical finding.

1. Get the CSVs onto the DGX

Log into the credit card company's web statements page on myPC1 (my Windows laptop), download 12 months of CSVs, then push them to the DGX.

I deliberately skipped GitHub for the transfer this time — once you push something, it's in the history forever, and credit card data shouldn't be there even briefly. Instead, I used direct PC-to-PC transfer over SSH (one command, finishes in seconds; details in the collapsibles at the end). The .gitignore excludes private-data/ too, so accidental commits are ruled out.

2. Install Ollama

Ollama is the de-facto runtime for local LLMs. One command should be enough.

There was a small password hiccup during install (details below), but eventually it was up and running.

The DGX Spark specs really show through:

Memory: 121 GB
Default context window: ~262,144 tokens

In other words: "throw a whole book at it, no problem" territory. Reassuring.

3. Two model sizes: Qwen2.5 7B vs 72B

The strategy: same model family, different sizes. That way the differences come from size, not architecture.

7B (light): ~4.7 GB, downloads in 5 minutes. Fast.
72B (heavy): ~47 GB, 25 minutes to download. Slow but smart.

What does "B" mean? Short for Billion. It's the number of "weights" inside the AI — more weights, more it remembers, basically. So 7B has 7 billion weights, 72B has 72 billion.

Loading both onto the DGX simultaneously, memory usage looks like:

AI model	Memory occupied
qwen2.5:72b	61 GB
qwen2.5:7b	8.2 GB
Total	69 GB

69 GB. Spacious!

4. Prepping the CSVs

Once I had the CSVs in hand, three small headaches before they were ready for the AI:

Headache 1: An older encoding (Windows Japanese flavor) → needs converting to modern UTF-8
Headache 2: Some merchant names contain commas, which breaks naive CSV parsing
Headache 3: Each file has a "monthly total" line at the end that isn't actually data

Details in the collapsible. After cleanup, the 12 files merge into a single dataset:

Item	Value
Transactions	383
Period	12 months (1 year)
Total spend	¥2,761,555
Avg per tx	¥7,210
Median per tx	¥3,000
Largest single tx	¥209,283 (overseas flight)
Smallest	¥-3,980 (refund)

Now to feed this to 7B and 72B and see what each of them says.

5. Experiment 1: Throw the raw CSV at the AI

No tricks: all 383 rows, straight at the AI. Prompt is the full ask: "As a household budget consultant, output category breakdown / monthly trend / waste patterns / savings suggestions / lifestyle hypothesis."

7B's answer (75 seconds)

...this is where the numbers go wildly off.

Item	What 7B said	Real data	Match?
Amazon total	¥2,014,386 (257 tx)	¥693,663 (166 tx)	❌
Amazon Downloads	¥2,014,386 (257 tx)	¥80,323 (50 tx)	❌
Outdoor brand	¥495,740	¥154,820	❌
A local recreation venue	"¥49,574" cited	(a different small charge actually exists)	❌

None of the numbers line up. Amazon total is roughly 3× off, Amazon Downloads about 25× off, and the cited venue context is a different charge entirely.

Reading 383 rows of CSV and computing totals turned out to be a heavy lift for the 7B model.

72B's answer (12m 9s)

What if we throw size at the problem? After 12 minutes of patience:

Item	What 72B said	Real data	Match?
Amazon total	¥635,792 (104 tx)	¥693,663 (166 tx)	❌
AI/dev tools	¥193,629 (21 tx)	¥176,850 (24 tx)	❌
Travel	¥487,555 (43 tx)	¥416,268 (8 tx)	❌

Not exact, but the off-by amounts are within ~10%, and there are no fabricated venues. A real improvement.

However — when asked about the monthly trend, here's what 72B said:

Month 1: ¥316,789 → Month 2: ¥229,600 → Month 3: ¥237,500 → ... → Month 12: ¥291,500
(Gradually increasing.)

The actual range is ¥69,961 (low) to ¥493,072 (high) — a chaotic up-and-down waveform. "Gradually increasing" isn't quite right. Even 72B isn't great at aggregating distributed data over a long CSV.

6. Experiment 2: Aggregate first, then feed the AI

If the AI struggles with aggregation, do the aggregation in a different tool first and only hand the AI the result.

The flow:

📥 Raw CSV (22,132 chars, 383 rows)
       ↓
🔧 Pre-aggregate with a spreadsheet tool (Python's pandas)
       ↓
📋 Aggregate summary (1,884 chars, ~90% smaller)
       ↓
🤖 Hand it to the AI (let it interpret and propose)

Python's pandas = a spreadsheet-like library, but ~10,000× more powerful than Excel functions, used for tabular data analysis.

7B + pre-aggregated input (50 seconds)

Numbers are fully accurate now.

Item	What 7B said	Real data	Match?
Amazon total	¥693,663	¥693,663	✅
AI/dev tools	¥176,850	¥176,850	✅
Monthly max	¥493,072	¥493,072	✅
Monthly min	¥69,961	¥69,961	✅

Quoting straight from the pre-aggregated numbers, the hallucinations vanished.

And 7B did this in 50 seconds — better quality than the 72B + raw CSV at 12 minutes. Quietly remarkable.

	Before (raw CSV)	After (aggregated)
Time	75s	50s
Numbers	wildly off	exact
Verdict	not usable as-is	quote directly

72B + pre-aggregated input (12m 13s)

72B's numbers also match exactly (well, since they're being quoted from pre-aggregated data, that's expected). The proposal quality was the strongest of the four patterns:

Reduce Amazon dependency

Current: online shopping (Amazon family) is 25.1% of total (¥693,663).

Suggestion: stick to essentials only, regular review, avoid impulse buys.

Expected savings: ¥57,805/month average (25% reduction) → ¥693,660/year

...wait, hold on. Annual Amazon spend was ¥693,663. The "savings" 72B suggests is ¥693,660. That's basically the same number. So the proposal is effectively "stop buying on Amazon entirely (100%)" — definitely not 25%. Apparently 72B's percentage arithmetic isn't bulletproof either.

That aside, the lifestyle hypothesis section was kind of striking. Here's what 72B observed:

Heavy reliance on apps and subscriptions: "App/subscription" category is 10.5% of total

Frequent international travel: "Travel/airline" is 15.1%, with notable overseas charges

Frequent online shopping: "Online (Amazon)" is 25.1% of total

It's just one card's data, so this isn't a complete picture — but if I fed an AI my full household financials, the analysis and advice would probably go a lot deeper.

Summary: 4 patterns

#	Model	Input	Time	Numerical accuracy	Proposal quality
1	7B	Raw CSV	75s	❌ Numbers way off	△
2	72B	Raw CSV	12m 9s	△ Misread monthly trend	○
3	7B	Aggregated	50s	✅ Exact	○ Some repetition
4	72B	Aggregated	12m 13s	✅ Exact	◎ Best (mind the % math)

Quietly notable: 72B takes ~12 minutes regardless of input size (shrinking the prompt didn't change wall-clock time much). Output generation is the bottleneck. Which strengthens the case for "small model + pre-aggregate" as the cost-effective default.

7. Cross-check: the actual graphs

Before trusting any of the AI output, let me put the real numbers on charts using the spreadsheet tool (pandas).

Monthly spending

Average ¥230,130/month, but the range is ¥69,961 (lowest) to ¥493,072 (highest) — about a 7× spread. The 72B's "gradually increasing" claim was a bit off the mark; the reality is bouncy.

Category share

"Other" being 32% is because my categorization rule is sloppy. I just wrote a simple "if the merchant name contains keyword X, bucket Y" rule, and lots of merchants didn't match any keyword and ended up in "Other." Reading meaning from a merchant name is exactly the kind of thing AI is good at, so next time I'll let the AI do the categorization itself.

Top 15 merchants

Amazon at ¥421,978 (105 tx) is far and away #1. Amazon really is too convenient...

Weekday rhythm

Tuesday alone is ¥692,549 — way above the rest. Probably because that's when most of the subscription auto-charges land.

8. Today's takeaways

Separate "aggregation" from "interpretation"

AI is bad at	AI is good at
Multi-row sum/average (numbers go wildly off)	Categorization (interpreting fuzzy meaning)
Percentage math (saw "25% off → 100% off")	Pattern recognition / hypothesis generation
Distributed aggregation like monthly totals	Narrative interpretation, savings proposals

→ Aggregation is the spreadsheet tool's job; interpretation is the AI's. When you split the work, things go fast and accurate. "Data prep matters before analysis" — yeah, that old saying really is true. Note to self.

Sometimes input quality beats raw size

"7B + pre-aggregated input in 50 seconds" outperformed "72B + raw CSV in 12 minutes". Sometimes you don't need a bigger model — you need cleaner input. Felt that one today.

The local-LLM angle

Feeding 12 months of raw credit card data to an AI without a single byte going to the cloud — it was surprisingly stress-free. This is one of the spots local LLMs really shine. Got personal info, or anything cloud-uncomfortable? This is the place for them.

9. Tech details (Claude explains)

The technical bits, written up by my AI pair.

SCP transfer to the DGX (mDNS, no IP needed)

NVIDIA Sync auto-configures a Host alias in ~/AppData/Local/NVIDIA Corporation/Sync/config/ssh_config:

Host spark-XXXX.local
  Hostname spark-XXXX.local
  User [user]
  Port 22
  IdentityFile "...\\nvsync.key"

Which means I can SSH/SCP using spark-XXXX.local without ever looking up an IP. The .local suffix uses mDNS (Multicast DNS) for hostname resolution within the LAN.

Transfer command (one line, from PowerShell on the Windows side):

scp -r "C:\Users\[user]\Desktop\docs\dgx\csv" spark-XXXX.local:/home/[user]/personal/dgx-100-experiments/private-data/credit-card-csv

Ollama install + the sudo-TTY catch + GPU detection log

Ollama install:

curl -fsSL https://ollama.com/install.sh | sh

Running this through Claude Code's Bash, it errored at the sudo password prompt — an interactive TTY is required there:

sudo: a terminal is required to read the password

Reopened a separate SSH session, ran the same command manually, and it went through.

Once installed, systemd auto-starts the service. The GPU detection log via journalctl -u ollama:

inference compute id=GPU-986c194b... name=CUDA0 description="NVIDIA GB10"
total="121.7 GiB" available="79.0 GiB"
default_num_ctx=262144

VRAM (DGX Spark unified memory): 121.7 GiB
Default context: 262,144 tokens

Compared with a typical RTX 4090 (24 GB VRAM, 8K–32K default context), the gap is significant.

Loading both models simultaneously

ollama pull qwen2.5:7b   # 4.7 GB
ollama pull qwen2.5:72b  # 47 GB

After loading both, ollama ps shows:

NAME           SIZE      PROCESSOR    CONTEXT    
qwen2.5:72b    61 GB     100% GPU     32768
qwen2.5:7b     8.2 GB    100% GPU     32768

Total ~69 GB used out of 79 GB available. Both models stay resident, switching between them is instant.

Custom CSV parser for the credit card data

Three quirks needed handling: CP932 encoding, no quotes (commas in some merchant names break parsing), and a trailing summary row in each file.

def parse_line(line: str) -&gt; list[str] | None:
    fields = line.rstrip("\r\n").split(",")
    if len(fields) &lt; 7 or not fields[0]:
        return None  # skip blank/summary rows
    if len(fields) &gt; 7:
        merchant = ",".join(fields[1:-5])
        fields = [fields[0], merchant] + fields[-5:]
    return fields


def load_one(path: Path) -&gt; pd.DataFrame:
    rows = []
    with path.open(encoding="cp932") as f:
        next(f)  # skip header (cardholder metadata)
        for line in f:
            parsed = parse_line(line)
            if parsed is not None:
                rows.append(parsed)
    df = pd.DataFrame(rows, columns=COLUMNS)
    df["利用日"] = pd.to_datetime(df["利用日"], format="%Y/%m/%d")
    df["利用金額"] = df["利用金額"].astype(int)
    return df

Japanese fonts in matplotlib

japanize-matplotlib doesn't work on Python 3.12 — it imports distutils, which was removed from the standard library.

The modern replacement is matplotlib-fontja:

pip install matplotlib-fontja

import matplotlib_fontja  # noqa: F401  ← just importing it sets up IPAexGothic

Calling Ollama from Python

The official ollama Python client is straightforward:

import ollama

client = ollama.Client()
stream = client.chat(
    model="qwen2.5:72b",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": user_prompt},
    ],
    options={"temperature": 0.3},
    stream=True,
)
for chunk in stream:
    print(chunk["message"]["content"], end="", flush=True)

Streaming makes long generation easier to watch unfold.

Tomorrow: Day 4

Day 4 plan: let a local AI sort 20,000 iPhone photos.

The actual goal is to have a local image-recognition model (CLIP family?) clean up my photo library so I can stop paying iCloud for storage upgrades...!

100ExperimentsWithDGX #LocalLLM #Ollama

[Day 2] I Trained an AI on 22 Photos of My Cat — Now It Draws Her in Any Scene

PEPPERCORN — Tue, 05 May 2026 00:06:00 +0000

[Day 2] I Trained an AI on 22 Photos of My Cat — Now It Draws Her in Any Scene

So, yesterday I generated "some cat"

Day 1 ended with "I made my DGX draw a cat" — but the cat that came out was just "a cat from somewhere". Today, the goal is to teach the AI about my actual cat (who's currently being looked after at my parents' place back in Japan).

This is what people call LoRA training.

LoRA: A technique that teaches an AI model "specific features" using a small set of images, without touching the base model itself. Apparently. The output is a small "diff" file (tens of MB).

This is experiment #2.

The training data

Source material: 22 photos of my cat.

I picked a mix of angles — front-facing, full body, sleepy poses, varying lighting — to give the AI a fair shot at recognizing the cat's defining features (tuxedo black-and-white pattern, white socks, the black smudge on the nose).

Training pipeline

1. Pre-processing

iPhone HEIC files don't work directly with most AI tools, so first conversion to JPG. 10 of the 22 were HEIC.

Then resize to 512px on the short side for training. This is where I tripped over a sneaky bug — details in the collapsible section below.

2. Captions

Every image gets a text description like "ohwx cat, sitting on a wooden floor, indoor, soft lighting". The four-letter ohwx is a meaningless token that becomes the trigger word for "my specific cat" after training.

Drafting 22 captions by hand would be tedious — but Claude can read images directly, so it drafted them while I just reviewed. The accuracy was uncanny. For example:

ohwx cat, walking on a metal kitchen counter, side profile, indoor kitchen with spice bottles and shelves in the background

ohwx cat, in a loaf pose on a gray carpet, mouth open showing teeth, mid-yawn, indoor with shelves and warm lights in the background

ohwx cat, sitting on a wooden floor by a balcony window, viewed from behind, sharp sunlight casting long shadows, indoor

SUGOI.

3. Kohya_ss training

Kohya_ss is the de-facto LoRA training tool. Set up a TOML config, run one command:

$ accelerate launch train_network.py \
    --config_file configs/train.toml \
    --dataset_config configs/dataset.toml

Training logs scroll by, and the loss value gradually drops. Lower loss = the model is learning, apparently.

4. Done

1100 steps in 13 minutes 3 seconds on the DGX Spark.

Result 1: just typing "ohwx cat" gives me my cat

The first thing I tried was a "without LoRA vs with LoRA" comparison. Same prompt — "ohwx cat as a chef in a kitchen, ..." — first without the LoRA, then with it:

Left: no LoRA. Right: with LoRA.

Without LoRA, ohwx is gibberish to the model, so it's ignored and only "a chef in a kitchen" carries weight. Result: a human chef. A nice woman cooking in a pink kitchen.

With LoRA, ohwx becomes a real token that points at my cat. Same prompt, but now my cat is the chef.

This was the moment that hit.

Result 2: novel scene reproduction

The training set has no photo of the cat sitting on a wooden floor in this exact composition. So I tried it:

White socks: present. Nose smudge: present.

My cat, in places she's never been

ohwx cat in various scenes.

Sunny balcony

Cozy.

Chef (reprise)

The chef hat fits suspiciously well. Cooking ability unverified.

Autumn forest

A painterly take.

Astronaut

A doppelgänger via the helmet glass — but sci-fi all the same.

Today's takeaway

"Build your own AI from your own data" turned out to be way more accessible than I'd assumed.

Tech details (Claude explains)

The technical bits, written up by my AI pair.

HEIC → JPG conversion and the EXIF orientation trap

Reading iPhone HEIC files in Python is straightforward with pillow-heif. JPG conversion is a few lines:

from PIL import Image, ImageOps
from pillow_heif import register_heif_opener
register_heif_opener()

with Image.open("IMG_1234.HEIC") as img:
    oriented = ImageOps.exif_transpose(img)  # ← critical line
    rgb = oriented.convert("RGB")
    rgb.save("IMG_1234.jpg", quality=95)

What I tripped on

My first version skipped ImageOps.exif_transpose(). Result: 8 of 22 photos came out rotated 90° in the resized output.

iPhones save portrait shots with the actual pixels stored landscape-ways, plus an EXIF Orientation tag saying "rotate 90° on display". Pillow's default Image.open() ignores that tag — you have to call exif_transpose() explicitly.

Caught it before training started. If I hadn't, the LoRA would have learned "sideways cat" and generation would be weird.

Kohya_ss setup on ARM64 (DGX Spark)

There are two repos commonly referred to as "Kohya_ss":

bmaltais/kohya_ss — GUI wrapper, xformers dependency (clashes with ARM64)
kohya-ss/sd-scripts — the actual training engine, CLI/TOML driven

DGX Spark is ARM64, so I went with the latter:

git clone --depth 1 https://github.com/kohya-ss/sd-scripts.git ~/Kohya_ss
cd ~/Kohya_ss
python3 -m venv venv &amp;&amp; source venv/bin/activate
pip install --upgrade pip
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt

DGX Spark uses CUDA 12.8 + ARM64 (sbsa), so the PyTorch cu128 channel works directly. Surprisingly painless.

Training config (TOML)

# train.toml (excerpt)
pretrained_model_name_or_path = ".../Realistic_Vision_V6.0_NV_B1.safetensors"
vae = ".../vae-ft-mse-840000-ema-pruned.safetensors"

network_module = "networks.lora"
network_dim = 32
network_alpha = 16

optimizer_type = "AdamW8bit"
unet_lr = 1e-4
text_encoder_lr = 5e-5
lr_scheduler = "cosine_with_restarts"

max_train_epochs = 10
save_every_n_epochs = 2

mixed_precision = "bf16"
sdpa = true
cache_latents = true

# dataset.toml
[general]
shuffle_caption = false
caption_extension = ".txt"
keep_tokens = 1

[[datasets]]
resolution = 512
batch_size = 2
enable_bucket = true

  [[datasets.subsets]]
  image_dir = "/path/to/cat-photos-512"
  num_repeats = 10

22 photos × 10 repeats × 10 epochs ÷ batch 2 = 1100 steps. 13 minutes.

Base model: Realistic Vision V6.0 B1 noVAE (a photo-realistic SD 1.5 derivative). External VAE: sd-vae-ft-mse-original. The combination is good at fur detail.

Hitting the ComfyUI HTTP API for batch generation

Clicking through the GUI for one image at a time gets old fast. ComfyUI exposes an HTTP API that's easy to drive from Python — urllib.request from the standard library is enough (no extra deps).

import json, urllib.request, time

COMFY_URL = "http://127.0.0.1:8188"

def queue_prompt(workflow):
    payload = json.dumps({"prompt": workflow}).encode()
    req = urllib.request.Request(
        f"{COMFY_URL}/prompt",
        data=payload,
        headers={"Content-Type": "application/json"},
    )
    return json.loads(urllib.request.urlopen(req).read())["prompt_id"]

def wait_for_history(prompt_id, timeout=180):
    start = time.time()
    while time.time() - start &lt; timeout:
        with urllib.request.urlopen(f"{COMFY_URL}/history/{prompt_id}") as resp:
            data = json.loads(resp.read())
            if prompt_id in data:
                return data[prompt_id]
        time.sleep(0.5)

The workflow is ComfyUI's API format (a dict of node IDs with their connections). To use a LoRA, insert a LoraLoader node between the checkpoint loader and KSampler.

DGX Spark generates one 512×768 image in about 3 seconds. With seed/strength/prompt parametrized in a script, all 12 grid images came out in under a minute.

Tomorrow: Day 3

Day 3 plan: have a local AI analyze my credit card history.

The kind of data I'd rather not send to a cloud AI, but absolutely want to understand. Quintessential local-AI territory.

100ExperimentsWithDGX #LocalLLM

[Day 1] DGX Spark Came Home — I Made It Draw a Cat

PEPPERCORN — Mon, 04 May 2026 03:20:48 +0000

[Day 1] DGX Spark Came Home — I Made It Draw a Cat

So... what is "local LLM" again?

Honestly, I'm still figuring out what "local LLM" even means. But somehow, through a series of decisions I won't fully justify here, I ended up buying an NVIDIA DGX Spark — and now it's sitting in my house.

DGX Spark: NVIDIA's "supercomputer for the home" — a small but seriously expensive box with the latest-gen AI chip inside. Apparently.

What I really want to figure out is: when should I use local AI vs. cloud AI? Reading articles about it doesn't seem to help, so I'm going full hands-on. Goal: 100 experiments, one per day-ish, until I have an evidence-based answer.

This is experiment#1.

First, the hardware

So this is what showed up at my door — solidly packed in a sturdy cardboard box.

When I opened it, I was surprised at how small it actually is. "This is the AI machine?" kind of small.

Boot up → Initial OS setup

Power on, and an Ubuntu-based DGX OS 7.5.0 boots up.

Welcome screen

"Get started" — yes, please.

Language and timezone

Standard Linux installer territory — same as Ubuntu?

Privacy settings

Diagnostic data sharing prompts.

System update

The moment I plugged it in, it started updating itself. Modern Linux being Linux.

Setup complete

I picked a username and let the hostname auto-assign. DGX-side prep done.

Connecting from my Windows PC

Plugging a monitor into the DGX every time would be tedious, so I want to SSH in from my regular Windows machine (which I've nicknamed "myPC1").

NVIDIA provides a desktop app called NVIDIA Sync that's supposed to make SSH setup painless. So I install it.

…and that's where I fell into a trap big-time. Windows OpenSSH refused to connect with a "your SSH config has weird permissions, can't trust it" error.

Full troubleshooting steps are in the collapsible "Tech details" section below.

Inside the DGX, finally

After much wrestling, I made it inside. Here's the rough lay of the land:

Item	Spec
GPU	NVIDIA GB10 Grace Blackwell
Memory	128GB (unified between CPU and GPU)
Storage	4TB SSD (basically empty)
CPU	20 cores (perf + efficiency combo)
Idle power	4W (yes, four)

128GB of memory is apparently 8–16x what's in a typical laptop.

Setting up image generation → 🐱

This is the main event. I'm setting up ComfyUI to generate the first cat from this DGX.

The ComfyUI interface looks like this:

The "boxes connected by cables" view is intimidating at first, but the default workflow is pre-wired. You just type a prompt and hit Queue Prompt.

So:

a cute fluffy cat sitting on a sunny windowsill, photorealistic, high detail, beautiful lighting, soft fur, cinematic, masterpiece, best quality

A few seconds later...

🐱 There it is — the very first cat my DGX has ever drawn!

Tweaked the prompt and made some more.

Eyes a bit unsettling but yeah, fluffy cat.

Going a touch dark there.

…is this a cat? It feels artistic though.

Distinctive composition.

Each masterpiece takes a few to a dozen seconds. That speed means I can iterate on prompts without thinking about cost — which turned out to be quite addictive.

Tech details (let the AI explain it)

The rest is the technical stuff. Read on if you're curious.

I'm a non-engineer poking at this stuff for the first time, so I had Claude (my AI pair programmer for this challenge) write up the technical details. Hopefully useful for anyone walking the same path.

How to actually get SSH working on Windows

NVIDIA Sync should generate an SSH keypair, register the public key on the DGX side at ~/.ssh/authorized_keys, and let you connect without a password.

If it doesn't work, the cause is usually permissions on Windows SSH config files.

Symptom

$ ssh spark-XXXX.local
Bad permissions. Try removing permissions for user: [PC]\CodexSandboxUsers
on file C:/Users/[user]/.ssh/config.

If you've installed Codex CLI or similar sandboxing tools in the past, the [PC]\CodexSandboxUsers group may have inherited permissions on ~/.ssh/.

Fix (run from an elevated PowerShell)

Use environment variables to avoid hard-coding your username/PC name.

# Take ownership
takeown /f "$env:USERPROFILE\.ssh\config"
icacls "$env:USERPROFILE\.ssh\config" /grant:r "$($env:USERNAME):F"

# Disable inheritance and remove the bad user
icacls "$env:USERPROFILE\.ssh\config" /inheritance:d
icacls "$env:USERPROFILE\.ssh\config" /remove "$env:COMPUTERNAME\CodexSandboxUsers"

Use /inheritance:d rather than /inheritance:r — :r strips all permissions, locking yourself out.

NVIDIA Sync's internal config files need the same treatment

~/.ssh/config Includes an NVIDIA Sync config file, and that one inherits the same problem.

$cfg = "$env:LOCALAPPDATA\NVIDIA Corporation\Sync\config\ssh_config"
icacls $cfg /inheritance:d
icacls $cfg /remove "$env:COMPUTERNAME\CodexSandboxUsers"

$key = "$env:LOCALAPPDATA\NVIDIA Corporation\Sync\config\nvsync.key"
icacls $key /inheritance:d
icacls $key /remove "$env:COMPUTERNAME\CodexSandboxUsers"

Ghost SIDs that icacls can't remove

If you have SIDs from deleted user accounts lingering, icacls /remove won't touch them. You need PowerShell ACL manipulation:

$cfg = "$env:LOCALAPPDATA\NVIDIA Corporation\Sync\config\ssh_config"
$acl = Get-Acl $cfg
$badRules = $acl.Access | Where-Object {
    $_.IdentityReference.Value -like "S-1-5-*" -and
    $_.IdentityReference.Translate([System.Security.Principal.NTAccount]) -isnot [System.Security.Principal.NTAccount]
}
$badRules | ForEach-Object { $acl.RemoveAccessRule($_) | Out-Null }
Set-Acl -Path $cfg -AclObject $acl

After this, ssh spark-XXXX.local connects on the first try (replace XXXX with your hostname).

Commands to check DGX specs

# GPU
$ nvidia-smi
NVIDIA-SMI 580.142    Driver Version: 580.142    CUDA Version: 13.0
GPU 0: NVIDIA GB10    36C    P8    4W / N/A

# OS
$ uname -a
Linux spark-XXXX 6.17.0-1014-nvidia ... aarch64 GNU/Linux

# Memory
$ free -h
Mem: 121Gi  2.6Gi  118Gi

# Storage
$ df -h
/dev/nvme0n1p2  3.7T  47G  3.5T  2%  /

# CPU
$ lscpu
Architecture:  aarch64
CPU(s):        20
Model name:    Cortex-X925 + Cortex-A725

Notable bits:

CUDA 13.0 (latest)
aarch64 (ARM64) architecture — yes, the DGX is ARM
121Gi (≈128GB) unified memory
20 cores in big.LITTLE layout (10 perf + 10 efficient)

ComfyUI installation steps

Following the official NVIDIA Comfy UI playbook.

# Virtual environment
cd ~
python3 -m venv comfyui-env
source comfyui-env/bin/activate

# PyTorch with CUDA 13.0
pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu130

# ComfyUI itself
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt

# Model (SD 1.5, ~2GB)
cd models/checkpoints/
wget https://huggingface.co/Comfy-Org/stable-diffusion-v1-5-archive/resolve/main/v1-5-pruned-emaonly-fp16.safetensors

# Launch server
cd ~/ComfyUI
python main.py --listen 0.0.0.0

Key packages installed:

torch 2.11.0+cu130
cuDNN 9.19
NCCL 2.28
transformers 5.7.0
comfyui-frontend-package 1.42.15

Open http://spark-XXXX.local:8188 from your Windows PC's browser to access ComfyUI (XXXX is your hostname).

Download speed

The 2GB model came down at 40.6 MB/s in 50 seconds from HuggingFace's CDN. About half of my home 1Gbps LAN.

Tomorrow: Day 2

Day 2 plan: Train a LoRA on photos of my actual cat.

Today's SD 1.5 only knows "some cat from somewhere". With LoRA fine-tuning, I should be able to teach it about my specific cat. That kind of personalization feels like the killer feature of running locally.

100ExperimentsWithDGX #LocalLLM