Get up and running with Keys & Caches in under 5 minutes! Find the true bottlenecks, errors, and performance optimizations previously hidden or hard to discover in your ML stack - from PyTorch down to the GPU - with the help of AI.
Prerequisites
Before getting started, ensure you have the following installed:
- Python 3.12+ (Python 3.12+ required)
- PyTorch installed in your environment (for model profiling features)
- Basic familiarity with PyTorch and command line
Installation
Install via pip
Verify Installation
python -c "import kandc; print(f'kandc v{kandc.__version__} installed successfully')"
You should see something like: kandc v0.0.22 installed successfully
Quick Start
Copy and paste this realistic transformer example that shows experiment tracking and PyTorch profiling with detailed performance analysis:
import time
import random
import torch
import torch.nn as nn
import kandc
@kandc.capture_model_class(model_name="SimpleTransformer")
class SimpleTransformer(nn.Module):
def __init__(self, input_dim=32, seq_len=16, d_model=64, nhead=4, num_layers=2, num_classes=10):
super().__init__()
self.input_dim = input_dim
self.seq_len = seq_len
self.d_model = d_model
self.input_proj = nn.Linear(input_dim, d_model)
self.pos_embedding = nn.Parameter(torch.zeros(1, seq_len, d_model))
encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, batch_first=True)
self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
self.head = nn.Sequential(
nn.LayerNorm(d_model),
nn.Linear(d_model, num_classes)
)
def forward(self, x):
x = self.input_proj(x)
x = x + self.pos_embedding
x = self.transformer(x)
x = x.mean(dim=1)
x = self.head(x)
return x
def main():
print("🚀 Simple kandc Example")
run = kandc.init(
project="optimize-transformer",
name="test-run-1",
)
print("✅ Using existing authentication")
model = SimpleTransformer()
data = torch.randn(32, 16, 32)
print("📊 Running model forward pass...")
output = model(data)
loss = output.mean()
@kandc.timed(name="random_wait")
def random_wait():
print("⏳ Starting random wait...")
time.sleep(random.random() * 2)
print("✅ Random wait complete")
for i in range(10):
random_wait()
print("📈 Logging metrics...")
for i in range(10):
time.sleep(0.1)
x_value = i * 0.5
kandc.log({"loss": loss.item(), "accuracy": random.random()}, x=x_value)
try:
backend_run_id = (
getattr(run, "_run_data", {}).get("id") if getattr(run, "_run_data", None) else None
)
except Exception:
backend_run_id = None
if backend_run_id:
print(f"✅ Run ID: {backend_run_id}")
print("✅ API client initialized")
else:
print(f"✅ Local Run ID: {run.id}")
print("⚠️ Backend run not created; operating offline")
kandc.finish()
print("✅ Done! Check your dashboard for results.")
if __name__ == "__main__":
main()
What Happens When You Run This?
Authentication
First time users will see a browser open for sign-in
Project Creation
kandc creates your project on the backend
Run Tracking
Your run is created and tracked in real-time
PyTorch Profiling
The @capture_model_class decorator automatically captures detailed GPU/CPU performance metrics, memory usage, and tensor shapes
Timing Capture
The @timed decorator captures execution time for your custom functions
Metrics Logging
Your metrics are automatically saved and synced
Chrome Trace Analysis
PyTorch profiler traces are exported as Chrome traces viewable in Perfetto UI for detailed performance analysis
Dashboard
Your browser opens to show live results, trace artifacts, and AI-powered performance insights
Data Sync
All data is synced to the cloud for analysis
Authentication
kandc uses browser-based authentication for security and ease of use.
First Time Setup
When you run kandc.init() for the first time:
Browser opens
A browser window opens to the authentication page
Sign in
Sign in with Google or GitHub
API key saved
Your API key is automatically saved to ~/.kandc/settings.json
Future runs
Future runs use the saved credentials
Next Steps
