From 9807b449c66b06b708766753a3d38ea9022537d8 Mon Sep 17 00:00:00 2001 From: Onur Gündüz Date: Sun, 28 Jun 2026 07:17:33 +0200 Subject: Add examples --- README.md | 26 ++++++++++++++ .../a_hyper_detailed_ultra_fluffy_fantasy_cr.png | Bin 0 -> 534653 bytes examples/torch_gpu_benchmark.py | 31 +++++++++++++++++ examples/txt2img.py | 38 +++++++++++++++++++++ 4 files changed, 95 insertions(+) create mode 100644 examples/a_hyper_detailed_ultra_fluffy_fantasy_cr.png create mode 100644 examples/torch_gpu_benchmark.py create mode 100644 examples/txt2img.py diff --git a/README.md b/README.md index 2ed3cb9..b5a669c 100644 --- a/README.md +++ b/README.md @@ -59,6 +59,10 @@ colabctl cp train.py :/content/train.py # upload # colabctl exec <<< '!tar czf /content/out.tgz -C /content/model .' # colabctl cp :content/out.tgz ./out.tgz +# Manage sessions +colabctl sessions +colabctl stop ID + # Check auth status colabctl auth status @@ -84,3 +88,25 @@ End a line with `\` to continue on the next line: 2. `list` queries the Google Drive API v3 for files with MIME type `application/vnd.google.colaboratory`. 3. `run` / `exec` calls the Colab session API (`POST /api/sessions`) to start a runtime, then connects to the Jupyter kernel over WebSocket using the Jupyter wire protocol (v5) to send `execute_request` messages and stream back output. 4. `cp` uses the Jupyter Contents API (`/api/contents`) over the runtime proxy to download or upload a single file. Paths are relative to the Jupyter server root. Directories are not handled directly; archive them on the runtime (`tar`) and copy the archive. + +## Examples + +Run GPU benchmark: + +```sh +$ cat examples/torch_gpu_benchmark.py | colabctl exec ID --accelerator T4 + +Device: Tesla T4 +Torch : 2.11.0+cu128 +4096x4096 matmul: 32.98 ms/iter, 4.2 TFLOP/s (fp32) +``` + +Generate an image from a text prompt using SD-Turbo: + +```sh +cat examples/txt2img.py | colabctl exec ID --accelerator T4 -o examples +``` + +![fluffy-creature](./examples/a_hyper_detailed_ultra_fluffy_fantasy_cr.png) + +SD-Turbo is about 2.5 GB and loads only on the first call; because the kernel persists between `exec` calls, later prompts reuse the loaded pipeline and finish in a second or two. diff --git a/examples/a_hyper_detailed_ultra_fluffy_fantasy_cr.png b/examples/a_hyper_detailed_ultra_fluffy_fantasy_cr.png new file mode 100644 index 0000000..b49a40f Binary files /dev/null and b/examples/a_hyper_detailed_ultra_fluffy_fantasy_cr.png differ diff --git a/examples/torch_gpu_benchmark.py b/examples/torch_gpu_benchmark.py new file mode 100644 index 0000000..777ea3b --- /dev/null +++ b/examples/torch_gpu_benchmark.py @@ -0,0 +1,31 @@ +import torch + +assert torch.cuda.is_available(), "no CUDA device" +dev = torch.device("cuda") +print("Device:", torch.cuda.get_device_name(0)) +print("Torch :", torch.__version__) + +# Measured matrix-multiply throughput in TFLOP/s. +n = 4096 +a = torch.randn(n, n, device=dev, dtype=torch.float32) +b = torch.randn(n, n, device=dev, dtype=torch.float32) + +# Warm up so the timed loop excludes one-time CUDA setup. +for _ in range(3): + a @ b +torch.cuda.synchronize() + +start = torch.cuda.Event(enable_timing=True) +end = torch.cuda.Event(enable_timing=True) + +iters = 20 +start.record() +for _ in range(iters): + c = a @ b +end.record() +torch.cuda.synchronize() + +ms = start.elapsed_time(end) / iters +flops = 2 * n ** 3 # one multiply and one add per output element +tflops = flops / (ms * 1e-3) / 1e12 +print(f"{n}x{n} matmul: {ms:.2f} ms/iter, {tflops:.1f} TFLOP/s (fp32)") diff --git a/examples/txt2img.py b/examples/txt2img.py new file mode 100644 index 0000000..0ad5e6d --- /dev/null +++ b/examples/txt2img.py @@ -0,0 +1,38 @@ +"""Generate an image from a text prompt with SD-Turbo. + +Pipe this to `colabctl exec ID --accelerator T4 -o examples`. The +generated PNG streams back through display() and is saved on your machine. +""" + +import re + +import torch +from IPython.display import display + +PROMPT = "A hyper-detailed, ultra-fluffy fantasy creature sitting in a glowing mossy forest hollow. The creature is a mix between a baby red panda and a tiny cloud, with oversized, sparkling cosmic violet eyes, floppy bunny ears, and a soft, pastel-pink and cream fur coat that looks impossibly plush. It is holding a tiny, glowing star-shaped wildflower in its small paws, looking up with an innocent, curious expression. Magical fireflies and soft, warm bokeh lights float in the background. Whimsical, cinematic lighting, 8k resolution, photorealistic fur texture, enchanted forest aesthetic, Pixar-meets-Studio-Ghibli style." + +# Load once, then keep the pipeline in the kernel for subsequent runs. +if "pipe" not in globals(): + import subprocess + import sys + + subprocess.run( + [sys.executable, "-m", "pip", "install", "-q", + "diffusers", "transformers", "accelerate", "safetensors"], + check=True, + ) + from diffusers import AutoPipelineForText2Image + + pipe = AutoPipelineForText2Image.from_pretrained( + "stabilityai/sd-turbo", + torch_dtype=torch.float16, + variant="fp16", + ).to("cuda") + print("Model loaded.") + +# SD-Turbo is a distilled model: one or two steps and no classifier-free guidance. +image = pipe(prompt=PROMPT, num_inference_steps=2, guidance_scale=0.0).images[0] + +slug = re.sub(r"[^a-z0-9]+", "_", PROMPT.lower())[:40].strip("_") or "image" +display(image, metadata={"filename": f"{slug}.png"}) +print("Generated:", PROMPT) -- cgit v1.3.1