GPU-Clean Conversion: Verify Every Node and Number

Where this fits

You've just converted a PyTorch model to LiteRT. You deploy it to a phone and get a silent CPU fallback—or worse, the GPU runs it but the numbers drift from your training output. Manually inspecting the delegate report and rewriting ops eats a full afternoon. This skill automates that loop: it converts, checks every node runs on GPU, and verifies on-device output against the source model.

Why agents benefit

• Runs the full verification loop automatically—convert, check GPU residency via the CompiledModel API, and numerically validate against CPU/PyTorch on the actual device.
• Detects the silent failure mode where the delegate claims full GPU residency but returns wrong numbers—the exact case that manual checks miss.
• Generates a model recipe (patches and conversion flags) that can be reused and versioned, so future conversions don't repeat the same debugging.
• Iterates on rewrites—suggests and applies op decompositions or attribute fixes until all three conditions (converts, runs on GPU, output matches) hold.
• Shortens feedback loops by catching GPU incompatibilities early, before device integration, using a lightweight compatibility check.

Practical scenarios

Model falls back to CPU on a new device

Your agent converts a Hugging Face BERT variant. The first device emulator shows CPU fallback. The skill applies targeted rewrites (changing unsupported ops or reshaping tensors) and re-verifies until the delegate reports full GPU residency.

GPU runs but output is wrong

A quantized MobileNet passes the GPU check but produces misclassified results. The skill compares outputs tensor-by-tensor, isolates the problematic layer, and adjusts the conversion (e.g., forcing fp32 accumulation) to match PyTorch.

Converting a previously unsupported model

You feed in a novel multi-modal model. The skill starts with a clean conversion, discovers which ops fail, and generates a recipe with minimal patches—documenting what was needed for future agents to reuse.

Add it to your agent workflow

Install with:

npx skills add google-ai-edge/litert-samples --skill gpu-clean-conversion

Then have your agent invoke the toolkit (as shown in the README) to get a report before sending models to device:

from litert_gpu_toolkit import check_gpu_compatibility, print_report
print_report(check_gpu_compatibility("model.tflite"))

The skill handles the rest: rewrites, verification, and recipe generation. For more context, check the skill page.

Compare before adopting

Before you bet on this skill, compare against your current conversion pipeline. Look at quality signals—does the skill actually verify numerical correctness, or just GPU residency? Check maintenance freshness: the repo is actively updated by Google's AI Edge team, but confirm the last commit works with your LiteRT version. Consider alternatives: manual scripts, TensorFlow's official converters, or writing your own validation harness. Finally, assess workflow fit: does it integrate with your existing build steps (CI, device farm)? This skill is most valuable if you repeatedly convert models and struggle with silent fallbacks.

Why it is worth tracking

This skill ships from the google-ai-edge organization directly—the same team building LiteRT—so it's aligned with upstream changes. With 408 stars and a clear signature (verified-correct GPU conversion), it signals a real gap: most conversion tools don't check numerical correctness. If your agents handle PyTorch-to-LiteRT conversions more than once a quarter, adopting this skill will save hours and prevent production bugs. Watch for updates that extend coverage to more op sets or add auto-patching heuristics—those would make it a default part of any mobile AI toolkit.