# IdleGPU additional workload research kit

Version 1 — 14 October 2026. These are offline research implementations, not enabled marketplace jobs. They never request a worker credential, submit evidence, grant badges, install packages or download models. The existing embeddings verification does not qualify any of these workloads.

Use a dedicated test directory in an existing working container. Do not change drivers, stop other workloads or install dependencies on the host. Keep the output report beside its new output directory. Existing paths are rejected to preserve evidence. Run one workload at a time, with an external timeout. CPU mode is explicit reference generation, not a GPU fallback.

## Files and dependencies

- `research_common.py`: local bounds, hashing, model validation and word-error scoring.
- `idlegpu_images.py`: CUDA PyTorch and Pillow; synthetic RGB resize batches.
- `idlegpu_audio.py`: CUDA PyTorch, Transformers, NumPy; reviewed local Whisper tiny.en and WAV fixtures.
- `idlegpu_render.py`: run inside an existing Blender installation with Cycles CUDA/OptiX support.
- `idlegpu_compare_research.py`: independent offline comparisons; Pillow and NumPy for image/render comparison.
- `research-workloads.json`: operation contracts, limits and readiness.

Record the actual image digest, library versions and machine environment. A supplied digest or device string alone does not attest hardware or software identity.

## 1. Image resizing — first test in the working PyTorch environment

Replace the image digest below with the actual pinned image used to launch the container. Work from a dedicated writable directory; keep the scripts together. This command generates only original synthetic image inputs.

```bash
python3 idlegpu_images.py --container-digest 'IMAGE@sha256:ACTUAL_DIGEST' \
  --items 64 --batch-size 8 --source-size 512 --target-size 256 \
  --output-dir image-gpu-64 --output image-gpu-64.json --preflight

timeout 180s python3 idlegpu_images.py --container-digest 'IMAGE@sha256:ACTUAL_DIGEST' \
  --items 64 --batch-size 8 --source-size 512 --target-size 256 \
  --output-dir image-gpu-64 --output image-gpu-64.json
```

In a separate trusted CPU environment, run the same runner and fixture settings with `--device cpu`, new output names and that environment's actual image digest. Keep its full JSON and PNG directory. Compare:

```bash
python3 idlegpu_compare_research.py --actual image-gpu-64.json \
  --reference image-cpu-64.json --output image-comparison-64.json
```

Initial acceptance: every image has the expected dimensions, finite float outputs, local maximum error ≤2e-6 and independent PNG difference ≤one 8-bit colour level. Then run sequential 1,000 and 10,000 item tests, using new report/output names. Keep batch size fixed first; later compare batches 1/8/32. This is resizing, not learned upscaling, tagging or image generation. `computeSeconds` excludes transfer/encoding/reference work; `pipelineSeconds` includes them. Compare delivered throughput using pipeline time, not compute time alone. PNG output storage scales with item count; confirm space before the larger runs.

## 2. Audio transcription — requires separately reviewed model and fixtures

Do not run if the model or dependencies are missing. Report the missing prerequisite first. No model is installed or downloaded by this kit.

The selected first model is `openai/whisper-tiny.en`, for short English clips only. Before staging, the owner must select and review an immutable 40-character upstream revision, model licence/provenance and SHA256 hashes. A manifest calculated by the provider alone is local integrity evidence, not independent provenance. Keep model files read-only in their own directory, without Python code, pickle weights, unrelated files or subdirectories. The reviewed manifest requires:

```json
{
  "modelId": "openai/whisper-tiny.en",
  "revision": "OWNER_REVIEWED_40_CHARACTER_COMMIT",
  "files": {
    "config.json": "REVIEWED_SHA256",
    "generation_config.json": "REVIEWED_SHA256",
    "preprocessor_config.json": "REVIEWED_SHA256",
    "tokenizer.json": "REVIEWED_SHA256",
    "tokenizer_config.json": "REVIEWED_SHA256",
    "special_tokens_map.json": "REVIEWED_SHA256",
    "vocab.json": "REVIEWED_SHA256",
    "merges.txt": "REVIEWED_SHA256",
    "model.safetensors": "REVIEWED_SHA256"
  }
}
```

This template deliberately has no invented revision/hashes. Additional reviewed JSON/text files can be added, up to 16 total. Store licence/provenance records outside the runtime model directory. Pin Transformers, PyTorch and the container separately.

Create 1–16 original or authorised public WAV clips with known English transcripts. They must be mono, 16 kHz, 16-bit PCM, 1–30 seconds each, no more than four minutes total. Do not use private meeting recordings. Put fixtures.json beside the WAVs:

```json
{
  "dataScope": "public_or_synthetic",
  "items": [{"file":"sample-01.wav","sha256":"REVIEWED_WAV_SHA256","expectedText":"The original words spoken in this approved test clip."}]
}
```

```bash
python3 idlegpu_audio.py --model-dir /models/reviewed-whisper-tiny-en \
  --model-manifest whisper-manifest.json --fixtures fixtures.json \
  --container-digest 'IMAGE@sha256:ACTUAL_DIGEST' --output audio-gpu.json --preflight

timeout 600s python3 idlegpu_audio.py --model-dir /models/reviewed-whisper-tiny-en \
  --model-manifest whisper-manifest.json --fixtures fixtures.json \
  --container-digest 'IMAGE@sha256:ACTUAL_DIGEST' --output audio-gpu.json
```

Generate independent CPU output with `--device cpu` and identical files/decoding settings. Compare reports using `idlegpu_compare_research.py`. The comparator requires matching fixture/model hashes and normalised CPU/GPU transcripts. Review word error rate, names, numbers and hallucinations manually even when both runs agree. No automatic quality pass or badge is awarded. The first runner uses FP32 greedy decoding, no translation/diarisation, no remote code and at most 128 new tokens; reaching the cap stops instead of treating a truncated transcript as success.

Official references: https://huggingface.co/openai/whisper-tiny.en and https://huggingface.co/docs/transformers/model_doc/whisper . The model card warns that plausible output can include words not spoken in the recording.

## 3. Rendering — availability depends on the existing Blender build

First check whether Blender is already installed and supports Cycles GPU rendering on this machine. Do not install it or assume support because an embeddings test passed. CUDA/OptiX support on the available aarch64 machine must be established separately.

```bash
blender --background --factory-startup --python-exit-code 1 \
  --python idlegpu_render.py -- --device CUDA --frames 3 --resolution 256 \
  --samples 32 --output-dir render-gpu --output render-gpu.json --preflight

timeout 600s blender --background --factory-startup --python-exit-code 1 \
  --python idlegpu_render.py -- --device CUDA --frames 3 --resolution 256 \
  --samples 32 --output-dir render-gpu --output render-gpu.json
```

Use `OPTIX` only if that existing backend is supported; never silently fall back to CPU. The script disables CPU devices for a GPU run. Generate separate CPU reference frames using `--device CPU` in the same Blender version, with identical samples/scene/seed and new output names. The comparator checks hashes and settings before comparing PNG pixels. The fixed-scene research tolerance is maximum normalised RGB error ≤0.2 and worst per-image mean error ≤0.02, followed by visual review. These are provisional research thresholds, not a production quality guarantee. The runner does not open customer .blend files or execute their scripts.

Official GPU support reference: https://docs.blender.org/manual/en/latest/render/cycles/gpu_rendering.html . Report Blender version/backend availability and stop if unsupported.

## Evidence to return and remaining gates

Return full JSON reports, separate CPU comparison reports, image/render output directories, fixture and model provenance, and exact commands with UTC timestamps. Do not send tokens, passwords, private recordings or unrelated host files. Include failures and missing dependencies; do not replace them with recreated success evidence.

Before enabling any of these in the marketplace: real GPU runs; separately generated trusted references; repeated runs; larger bounded batches; measured transfer/validation costs; interruption, cancellation and stale-result tests; reviewed input storage and retention; workload-specific machine verification; and agreed customer acceptance rules. Existing embeddings badges and eligibility remain unchanged.