tinygrad Skill
✓ VerifiziertEntwickle Deep-Learning-Modelle mit einer minimalen Tensor-Library, die Autograd, JIT-Kompilierung und Multi-Device-Support bietet.
- GitHub Stars
- 28
- Dateien
- 2
- Letzter Commit
- 11. Nov. 2026
- Lizenz
- MIT
- Erlaubte Tools
- —
Was macht der tinygrad Skill?
Entwickle Deep-Learning-Modelle mit einer minimalen Tensor-Library, die Autograd, JIT-Kompilierung und Multi-Device-Support bietet.
Zusammenfassung erzeugt aus der SKILL.md des Skills.
Über den tinygrad skill
Mit diesem minimalen Deep-Learning-Framework können Entwickler neuronale Netze bauen und Tensor-Operationen verwalten. Es bietet eine leichtgewichtige Alternative für alle, die eigene Tensor-Operationen implementieren, Trainings-Loops schreiben oder zur internen Architektur einer Deep-Learning-Library beitragen wollen. Ein Agent sollte diesen SKILL laden, wenn er damit beauftragt wird, Modellarchitekturen zu entwerfen, Kernel-Graphen zu optimieren oder die Multi-Device-Ausführung auf Hardware wie CUDA, METAL oder CPU zu verwalten.
Das Framework arbeitet über eine spezifische Pipeline, die von einer Tensor-API für User zu einer vereinheitlichten IR namens UOp führt, gefolgt von einer Schedule- und Codegen-Phase, bevor sie die Device-Runtime erreicht. Es zeichnet sich durch Lazy Execution aus, bei der Operationen erst realisiert werden, wenn sie explizit angefordert werden. Entwickler können zudem über die PatternMatcher- und UOp-Systeme mit den internen Graph-Transformationen interagieren, um Computation Graphen für eine bessere Performance umzuschreiben.
Was ein agent damit machen kann
- 1Neuronale Netzwerkarchitekturen definierenErstelle eigene Modellklassen mit Standard-Python-Syntax und eingebauten Modulen wie Linear oder Conv2d.
- 2Graph-Transformationen durchführenNutze das PatternMatcher-Tool, um UOp-Graphen für spezifische Operations-Optimierungen umzuschreiben.
- 3Multi-Device-Workloads verwaltenLeite Tensor-Berechnungen direkt an spezifische Hardware-Backends wie CUDA oder AMD weiter.
Geschrieben basierend auf dem SKILL.md des skills. Jeder use case wurde gegen ein zitat daraus geprüft.
So installierst du den tinygrad Skill
Jeder Befehl kopiert den Skill-Ordner in das Skills-Verzeichnis des Clients. Starte den Client neu oder beginne eine neue Session, um ihn zu laden.Den tinygrad Skill in Claude Code installieren
~/.claude/skills/tinygrad/SKILL.md
$ npx degit av/skills/tinygrad ~/.claude/skills/tinygradDen tinygrad Skill in Claude Code (project) installieren
.claude/skills/tinygrad/SKILL.md
$ npx degit av/skills/tinygrad .claude/skills/tinygradDen tinygrad Skill in Codex installieren
~/.agents/skills/tinygrad/SKILL.md
$ npx degit av/skills/tinygrad ~/.agents/skills/tinygradDen tinygrad Skill in Gemini CLI installieren
~/.gemini/skills/tinygrad/SKILL.md
$ npx degit av/skills/tinygrad ~/.gemini/skills/tinygradDen tinygrad Skill in Claude.ai installieren
npx degit av/skills/tinygrad tinygrad && zip -r tinygrad.zip tinygrad # claude.ai → Customize → Skills → + → Create skill → Upload a skill → tinygrad.zip
Automatisierte Checks
Geluften am 14. Nov. 2026Vollständiger Bericht →Hat unsere automatischen Prüfungen bestanden. Das ist kein Sicherheitsaudit: Lesen Sie die Skripte, bevor ein Agent sie ausführt. Wie die Checks funktionieren
- Source Repository verknüpft und erreichbarav/skills/tinygrad is public and reachablegithub.com/av/skills/tree/HEAD/tinygrad ↗Bestanden
- Open Source Lizenz (OSI)MITspdx.org/licenses/MIT.html ↗Bestanden
- Commit oder Release im letzten JahrLast commit 2026-11-11github.com/av/skills/commits ↗Bestanden
- Keine Download-und-Ausführen-Muster oder Zugangsdatendiebstahl in SkriptenNo scripts in the skill folderBestanden
- Keine versteckten Anweisungen in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/av/skills/blob/HEAD/tinygrad/SKILL.md ↗Bestanden
- Vorab erlaubte Tools sind eingeschränktNo pre-approved tools; the agent asks before using onegithub.com/av/skills/blob/HEAD/tinygrad/SKILL.md ↗Bestanden
- SKILL.md folgt dem Agent-Skills-FormatValid name and description; says when to use it; 170 linesgithub.com/av/skills/blob/HEAD/tinygrad/SKILL.md ↗Bestanden
SKILL.md
Auf GitHub ansehentinygrad
A minimal deep learning framework focused on beauty and minimalism. Every line must earn its keep.
Quick Reference
from tinygrad import Tensor, TinyJit, nn, dtypes, Device, GlobalCounters
# Tensor creation
x = Tensor([1, 2, 3])
x = Tensor.rand(2, 3)
x = Tensor.kaiming_uniform(128, 784)
# Operations are lazy until realized
y = (x + 1).relu().sum()
y.realize() # or y.numpy()
# Training context
with Tensor.train():
loss = model(x).sparse_categorical_crossentropy(labels).backward()
optim.step()
Architecture Pipeline
- Tensor (
tinygrad/tensor.py) - User API, creates UOp graph - UOp (
tinygrad/uop/ops.py) - Unified IR for all operations - Schedule (
tinygrad/engine/schedule.py) - Converts tensor UOps to kernel UOps - Codegen (
tinygrad/codegen/) - Converts kernel UOps to device code - Runtime (
tinygrad/runtime/) - Device-specific execution
Training Loop Pattern
from tinygrad import Tensor, TinyJit, nn
from tinygrad.nn.datasets import mnist
X_train, Y_train, X_test, Y_test = mnist()
model = Model()
optim = nn.optim.Adam(nn.state.get_parameters(model))
@TinyJit
@Tensor.train()
def train_step():
optim.zero_grad()
samples = Tensor.randint(512, high=X_train.shape[0])
loss = model(X_train[samples]).sparse_categorical_crossentropy(Y_train[samples]).backward()
return loss.realize(*optim.schedule_step())
for i in range(100):
loss = train_step()
Model Definition
Models are plain Python classes with __call__. No base class required.
class Model:
def __init__(self):
self.l1 = nn.Linear(784, 128)
self.l2 = nn.Linear(128, 10)
def __call__(self, x):
return self.l1(x).relu().sequential([self.l2])
Available nn modules: Linear, Conv2d, BatchNorm, LayerNorm, RMSNorm, Embedding, GroupNorm, LSTMCell
Optimizers: SGD, Adam, AdamW, LARS, LAMB, Muon
State Dict / Weights
from tinygrad.nn.state import safe_save, safe_load, get_state_dict, load_state_dict, get_parameters
# Save/load safetensors
safe_save(get_state_dict(model), "model.safetensors")
load_state_dict(model, safe_load("model.safetensors"))
# Get all trainable params
params = get_parameters(model)
JIT Compilation
TinyJit captures and replays kernel graphs. Input shapes must be fixed.
@TinyJit
def forward(x):
return model(x).realize()
# First call captures, subsequent calls replay
out = forward(batch)
Device Management
from tinygrad import Device
print(Device.DEFAULT) # Auto-detected: METAL, CUDA, AMD, CPU, etc.
# Force device
x = Tensor.rand(10, device="CPU")
x = x.to("CUDA")
Environment Variables
| Variable | Values | Description |
|---|---|---|
DEBUG |
1-7 | Increasing verbosity (4=code, 7=asm) |
VIZ |
1 | Graph visualization |
BEAM |
# | Kernel beam search width |
NOOPT |
1 | Disable optimizations |
SPEC |
1-2 | UOp spec verification |
Debugging
# Visualize computation graph
VIZ=1 python -c "from tinygrad import Tensor; Tensor.ones(10).sum().realize()"
# Show generated code
DEBUG=4 python script.py
# Run tests
python -m pytest test/test_tensor.py -xvs
UOp and PatternMatcher (Internals)
UOps are immutable, cached graph nodes. Use PatternMatcher for transformations:
from tinygrad.uop.ops import UOp, Ops
from tinygrad.uop.upat import UPat, PatternMatcher, graph_rewrite
pm = PatternMatcher([
(UPat(Ops.ADD, src=(UPat.cvar("x"), UPat.cvar("x"))), lambda x: x * 2),
])
result = graph_rewrite(uop, pm)
Key UOp properties: op, dtype, src, arg, tag
Define PatternMatchers at module level - they're slow to construct.
Style Guide
- 2-space indentation, 150 char line limit
- Prefer readability over cleverness
- Never mix functionality changes with whitespace changes
- All functionality changes must be tested
- Run
pre-commit run --all-filesbefore commits
Testing
python -m pytest test/test_tensor.py -xvs
python -m pytest test/unit/test_schedule_cache.py -x --timeout=60
SPEC=2 python -m pytest test/test_something.py # With spec verification
Dateien in diesem Skill
2tinygrad Skill-Fragen
Wie installiere ich den tinygrad Skill in Claude Code?
Führe npx degit av/skills/tinygrad ~/.claude/skills/tinygrad aus. Claude Code lädt Skills aus ~/.claude/skills (alle Projekte) oder .claude/skills (ein Projekt) und nutzt einen Skill, wenn seine Beschreibung zur Aufgabe passt.
Welche Clients können den tinygrad Skill nutzen?
Jeder Client, der das Agent Skills-Format liest: Claude Code, Codex, Gemini CLI und claude.ai (als ZIP hochladen). Skripte im Skill laufen nur dort, wo der Client Codeausführung erlaubt.
Wie definiere ich ein Modell in tinygrad?
Modelle sind einfache Python-Klassen, die die __call__-Methode implementieren; sie benötigen keine spezifische Basisklasse.
Wie kann ich die Ausführung mittels JIT beschleunigen?
Du kannst den TinyJit-Decorator verwenden, um Kernel-Graphen zu erfassen und wieder abzuspielen, wobei die Input-Shapes dabei gleich bleiben müssen.
Wie verwalte ich verschiedene Hardware-Devices?
Tinygrad erkennt Devices wie METAL, CUDA, AMD oder CPU automatisch. Du kannst jedoch manuell ein Device erzwingen, indem du das device-Argument bei der Tensor-Erstellung oder die .to()-Methode nutzt.
Wie kann ich den Computation Graph visualisieren?
Du kannst den Graph visualisieren, indem du die Umgebungsvariable VIZ vor dem Ausführen deines Skripts auf 1 setzt.