Add image classifier training tutorial and template

- train-image-classifier.py: Fine-tune ViT for image classification
- Works as interactive tutorial AND batch script
- Includes HF Jobs documentation with GPU flavor table
- Uses beans dataset by default (fast to train)

- _template.py: Minimal template for community adoption

- README.md: Added new scripts, recipes, best practices

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

README.md

@@ -23,17 +23,22 @@ This makes them perfect for tutorials and educational content where you want use
 | Script | Description |
 |--------|-------------|
 | `getting-started.py` | Introduction to UV scripts and HF datasets |
+| `train-image-classifier.py` | Fine-tune a Vision Transformer on image classification |
+| `_template.py` | Minimal template for creating your own notebooks |
 
 ## Usage
 
 ### Run as a script
 
 ```bash
-# Run directly from Hugging Face
-uv run https://huggingface.co/datasets/uv-scripts/marimo/raw/main/getting-started.py --help
-
-# Load a dataset and show info
+# Get dataset info
 uv run https://huggingface.co/datasets/uv-scripts/marimo/raw/main/getting-started.py --dataset squad
+
+# Train an image classifier
+uv run https://huggingface.co/datasets/uv-scripts/marimo/raw/main/train-image-classifier.py \
+    --dataset beans \
+    --epochs 3 \
+    --output-repo your-username/beans-vit
 ```
 
 ### Run interactively
@@ -45,15 +50,16 @@ cd marimo
 
 # Open in marimo editor (--sandbox auto-installs dependencies)
 uvx marimo edit --sandbox getting-started.py
+uvx marimo edit --sandbox train-image-classifier.py
 ```
 
-### Run on HF Jobs
+### Run on HF Jobs (GPU)
 
 ```bash
-hf jobs uv run --flavor cpu-basic \
-    -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \
-    https://huggingface.co/datasets/uv-scripts/marimo/raw/main/getting-started.py \
-    --dataset squad
+# Train image classifier with GPU
+hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/marimo/raw/main/train-image-classifier.py \
+    -- --dataset beans --output-repo your-username/beans-vit --epochs 5 --push-to-hub
 ```
 
 ## Why Marimo?
@@ -63,6 +69,83 @@ hf jobs uv run --flavor cpu-basic \
 - **Self-contained**: Inline dependencies via PEP 723 metadata
 - **Dual-mode**: Same file works as notebook and script
 
+## Create Your Own Marimo UV Script
+
+Use `_template.py` as a starting point:
+
+```bash
+# Clone and copy the template
+git clone https://huggingface.co/datasets/uv-scripts/marimo
+cp marimo/_template.py my-notebook.py
+
+# Edit interactively
+uvx marimo edit --sandbox my-notebook.py
+
+# Test as script
+uv run my-notebook.py --help
+```
+
+## Recipes
+
+### Add explanation (notebook only)
+
+```python
+mo.md("""
+## This is a heading
+
+This text explains what's happening. Only shows in interactive mode.
+""")
+```
+
+### Show output in both modes
+
+```python
+# print() shows in terminal (script) AND cell output (notebook)
+print(f"Loaded {len(data)} items")
+```
+
+### Interactive control with CLI fallback
+
+```python
+# Parse CLI args first
+parser = argparse.ArgumentParser()
+parser.add_argument("--count", type=int, default=10)
+args, _ = parser.parse_known_args()
+
+# Create UI control with CLI default
+slider = mo.ui.slider(1, 100, value=args.count, label="Count")
+
+# Use it - works in both modes
+count = slider.value  # UI value in notebook, CLI value in script
+```
+
+### Show visuals (notebook only)
+
+```python
+# mo.md() with images, mo.ui.table(), etc. only display in notebook
+mo.ui.table(dataframe)
+
+# For script mode, also print summary
+print(f"DataFrame has {len(df)} rows")
+```
+
+### Conditional notebook-only code
+
+```python
+# Check if running interactively
+if hasattr(mo, 'running_in_notebook') and mo.running_in_notebook():
+    # Heavy visualization only in notebook
+    show_complex_plot(data)
+```
+
+## Best Practices
+
+1. **Always include `print()` for important output** - It works in both modes
+2. **Use argparse for all configuration** - CLI args work everywhere
+3. **Add `mo.md()` explanations between steps** - Makes tutorials readable
+4. **Test in script mode first** - Ensure it works without interactivity
+5. **Keep dependencies minimal** - Add `marimo` plus only what you need
+
 ## Learn More
 
 - [Marimo documentation](https://docs.marimo.io/)

_template.py

@@ -0,0 +1,138 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "marimo",
+#     # Add your dependencies here, e.g.:
+#     # "datasets",
+#     # "transformers",
+#     # "torch",
+# ]
+# ///
+"""
+Your Notebook Title
+
+Brief description of what this notebook does.
+
+Two ways to run:
+- Tutorial: uvx marimo edit --sandbox your-notebook.py
+- Script: uv run your-notebook.py --your-args
+"""
+
+import marimo
+
+app = marimo.App(width="medium")
+
+
+# =============================================================================
+# Cell 1: Import marimo
+# This cell is required - it imports marimo for use in other cells
+# =============================================================================
+@app.cell
+def _():
+    import marimo as mo
+
+    return (mo,)
+
+
+# =============================================================================
+# Cell 2: Introduction (notebook mode only)
+# Use mo.md() for explanations that only show in interactive mode
+# =============================================================================
+@app.cell
+def _(mo):
+    mo.md(
+        """
+        # Your Notebook Title
+
+        Explain what this notebook does and why it's useful.
+
+        **Two ways to run:**
+        - **Tutorial**: `uvx marimo edit --sandbox your-notebook.py`
+        - **Script**: `uv run your-notebook.py --your-args`
+        """
+    )
+    return
+
+
+# =============================================================================
+# Cell 3: Configuration
+# Pattern: argparse for CLI + mo.ui for interactive controls
+# Interactive controls fall back to CLI defaults
+# =============================================================================
+@app.cell
+def _(mo):
+    import argparse
+
+    # Parse CLI args (works in both modes)
+    parser = argparse.ArgumentParser(description="Your script description")
+    parser.add_argument("--input", default="default_value", help="Input parameter")
+    parser.add_argument("--count", type=int, default=10, help="Number of items")
+    args, _ = parser.parse_known_args()
+
+    # Interactive controls (shown in notebook mode)
+    # These use CLI args as defaults, so script mode still works
+    input_control = mo.ui.text(value=args.input, label="Input")
+    count_control = mo.ui.slider(1, 100, value=args.count, label="Count")
+
+    mo.hstack([input_control, count_control])
+    return argparse, args, count_control, input_control, parser
+
+
+# =============================================================================
+# Cell 4: Resolve values
+# Use interactive values if set, otherwise fall back to CLI args
+# print() shows output in BOTH modes (script stdout + notebook console)
+# =============================================================================
+@app.cell
+def _(args, count_control, input_control):
+    # Resolve values (interactive takes precedence)
+    input_value = input_control.value or args.input
+    count_value = count_control.value or args.count
+
+    # print() works in both modes - shows in terminal for scripts,
+    # shows in cell output for notebooks
+    print(f"Input: {input_value}")
+    print(f"Count: {count_value}")
+    return count_value, input_value
+
+
+# =============================================================================
+# Cell 5: Your main logic
+# This is where you do the actual work
+# =============================================================================
+@app.cell
+def _(count_value, input_value, mo):
+    mo.md(
+        """
+        ## Processing
+
+        Explain what this step does...
+        """
+    )
+
+    # Your processing code here
+    results = [f"{input_value}_{i}" for i in range(count_value)]
+    print(f"Generated {len(results)} results")
+    return (results,)
+
+
+# =============================================================================
+# Cell 6: Display results
+# Use mo.md() or mo.ui.table() for rich display in notebook mode
+# Use print() for output that shows in both modes
+# =============================================================================
+@app.cell
+def _(mo, results):
+    # Show in notebook mode (rich display)
+    mo.md("### Results\n\n- " + "\n- ".join(results[:5]) + "\n- ...")
+
+    # Also print for script mode
+    print(f"First 5 results: {results[:5]}")
+    return
+
+
+# =============================================================================
+# Entry point - required for script mode
+# =============================================================================
+if __name__ == "__main__":
+    app.run()

train-image-classifier.py

@@ -0,0 +1,529 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "marimo",
+#     "datasets",
+#     "transformers",
+#     "torch",
+#     "torchvision",
+#     "huggingface-hub",
+#     "evaluate",
+#     "accelerate",
+#     "scikit-learn",
+# ]
+# ///
+"""
+Train an Image Classifier
+
+This marimo notebook fine-tunes a Vision Transformer (ViT) for image classification.
+
+Two ways to run:
+- Tutorial: uvx marimo edit --sandbox train-image-classifier.py
+- Script: uv run train-image-classifier.py --dataset beans --output-repo user/my-model
+
+On HF Jobs (GPU):
+hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/marimo/raw/main/train-image-classifier.py \
+    -- --dataset beans --output-repo user/beans-vit --epochs 5
+"""
+
+import marimo
+
+__generated_with = "0.19.6"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    # Train an Image Classifier
+
+    This notebook fine-tunes a Vision Transformer (ViT) for image classification.
+
+    **Two ways to run:**
+    - **Tutorial**: `uvx marimo edit --sandbox train-image-classifier.py`
+    - **Script**: `uv run train-image-classifier.py --dataset beans --output-repo user/my-model`
+
+    The same code powers both experiences!
+    """)
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Running on HF Jobs (GPU)
+
+    This notebook can run on [Hugging Face Jobs](https://huggingface.co/docs/hub/jobs) for GPU training.
+    No local GPU needed - just run:
+
+    ```bash
+    hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/marimo/raw/main/train-image-classifier.py \\
+        -- --dataset beans --output-repo your-username/beans-vit --epochs 5 --push-to-hub
+    ```
+
+    **GPU Flavors:**
+    | Flavor | GPU | VRAM | Best for |
+    |--------|-----|------|----------|
+    | `l4x1` | L4 | 24GB | Most fine-tuning tasks |
+    | `a10gx1` | A10G | 24GB | Slightly faster than L4 |
+    | `a100x1` | A100 | 40GB | Large models, big batches |
+
+    **Key flags:**
+    - `--secrets HF_TOKEN` - Passes your HF token for pushing models
+    - `--` - Separates `hf jobs` args from script args
+    - `--push-to-hub` - Actually pushes the model (otherwise just saves locally)
+
+    **Tip:** Start with `beans` dataset and 1-3 epochs to test, then scale up!
+    """)
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Step 1: Configuration
+
+    Set up training parameters. In interactive mode, use the controls below.
+    In script mode, pass command-line arguments.
+    """)
+    return
+
+
+@app.cell
+def _(mo):
+    import argparse
+
+    # Parse CLI args (works in both modes)
+    parser = argparse.ArgumentParser(description="Fine-tune ViT for image classification")
+    parser.add_argument(
+        "--dataset",
+        default="beans",
+        help="HF dataset name (must be image classification dataset)",
+    )
+    parser.add_argument(
+        "--model",
+        default="google/vit-base-patch16-224-in21k",
+        help="Pretrained model to fine-tune",
+    )
+    parser.add_argument(
+        "--output-repo",
+        default=None,
+        help="Where to push trained model (e.g., user/my-model)",
+    )
+    parser.add_argument("--epochs", type=int, default=3, help="Number of training epochs")
+    parser.add_argument("--batch-size", type=int, default=16, help="Batch size")
+    parser.add_argument("--lr", type=float, default=5e-5, help="Learning rate")
+    parser.add_argument(
+        "--push-to-hub",
+        action="store_true",
+        default=False,
+        help="Push model to Hub after training",
+    )
+    args, _ = parser.parse_known_args()
+
+    # Interactive controls (shown in notebook mode)
+    dataset_input = mo.ui.text(value=args.dataset, label="Dataset")
+    model_input = mo.ui.text(value=args.model, label="Model")
+    output_input = mo.ui.text(value=args.output_repo or "", label="Output Repo")
+    epochs_input = mo.ui.slider(1, 20, value=args.epochs, label="Epochs")
+    batch_size_input = mo.ui.dropdown(
+        options=["8", "16", "32", "64"], value=str(args.batch_size), label="Batch Size"
+    )
+    lr_input = mo.ui.dropdown(
+        options=["1e-5", "2e-5", "5e-5", "1e-4"],
+        value=f"{args.lr:.0e}".replace("e-0", "e-"),
+        label="Learning Rate",
+    )
+
+    mo.vstack(
+        [
+            mo.hstack([dataset_input, model_input]),
+            mo.hstack([output_input]),
+            mo.hstack([epochs_input, batch_size_input, lr_input]),
+        ]
+    )
+    return (
+        args,
+        batch_size_input,
+        dataset_input,
+        epochs_input,
+        lr_input,
+        model_input,
+        output_input,
+    )
+
+
+@app.cell
+def _(
+    args,
+    batch_size_input,
+    dataset_input,
+    epochs_input,
+    lr_input,
+    model_input,
+    output_input,
+):
+    # Resolve values (interactive takes precedence)
+    dataset_name = dataset_input.value or args.dataset
+    model_name = model_input.value or args.model
+    output_repo = output_input.value or args.output_repo
+    num_epochs = epochs_input.value or args.epochs
+    batch_size = int(batch_size_input.value) if batch_size_input.value else args.batch_size
+    learning_rate = float(lr_input.value) if lr_input.value else args.lr
+
+    print("Configuration:")
+    print(f"  Dataset: {dataset_name}")
+    print(f"  Model: {model_name}")
+    print(f"  Output: {output_repo or '(not pushing to Hub)'}")
+    print(f"  Epochs: {num_epochs}, Batch Size: {batch_size}, LR: {learning_rate}")
+    return (
+        batch_size,
+        dataset_name,
+        learning_rate,
+        model_name,
+        num_epochs,
+        output_repo,
+    )
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Step 2: Load Dataset
+
+    We'll load an image classification dataset from the Hub.
+    The `beans` dataset is small (~1000 images) and trains quickly - perfect for learning!
+    """)
+    return
+
+
+@app.cell
+def _(dataset_name, mo):
+    from datasets import load_dataset
+
+    print(f"Loading dataset: {dataset_name}...")
+    dataset = load_dataset(dataset_name, trust_remote_code=True)
+    print(f"Train: {len(dataset['train']):,} samples")
+    print(f"Test: {len(dataset['test']):,} samples")
+
+    # Get label info
+    label_feature = dataset["train"].features["label"]
+    labels = label_feature.names if hasattr(label_feature, "names") else None
+    num_labels = label_feature.num_classes if hasattr(label_feature, "num_classes") else len(set(dataset["train"]["label"]))
+
+    print(f"Labels ({num_labels}): {labels}")
+
+    mo.md(f"**Loaded {len(dataset['train']):,} training samples with {num_labels} classes**")
+    return dataset, labels, num_labels
+
+
+@app.cell
+def _(dataset, labels, mo):
+    # Show sample images (notebook mode only)
+    import base64
+    from io import BytesIO
+
+    def image_to_base64(img, max_size=150):
+        """Convert PIL image to base64 for HTML display."""
+        img_copy = img.copy()
+        img_copy.thumbnail((max_size, max_size))
+        buffered = BytesIO()
+        img_copy.save(buffered, format="PNG")
+        return base64.b64encode(buffered.getvalue()).decode()
+
+    # Get 6 sample images with different labels
+    samples = dataset["train"].shuffle(seed=42).select(range(6))
+
+    images_html = []
+    for sample in samples:
+        img_b64 = image_to_base64(sample["image"])
+        label_name = labels[sample["label"]] if labels else sample["label"]
+        images_html.append(
+            f"""
+            <div style="text-align: center; margin: 5px;">
+                <img src="data:image/png;base64,{img_b64}" style="border-radius: 8px;"/>
+                <br/><small>{label_name}</small>
+            </div>
+            """
+        )
+
+    mo.md(f"""
+    ### Sample Images
+    <div style="display: flex; flex-wrap: wrap; gap: 10px;">
+    {"".join(images_html)}
+    </div>
+    """)
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Step 3: Prepare Model and Processor
+
+    We load a pretrained Vision Transformer and its image processor.
+    The processor handles resizing and normalization to match the model's training.
+    """)
+    return
+
+
+@app.cell
+def _(labels, model_name, num_labels):
+    from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+    print(f"Loading model: {model_name}...")
+
+    # Load image processor
+    image_processor = AutoImageProcessor.from_pretrained(model_name)
+    print(f"Image size: {image_processor.size}")
+
+    # Load model with correct number of labels
+    label2id = {label: i for i, label in enumerate(labels)} if labels else None
+    id2label = {i: label for i, label in enumerate(labels)} if labels else None
+
+    model = AutoModelForImageClassification.from_pretrained(
+        model_name,
+        num_labels=num_labels,
+        label2id=label2id,
+        id2label=id2label,
+        ignore_mismatched_sizes=True,  # Classification head will be different
+    )
+    print(f"Model loaded with {num_labels} output classes")
+    return id2label, image_processor, model
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Step 4: Preprocess Data
+
+    Apply the image processor to convert images into tensors suitable for the model.
+    """)
+    return
+
+
+@app.cell
+def _(dataset, image_processor):
+    def preprocess(examples):
+        """Apply image processor to batch of images."""
+        images = [img.convert("RGB") for img in examples["image"]]
+        inputs = image_processor(images, return_tensors="pt")
+        inputs["label"] = examples["label"]
+        return inputs
+
+    print("Preprocessing dataset...")
+    processed_dataset = dataset.with_transform(preprocess)
+    print("Preprocessing complete (transforms applied lazily)")
+    return (processed_dataset,)
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Step 5: Training
+
+    We use the Hugging Face Trainer for a clean training loop with built-in logging.
+    """)
+    return
+
+
+@app.cell
+def _(
+    batch_size,
+    learning_rate,
+    model,
+    num_epochs,
+    output_repo,
+    processed_dataset,
+):
+    import evaluate
+    import numpy as np
+    from transformers import Trainer, TrainingArguments
+
+    # Load accuracy metric
+    accuracy_metric = evaluate.load("accuracy")
+
+    def compute_metrics(eval_pred):
+        predictions, labels = eval_pred
+        predictions = np.argmax(predictions, axis=1)
+        return accuracy_metric.compute(predictions=predictions, references=labels)
+
+    # Training arguments
+    training_args = TrainingArguments(
+        output_dir="./image-classifier-output",
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        learning_rate=learning_rate,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        logging_steps=10,
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        push_to_hub=bool(output_repo),
+        hub_model_id=output_repo if output_repo else None,
+        remove_unused_columns=False,  # Keep image column for transforms
+        report_to="none",  # Disable wandb/tensorboard for simplicity
+    )
+
+    # Create trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=processed_dataset["train"],
+        eval_dataset=processed_dataset["test"],
+        compute_metrics=compute_metrics,
+    )
+
+    print(f"Starting training for {num_epochs} epochs...")
+    return (trainer,)
+
+
+@app.cell
+def _(trainer):
+    # Run training
+    train_result = trainer.train()
+    print("\nTraining complete!")
+    print(f"  Total steps: {train_result.global_step}")
+    print(f"  Training loss: {train_result.training_loss:.4f}")
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Step 6: Evaluation
+
+    Let's see how well our model performs on the test set.
+    """)
+    return
+
+
+@app.cell
+def _(trainer):
+    # Evaluate on test set
+    eval_results = trainer.evaluate()
+    print("\nEvaluation Results:")
+    print(f"  Accuracy: {eval_results['eval_accuracy']:.2%}")
+    print(f"  Loss: {eval_results['eval_loss']:.4f}")
+    return
+
+
+@app.cell
+def _(dataset, id2label, image_processor, mo, model):
+    import torch
+
+    # Show some predictions (notebook mode)
+    model.eval()
+    test_samples = dataset["test"].shuffle(seed=42).select(range(4))
+
+    prediction_html = []
+    for sample in test_samples:
+        img = sample["image"].convert("RGB")
+        inputs = image_processor(img, return_tensors="pt")
+
+        with torch.no_grad():
+            outputs = model(**inputs)
+            pred_idx = outputs.logits.argmax(-1).item()
+
+        true_label = id2label[sample["label"]] if id2label else sample["label"]
+        pred_label = id2label[pred_idx] if id2label else pred_idx
+        correct = "correct" if pred_idx == sample["label"] else "wrong"
+
+        # Convert image for display
+        from io import BytesIO
+        import base64
+
+        img_copy = img.copy()
+        img_copy.thumbnail((120, 120))
+        buffered = BytesIO()
+        img_copy.save(buffered, format="PNG")
+        img_b64 = base64.b64encode(buffered.getvalue()).decode()
+
+        border_color = "#4ade80" if correct == "correct" else "#f87171"
+        prediction_html.append(
+            f"""
+            <div style="text-align: center; margin: 5px; padding: 10px; border: 2px solid {border_color}; border-radius: 8px;">
+                <img src="data:image/png;base64,{img_b64}" style="border-radius: 4px;"/>
+                <br/><small>True: <b>{true_label}</b></small>
+                <br/><small>Pred: <b>{pred_label}</b></small>
+            </div>
+            """
+        )
+
+    mo.md(f"""
+    ### Sample Predictions
+    <div style="display: flex; flex-wrap: wrap; gap: 10px;">
+    {"".join(prediction_html)}
+    </div>
+    <small>Green border = correct, Red border = wrong</small>
+    """)
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Step 7: Push to Hub
+
+    If you specified `--output-repo`, the model will be pushed to the Hugging Face Hub.
+    """)
+    return
+
+
+@app.cell
+def _(args, output_repo, trainer):
+    if output_repo and args.push_to_hub:
+        print(f"Pushing model to: https://huggingface.co/{output_repo}")
+        trainer.push_to_hub()
+        print("Model pushed successfully!")
+    elif output_repo:
+        print("Model saved locally. To push to Hub, add --push-to-hub flag.")
+        print("  Or run: trainer.push_to_hub()")
+    else:
+        print("No output repo specified. Model saved locally to ./image-classifier-output")
+        print("To push to Hub, run with: --output-repo your-username/model-name --push-to-hub")
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Next Steps
+
+    ### Try different datasets
+    - `food101` - 101 food categories (75k train images)
+    - `cifar10` - 10 classes of objects (50k train images)
+    - `oxford_flowers102` - 102 flower species
+    - `fashion_mnist` - Clothing items (grayscale)
+
+    ### Try different models
+    - `microsoft/resnet-50` - Classic CNN architecture
+    - `facebook/deit-base-patch16-224` - Data-efficient ViT
+    - `google/vit-large-patch16-224` - Larger ViT (needs more VRAM)
+
+    ### Scale up with HF Jobs
+
+    ```bash
+    # Train on food101 with more epochs
+    hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/marimo/raw/main/train-image-classifier.py \\
+        -- --dataset food101 --epochs 10 --batch-size 32 \\
+        --output-repo your-username/food101-vit --push-to-hub
+    ```
+
+    **More UV scripts**: [huggingface.co/uv-scripts](https://huggingface.co/uv-scripts)
+    """)
+    return
+
+
+if __name__ == "__main__":
+    app.run()