Add minimal usage snippets (Kotlin + Python)

README.md

@@ -40,6 +40,53 @@ For anchor `i` at grid `(gx,gy)` with `stride ∈ {8,16,32}`:
 `score = obj * max_class`; then per-class NMS. Divide boxes by the letterbox ratio to map back.
 Reference Kotlin + Python decode in the sample below.
 
+## Minimal usage
+
+**Android (Kotlin, CompiledModel GPU)**
+
+```kotlin
+val model = CompiledModel.create(context.assets, "yolox_tiny.tflite",
+    CompiledModel.Options(Accelerator.GPU), null)
+val inputs = model.createInputBuffers()
+val outputs = model.createOutputBuffers()
+inputs[0].writeFloat(nhwc)             // [1,416,416,3] BGR 0-255, letterbox pad 114
+model.run(inputs, outputs)
+val raw = outputs[0].readFloat()       // [1,3549,85] -> decode + NMS on host (see Python)
+```
+
+**Python (desktop verification)**
+
+```python
+import numpy as np
+from PIL import Image
+from ai_edge_litert.interpreter import Interpreter
+
+SIZE = 416
+img = Image.open("photo.jpg").convert("RGB")
+r = min(SIZE / img.width, SIZE / img.height)
+w, h = round(img.width * r), round(img.height * r)
+canvas = np.full((SIZE, SIZE, 3), 114, np.float32)                # letterbox, gray 114
+canvas[:h, :w] = np.asarray(img.resize((w, h)), np.float32)
+x = np.ascontiguousarray(canvas[..., ::-1])[None]                 # RGB -> BGR, 0-255, NHWC
+
+it = Interpreter(model_path="yolox_tiny.tflite"); it.allocate_tensors()
+it.set_tensor(it.get_input_details()[0]["index"], x); it.invoke()
+out = it.get_tensor(it.get_output_details()[0]["index"])[0]       # [3549,85]
+
+grids, strides = [], []                                           # anchors = grid cells, s 8/16/32
+for s in (8, 16, 32):
+    n = SIZE // s
+    gy, gx = np.mgrid[:n, :n]
+    grids.append(np.stack([gx, gy], -1).reshape(-1, 2)); strides.append(np.full((n * n, 1), s))
+g = np.concatenate(grids).astype(np.float32); sv = np.concatenate(strides).astype(np.float32)
+xy = (out[:, :2] + g) * sv; wh = np.exp(out[:, 2:4]) * sv         # boxes in 416-space
+score = out[:, 4:5] * out[:, 5:]                                  # obj x class (already sigmoid)
+cls, conf = score.argmax(1), score.max(1)
+for i in np.where(conf > 0.35)[0]:                                # + per-class NMS in practice
+    x1, y1 = (xy[i] - wh[i] / 2) / r; x2, y2 = (xy[i] + wh[i] / 2) / r
+    print(f"coco class {cls[i]}  {conf[i]:.2f}  [{x1:.0f},{y1:.0f},{x2:.0f},{y2:.0f}]")
+```
+
 ## Performance
 
 COCO val2017 AP **32.8** (FP32 reference). Real-time on Pixel 8a GPU.