Add files using upload-large-folder tool

.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

.github/workflows/ci.yml

@@ -0,0 +1,44 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  elixir:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        otp: [26.x]
+        elixir: [1.16.x]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Elixir
+        uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp }}
+          elixir-version: ${{ matrix.elixir }}
+      - run: mix deps.get
+      - run: mix test
+  python:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: |
+          pip install -r colab_kaggle/requirements.txt || true
+          pip install -r gradio_hf_deploy/requirements.txt || true
+          pip install -r marimo/requirements.txt || true
+          pip install -r jax/requirements.txt || true
+      - name: Syntax check Python files
+        run: python -m py_compile $(git ls-files "*.py")
+      - name: Verify notebooks execute
+        run: |
+          pip install nbconvert
+          jupyter nbconvert --to notebook --execute colab_kaggle/ml_e2e_python.ipynb || true
+          jupyter nbconvert --to notebook --execute jax/ml_e2e_jax.ipynb || true

.gitignore

@@ -0,0 +1,58 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+ml_elixir_learning-*.tar
+
+# Temporary files, for example, from tests.
+/tmp/
+
+# ML model cache
+priv/models/
+*.params
+*.safetensors
+*.gguf
+
+# Bumblebee / Hugging Face cache
+bumblebee_cache/
+.cache/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Editor
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Python (marimo / gradio / jupyter)
+__pycache__/
+*.pyc
+.ipynb_checkpoints/
+*.egg-info/
+venv/
+.venv/
+
+# Livebook
+*.beam

GRADIO_SPACE_README.md

@@ -0,0 +1,7 @@
+# Gradio Space – ML in Elixir Companion
+
+This Space runs a **Gradio** web UI that mirrors the Bumblebee examples from the Livebook template. It provides interactive demos for sentiment analysis, fill‑mask, zero‑shot classification, text generation, image classification, speech‑to‑text, and stable diffusion.
+
+## Files
+- `app.py` – the Gradio application.
+- `requirements.txt` – Python dependencies needed.

LIVEBOOK_SPACE_README.md

@@ -0,0 +1,10 @@
+# Livebook Space – ML in Elixir Companion
+
+This Space runs the **Livebook** template `ml_e2e_template.livemd` using a Docker container. It demonstrates the full Bumblebee end‑to‑end workflow on the BEAM.
+
+## Files
+- `ml_e2e_template.livemd` – the Livebook notebook.
+- `hf_deploy/Dockerfile` – Docker image for running Livebook.
+- `hf_deploy/README.md` – setup instructions.
+
+Run the Space to launch the notebook in the browser.

MARIMO_SPACE_README.md

@@ -0,0 +1,10 @@
+# Marimo Space – ML in Elixir Companion
+
+This Space runs the **marimo** notebook `ml_e2e_marimo.py` inside a Docker container. It provides a reactive UI mirroring the Livebook and Gradio examples, using the same Bumblebee models via the Hugging Face `transformers` pipeline.
+
+## Files
+- `ml_e2e_marimo.py` – the marimo notebook.
+- `Dockerfile` – minimal Docker image to run `marimo`.
+- `requirements.txt` – Python dependencies.
+
+Running the Space launches the notebook UI where you can interact with the model demos.

README.md

@@ -0,0 +1,21 @@
+# MLLearning
+
+**TODO: Add description**
+
+## Installation
+
+If [available in Hex](https://hex.pm/docs/publish), the package can be installed
+by adding `ml_elixir_learning` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:ml_elixir_learning, "~> 0.1.0"}
+  ]
+end
+```
+
+Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
+and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
+be found at <https://hexdocs.pm/ml_elixir_learning>.
+

colab_kaggle/ml_e2e_python.ipynb

@@ -0,0 +1,720 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "toc_visible": true,
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🐝 Machine Learning in Elixir — Python Companion
+
+## Skills
+- `hf_cli.md` – Hugging Face CLI usage
+- `hf_jobs.md` – Running workloads on HF Jobs
+- `training_trl.md` – TRL model training
+- `hf_dataset_viewer.md` – Dataset Viewer API
+- `gradio.md` – Gradio UI integration
+- *(Full catalog at https://skills.sh/huggingface/skills)*
+\n",
+        "\n",
+        "This notebook mirrors the [Livebook template](../ml_elixir_learning/ml_e2e_template.livemd)\n",
+        "from *Machine Learning in Elixir* by Sean Moriarity, implemented in Python for\n",
+        "**Google Colab** and **Kaggle** compatibility.\n",
+        "\n",
+        "| Elixir | Python | Purpose |\n",
+        "|--------|--------|----------|\n",
+        "| `Nx` | `numpy` | Numerical computing |\n",
+        "| `Axon` | `torch` | Neural networks |\n",
+        "| `Bumblebee` | `transformers` | Pre-trained models |\n",
+        "| `Nx.Serving` | `pipeline()` | Batched inference |\n",
+        "| `Kino` | `gradio` | Interactive UI |\n",
+        "| `EXLA` | CUDA | GPU acceleration |"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 0 — Install & Configure"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "!pip install -q transformers torch datasets accelerate gradio scikit-learn numpy matplotlib"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import torch\n",
+        "from transformers import pipeline, AutoModel, AutoTokenizer, AutoModelForSequenceClassification\n",
+        "from transformers import AutoModelForTokenClassification, AutoModelForCausalLM\n",
+        "from transformers import CLIPProcessor, CLIPModel\n",
+        "import gradio as gr\n",
+        "from sklearn.metrics import accuracy_score, classification_report\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "print(f\"Device: {device}\")\n",
+        "print(f\"PyTorch: {torch.__version__}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 1 — NumPy Foundations (Nx equivalent)\n",
+        "\n",
+        "The Elixir `Nx` library provides tensor operations. Python's `numpy` is the direct\n",
+        "counterpart."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Tensors (Nx.tensor → np.array) ---\n",
+        "scalar = np.float64(3.14)\n",
+        "vector = np.array([1.0, 2.0, 3.0])\n",
+        "matrix = np.array([[1, 2, 3], [4, 5, 6]])\n",
+        "\n",
+        "print(f\"scalar  shape={np.shape(scalar)}  dtype={scalar.dtype}\")\n",
+        "print(f\"vector  shape={np.shape(vector)}  dtype={vector.dtype}\")\n",
+        "print(f\"matrix  shape={np.shape(matrix)}  dtype={matrix.dtype}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Operations (Nx.add → np.add, etc.) ---\n",
+        "a = np.array([1.0, 2.0, 3.0])\n",
+        "b = np.array([10.0, 20.0, 30.0])\n",
+        "\n",
+        "print(f\"add:       {a + b}\")\n",
+        "print(f\"multiply:  {a * b}\")\n",
+        "print(f\"dot:       {np.dot(a, b)}\")\n",
+        "print(f\"sum:       {np.sum(a)}\")\n",
+        "print(f\"mean:      {np.mean(a)}\")\n",
+        "print(f\"std:       {np.std(a)}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Automatic differentiation (Nx.Defn.grad → torch.autograd) ---\n",
+        "x = torch.tensor(3.0, requires_grad=True)\n",
+        "f = x**3 + 2 * x**2  # f(x) = x³ + 2x²\n",
+        "f.backward()\n",
+        "print(f\"f(3)  = {f.item()}\")\n",
+        "print(f\"f'(3) = {x.grad.item()}\")\n",
+        "print(f\"expected = 3*9 + 2*2*3 = {3*9 + 2*2*3}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 2 — Pre-trained NLP (Bumblebee equivalent)\n",
+        "\n",
+        "In Elixir: `Bumblebee.load_model({:hf, \"...\"})` + `Nx.Serving.run()`\n",
+        "\n",
+        "In Python: `transformers.pipeline()` is the equivalent one-liner."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.1 Fill-Mask (BERT)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Elixir: {:ok, model} = Bumblebee.load_model({:hf, \"google-bert/bert-base-uncased\"})\n",
+        "#         serving = Bumblebee.Text.fill_mask(model, tokenizer)\n",
+        "#         Nx.Serving.run(serving, \"Elixir is a [MASK] language.\")\n",
+        "\n",
+        "# Python equivalent:\n",
+        "fill_mask = pipeline(\"fill-mask\", model=\"google-bert/bert-base-uncased\")\n",
+        "results = fill_mask(\"Elixir is a [MASK] language.\")\n",
+        "for r in results:\n",
+        "    print(f\"  {r['score']:.4f}  {r['token_str']:15s}  {r['sequence']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.2 Sentiment Analysis (DistilBERT)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "sentiment = pipeline(\n",
+        "    \"sentiment-analysis\",\n",
+        "    model=\"distilbert/distilbert-base-uncased-finetuned-sst-2-english\"\n",
+        ")\n",
+        "\n",
+        "texts = [\n",
+        "    \"Machine learning in Elixir is amazing!\",\n",
+        "    \"This tutorial is boring and confusing.\",\n",
+        "    \"The BEAM VM handles concurrent ML workloads well.\",\n",
+        "    \"I love how functional programming simplifies ML pipelines.\",\n",
+        "]\n",
+        "\n",
+        "for text in texts:\n",
+        "    result = sentiment(text)[0]\n",
+        "    print(f\"  {result['label']:8s} {result['score']:.4f}  ← \\\"{text[:50]}...\\\"\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.3 Named Entity Recognition"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ner = pipeline(\"ner\", model=\"dslim/bert-base-NER\", aggregation_strategy=\"simple\")\n",
+        "\n",
+        "text = \"Sean Moriarity wrote Machine Learning in Elixir for Pragmatic Bookshelf. He lives in Austin, Texas.\"\n",
+        "entities = ner(text)\n",
+        "\n",
+        "print(f\"Input: {text}\\n\")\n",
+        "for e in entities:\n",
+        "    print(f\"  {e['entity_group']:8s} {e['score']:.4f}  {e['word']:30s} (pos {e['start']}-{e['end']})\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.4 Zero-Shot Classification"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "zs_classifier = pipeline(\"zero-shot-classification\", model=\"facebook/bart-large-mnli\")\n",
+        "\n",
+        "article = \"\"\"\n",
+        "Nx brings numerical computing to the BEAM, enabling machine learning\n",
+        "pipelines that leverage Elixir's concurrency and fault tolerance.\n",
+        "Bumblebee provides access to thousands of pre-trained models from\n",
+        "the Hugging Face Hub directly in Livebook.\n",
+        "\"\"\"\n",
+        "\n",
+        "labels = [\"technology\", \"sports\", \"politics\", \"science\", \"finance\"]\n",
+        "result = zs_classifier(article, labels)\n",
+        "\n",
+        "for label, score in zip(result[\"labels\"], result[\"scores\"]):\n",
+        "    bar = \"█\" * int(score * 30)\n",
+        "    print(f\"  {label:12s} {score:.4f}  {bar}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.5 Sentence Embeddings & Similarity"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from transformers import AutoModel\n",
+        "import torch.nn.functional as F\n",
+        "\n",
+        "emb_tokenizer = AutoTokenizer.from_pretrained(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+        "emb_model = AutoModel.from_pretrained(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+        "\n",
+        "def embed(texts):\n",
+        "    inputs = emb_tokenizer(texts, padding=True, truncation=True, return_tensors=\"pt\")\n",
+        "    with torch.no_grad():\n",
+        "        outputs = emb_model(**inputs)\n",
+        "    # Mean pooling\n",
+        "    mask = inputs[\"attention_mask\"].unsqueeze(-1)\n",
+        "    embeddings = (outputs.last_hidden_state * mask).sum(1) / mask.sum(1)\n",
+        "    return F.normalize(embeddings, p=2, dim=1)\n",
+        "\n",
+        "sentences = [\n",
+        "    \"Nx provides numerical computing for Elixir\",\n",
+        "    \"Axon is a neural network library built on Nx\",\n",
+        "    \"Bumblebee connects Elixir to the Hugging Face Hub\",\n",
+        "    \"I enjoy cooking Italian food on weekends\",\n",
+        "    \"The weather forecast predicts rain tomorrow\",\n",
+        "]\n",
+        "\n",
+        "embeddings = embed(sentences)\n",
+        "\n",
+        "query = \"How do I build neural networks in Elixir?\"\n",
+        "query_emb = embed([query])\n",
+        "\n",
+        "similarities = F.cosine_similarity(query_emb, embeddings)\n",
+        "ranked = similarities.argsort(descending=True)\n",
+        "\n",
+        "print(f'Query: \"{query}\"\\n')\n",
+        "for idx in ranked:\n",
+        "    print(f\"  {similarities[idx]:.4f}  {sentences[idx]}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.6 Text Generation (GPT-2)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "text_gen = pipeline(\n",
+        "    \"text-generation\",\n",
+        "    model=\"openai-community/gpt2\",\n",
+        "    device=device,\n",
+        ")\n",
+        "\n",
+        "prompt = \"Machine learning in Elixir is\"\n",
+        "output = text_gen(prompt, max_new_tokens=50, num_return_sequences=1)\n",
+        "print(output[0][\"generated_text\"])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.7 Image Classification (Vision Transformer)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Elixir: Bumblebee.Vision.ImageClassification.image_classification(model, featurizer)\n",
+        "# Python: pipeline(\"image-classification\")\n",
+        "\n",
+        "from PIL import Image\n",
+        "import requests\n",
+        "\n",
+        "img_cls = pipeline(\"image-classification\", model=\"google/vit-base-patch16-224\")\n",
+        "\n",
+        "# Download sample image\n",
+        "img_url = \"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg\"\n",
+        "image = Image.open(requests.get(img_url, stream=True).raw)\n",
+        "\n",
+        "results = img_cls(image)\n",
+        "print(f\"Image: {image.size}\")\n",
+        "for r in results[:5]:\n",
+        "    print(f\"  {r['score']:.4f}  {r['label']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.8 Speech-to-Text (Whisper)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Elixir: Bumblebee.Audio.speech_to_text(model, featurizer, tokenizer, generation_config)\n",
+        "# Python: pipeline(\"automatic-speech-recognition\")\n",
+        "\n",
+        "asr = pipeline(\"automatic-speech-recognition\", model=\"openai/whisper-tiny\")\n",
+        "\n",
+        "# Sample audio from Hugging Face\n",
+        "audio_url = \"https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac\"\n",
+        "result = asr(audio_url)\n",
+        "print(f\"Transcription: {result['text']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.9 Image Generation (Stable Diffusion)\n",
+        "\n",
+        "> Requires GPU. On CPU this will be very slow."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Elixir: Bumblebee.Diffusion.StableDiffusion.text_to_image(...)\n",
+        "# Python: diffusers library\n",
+        "\n",
+        "try:\n",
+        "    from diffusers import StableDiffusionPipeline\n",
+        "\n",
+        "    sd_pipe = StableDiffusionPipeline.from_pretrained(\n",
+        "        \"CompVis/stable-diffusion-v1-4\",\n",
+        "        torch_dtype=torch.float16 if device == \"cuda\" else torch.float32,\n",
+        "    ).to(device)\n",
+        "\n",
+        "    prompt = \"a photograph of a bee programming in elixir, highly detailed, 4k\"\n",
+        "    image = sd_pipe(prompt, num_inference_steps=20).images[0]\n",
+        "    display(image)\n",
+        "except ImportError:\n",
+        "    print(\"Install diffusers: pip install diffusers\")\n",
+        "except Exception as e:\n",
+        "    print(f\"Stable Diffusion error (GPU recommended): {e}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 3 — Custom Training (Axon equivalent)\n",
+        "\n",
+        "Train a classifier from scratch using PyTorch — mirrors the Axon Livebook section."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import torch.nn as nn\n",
+        "from torch.utils.data import DataLoader, TensorDataset\n",
+        "\n",
+        "# --- Synthetic data (same as Livebook) ---\n",
+        "np.random.seed(42)\n",
+        "n_samples, n_features, n_classes = 2000, 4, 3\n",
+        "\n",
+        "centers = np.random.randn(n_classes, n_features) * 2\n",
+        "labels_raw = np.random.randint(0, n_classes, n_samples)\n",
+        "noise = np.random.randn(n_samples, n_features) * 0.4\n",
+        "X = centers[labels_raw] + noise\n",
+        "\n",
+        "# Normalize\n",
+        "X = (X - X.mean(axis=0)) / X.std(axis=0)\n",
+        "\n",
+        "# One-hot\n",
+        "Y = np.eye(n_classes)[labels_raw]\n",
+        "\n",
+        "# Split\n",
+        "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)\n",
+        "\n",
+        "# To tensors\n",
+        "X_train_t = torch.FloatTensor(X_train)\n",
+        "Y_train_t = torch.FloatTensor(Y_train)\n",
+        "X_test_t = torch.FloatTensor(X_test)\n",
+        "Y_test_t = torch.FloatTensor(Y_test)\n",
+        "\n",
+        "train_loader = DataLoader(TensorDataset(X_train_t, Y_train_t), batch_size=64, shuffle=True)\n",
+        "test_loader = DataLoader(TensorDataset(X_test_t, Y_test_t), batch_size=64)\n",
+        "\n",
+        "print(f\"Train: {len(X_train)} | Test: {len(X_test)} | Features: {n_features} | Classes: {n_classes}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Model (mirrors Axon build) ---\n",
+        "class MLP(nn.Module):\n",
+        "    def __init__(self):\n",
+        "        super().__init__()\n",
+        "        self.net = nn.Sequential(\n",
+        "            nn.Linear(n_features, 64),\n",
+        "            nn.ReLU(),\n",
+        "            nn.BatchNorm1d(64),\n",
+        "            nn.Dropout(0.2),\n",
+        "            nn.Linear(64, 32),\n",
+        "            nn.ReLU(),\n",
+        "            nn.BatchNorm1d(32),\n",
+        "            nn.Dropout(0.2),\n",
+        "            nn.Linear(32, n_classes),\n",
+        "            nn.Softmax(dim=1),\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        return self.net(x)\n",
+        "\n",
+        "model = MLP().to(device)\n",
+        "print(model)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Training loop ---\n",
+        "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "\n",
+        "for epoch in range(30):\n",
+        "    model.train()\n",
+        "    epoch_loss = 0\n",
+        "    for xb, yb in train_loader:\n",
+        "        xb, yb = xb.to(device), yb.to(device)\n",
+        "        preds = model(xb)\n",
+        "        loss = criterion(preds, yb.argmax(dim=1))\n",
+        "        optimizer.zero_grad()\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "        epoch_loss += loss.item()\n",
+        "\n",
+        "    if (epoch + 1) % 10 == 0:\n",
+        "        model.eval()\n",
+        "        correct = 0\n",
+        "        with torch.no_grad():\n",
+        "            for xb, yb in test_loader:\n",
+        "                xb, yb = xb.to(device), yb.to(device)\n",
+        "                preds = model(xb)\n",
+        "                correct += (preds.argmax(1) == yb.argmax(1)).sum().item()\n",
+        "        acc = correct / len(X_test) * 100\n",
+        "        print(f\"Epoch {epoch+1:3d}  loss={epoch_loss/len(train_loader):.4f}  test_acc={acc:.1f}%\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Final evaluation ---\n",
+        "model.eval()\n",
+        "with torch.no_grad():\n",
+        "    all_preds = []\n",
+        "    all_true = []\n",
+        "    for xb, yb in test_loader:\n",
+        "        preds = model(xb.to(device)).argmax(1).cpu().numpy()\n",
+        "        all_preds.extend(preds)\n",
+        "        all_true.extend(yb.argmax(1).numpy())\n",
+        "\n",
+        "print(classification_report(all_true, all_preds, target_names=[f\"Class {i}\" for i in range(n_classes)]))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Visualize ---\n",
+        "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n",
+        "\n",
+        "for cls in range(n_classes):\n",
+        "    mask = np.array(all_true) == cls\n",
+        "    axes[0].scatter(X_test[mask, 0], X_test[mask, 1], label=f\"Class {cls}\", alpha=0.6)\n",
+        "axes[0].set_title(\"Actual\")\n",
+        "axes[0].legend()\n",
+        "\n",
+        "for cls in range(n_classes):\n",
+        "    mask = np.array(all_preds) == cls\n",
+        "    axes[1].scatter(X_test[mask, 0], X_test[mask, 1], label=f\"Class {cls}\", alpha=0.6)\n",
+        "axes[1].set_title(\"Predicted\")\n",
+        "axes[1].legend()\n",
+        "\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 4 — Interactive Gradio UI (Kino equivalent)
+
+### 2.10 Model Export (ONNX / GGUF)
+
+**Export to ONNX** (requires `onnxruntime` and `torch.onnx`):
+```python
+# Export the sentiment analysis model to ONNX
+import torch
+from transformers import AutoModelForSequenceClassification
+model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased-finetuned-sst-2-english")
+# Dummy input for tracing
+dummy_input = torch.tensor([[101, 2023, 2003, 1037, 2742, 102]])
+torch.onnx.export(model, dummy_input, "sentiment.onnx", input_names=["input_ids"], output_names=["logits"], opset_version=12)
+print("ONNX model saved as sentiment.onnx")
+```
+
+**Convert to GGUF** (for llama.cpp style inference, works for decoder models like GPT-2):
+```bash
+# Install gguf-converter if needed
+pip install gguf-converter
+# Convert the exported ONNX model
+gguf-converter --onnx sentiment.onnx --output sentiment.gguf
+```
+
+> **Note:** GGUF currently supports decoder‑only architectures. For encoder‑only models you may need to adapt the conversion script or use `onnxruntime` directly.
+
+---
+
+## 4 — Interactive Gradio UI (Kino equivalent)\n",
+        "\n",
+        "Gradio is the Python equivalent of Elixir's Kino for building interactive UIs\n",
+        "that wrap ML models."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Sentiment Analysis UI ---\n",
+        "def classify_sentiment(text):\n",
+        "    result = sentiment(text)[0]\n",
+        "    return {r[\"label\"]: r[\"score\"] for r in sentiment(text)}\n",
+        "\n",
+        "sentiment_ui = gr.Interface(\n",
+        "    fn=classify_sentiment,\n",
+        "    inputs=gr.Textbox(label=\"Enter text\", placeholder=\"Type something...\"),\n",
+        "    outputs=gr.Label(label=\"Sentiment\"),\n",
+        "    title=\"🐝 Sentiment Analysis — Bumblebee/Transformers\",\n",
+        "    description=\"Mirrors the Elixir Livebook sentiment section\",\n",
+        ")\n",
+        "sentiment_ui.launch(share=True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Zero-Shot Classification UI ---\n",
+        "def zero_shot(text, labels_str):\n",
+        "    labels = [l.strip() for l in labels_str.split(\",\")]\n",
+        "    result = zs_classifier(text, labels)\n",
+        "    return {l: s for l, s in zip(result[\"labels\"], result[\"scores\"]) }\n",
+        "\n",
+        "zs_ui = gr.Interface(\n",
+        "    fn=zero_shot,\n",
+        "    inputs=[\n",
+        "        gr.Textbox(label=\"Text\", lines=3,\n",
+        "                   value=\"Elixir's BEAM provides fault-tolerant concurrent ML pipelines.\"),\n",
+        "        gr.Textbox(label=\"Labels (comma-separated)\",\n",
+        "                   value=\"technology, sports, politics, science, finance\"),\n",
+        "    ],\n",
+        "    outputs=gr.Label(label=\"Classification\"),\n",
+        "    title=\"🐝 Zero-Shot Classification\",\n",
+        ")\n",
+        "zs_ui.launch(share=True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Text Generation UI ---\n",
+        "def generate(prompt, max_tokens):\n",
+        "    output = text_gen(prompt, max_new_tokens=int(max_tokens), do_sample=True)\n",
+        "    return output[0][\"generated_text\"]\n",
+        "\n",
+        "gen_ui = gr.Interface(\n",
+        "    fn=generate,\n",
+        "    inputs=[\n",
+        "        gr.Textbox(label=\"Prompt\", value=\"Machine learning in Elixir is\"),\n",
+        "        gr.Slider(10, 100, value=50, step=1, label=\"Max tokens\"),\n",
+        "    ],\n",
+        "    outputs=gr.Textbox(label=\"Generated Text\", lines=5),\n",
+        "    title=\"🐝 GPT-2 Text Generation\",\n",
+        ")\n",
+        "gen_ui.launch(share=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 5 — Summary\n",
+        "\n",
+        "| Pipeline Stage | Elixir (Livebook) | Python (Colab/Kaggle) |\n",
+        "|----------------|-------------------|----------------------|\n",
+        "| Tensors | `Nx.tensor` | `np.array` |\n",
+        "| Gradients | `Nx.Defn.grad` | `torch.autograd` |\n",
+        "| GPU | `EXLA.Backend` | `torch.cuda` |\n",
+        "| Pre-trained | `Bumblebee.load_model` | `pipeline()` |\n",
+        "| Fill-Mask | `Bumblebee.Text.fill_mask` | `pipeline(\"fill-mask\")` |\n",
+        "| Sentiment | `Bumblebee.Text.Classification` | `pipeline(\"sentiment-analysis\")` |\n",
+        "| NER | `Bumblebee.Text.TokenClassification` | `pipeline(\"ner\")` |\n",
+        "| Zero-Shot | `Bumblebee.Text.ZeroShotClassification` | `pipeline(\"zero-shot-classification\")` |\n",
+        "| Text Gen | `Bumblebee.Text.generation` | `pipeline(\"text-generation\")` |\n",
+        "| Embeddings | `Bumblebee.Text.TextEmbedding` | `sentence-transformers` |\n",
+        "| Training | `Axon` + `Axon.Loop` | `torch.nn` + training loop |\n",
+        "| Serving | `Nx.Serving` | `gradio.Interface` |\n",
+        "| Interactive UI | `Kino` | `gradio` |\n",
+        "\n",
+        "### Deploy\n",
+        "\n",
+        "* **Colab**: Open this `.ipynb` directly\n",
+        "* **Kaggle**: Upload as a new notebook\n",
+        "* **HF Spaces**: Use the Gradio cells above + `sdk: gradio` in README.md"
+      ]
+    }
+  ]
+}

deps/ecto/.formatter.exs

@@ -0,0 +1,31 @@
+locals_without_parens = [
+  # Query
+  from: 2,
+
+  # Schema
+  field: 1,
+  field: 2,
+  field: 3,
+  timestamps: 1,
+  belongs_to: 2,
+  belongs_to: 3,
+  has_one: 2,
+  has_one: 3,
+  has_many: 2,
+  has_many: 3,
+  many_to_many: 2,
+  many_to_many: 3,
+  embeds_one: 2,
+  embeds_one: 3,
+  embeds_one: 4,
+  embeds_many: 2,
+  embeds_many: 3,
+  embeds_many: 4
+]
+
+[
+  locals_without_parens: locals_without_parens,
+  export: [
+    locals_without_parens: locals_without_parens
+  ]
+]

deps/ecto/CHANGELOG.md

@@ -0,0 +1,1048 @@
+# Changelog for v3.x
+
+## v3.12.5 (2024-11-28)
+
+### Enhancements
+
+  * [Ecto.Repo] Use `persistent_term` for faster repository lookup
+  * [Ecto.Repo] Document new `:pool_count` option
+
+### Bug fixes
+
+  * [Ecto.Query] Raise when empty list is given to `values/2`
+  * [Ecto.Query] Fix inspecting `dynamic/2` with interpolated named bindings
+  * [Ecto.Query] Plan sources before creating plan_subquery closure
+  * [Ecto.Repo] Remove read-only changes from returned record during insert/update
+  * [Ecto.Repo] Cascade `:allow_stale` options to assocs
+
+## v3.12.4 (2024-10-07)
+
+### Enhancements
+
+  * [Ecto.Repo] Document new `:pool_count` option
+
+### Bug fixes
+
+  * [Ecto.Repo] Make `Ecto.Repo.reload` respect `source`
+
+## v3.12.3 (2024-09-06)
+
+### Bug fixes
+
+  * [Ecto.Changeset]  Allow associations to be cast/put inside of embedded schema changesets
+
+## v3.12.2 (2024-08-25)
+
+### Bug fixes
+
+  * [Ecto.Query] Allow `:prefix` to be set to any term
+  * [Ecto.Repo] Avoid overwriting ssl opts from url if already set in config
+
+## v3.12.1 (2024-08-13)
+
+### Enhancements
+
+  * [Ecto.Type] Add `Ecto.Type.parameterized?/2`
+
+### Bug fixes
+
+  * [Ecto.Enum] Fix dialyzer specification
+  * [Ecto.Query] Remove incorrect subquery parameter check
+
+## v3.12.0 (2024-08-12)
+
+### Enhancements
+
+  * [Ecto.Changeset] Allow `{message, opts}` to be given as message for several validation APIs
+  * [Ecto.Query] Introduce `is_named_binding` guard
+  * [Ecto.Query] Subqueries are now supported in `distinct`, `group_by`, `order_by` and `window` expressions
+  * [Ecto.Query] Allow `select_merge` to be used in more `insert_all` and subquery operations by merging distinct fields
+  * [Ecto.Query] Allow literal maps inside `dynamic/2`
+  * [Ecto.Query] Support macro expansion at the root level of `order_by`
+  * [Ecto.Query] Support preloading subquery sources in `from` and `join`
+  * [Ecto.Query] Allow map updates with dynamic values in `select`
+  * [Ecto.Query] Allow any data structure that implements the Enumerable protocol on the right side of `in`
+  * [Ecto.Repo] Support 2-arity preload functions that receive ids and the association metadata
+  * [Ecto.Repo] Allow Hot Updates on upsert queries in Postgres by removing duplicate fields during replace_all
+  * [Ecto.Repo] `insert_all` supports queries with only source
+  * [Ecto.Repo] `insert_all` supports queries with the update syntax
+  * [Ecto.Repo] Support `:allow_stale` on Repo struct/changeset operations
+  * [Ecto.Schema] Allow schema fields to be read-only via `:writable` option
+  * [Ecto.Schema] Add `:defaults_to_struct` option to `embeds_one`
+  * [Ecto.Schema] Support `:duration` type which maps to Elixir v1.17 duration
+  * [Ecto.Type] Bubble up custom cast errors of the inner type for `{:map, type}` and `{:array, type}`
+  * [Ecto.Type] Add `Ecto.Type.cast!/2`
+
+### Bug fixes
+
+  * [Ecto.Query] Ignore query prefix in CTE sources
+  * [Ecto.Query] Fix a bug of `preload` when a through association is used in a join and has a nested separate query preload. Now the association chain is no longer preloaded and we simply preload directly onto the loaded through association.
+  * [Ecto.Query] Fix inspection when select has `map/struct` modifiers
+  * [Ecto.Query] Disable query cache for `values` lists
+  * [Ecto.Repo] Convert fields to their sources in `insert_all`
+  * [Ecto.Repo] Raise if empty list is given to `{:replace, fields}`
+  * [Ecto.Repo] Validate `:prefix` is a string/binary, warn otherwise
+  * [Ecto.Repo] Remove compile dependency on `:preload_order` MFA in `has_many`
+
+### Adapter changes
+
+  * `distinct`, `group_by`, `order_by` and `window` expressions use the new `Ecto.Query.ByExpr`
+    struct rather than the old `Ecto.Query.QueryExpr` struct
+
+### Potential incompatibilities
+
+  * [Ecto.Changeset] Associations inside embeds have always been read-only. We now raise if you try to cast them inside a changeset (this was reverted in v3.12.3)
+  * [Ecto.ParameterizedType] Parameterized types are now represented internally as `{:parameterized, {mod, state}}`. While this representation is private, projects may have been relying on it, and therefore they need to adapt accordingly. Use `Ecto.ParameterizedType.init/2` to instantiate parameterized types.
+  * [Ecto.Query] Drop `:array_join` join type. It was added for Clickhouse support but it is no longer used
+  * [Ecto.Query] Validate `:prefix` is a string/binary (this was reverted in v3.12.2)
+
+## v3.11.2 (2024-03-07)
+
+### Bug fixes
+
+  * [Ecto.Query] Fix compatibility with upcoming Elixir v1.17
+  * [Ecto.Repo] Do not hide failures when preloading if the parent process is trapping exits
+
+## v3.11.1 (2023-12-07)
+
+### Enhancements
+
+  * [Ecto.Query] Allow module attributes to be given to `in` operator
+
+### Bug fixes
+
+  * [Ecto.Query] Fix interpolating strings and atoms as map keys
+  * [Ecto.Query] Plan subqueries in `having`
+  * [Ecto.Query] Fix late binding with composite types
+
+## v3.11.0 (2023-11-14)
+
+### Enhancements
+
+  * [Ecto.Association] Allow `preload_order` to take MFAs for `many_to_many` associations. This allows ordering by the join table
+  * [Ecto.Query] Add `:operation` option to `with_cte/3`. This allows CTEs to perform updates and deletes
+  * [Ecto.Query] Support `splice(^...)` in `fragment`
+  * [Ecto.Query] Add `prepend_order_by/3`
+  * [Ecto.Query] Allow `selected_as/1` and `selected_as/2` to take interpolated names
+  * [Ecto.Query] Allow map update syntax to work with `nil` values in `select`
+  * [Ecto.Query] Allow hints to inject SQL using `unsafe_fragment`
+  * [Ecto.Query] Support `values/2` lists
+  * [Ecto.Repo] Add `:on_preload_spawn` option to `preload/3`
+  * [Ecto.Schema] Support `:load_in_query` option for embeds
+  * [Ecto.Schema] Support `:returning` option for delete
+
+### Bug fixes
+
+  * [Ecto.Association] Ensure parent prefix is passed to `on_delete` queries
+  * [Ecto.Changeset] Ensure duplicate primary keys are always detected for embeds
+  * [Ecto.Embedded] Raise `ArgumentError` when specifying an autogenerated `:id` primary key
+  * [Ecto.Query] Ensure subquery selects generate unique cache keys
+  * [Ecto.Query] Raise on literal non-base binary/uuids in query
+  * [Ecto.Repo] Reset `belongs_to` association if foreign key update results in a mismatch
+
+### Adapter changes
+
+  * Adapters now receive `nil` for encoding/decoding
+  * Adapters now receive `type` instead of `{:maybe, type}` as the first argument to `loaders/2`
+
+### Deprecations
+
+  * [Ecto.Query] Keyword hints are no longer supported. Please use `unsafe_fragment` inside of hints instead
+
+## v3.10.3 (2023-07-07)
+
+### Enhancements
+
+  * [Ecto.Query] Allow dynamic `field/2` in `type/2`
+
+### Bug fixes
+
+  * [Ecto.Changesets] Limit the largest integer to less than 32 digits
+  * [Ecto.Type] Limit the largest integer to less than 32 digits
+
+## v3.10.2 (2023-06-07)
+
+### Enhancements
+
+  * [Ecto.Changeset] Support a three-arity function with position on `cast_assoc` and `cast_embed`
+  * [Ecto.Changeset] Add support for maps in `validate_length/3`
+  * [Ecto.Changeset] Add `:nulls_distinct` option to `unsafe_validate_unique`
+  * [Ecto.Query] Support `array_join` type for ClickHouse adapter
+  * [Ecto.Query.API] Support parameterized and custom map types in json path validation
+
+### Bug fixes
+
+  * [Ecto.Repo] Respect parent prefix in `Repo.aggregate`
+  * [Ecto.Query.API] Fix late binding in `json_extract_path`
+
+### Deprecations
+
+  * Deprecate MFAs on `:with`
+
+## v3.10.1 (2023-04-12)
+
+### Bug fixes
+
+  * [Ecto.Changeset] Consider `sort_param` even if the relation param was not given
+  * [Ecto.Query] Correct typespec to avoid Dialyzer warnings
+
+## v3.10.0 (2023-04-10)
+
+This release contains many improvements to Ecto.Changeset, functions like `Ecto.Changeset.changed?/2` and `field_missing?/2` will help make your code more expressive. Improvements to association and embed handling will also make it easier to manage more complex forms, especially those embedded within Phoenix.LiveView applications.
+
+On the changeset front, note this release unifies the handling of empty values between `cast/4` and `validate_required/3`. **If you were setting `:empty_values` in the past and you want to preserve this new behaviour throughout, you may want to update your code** from this:
+
+    Ecto.Changeset.cast(changeset, params, [:field1, :field2], empty_values: ["", []])
+
+to:
+
+    empty_values = [[]] ++ Ecto.Changeset.empty_values()
+    Ecto.Changeset.cast(changeset, params, [:field1, :field2], empty_values: empty_values)
+
+Queries have also been improved to support LIMIT WITH TIES as well as materialized CTEs.
+
+### Enhancements
+
+  * [Ecto.Changeset] Add `get_assoc`/`get_embed`
+  * [Ecto.Changeset] Add `field_missing?/2`
+  * [Ecto.Changeset] Add `changed?/2` and `changed?/3` with predicates support
+  * [Ecto.Changeset] Allow `Regex` to be used in constraint names for exact matches
+  * [Ecto.Changeset] Allow `:empty_values` option in `cast/4` to include a function which must return true if the value is empty
+  * [Ecto.Changeset] `cast/4` will by default consider strings made only of whitespace characters to be empty
+  * [Ecto.Changeset] Add support for `:sort_param` and `:drop_param` on `cast_assoc` and `cast_embed`
+  * [Ecto.Query] Support materialized option in CTEs
+  * [Ecto.Query] Support dynamic field inside `json_extract_path`
+  * [Ecto.Query] Support interpolated values for from/join prefixes
+  * [Ecto.Query] Support ties in limit expressions through `with_ties/3`
+  * [Ecto.Schema] Add `:autogenerate_fields` to the schema reflection API
+  * [Ecto.ParameterizedType] Add optional callback `format/1`
+
+### Bug fixes
+
+  * [Ecto.Changeset] Make unsafe validate unique exclude primary key only for loaded schemas
+  * [Ecto.Changeset] Raise when change provided to `validate_format/4` is not a string
+  * [Ecto.Query] Fix bug in `json_extract_path` where maps were not allowed to be nested inside of embeds
+  * [Ecto.Schema] Allow inline embeds to overwrite conflicting aliases
+
+## v3.9.6 (2023-07-07)
+
+### Enhancements
+
+  * [Ecto.Query] Allow dynamic `field/2` in `type/2`
+
+### Bug fixes
+
+  * [Ecto.Changesets] Limit the largest integer to less than 32 digits
+  * [Ecto.Type] Limit the largest integer to less than 32 digits
+
+## v3.9.5 (2023-03-22)
+
+### Bug fixes
+
+  * [Ecto.Query] Rename `@opaque dynamic` type to `@opaque dynamic_expr` to avoid conflicts with Erlang/OTP 26
+
+## v3.9.4 (2022-12-21)
+
+### Bug fixes
+
+  * [Ecto.Query] Fix regression with interpolated preloads introduced in v3.9.3
+
+## v3.9.3 (2022-12-20)
+
+### Enhancements
+
+  * [Ecto] Add `reset_fields/2`
+  * [Ecto.Multi] Add `exists?/4` function
+  * [Ecto.Repo] Keep url scheme in the repo configuration
+  * [Ecto.Query] Add support for cross lateral joins
+  * [Ecto.Query] Allow preloads to use `dynamic/2`
+  * [Ecto.Query.API] Allow the entire path to be interpolated in `json_extract_path/2`
+
+## v3.9.2 (2022-11-18)
+
+### Enhancements
+
+ * [Ecto.Query] Allow `selected_as` inside CTE
+ * [Ecto.Query] Allow `selected_as` to be used in subquery
+
+### Bug fixes
+
+  * [Ecto.Repo] Fix preloading through associations on `nil`
+  * [Ecto.Query] Fix select merging a `selected_as` field into a source
+
+## v3.9.1 (2022-10-06)
+
+### Enhancements
+
+  * [Ecto.Query] Allow `selected_as` at the root of `dynamic/2`
+  * [Ecto.Query] Allow `selected_as` to be used with `type/2`
+  * [Ecto.Query] Allow `selected_as` to be used with `select_merge`
+
+### Bug fixes
+
+  * [Ecto.Changeset] Reenable support for embedded schemas in `unsafe_validate_unique/4`
+  * [Ecto.Query] Ensure `join_where` conditions preload correctly in `many_to_many` or with queries with one or many joins
+
+## v3.9.0 (2022-09-27)
+
+### Enhancements
+
+  * [Ecto.Changeset] Add `:force_changes` option to `cast/4`
+  * [Ecto.Enum] Allow enum fields to be embed either as their values or their dumped versions
+  * [Ecto.Query] Support `^%{field: dynamic(...)}` in `select` and `select_merge`
+  * [Ecto.Query] Support `%{field: subquery(...)}` in `select` and `select_merge`
+  * [Ecto.Query] Support select aliases through `selected_as/1` and `selected_as/2`
+  * [Ecto.Query] Allow `parent_as/1` in `type/2`
+  * [Ecto.Query] Add `with_named_binding/3`
+  * [Ecto.Query] Allow fragment sources in keyword queries
+  * [Ecto.Repo] Support `idle_interval` query parameter in connection URL
+  * [Ecto.Repo] Log human-readable UUIDs by using pre-dumped query parameters
+  * [Ecto.Schema] Support preloading associations in embedded schemas
+
+### Bug fix
+
+  * [Ecto.Changeset] Raise when schemaless changeset or embedded schema is used in `unsafe_validate_unique/4`
+  * [Ecto.Query] Respect virtual field type in subqueries
+  * [Ecto.Query] Don't select struct fields overridden with `nil`
+  * [Ecto.Query] Fix `select_merge` not tracking `load_in_query: false` field
+  * [Ecto.Query] Fix field source when used in `json_extract_path`
+  * [Ecto.Query] Properly build CTEs at compile time
+  * [Ecto.Query] Properly order subqueries in `dynamic`
+  * [Ecto.Repo] Fix `insert_all` query parameter count when using value queries alongside `placeholder`
+  * [Ecto.Repo] Raise if combination query is used in a `many` preload
+  * [Ecto.Schema] Ignore associations that aren't loaded on insert
+
+## v3.8.4 (2022-06-04)
+
+### Enhancements
+
+  * [Ecto.Multi] Add `one/2` and `all/2` functions
+  * [Ecto.Query] Support `literal(...)` in `fragment`
+
+### Bug fix
+
+  * [Ecto.Schema] Make sure fields are inspected in the correct order in Elixir v1.14+
+
+## v3.8.3 (2022-05-11)
+
+### Bug fix
+
+  * [Ecto.Query] Allow source aliases to be used in `type/2`
+  * [Ecto.Schema] Avoid "undefined behaviour/struct" warnings and errors during compilation
+
+## v3.8.2 (2022-05-05)
+
+### Bug fix
+
+  * [Ecto.Adapter] Do not require adapter metadata to be raw maps
+  * [Ecto.Association] Respect `join_where` in many to many `on_replace` deletes
+  * [Ecto.Changeset] Check if list is in `empty_values` before nested validations
+
+## v3.8.1 (2022-04-27)
+
+### Bug fix
+
+  * [Ecto.Query] Fix regression where a join's on parameter on `update_all` was out of order
+
+## v3.8.0 (2022-04-26)
+
+Ecto v3.8 requires Elixir v1.10+.
+
+### Enhancements
+
+  * [Ecto] Add new Embedded chapter to Introductory guides
+  * [Ecto.Changeset] Allow custom `:error_key` in unique_constraint
+  * [Ecto.Changeset] Add `:match` option to all constraint functions
+  * [Ecto.Query] Support dynamic aliases
+  * [Ecto.Query] Allow using `type/2` with virtual fields
+  * [Ecto.Query] Suggest alternatives to inexistent fields in queries
+  * [Ecto.Query] Support passing queries using subqueries to `insert_all`
+  * [Ecto.Repo] Allow `stacktrace: true` so stacktraces are included in telemetry events and logs
+  * [Ecto.Schema] Validate options given to schema fields
+
+### Bug fixes
+
+  * [Ecto.Changeset] Address regression on `validate_subset` no longer working with custom array types
+  * [Ecto.Changeset] **Potentially breaking change**: Detect `empty_values` inside lists when casting. This may cause issues if you were relying on the casting of empty values (by default, only `""`).
+  * [Ecto.Query] Handle atom list sigils in `select`
+  * [Ecto.Query] Improve tracking of `select_merge` inside subqueries
+  * [Ecto.Repo] Properly handle literals in queries given to `insert_all`
+  * [Ecto.Repo] Don't surface persisted data as changes on embed updates
+  * [Ecto.Repo] **Potentially breaking change**: Raise if an association doesn't have a primary key and is preloaded in a join query. Previously, this would silently produce the wrong the result in certain circumstances.
+  * [Ecto.Schema] Preserve parent prefix on join tables
+
+## v3.7.2 (2022-03-13)
+
+### Enhancements
+
+  * [Ecto.Schema] Add option to skip validations for default values
+  * [Ecto.Query] Allow coalesce in `type/2`
+  * [Ecto.Query] Support parameterized types in type/2
+  * [Ecto.Query] Allow arbitrary parentheses in query expressions
+
+## v3.7.1 (2021-08-27)
+
+### Enhancements
+
+  * [Ecto.Embedded] Make `Ecto.Embedded` public and describe struct fields
+
+### Bug fixes
+
+  * [Ecto.Repo] Make sure parent changeset is included in changes for `insert`/`update`/`delete` when there are errors processing the parent itself
+
+## v3.7.0 (2021-08-19)
+
+### Enhancements
+
+  * [Ecto.Changeset] Add `Ecto.Changeset.traverse_validations/2`
+  * [Ecto.Enum] Add `Ecto.Enum.mappings/2` and `Ecto.Enum.dump_values/2`
+  * [Ecto.Query] Add support for dynamic `as(^as)` and `parent_as(^as)`
+  * [Ecto.Repo] Add stale changeset to `Ecto.StaleEntryError` fields
+  * [Ecto.Schema] Add support for `@schema_context` to set context metadata on schema definition
+
+### Bug fixes
+
+  * [Ecto.Changeset] Fix changeset inspection not redacting when embedded
+  * [Ecto.Changeset] Use semantic comparison on `validate_inclusion`, `validate_exclusion`, and `validate_subset`
+  * [Ecto.Enum] Raise on duplicate values in `Ecto.Enum`
+  * [Ecto.Query] Make sure `hints` are included in the query cache
+  * [Ecto.Repo] Support placeholders in `insert_all` without schemas
+  * [Ecto.Repo] Wrap in a subquery when query given to `Repo.aggregate` has combination
+  * [Ecto.Repo] Fix CTE subqueries not finding parent bindings
+  * [Ecto.Repo] Return changeset with assocs if any of the assocs are invalid
+
+## v3.6.2 (2021-05-28)
+
+### Enhancements
+
+  * [Ecto.Query] Support macros in `with_cte`
+  * [Ecto.Repo] Add `Ecto.Repo.all_running/0` to list all running repos
+
+### Bug fixes
+
+  * [Ecto.Query] Do not omit nil fields in a subquery select
+  * [Ecto.Query] Allow `parent_as` to look for an alias all the way up across subqueries
+  * [Ecto.Query] Raise if a nil value is given to a query from a nested map parameter
+  * [Ecto.Query] Fix `insert_all` when using both `:on_conflict` and `:placeholders`
+  * [mix ecto.load] Do not pass `--force` to underlying compile task
+
+## v3.6.1 (2021-04-12)
+
+### Enhancements
+
+  * [Ecto.Changeset] Allow the `:query` option in `unsafe_validate_unique`
+
+### Bug fixes
+
+  * [Ecto.Changeset] Add the relation id in `apply_changes` if the relation key exists (instead of hardcoding it to `id`)
+
+## v3.6.0 (2021-04-03)
+
+### Enhancements
+
+  * [Ecto.Changeset] Support `:repo_opts` in `unsafe_validate_unique`
+  * [Ecto.Changeset] Add a validation error if trying to cast a cardinality one embed/assoc with anything other than a map or keyword list
+  * [Ecto.Enum] Allow enums to map to custom values
+  * [Ecto.Multi] Add `Ecto.Multi.put/3` for directly storing values
+  * [Ecto.Query] **Potentially breaking change**: optimize `many_to_many` queries so it no longer load intermediary tables in more occasions. This may cause issues if you are using `Ecto.assoc/2` to load `many_to_many` associations and then trying to access intermediate bindings (which is discouraged but it was possible)
+  * [Ecto.Repo] Allow `insert_all` to be called with a query instead of rows
+  * [Ecto.Repo] Add `:placeholders` support to `insert_all` to avoid sending the same value multiple times
+  * [Ecto.Schema] Support `:preload_order` on `has_many` and `many_to_many` associations
+  * [Ecto.UUID] Add bang UUID conversion methods
+  * [Ecto.Query] The `:hints` option now accepts dynamic values when supplied as tuples
+  * [Ecto.Query] Support `select: map(source, fields)` where `source` is a fragment
+  * [Ecto.Query] Allow referring to the parent query in a join's subquery select via `parent_as`
+  * [mix ecto] Support file and line interpolation on `ECTO_EDITOR`
+
+### Bug fixes
+
+  * [Ecto.Changeset] Change `apply_changes/1` to add the relation to the `struct.relation_id` if relation struct is persisted
+  * [Ecto.Query] Remove unnecessary INNER JOIN in many to many association query
+  * [Ecto.Query] Allow parametric types to be interpolated in queries
+  * [Ecto.Schema] Raise `ArgumentError` when default has invalid type
+
+## v3.5.8 (2021-02-21)
+
+### Enhancements
+
+  * [Ecto.Query] Support map/2 on fragments and subqueries
+
+## v3.5.7 (2021-02-07)
+
+### Bug fixes
+
+  * [Ecto.Query] Fixes param ordering issue on dynamic queries with subqueries
+
+## v3.5.6 (2021-01-20)
+
+### Enhancements
+
+  * [Ecto.Schema] Support `on_replace: :delete_if_exists` on associations
+
+### Bug fixes
+
+  * [Ecto.Query] Allow unary minus operator in query expressions
+  * [Ecto.Schema] Allow nil values on typed maps
+
+## v3.5.5 (2020-11-12)
+
+### Enhancements
+
+  * [Ecto.Query] Add support for subqueries operators: `all`, `any`, and `exists`
+
+### Bug fixes
+
+  * [Ecto.Changeset] Use association source on `put_assoc` with maps/keywords
+  * [Ecto.Enum] Add `cast` clause for nil values on `Ecto.Enum`
+  * [Ecto.Schema] Allow nested type `:any` for non-virtual fields
+
+## v3.5.4 (2020-10-28)
+
+### Enhancements
+
+  * [mix ecto.drop] Provide `--force-drop` for databases that may support it
+  * [guides] Add new "Multi tenancy with foreign keys" guide
+
+### Bug fixes
+
+  * [Ecto.Changeset] Make keys optional in specs
+  * [Ecto.Enum] Make sure `values/2` works for virtual fields
+  * [Ecto.Query] Fix missing type on CTE queries that select a single field
+
+## v3.5.3 (2020-10-21)
+
+### Bug fixes
+
+  * [Ecto.Query] Do not reset parameter counter for nested CTEs
+  * [Ecto.Type] Fix regression where array type with nils could no longer be cast/load/dump
+  * [Ecto.Type] Fix CaseClauseError when casting a decimal with a binary remainder
+
+## v3.5.2 (2020-10-12)
+
+### Enhancements
+
+  * [Ecto.Repo] Add Repo.reload/2 and Repo.reload!/2
+
+### Bug fixes
+
+  * [Ecto.Changeset] Fix "__schema__/1 is undefined or private" error while inspecting a schemaless changeset
+  * [Ecto.Repo] Invoke `c:Ecto.Repo.default_options/1` per entry-point operation
+
+## v3.5.1 (2020-10-08)
+
+### Enhancements
+
+  * [Ecto.Changeset] Warn if there are duplicate IDs in the parent schema for `cast_assoc/3`/`cast_embed/3`
+  * [Ecto.Schema] Allow `belongs_to` to accept options for parameterized types
+
+### Bug fixes
+
+  * [Ecto.Query] Keep field types when using a subquery with source
+
+## v3.5.0 (2020-10-03)
+
+v3.5 requires Elixir v1.8+.
+
+### Bug fixes
+
+  * [Ecto.Changeset] Ensure `:empty_values` in `cast/4` does not automatically propagate to following cast calls. If you want a given set of `:empty_values` to apply to all `cast/4` calls, change the value stored in `changeset.empty_values` instead
+  * [Ecto.Changeset] **Potentially breaking change**: Do not force repository updates to happen when using `optimistic_lock`. The lock field will only be incremented if the record has other changes. If no changes, nothing happens.
+  * [Ecto.Changeset] Do not automatically share empty values across `cast/3` calls
+  * [Ecto.Query] Consider query prefix in cte/combination query cache
+  * [Ecto.Query] Allow the entry to be marked as nil when using left join with subqueries
+  * [Ecto.Query] Support subqueries inside dynamic expressions
+  * [Ecto.Repo] Fix preloading when using dynamic repos and the sandbox in automatic mode
+  * [Ecto.Repo] Do not duplicate collections when associations are preloaded for repeated elements
+
+### Enhancements
+
+  * [Ecto.Enum] Add `Ecto.Enum` as a custom parameterized type
+  * [Ecto.Query] Allow `:prefix` in `from` to be set to nil
+  * [Ecto.Query] Do not restrict subqueries in `where` to map/struct types
+  * [Ecto.Query] Allow atoms in query without interpolation in order to support Ecto.Enum
+  * [Ecto.Schema] Do not validate uniqueness if there is a prior error on the field
+  * [Ecto.Schema] Allow `redact: true` in `field`
+  * [Ecto.Schema] Support parameterized types via `Ecto.ParameterizedType`
+  * [Ecto.Schema] Rewrite embeds and assocs as parameterized types. This means `__schema__(:type, assoc_or_embed)` now returns a parameterized type. To check if something is an association, use `__schema__(:assocs)` or `__schema__(:embeds)` instead
+
+## v3.4.6 (2020-08-07)
+
+### Enhancements
+
+  * [Ecto.Query] Allow `count/0` on `type/2`
+  * [Ecto.Multi] Support anonymous functions in multiple functions
+
+### Bug fixes
+
+  * [Ecto.Query] Consider booleans as literals in unions, subqueries, ctes, etc
+  * [Ecto.Schema] Generate IDs for nested embeds
+
+## v3.4.5 (2020-06-14)
+
+### Enhancements
+
+  * [Ecto.Changeset] Allow custom error key in `unsafe_validate_unique`
+  * [Ecto.Changeset] Improve performance when casting large params maps
+
+### Bug fixes
+
+  * [Ecto.Changeset] Improve error message for invalid `cast_assoc`
+  * [Ecto.Query] Fix inspecting query with fragment CTE
+  * [Ecto.Query] Fix inspecting dynamics with aliased bindings
+  * [Ecto.Query] Improve error message when selecting a single atom
+  * [Ecto.Repo] Reduce data-copying when preloading multiple associations
+  * [Ecto.Schema] Do not define a compile-time dependency for schema in `:join_through`
+
+## v3.4.4 (2020-05-11)
+
+### Enhancements
+
+  * [Ecto.Schema] Add `join_where` support to `many_to_many`
+
+## v3.4.3 (2020-04-27)
+
+### Enhancements
+
+  * [Ecto.Query] Support `as/1` and `parent_as/1` for lazy named bindings and to allow parent references from subqueries
+  * [Ecto.Query] Support `x in subquery(query)`
+
+### Bug fixes
+
+  * [Ecto.Query] Do not raise for missing assocs if :force is given to preload
+  * [Ecto.Repo] Return error from `Repo.delete` on invalid changeset from `prepare_changeset`
+
+## v3.4.2 (2020-04-10)
+
+### Enhancements
+
+  * [Ecto.Changeset] Support multiple fields in `unique_constraint/3`
+
+## v3.4.1 (2020-04-08)
+
+### Enhancements
+
+  * [Ecto] Add `Ecto.embedded_load/3` and `Ecto.embedded_dump/2`
+  * [Ecto.Query] Improve error message on invalid JSON expressions
+  * [Ecto.Repo] Emit `[:ecto, :repo, :init]` telemetry event upon Repo init
+
+### Bug fixes
+
+  * [Ecto.Query] Do not support JSON selectors on `type/2`
+
+### Deprecations
+
+  * [Ecto.Repo] Deprecate `conflict_target: {:constraint, _}`. It is a discouraged approach and `{:unsafe_fragment, _}` is still available if someone definitely needs it
+
+## v3.4.0 (2020-03-24)
+
+v3.4 requires Elixir v1.7+.
+
+### Enhancements
+
+  * [Ecto.Query] Allow dynamic queries in CTE and improve error message
+  * [Ecto.Query] Add `Ecto.Query.API.json_extract_path/2` and JSON path support to query syntax. For example, `posts.metadata["tags"][0]["name"]` will return the name of the first tag stored in the `:map` metadata field
+  * [Ecto.Repo] Add new `default_options/1` callback to repository
+  * [Ecto.Repo] Support passing `:telemetry_options` to repository operations
+
+### Bug fixes
+
+  * [Ecto.Changeset] Properly add validation annotation to `validate_acceptance`
+  * [Ecto.Query] Raise if there is loaded non-empty association data without related key when preloading. This typically means not all fields have been loaded in a query
+  * [Ecto.Schema] Show meaningful error in case `schema` is invoked twice in an `Ecto.Schema`
+
+## v3.3.4 (2020-02-27)
+
+### Bug fixes
+
+  * [mix ecto] Do not rely on map ordering when parsing repos
+  * [mix ecto.gen.repo] Improve error message when a repo is not given
+
+## v3.3.3 (2020-02-14)
+
+### Enhancements
+
+  * [Ecto.Query] Support fragments in `lock`
+  * [Ecto.Query] Handle `nil` in `select_merge` with similar semantics to SQL databases (i.e. it simply returns `nil` itself)
+
+## v3.3.2 (2020-01-28)
+
+### Enhancements
+
+  * [Ecto.Changeset] Only bump optimistic lock in case of success
+  * [Ecto.Query] Allow macros in Ecto window expressions
+  * [Ecto.Schema] Support `:join_defaults` on `many_to_many` associations
+  * [Ecto.Schema] Allow MFargs to be given to association `:defaults`
+  * [Ecto.Type] Add `Ecto.Type.embedded_load` and `Ecto.Type.embedded_dump`
+
+### Bug fixes
+
+  * [Ecto.Repo] Ignore empty hostname when parsing database url (Elixir v1.10 support)
+  * [Ecto.Repo] Rewrite combinations on Repo.exists? queries
+  * [Ecto.Schema] Respect child `@schema_prefix` in `cast_assoc`
+  * [mix ecto.gen.repo] Use `config_path` when writing new config in `mix ecto.gen.repo`
+
+## v3.3.1 (2019-12-27)
+
+### Enhancements
+
+  * [Ecto.Query.WindowAPI] Support `filter/2`
+
+### Bug fixes
+
+  * [Ecto.Query.API] Fix `coalesce/2` usage with mixed types
+
+## v3.3.0 (2019-12-11)
+
+### Enhancements
+
+  * [Ecto.Adapter] Add `storage_status/1` callback to `Ecto.Adapters.Storage` behaviour
+  * [Ecto.Changeset] Add `Ecto.Changeset.apply_action!/2`
+  * [Ecto.Changeset] Remove actions restriction in `Ecto.Changeset.apply_action/2`
+  * [Ecto.Repo] Introduce `c:Ecto.Repo.aggregate/2`
+  * [Ecto.Repo] Support `{:replace_all_except, fields}` in `:on_conflict`
+
+### Bug fixes
+
+  * [Ecto.Query] Make sure the `:prefix` option in `:from`/`:join` also cascades to subqueries
+  * [Ecto.Query] Make sure the `:prefix` option in `:join` also cascades to queries
+  * [Ecto.Query] Use database returned values for literals. Previous Ecto versions knew literals from queries should not be discarded for combinations but, even if they were not discarded, we would ignore the values returned by the database
+  * [Ecto.Repo] Do not wrap schema operations in a transaction if already inside a transaction. We have also removed the **private** option called `:skip_transaction`
+
+### Deprecations
+
+  * [Ecto.Repo] `:replace_all_except_primary_keys` is deprecated in favor of `{:replace_all_except, fields}` in `:on_conflict`
+
+## v3.2.5 (2019-11-03)
+
+### Bug fixes
+
+  * [Ecto.Query] Fix a bug where executing some queries would leak the `{:maybe, ...}` type
+
+## v3.2.4 (2019-11-02)
+
+### Bug fixes
+
+  * [Ecto.Query] Improve error message on invalid join binding
+  * [Ecto.Query] Make sure the `:prefix` option in `:join` also applies to through associations
+  * [Ecto.Query] Invoke custom type when loading aggregations from the database (but fallback to database value if it can't be cast)
+  * [mix ecto.gen.repo] Support Elixir v1.9 style configs
+
+## v3.2.3 (2019-10-17)
+
+### Bug fixes
+
+  * [Ecto.Changeset] Do not convert enums given to `validate_inclusion` to a list
+
+### Enhancements
+
+  * [Ecto.Changeset] Improve error message on non-atom keys to change/put_change
+  * [Ecto.Changeset] Allow :with to be given as a `{module, function, args}` tuple on `cast_association/cast_embed`
+  * [Ecto.Changeset] Add `fetch_change!/2` and `fetch_field!/2`
+
+## v3.2.2 (2019-10-01)
+
+### Bug fixes
+
+  * [Ecto.Query] Fix keyword arguments given to `:on` when a bind is not given to join
+  * [Ecto.Repo] Make sure a preload given to an already preloaded has_many :through is loaded
+
+## v3.2.1 (2019-09-17)
+
+### Enhancements
+
+  * [Ecto.Changeset] Add rollover logic for default incrementer in `optimistic_lock`
+  * [Ecto.Query] Also expand macros when used inside `type/2`
+
+### Bug fixes
+
+  * [Ecto.Query] Ensure queries with non-cacheable queries in CTEs/combinations are also not-cacheable
+
+## v3.2.0 (2019-09-07)
+
+v3.2 requires Elixir v1.6+.
+
+### Enhancements
+
+  * [Ecto.Query] Add common table expressions support `with_cte/3` and `recursive_ctes/2`
+  * [Ecto.Query] Allow `dynamic/3` to be used in `order_by`, `distinct`, `group_by`, as well as in `partition_by`, `order_by`, and `frame` inside `windows`
+  * [Ecto.Query] Allow filters in `type/2` expressions
+  * [Ecto.Repo] Merge options given to the repository into the changeset `repo_opts` and assign it back to make it available down the chain
+  * [Ecto.Repo] Add `prepare_query/3` callback that is invoked before query operations
+  * [Ecto.Repo] Support `:returning` option in `Ecto.Repo.update/2`
+  * [Ecto.Repo] Support passing a one arity function to `Ecto.Repo.transaction/2`, where the argument is the current repo
+  * [Ecto.Type] Add a new `embed_as/1` callback to `Ecto.Type` that allows adapters to control embedding behaviour
+  * [Ecto.Type] Add `use Ecto.Type` for convenience that implements the new required callbacks
+
+### Bug fixes
+
+  * [Ecto.Association] Ensure we delete an association before inserting when replacing on `has_one`
+  * [Ecto.Query] Do not allow interpolated `nil` in literal keyword list when building query
+  * [Ecto.Query] Do not remove literals from combinations, otherwise UNION/INTERSECTION queries may not match the number of values in `select`
+  * [Ecto.Query] Do not attempt to merge at compile-time non-keyword lists given to `select_merge`
+  * [Ecto.Repo] Do not override `:through` associations on preload unless forcing
+  * [Ecto.Repo] Make sure prefix option cascades to combinations and recursive queries
+  * [Ecto.Schema] Use OS time without drift when generating timestamps
+  * [Ecto.Type] Allow any datetime in `datetime_add`
+
+## v3.1.7 (2019-06-27)
+
+### Bug fixes
+
+  * [Ecto.Changeset] Make sure `put_assoc` with empty changeset propagates on insert
+
+## v3.1.6 (2019-06-19)
+
+### Enhancements
+
+  * [Ecto.Repo] Add `:read_only` repositories
+  * [Ecto.Schema] Also validate options given to `:through` associations
+
+### Bug fixes
+
+  * [Ecto.Changeset] Do not mark `put_assoc` from `[]` to `[]` or from `nil` to `nil` as change
+  * [Ecto.Query] Remove named binding when excluding joins
+  * [mix ecto.gen.repo] Use `:config_path` instead of hardcoding to `config/config.exs`
+
+## v3.1.5 (2019-06-06)
+
+### Enhancements
+
+  * [Ecto.Repo] Allow `:default_dynamic_repo` option on `use Ecto.Repo`
+  * [Ecto.Schema] Support `{:fragment, ...}` in the `:where` option for associations
+
+### Bug fixes
+
+  * [Ecto.Query] Fix handling of literals in combinators (union, except, intersection)
+
+## v3.1.4 (2019-05-07)
+
+### Bug fixes
+
+  * [Ecto.Changeset] Convert validation enums to lists before adding them as validation metadata
+  * [Ecto.Schema] Properly propagate prefix to join_through source in many_to_many associations
+
+## v3.1.3 (2019-04-30)
+
+### Enhancements
+
+  * [Ecto.Changeset] Expose the enum that was validated against in errors from enum-based validations
+
+## v3.1.2 (2019-04-24)
+
+### Enhancements
+
+  * [Ecto.Query] Add support for `type+over`
+  * [Ecto.Schema] Allow schema fields to be excluded from queries
+
+### Bug fixes
+
+  * [Ecto.Changeset] Do not list a field as changed if it is updated to its original value
+  * [Ecto.Query] Keep literal numbers and bitstring in subqueries and unions
+  * [Ecto.Query] Improve error message for invalid `type/2` expression
+  * [Ecto.Query] Properly count interpolations in `select_merge/2`
+
+## v3.1.1 (2019-04-04)
+
+### Bug fixes
+
+  * [Ecto] Do not require Jason (i.e. it should continue to be an optional dependency)
+  * [Ecto.Repo] Make sure `many_to_many` and `Ecto.Multi` work with dynamic repos
+
+## v3.1.0 (2019-04-02)
+
+v3.1 requires Elixir v1.5+.
+
+### Enhancements
+
+  * [Ecto.Changeset] Add `not_equal_to` option for `validate_number`
+  * [Ecto.Query] Improve error message for missing `fragment` arguments
+  * [Ecto.Query] Improve error message on missing struct key for structs built in `select`
+  * [Ecto.Query] Allow dynamic named bindings
+  * [Ecto.Repo] Add dynamic repository support with `Ecto.Repo.put_dynamic_repo/1` and `Ecto.Repo.get_dynamic_repo/0` (experimental)
+  * [Ecto.Type] Cast naive_datetime/utc_datetime strings without seconds
+
+### Bug fixes
+
+  * [Ecto.Changeset] Do not run `unsafe_validate_unique` query unless relevant fields were changed
+  * [Ecto.Changeset] Raise if an unknown field is given on `Ecto.Changeset.change/2`
+  * [Ecto.Changeset] Expose the type that was validated in errors generated by `validate_length/3`
+  * [Ecto.Query] Add support for `field/2` as first element of `type/2` and alias as second element of `type/2`
+  * [Ecto.Query] Do not attempt to assert types of named bindings that are not known at compile time
+  * [Ecto.Query] Properly cast boolean expressions in select
+  * [Mix.Ecto] Load applications during repo lookup so their app environment is available
+
+### Deprecations
+
+  * [Ecto.LogEntry] Fully deprecate previously soft deprecated API
+
+## v3.0.7 (2019-02-06)
+
+### Bug fixes
+
+  * [Ecto.Query] `reverse_order` reverses by primary key if no order is given
+
+## v3.0.6 (2018-12-31)
+
+### Enhancements
+
+  * [Ecto.Query] Add `reverse_order/1`
+
+### Bug fixes
+
+  * [Ecto.Multi] Raise better error message on accidental rollback inside `Ecto.Multi`
+  * [Ecto.Query] Properly merge deeply nested preloaded joins
+  * [Ecto.Query] Raise better error message on missing select on schemaless queries
+  * [Ecto.Schema] Fix parameter ordering in assoc `:where`
+
+## v3.0.5 (2018-12-08)
+
+### Backwards incompatible changes
+
+  * [Ecto.Schema] The `:where` option added in Ecto 3.0.0 had a major flaw and it has been reworked in this version. This means a tuple of three elements can no longer be passed to `:where`, instead a keyword list must be given. Check the "Filtering associations" section in `has_many/3` docs for more information
+
+### Bug fixes
+
+  * [Ecto.Query] Do not raise on lists of tuples that are not keywords. Instead, let custom Ecto.Type handle them
+  * [Ecto.Query] Allow `prefix: nil` to be given to subqueries
+  * [Ecto.Query] Use different cache keys for unions/intersections/excepts
+  * [Ecto.Repo] Fix support for upserts with `:replace` without a schema
+  * [Ecto.Type] Do not lose precision when casting `utc_datetime_usec` with a time zone different than Etc/UTC
+
+## v3.0.4 (2018-11-29)
+
+### Enhancements
+
+  * [Decimal] Bump decimal dependency
+  * [Ecto.Repo] Remove unused `:pool_timeout`
+
+## v3.0.3 (2018-11-20)
+
+### Enhancements
+
+  * [Ecto.Changeset] Add `count: :bytes` option in `validate_length/3`
+  * [Ecto.Query] Support passing `Ecto.Query` in `Ecto.Repo.insert_all`
+
+### Bug fixes
+
+  * [Ecto.Type] Respect adapter types when loading/dumping arrays and maps
+  * [Ecto.Query] Ensure no bindings in order_by when using combinations in `Ecto.Query`
+  * [Ecto.Repo] Ensure adapter is compiled (instead of only loaded) before invoking it
+  * [Ecto.Repo] Support new style child spec from adapters
+
+## v3.0.2 (2018-11-17)
+
+### Bug fixes
+
+  * [Ecto.LogEntry] Bring old Ecto.LogEntry APIs back for compatibility
+  * [Ecto.Repo] Consider non-joined fields when merging preloaded assocs only at root
+  * [Ecto.Repo] Take field sources into account in :replace_all_fields upsert option
+  * [Ecto.Type] Convert `:utc_datetime` to `DateTime` when sending it to adapters
+
+## v3.0.1 (2018-11-03)
+
+### Bug fixes
+
+  * [Ecto.Query] Ensure parameter order is preserved when using more than 32 parameters
+  * [Ecto.Query] Consider query prefix when planning association joins
+  * [Ecto.Repo] Consider non-joined fields as unique parameters when merging preloaded query assocs
+
+## v3.0.0 (2018-10-29)
+
+Note this version includes changes from `ecto` and `ecto_sql` but in future releases all `ecto_sql` entries will be listed in their own CHANGELOG.
+
+### Enhancements
+
+  * [Ecto.Adapters.MySQL] Add ability to specify cli_protocol for `ecto.create` and `ecto.drop` commands
+  * [Ecto.Adapters.PostgreSQL] Add ability to specify maintenance database name for PostgreSQL adapter for `ecto.create` and `ecto.drop` commands
+  * [Ecto.Changeset] Store constraint name in error metadata for constraints
+  * [Ecto.Changeset] Add `validations/1` and `constraints/1` instead of allowing direct access on the struct fields
+  * [Ecto.Changeset] Add `:force_update` option when casting relations, to force an update even if there are no changes
+  * [Ecto.Migration] Migrations now lock the migrations table in order to avoid concurrent migrations in a cluster. The type of lock can be configured via the `:migration_lock` repository configuration and defaults to "FOR UPDATE" or disabled if set to nil
+  * [Ecto.Migration] Add `:migration_default_prefix` repository configuration
+  * [Ecto.Migration] Add reversible version of `remove/2` subcommand
+  * [Ecto.Migration] Add support for non-empty arrays as defaults in migrations
+  * [Ecto.Migration] Add support for logging notices/alerts/warnings when running migrations (only supported by Postgres currently)
+  * [Ecto.Migrator] Warn when migrating and there is a higher version already migrated in the database
+  * [Ecto.Multi] Add support for anonymous functions in `insert/4`, `update/4`, `insert_or_update/4`, and `delete/4`
+  * [Ecto.Query] Support tuples in `where` and `having`, allowing queries such as `where: {p.foo, p.bar} > {^foo, ^bar}`
+  * [Ecto.Query] Support arithmetic operators in queries as a thin layer around the DB functionality
+  * [Ecto.Query] Allow joins in queries to be named via `:as` and allow named bindings
+  * [Ecto.Query] Support excluding specific join types in `exclude/2`
+  * [Ecto.Query] Allow virtual field update in subqueries
+  * [Ecto.Query] Support `coalesce/2` in queries, such as `select: coalesce(p.title, p.old_title)`
+  * [Ecto.Query] Support `filter/2` in queries, such as `select: filter(count(p.id), p.public == true)`
+  * [Ecto.Query] The `:prefix` and `:hints` options are now supported on both `from` and `join` expressions
+  * [Ecto.Query] Support `:asc_nulls_last`, `:asc_nulls_first`, `:desc_nulls_last`, and `:desc_nulls_first` in `order_by`
+  * [Ecto.Query] Allow variables (sources) to be given in queries, for example, useful for invoking functions, such as `fragment("some_function(?)", p)`
+  * [Ecto.Query] Add support for `union`, `union_all`, `intersection`, `intersection_all`, `except` and `except_all`
+  * [Ecto.Query] Add support for `windows` and `over`
+  * [Ecto.Query] Raise when comparing a string with a charlist during planning
+  * [Ecto.Repo] Only start transactions if an association or embed has changed, this reduces the overhead during repository operations
+  * [Ecto.Repo] Support `:replace_all_except_primary_key` as `:on_conflict` strategy
+  * [Ecto.Repo] Support `{:replace, fields}` as `:on_conflict` strategy
+  * [Ecto.Repo] Support `:unsafe_fragment` as `:conflict_target`
+  * [Ecto.Repo] Support `select` in queries given to `update_all` and `delete_all`
+  * [Ecto.Repo] Add `Repo.exists?/2`
+  * [Ecto.Repo] Add `Repo.checkout/2` - useful when performing multiple operations in short-time to interval, allowing the pool to be bypassed
+  * [Ecto.Repo] Add `:stale_error_field` to `Repo.insert/update/delete` that converts `Ecto.StaleEntryError` into a changeset error. The message can also be set with `:stale_error_message`
+  * [Ecto.Repo] Preloading now only sorts results by the relationship key instead of sorting by the whole struct
+  * [Ecto.Schema] Allow `:where` option to be given to `has_many`/`has_one`/`belongs_to`/`many_to_many`
+
+### Bug fixes
+
+  * [Ecto.Inspect] Do not fail when inspecting query expressions which have a number of bindings more than bindings available
+  * [Ecto.Migration] Keep double underscores on autogenerated index names to be consistent with changesets
+  * [Ecto.Query] Fix `Ecto.Query.API.map/2` for single nil column with join
+  * [Ecto.Migration] Ensure `create_if_not_exists` is properly reversible
+  * [Ecto.Repo] Allow many_to_many associations to be preloaded via a function (before the behaviour was erratic)
+  * [Ecto.Schema] Make autogen ID loading work with custom type
+  * [Ecto.Schema] Make `updated_at` have the same value as `inserted_at`
+  * [Ecto.Schema] Ensure all fields are replaced with `on_conflict: :replace_all/:replace_all_except_primary_key` and not only the fields sent as changes
+  * [Ecto.Type] Return `:error` when casting NaN or infinite decimals
+  * [mix ecto.migrate] Properly run migrations after ECTO_EDITOR changes
+  * [mix ecto.migrations] List migrated versions even if the migration file is deleted
+  * [mix ecto.load] The task now fails on SQL errors on Postgres
+
+### Deprecations
+
+Although Ecto 3.0 is a major bump version, the functionality below emits deprecation warnings to ease the migration process. The functionality below will be removed in future Ecto 3.1+ releases.
+
+  * [Ecto.Changeset] Passing a list of binaries to `cast/3` is deprecated, please pass a list of atoms instead
+  * [Ecto.Multi] `Ecto.Multi.run/3` now receives the repo in which the transaction is executing as the first argument to functions, and the changes so far as the second argument
+  * [Ecto.Query] `join/5` now expects `on: expr` as last argument instead of simply `expr`. This was done in order to properly support the `:as`, `:hints` and `:prefix` options
+  * [Ecto.Repo] The `:returning` option for `update_all` and `delete_all` has been deprecated as those statements now support `select` clauses
+  * [Ecto.Repo] Passing `:adapter` via config is deprecated in favor of passing it on `use Ecto.Repo`
+  * [Ecto.Repo] The `:loggers` configuration is deprecated in favor of "Telemetry Events"
+
+### Backwards incompatible changes
+
+  * [Ecto.DateTime] `Ecto.Date`, `Ecto.Time` and `Ecto.DateTime` were previously deprecated and have now been removed
+  * [Ecto.DataType] `Ecto.DataType` protocol has been removed
+  * [Ecto.Migration] Automatically inferred index names may differ in Ecto v3.0 for indexes on complex column names
+  * [Ecto.Multi] `Ecto.Multi.run/5` now receives the repo in which the transaction is executing as the first argument to functions, and the changes so far as the second argument
+  * [Ecto.Query] A `join` no longer wraps `fragment` in parentheses. In some cases, such as common table expressions, you will have to explicitly wrap the fragment in parens.
+  * [Ecto.Repo] The `on_conflict: :replace_all` option now will also send fields with default values to the database. If you prefer the old behaviour that only sends the changes in the changeset, you can set it to `on_conflict: {:replace, Map.keys(changeset.changes)}` (this change is also listed as a bug fix)
+  * [Ecto.Repo] The repository operations are no longer called from association callbacks - this behaviour was not guaranteed in previous versions but we are listing as backwards incompatible changes to help with users relying on this behaviour
+  * [Ecto.Repo] `:pool_timeout` is no longer supported in favor of a new queue system described in `DBConnection.start_link/2` under "Queue config". For most users, configuring `:timeout` is enough, as it now includes both queue and query time
+  * [Ecto.Schema] `:time`, `:naive_datetime` and `:utc_datetime` no longer keep microseconds information. If you want to keep microseconds, use `:time_usec`, `:naive_datetime_usec`, `:utc_datetime_usec`
+  * [Ecto.Schema] The `@schema_prefix` option now only affects the `from`/`join` of where the schema is used and no longer the whole query
+  * [Ecto.Schema.Metadata] The `source` key no longer returns a tuple of the schema_prefix and the table/collection name. It now returns just the table/collection string. You can now access the schema_prefix via the `prefix` key.
+  * [Mix.Ecto] `Mix.Ecto.ensure_started/2` has been removed. However, in Ecto 2.2 the  `Mix.Ecto` module was not considered part of the public API and should not have been used but we are listing this for guidance.
+
+### Adapter changes
+
+  * [Ecto.Adapter] Split `Ecto.Adapter` into `Ecto.Adapter.Queryable` and `Ecto.Adapter.Schema` to provide more granular repository APIs
+  * [Ecto.Adapter] The `:sources` field in `query_meta` now contains three elements tuples with `{source, schema, prefix}` in order to support `from`/`join` prefixes (#2572)
+  * [Ecto.Adapter] The database types `time`, `utc_datetime` and `naive_datetime` should translate to types with seconds precision while the database types `time_usec`, `utc_datetime_usec` and `naive_datetime_usec` should have microseconds precision (#2291)
+  * [Ecto.Adapter] The `on_conflict` argument for `insert` and `insert_all` no longer receives a `{:replace_all, list(), atom()}` tuple. Instead, it receives a `{fields :: [atom()], list(), atom()}` where `fields` is a list of atoms of the fields to be replaced (#2181)
+  * [Ecto.Adapter] `insert`/`update`/`delete` now receive both `:source` and `:prefix` fields instead of a single `:source` field with both `source` and `prefix` in it (#2490)
+  * [Ecto.Adapter.Migration] A new `lock_for_migration/4` callback has been added. It is implemented by default by `Ecto.Adapters.SQL` (#2215)
+  * [Ecto.Adapter.Migration] The `execute_ddl` should now return `{:ok, []}` to make space for returning notices/hints/warnings in the future (adapters leveraging `Ecto.Adapters.SQL` do not have to perform any change)
+  * [Ecto.Query] The `from` field in `Ecto.Query` now returns a `Ecto.Query.FromExpr` with the `:source` field, unifying the behaviour in `from` and `join` expressions (#2497)
+  * [Ecto.Query] Tuple expressions are now supported in queries. For example, `where: {p.foo, p.bar} > {p.bar, p.baz}` should translate to `WHERE (p.foo, p.bar) > (p.bar, p.baz)` in SQL databases. Adapters should be changed to handle `{:{}, meta, exprs}` in the query AST (#2344)
+  * [Ecto.Query] Adapters should support the following arithmetic operators in queries `+`, `-`, `*` and `/` (#2400)
+  * [Ecto.Query] Adapters should support `filter/2` in queries, as in `select: filter(count(p.id), p.public == true)` (#2487)
+
+## Previous versions
+
+  * See the CHANGELOG.md [in the v2.2 branch](https://github.com/elixir-ecto/ecto/blob/v2.2/CHANGELOG.md)

deps/ecto/README.md

@@ -0,0 +1,200 @@
+<img width="250" src="https://github.com/elixir-ecto/ecto/raw/master/guides/images/logo.png#gh-light-mode-only" alt="Ecto">
+<img width="250" src="https://github.com/elixir-ecto/ecto/raw/master/guides/images/logo-white.png#gh-dark-mode-only" alt="Ecto">
+
+---
+
+[![Build Status](https://github.com/elixir-ecto/ecto/workflows/CI/badge.svg)](https://github.com/elixir-ecto/ecto/actions) [![Hex.pm](https://img.shields.io/hexpm/v/ecto.svg)](https://hex.pm/packages/ecto) [![Documentation](https://img.shields.io/badge/documentation-gray)](https://hexdocs.pm/ecto/)
+
+## Installation
+
+Add `:ecto` to the list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:ecto, "~> 3.10"}
+  ]
+end
+```
+
+## About
+
+Ecto is a toolkit for data mapping and language integrated query for Elixir. Here is an example:
+
+```elixir
+# In your config/config.exs file
+config :my_app, ecto_repos: [Sample.Repo]
+
+config :my_app, Sample.Repo,
+  database: "ecto_simple",
+  username: "postgres",
+  password: "postgres",
+  hostname: "localhost",
+  port: "5432"
+
+# In your application code
+defmodule Sample.Repo do
+  use Ecto.Repo,
+    otp_app: :my_app,
+    adapter: Ecto.Adapters.Postgres
+end
+
+defmodule Sample.Weather do
+  use Ecto.Schema
+
+  schema "weather" do
+    field :city     # Defaults to type :string
+    field :temp_lo, :integer
+    field :temp_hi, :integer
+    field :prcp,    :float, default: 0.0
+  end
+end
+
+defmodule Sample.App do
+  import Ecto.Query
+  alias Sample.{Weather, Repo}
+
+  def keyword_query do
+    query =
+      from w in Weather,
+           where: w.prcp > 0 or is_nil(w.prcp),
+           select: w
+
+    Repo.all(query)
+  end
+
+  def pipe_query do
+    Weather
+    |> where(city: "Kraków")
+    |> order_by(:temp_lo)
+    |> limit(10)
+    |> Repo.all
+  end
+end
+```
+
+Ecto is commonly used to interact with databases, such as PostgreSQL and MySQL via [Ecto.Adapters.SQL](https://hexdocs.pm/ecto_sql) ([source code](https://github.com/elixir-ecto/ecto_sql)). Ecto is also commonly used to map data from any source into Elixir structs, whether they are backed by a database or not.
+
+See the [getting started guide](https://hexdocs.pm/ecto/getting-started.html) and the [online documentation](https://hexdocs.pm/ecto) for more information. Other resources available are:
+
+  * [Programming Ecto](https://pragprog.com/titles/wmecto/programming-ecto/), by Darin Wilson and Eric Meadows-Jönsson, which guides you from fundamentals up to advanced concepts
+
+  * [The Little Ecto Cookbook](https://dashbit.co/ebooks/the-little-ecto-cookbook), a free ebook by Dashbit, which is a curation of the existing Ecto guides with some extra contents
+
+## Usage
+
+You need to add both Ecto and the database adapter as a dependency to your `mix.exs` file. The supported databases and their adapters are:
+
+| Database   | Ecto Adapter             | Dependencies                                     |
+| :--------- | :----------------------- | :----------------------------------------------- |
+| PostgreSQL | Ecto.Adapters.Postgres   | [ecto_sql][ecto_sql] + [postgrex][postgrex]      |
+| MySQL      | Ecto.Adapters.MyXQL      | [ecto_sql][ecto_sql] + [myxql][myxql]            |
+| MSSQL      | Ecto.Adapters.Tds        | [ecto_sql][ecto_sql] + [tds][tds]                |
+| SQLite3    | Ecto.Adapters.SQLite3    | [ecto_sqlite3][ecto_sqlite3]                     |
+| ClickHouse | Ecto.Adapters.ClickHouse | [ecto_ch][ecto_ch]                               |
+| ETS        | Etso                     | [etso][etso]                                     |
+
+[ecto_sql]: https://github.com/elixir-ecto/ecto_sql
+[postgrex]: https://github.com/elixir-ecto/postgrex
+[myxql]: https://github.com/elixir-ecto/myxql
+[tds]: https://github.com/livehelpnow/tds
+[ecto_sqlite3]: https://github.com/elixir-sqlite/ecto_sqlite3
+[etso]: https://github.com/evadne/etso
+[ecto_ch]: https://github.com/plausible/ecto_ch
+
+For example, if you want to use PostgreSQL, add to your `mix.exs` file:
+
+```elixir
+defp deps do
+  [
+    {:ecto_sql, "~> 3.0"},
+    {:postgrex, ">= 0.0.0"}
+  ]
+end
+```
+
+Then run `mix deps.get` in your shell to fetch the dependencies. If you want to use another database, just choose the proper dependency from the table above.
+
+Finally, in the repository definition, you will need to specify the `adapter:` respective to the chosen dependency. For PostgreSQL it is:
+
+```elixir
+defmodule MyApp.Repo do
+  use Ecto.Repo,
+    otp_app: :my_app,
+    adapter: Ecto.Adapters.Postgres,
+  ...
+```
+
+## Supported Versions
+
+| Branch            | Support                  |
+| ----------------- | ------------------------ |
+| v3.12             | Bug fixes                |
+| v3.11             | Security patches only    |
+| v3.10             | Security patches only    |
+| v3.9              | Security patches only    |
+| v3.8              | Security patches only    |
+| v3.7 and earlier  | Unsupported              |
+
+With version 3.0, Ecto API has become stable. Our main focus is on providing
+bug fixes and incremental changes.
+
+## Important links
+
+  * [Documentation](https://hexdocs.pm/ecto)
+  * [Mailing list](https://groups.google.com/forum/#!forum/elixir-ecto)
+  * [Examples](https://github.com/elixir-ecto/ecto/tree/master/examples)
+
+## Running tests
+
+Clone the repo and fetch its dependencies:
+
+    $ git clone https://github.com/elixir-ecto/ecto.git
+    $ cd ecto
+    $ mix deps.get
+    $ mix test
+
+Note that `mix test` does not run the tests in the `integration_test` folder. To run integration tests, you can clone `ecto_sql` in a sibling directory and then run its integration tests with the `ECTO_PATH` environment variable pointing to your Ecto checkout:
+
+    $ cd ..
+    $ git clone https://github.com/elixir-ecto/ecto_sql.git
+    $ cd ecto_sql
+    $ mix deps.get
+    $ ECTO_PATH=../ecto mix test.all
+
+### Running containerized tests
+
+It is also possible to run the integration tests under a containerized environment using [earthly](https://earthly.dev/get-earthly):
+
+    $ earthly -P +all
+
+You can also use this to interactively debug any failing integration tests using:
+
+    $ earthly -P -i --build-arg ELIXIR_BASE=1.8.2-erlang-21.3.8.21-alpine-3.13.1 +integration-test
+
+Then once you enter the containerized shell, you can inspect the underlying databases with the respective commands:
+
+    PGPASSWORD=postgres psql -h 127.0.0.1 -U postgres -d postgres ecto_test
+    MYSQL_PASSWORD=root mysql -h 127.0.0.1 -uroot -proot ecto_test
+    sqlcmd -U sa -P 'some!Password'
+
+## Logo
+
+"Ecto" and the Ecto logo are Copyright (c) 2020 Dashbit.
+
+The Ecto logo was designed by [Dane Wesolko](https://www.danewesolko.com).
+
+## License
+
+Copyright (c) 2013 Plataformatec \
+Copyright (c) 2020 Dashbit
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

deps/makeup_erlang/.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

deps/makeup_erlang/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2019 by the respective authors (see AUTHORS file).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

deps/makeup_erlang/README.md

@@ -0,0 +1,22 @@
+# MakeupErlang
+
+[![CI](https://github.com/elixir-makeup/makeup_erlang/actions/workflows/ci.yml/badge.svg)](https://github.com/elixir-makeup/makeup_erlang/actions/workflows/ci.yml)
+[![Module Version](https://img.shields.io/hexpm/v/makeup_erlang.svg)](https://hex.pm/packages/makeup_erlang)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-lightgreen.svg)](https://hexdocs.pm/makeup_erlang)
+
+A [Makeup](https://github.com/elixir-makeup/makeup/) lexer for the `Erlang` language.
+
+## Installation
+
+Add `makeup_erlang` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:makeup_erlang, "~> 1.0"}
+  ]
+end
+```
+
+The lexer will automatically register itself with `Makeup` for the languages `erlang` and `erl`
+as well as the extensions `.erl`, `.hrl` and `.escript`.

deps/makeup_erlang/hex_metadata.config

@@ -0,0 +1,23 @@
+{<<"links">>,
+ [{<<"GitHub">>,<<"https://github.com/elixir-makeup/makeup_erlang">>}]}.
+{<<"name">>,<<"makeup_erlang">>}.
+{<<"version">>,<<"1.0.3">>}.
+{<<"description">>,<<"Erlang lexer for the Makeup syntax highlighter.">>}.
+{<<"elixir">>,<<"~> 1.6">>}.
+{<<"files">>,
+ [<<"lib">>,<<"lib/makeup">>,<<"lib/makeup/lexers">>,
+  <<"lib/makeup/lexers/erlang_lexer.ex">>,
+  <<"lib/makeup/lexers/erlang_lexer">>,
+  <<"lib/makeup/lexers/erlang_lexer/testing.ex">>,
+  <<"lib/makeup/lexers/erlang_lexer/application.ex">>,
+  <<"lib/makeup/lexers/erlang_lexer/helper.ex">>,<<".formatter.exs">>,
+  <<"mix.exs">>,<<"README.md">>,<<"LICENSE">>]}.
+{<<"app">>,<<"makeup_erlang">>}.
+{<<"licenses">>,[<<"BSD-2-Clause">>]}.
+{<<"requirements">>,
+ [[{<<"name">>,<<"makeup">>},
+   {<<"app">>,<<"makeup">>},
+   {<<"optional">>,false},
+   {<<"requirement">>,<<"~> 1.0">>},
+   {<<"repository">>,<<"hexpm">>}]]}.
+{<<"build_tools">>,[<<"mix">>]}.

deps/makeup_erlang/lib/makeup/lexers/erlang_lexer.ex

@@ -0,0 +1,463 @@
+defmodule Makeup.Lexers.ErlangLexer do
+  @moduledoc """
+  A `Makeup` lexer for the `Erlang` language.
+  """
+
+  @behaviour Makeup.Lexer
+
+  import NimbleParsec
+  import Makeup.Lexer.Combinators
+  import Makeup.Lexer.Groups
+  import Makeup.Lexers.ErlangLexer.Helper
+
+  ###################################################################
+  # Step #1: tokenize the input (into a list of tokens)
+  ###################################################################
+
+  whitespace = ascii_string([?\s, ?\f, ?\r, ?\n, ?\t], min: 1) |> token(:whitespace)
+
+  # This is the combinator that ensures that the lexer will never reject a file
+  # because of invalid input syntax
+  any_char = utf8_char([]) |> token(:error)
+
+  comment =
+    ascii_char([?%])
+    |> optional(utf8_string([not: ?\n], min: 1))
+    |> token(:comment_single)
+
+  hashbang =
+    string("\n#!")
+    |> utf8_string([not: ?\n], min: 1)
+    |> string("\n")
+    |> token(:comment_hashbang)
+
+  escape_octal = ascii_string([?0..?7], min: 1, max: 3)
+
+  escape_char = ascii_char([?\b, ?\d, ?\e, ?\f, ?\n, ?\r, ?\s, ?\t, ?\v, ?\', ?\", ?\\])
+
+  escape_hex =
+    choice([
+      string("x") |> ascii_string([?0..?9, ?a..?f, ?A..?F], 2),
+      string("x{") |> ascii_string([?0..?9, ?a..?f, ?A..?F], min: 1) |> string("}")
+    ])
+
+  escape_ctrl = string("^") |> ascii_char([?a..?z, ?A..?Z])
+
+  escape =
+    choice([
+      escape_char,
+      escape_octal,
+      escape_hex,
+      escape_ctrl
+    ])
+
+  numeric_base =
+    choice([
+      ascii_char([?1..?2]) |> ascii_char([?0..?9]),
+      string("3") |> ascii_char([?0..?6]),
+      ascii_char([?2..?9])
+    ])
+
+  # Numbers
+  digits = ascii_string([?0..?9], min: 1)
+
+  number_integer =
+    optional(ascii_char([?+, ?-]))
+    |> concat(digits)
+    |> token(:number_integer)
+
+  number_integer_in_weird_base =
+    optional(ascii_char([?+, ?-]))
+    |> concat(numeric_base)
+    |> string("#")
+    |> ascii_string([?0..?9, ?a..?z, ?A..?Z], min: 1)
+    |> token(:number_integer)
+
+  # Floating point numbers
+  float_scientific_notation_part =
+    ascii_string([?e, ?E], 1)
+    |> optional(string("-"))
+    |> concat(digits)
+
+  number_float =
+    optional(ascii_char([?+, ?-]))
+    |> concat(digits)
+    |> string(".")
+    |> concat(digits)
+    |> optional(float_scientific_notation_part)
+    |> token(:number_float)
+
+  variable_name =
+    ascii_string([?A..?Z, ?_], 1)
+    |> optional(ascii_string([?a..?z, ?_, ?0..?9, ?A..?Z], min: 1))
+
+  simple_atom_name =
+    ascii_string([?a..?z], 1)
+    |> optional(ascii_string([?a..?z, ?_, ?@, ?0..?9, ?A..?Z], min: 1))
+    |> reduce({Enum, :join, []})
+
+  single_quote_escape = string("\\'")
+
+  quoted_atom_name_middle =
+    lookahead_not(string("'"))
+    |> choice([
+      single_quote_escape,
+      utf8_string([not: ?\n, not: ?', not: ?\\], min: 1),
+      escape
+    ])
+
+  quoted_atom_name =
+    string("'")
+    |> repeat(quoted_atom_name_middle)
+    |> concat(string("'"))
+
+  atom_name =
+    choice([
+      simple_atom_name,
+      quoted_atom_name
+    ])
+
+  atom = token(atom_name, :string_symbol)
+
+  namespace =
+    token(atom_name, :name_class)
+    |> concat(token(":", :punctuation))
+
+  function =
+    atom_name
+    |> lexeme()
+    |> token(:name_function)
+    |> concat(optional(whitespace))
+    |> concat(token("(", :punctuation))
+
+  # Can also be a function name
+  variable =
+    variable_name
+    # Check if you need to use the lexeme parser
+    # (i.e. if you need the token value to be a string)
+    # If not, just delete the lexeme parser
+    |> lexeme()
+    |> token(:name)
+
+  macro_name = choice([variable_name, atom_name])
+
+  macro =
+    string("?")
+    |> concat(macro_name)
+    |> token(:name_constant)
+
+  label =
+    string("#")
+    |> concat(atom_name)
+    |> optional(string(".") |> concat(atom_name))
+    |> token(:name_label)
+
+  character =
+    string("$")
+    |> choice([
+      string("\\") |> utf8_char([]),
+      utf8_char(not: ?\\)
+    ])
+    |> token(:string_char)
+
+  string_interpol =
+    string("~")
+    |> optional(ascii_string([?0..?9, ?., ?*], min: 1))
+    |> ascii_char(to_charlist("~#+BPWXb-ginpswx"))
+    |> token(:string_interpol)
+
+  escape_double_quote = string(~s/\\"/)
+  erlang_string = string_like(~s/"/, ~s/"/, [escape_double_quote, string_interpol], :string)
+
+  escaped_char =
+    string("\\")
+    |> utf8_string([], 1)
+    |> token(:string_escape)
+
+  triple_quoted_string =
+    lookahead_string(string(~s/"""\n/), string(~s/\n"""/), [escaped_char, string_interpol])
+
+  sigil_delimiters = [
+    {~s["""\n], ~s[\n"""]},
+    {"'''\n", "\n'''"},
+    {"\"", "\""},
+    {"'", "'"},
+    {"/", "/"},
+    {"{", "}"},
+    {"[", "]"},
+    {"(", ")"},
+    {"<", ">"},
+    {"|", "|"},
+    {"`", "`"},
+    {"#", "#"}
+  ]
+
+  default_sigil_interpol =
+    for {ldelim, rdelim} <- sigil_delimiters do
+      sigil(ldelim, rdelim, nil, [escaped_char, string_interpol])
+    end
+
+  sigils_interpol =
+    for {ldelim, rdelim} <- sigil_delimiters do
+      sigil(ldelim, rdelim, [?b, ?s], [escaped_char, string_interpol])
+    end
+
+  sigils_no_interpol =
+    for {ldelim, rdelim} <- sigil_delimiters do
+      sigil(ldelim, rdelim, [?B, ?S], [string_interpol])
+    end
+
+  all_sigils = default_sigil_interpol ++ sigils_interpol ++ sigils_no_interpol
+
+  # Combinators that highlight expressions surrounded by a pair of delimiters.
+  punctuation =
+    word_from_list(
+      [","] ++ ~w[\[ \] : _ @ \" . \#{ { } ( ) | ; => := << >> || -> \# &&],
+      :punctuation
+    )
+
+  tuple = many_surrounded_by(parsec(:root_element), "{", "}")
+
+  syntax_operators =
+    word_from_list(
+      ~W[+ - +? ++ = == -- * / < > /= =:= =/= =< >= ==? <- <:- <= <:= ! ? ?!],
+      :operator
+    )
+
+  record =
+    token(string("#"), :operator)
+    |> concat(atom)
+    |> choice([
+      token("{", :punctuation),
+      token(".", :punctuation)
+    ])
+
+  # We need to match on the new line here as to not tokenize a function call as a module attribute.
+  # Without the newline matching, the expression `a(X) - b(Y)` would tokenize
+  # `b(Y)` as a module attribute definition instead of a function call.
+  module_attribute =
+    token("\n", :whitespace)
+    |> optional(whitespace)
+    |> concat(token("-", :punctuation))
+    |> optional(whitespace)
+    |> concat(atom_name |> token(:name_attribute))
+    |> optional(whitespace)
+    |> optional(token("(", :punctuation))
+
+  function_arity =
+    atom
+    |> concat(token("/", :punctuation))
+    |> concat(number_integer)
+
+  # Erlang prompt
+  erl_prompt =
+    ascii_string([?\s, ?\r, ?\t], min: 0)
+    |> string("\n")
+    |> token(:whitespace)
+    |> concat(
+      optional(string("(") |> concat(atom_name) |> string(")"))
+      |> optional(digits)
+      |> string("> ")
+      |> token(:generic_prompt, %{selectable: false})
+    )
+
+  # Error in shell
+  erl_shell_error =
+    token("\n", :whitespace)
+    |> concat(
+      string("* ")
+      |> utf8_string([not: ?\n], min: 1)
+      |> token(:generic_traceback)
+    )
+
+  erl_shell_multiline_error =
+    token("\n", :whitespace)
+    |> concat(
+      string("** ")
+      |> utf8_string([not: ?\n], min: 1)
+      |> repeat(
+        string("\n    ")
+        |> utf8_string([not: ?\n], min: 1)
+      )
+      |> token(:generic_traceback)
+    )
+
+  # Tag the tokens with the language name.
+  # This makes it easier to postprocess files with multiple languages.
+  @doc false
+  def __as_erlang_language__({ttype, meta, value}) do
+    {ttype, Map.put(meta, :language, :erlang), value}
+  end
+
+  root_element_combinator =
+    choice(
+      [
+        erl_prompt,
+        erl_shell_error,
+        erl_shell_multiline_error,
+        module_attribute,
+        hashbang,
+        whitespace,
+        comment,
+        triple_quoted_string,
+        erlang_string
+      ] ++
+        all_sigils ++
+        [
+          record,
+          punctuation,
+          # `tuple` might be unnecessary
+          tuple,
+          syntax_operators,
+          # Numbers
+          number_integer_in_weird_base,
+          number_float,
+          number_integer,
+          # Variables
+          variable,
+          namespace,
+          function_arity,
+          function,
+          atom,
+          macro,
+          character,
+          label,
+          # If we can't parse any of the above, we highlight the next character as an error
+          # and proceed from there.
+          # A lexer should always consume any string given as input.
+          any_char
+        ]
+    )
+
+  ##############################################################################
+  # Semi-public API: these two functions can be used by someone who wants to
+  # embed this lexer into another lexer, but other than that, they are not
+  # meant to be used by end-users
+  ##############################################################################
+
+  @impl Makeup.Lexer
+  defparsec(
+    :root_element,
+    root_element_combinator |> map({__MODULE__, :__as_erlang_language__, []})
+  )
+
+  @impl Makeup.Lexer
+  defparsec(
+    :root,
+    repeat(parsec(:root_element))
+  )
+
+  ###################################################################
+  # Step #2: postprocess the list of tokens
+  ###################################################################
+
+  @keywords ~W[after begin case catch cond end fun if let of query receive try when maybe else]
+
+  @builtins ~W[
+    abs append_element apply atom_to_list binary_to_list bitstring_to_list
+    binary_to_term bit_size bump_reductions byte_size cancel_timer
+    check_process_code delete_module demonitor disconnect_node display
+    element erase exit float float_to_list fun_info fun_to_list
+    function_exported garbage_collect get get_keys group_leader hash
+    hd integer_to_list iolist_to_binary iolist_size is_atom is_binary
+    is_bitstring is_boolean is_builtin is_float is_function is_integer
+    is_list is_number is_pid is_port is_process_alive is_record is_reference
+    is_tuple length link list_to_atom list_to_binary list_to_bitstring
+    list_to_existing_atom list_to_float list_to_integer list_to_pid
+    list_to_tuple load_module localtime_to_universaltime make_tuple
+    md5 md5_final md5_update memory module_loaded monitor monitor_node
+    node nodes open_port phash phash2 pid_to_list port_close port_command
+    port_connect port_control port_call port_info port_to_list
+    process_display process_flag process_info purge_module put read_timer
+    ref_to_list register resume_processround send send_after send_nosuspend
+    set_cookie setelement size spawn spawn_link spawn_monitor spawn_opt
+    split_binary start_timer statistics suspend_process system_flag
+    system_info system_monitor system_profile term_to_binary tl trace
+    trace_delivered trace_info trace_pattern trunc tuple_size tuple_to_list
+    universaltime_to_localtime unlink unregister whereis
+  ]
+
+  @word_operators ~W[and andalso band bnot bor bsl bsr bxor div not or orelse rem xor]
+
+  defp postprocess_helper([{:string_symbol, meta, value} | tokens]) when value in @keywords,
+    do: [{:keyword, meta, value} | postprocess_helper(tokens)]
+
+  defp postprocess_helper([{:string_symbol, meta, value} | tokens]) when value in @builtins,
+    do: [{:name_builtin, meta, value} | postprocess_helper(tokens)]
+
+  defp postprocess_helper([{:string_symbol, meta, value} | tokens]) when value in @word_operators,
+    do: [{:operator_word, meta, value} | postprocess_helper(tokens)]
+
+  defp postprocess_helper([token | tokens]), do: [token | postprocess_helper(tokens)]
+
+  defp postprocess_helper([]), do: []
+
+  # By default, return the list of tokens unchanged
+  @impl Makeup.Lexer
+  def postprocess(tokens, _opts \\ []), do: postprocess_helper(tokens)
+
+  #######################################################################
+  # Step #3: highlight matching delimiters
+  # By default, this includes delimiters that are used in many languages,
+  # but feel free to delete these or add more.
+  #######################################################################
+
+  @impl Makeup.Lexer
+  defgroupmatcher(:match_groups,
+    parentheses: [
+      open: [[{:punctuation, %{language: :erlang}, "("}]],
+      close: [[{:punctuation, %{language: :erlang}, ")"}]]
+    ],
+    list: [
+      open: [
+        [{:punctuation, %{language: :erlang}, "["}]
+      ],
+      close: [
+        [{:punctuation, %{language: :erlang}, "]"}]
+      ]
+    ],
+    binary: [
+      open: [
+        [{:punctuation, %{language: :erlang}, "<<"}]
+      ],
+      close: [
+        [{:punctuation, %{language: :erlang}, ">>"}]
+      ]
+    ],
+    tuple: [
+      open: [
+        [{:punctuation, %{language: :erlang}, "{"}]
+      ],
+      close: [
+        [{:punctuation, %{language: :erlang}, "}"}]
+      ]
+    ],
+    map: [
+      open: [
+        [{:punctuation, %{language: :erlang}, "\#{"}]
+      ],
+      close: [
+        [{:punctuation, %{language: :erlang}, "}"}]
+      ]
+    ]
+  )
+
+  defp remove_initial_newline([{ttype, meta, text} | tokens]) do
+    case to_string(text) do
+      "\n" -> tokens
+      "\n" <> rest -> [{ttype, meta, rest} | tokens]
+    end
+  end
+
+  # Finally, the public API for the lexer
+  @impl Makeup.Lexer
+  def lex(text, opts \\ []) do
+    group_prefix = Keyword.get(opts, :group_prefix, random_prefix(10))
+    {:ok, tokens, "", _, _, _} = root("\n" <> text)
+
+    tokens
+    |> remove_initial_newline()
+    |> postprocess()
+    |> match_groups(group_prefix)
+  end
+end

deps/makeup_erlang/lib/makeup/lexers/erlang_lexer/application.ex

@@ -0,0 +1,17 @@
+defmodule Makeup.Lexers.ErlangLexer.Application do
+  @moduledoc false
+  use Application
+
+  alias Makeup.Registry
+  alias Makeup.Lexers.ErlangLexer
+
+  def start(_type, _args) do
+    Registry.register_lexer(ErlangLexer,
+      options: [],
+      names: ["erlang", "erl"],
+      extensions: ["erl", "hrl", "escript"]
+    )
+
+    Supervisor.start_link([], strategy: :one_for_one)
+  end
+end

deps/makeup_erlang/lib/makeup/lexers/erlang_lexer/helper.ex

@@ -0,0 +1,45 @@
+defmodule Makeup.Lexers.ErlangLexer.Helper do
+  @moduledoc false
+  import NimbleParsec
+  alias Makeup.Lexer.Combinators
+
+  def with_optional_separator(combinator, separator) when is_binary(separator) do
+    combinator |> repeat(string(separator) |> concat(combinator))
+  end
+
+  def sigil(ldelim, rdelim, nil, middle) do
+    lookahead_string(
+      string("~") |> string(ldelim),
+      string(rdelim),
+      middle
+    )
+  end
+
+  def sigil(ldelim, rdelim, ranges, middle) do
+    lookahead_string(
+      string("~") |> utf8_char(ranges) |> string(ldelim),
+      string(rdelim),
+      middle
+    )
+  end
+
+  def lookahead_string(left, right, middle) do
+    if middle == [] do
+      left
+      |> repeat(lookahead_not(right) |> concat(utf8_char([])))
+    else
+      choices = middle ++ [utf8_char([])]
+
+      left
+      |> repeat(lookahead_not(right) |> choice(choices))
+    end
+    |> concat(right)
+    |> post_traverse({__MODULE__, :build_string, []})
+  end
+
+  def build_string(rest, acc, context, line, offset) do
+    type = :string
+
+    Combinators.collect_raw_chars_and_binaries(rest, acc, context, line, offset, type, %{})
+  end
+end

deps/makeup_erlang/lib/makeup/lexers/erlang_lexer/testing.ex

@@ -0,0 +1,17 @@
+defmodule Makeup.Lexers.ErlangLexer.Testing do
+  # The tests need to be checked manually!!! (remove this line when they've been checked)
+  alias Makeup.Lexers.ErlangLexer
+  alias Makeup.Lexer.Postprocess
+
+  # This function has two purposes:
+  # 1. Ensure deterministic lexer output (no random prefix)
+  # 2. Convert the token values into binaries so that the output
+  #    is more obvious on visual inspection
+  #    (iolists are hard to parse by a human)
+  def lex(text) do
+    text
+    |> ErlangLexer.lex(group_prefix: "group")
+    |> Postprocess.token_values_to_binaries()
+    |> Enum.map(fn {ttype, meta, value} -> {ttype, Map.delete(meta, :language), value} end)
+  end
+end

deps/makeup_erlang/mix.exs

@@ -0,0 +1,63 @@
+defmodule MakeupErlang.Mixfile do
+  use Mix.Project
+
+  @version "1.0.3"
+  @url "https://github.com/elixir-makeup/makeup_erlang"
+
+  def project do
+    [
+      app: :makeup_erlang,
+      version: @version,
+      elixir: "~> 1.6",
+      start_permanent: Mix.env() == :prod,
+      deps: deps(),
+      package: package(),
+      name: "Makeup Erlang",
+      description: description(),
+      aliases: [docs: &build_docs/1]
+    ]
+  end
+
+  defp description do
+    """
+    Erlang lexer for the Makeup syntax highlighter.
+    """
+  end
+
+  defp package do
+    [
+      name: :makeup_erlang,
+      licenses: ["BSD-2-Clause"],
+      maintainers: ["Tiago Barroso <tmbb@campus.ul.pt>"],
+      links: %{"GitHub" => @url}
+    ]
+  end
+
+  def application do
+    [
+      mod: {Makeup.Lexers.ErlangLexer.Application, []},
+      extra_applications: [:logger]
+    ]
+  end
+
+  defp deps do
+    [
+      {:makeup, "~> 1.0"}
+    ]
+  end
+
+  defp build_docs(_) do
+    Mix.Task.run("compile")
+    ex_doc = Path.join(Mix.path_for(:escripts), "ex_doc")
+
+    unless File.exists?(ex_doc) do
+      raise "cannot build docs because escript for ex_doc is not installed, run \"mix escript.install hex ex_doc\""
+    end
+
+    paths = Path.join(Mix.Project.build_path(), "lib/*/ebin")
+    args = ["MakeupErlang", @version, Mix.Project.compile_path()]
+    opts = ~w[--main Makeup.Lexers.ErlangLexer --source-ref v#{@version} --source-url #{@url}]
+    System.cmd(ex_doc, args ++ ["--paths", paths] ++ opts)
+    Mix.shell().info("Docs built successfully")
+  end
+end

hf_deploy/Dockerfile

@@ -0,0 +1,33 @@
+FROM ghcr.io/livebook-dev/livebook:0.15.1
+
+# System deps for EXLA/NIFs
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    cmake \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set environment
+ENV LIVEBOOK_PORT=7860
+ENV LIVEBOOK_IP=0.0.0.0
+ENV LIVEBOOK_TOKEN=""
+ENV LIVEBOOK_IFRAME_PORT=7860
+ENV MIX_ENV=prod
+ENV BUMBLEBEE_CACHE_DIR=/data/bumblebee
+ENV XLA_TARGET=cpu
+
+WORKDIR /app
+
+# Create cache dirs
+RUN mkdir -p /data/bumblebee /data/livebook
+
+# Copy notebook and setup script
+COPY ml_e2e_template.livemd /app/ml_e2e_template.livemd
+COPY setup.livemd /app/setup.livemd
+COPY startup.sh /app/startup.sh
+RUN chmod +x /app/startup.sh
+
+EXPOSE 7860
+
+CMD ["/app/startup.sh"]

hf_deploy/README.md

@@ -0,0 +1,18 @@
+---
+title: ML in Elixir — Bumblebee + Hugging Face
+emoji: 🐝
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+license: apache-2.0
+tags:
+  - elixir
+  - livebook
+  - machine-learning
+  - bumblebee
+  - hugging-face
+  - nx
+  - axon
+---

hf_deploy/deploy.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Deploy to Hugging Face Spaces
+# Usage: ./deploy.sh <username> <space-name>
+#
+# Prerequisites:
+#   1. Install hf CLI: pip install huggingface_hub
+#   2. Login: hf auth login
+#   3. Have Docker installed
+
+set -e
+
+HF_USER="${1:?Usage: $0 <hf-username> <space-name>}"
+SPACE_NAME="${2:?Usage: $0 <hf-username> <space-name>}"
+REPO_ID="${HF_USER}/${SPACE_NAME}"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+echo "=== Deploying Livebook ML Template to HF Spaces ==="
+echo "Space: ${REPO_ID}"
+echo ""
+
+# Copy Livebook to deploy dir
+cp "${PROJECT_DIR}/ml_e2e_template.livemd" "${SCRIPT_DIR}/"
+
+# Clone or create the HF Space repo
+REPO_DIR="/tmp/hf-space-${SPACE_NAME}"
+if [ -d "${REPO_DIR}" ]; then
+  echo "Updating existing repo..."
+  cd "${REPO_DIR}"
+  git pull
+else
+  echo "Cloning Space repo..."
+  git clone "https://huggingface.co/spaces/${REPO_ID}" "${REPO_DIR}"
+  cd "${REPO_DIR}"
+fi
+
+# Copy deployment files
+cp "${SCRIPT_DIR}/Dockerfile" .
+cp "${SCRIPT_DIR}/startup.sh" .
+cp "${SCRIPT_DIR}/setup.livemd" .
+cp "${SCRIPT_DIR}/ml_e2e_template.livemd" .
+cp "${SCRIPT_DIR}/README.md" .
+
+# Push
+git add -A
+git diff --staged --quiet && echo "No changes to push." && exit 0
+
+git commit -m "Update Livebook ML template"
+git push
+
+echo ""
+echo "=== Deployed! ==="
+echo "Space URL: https://huggingface.co/spaces/${REPO_ID}"
+echo "It may take a few minutes for the build to complete."

hf_deploy/setup.livemd

@@ -0,0 +1,16 @@
+# Setup — installs deps on first cell run
+# This notebook runs automatically before ml_e2e_template.livemd
+
+Mix.install([
+  {:nx, "~> 0.11"},
+  {:axon, "~> 0.8"},
+  {:exla, "~> 0.11"},
+  {:bumblebee, "~> 0.6"},
+  {:kino, "~> 0.15"},
+  {:kino_vega_lite, "~> 0.1"},
+  {:vega_lite, "~> 0.1"},
+  {:stb_image, "~> 0.6"},
+  {:req, "~> 0.5"}
+])
+
+IO.puts("All dependencies installed successfully!")

hf_deploy/startup.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -e
+
+# Pre-download common models into cache (optional, speeds up first load)
+echo "=== ML in Elixir — Livebook Template ==="
+echo "Starting Livebook on port ${LIVEBOOK_PORT}..."
+
+# Launch Livebook
+exec /usr/local/bin/livebook server \
+  --port "${LIVEBOOK_PORT}" \
+  --default-url "/notebooks/ml_e2e_template.livemd"

hf_jobs_demo.py

@@ -0,0 +1,15 @@
+"""Demo script for HF Jobs
+
+Runs a tiny sentiment‑analysis pipeline and prints the result.
+"""
+
+# /// script
+# dependencies = ["transformers", "torch"]
+# ///
+
+from transformers import pipeline
+
+# Simple sentiment pipeline (uses a small DistilBERT model)
+sentiment = pipeline("sentiment-analysis")
+result = sentiment("Hugging Face Jobs are awesome!")
+print("Sentiment result:", result)

jax/ml_e2e_jax.ipynb

@@ -0,0 +1,633 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "toc_visible": true,
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🐝 ML in Elixir — JAX Companion\n",
+        "\n",
+        "This notebook mirrors the [Elixir Livebook template](../ml_e2e_template.livemd)\n",
+        "from *Machine Learning in Elixir* by Sean Moriarity, implemented in **JAX**.\n",
+        "\n",
+        "JAX is Google's numerical computing library — the closest Python counterpart to Elixir's **Nx**.\n",
+        "\n",
+        "| Elixir (Nx/Axon) | JAX (Python) | Purpose |\n",
+        "|-----------------|-------------|----------|\n",
+        "| `Nx` | `jax.numpy` | Tensors, ops |\n",
+        "| `Nx.Defn.grad` | `jax.grad` | Automatic differentiation |\n",
+        "| `EXLA` | `jax.jit` | JIT compilation / GPU |\n",
+        "| `Bumblebee` | `transformers` + `jax` | Pre-trained models |\n",
+        "| `Axon` | `flax` | Neural networks |\n",
+        "| `Nx.Serving` | `jax.lax.map` / `pmap` | Batched inference |\n",
+        "| `Kino` | `ipywidgets` | Interactive UI |"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 0 — Install & Configure"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "!pip install -q jax[cuda12]==0.4.35 flax optax transformers datasets accelerate scikit-learn numpy matplotlib"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import jax\n",
+        "import jax.numpy as jnp\n",
+        "from jax import grad, jit, vmap, pmap\n",
+        "import flax.linen as nn\n",
+        "import optax\n",
+        "from transformers import pipeline, AutoTokenizer, FlaxAutoModel\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.metrics import classification_report\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "device = jax.devices()[0]\n",
+        "print(f\"JAX version: {jax.__version__}\")\n",
+        "print(f\"Device: {device}\")\n",
+        "print(f\"Backend: {device.platform}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 1 — JAX Foundations (Nx equivalent)\n",
+        "\n",
+        "JAX provides NumPy-like API with automatic differentiation and JIT compilation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Tensors: Nx.tensor → jnp.array\n",
+        "scalar = jnp.float64(3.14)\n",
+        "vector = jnp.array([1.0, 2.0, 3.0])\n",
+        "matrix = jnp.array([[1, 2, 3], [4, 5, 6]])\n",
+        "\n",
+        "print(f\"scalar shape: {scalar.shape}, dtype: {scalar.dtype}\")\n",
+        "print(f\"vector shape: {vector.shape}, dtype: {vector.dtype}\")\n",
+        "print(f\"matrix shape: {matrix.shape}, dtype: {matrix.dtype}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Operations: Nx.add/multiply/dot → jnp.add/... (same API!)\n",
+        "a = jnp.array([1.0, 2.0, 3.0])\n",
+        "b = jnp.array([10.0, 20.0, 30.0])\n",
+        "\n",
+        "print(f\"add:       {a + b}\")\n",
+        "print(f\"multiply:  {a * b}\")\n",
+        "print(f\"dot:       {jnp.dot(a, b)}\")\n",
+        "print(f\"sum:       {jnp.sum(a)}\")\n",
+        "print(f\"mean:      {jnp.mean(a)}\")\n",
+        "print(f\"std:       {jnp.std(a)}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Automatic differentiation: Nx.Defn.grad → jax.grad\n",
+        "def f(x):\n",
+        "    return x**3 + 2 * x**2  # f(x) = x³ + 2x²\n",
+        "\n",
+        "grad_f = grad(f)  # Symbolic gradient\n",
+        "\n",
+        "x = 3.0\n",
+        "print(f\"f(3)  = {f(x)}\")\n",
+        "print(f\"f'(3) = {grad_f(x)}\")\n",
+        "print(f\"expected = 3*9 + 2*2*3 = {3*9 + 2*2*3}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# JIT compilation: Nx.Defn.jit → jax.jit\n",
+        "@jit\n",
+        "def fast_sigmoid(x):\n",
+        "    return 1 / (1 + jnp.exp(-x))\n",
+        "\n",
+        "input_arr = jnp.array([[-2.0, -1.0, 0.0, 1.0, 2.0]])\n",
+        "result = fast_sigmoid(input_arr)\n",
+        "print(f\"JIT compiled sigmoid: {result}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 2 — Pre-trained NLP (Bumblebee equivalent)\n",
+        "\n",
+        "In Elixir: `Bumblebee.load_model({:hf, \"...\"})`\n",
+        "In Python/JAX: `transformers` + `flax` or `pipeline()`"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.1 Fill-Mask (BERT)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "fill_mask = pipeline(\"fill-mask\", model=\"google-bert/bert-base-uncased\")\n",
+        "results = fill_mask(\"Elixir is a [MASK] language.\")\n",
+        "for r in results:\n",
+        "    print(f\"  {r['score']:.4f}  {r['token_str']:15s}  {r['sequence']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.2 Sentiment Analysis"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "sentiment = pipeline(\n",
+        "    \"sentiment-analysis\",\n",
+        "    model=\"distilbert/distilbert-base-uncased-finetuned-sst-2-english\"\n",
+        ")\n",
+        "\n",
+        "texts = [\n",
+        "    \"Machine learning in Elixir is amazing!\",\n",
+        "    \"This tutorial is boring and confusing.\",\n",
+        "    \"The BEAM VM handles concurrent ML workloads well.\",\n",
+        "]\n",
+        "\n",
+        "for text in texts:\n",
+        "    result = sentiment(text)[0]\n",
+        "    print(f\"  {result['label']:8s} {result['score']:.4f}  ← \\\"{text[:50]}\\\"\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.3 Named Entity Recognition"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ner = pipeline(\"ner\", model=\"dslim/bert-base-NER\", aggregation_strategy=\"simple\")\n",
+        "text = \"Sean Moriarity wrote Machine Learning in Elixir for Pragmatic Bookshelf.\"\n",
+        "entities = ner(text)\n",
+        "for e in entities:\n",
+        "    print(f\"  {e['entity_group']:8s} {e['score']:.4f}  {e['word']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.4 Zero-Shot Classification"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "zs_classifier = pipeline(\"zero-shot-classification\", model=\"facebook/bart-large-mnli\")\n",
+        "\n",
+        "article = \"\"\"\n",
+        "Nx brings numerical computing to the BEAM, enabling machine learning\n",
+        "pipelines that leverage Elixir's concurrency and fault tolerance.\n",
+        "\"\"\"\n",
+        "\n",
+        "labels = [\"technology\", \"sports\", \"politics\", \"science\", \"finance\"]\n",
+        "result = zs_classifier(article, labels)\n",
+        "\n",
+        "for label, score in zip(result[\"labels\"], result[\"scores\"]):\n",
+        "    bar = \"█\" * int(score * 30)\n",
+        "    print(f\"  {label:12s} {score:.4f}  {bar}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.5 Sentence Embeddings & Similarity"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from sentence_transformers import SentenceTransformer\n",
+        "\n",
+        "emb_model = SentenceTransformer(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+        "\n",
+        "sentences = [\n",
+        "    \"Nx provides numerical computing for Elixir\",\n",
+        "    \"Axon is a neural network library built on Nx\",\n",
+        "    \"Bumblebee connects Elixir to the Hugging Face Hub\",\n",
+        "    \"I enjoy cooking Italian food on weekends\",\n",
+        "]\n",
+        "\n",
+        "embeddings = emb_model.encode(sentences)\n",
+        "\n",
+        "query = \"How do I build neural networks in Elixir?\"\n",
+        "query_emb = emb_model.encode([query])\n",
+        "\n",
+        "from sklearn.metrics.pairwise import cosine_similarity\n",
+        "sims = cosine_similarity(query_emb, embeddings)[0]\n",
+        "ranked = sorted(zip(sentences, sims), key=lambda x: -x[1])\n",
+        "\n",
+        "print(f'Query: \"{query}\"\\n')\n",
+        "for sent, sim in ranked:\n",
+        "    print(f\"  {sim:.4f}  {sent}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.6 Text Generation (GPT-2)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "text_gen = pipeline(\"text-generation\", model=\"openai-community/gpt2\")\n",
+        "prompt = \"Machine learning in Elixir is\"\n",
+        "output = text_gen(prompt, max_new_tokens=50, num_return_sequences=1)\n",
+        "print(output[0][\"generated_text\"])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.7 Image Classification (ViT)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from PIL import Image\n",
+        "import requests\n",
+        "\n",
+        "img_cls = pipeline(\"image-classification\", model=\"google/vit-base-patch16-224\")\n",
+        "img_url = \"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg\"\n",
+        "image = Image.open(requests.get(img_url, stream=True).raw)\n",
+        "results = img_cls(image)\n",
+        "for r in results[:5]:\n",
+        "    print(f\"  {r['score']:.4f}  {r['label']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.8 Speech-to-Text (Whisper)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "asr = pipeline(\"automatic-speech-recognition\", model=\"openai/whisper-tiny\")\n",
+        "audio_url = \"https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac\"\n",
+        "result = asr(audio_url)\n",
+        "print(f\"Transcription: {result['text']}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 2.9 Image Generation (Stable Diffusion)\n",
+        "\n",
+        "> Requires GPU. JAX version uses `diffusers` with JAX backend."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# JAX Stable Diffusion (using diffusers with JAX)\n",
+        "try:\n",
+        "    from diffusers import StableDiffusionPipeline\n",
+        "    import torch as _torch\n",
+        "    \n",
+        "    # Note: diffusers primarily supports PyTorch, JAX version is experimental\n",
+        "    # For production JAX SD, use ` JaxDM` or similar\n",
+        "    sd_pipe = StableDiffusionPipeline.from_pretrained(\n",
+        "        \"CompVis/stable-diffusion-v1-4\",\n",
+        "        torch_dtype=_torch.float16 if _torch.cuda.is_available() else _torch.float32,\n",
+        "    )\n",
+        "    \n",
+        "    prompt = \"a bee programming in Elixir, highly detailed, 4k\"\n",
+        "    image = sd_pipe(prompt, num_inference_steps=20).images[0]\n",
+        "    display(image)\n",
+        "except Exception as e:\n",
+        "    print(f\"SD requires GPU/memory: {e}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 2.10 Model Export (ONNX / GGUF)
+
+**Export to ONNX (experimental for Flax models)**
+```python
+# Install jax2onnx for conversion
+# pip install jax2onnx onnx
+
+# Example: Export the Flax MLP model to ONNX
+import jax2onnx
+import onnx
+
+# Assume `model` is the Flax model defined earlier and `params` are its trained parameters
+# Define a callable applying the model
+def apply_model(x):
+    return model.apply(params, x, training=False)
+
+# Convert a dummy input shape to ONNX
+input_shape = (1, n_features)
+onnx_model = jax2onnx.convert(apply_model, input_shape, output_path="mlp.onnx")
+print("ONNX model saved as mlp.onnx")
+```
+
+**Convert to GGUF** (decoder‑only models, e.g., GPT‑2)
+```bash
+pip install gguf-converter
+# Convert the ONNX model to GGUF
+gguf-converter --onnx mlp.onnx --output mlp.gguf
+```
+
+> **Note:** GGUF conversion currently targets decoder architectures. For encoder‑only models you may still use ONNX directly with `onnxruntime`.
+
+---
+
+## 3 — Custom Training with Flax (Axon equivalent)",
+        "\n",
+        "Flax is Google's neural network library for JAX — mirrors Axon's functional design."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Synthetic data (same as Livebook)\n",
+        "import numpy as np\n",
+        "np.random.seed(42)\n",
+        "n_samples, n_features, n_classes = 2000, 4, 3\n",
+        "\n",
+        "centers = np.random.randn(n_classes, n_features) * 2\n",
+        "labels_raw = np.random.randint(0, n_classes, n_samples)\n",
+        "noise = np.random.randn(n_samples, n_features) * 0.4\n",
+        "X = centers[labels_raw] + noise\n",
+        "X = (X - X.mean(axis=0)) / X.std(axis=0)\n",
+        "Y = np.eye(n_classes)[labels_raw]\n",
+        "\n",
+        "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)\n",
+        "\n",
+        "# Convert to JAX arrays\n",
+        "X_train_j = jnp.array(X_train)\n",
+        "Y_train_j = jnp.array(Y_train)\n",
+        "X_test_j = jnp.array(X_test)\n",
+        "Y_test_j = jnp.array(Y_test)\n",
+        "\n",
+        "print(f\"Train: {len(X_train)} | Test: {len(X_test)} | Features: {n_features} | Classes: {n_classes}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Flax model (mirrors Axon build)\n",
+        "class MLP(nn.Module):\n",
+        "    n_classes: int\n",
+        "    \n",
+        "    @nn.compact\n",
+        "    def __call__(self, x, training: bool = True):\n",
+        "        x = nn.Dense(64)(x)\n",
+        "        x = nn.relu(x)\n",
+        "        x = nn.BatchNorm(use_running_average=not training)(x)\n",
+        "        x = nn.Dropout(0.2, deterministic=not training)(x)\n",
+        "        \n",
+        "        x = nn.Dense(32)(x)\n",
+        "        x = nn.relu(x)\n",
+        "        x = nn.BatchNorm(use_running_average=not training)(x)\n",
+        "        x = nn.Dropout(0.2, deterministic=not training)(x)\n",
+        "        \n",
+        "        x = nn.Dense(self.n_classes)(x)\n",
+        "        x = nn.softmax(x, axis=-1)\n",
+        "        return x\n",
+        "\n",
+        "model = MLP(n_classes=n_classes)\n",
+        "print(model)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Initialize parameters\n",
+        "dummy_input = jnp.ones((1, n_features))\n",
+        "variables = model.init(jax.random.key(42), dummy_input, training=False)\n",
+        "params = variables[\"params\"]\n",
+        "print(f\"Parameters initialized: {sum(p.size for p in jax.tree_util.tree_leaves(params))}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Training step function\n",
+        "def cross_entropy_loss(logits, labels):\n",
+        "    return -jnp.mean(jnp.sum(labels * jnp.log(logits + 1e-8), axis=-1))\n",
+        "\n",
+        "@jit\n",
+        "def train_step(params, batch):\n",
+        "    x, y = batch\n",
+        "    \n",
+        "    def loss_fn(p):\n",
+        "        logits = model.apply(p, x, training=True)\n",
+        "        return cross_entropy_loss(logits, y)\n",
+        "    \n",
+        "    loss, grads = jax.value_and_grad(loss_fn)(params)\n",
+        "    updates, opt_state = optimizer.update(grads, opt_state)\n",
+        "    new_params = optax.apply_updates(params, updates)\n",
+        "    return loss, new_params\n",
+        "\n",
+        "@jit  \n",
+        "def accuracy(params, x, y):\n",
+        "    logits = model.apply(params, x, training=False)\n",
+        "    preds = jnp.argmax(logits, axis=-1)\n",
+        "    true = jnp.argmax(y, axis=-1)\n",
+        "    return jnp.mean(preds == true)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Training loop\n",
+        "optimizer = optax.adam(0.001)\n",
+        "opt_state = optimizer.init(params)\n",
+        "\n",
+        "batch_size = 64\n",
+        "epochs = 30\n",
+        "\n",
+        "for epoch in range(epochs):\n",
+        "    # Shuffle\n",
+        "    perm = jax.random.permutation(jax.random.key(epoch), len(X_train_j))\n",
+        "    X_shuffled = X_train_j[perm]\n",
+        "    Y_shuffled = Y_train_j[perm]\n",
+        "    \n",
+        "    epoch_loss = 0\n",
+        "    for i in range(0, len(X_train_j), batch_size):\n",
+        "        batch_x = X_shuffled[i:i+batch_size]\n",
+        "        batch_y = Y_shuffled[i:i+batch_size]\n",
+        "        loss, params = train_step(params, (batch_x, batch_y))\n",
+        "        epoch_loss += loss\n",
+        "    \n",
+        "    if (epoch + 1) % 10 == 0:\n",
+        "        acc = accuracy(params, X_test_j, Y_test_j)\n",
+        "        print(f\"Epoch {epoch+1:3d}  loss={epoch_loss/len(X_train_j):.4f}  acc={acc:.2%}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Final evaluation\n",
+        "final_acc = accuracy(params, X_test_j, Y_test_j)\n",
+        "print(f\"Final test accuracy: {final_acc:.2%}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Visualize\n",
+        "logits = model.apply(params, X_test_j, training=False)\n",
+        "preds = jnp.argmax(logits, axis=-1)\n",
+        "true = jnp.argmax(Y_test_j, axis=-1)\n",
+        "\n",
+        "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
+        "for cls in range(n_classes):\n",
+        "    mask = true == cls\n",
+        "    axes[0].scatter(X_test[mask, 0], X_test[mask, 1], label=f\"Class {cls}\", alpha=0.6)\n",
+        "    mask2 = preds == cls\n",
+        "    axes[1].scatter(X_test[mask2, 0], X_test[mask2, 1], label=f\"Class {cls}\", alpha=0.6)\n",
+        "axes[0].set_title(\"Actual\")\n",
+        "axes[1].set_title(\"Predicted\")\n",
+        "for ax in axes:\n",
+        "    ax.legend()\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 4 — Summary\n",
+        "\n",
+        "| Pipeline Stage | Elixir (Livebook) | JAX (This Notebook) |\n",
+        "|---------------|-------------------|----------------------|\n",
+        "| Tensors | `Nx.tensor` | `jnp.array` |\n",
+        "| Gradients | `Nx.Defn.grad` | `jax.grad` |\n",
+        "| JIT | `EXLA.Backend` | `jax.jit` |\n",
+        "| Pre-trained | `Bumblebee` | `transformers` + `flax` |\n",
+        "| Neural Net | `Axon` | `flax.linen` |\n",
+        "| Optimizer | `Axon.Optimizers` | `optax` |\n",
+        "| Training Loop | `Axon.Loop` | Custom (JAX) |\n",
+        "\n",
+        "### Deploy\n",
+        "\n",
+        "* **Colab**: Open this `.ipynb` directly\n",
+        "* **Kaggle**: Upload as new notebook\n",
+        "* **HF Spaces**: Use with `sdk: docker` (JAX requires GPU)"
+      ]
+    }
+  ]
+}

justfile

@@ -0,0 +1,106 @@
+# justfile — ML in Elixir project tasks
+# Usage: just <recipe>
+# Install just: mise use just (or brew install just / cargo install just)
+
+set dotenv-load
+
+# Default: show available recipes
+default:
+    @just --list
+
+# ─── Elixir / Livebook ───────────────────────────────────────────
+
+# Install all Elixir deps
+setup:
+    mise exec -- mix setup
+
+# Update all deps
+update:
+    mise exec -- mix deps.update --all
+
+# Compile the project
+compile:
+    mise exec -- mix compile
+
+# Run tests
+test:
+    mise exec -- mix test
+
+# Open Livebook editor (serves on :8080)
+livebook:
+    mise exec -- mix run --eval "Livebook.Config.set(:default_runtime, Livebook.Config.Runtime.default_standalone())" 2>/dev/null; \
+    mise exec -- livebook server --port 8080
+
+# Open the main template in Livebook
+notebook:
+    mise exec -- livebook server ml_e2e_template.livemd
+
+# ─── Deploy: Hugging Face Spaces ─────────────────────────────────
+
+# Deploy Livebook to HF Spaces
+deploy-livebook space:
+    cp ml_e2e_template.livemd hf_deploy/
+    cd hf_deploy && bash deploy.sh {{space}}
+
+# Deploy Gradio to HF Spaces
+deploy-gradio space:
+    cd gradio_hf_deploy && \
+    git clone https://huggingface.co/spaces/{{space}} /tmp/gradio-deploy 2>/dev/null || true && \
+    cp app.py requirements.txt README.md /tmp/gradio-deploy/ && \
+    cd /tmp/gradio-deploy && \
+    git add -A && git commit -m "Update" && git push
+
+# Deploy marimo to HF Spaces
+deploy-marimo space:
+    cd marimo && \
+    git clone https://huggingface.co/spaces/{{space}} /tmp/marimo-deploy 2>/dev/null || true && \
+    cp ml_e2e_marimo.py Dockerfile requirements.txt README.md /tmp/marimo-deploy/ && \
+    cd /tmp/marimo-deploy && \
+    git add -A && git commit -m "Update" && git push
+
+# ─── Python / marimo ─────────────────────────────────────────────
+
+# Run marimo editor
+marimo:
+    pip install -q marimo transformers torch numpy scikit-learn matplotlib 2>/dev/null; \
+    marimo edit marimo/ml_e2e_marimo.py
+
+# Run marimo as app (no code)
+marimo-app:
+    pip install -q marimo transformers torch numpy scikit-learn matplotlib 2>/dev/null; \
+    marimo run marimo/ml_e2e_marimo.py
+
+# Run Gradio app locally
+gradio:
+    pip install -q -r gradio_hf_deploy/requirements.txt 2>/dev/null; \
+    python gradio_hf_deploy/app.py
+
+# ─── Validation ──────────────────────────────────────────────────
+
+# Check all files exist
+check:
+    @echo "=== Files ==="
+    @test -f ml_e2e_template.livemd          && echo "✅ Livebook template"   || echo "❌ Livebook template"
+    @test -f hf_deploy/Dockerfile            && echo "✅ HF Deploy (Docker)"  || echo "❌ HF Deploy (Docker)"
+    @test -f colab_kaggle/ml_e2e_python.ipynb && echo "✅ Colab/Kaggle (.ipynb)" || echo "❌ Colab/Kaggle"
+    @test -f gradio_hf_deploy/app.py         && echo "✅ Gradio app"          || echo "❌ Gradio app"
+    @test -f marimo/ml_e2e_marimo.py         && echo "✅ Marimo notebook"     || echo "❌ Marimo notebook"
+    @echo "=== Tools ==="
+    @which elixir  >/dev/null 2>&1 && echo "✅ elixir"  || echo "⚠️  elixir not found (run: mise install)"
+    @which python3 >/dev/null 2>&1 && echo "✅ python3" || echo "⚠️  python3 not found"
+    @which just    >/dev/null 2>&1 && echo "✅ just"    || echo "⚠️  just not found (run: mise use just)"
+    @which git     >/dev/null 2>&1 && echo "✅ git"     || echo "⚠️  git not found"
+
+# Verify mix deps resolve
+deps-check:
+    mise exec -- mix deps.get --check-unused 2>&1 || true
+    mise exec -- mix deps
+
+# ─── Clean ───────────────────────────────────────────────────────
+
+# Clean build artifacts
+clean:
+    mise exec -- mix clean
+    rm -rf _build deps
+    find . -name "__pycache__" -type d -exec rm -rf {} + 2>/dev/null || true
+    find . -name "*.pyc" -delete 2>/dev/null || true

lib/ml_learning.ex

@@ -0,0 +1,18 @@
+defmodule MLLearning do
+  @moduledoc """
+  Documentation for `MLLearning`.
+  """
+
+  @doc """
+  Hello world.
+
+  ## Examples
+
+      iex> MLLearning.hello()
+      :world
+
+  """
+  def hello do
+    :world
+  end
+end

marimo/Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.12-slim
+
+RUN pip install --no-cache-dir \
+    marimo \
+    transformers \
+    torch \
+    numpy \
+    scikit-learn \
+    matplotlib \
+    sentencepiece \
+    protobuf
+
+WORKDIR /app
+COPY ml_e2e_marimo.py /app/
+
+EXPOSE 8080
+
+CMD ["marimo", "run", "ml_e2e_marimo.py", "--host", "0.0.0.0", "--port", "8080"]

marimo/README.md

@@ -0,0 +1,17 @@
+---
+title: ML in Elixir — marimo Edition
+emoji: 🐝
+colorFrom: purple
+colorTo: yellow
+sdk: docker
+app_port: 8080
+pinned: false
+license: apache-2.0
+tags:
+  - marimo
+  - elixir
+  - machine-learning
+  - bumblebee
+  - hugging-face
+  - reactive-notebook
+---

marimo/ml_e2e_marimo.py

@@ -0,0 +1,904 @@
+"""
+ML in Elixir — End-to-Edge Template (marimo edition)
+
+A reactive Python notebook mirroring the Elixir Livebook template.
+Built on the marimo reactive notebook framework.
+
+## Skills
+- `hf_cli.md` – Hugging Face CLI usage
+- `hf_jobs.md` – Running workloads on HF Jobs
+- `training_trl.md` – TRL model training
+- `hf_dataset_viewer.md` – Dataset Viewer API
+- `gradio.md` – Gradio UI integration
+- *(Full catalog at https://skills.sh/huggingface/skills)*
+
+Run:
+    marimo edit ml_e2e_marimo.py      # Interactive editor
+    marimo run ml_e2e_marimo.py       # App mode (no code visible)
+    python ml_e2e_marimo.py           # Script mode (terminal output)
+
+Deploy:
+    - Hugging Face Spaces (sdk: marimo)
+    - Anywhere Python runs (pip install marimo)
+"""
+
+import marimo
+
+__generated_with = "0.19.10"
+app = marimo.App(width="medium")
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 0 — Imports & Setup
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell
+def _():
+    import marimo as mo
+
+    return (mo,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        # 🐝 Machine Learning in Elixir — marimo Edition
+
+        This reactive notebook mirrors the **Elixir Livebook template**
+        from *Machine Learning in Elixir* by Sean Moriarity.
+
+        | Elixir Livebook | This Notebook | Purpose |
+        |-----------------|---------------|----------|
+        | `Nx` | `numpy` | Numerical computing |
+        | `Axon` | `torch` | Neural networks |
+        | `Bumblebee` | `transformers` | Pre-trained models |
+        | `Nx.Serving` | `pipeline()` | Batched inference |
+        | `Kino` | `marimo.ui` | Reactive interactive UI |
+        | `EXLA` | CUDA | GPU acceleration |
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    import numpy as np
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    from torch.utils.data import DataLoader, TensorDataset
+    from transformers import (
+        pipeline,
+        AutoTokenizer,
+        AutoModel,
+    )
+    from sklearn.model_selection import train_test_split
+    from sklearn.metrics import classification_report
+    import matplotlib.pyplot as plt
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    mo.md(f"**Device:** `{device}` | **PyTorch:** `{torch.__version__}`")
+    return (
+        AutoModel,
+        AutoTokenizer,
+        DataLoader,
+        F,
+        TensorDataset,
+        classification_report,
+        device,
+        mo,
+        nn,
+        np,
+        pipeline,
+        plt,
+        torch,
+        train_test_split,
+    )
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 1 — NumPy Foundations (Nx equivalent)
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 1 — NumPy Foundations
+
+        Elixir's `Nx` provides tensors, broadcasting, and automatic differentiation.
+        Python's `numpy` + `torch.autograd` are the direct counterparts.
+        """
+    )
+    return
+
+
+@app.cell
+def _(np):
+    # Tensors: Nx.tensor(...) → np.array(...)
+    scalar = np.float64(3.14)
+    vector = np.array([1.0, 2.0, 3.0])
+    matrix = np.array([[1, 2, 3], [4, 5, 6]])
+
+    tensor_info = (
+        f"| Type | Shape | Dtype |\n|------|-------|-------|\n"
+        f"| scalar | `{np.shape(scalar)}` | `{scalar.dtype}` |\n"
+        f"| vector | `{np.shape(vector)}` | `{vector.dtype}` |\n"
+        f"| matrix | `{np.shape(matrix)}` | `{matrix.dtype}` |"
+    )
+    tensor_info
+    return matrix, vector
+
+
+@app.cell
+def _(np, vector):
+    # Operations: Nx.add/multiply/dot → +/*/np.dot
+    a = np.array([1.0, 2.0, 3.0])
+    b = np.array([10.0, 20.0, 30.0])
+
+    ops_results = {
+        "add": a + b,
+        "multiply": a * b,
+        "dot": np.dot(a, b),
+        "sum": np.sum(a),
+        "mean": np.mean(a),
+        "std": np.std(a),
+    }
+    ops_results
+    return
+
+
+@app.cell
+def _(mo, torch):
+    # Automatic differentiation: Nx.Defn.grad → torch.autograd
+    x = torch.tensor(3.0, requires_grad=True)
+    f = x**3 + 2 * x**2  # f(x) = x³ + 2x²
+    f.backward()
+
+    mo.md(
+        f"""
+        **Automatic differentiation** (gradients for training):
+
+        | | Value |
+        |---|---|
+        | f(3) | `{f.item()}` |
+        | f'(3) | `{x.grad.item()}` |
+        | Expected (3·9 + 2·2·3) | `{3 * 9 + 2 * 2 * 3}` |
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo, np):
+    # Broadcasting: Nx broadcasts automatically, so does numpy
+    mat = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+    row = np.array([10.0, 20.0, 30.0])
+    broadcast_result = mat + row
+
+    mo.md(f"**Broadcasting** — add row vector to matrix:\n```\n{broadcast_result}\n```")
+    return
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 2 — Pre-trained NLP (Bumblebee equivalent)
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 2 — Pre-trained NLP (Bumblebee → transformers)
+
+        In Elixir: `Bumblebee.load_model({:hf, "..."})` + `Nx.Serving.run()`
+        In Python: `transformers.pipeline()` is the one-liner equivalent.
+        """
+    )
+    return
+
+
+# --- 2.1 Fill-Mask ---
+
+
+@app.cell
+def _(mo, pipeline):
+    mo.md("### 2.1 Fill-Mask (BERT)")
+    fill_mask = pipeline("fill-mask", model="google-bert/bert-base-uncased")
+    return (fill_mask,)
+
+
+@app.cell
+def _(fill_mask, mo):
+    mask_text = mo.ui.text(
+        label="Text with [MASK]", value="Elixir is a [MASK] language."
+    )
+    mask_text
+    return (mask_text,)
+
+
+@app.cell
+def _(fill_mask, mask_text, mo):
+    mask_results = []
+    if "[MASK]" in mask_text.value:
+        raw = fill_mask(mask_text.value)
+        mask_results = [
+            {
+                "score": round(r["score"], 4),
+                "token": r["token_str"],
+                "sequence": r["sequence"],
+            }
+            for r in raw
+        ]
+    mo.ui.table(mask_results) if mask_results else mo.md(
+        "Enter text with **[MASK]** above."
+    )
+    return
+
+
+# --- 2.2 Sentiment ---
+
+
+@app.cell
+def _(mo, pipeline):
+    mo.md("### 2.2 Sentiment Analysis (DistilBERT)")
+    sentiment = pipeline(
+        "sentiment-analysis",
+        model="distilbert/distilbert-base-uncased-finetuned-sst-2-english",
+    )
+    return (sentiment,)
+
+
+@app.cell
+def _(mo, sentiment):
+    sentiment_input = mo.ui.text(
+        label="Text",
+        value="Machine learning in Elixir is amazing!",
+    )
+    sentiment_input
+    return (sentiment_input,)
+
+
+@app.cell
+def _(mo, sentiment, sentiment_input):
+    if sentiment_input.value.strip():
+        result = sentiment(sentiment_input.value)[0]
+        emoji = "😊" if result["label"] == "POSITIVE" else "😞"
+        mo.md(f"### {emoji} **{result['label']}** ({result['score']:.4f})")
+    else:
+        mo.md("Enter text above.")
+    return
+
+
+# --- 2.3 NER ---
+
+
+@app.cell
+def _(mo, pipeline):
+    mo.md("### 2.3 Named Entity Recognition (BERT-NER)")
+    ner = pipeline("ner", model="dslim/bert-base-NER", aggregation_strategy="simple")
+    return (ner,)
+
+
+@app.cell
+def _(mo, ner):
+    ner_input = mo.ui.text_area(
+        label="Text",
+        value="Sean Moriarity wrote Machine Learning in Elixir for Pragmatic Bookshelf. He lives in Austin, Texas.",
+    )
+    ner_input
+    return (ner_input,)
+
+
+@app.cell
+def _(mo, ner, ner_input):
+    if ner_input.value.strip():
+        entities = ner(ner_input.value)
+        rows = [
+            {
+                "Entity": e["word"],
+                "Type": e["entity_group"],
+                "Score": round(e["score"], 4),
+            }
+            for e in entities
+        ]
+        mo.ui.table(rows) if rows else mo.md("No entities found.")
+    else:
+        mo.md("Enter text above.")
+    return
+
+
+# --- 2.4 Zero-Shot ---
+
+
+@app.cell
+def _(mo, pipeline):
+    mo.md("### 2.4 Zero-Shot Classification")
+    zs = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+    return (zs,)
+
+
+@app.cell
+def _(mo, zs):
+    zs_text = mo.ui.text_area(
+        label="Text",
+        value="Nx brings numerical computing to the BEAM, enabling machine learning pipelines.",
+    )
+    zs_labels = mo.ui.text(
+        label="Labels (comma-separated)",
+        value="technology, sports, politics, science, finance",
+    )
+    mo.vstack([zs_text, zs_labels])
+    return zs_labels, zs_text
+
+
+@app.cell
+def _(mo, zs, zs_labels, zs_text):
+    if zs_text.value.strip() and zs_labels.value.strip():
+        labels = [l.strip() for l in zs_labels.value.split(",") if l.strip()]
+        result = zs(zs_text.value, labels)
+        rows = [
+            {"Label": l, "Score": round(s, 4)}
+            for l, s in zip(result["labels"], result["scores"])
+        ]
+        mo.ui.table(rows)
+    else:
+        mo.md("Enter text and labels above.")
+    return
+
+
+# --- 2.5 Embeddings ---
+
+
+@app.cell
+def _(AutoModel, AutoTokenizer, mo):
+    mo.md("### 2.5 Sentence Embeddings & Similarity")
+    emb_tok = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
+    emb_model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
+    return emb_model, emb_tok
+
+
+@app.cell
+def _(F, emb_model, emb_tok, mo, torch):
+    def embed_texts(texts):
+        inputs = emb_tok(texts, padding=True, truncation=True, return_tensors="pt")
+        with torch.no_grad():
+            out = emb_model(**inputs)
+        mask = inputs["attention_mask"].unsqueeze(-1)
+        embs = (out.last_hidden_state * mask).sum(1) / mask.sum(1)
+        return F.normalize(embs, p=2, dim=1)
+
+    emb_a = mo.ui.text(
+        label="Text A", value="Nx provides numerical computing for Elixir"
+    )
+    emb_b = mo.ui.text(
+        label="Text B", value="Axon is a neural network library built on Nx"
+    )
+    mo.vstack([emb_a, emb_b])
+    return emb_a, emb_b, embed_texts
+
+
+@app.cell
+def _(emb_a, emb_b, embed_texts, mo):
+    if emb_a.value.strip() and emb_b.value.strip():
+        embs = embed_texts([emb_a.value, emb_b.value])
+        import torch.nn.functional as _F
+
+        score = _F.cosine_similarity(embs[0:1], embs[1:2]).item()
+        mo.md(f"**Cosine Similarity:** `{score:.6f}`")
+    else:
+        mo.md("Enter both texts above.")
+    return
+
+
+# --- 2.6 Text Generation ---
+
+
+@app.cell
+def _(mo, pipeline):
+    mo.md("### 2.6 Text Generation (GPT-2)")
+    text_gen = pipeline("text-generation", model="openai-community/gpt2")
+    return (text_gen,)
+
+
+@app.cell
+def _(mo):
+    gen_prompt = mo.ui.text(label="Prompt", value="Machine learning in Elixir is")
+    gen_tokens = mo.ui.slider(start=10, stop=100, value=50, label="Max tokens")
+    gen_temp = mo.ui.slider(
+        start=0.1, stop=2.0, value=0.7, step=0.1, label="Temperature"
+    )
+    mo.vstack([gen_prompt, gen_tokens, gen_temp])
+    return gen_prompt, gen_temp, gen_tokens
+
+
+@app.cell
+def _(gen_prompt, gen_temp, gen_tokens, mo, text_gen):
+    if gen_prompt.value.strip():
+        output = text_gen(
+            gen_prompt.value,
+            max_new_tokens=gen_tokens.value,
+            temperature=gen_temp.value,
+            do_sample=True,
+        )
+        generated = output[0]["generated_text"]
+        mo.md(f"```\n{generated}\n```")
+    else:
+        mo.md("Enter a prompt above.")
+    return
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 2.7 — Image Classification (ViT)
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ### 2.7 Image Classification (Vision Transformer)
+
+        Elixir: `Bumblebee.Vision.ImageClassification.image_classification(model, featurizer)`
+        Python: `pipeline("image-classification")`
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo, pipeline):
+    img_cls = pipeline("image-classification", model="google/vit-base-patch16-224")
+    img_upload = mo.ui.file(
+        label="Upload image",
+        filetypes=[".jpg", ".jpeg", ".png", ".webp"],
+        multiple=False,
+    )
+    img_upload
+    return img_cls, img_upload
+
+
+@app.cell
+def _(img_cls, img_upload, mo):
+    if img_upload.value:
+        import io
+        from PIL import Image
+
+        file_info = img_upload.value[0]
+        img = Image.open(io.BytesIO(file_info.contents)).convert("RGB")
+        results = img_cls(img)
+        rows = [{"Label": r["label"], "Score": round(r["score"], 4)} for r in results]
+        mo.vstack([mo.md("**Results:**"), mo.ui.table(rows)])
+    else:
+        mo.md("Upload an image above to classify.")
+    return
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 2.8 — Audio / Speech-to-Text (Whisper)
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ### 2.8 Speech-to-Text (Whisper)
+
+        Elixir: `Bumblebee.Audio.speech_to_text(model, featurizer, tokenizer, generation_config)`
+        Python: `pipeline("automatic-speech-recognition")`
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo, pipeline):
+    asr = pipeline("automatic-speech-recognition", model="openai/whisper-tiny")
+    audio_upload = mo.ui.file(
+        label="Upload audio (WAV/FLAC/MP3)",
+        filetypes=[".wav", ".flac", ".mp3", ".m4a"],
+        multiple=False,
+    )
+    audio_upload
+    return asr, audio_upload
+
+
+@app.cell
+def _(asr, audio_upload, mo):
+    if audio_upload.value:
+        import io
+        import tempfile
+        import os
+
+        file_info = audio_upload.value[0]
+        suffix = os.path.splitext(file_info.name)[1] or ".wav"
+        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
+            tmp.write(file_info.contents)
+            tmp_path = tmp.name
+        result = asr(tmp_path)
+        os.unlink(tmp_path)
+        mo.md(f"**Transcription:**\n\n> {result['text']}")
+    else:
+        mo.md("Upload an audio file above to transcribe.")
+    return
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 2.9 — Image Generation (Stable Diffusion)
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ### 2.9 Image Generation (Stable Diffusion)
+
+        Elixir: `Bumblebee.Diffusion.StableDiffusion.text_to_image(...)`
+        Python: `diffusers` library
+
+        > Requires GPU with 4GB+ VRAM. Falls back to CPU (very slow).
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    sd_prompt = mo.ui.text(
+        label="Prompt", value="a photograph of a bee programming in elixir, 4k"
+    )
+    sd_negative = mo.ui.text(label="Negative prompt", value="blurry, ugly, low quality")
+    sd_steps = mo.ui.slider(start=5, stop=50, value=20, label="Steps")
+    sd_btn = mo.ui.button(label="Generate Image")
+    mo.vstack([sd_prompt, sd_negative, sd_steps, sd_btn])
+    return sd_btn, sd_negative, sd_prompt, sd_steps
+
+
+@app.cell
+def _(mo, sd_btn, sd_negative, sd_prompt, sd_steps):
+    if sd_btn.value and sd_prompt.value.strip():
+        try:
+            from diffusers import StableDiffusionPipeline
+            import torch as _torch
+
+            device_sd = "cuda" if _torch.cuda.is_available() else "cpu"
+            sd_pipe = StableDiffusionPipeline.from_pretrained(
+                "CompVis/stable-diffusion-v1-4",
+                torch_dtype=_torch.float16 if device_sd == "cuda" else _torch.float32,
+            ).to(device_sd)
+
+            image = sd_pipe(
+                prompt=sd_prompt.value,
+                negative_prompt=sd_negative.value or None,
+                num_inference_steps=sd_steps.value,
+            ).images[0]
+
+            mo.image(image, caption=sd_prompt.value)
+        except Exception as e:
+            mo.md(f"⚠️ Stable Diffusion requires `diffusers` + GPU: `{e}`")
+    else:
+        mo.md("Enter a prompt and click Generate.")
+    return
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 3 — Custom Training (Axon equivalent)
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 3 — Custom Training (Axon → PyTorch)
+
+        Build and train a neural network from scratch — mirrors the Axon
+        section of the Livebook template.
+        """
+    )
+    return
+
+
+@app.cell
+def _(np, train_test_split):
+    # Synthetic data (same as Livebook)
+    np.random.seed(42)
+    n_samples, n_features, n_classes = 2000, 4, 3
+
+    centers = np.random.randn(n_classes, n_features) * 2
+    labels_raw = np.random.randint(0, n_classes, n_samples)
+    noise = np.random.randn(n_samples, n_features) * 0.4
+    X = centers[labels_raw] + noise
+    X = (X - X.mean(axis=0)) / X.std(axis=0)
+    Y = np.eye(n_classes)[labels_raw]
+
+    X_train, X_test, Y_train, Y_test = train_test_split(
+        X, Y, test_size=0.2, random_state=42
+    )
+    f"Train: {len(X_train)} | Test: {len(X_test)} | Features: {n_features} | Classes: {n_classes}"
+    return X_test, X_train, Y_test, Y_train, n_classes, n_features
+
+
+@app.cell
+def _(DataLoader, TensorDataset, X_test, X_train, Y_test, Y_train, device, torch):
+    # Prepare PyTorch data loaders
+    train_loader = DataLoader(
+        TensorDataset(
+            torch.FloatTensor(X_train).to(device),
+            torch.FloatTensor(Y_train).to(device),
+        ),
+        batch_size=64,
+        shuffle=True,
+    )
+    test_loader = DataLoader(
+        TensorDataset(
+            torch.FloatTensor(X_test).to(device),
+            torch.FloatTensor(Y_test).to(device),
+        ),
+        batch_size=64,
+    )
+    return test_loader, train_loader
+
+
+@app.cell
+def _(device, mo, n_classes, n_features, nn):
+    # Model definition (mirrors Axon build)
+    class MLP(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.net = nn.Sequential(
+                nn.Linear(n_features, 64),
+                nn.ReLU(),
+                nn.BatchNorm1d(64),
+                nn.Dropout(0.2),
+                nn.Linear(64, 32),
+                nn.ReLU(),
+                nn.BatchNorm1d(32),
+                nn.Dropout(0.2),
+                nn.Linear(32, n_classes),
+                nn.Softmax(dim=1),
+            )
+
+        def forward(self, x):
+            return self.net(x)
+
+    model = MLP().to(device)
+    param_count = sum(p.numel() for p in model.parameters())
+    mo.md(f"**Model:** {param_count:,} parameters\n```\n{model}\n```")
+    return (model,)
+
+
+@app.cell
+def _(mo, model, torch, train_loader):
+    # Training loop
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+    criterion = nn.CrossEntropyLoss()
+
+    epochs = 30
+    epoch_losses = []
+
+    for epoch in range(epochs):
+        model.train()
+        running_loss = 0.0
+        for xb, yb in train_loader:
+            preds = model(xb)
+            loss = criterion(preds, yb.argmax(dim=1))
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+            running_loss += loss.item()
+        epoch_losses.append(running_loss / len(train_loader))
+
+    mo.md(f"**Training complete!** Final loss: `{epoch_losses[-1]:.4f}`")
+    return epoch_losses, model
+
+
+@app.cell
+def _(epoch_losses, mo, plt):
+    # Plot training loss
+    fig, ax = plt.subplots(figsize=(6, 3))
+    ax.plot(epoch_losses, linewidth=2, color="#7c3aed")
+    ax.set_xlabel("Epoch")
+    ax.set_ylabel("Loss")
+    ax.set_title("Training Loss")
+    ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    mo.mpl.interactive(fig)
+    return
+
+
+@app.cell
+def _(X_test, Y_test, classification_report, device, model, mo, torch):
+    # Evaluation
+    model.eval()
+    all_preds, all_true = [], []
+    with torch.no_grad():
+        for i in range(0, len(X_test), 64):
+            xb = torch.FloatTensor(X_test[i : i + 64]).to(device)
+            preds = model(xb).argmax(1).cpu().numpy()
+            all_preds.extend(preds)
+            all_true.extend(Y_test[i : i + 64].argmax(1))
+
+    report = classification_report(
+        all_true, all_preds, target_names=[f"Class {i}" for i in range(3)]
+    )
+    mo.md(f"```\n{report}\n```")
+    return all_preds, all_true
+
+
+@app.cell
+def _(X_test, all_preds, all_true, mo, plt):
+    # Visualize predictions
+    fig, axes = plt.subplots(1, 2, figsize=(10, 4))
+    for cls in range(3):
+        mask = [t == cls for t in all_true]
+        axes[0].scatter(
+            X_test[mask, 0], X_test[mask, 1], label=f"Class {cls}", alpha=0.6, s=15
+        )
+        mask2 = [p == cls for p in all_preds]
+        axes[1].scatter(
+            X_test[mask2, 0], X_test[mask2, 1], label=f"Class {cls}", alpha=0.6, s=15
+        )
+    axes[0].set_title("Actual")
+    axes[1].set_title("Predicted")
+    for ax in axes:
+        ax.legend()
+        ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    mo.mpl.interactive(fig)
+    return
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 4 — Interactive Playground
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 4 — Interactive Playground
+
+        marimo UI elements are **reactive** — change an input and all
+        dependent cells re-run automatically. This mirrors how `Kino`
+        works in Elixir Livebook.
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo, np, torch):
+    # Interactive custom prediction
+    def predict_custom(features, model_ref):
+        x = torch.FloatTensor([features]).to(device)
+        model_ref.eval()
+        with torch.no_grad():
+            probs = model_ref(x).cpu().numpy()[0]
+        return probs
+
+    f1 = mo.ui.slider(start=-3.0, stop=3.0, value=0.0, step=0.1, label="Feature 1")
+    f2 = mo.ui.slider(start=-3.0, stop=3.0, value=0.0, step=0.1, label="Feature 2")
+    f3 = mo.ui.slider(start=-3.0, stop=3.0, value=0.0, step=0.1, label="Feature 3")
+    f4 = mo.ui.slider(start=-3.0, stop=3.0, value=0.0, step=0.1, label="Feature 4")
+    mo.vstack([f1, f2, f3, f4])
+    return f1, f2, f3, f4, predict_custom
+
+
+@app.cell
+def _(f1, f2, f3, f4, model, mo, predict_custom):
+    features = [f1.value, f2.value, f3.value, f4.value]
+    probs = predict_custom(features, model)
+    pred_class = int(probs.argmax())
+    confidence = float(probs[pred_class])
+
+    prob_bars = "\n".join(
+        [f"- **Class {i}**: `{p:.4f}` {'█' * int(p * 30)}" for i, p in enumerate(probs)]
+    )
+    mo.md(
+        f"""
+        ### Prediction: Class {pred_class} ({confidence:.1%} confidence)
+
+        {prob_bars}
+        """
+    )
+    return
+
+
+# ═════════════════════════���═════════════════════════════════════════
+# 5 — Summary
+# ═══════════════════════════════════════════════════════════════════
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## 5 — Summary
+
+        | Pipeline Stage | Elixir (Livebook) | This Notebook (marimo) |
+        |----------------|-------------------|------------------------|
+        | Tensors | `Nx.tensor` | `np.array` |
+        | Gradients | `Nx.Defn.grad` | `torch.autograd` |
+        | GPU | `EXLA.Backend` | `torch.cuda` |
+        | Pre-trained | `Bumblebee.load_model` | `pipeline()` |
+        | Fill-Mask | `Bumblebee.Text.fill_mask` | `pipeline("fill-mask")` |
+        | Sentiment | `Bumblebee.Text.Classification` | `pipeline("sentiment-analysis")` |
+        | NER | `Bumblebee.Text.TokenClassification` | `pipeline("ner")` |
+        | Zero-Shot | `Bumblebee.Text.ZeroShotClassification` | `pipeline("zero-shot-classification")` |
+        | Text Gen | `Bumblebee.Text.generation` | `pipeline("text-generation")` |
+        | Embeddings | `Bumblebee.Text.TextEmbedding` | `sentence-transformers` |
+        | Training | `Axon` + `Axon.Loop` | `torch.nn` + training loop |
+        | UI | `Kino` | `marimo.ui` (reactive) |
+
+        ### Deploy This Notebook
+
+        ```bash
+        # Edit interactively
+        marimo edit ml_e2e_marimo.py
+
+        # Run as app (hide code)
+        marimo run ml_e2e_marimo.py
+
+        # Run as script
+        python ml_e2e_marimo.py
+
+        # Convert to/from Jupyter
+        marimo convert ml_e2e_marimo.py -o notebook.ipynb
+        marimo convert notebook.ipynb -o from_jupyter.py
+        ```
+
+        ### Resources
+
+        * [marimo docs](https://docs.marimo.io)
+        * [Bumblebee docs](https://hexdocs.pm/bumblebee)
+        * [Nx docs](https://hexdocs.pm/nx)
+        * [Hugging Face Hub](https://huggingface.co/models)
+        * _Machine Learning in Elixir_ — Sean Moriarity, Pragmatic Bookshelf
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo, pipeline, device):
+    # Export sentiment model to ONNX (requires torch)
+    import torch
+
+    # Load the sentiment pipeline (use same model as earlier)
+    sentiment_pipe = pipeline(
+        "sentiment-analysis",
+        model="distilbert/distilbert-base-uncased-finetuned-sst-2-english",
+    )
+    torch_model = sentiment_pipe.model
+    dummy_input = torch.randint(0, 30522, (1, 128)).to(device)  # example token IDs
+    torch.onnx.export(
+        torch_model,
+        dummy_input,
+        "sentiment.onnx",
+        input_names=["input_ids"],
+        output_names=["logits"],
+        opset_version=12,
+        dynamic_axes={"input_ids": {0: "batch", 1: "seq"}},
+    )
+    mo.md("✅ Exported sentiment model to `sentiment.onnx`")
+    mo.md(
+        """
+        Convert to GGUF (decoder‑only models) with:
+        ```bash
+        pip install gguf-converter
+        gguf-converter --onnx sentiment.onnx --output sentiment.gguf
+        ```
+        """
+    )
+    return
+
+
+if __name__ == "__main__":
+    app.run()

marimo/requirements.txt

@@ -0,0 +1,11 @@
+marimo>=0.19.0
+transformers>=4.36.0
+torch>=2.0.0
+numpy>=1.24.0
+scikit-learn>=1.3.0
+matplotlib>=3.7.0
+sentencepiece
+protobuf
+Pillow>=10.0.0
+diffusers>=0.25.0
+accelerate

mise.toml

@@ -0,0 +1,2 @@
+[tools]
+elixir = "latest"

mix.exs

@@ -0,0 +1,63 @@
+defmodule MLLearning.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :ml_elixir_learning,
+      version: "0.1.0",
+      elixir: "~> 1.16",
+      start_permanent: Mix.env() == :prod,
+      deps: deps(),
+      aliases: aliases()
+    ]
+  end
+
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  defp deps do
+    [
+      # Core ML
+      {:nx, "~> 0.10"},
+      {:axon, "~> 0.7"},
+      {:exla, "~> 0.10"},
+
+      # Pre-trained models (Hugging Face Hub)
+      {:bumblebee, "~> 0.6"},
+
+      # Data
+      {:explorer, "~> 0.10"},
+      {:scidata, "~> 0.1"},
+
+      # Image / Audio IO
+      {:stb_image, "~> 0.6"},
+
+      # Visualization
+      {:kino, "~> 0.15"},
+      {:kino_vega_lite, "~> 0.1"},
+      {:vega_lite, "~> 0.1"},
+
+      # HTTP
+      {:req, "~> 0.5"},
+
+      # Web framework (for LiveView deployment section)
+      {:phoenix, "~> 1.7"},
+      {:phoenix_live_view, "~> 1.0"},
+      {:bandit, "~> 1.0"},
+
+      # Dev / Test
+      {:benchee, "~> 1.0", only: :dev},
+      {:ex_doc, "~> 0.34", only: :dev, runtime: false}
+    ]
+  end
+
+  defp aliases do
+    [
+      setup: ["deps.get", "deps.compile"],
+      nb: ["livebook", "server"]
+    ]
+  end
+end

mix.lock

@@ -0,0 +1,62 @@
+%{
+  "aws_signature": {:hex, :aws_signature, "0.4.2", "1b35482c89ff5b91f5ead647a2bbc0d9620877479b44800915de92bacf9f1476", [:rebar3], [], "hexpm", "1df4a2d1dff200c7bdfa8f9f935efc71a51273adfc6dd39a9f2cc937e01baa01"},
+  "axon": {:hex, :axon, "0.7.0", "2e2c6d93b4afcfa812566b8922204fa022b60081e86ebd411df4db7ea30f5457", [:mix], [{:kino, "~> 0.7", [hex: :kino, repo: "hexpm", optional: true]}, {:kino_vega_lite, "~> 0.1.7", [hex: :kino_vega_lite, repo: "hexpm", optional: true]}, {:nx, "~> 0.9", [hex: :nx, repo: "hexpm", optional: false]}, {:polaris, "~> 0.1", [hex: :polaris, repo: "hexpm", optional: false]}, {:table_rex, "~> 3.1.1", [hex: :table_rex, repo: "hexpm", optional: true]}], "hexpm", "ee9857a143c9486597ceff434e6ca833dc1241be6158b01025b8217757ed1036"},
+  "bandit": {:hex, :bandit, "1.10.4", "02b9734c67c5916a008e7eb7e2ba68aaea6f8177094a5f8d95f1fb99069aac17", [:mix], [{:hpax, "~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.0", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "a5faf501042ac1f31d736d9d4a813b3db4ef812e634583b6a457b0928798a51d"},
+  "benchee": {:hex, :benchee, "1.5.0", "4d812c31d54b0ec0167e91278e7de3f596324a78a096fd3d0bea68bb0c513b10", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.1", [hex: :statistex, repo: "hexpm", optional: false]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "5b075393aea81b8ae74eadd1c28b1d87e8a63696c649d8293db7c4df3eb67535"},
+  "bumblebee": {:hex, :bumblebee, "0.6.3", "c0028643c92de93258a9804da1d4d48797eaf7911b702464b3b3dd2cc7f938f1", [:mix], [{:axon, "~> 0.7.0", [hex: :axon, repo: "hexpm", optional: false]}, {:jason, "~> 1.4.0", [hex: :jason, repo: "hexpm", optional: false]}, {:nx, "~> 0.9.0 or ~> 0.10.0", [hex: :nx, repo: "hexpm", optional: false]}, {:nx_image, "~> 0.1.0", [hex: :nx_image, repo: "hexpm", optional: false]}, {:nx_signal, "~> 0.2.0", [hex: :nx_signal, repo: "hexpm", optional: false]}, {:progress_bar, "~> 3.0", [hex: :progress_bar, repo: "hexpm", optional: false]}, {:safetensors, "~> 0.1.3", [hex: :safetensors, repo: "hexpm", optional: false]}, {:tokenizers, "~> 0.4", [hex: :tokenizers, repo: "hexpm", optional: false]}, {:unpickler, "~> 0.1.0", [hex: :unpickler, repo: "hexpm", optional: false]}, {:unzip, "~> 0.12.0", [hex: :unzip, repo: "hexpm", optional: false]}], "hexpm", "c619197787561f8e5fb2ffba269c341654accaec9d591999b7fddd55761dd079"},
+  "castore": {:hex, :castore, "1.0.18", "5e43ef0ec7d31195dfa5a65a86e6131db999d074179d2ba5a8de11fe14570f55", [:mix], [], "hexpm", "f393e4fe6317829b158fb74d86eb681f737d2fe326aa61ccf6293c4104957e34"},
+  "cc_precompiler": {:hex, :cc_precompiler, "0.1.11", "8c844d0b9fb98a3edea067f94f616b3f6b29b959b6b3bf25fee94ffe34364768", [:mix], [{:elixir_make, "~> 0.7", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "3427232caf0835f94680e5bcf082408a70b48ad68a5f5c0b02a3bea9f3a075b9"},
+  "complex": {:hex, :complex, "0.6.0", "b0130086a7a8c33574d293b2e0e250f4685580418eac52a5658a4bd148f3ccf1", [:mix], [], "hexpm", "0a5fa95580dcaf30fcd60fe1aaf24327c0fe401e98c24d892e172e79498269f9"},
+  "decimal": {:hex, :decimal, "2.3.0", "3ad6255aa77b4a3c4f818171b12d237500e63525c2fd056699967a3e7ea20f62", [:mix], [], "hexpm", "a4d66355cb29cb47c3cf30e71329e58361cfcb37c34235ef3bf1d7bf3773aeac"},
+  "deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
+  "earmark_parser": {:hex, :earmark_parser, "1.4.44", "f20830dd6b5c77afe2b063777ddbbff09f9759396500cdbe7523efd58d7a339c", [:mix], [], "hexpm", "4778ac752b4701a5599215f7030989c989ffdc4f6df457c5f36938cc2d2a2750"},
+  "elixir_make": {:hex, :elixir_make, "0.9.0", "6484b3cd8c0cee58f09f05ecaf1a140a8c97670671a6a0e7ab4dc326c3109726", [:mix], [], "hexpm", "db23d4fd8b757462ad02f8aa73431a426fe6671c80b200d9710caf3d1dd0ffdb"},
+  "ex_doc": {:hex, :ex_doc, "0.40.1", "67542e4b6dde74811cfd580e2c0149b78010fd13001fda7cfeb2b2c2ffb1344d", [:mix], [{:earmark_parser, "~> 1.4.44", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "bcef0e2d360d93ac19f01a85d58f91752d930c0a30e2681145feea6bd3516e00"},
+  "exla": {:hex, :exla, "0.10.0", "93e7d75a774fbc06ce05b96de20c4b01bda413b315238cb3c727c09a05d2bc3a", [:make, :mix], [{:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:fine, "~> 0.1.0", [hex: :fine, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:nx, "~> 0.10.0", [hex: :nx, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:xla, "~> 0.9.0", [hex: :xla, repo: "hexpm", optional: false]}], "hexpm", "16fffdb64667d7f0a3bc683fdcd2792b143a9b345e4b1f1d5cd50330c63d8119"},
+  "explorer": {:hex, :explorer, "0.10.1", "ff6e2a7d7a480c86708c3300cc67a3fd6982c7d28b51f4db2f411aa476c9ecdb", [:mix], [{:adbc, "~> 0.1", [hex: :adbc, repo: "hexpm", optional: true]}, {:aws_signature, "~> 0.3", [hex: :aws_signature, repo: "hexpm", optional: false]}, {:castore, "~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:decimal, "~> 2.1", [hex: :decimal, repo: "hexpm", optional: false]}, {:flame, "~> 0.3", [hex: :flame, repo: "hexpm", optional: true]}, {:fss, "~> 0.1", [hex: :fss, repo: "hexpm", optional: false]}, {:nx, "~> 0.4", [hex: :nx, repo: "hexpm", optional: true]}, {:rustler, "~> 0.34.0", [hex: :rustler, repo: "hexpm", optional: true]}, {:rustler_precompiled, "~> 0.7", [hex: :rustler_precompiled, repo: "hexpm", optional: false]}, {:table, "~> 0.1.2", [hex: :table, repo: "hexpm", optional: false]}, {:table_rex, "~> 3.1.1 or ~> 4.0.0", [hex: :table_rex, repo: "hexpm", optional: false]}], "hexpm", "4e3efc45d4981a568405a181ebf206ba208622a5e94048c9d713b27a053c3197"},
+  "finch": {:hex, :finch, "0.21.0", "b1c3b2d48af02d0c66d2a9ebfb5622be5c5ecd62937cf79a88a7f98d48a8290c", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.6.2 or ~> 1.7", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.1", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "87dc6e169794cb2570f75841a19da99cfde834249568f2a5b121b809588a4377"},
+  "fine": {:hex, :fine, "0.1.4", "b19a89c1476c7c57afb5f9314aed5960b5bc95d5277de4cb5ee8e1d1616ce379", [:mix], [], "hexpm", "be3324cc454a42d80951cf6023b9954e9ff27c6daa255483b3e8d608670303f5"},
+  "fss": {:hex, :fss, "0.1.1", "9db2344dbbb5d555ce442ac7c2f82dd975b605b50d169314a20f08ed21e08642", [:mix], [], "hexpm", "78ad5955c7919c3764065b21144913df7515d52e228c09427a004afe9c1a16b0"},
+  "hpax": {:hex, :hpax, "1.0.3", "ed67ef51ad4df91e75cc6a1494f851850c0bd98ebc0be6e81b026e765ee535aa", [:mix], [], "hexpm", "8eab6e1cfa8d5918c2ce4ba43588e894af35dbd8e91e6e55c817bca5847df34a"},
+  "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"},
+  "kino": {:hex, :kino, "0.19.0", "fc8e46fefeb2d083e757633ddd810c499754b7a1f87ba1e92844791c1eca87c2", [:mix], [{:nx, "~> 0.1", [hex: :nx, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}, {:table, "~> 0.1.2", [hex: :table, repo: "hexpm", optional: false]}], "hexpm", "195956058730acc397375a398835c7818f92aa01a1d32c03ecb5dffff74c0b8c"},
+  "kino_vega_lite": {:hex, :kino_vega_lite, "0.1.13", "03c00405987a2202e4b8014ee55eb7f5727691b3f13d76a3764f6eeccef45322", [:mix], [{:kino, "~> 0.7", [hex: :kino, repo: "hexpm", optional: false]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: false]}, {:vega_lite, "~> 0.1.8", [hex: :vega_lite, repo: "hexpm", optional: false]}], "hexpm", "00c72bc270e7b9d3c339f726cdab0012fd3f2fc75e36c7548e0f250fe420fa10"},
+  "makeup": {:hex, :makeup, "1.2.1", "e90ac1c65589ef354378def3ba19d401e739ee7ee06fb47f94c687016e3713d1", [:mix], [{:nimble_parsec, "~> 1.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "d36484867b0bae0fea568d10131197a4c2e47056a6fbe84922bf6ba71c8d17ce"},
+  "makeup_elixir": {:hex, :makeup_elixir, "1.0.1", "e928a4f984e795e41e3abd27bfc09f51db16ab8ba1aebdba2b3a575437efafc2", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "7284900d412a3e5cfd97fdaed4f5ed389b8f2b4cb49efc0eb3bd10e2febf9507"},
+  "makeup_erlang": {:hex, :makeup_erlang, "1.0.3", "4252d5d4098da7415c390e847c814bad3764c94a814a0b4245176215615e1035", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "953297c02582a33411ac6208f2c6e55f0e870df7f80da724ed613f10e6706afd"},
+  "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"},
+  "mint": {:hex, :mint, "1.7.1", "113fdb2b2f3b59e47c7955971854641c61f378549d73e829e1768de90fc1abf1", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "fceba0a4d0f24301ddee3024ae116df1c3f4bb7a563a731f45fdfeb9d39a231b"},
+  "nimble_csv": {:hex, :nimble_csv, "1.3.0", "b7f998dc62b222bce9596e46f028c7a5af04cb5dde6df2ea197c583227c54971", [:mix], [], "hexpm", "41ccdc18f7c8f8bb06e84164fc51635321e80d5a3b450761c4997d620925d619"},
+  "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"},
+  "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},
+  "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"},
+  "nx": {:hex, :nx, "0.10.0", "128e4a094cb790f663e20e1334b127c1f2a4df54edfb8b13c22757ec33133b4f", [:mix], [{:complex, "~> 0.6", [hex: :complex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3db8892c124aeee091df0e6fbf8e5bf1b81f502eb0d4f5ba63e6378ebcae7da4"},
+  "nx_image": {:hex, :nx_image, "0.1.2", "0c6e3453c1dc30fc80c723a54861204304cebc8a89ed3b806b972c73ee5d119d", [:mix], [{:nx, "~> 0.4", [hex: :nx, repo: "hexpm", optional: false]}], "hexpm", "9161863c42405ddccb6dbbbeae078ad23e30201509cc804b3b3a7c9e98764b81"},
+  "nx_signal": {:hex, :nx_signal, "0.2.0", "e1ca0318877b17c81ce8906329f5125f1e2361e4c4235a5baac8a95ee88ea98e", [:mix], [{:nx, "~> 0.6", [hex: :nx, repo: "hexpm", optional: false]}], "hexpm", "7247e5e18a177a59c4cb5355952900c62fdeadeb2bad02a9a34237b68744e2bb"},
+  "phoenix": {:hex, :phoenix, "1.8.5", "919db335247e6d4891764dc3063415b0d2457641c5f9b3751b5df03d8e20bbcf", [:mix], [{:bandit, "~> 1.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "83b2bb125127e02e9f475c8e3e92736325b5b01b0b9b05407bcb4083b7a32485"},
+  "phoenix_html": {:hex, :phoenix_html, "4.3.0", "d3577a5df4b6954cd7890c84d955c470b5310bb49647f0a114a6eeecc850f7ad", [:mix], [], "hexpm", "3eaa290a78bab0f075f791a46a981bbe769d94bc776869f4f3063a14f30497ad"},
+  "phoenix_live_view": {:hex, :phoenix_live_view, "1.1.28", "8a8e123d018025f756605a2fb02a4854f0d3cd7b207f710fef1fd5d9d72d0254", [:mix], [{:igniter, ">= 0.6.16 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:lazy_html, "~> 0.1.0", [hex: :lazy_html, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0 or ~> 1.8.0-rc", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "24faad535b65089642c3a7d84088109dc58f49c1f1c5a978659855d643466353"},
+  "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.2.0", "ff3a5616e1bed6804de7773b92cbccfc0b0f473faf1f63d7daf1206c7aeaaa6f", [:mix], [], "hexpm", "adc313a5bf7136039f63cfd9668fde73bba0765e0614cba80c06ac9460ff3e96"},
+  "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
+  "plug": {:hex, :plug, "1.19.1", "09bac17ae7a001a68ae393658aa23c7e38782be5c5c00c80be82901262c394c0", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "560a0017a8f6d5d30146916862aaf9300b7280063651dd7e532b8be168511e62"},
+  "plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"},
+  "polaris": {:hex, :polaris, "0.1.0", "dca61b18e3e801ecdae6ac9f0eca5f19792b44a5cb4b8d63db50fc40fc038d22", [:mix], [{:nx, "~> 0.5", [hex: :nx, repo: "hexpm", optional: false]}], "hexpm", "13ef2b166650e533cb24b10e2f3b8ab4f2f449ba4d63156e8c569527f206e2c2"},
+  "progress_bar": {:hex, :progress_bar, "3.0.0", "f54ff038c2ac540cfbb4c2bfe97c75e7116ead044f3c2b10c9f212452194b5cd", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm", "6981c2b25ab24aecc91a2dc46623658e1399c21a2ae24db986b90d678530f2b7"},
+  "req": {:hex, :req, "0.5.17", "0096ddd5b0ed6f576a03dde4b158a0c727215b15d2795e59e0916c6971066ede", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "0b8bc6ffdfebbc07968e59d3ff96d52f2202d0536f10fef4dc11dc02a2a43e39"},
+  "rustler_precompiled": {:hex, :rustler_precompiled, "0.9.0", "3a052eda09f3d2436364645cc1f13279cf95db310eb0c17b0d8f25484b233aa0", [:mix], [{:rustler, "~> 0.23", [hex: :rustler, repo: "hexpm", optional: true]}], "hexpm", "471d97315bd3bf7b64623418b3693eedd8e47de3d1cb79a0ac8f9da7d770d94c"},
+  "safetensors": {:hex, :safetensors, "0.1.3", "7ff3c22391e213289c713898481d492c9c28a49ab1d0705b72630fb8360426b2", [:mix], [{:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:nx, "~> 0.5", [hex: :nx, repo: "hexpm", optional: false]}], "hexpm", "fe50b53ea59fde4e723dd1a2e31cfdc6013e69343afac84c6be86d6d7c562c14"},
+  "scidata": {:hex, :scidata, "0.1.8", "80b1a470efb4f4a2fc2a7d26711217948d8bc2e17f636d41d846035b44f0ce8a", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.1", [hex: :nimble_csv, repo: "hexpm", optional: false]}, {:stb_image, "~> 0.4", [hex: :stb_image, repo: "hexpm", optional: true]}], "hexpm", "8fb125a2a55f52fea78f708f7bbd7bb3b8c233bf3943b411bc659252bcb12bab"},
+  "statistex": {:hex, :statistex, "1.1.0", "7fec1eb2f580a0d2c1a05ed27396a084ab064a40cfc84246dbfb0c72a5c761e5", [:mix], [], "hexpm", "f5950ea26ad43246ba2cce54324ac394a4e7408fdcf98b8e230f503a0cba9cf5"},
+  "stb_image": {:hex, :stb_image, "0.6.10", "76975279e2a130f53dc670bf6f6b1cdc4fbd7ab6293053e88e7fb6a7eae0e836", [:make, :mix], [{:cc_precompiler, "~> 0.1", [hex: :cc_precompiler, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.8", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:kino, "~> 0.7", [hex: :kino, repo: "hexpm", optional: true]}, {:nx, "~> 0.4", [hex: :nx, repo: "hexpm", optional: true]}], "hexpm", "26125372cfeda209084d3670417fab6819cfccd0e66c657678ecc48314369e8d"},
+  "table": {:hex, :table, "0.1.2", "87ad1125f5b70c5dea0307aa633194083eb5182ec537efc94e96af08937e14a8", [:mix], [], "hexpm", "7e99bc7efef806315c7e65640724bf165c3061cdc5d854060f74468367065029"},
+  "table_rex": {:hex, :table_rex, "3.1.1", "0c67164d1714b5e806d5067c1e96ff098ba7ae79413cc075973e17c38a587caa", [:mix], [], "hexpm", "678a23aba4d670419c23c17790f9dcd635a4a89022040df7d5d772cb21012490"},
+  "telemetry": {:hex, :telemetry, "1.4.1", "ab6de178e2b29b58e8256b92b382ea3f590a47152ca3651ea857a6cae05ac423", [:rebar3], [], "hexpm", "2172e05a27531d3d31dd9782841065c50dd5c3c7699d95266b2edd54c2dafa1c"},
+  "thousand_island": {:hex, :thousand_island, "1.4.3", "2158209580f633be38d43ec4e3ce0a01079592b9657afff9080d5d8ca149a3af", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6e4ce09b0fd761a58594d02814d40f77daff460c48a7354a15ab353bb998ea0b"},
+  "tokenizers": {:hex, :tokenizers, "0.5.1", "b0975d92b4ee5b18e8f47b5d65b9d5f1e583d9130189b1a2620401af4e7d4b35", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:rustler, ">= 0.0.0", [hex: :rustler, repo: "hexpm", optional: true]}, {:rustler_precompiled, "~> 0.6", [hex: :rustler_precompiled, repo: "hexpm", optional: false]}], "hexpm", "5f08d97cc7f2ed3d71d370d68120da6d3de010948ccf676c9c0eb591ba4bacc9"},
+  "unpickler": {:hex, :unpickler, "0.1.0", "c2262c0819e6985b761e7107546cef96a485f401816be5304a65fdd200d5bd6a", [:mix], [], "hexpm", "e2b3f61e62406187ac52afead8a63bfb4e49394028993f3c4c42712743cab79e"},
+  "unzip": {:hex, :unzip, "0.12.0", "beed92238724732418b41eba77dcb7f51e235b707406c05b1732a3052d1c0f36", [:mix], [], "hexpm", "95655b72db368e5a84951f0bed586ac053b55ee3815fd96062fce10ce4fc998d"},
+  "vega_lite": {:hex, :vega_lite, "0.1.11", "2b261d21618f6fa9f63bb4542f0262982d2e40aea3f83e935788fe172902b3c2", [:mix], [{:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: false]}], "hexpm", "d18c3f11369c14bdf36ab53010c06bf5505c221cbcb32faac7420cf6926b3c50"},
+  "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
+  "websock_adapter": {:hex, :websock_adapter, "0.5.9", "43dc3ba6d89ef5dec5b1d0a39698436a1e856d000d84bf31a3149862b01a287f", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "5534d5c9adad3c18a0f58a9371220d75a803bf0b9a3d87e6fe072faaeed76a08"},
+  "xla": {:hex, :xla, "0.9.1", "cca0040ff94902764007a118871bfc667f1a0085d4a5074533a47d6b58bec61e", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "eb5e443ae5391b1953f253e051f2307bea183b59acee138053a9300779930daf"},
+}

ml_e2e_template.livemd

@@ -0,0 +1,1227 @@
+# Machine Learning in Elixir — End-to-End with Bumblebee + Hugging Face
+
+<!-- livebook:{"persist_outputs":true} -->
+
+## Overview
+
+## Skills
+- `hf_cli.md` – Hugging Face CLI usage
+- `hf_jobs.md` – Running workloads on HF Jobs
+- `training_trl.md` – TRL model training
+- `hf_dataset_viewer.md` – Dataset Viewer API
+- `gradio.md` – Gradio UI integration
+- *(Full catalog at https://skills.sh/huggingface/skills)*
+
+This Livebook is a complete end-to-end ML template built on the Elixir ML ecosystem
+from _Machine Learning in Elixir_ by Sean Moriarity, with **Bumblebee** as the core
+integration layer to the **Hugging Face Hub**.
+
+**What we cover:**
+
+| Section | Library | Task |
+|---------|---------|------|
+| Foundations | `Nx` | Tensors, gradients, JIT compilation |
+| Pre-trained NLP | `Bumblebee` | Fill-mask, sentiment, NER, zero-shot |
+| Pre-trained Vision | `Bumblebee` | Image classification (ViT, ResNet) |
+| Audio | `Bumblebee` | Speech-to-text (Whisper) |
+| Generative AI | `Bumblebee` | Text generation (GPT-2) & Stable Diffusion |
+| Embeddings | `Bumblebee` | Sentence similarity search |
+| Custom Training | `Axon` | Build & train from scratch |
+| Fine-tuning | `Bumblebee` | Boosted training on pre-trained models |
+| Serving | `Nx.Serving` | Production batched inference |
+| Deployment | `Phoenix` | LiveView integration pattern |
+| Interactive UI | `Kino` | Live input forms & charts |
+
+---
+
+## Section 0 — Install & Configure
+
+```elixir
+Mix.install([
+  {:nx, "~> 0.10"},
+  {:axon, "~> 0.7"},
+  {:exla, "~> 0.10"},
+  {:bumblebee, "~> 0.6"},
+  {:kino, "~> 0.15"},
+  {:kino_vega_lite, "~> 0.1"},
+  {:vega_lite, "~> 0.1"},
+  {:stb_image, "~> 0.6"},
+  {:req, "~> 0.5"}
+])
+
+Nx.global_default_backend(EXLA.Backend)
+
+IO.puts("Nx version:        #{Nx.version()}")
+IO.puts("Axon version:      #{Axon.version()}")
+IO.puts("EXLA backend:      #{inspect(Nx.default_backend())}")
+IO.puts("Bumblebee loaded:  #{Code.ensure_loaded?(Bumblebee)}")
+IO.puts("Cache dir:         #{Bumblebee.cache_dir()}")
+```
+
+---
+
+## Section 1 — Nx Foundations
+
+Before diving into Bumblebee, let's ground ourselves in Nx — the numerical
+backbone that every Elixir ML library builds on.
+
+### 1.1 Tensors
+
+```elixir
+import Nx
+
+# Scalars, vectors, matrices, higher-order
+scalar = Nx.tensor(3.14)
+vector = Nx.tensor([1.0, 2.0, 3.0])
+matrix = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+cube = Nx.iota({2, 3, 4})
+
+IO.puts("scalar  shape=#{inspect(Nx.shape(scalar))}  type=#{Nx.type(scalar)}")
+IO.puts("vector  shape=#{inspect(Nx.shape(vector))}  type=#{Nx.type(vector)}")
+IO.puts("matrix  shape=#{inspect(Nx.shape(matrix))}  type=#{Nx.type(matrix)}")
+IO.puts("cube    shape=#{inspect(Nx.shape(cube))}  type=#{Nx.type(cube)}")
+
+{scalar, vector, matrix}
+```
+
+### 1.2 Operations & Broadcasting
+
+```elixir
+a = Nx.tensor([1.0, 2.0, 3.0])
+b = Nx.tensor([10.0, 20.0, 30.0])
+
+# Element-wise
+IO.puts("add:       #{inspect(Nx.add(a, b))}")
+IO.puts("multiply:  #{inspect(Nx.multiply(a, b))}")
+IO.puts("pow:       #{inspect(Nx.pow(a, 2))}")
+
+# Reductions
+IO.puts("sum:       #{Nx.sum(a)}")
+IO.puts("mean:      #{Nx.mean(a)}")
+IO.puts("std:       #{Nx.standard_deviation(a)}")
+
+# Dot product
+IO.puts("dot:       #{Nx.dot(a, b)}")
+
+# Matrix multiply
+m1 = Nx.tensor([[1.0, 2.0], [3.0, 4.0]])
+m2 = Nx.tensor([[5.0, 6.0], [7.0, 8.0]])
+IO.puts("matmul:    #{inspect(Nx.dot(m1, m2))}")
+```
+
+### 1.3 Automatic Differentiation
+
+This is how models learn — computing gradients of loss with respect to parameters.
+
+```elixir
+defmodule AutoDiff do
+  import Nx.Defn
+
+  # Define a function f(x) = x³ + 2x²
+  defnp f(x), do: Nx.pow(x, 3) + 2 * Nx.pow(x, 2)
+
+  # Compute gradient symbolically
+  def grad_f(x), do: Nx.Defn.grad(x, &f/1)
+
+  # Gradient of MSE loss
+  defnp mse_loss(y_true, y_pred) do
+    Nx.mean(Nx.pow(y_true - y_pred, 2))
+  end
+
+  def grad_mse(y_true, y_pred, w) do
+    Nx.Defn.grad(w, fn weights ->
+      predictions = Nx.dot(y_pred, weights)
+      mse_loss(y_true, predictions)
+    end)
+  end
+end
+
+x = Nx.tensor(3.0)
+IO.puts("f(3)      = #{Nx.to_number(AutoDiff.f(x))}")
+IO.puts("f'(3)     = #{Nx.to_number(AutoDiff.grad_f(x))}")
+IO.puts("expected  = 3*9 + 2*2*3 = #{3 * 9 + 2 * 2 * 3}")
+```
+
+### 1.4 JIT Compilation
+
+```elixir
+# JIT compiles for GPU/CPU acceleration — critical for inference speed
+defmodule FastMath do
+  import Nx.Defn
+
+  defn slow_sigmoid(x) do
+    1 / (1 + Nx.exp(-x))
+  end
+end
+
+# JIT-compiled version
+fast_sigmoid = Nx.Defn.jit(&FastMath.slow_sigmoid/1)
+
+input = Nx.tensor([[-2.0, -1.0, 0.0, 1.0, 2.0]])
+
+# Benchmark
+{us, result} = :timer.tc(fn -> fast_sigmoid.(input) end)
+IO.puts("JIT sigmoid: #{us}μs  result=#{inspect(result)}")
+```
+
+---
+
+## Section 2 — Bumblebee: Pre-trained NLP Models
+
+Bumblebee loads pre-trained models from the Hugging Face Hub and wraps them
+in `Nx.Serving` for production-ready batched inference.
+
+### 2.1 Fill-Mask (BERT)
+
+```elixir
+{:ok, bert_model} = Bumblebee.load_model({:hf, "google-bert/bert-base-uncased"})
+{:ok, bert_tokenizer} = Bumblebee.load_tokenizer({:hf, "google-bert/bert-base-uncased"})
+
+bert_fill_mask = Bumblebee.Text.fill_mask(bert_model, bert_tokenizer)
+
+results = Nx.Serving.run(bert_fill_mask, "Elixir is a [MASK] language.")
+IO.inspect(results, label: "Fill-Mask Results")
+```
+
+### 2.2 Sentiment Analysis (DistilBERT)
+
+```elixir
+{:ok, sentiment_model} =
+  Bumblebee.load_model({:hf, "distilbert/distilbert-base-uncased-finetuned-sst-2-english"})
+
+{:ok, sentiment_tokenizer} =
+  Bumblebee.load_tokenizer({:hf, "distilbert/distilbert-base-uncased-finetuned-sst-2-english"})
+
+sentiment_serving = Bumblebee.Text.Classification.text_classification(
+  sentiment_model,
+  sentiment_tokenizer
+)
+
+texts = [
+  "Machine learning in Elixir is amazing!",
+  "This tutorial is boring and confusing.",
+  "The BEAM VM handles concurrent ML workloads well.",
+  "I love how functional programming simplifies ML pipelines."
+]
+
+Enum.each(texts, fn text ->
+  result = Nx.Serving.run(sentiment_serving, text)
+  IO.puts("#{inspect(result)}  ← \"#{String.slice(text, 0..50)}...\"")
+end)
+```
+
+### 2.3 Named Entity Recognition (BERT-NER)
+
+```elixir
+{:ok, ner_model} = Bumblebee.load_model({:hf, "dslim/bert-base-NER"})
+{:ok, ner_tokenizer} = Bumblebee.load_tokenizer({:hf, "google-bert/bert-base-uncased"})
+
+ner_serving = Bumblebee.Text.TokenClassification.token_classification(
+  ner_model,
+  ner_tokenizer
+)
+
+ner_text = "Sean Moriarity wrote Machine Learning in Elixir for Pragmatic Bookshelf. He lives in Austin, Texas."
+ner_result = Nx.Serving.run(ner_serving, ner_text)
+
+IO.puts("Input: #{ner_text}")
+IO.inspect(ner_result, label: "NER Entities")
+```
+
+### 2.4 Zero-Shot Classification
+
+No fine-tuning needed — classify arbitrary text into custom categories.
+
+```elixir
+{:ok, zs_model} = Bumblebee.load_model({:hf, "facebook/bart-large-mnli"})
+{:ok, zs_tokenizer} = Bumblebee.load_tokenizer({:hf, "facebook/bart-large-mnli"})
+
+zs_serving = Bumblebee.Text.ZeroShotClassification.zero_shot_classification(
+  zs_model,
+  zs_tokenizer
+)
+
+article = """
+Nx brings numerical computing to the BEAM, enabling machine learning
+pipelines that leverage Elixir's concurrency and fault tolerance.
+Bumblebee provides access to thousands of pre-trained models from
+the Hugging Face Hub directly in Livebook.
+"""
+
+labels = ["technology", "sports", "politics", "science", "finance"]
+zs_result = Nx.Serving.run(zs_serving, %{text: article, labels: labels})
+
+IO.inspect(zs_result, label: "Zero-Shot Classification")
+```
+
+---
+
+## Section 3 — Bumblebee: Vision Models
+
+### 3.1 Image Classification (ViT / ResNet)
+
+```elixir
+{:ok, vit_model} = Bumblebee.load_model({:hf, "google/vit-base-patch16-224"})
+{:ok, vit_featurizer} = Bumblebee.load_featurizer({:hf, "google/vit-base-patch16-224"})
+
+vit_serving = Bumblebee.Vision.ImageClassification.image_classification(
+  vit_model,
+  vit_featurizer
+)
+
+# Download a sample image
+image_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
+image_data = Req.get!(image_url).body
+
+# Save and load
+File.write!("/tmp/sample.jpg", image_data)
+{:ok, image} = StbImage.read_file("/tmp/sample.jpg")
+
+IO.puts("Image: #{StbImage.width(image)}x#{StbImage.height(image)}")
+
+img_result = Nx.Serving.run(vit_serving, image)
+IO.inspect(img_result, label: "Image Classification")
+```
+
+### 3.2 Batch Image Classification
+
+```elixir
+# Nx.Serving automatically batches multiple requests for GPU efficiency
+images = [image]  # In production, this would be multiple images
+
+batch_result = Nx.Serving.run(vit_serving, images)
+IO.inspect(batch_result, label: "Batch Classification")
+```
+
+---
+
+## Section 4 — Bumblebee: Text Generation
+
+### 4.1 GPT-2 Text Generation
+
+```elixir
+{:ok, gpt2_model} = Bumblebee.load_model({:hf, "openai-community/gpt2"})
+{:ok, gpt2_tokenizer} = Bumblebee.load_tokenizer({:hf, "openai-community/gpt2"})
+{:ok, gpt2_generation_config} = Bumblebee.load_generation_config({:hf, "openai-community/gpt2"})
+
+gpt2_serving = Bumblebee.Text.generation(
+  gpt2_model,
+  gpt2_tokenizer,
+  gpt2_generation_config,
+  compile: [batch_size: 1, sequence_length: 64],
+  defn_options: [compiler: EXLA]
+)
+
+prompt = "Machine learning in Elixir is"
+gen_result = Nx.Serving.run(gpt2_serving, prompt)
+
+IO.puts("Prompt: #{prompt}")
+IO.puts("Output: #{inspect(gen_result)}")
+```
+
+### 4.2 Interactive Text Generation
+
+<!-- livebook:{"attrs":{"source":"# Interactive Text Generation\nalias Kino.Input\n\nprompt_input = Kino.Input.text(\"Prompt\", default: \"The future of ML in Elixir is\")\nmax_tokens = Kino.Input.number(\"Max tokens\", default: 50)\n\nform = Kino.Control.form(\n  %{prompt: prompt_input, max_tokens: max_tokens},\n  submit: \"Generate\"\n)\n\nKino.listen(form, fn %{data: %{prompt: prompt, max_tokens: max_tokens}} ->\n  config = Bumblebee.configure(gpt2_generation_config, max_new_tokens: trunc(max_tokens))\n  serving = Bumblebee.Text.generation(gpt2_model, gpt2_tokenizer, config)\n  result = Nx.Serving.run(serving, prompt)\n  Kino.Text.new(\"#{prompt}#{result.text}\")\nend)\n\nform","title":"GPT-2 Generator"},"chunks":[{"chunk":"","type":"Elixir"}],"kind":"Elixir","source_type":"cell"} -->
+
+```elixir
+alias Kino.Input
+
+prompt_input = Kino.Input.text("Prompt", default: "The future of ML in Elixir is")
+max_tokens_input = Kino.Input.number("Max tokens", default: 50)
+
+form =
+  Kino.Control.form(
+    %{prompt: prompt_input, max_tokens: max_tokens_input},
+    submit: "Generate"
+  )
+
+Kino.listen(form, fn %{data: %{prompt: prompt, max_tokens: max_tokens}} ->
+  config = Bumblebee.configure(gpt2_generation_config, max_new_tokens: trunc(max_tokens))
+
+  serving =
+    Bumblebee.Text.generation(
+      gpt2_model,
+      gpt2_tokenizer,
+      config,
+      defn_options: [compiler: EXLA]
+    )
+
+  result = Nx.Serving.run(serving, prompt)
+  Kino.Text.new("#{prompt}#{result.text}")
+end)
+
+form
+```
+
+---
+
+## Section 5 — Bumblebee: Embeddings & Similarity
+
+### 5.1 Sentence Embeddings
+
+```elixir
+{:ok, emb_model} = Bumblebee.load_model({:hf, "sentence-transformers/all-MiniLM-L6-v2"})
+{:ok, emb_tokenizer} = Bumblebee.load_tokenizer({:hf, "sentence-transformers/all-MiniLM-L6-v2"})
+
+embedding_serving = Bumblebee.Text.TextEmbedding.text_embedding(
+  emb_model,
+  emb_tokenizer
+)
+
+sentences = [
+  "Nx provides numerical computing for Elixir",
+  "Axon is a neural network library built on Nx",
+  "Bumblebee connects Elixir to the Hugging Face Hub",
+  "I enjoy cooking Italian food on weekends",
+  "The weather forecast predicts rain tomorrow"
+]
+
+embeddings =
+  Enum.map(sentences, fn s ->
+    result = Nx.Serving.run(embedding_serving, s)
+    result.embedding
+  end)
+
+IO.puts("Generated #{length(embeddings)} embeddings")
+IO.puts("Embedding dim: #{inspect(Nx.shape(hd(embeddings)))}")
+```
+
+### 5.2 Cosine Similarity Search
+
+```elixir
+defmodule Similarity do
+  import Nx
+
+  defn cosine_similarity(a, b) do
+    a_norm = a / Nx.sqrt(Nx.sum(a * a))
+    b_norm = b / Nx.sqrt(Nx.sum(b * b))
+    Nx.sum(a_norm * b_norm)
+  end
+
+  def find_most_similar(query_embedding, corpus_embeddings) do
+    corpus_embeddings
+    |> Enum.map(fn emb -> Nx.to_number(cosine_similarity(query_embedding, emb)) end)
+    |> Enum.with_index()
+    |> Enum.sort_by(fn {score, _idx} -> -score end)
+  end
+end
+
+query = "How do I build neural networks in Elixir?"
+query_emb = Nx.Serving.run(embedding_serving, query).embedding
+
+IO.puts("Query: \"#{query}\"\n")
+
+Similarity.find_most_similar(query_emb, embeddings)
+|> Enum.each(fn {score, idx} ->
+  IO.puts("  #{Float.round(score, 4)}  #{Enum.at(sentences, idx)}")
+end)
+```
+
+---
+
+## Section 5.5 — Bumblebee: Audio (Whisper Speech-to-Text)
+
+Bumblebee wraps OpenAI's Whisper for speech-to-text directly in Elixir.
+
+```elixir
+{:ok, whisper_model} = Bumblebee.load_model({:hf, "openai/whisper-tiny"})
+{:ok, whisper_featurizer} = Bumblebee.load_featurizer({:hf, "openai/whisper-tiny"})
+{:ok, whisper_tokenizer} = Bumblebee.load_tokenizer({:hf, "openai/whisper-tiny"})
+{:ok, whisper_generation_config} = Bumblebee.load_generation_config({:hf, "openai/whisper-tiny"})
+
+whisper_serving = Bumblebee.Audio.speech_to_text(
+  whisper_model,
+  whisper_featurizer,
+  whisper_tokenizer,
+  whisper_generation_config
+)
+
+# Download a sample audio file
+audio_url = "https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac"
+audio_data = Req.get!(audio_url).body
+File.write!("/tmp/sample_audio.flac", audio_data)
+
+# Transcribe
+{:ok, audio_info} = Bumblebee.Audio.LoadedAudio.from_file("/tmp/sample_audio.flac")
+whisper_result = Nx.Serving.run(whisper_serving, audio_info)
+
+IO.puts("Transcription: #{whisper_result.text}")
+```
+
+### Interactive Audio Transcription
+
+```elixir
+audio_file_input = Kino.Input.file("Upload audio (WAV/FLAC/MP3)")
+
+audio_form = Kino.Control.form(%{file: audio_file_input}, submit: "Transcribe")
+
+Kino.listen(audio_form, fn %{data: %{file: file}} ->
+  if file do
+    {:ok, audio} = Bumblebee.Audio.LoadedAudio.from_file(file.path)
+    result = Nx.Serving.run(whisper_serving, audio)
+    Kino.Text.new(result.text)
+  else
+    Kino.Text.new("Please upload an audio file.")
+  end
+end)
+
+audio_form
+```
+
+---
+
+## Section 5.6 — Bumblebee: Stable Diffusion (Image Generation)
+
+Generate images from text prompts using Stable Diffusion — all within Elixir.
+
+> **Note:** This section requires a GPU with 4GB+ VRAM. On CPU it will be very slow.
+
+```elixir
+{:ok, sd_info} = Bumblebee.load_model({:hf, "CompVis/stable-diffusion-v1-4", subdir: "unet"})
+{:ok, sd_vae} = Bumblebee.load_model({:hf, "CompVis/stable-diffusion-v1-4", subdir: "vae"})
+{:ok, sd_clip} = Bumblebee.load_model({:hf, "CompVis/stable-diffusion-v1-4", subdir: "text_encoder"})
+{:ok, sd_tokenizer} = Bumblebee.load_tokenizer({:hf, "CompVis/stable-diffusion-v1-4", subdir: "tokenizer"})
+{:ok, sd_scheduler} = Bumblebee.load_scheduler({:hf, "CompVis/stable-diffusion-v1-4", subdir: "scheduler"})
+
+# Image generation serving
+sd_serving = Bumblebee.Diffusion.StableDiffusion.text_to_image(
+  sd_info,
+  sd_vae,
+  sd_clip,
+  sd_tokenizer,
+  sd_scheduler,
+  num_steps: 20,
+  guidance_scale: 7.5
+)
+
+# Generate
+sd_result = Nx.Serving.run(sd_serving, %{
+  prompt: "a photograph of a bee programming in elixir, highly detailed, 4k",
+  negative_prompt: "blurry, low quality"
+})
+
+# Display the generated image
+Kino.Image.new(sd_result.image)
+```
+
+### Interactive Image Generation
+
+```elixir
+prompt_input = Kino.Input.text("Prompt", default: "a cute robot bee coding in Elixir")
+neg_input = Kino.Input.text("Negative prompt", default: "blurry, ugly, low quality")
+steps_input = Kino.Input.number("Steps", default: 20)
+
+sd_form = Kino.Control.form(
+  %{prompt: prompt_input, negative: neg_input, steps: steps_input},
+  submit: "Generate"
+)
+
+Kino.listen(sd_form, fn %{data: %{prompt: prompt, negative: negative, steps: steps}} ->
+  result = Nx.Serving.run(sd_serving, %{
+    prompt: prompt,
+    negative_prompt: negative,
+    num_steps: trunc(steps)
+  })
+  Kino.Layout.grid([Kino.Image.new(result.image)], columns: 1)
+end)
+
+sd_form
+```
+
+---
+
+## Section 6 — Custom Training with Axon
+
+Beyond pre-trained models, Axon lets you build and train from scratch.
+
+### 6.1 Synthetic Data
+
+```elixir
+defmodule Data do
+  import Nx
+
+  def make_classification(n \\ 2000, features \\ 4, classes \\ 3, seed \\ 42) do
+    key = Nx.Random.key(seed)
+    {centers, key} = Nx.Random.normal(key, 0, 2, shape: {classes, features})
+    {labels_raw, key} = Nx.Random.randint(key, 0, classes, shape: {n})
+    {noise, _key} = Nx.Random.normal(key, 0, 0.4, shape: {n, features})
+
+    x = Nx.take(centers, labels_raw) |> Nx.add(noise)
+    y = Nx.equal(Nx.new_axis(labels_raw, 1), Nx.iota({1, classes})) |> Nx.as_type(:f32)
+
+    # Normalize
+    mu = Nx.mean(x, axes: [0])
+    sigma = Nx.standard_deviation(x, axes: [0])
+    x_norm = Nx.divide(Nx.subtract(x, mu), sigma)
+
+    # Split
+    split = round(n * 0.8)
+    {{x_norm[0..(split - 1)//1], y[0..(split - 1)//1]},
+     {x_norm[split..(n - 1)//1], y[split..(n - 1)//1]}}
+  end
+end
+
+{{x_train, y_train}, {x_test, y_test} = _test_data} = Data.make_classification()
+IO.puts("Train: #{Nx.axis_size(x_train, 0)} | Test: #{Nx.axis_size(x_test, 0)}")
+IO.puts("Features: #{Nx.axis_size(x_train, 1)} | Classes: #{Nx.axis_size(y_train, 1)}")
+```
+
+### 6.2 Define Model
+
+```elixir
+import Axon
+
+n_features = Nx.axis_size(x_train, 1)
+n_classes = Nx.axis_size(y_train, 1)
+
+model =
+  Axon.input("features", shape: {nil, n_features})
+  |> Axon.dense(64, activation: :relu, name: "hidden_1")
+  |> Axon.batch_norm(name: "bn_1")
+  |> Axon.dropout(rate: 0.2, name: "drop_1")
+  |> Axon.dense(32, activation: :relu, name: "hidden_2")
+  |> Axon.batch_norm(name: "bn_2")
+  |> Axon.dropout(rate: 0.2, name: "drop_2")
+  |> Axon.dense(n_classes, activation: :softmax, name: "output")
+
+Axon.Display.as_table(model, Nx.template({1, n_features}, :f32)) |> IO.puts()
+```
+
+### 6.3 Train
+
+```elixir
+train_data =
+  x_train
+  |> Nx.to_batched(64)
+  |> Enum.zip(Nx.to_batched(y_train, 64))
+  |> Stream.map(fn {xb, yb} -> %{"features" => xb, "targets" => yb} end)
+
+val_data =
+  x_test
+  |> Nx.to_batched(64)
+  |> Enum.zip(Nx.to_batched(y_test, 64))
+  |> Stream.map(fn {xb, yb} -> %{"features" => xb, "targets" => yb} end)
+
+trained_state =
+  model
+  |> Axon.Loop.trainer(:categorical_cross_entropy, Axon.Optimizers.adam(0.001))
+  |> Axon.Loop.metric(:accuracy, "acc")
+  |> Axon.Loop.validate(model, val_data)
+  |> Axon.Loop.early_stopping("validation_loss", patience: 5, mode: :min)
+  |> Axon.Loop.run(train_data, %{}, epochs: 30, compiler: EXLA)
+
+IO.puts("Training complete!")
+```
+
+### 6.4 Evaluate & Predict
+
+```elixir
+# JIT-compiled prediction
+predict_fn = Nx.Defn.jit(fn params, input -> Axon.predict(model, params, input) end)
+
+# Evaluate on test set
+test_preds = predict_fn.(trained_state, x_test)
+pred_classes = Nx.argmax(test_preds, axis: 1)
+true_classes = Nx.argmax(y_test, axis: 1)
+
+accuracy = Nx.mean(Nx.equal(pred_classes, true_classes) |> Nx.as_type(:f32))
+IO.puts("Test accuracy: #{Float.round(Nx.to_number(accuracy) * 100, 2)}%")
+
+# Single prediction
+sample = x_test[0]
+probs = predict_fn.(trained_state, Nx.new_axis(sample, 0)) |> Nx.squeeze()
+IO.puts("Sample prediction: class #{Nx.argmax(probs) |> Nx.to_number()}  probs=#{inspect(Nx.to_flat_list(probs) |> Enum.map(&Float.round(&1, 4)))}")
+```
+
+### 6.5 Visualize Training
+
+```elixir
+# Visualize predictions vs actual on first 2 features
+alias VegaLite, as: Vl
+
+scatter_data =
+  Enum.map(0..(min(Nx.axis_size(x_test, 0), 500) - 1), fn i ->
+    %{
+      "f1" => Nx.to_number(x_test[i][0]),
+      "f2" => Nx.to_number(x_test[i][1]),
+      "actual" => Nx.to_number(Nx.argmax(y_test[i])),
+      "predicted" => Nx.to_number(pred_classes[i])
+    }
+  end)
+
+Vl.new(
+  title: "Test Predictions (first 2 features)",
+  width: 500,
+  height: 400
+)
+|> Vl.data_from_values(scatter_data)
+|> Vl.layers([
+  Vl.new()
+  |> Vl.mark(:circle, opacity: 0.7, size: 40)
+  |> Vl.encode_field(:x, "f1", type: :quantitative)
+  |> Vl.encode_field(:y, "f2", type: :quantitative)
+  |> Vl.encode_field(:color, "actual", type: :nominal, title: "Actual"),
+  Vl.new()
+  |> Vl.mark(:point, opacity: 0.3, size: 20, shape: "cross")
+  |> Vl.encode_field(:x, "f1", type: :quantitative)
+  |> Vl.encode_field(:y, "f2", type: :quantitative)
+  |> Vl.encode_field(:color, "predicted", type: :nominal, title: "Predicted")
+])
+```
+
+---
+
+## Section 7 — Nx.Serving: Production Inference
+
+`Nx.Serving` batches requests from multiple clients and runs them efficiently
+on GPU — essential for production deployment.
+
+### 7.1 Serving Architecture
+
+```elixir
+# Start a named serving process (typically in your Application supervisor)
+# In production, you would do:
+#
+#   Nx.Serving.start_link(
+#     serving: sentiment_serving,
+#     name: MyApp.SentimentServing,
+#     batch_size: 16,
+#     batch_timeout: 100
+#   )
+#
+# Then in your Phoenix controller:
+#
+#   Nx.Serving.run(MyApp.SentimentServing, text)
+
+# For demonstration, run directly:
+IO.puts("Serving is stateless — just call Nx.Serving.run/2")
+IO.puts("For production, wrap in Nx.Serving.start_link/1 for automatic batching")
+```
+
+### 7.2 Benchmark Inference
+
+```elixir
+# Benchmark a single inference
+{us_single, _} = :timer.tc(fn ->
+  Nx.Serving.run(sentiment_serving, "This is a test sentence for benchmarking.")
+end)
+
+IO.puts("Single inference: #{Float.round(us_single / 1000, 2)}ms")
+
+# Benchmark batch
+batch = for i <- 1..8, do: "Test sentence number #{i} for batch benchmarking."
+{us_batch, _} = :timer.tc(fn ->
+  Enum.map(batch, fn text -> Nx.Serving.run(sentiment_serving, text) end)
+end)
+
+IO.puts("8 sequential inferences: #{Float.round(us_batch / 1000, 2)}ms")
+IO.puts("Per-request (batched):   #{Float.round(us_batch / 8000, 2)}ms")
+```
+
+---
+
+## Section 7.5 — Fine-tuning with Bumblebee
+
+Bumblebee supports **boosted training** — taking a pre-trained model head and
+fine-tuning it on your own labeled data. This is far more practical than
+training from scratch when you have limited data.
+
+### 7.5.1 Load Pre-trained Model for Fine-tuning
+
+```elixir
+# Load a pre-trained BERT with a classification head
+{:ok, ft_spec} = Bumblebee.load_spec({:hf, "google-bert/bert-base-uncased"},
+  module: Bumblebee.Text.BertForSequenceClassification
+)
+
+# Configure for your number of classes
+ft_spec = Bumblebee.configure(ft_spec, num_labels: 3)
+
+# Load with the custom spec — only the encoder weights are pre-trained,
+# the classification head is randomly initialized
+{:ok, ft_model_info} = Bumblebee.load_model({:hf, "google-bert/bert-base-uncased"},
+  spec: ft_spec
+)
+
+%{model: ft_model, params: ft_params} = ft_model_info
+IO.puts("Model loaded. Pre-trained encoder + fresh classification head.")
+IO.puts("Total params: #{inspect(Nx.size(ft_params.parameters))}")
+```
+
+### 7.5.2 Prepare Labeled Data
+
+```elixir
+# Your labeled dataset — in practice, load from CSV/JSON
+training_texts = [
+  "The BEAM VM provides fault-tolerant concurrent computing",
+  "Nx brings numerical computing to the Elixir ecosystem",
+  "Phoenix LiveView enables real-time web applications",
+  "Bumblebee integrates Hugging Face models into Elixir",
+  "Axon provides a functional API for neural networks",
+  "The weather is sunny and warm today",
+  "Football season starts next month",
+  "The stock market rallied on positive earnings reports",
+  # ... add more samples per class
+]
+
+training_labels = [0, 0, 0, 0, 0, 1, 1, 2]  # 0=tech, 1=sports, 2=finance
+
+# Tokenize
+{:ok, ft_tokenizer} = Bumblebee.load_tokenizer({:hf, "google-bert/bert-base-uncased"})
+
+encoded = Bumblebee.apply_tokenizer(ft_tokenizer, training_texts)
+IO.inspect(encoded, label: "Tokenized input")
+```
+
+### 7.5.3 Training Loop
+
+```elixir
+defmodule FineTuner do
+  import Nx.Defn
+
+  defn cross_entropy_loss(logits, labels) do
+    log_probs = Axon.Activations.log_softmax(logits, axis: -1)
+    -Nx.mean(Nx.sum(log_probs * labels, axes: [-1]))
+  end
+
+  def train_step(model, params, batch, learning_rate \\ 2.0e-5) do
+    {loss, gradient} = Nx.Defn.value_and_grad(params, fn p ->
+      output = Axon.predict(model, p, batch)
+      cross_entropy_loss(output.logits, batch["labels"])
+    end)
+
+    new_params =
+      Map.new(params, fn {k, v} ->
+        {k, Nx.subtract(v, Nx.multiply(learning_rate, gradient[k] || 0))}
+      end)
+
+    {loss, new_params}
+  end
+end
+
+# Example training (simplified — real training uses Axon.Loop)
+epochs = 3
+batch_size = 4
+
+for epoch <- 1..epochs do
+  encoded
+  |> Nx.to_batched(batch_size)
+  |> Enum.reduce(ft_params, fn batch, params ->
+    labels = Nx.eye(3) |> Nx.take(Nx.tensor(Enum.take(training_labels, batch_size)))
+    batch_with_labels = Map.put(batch, "labels", labels)
+
+    {loss, new_params} = FineTuner.train_step(ft_model, params, batch_with_labels)
+
+    if rem(epoch, 1) == 0 do
+      IO.puts("Epoch #{epoch}, Loss: #{Float.round(Nx.to_number(loss), 4)}")
+    end
+
+    new_params
+  end)
+end
+```
+
+> **Tip:** For production fine-tuning, use `Axon.Loop` with proper data
+> pipelines, learning rate scheduling, and mixed precision. The above
+> demonstrates the concept — see `Bumblebee` examples on GitHub for
+> full fine-tuning recipes.
+
+---
+
+## Section 7.6 — Model Export (ONNX / GGUF)
+
+### 7.6.1 Export a Bumblebee model to ONNX
+
+```elixir
+# Load a pretrained model
+{:ok, spec} = Bumblebee.load_spec({:hf, "distilbert/bert-base-uncased"}, module: Bumblebee.Text.BertForSequenceClassification)
+{:ok, model_info} = Bumblebee.load_model({:hf, "distilbert/bert-base-uncased"}, spec: spec)
+
+# Export to ONNX (requires `onnx` library installed)
+Bumblebee.export(model_info.model, format: :onnx, path: "distilbert.onnx")
+```
+
+The resulting `distilbert.onnx` can be loaded in any ONNX runtime.
+
+### 7.6.2 Export to GGUF (via `gguf-converter`)
+
+```bash
+gguf-converter --onnx distilbert.onnx --output distilbert.gguf
+```
+
+> **Note:** GGUF is primarily for decoder models (e.g., Llama). Ensure compatibility.
+
+---
+
+## Section 7.7 — Phoenix LiveView Integration
+
+Deploy ML models into Phoenix web apps using `Nx.Serving` and LiveView.
+
+### 7.7.1 Application Supervision Tree
+
+```elixir
+# In your Phoenix app's application.ex:
+defmodule MyApp.Application do
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [
+      MyAppWeb.Telemetry,
+      {DNSCluster, query: Application.get_env(:my_app, :dns_cluster_query) || :ignore},
+      {Phoenix.PubSub, name: MyApp.PubSub},
+
+      # ─── ML Servings ───────────────────────────────────────
+      # Sentiment analysis serving
+      {Nx.Serving,
+       serving: sentiment_serving(),
+       name: MyApp.SentimentServing,
+       batch_size: 16,
+       batch_timeout: 100},
+
+      # Image classification serving
+      {Nx.Serving,
+       serving: image_serving(),
+       name: MyApp.ImageServing,
+       batch_size: 8,
+       batch_timeout: 200},
+
+      # Embedding serving (for similarity search)
+      {Nx.Serving,
+       serving: embedding_serving(),
+       name: MyApp.EmbeddingServing,
+       batch_size: 32,
+       batch_timeout: 50},
+
+      MyAppWeb.Endpoint
+    ]
+
+    opts = [strategy: :one_for_one, name: MyApp.Supervisor]
+    Supervisor.start_link(children, opts)
+  end
+
+  defp sentiment_serving do
+    {:ok, model} = Bumblebee.load_model({:hf, "distilbert/distilbert-base-uncased-finetuned-sst-2-english"})
+    {:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "distilbert/distilbert-base-uncased-finetuned-sst-2-english"})
+    Bumblebee.Text.Classification.text_classification(model, tokenizer)
+  end
+
+  defp image_serving do
+    {:ok, model} = Bumblebee.load_model({:hf, "google/vit-base-patch16-224"})
+    {:ok, featurizer} = Bumblebee.load_featurizer({:hf, "google/vit-base-patch16-224"})
+    Bumblebee.Vision.ImageClassification.image_classification(model, featurizer)
+  end
+
+  defp embedding_serving do
+    {:ok, model} = Bumblebee.load_model({:hf, "sentence-transformers/all-MiniLM-L6-v2"})
+    {:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "sentence-transformers/all-MiniLM-L6-v2"})
+    Bumblebee.Text.TextEmbedding.text_embedding(model, tokenizer)
+  end
+end
+```
+
+### 7.7.2 LiveView for Sentiment Analysis
+
+```elixir
+# lib/my_app_web/live/sentiment_live.ex
+defmodule MyAppWeb.SentimentLive do
+  use MyAppWeb, :live_view
+
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket, text: "", result: nil, loading: false)}
+  end
+
+  def handle_event("analyze", %{"text" => text}, socket) do
+    # Nx.Serving.run is synchronous and fast (batches with other requests)
+    result = Nx.Serving.run(MyApp.SentimentServing, text)
+
+    label = hd(result.predictions)
+    {:noreply, assign(socket,
+      text: text,
+      result: %{
+        label: label.label,
+        score: Float.round(label.score * 100, 1)
+      },
+      loading: false
+    )}
+  end
+
+  def handle_event("update_text", %{"text" => text}, socket) do
+    {:noreply, assign(socket, text: text)}
+  end
+
+  def render(assigns) do
+    ~H"""
+    <div class="max-w-lg mx-auto p-6">
+      <h1 class="text-2xl font-bold mb-4">🐝 Sentiment Analysis</h1>
+
+      <form phx-submit="analyze">
+        <textarea
+          name="text"
+          phx-change="update_text"
+          class="w-full p-3 border rounded-lg"
+          rows="3"
+          placeholder="Enter text to analyze..."
+        ><%= @text %></textarea>
+        <button type="submit" class="mt-2 px-4 py-2 bg-purple-600 text-white rounded-lg">
+          Analyze
+        </button>
+      </form>
+
+      <%= if @result do %>
+        <div class="mt-4 p-4 bg-gray-100 rounded-lg">
+          <p class="text-lg">
+            <strong><%= @result.label %></strong>
+            — <%= @result.score %>%
+          </p>
+        </div>
+      <% end %>
+    </div>
+    """
+  end
+end
+```
+
+### 7.7.3 LiveView for Image Classification
+
+```elixir
+# lib/my_app_web/live/vision_live.ex
+defmodule MyAppWeb.VisionLive do
+  use MyAppWeb, :live_view
+
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket, predictions: nil)}
+  end
+
+  def handle_event("classify", %{"image" => %Plug.Upload{path: path}}, socket) do
+    {:ok, image} = StbImage.read_file(path)
+
+    result = Nx.Serving.run(MyApp.ImageServing, image)
+
+    predictions =
+      result.predictions
+      |> Enum.take(5)
+      |> Enum.map(fn %{label: label, score: score} ->
+        %{label: label, score: Float.round(score * 100, 1)}
+      end)
+
+    {:noreply, assign(socket, predictions: predictions)}
+  end
+
+  def render(assigns) do
+    ~H"""
+    <div class="max-w-lg mx-auto p-6">
+      <h1 class="text-2xl font-bold mb-4">🖼️ Image Classification</h1>
+
+      <form phx-submit="classify" multipart>
+        <input type="file" name="image" accept="image/*" class="mb-2" />
+        <button type="submit" class="px-4 py-2 bg-purple-600 text-white rounded-lg">
+          Classify
+        </button>
+      </form>
+
+      <%= if @predictions do %>
+        <div class="mt-4">
+          <%= for pred <- @predictions do %>
+            <div class="flex justify-between py-1 border-b">
+              <span><%= pred.label %></span>
+              <span class="font-mono"><%= pred.score %>%</span>
+            </div>
+          <% end %>
+        </div>
+      <% end %>
+    </div>
+    """
+  end
+end
+```
+
+### 7.7.4 API Endpoint (REST)
+
+```elixir
+# lib/my_app_web/controllers/prediction_controller.ex
+defmodule MyAppWeb.PredictionController do
+  use MyAppWeb, :controller
+
+  def sentiment(conn, %{"text" => text}) do
+    result = Nx.Serving.run(MyApp.SentimentServing, text)
+
+    json(conn, %{
+      predictions: Enum.map(result.predictions, fn p ->
+        %{label: p.label, score: Float.round(p.score, 4)}
+      end)
+    })
+  end
+
+  def embed(conn, %{"text" => text}) do
+    result = Nx.Serving.run(MyApp.EmbeddingServing, text)
+
+    json(conn, %{
+      embedding: Nx.to_flat_list(result.embedding),
+      dimensions: Nx.size(result.embedding)
+    })
+  end
+end
+
+# In router.ex:
+# scope "/api", MyAppWeb do
+#   post "/sentiment", PredictionController, :sentiment
+#   post "/embed", PredictionController, :embed
+# end
+```
+
+---
+
+## Section 8 — Interactive Playground
+
+### 8.1 Text Classification UI
+
+```elixir
+alias Kino.Input
+
+text_input = Kino.Input.textarea("Enter text to classify", default: "Elixir is the best language for building scalable ML systems!")
+
+class_form = Kino.Control.form(%{text: text_input}, submit: "Classify Sentiment")
+
+Kino.listen(class_form, fn %{data: %{text: text}} ->
+  result = Nx.Serving.run(sentiment_serving, text)
+
+  label_text =
+    result
+    |> Map.get(:predictions, [])
+    |> Enum.map(fn %{label: label, score: score} ->
+      "#{label}: #{Float.round(score * 100, 1)}%"
+    end)
+    |> Enum.join(" | ")
+
+  Kino.Text.new(label_text)
+end)
+
+class_form
+```
+
+### 8.2 Embedding Similarity UI
+
+```elixir
+ref_input = Kino.Input.textarea("Reference text", default: "Nx provides numerical computing for the BEAM")
+query_input = Kino.Input.textarea("Query text", default: "How do I do math in Elixir?")
+
+sim_form = Kino.Control.form(%{ref: ref_input, query: query_input}, submit: "Compute Similarity")
+
+Kino.listen(sim_form, fn %{data: %{ref: ref, query: query}} ->
+  ref_emb = Nx.Serving.run(embedding_serving, ref).embedding
+  query_emb = Nx.Serving.run(embedding_serving, query).embedding
+  score = Similarity.cosine_similarity(ref_emb, query_emb) |> Nx.to_number()
+
+  Kino.Text.new("Cosine similarity: #{Float.round(score, 6)}")
+end)
+
+sim_form
+```
+
+---
+## Section 8.3 — Distributed Training on BEAM Nodes
+
+### 8.3.1 Using `Nx` with `Node.spawn/4`
+
+```elixir
+# Assuming you have a cluster of BEAM nodes: node1@host, node2@host, ...
+nodes = [:"node1@host", :"node2@host"]
+
+# Distribute a tensor computation across nodes
+defmodule DistTrainer do
+  def compute(tensor) do
+    Enum.map(nodes, fn node ->
+      Node.spawn(node, fn -> Nx.mean(tensor) end)
+    end)
+  end
+end
+
+tensor = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+results = DistTrainer.compute(tensor)
+IO.inspect(results, label: "Means from each node")
+```
+
+### 8.3.2 Distributed Axon training
+
+```elixir
+# Using Axon with `Nx.Cluster` (requires `:zx` and `Nx.Cluster` setup)
+defmodule ClusterTrainer do
+  use Axon
+
+  # Define a simple model
+  defmodel do
+    input({nil, 784})
+    |> dense(128, activation: :relu)
+    |> dense(10, activation: :softmax)
+  end
+
+  # Launch training across nodes
+  def train(data, labels) do
+    model = model()
+    # `Nx.Cluster.train/5` will split data and run steps on each BEAM node
+    Nx.Cluster.train(model, data, labels, nodes: nodes, epochs: 5)
+  end
+end
+```
+
+> **Tip:** Ensure all nodes have the same code version and the required dependencies (`nx`, `axon`). Use `:net_kernel.connect_node/1` or a clustering tool such as `libcluster` to form the cluster.
+
+---
+
+## Section 9 — Summary & Next Steps
+
+```elixir
+Kino.Markdown.new("""
+## What You've Built
+
+| Pipeline Stage | Implementation | Key Library |
+|----------------|----------------|-------------|
+| **Tensors** | Creation, ops, broadcasting, gradients | `Nx` |
+| **JIT Compile** | GPU-accelerated inference | `EXLA` |
+| **Fill-Mask** | BERT masked language modeling | `Bumblebee` |
+| **Sentiment** | DistilBERT text classification | `Bumblebee` |
+| **NER** | Named entity recognition | `Bumblebee` |
+| **Zero-Shot** | Classify without fine-tuning | `Bumblebee` |
+| **Image CLS** | Vision Transformer (ViT) | `Bumblebee` |
+| **Audio** | Whisper speech-to-text | `Bumblebee` |
+| **Stable Diffusion** | Text-to-image generation | `Bumblebee` |
+| **Text Gen** | GPT-2 autoregressive generation | `Bumblebee` |
+| **Embeddings** | Sentence similarity search | `Bumblebee` |
+| **Custom MLP** | Train from scratch with Axon | `Axon` |
+| **Fine-tuning** | Boosted training on pre-trained models | `Bumblebee` |
+| **Serving** | Production batched inference | `Nx.Serving` |
+| **Phoenix** | LiveView + REST API deployment | `Phoenix` |
+| **Interactive** | Kino live forms | `Kino` |
+
+### Companion Notebooks
+
+| Format | Path | Deploy To |
+|--------|------|-----------|
+| Livebook | `ml_e2e_template.livemd` | HF Spaces (Docker), Livebook Teams |
+| Jupyter | `colab_kaggle/ml_e2e_python.ipynb` | Google Colab, Kaggle |
+| Gradio | `gradio_hf_deploy/app.py` | HF Spaces (sdk: gradio) |
+| marimo | `marimo/ml_e2e_marimo.py` | Anywhere Python runs |
+
+### Resources
+
+* [Bumblebee docs](https://hexdocs.pm/bumblebee) — Pre-trained models
+* [Nx docs](https://hexdocs.pm/nx) — Numerical computing
+* [Axon docs](https://hexdocs.pm/axon) — Neural networks
+* [EXLA docs](https://hexdocs.pm/exla) — GPU backend
+* [Phoenix docs](https://hexdocs.pm/phoenix) — Web framework
+* [Hugging Face Hub](https://huggingface.co/models) — 500k+ models
+* [marimo docs](https://docs.marimo.io) — Reactive Python notebooks
+* _Machine Learning in Elixir_ — Sean Moriarity, Pragmatic Bookshelf
+
+### Deploy
+
+```bash
+just check           # Verify all files and tools
+just livebook        # Open Livebook locally
+just deploy-livebook # Push to HF Spaces
+just marimo          # Open marimo editor
+just gradio          # Run Gradio app
+```
+""")
+```

ml_tutorial.livemd

@@ -0,0 +1,430 @@
+# Machine Learning in Elixir - Interactive Tutorial
+
+<!-- livebook:{"app":"embedded"} -->
+
+```elixir
+Mix.install([
+  {:nx, "~> 0.11"},
+  {:axon, "~> 0.8"},
+  {:exla, "~> 0.11"},
+  {:kino, "~> 0.13"}
+])
+```
+
+## Chapter 1: Introduction to ML in Elixir 🚀
+
+### Welcome to Machine Learning with Elixir!
+
+**I'm an intermediate Elixir developer and I want to learn Machine Learning in Elixir so I can build intelligent applications and understand ML concepts using functional programming patterns.**
+
+### What Makes Elixir Special for ML?
+
+Elixir brings some unique advantages to machine learning:
+
+- **🏗️ Functional Programming Foundation**: Pure functions and immutability naturally align with ML workflows
+- **⚡ Concurrency & Distribution**: Handle large datasets and parallel training efficiently
+- **🔧 Erlang VM Benefits**: Fault tolerance and hot code reloading for production ML systems
+- **📊 Nx Library**: Numerical computing with GPU acceleration
+
+### Core Concepts in Elixir ML
+
+**1. Tensors** 🔢
+Tensors are the fundamental building blocks - think of them as multi-dimensional arrays:
+
+```elixir
+import Nx
+
+# Creating a tensor
+tensor = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+tensor
+```
+
+**2. Numerical Operations** ➕
+Perform mathematical operations efficiently:
+
+```elixir
+# Element-wise operations
+a = Nx.tensor([1, 2, 3])
+b = Nx.tensor([4, 5, 6])
+result = Nx.add(a, b)
+result
+```
+
+### Your First ML Program 💻
+
+Let's create a simple linear regression example:
+
+```elixir
+defmodule SimpleML do
+  import Nx
+  
+  def predict(x, weights) do
+    # Simple linear prediction: y = mx + b
+    multiply(x, weights[0]) + weights[1]
+  end
+  
+  def train(x_data, y_data, learning_rate \\ 0.01, epochs \\ 1000) do
+    # Initialize random weights
+    weights = [Nx.random_normal({}), Nx.random_normal({})]
+    
+    Enum.reduce(1..epochs, weights, fn epoch, [m, b] ->
+      # Forward pass
+      predictions = multiply(x_data, m) + b
+      
+      # Calculate loss (mean squared error)
+      loss = mean(power(predictions - y_data, 2))
+      
+      # Backward pass (gradients)
+      grad_m = mean(2 * (predictions - y_data) * x_data)
+      grad_b = mean(2 * (predictions - y_data))
+      
+      # Update weights
+      [m - learning_rate * grad_m, b - learning_rate * grad_b]
+    end)
+  end
+end
+```
+
+**Try it out:**
+
+```elixir
+# Generate simple linear data: y = 2x + 3 + noise
+x_data = Nx.tensor(Enum.map(0..100, &(&1 / 10.0)))  # 0 to 10 in steps of 0.1
+noise = Nx.random_normal({101}) |> Nx.multiply(0.1)
+y_data = Nx.multiply(x_data, 2) |> Nx.add(3) |> Nx.add(noise)
+
+# Train the model
+weights = SimpleML.train(x_data, y_data, 0.01, 500)
+
+# Test prediction
+test_x = Nx.tensor([0.5, 1.0, 1.5, 2.0])
+predictions = SimpleML.predict(test_x, weights)
+
+"Trained weights: #{inspect(weights)}, Predictions: #{inspect(predictions)}"
+```
+
+## Chapter 2: Nx and Numerical Computing 🔢
+
+### Understanding Nx Tensors 📊
+
+Tensors are multi-dimensional arrays that power all ML computations:
+
+```elixir
+import Nx
+
+# Different tensor types
+scalar = Nx.tensor(42)           # 0-dimensional
+vector = Nx.tensor([1, 2, 3])    # 1-dimensional  
+matrix = Nx.tensor([[1, 2], [3, 4]])  # 2-dimensional
+
+# Tensor properties
+IO.puts("Vector shape: #{inspect(Nx.shape(vector))}")
+IO.puts("Vector type: #{inspect(Nx.type(vector))}")
+IO.puts("Vector size: #{inspect(Nx.size(vector))}")
+```
+
+### Essential Tensor Operations ⚡
+
+**Mathematical Operations:**
+
+```elixir
+# Basic arithmetic
+a = Nx.tensor([1.0, 2.0, 3.0])
+b = Nx.tensor([4.0, 5.0, 6.0])
+
+add_result = Nx.add(a, b)
+mult_result = Nx.multiply(a, b)
+pow_result = Nx.power(a, 2)
+
+{add_result, mult_result, pow_result}
+```
+
+**Aggregation Operations:**
+
+```elixir
+matrix = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+
+sum_all = Nx.sum(matrix)
+sum_rows = Nx.sum(matrix, axes: [1])
+mean_all = Nx.mean(matrix)
+
+{sum_all, sum_rows, mean_all}
+```
+
+### Broadcasting Magic ✨
+
+Nx automatically broadcasts tensors to compatible shapes:
+
+```elixir
+# Broadcasting examples
+vector = Nx.tensor([1, 2, 3])
+scalar = Nx.tensor(10)
+
+# Add scalar to each element
+result1 = Nx.add(vector, scalar)
+
+# Broadcasting with different dimensions
+matrix = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+result2 = Nx.add(matrix, vector)
+
+{result1, result2}
+```
+
+### Hands-On Exercise 💻
+
+Create a function that normalizes a dataset:
+
+```elixir
+defmodule DataPreprocessing do
+  import Nx
+  
+  def normalize(tensor) do
+    mean = Nx.mean(tensor)
+    std = Nx.standard_deviation(tensor)
+    
+    # Normalize: (x - mean) / std
+    Nx.divide(Nx.subtract(tensor, mean), std)
+  end
+  
+  def min_max_scale(tensor) do
+    min = Nx.reduce_min(tensor)
+    max = Nx.reduce_max(tensor)
+    
+    # Scale to [0, 1] range
+    Nx.divide(Nx.subtract(tensor, min), Nx.subtract(max, min))
+  end
+end
+
+# Test with sample data
+data = Nx.tensor([10, 20, 30, 40, 50])
+normalized = DataPreprocessing.normalize(data)
+scaled = DataPreprocessing.min_max_scale(data)
+
+{data, normalized, scaled}
+```
+
+## Chapter 3: Building ML Models with Axon 🧠
+
+### Understanding Axon Architecture 🏗️
+
+Axon provides a functional API for building neural networks:
+
+```elixir
+import Axon
+
+# Simple neural network
+model = Axon.input("input", shape: {nil, 784})
+  |> Axon.dense(128, activation: :relu)
+  |> Axon.dense(64, activation: :relu)
+  |> Axon.dense(10, activation: :softmax)
+
+IO.puts("Model structure:")
+IO.inspect(model)
+```
+
+### Building Your First Neural Network 🚀
+
+**MNIST Digit Classification:**
+
+```elixir
+defmodule MNISTClassifier do
+  import Axon
+  
+  def build_model() do
+    # Input: 28x28 grayscale images (flattened to 784)
+    Axon.input("input", shape: {nil, 784})
+    # Hidden layers
+    |> Axon.dense(128, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    # Output: 10 classes (digits 0-9)
+    |> Axon.dense(10, activation: :softmax)
+  end
+  
+  def train_model(model, train_data, validation_data) do
+    # Training loop
+    Axon.Loop.trainer(model, :categorical_cross_entropy, :adam)
+    |> Axon.Loop.validate(model, validation_data)
+    |> Axon.Loop.run(train_data, epochs: 10)
+  end
+end
+
+# Create a sample model
+model = MNISTClassifier.build_model()
+model
+```
+
+### Common Layer Types 🧩
+
+**Dense (Fully Connected) Layers:**
+
+```elixir
+model1 = Axon.input("input", shape: {nil, 100})
+  |> Axon.dense(50)  # 50 neurons
+  |> Axon.dense(25)  # 25 neurons
+  |> Axon.dense(1)   # Output neuron
+
+model1
+```
+
+**Convolutional Layers (for images):**
+
+```elixir
+model2 = Axon.input("input", shape: {nil, 28, 28, 1})  # Grayscale images
+  |> Axon.conv(32, kernel_size: {3, 3}, activation: :relu)
+  |> Axon.max_pool(kernel_size: {2, 2})
+  |> Axon.conv(64, kernel_size: {3, 3}, activation: :relu)
+  |> Axon.max_pool(kernel_size: {2, 2})
+  |> Axon.flatten()
+  |> Axon.dense(128, activation: :relu)
+  |> Axon.dense(10, activation: :softmax)
+
+model2
+```
+
+### Activation Functions 🔥
+
+```elixir
+model3 = Axon.input("input", shape: {nil, 100})
+  |> Axon.dense(50, activation: :relu)     # ReLU - most common
+  |> Axon.dense(25, activation: :sigmoid)  # Sigmoid - for probabilities
+  |> Axon.dense(10, activation: :softmax)  # Softmax - for classification
+  |> Axon.dense(1, activation: :tanh)     # Tanh - for outputs in [-1, 1]
+
+model3
+```
+
+## Chapter 4: Real-world Applications 🚀
+
+### Complete ML Pipeline Example 🔄
+
+**End-to-End Fraud Detection System:**
+
+```elixir
+defmodule FraudDetection do
+  import Axon
+  
+  def build_pipeline() do
+    # Data preprocessing -> Model training -> Prediction
+    
+    # 1. Model definition
+    model = build_fraud_model()
+    
+    %{
+      model: model
+    }
+  end
+  
+  defp build_fraud_model() do
+    Axon.input("input", shape: {nil, 20})  # 20 features
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(32, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(1, activation: :sigmoid)  # Probability of fraud
+  end
+end
+
+# Create the fraud detection pipeline
+pipeline = FraudDetection.build_pipeline()
+pipeline.model
+```
+
+### Practical Project: Customer Churn Prediction 📈
+
+```elixir
+defmodule ChurnPredictor do
+  import Axon
+  
+  def build_churn_model() do
+    # Customer features: age, usage_pattern, support_tickets, etc.
+    Axon.input("input", shape: {nil, 15})
+    |> Axon.dense(32, activation: :relu)
+    |> Axon.batch_norm()
+    |> Axon.dense(16, activation: :relu)
+    |> Axon.dropout(rate: 0.2)
+    |> Axon.dense(1, activation: :sigmoid)  # Probability of churn
+  end
+  
+  def predict_churn_risk(customer_features) do
+    # Simulate prediction
+    %{
+      probability: 0.65,
+      risk_level: :medium,
+      recommendation: "Offer loyalty discount"
+    }
+  end
+end
+
+# Build churn prediction model
+churn_model = ChurnPredictor.build_churn_model()
+churn_model
+```
+
+## Interactive Exercises 🎯
+
+### Exercise 1: Tensor Operations
+Create a function that calculates the dot product of two matrices:
+
+```elixir
+defmodule TensorExercises do
+  import Nx
+  
+  def dot_product(a, b) do
+    # Your code here
+    # Hint: Use Nx.dot/2
+    Nx.dot(a, b)
+  end
+  
+  def elementwise_multiply(a, b) do
+    # Your code here
+    Nx.multiply(a, b)
+  end
+end
+
+# Test your functions
+a = Nx.tensor([[1, 2], [3, 4]])
+b = Nx.tensor([[5, 6], [7, 8]])
+
+dot_result = TensorExercises.dot_product(a, b)
+mult_result = TensorExercises.elementwise_multiply(a, b)
+
+{dot_result, mult_result}
+```
+
+### Exercise 2: Build a Custom Model
+Create a neural network with 3 hidden layers (128, 64, 32 neurons) and ReLU activations:
+
+```elixir
+defmodule CustomModel do
+  import Axon
+  
+  def build_custom_model(input_shape \\ {nil, 10}) do
+    # Your code here
+    Axon.input("input", shape: input_shape)
+    |> Axon.dense(128, activation: :relu)
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dense(32, activation: :relu)
+    |> Axon.dense(1, activation: :sigmoid)
+  end
+end
+
+# Build and display the model
+model = CustomModel.build_custom_model()
+model
+```
+
+## Next Steps 🚀
+
+1. **Experiment** with different tensor operations
+2. **Modify** the models with different architectures
+3. **Try** training on real datasets
+4. **Explore** Livebook's visualization features
+
+Happy learning! 🎉✨
+
+---
+
+*This notebook was created as a companion to the "Machine Learning in Elixir" tutorial.*
+*Save this notebook (Ctrl+S) to keep your progress!*

ml_tutorial_fixed.livemd

@@ -0,0 +1,438 @@
+# Machine Learning in Elixir - Interactive Tutorial
+
+<!-- livebook:{"app":"embedded"} -->
+
+```elixir
+Mix.install([
+  {:nx, "~> 0.11"},
+  {:axon, "~> 0.8"},
+  {:exla, "~> 0.11"},
+  {:kino, "~> 0.13"}
+])
+```
+
+## Chapter 1: Introduction to ML in Elixir 🚀
+
+### Welcome to Machine Learning with Elixir!
+
+**I'm an intermediate Elixir developer and I want to learn Machine Learning in Elixir so I can build intelligent applications and understand ML concepts using functional programming patterns.**
+
+### What Makes Elixir Special for ML?
+
+Elixir brings some unique advantages to machine learning:
+
+- **🏗️ Functional Programming Foundation**: Pure functions and immutability naturally align with ML workflows
+- **⚡ Concurrency & Distribution**: Handle large datasets and parallel training efficiently
+- **🔧 Erlang VM Benefits**: Fault tolerance and hot code reloading for production ML systems
+- **📊 Nx Library**: Numerical computing with GPU acceleration
+
+### Core Concepts in Elixir ML
+
+**1. Tensors** 🔢
+Tensors are the fundamental building blocks - think of them as multi-dimensional arrays:
+
+```elixir
+import Nx
+
+# Creating a tensor
+tensor = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+tensor
+```
+
+**2. Numerical Operations** ➕
+Perform mathematical operations efficiently:
+
+```elixir
+# Element-wise operations
+a = Nx.tensor([1, 2, 3])
+b = Nx.tensor([4, 5, 6])
+result = Nx.add(a, b)
+result
+```
+
+### Your First ML Program 💻
+
+Let's create a simple linear regression example:
+
+```elixir
+defmodule SimpleML do
+  import Nx
+  
+  def predict(x, weights) do
+    # Simple linear prediction: y = mx + b
+    Nx.multiply(x, weights[0]) + weights[1]
+  end
+  
+  def train(x_data, y_data, learning_rate \\ 0.01, epochs \\ 1000) do
+    # Initialize random weights
+    weights = [Nx.random_normal({}), Nx.random_normal({})]
+    
+    Enum.reduce(1..epochs, weights, fn _epoch, [m, b] ->
+      # Forward pass
+      predictions = Nx.multiply(x_data, m) + b
+      
+      # Calculate loss (mean squared error)
+      _loss = Nx.mean(Nx.power(predictions - y_data, 2))
+      
+      # Backward pass (gradients)
+      grad_m = Nx.mean(2 * (predictions - y_data) * x_data)
+      grad_b = Nx.mean(2 * (predictions - y_data))
+      
+      # Update weights
+      [m - learning_rate * grad_m, b - learning_rate * grad_b]
+    end)
+  end
+end
+```
+
+**Try it out:**
+
+```elixir
+# Generate simple linear data: y = 2x + 3 + noise
+x_data = Nx.tensor(Enum.map(0..100, &(&1 / 10.0)))  # 0 to 10 in steps of 0.1
+noise = Nx.random_normal({101}) |> Nx.multiply(0.1)
+y_data = Nx.multiply(x_data, 2) |> Nx.add(3) |> Nx.add(noise)
+
+# Train the model
+weights = SimpleML.train(x_data, y_data, 0.01, 500)
+
+# Test prediction
+test_x = Nx.tensor([0.5, 1.0, 1.5, 2.0])
+predictions = SimpleML.predict(test_x, weights)
+
+"Trained weights: #{inspect(weights)}, Predictions: #{inspect(predictions)}"
+```
+
+## Chapter 2: Nx and Numerical Computing 🔢
+
+### Understanding Nx Tensors 📊
+
+Tensors are multi-dimensional arrays that power all ML computations:
+
+```elixir
+import Nx
+
+# Different tensor types
+scalar = Nx.tensor(42)           # 0-dimensional
+vector = Nx.tensor([1, 2, 3])    # 1-dimensional  
+matrix = Nx.tensor([[1, 2], [3, 4]])  # 2-dimensional
+
+# Tensor properties
+IO.puts("Vector shape: #{inspect(Nx.shape(vector))}")
+IO.puts("Vector type: #{inspect(Nx.type(vector))}")
+IO.puts("Vector size: #{inspect(Nx.size(vector))}")
+```
+
+### Essential Tensor Operations ⚡
+
+**Mathematical Operations:**
+
+```elixir
+# Basic arithmetic
+a = Nx.tensor([1.0, 2.0, 3.0])
+b = Nx.tensor([4.0, 5.0, 6.0])
+
+add_result = Nx.add(a, b)
+mult_result = Nx.multiply(a, b)
+pow_result = Nx.power(a, 2)
+
+{add_result, mult_result, pow_result}
+```
+
+**Aggregation Operations:**
+
+```elixir
+matrix = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+
+sum_all = Nx.sum(matrix)
+sum_rows = Nx.sum(matrix, axes: [1])
+mean_all = Nx.mean(matrix)
+
+{sum_all, sum_rows, mean_all}
+```
+
+### Broadcasting Magic ✨
+
+Nx automatically broadcasts tensors to compatible shapes:
+
+```elixir
+# Broadcasting examples
+vector = Nx.tensor([1, 2, 3])
+scalar = Nx.tensor(10)
+
+# Add scalar to each element
+result1 = Nx.add(vector, scalar)
+
+# Broadcasting with different dimensions
+matrix = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+result2 = Nx.add(matrix, vector)
+
+{result1, result2}
+```
+
+### Hands-On Exercise 💻
+
+Create a function that normalizes a dataset:
+
+```elixir
+defmodule DataPreprocessing do
+  import Nx
+  
+  def normalize(tensor) do
+    mean = Nx.mean(tensor)
+    std = Nx.standard_deviation(tensor)
+    
+    # Normalize: (x - mean) / std
+    Nx.divide(Nx.subtract(tensor, mean), std)
+  end
+  
+  def min_max_scale(tensor) do
+    min = Nx.reduce_min(tensor)
+    max = Nx.reduce_max(tensor)
+    
+    # Scale to [0, 1] range
+    Nx.divide(Nx.subtract(tensor, min), Nx.subtract(max, min))
+  end
+end
+
+# Test with sample data
+data = Nx.tensor([10, 20, 30, 40, 50])
+normalized = DataPreprocessing.normalize(data)
+scaled = DataPreprocessing.min_max_scale(data)
+
+{data, normalized, scaled}
+```
+
+## Chapter 3: Building ML Models with Axon 🧠
+
+### Understanding Axon Architecture 🏗️
+
+Axon provides a functional API for building neural networks:
+
+```elixir
+import Axon
+
+# Simple neural network
+model = Axon.input("input", shape: {nil, 784})
+  |> Axon.dense(128, activation: :relu)
+  |> Axon.dense(64, activation: :relu)
+  |> Axon.dense(10, activation: :softmax)
+
+IO.puts("Model structure:")
+IO.inspect(model)
+```
+
+### Building Your First Neural Network 🚀
+
+**MNIST Digit Classification:**
+
+```elixir
+defmodule MNISTClassifier do
+  import Axon
+  
+  def build_model() do
+    # Input: 28x28 grayscale images (flattened to 784)
+    Axon.input("input", shape: {nil, 784})
+    # Hidden layers
+    |> Axon.dense(128, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    # Output: 10 classes (digits 0-9)
+    |> Axon.dense(10, activation: :softmax)
+  end
+  
+  def train_model(model, train_data, validation_data) do
+    # Training loop
+    Axon.Loop.trainer(model, :categorical_cross_entropy, :adam)
+    |> Axon.Loop.validate(model, validation_data)
+    |> Axon.Loop.run(train_data, epochs: 10)
+  end
+end
+
+# Create a sample model
+model = MNISTClassifier.build_model()
+model
+```
+
+### Common Layer Types 🧩
+
+**Dense (Fully Connected) Layers:**
+
+```elixir
+model1 = Axon.input("input", shape: {nil, 100})
+  |> Axon.dense(50)  # 50 neurons
+  |> Axon.dense(25)  # 25 neurons
+  |> Axon.dense(1)   # Output neuron
+
+model1
+```
+
+**Convolutional Layers (for images):**
+
+```elixir
+model2 = Axon.input("input", shape: {nil, 28, 28, 1})  # Grayscale images
+  |> Axon.conv(32, kernel_size: {3, 3}, activation: :relu)
+  |> Axon.max_pool(kernel_size: {2, 2})
+  |> Axon.conv(64, kernel_size: {3, 3}, activation: :relu)
+  |> Axon.max_pool(kernel_size: {2, 2})
+  |> Axon.flatten()
+  |> Axon.dense(128, activation: :relu)
+  |> Axon.dense(10, activation: :softmax)
+
+model2
+```
+
+### Activation Functions 🔥
+
+```elixir
+model3 = Axon.input("input", shape: {nil, 100})
+  |> Axon.dense(50, activation: :relu)     # ReLU - most common
+  |> Axon.dense(25, activation: :sigmoid)  # Sigmoid - for probabilities
+  |> Axon.dense(10, activation: :softmax)  # Softmax - for classification
+  |> Axon.dense(1, activation: :tanh)     # Tanh - for outputs in [-1, 1]
+
+model3
+```
+
+## Chapter 4: Real-world Applications 🚀
+
+### Complete ML Pipeline Example 🔄
+
+**End-to-End Fraud Detection System:**
+
+```elixir
+defmodule FraudDetection do
+  import Axon
+  
+  def build_pipeline() do
+    # Data preprocessing -> Model training -> Prediction
+    
+    # 1. Model definition
+    model = build_fraud_model()
+    
+    %{
+      model: model
+    }
+  end
+  
+  defp build_fraud_model() do
+    Axon.input("input", shape: {nil, 20})  # 20 features
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(32, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(1, activation: :sigmoid)  # Probability of fraud
+  end
+end
+
+# Create the fraud detection pipeline
+pipeline = FraudDetection.build_pipeline()
+pipeline.model
+```
+
+### Practical Project: Customer Churn Prediction 📈
+
+```elixir
+defmodule ChurnPredictor do
+  import Axon
+  
+  def build_churn_model() do
+    # Customer features: age, usage_pattern, support_tickets, etc.
+    Axon.input("input", shape: {nil, 15})
+    |> Axon.dense(32, activation: :relu)
+    |> Axon.batch_norm()
+    |> Axon.dense(16, activation: :relu)
+    |> Axon.dropout(rate: 0.2)
+    |> Axon.dense(1, activation: :sigmoid)  # Probability of churn
+  end
+  
+  def predict_churn_risk(customer_features) do
+    # Simulate prediction
+    %{
+      probability: 0.65,
+      risk_level: :medium,
+      recommendation: "Offer loyalty discount"
+    }
+  end
+end
+
+# Build churn prediction model
+churn_model = ChurnPredictor.build_churn_model()
+churn_model
+```
+
+## Interactive Exercises 🎯
+
+### Exercise 1: Tensor Operations
+Create a function that calculates the dot product of two matrices:
+
+```elixir
+defmodule TensorExercises do
+  import Nx
+  
+  def dot_product(a, b) do
+    # Your code here
+    # Hint: Use Nx.dot/2
+    Nx.dot(a, b)
+  end
+  
+  def elementwise_multiply(a, b) do
+    # Your code here
+    Nx.multiply(a, b)
+  end
+end
+
+# Test your functions
+a = Nx.tensor([[1, 2], [3, 4]])
+b = Nx.tensor([[5, 6], [7, 8]])
+
+dot_result = TensorExercises.dot_product(a, b)
+mult_result = TensorExercises.elementwise_multiply(a, b)
+
+{dot_result, mult_result}
+```
+
+### Exercise 2: Build a Custom Model
+Create a neural network with 3 hidden layers (128, 64, 32 neurons) and ReLU activations:
+
+```elixir
+defmodule CustomModel do
+  import Axon
+  
+  def build_custom_model(input_shape \\ {nil, 10}) do
+    # Your code here
+    Axon.input("input", shape: input_shape)
+    |> Axon.dense(128, activation: :relu)
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dense(32, activation: :relu)
+    |> Axon.dense(1, activation: :sigmoid)
+  end
+end
+
+# Build and display the model
+model = CustomModel.build_custom_model()
+model
+```
+
+## Debugging Tips 🐛
+
+Found errors? Common fixes:
+1. **Missing imports** - Always `import Nx` or `import Axon`
+2. **Wrong function names** - Use `Nx.function()` not just `function()`
+3. **Unused variables** - Prefix with `_` like `_epoch`
+4. **Shape mismatches** - Check tensor dimensions with `Nx.shape()`
+
+## Next Steps 🚀
+
+1. **Experiment** with different tensor operations
+2. **Modify** the models with different architectures
+3. **Try** training on real datasets
+4. **Explore** Livebook's visualization features
+
+Happy learning! 🎉✨
+
+---
+
+*This notebook was created as a companion to the "Machine Learning in Elixir" tutorial.*
+*Save this notebook (Ctrl+S) to keep your progress!*

ml_tutorial_latest.livemd

@@ -0,0 +1,416 @@
+# Machine Learning in Elixir - Interactive Tutorial (Latest Versions)
+
+<!-- livebook:{"app":"embedded"} -->
+
+```elixir
+Mix.install([
+  {:nx, "~> 0.11"},
+  {:axon, "~> 0.8"},
+  {:exla, "~> 0.11"},
+  {:kino, "~> 0.13"}
+])
+```
+
+## Chapter 1: Introduction to ML in Elixir 🚀
+
+### Welcome to Machine Learning with Elixir!
+
+**I'm an intermediate Elixir developer and I want to learn Machine Learning in Elixir so I can build intelligent applications and understand ML concepts using functional programming patterns.**
+
+### What Makes Elixir Special for ML?
+
+Elixir brings some unique advantages to machine learning:
+
+- **🏗️ Functional Programming Foundation**: Pure functions and immutability naturally align with ML workflows
+- **⚡ Concurrency & Distribution**: Handle large datasets and parallel training efficiently
+- **🔧 Erlang VM Benefits**: Fault tolerance and hot code reloading for production ML systems
+- **📊 Nx Library**: Numerical computing with GPU acceleration
+
+### Core Concepts in Elixir ML
+
+**1. Tensors** 🔢
+Tensors are the fundamental building blocks - think of them as multi-dimensional arrays:
+
+```elixir
+import Nx
+
+# Creating a tensor
+tensor = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+tensor
+```
+
+**2. Numerical Operations** ➕
+Perform mathematical operations efficiently:
+
+```elixir
+# Element-wise operations
+a = Nx.tensor([1, 2, 3])
+b = Nx.tensor([4, 5, 6])
+result = Nx.add(a, b)
+result
+```
+
+### Your First ML Program 💻
+
+Let's create a simple linear regression example compatible with Nx 0.11:
+
+```elixir
+defmodule SimpleML do
+  import Nx
+  
+  def predict(x, weights) do
+    # Simple linear prediction: y = mx + b
+    Nx.multiply(x, weights[0]) + weights[1]
+  end
+  
+  def train(x_data, y_data, learning_rate \\ 0.01, epochs \\ 1000) do
+    # Initialize random weights
+    weights = [
+      Nx.random_normal({}, 0.0, 1.0),  # m weight
+      Nx.random_normal({}, 0.0, 1.0)   # b weight
+    ]
+    
+    Enum.reduce(1..epochs, weights, fn _epoch, [m, b] ->
+      # Forward pass
+      predictions = Nx.multiply(x_data, m) + b
+      
+      # Calculate loss (mean squared error)
+      _loss = Nx.mean(Nx.pow(Nx.subtract(predictions, y_data), 2))
+      
+      # Backward pass (gradients)
+      grad_m = Nx.mean(2 * Nx.multiply(Nx.subtract(predictions, y_data), x_data))
+      grad_b = Nx.mean(2 * Nx.subtract(predictions, y_data))
+      
+      # Update weights
+      [
+        Nx.subtract(m, Nx.multiply(learning_rate, grad_m)),
+        Nx.subtract(b, Nx.multiply(learning_rate, grad_b))
+      ]
+    end)
+  end
+end
+```
+
+**Try it out:**
+
+```elixir
+# Generate simple linear data: y = 2x + 3 + noise
+x_data = Nx.tensor(Enum.map(0..100, &(&1 / 10.0)))  # 0 to 10 in steps of 0.1
+noise = Nx.random_normal({101}, 0.0, 0.1)
+y_data = Nx.add(Nx.add(Nx.multiply(x_data, 2), 3), noise)
+
+# Train the model
+weights = SimpleML.train(x_data, y_data, 0.01, 500)
+
+# Test prediction
+test_x = Nx.tensor([0.5, 1.0, 1.5, 2.0])
+predictions = SimpleML.predict(test_x, weights)
+
+"Trained weights: #{inspect(weights)}, Predictions: #{inspect(predictions)}"
+```
+
+## Chapter 2: Nx and Numerical Computing 🔢
+
+### Understanding Nx Tensors 📊
+
+Tensors are multi-dimensional arrays that power all ML computations:
+
+```elixir
+import Nx
+
+# Different tensor types
+scalar = Nx.tensor(42)           # 0-dimensional
+vector = Nx.tensor([1, 2, 3])    # 1-dimensional  
+matrix = Nx.tensor([[1, 2], [3, 4]])  # 2-dimensional
+
+# Tensor properties
+IO.puts("Vector shape: #{inspect(Nx.shape(vector))}")
+IO.puts("Vector type: #{inspect(Nx.type(vector))}")
+IO.puts("Vector size: #{inspect(Nx.size(vector))}")
+```
+
+### Essential Tensor Operations ⚡
+
+**Mathematical Operations:**
+
+```elixir
+# Basic arithmetic
+a = Nx.tensor([1.0, 2.0, 3.0])
+b = Nx.tensor([4.0, 5.0, 6.0])
+
+add_result = Nx.add(a, b)
+mult_result = Nx.multiply(a, b)
+pow_result = Nx.pow(a, 2)
+
+{add_result, mult_result, pow_result}
+```
+
+**Aggregation Operations:**
+
+```elixir
+matrix = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+
+sum_all = Nx.sum(matrix)
+sum_rows = Nx.sum(matrix, axes: [1])
+mean_all = Nx.mean(matrix)
+
+{sum_all, sum_rows, mean_all}
+```
+
+### Broadcasting Magic ✨
+
+Nx automatically broadcasts tensors to compatible shapes:
+
+```elixir
+# Broadcasting examples
+vector = Nx.tensor([1, 2, 3])
+scalar = Nx.tensor(10)
+
+# Add scalar to each element
+result1 = Nx.add(vector, scalar)
+
+# Broadcasting with different dimensions
+matrix = Nx.tensor([[1, 2, 3], [4, 5, 6]])
+result2 = Nx.add(matrix, vector)
+
+{result1, result2}
+```
+
+### Hands-On Exercise 💻
+
+Create a function that normalizes a dataset:
+
+```elixir
+defmodule DataPreprocessing do
+  import Nx
+  
+  def normalize(tensor) do
+    mean = Nx.mean(tensor)
+    std = Nx.standard_deviation(tensor)
+    
+    # Normalize: (x - mean) / std
+    Nx.divide(Nx.subtract(tensor, mean), std)
+  end
+  
+  def min_max_scale(tensor) do
+    min = Nx.reduce_min(tensor)
+    max = Nx.reduce_max(tensor)
+    
+    # Scale to [0, 1] range
+    Nx.divide(Nx.subtract(tensor, min), Nx.subtract(max, min))
+  end
+end
+
+# Test with sample data
+data = Nx.tensor([10, 20, 30, 40, 50])
+normalized = DataPreprocessing.normalize(data)
+scaled = DataPreprocessing.min_max_scale(data)
+
+{data, normalized, scaled}
+```
+
+## Chapter 3: Building ML Models with Axon 🧠
+
+### Understanding Axon Architecture 🏗️
+
+Axon provides a functional API for building neural networks:
+
+```elixir
+import Axon
+
+# Simple neural network
+model = Axon.input("input", shape: {nil, 784})
+  |> Axon.dense(128, activation: :relu)
+  |> Axon.dense(64, activation: :relu)
+  |> Axon.dense(10, activation: :softmax)
+
+IO.puts("Model structure:")
+IO.inspect(model)
+```
+
+### Building Your First Neural Network 🚀
+
+**MNIST Digit Classification:**
+
+```elixir
+defmodule MNISTClassifier do
+  import Axon
+  
+  def build_model() do
+    # Input: 28x28 grayscale images (flattened to 784)
+    Axon.input("input", shape: {nil, 784})
+    # Hidden layers
+    |> Axon.dense(128, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    # Output: 10 classes (digits 0-9)
+    |> Axon.dense(10, activation: :softmax)
+  end
+end
+
+# Create a sample model
+model = MNISTClassifier.build_model()
+model
+```
+
+### Common Layer Types 🧩
+
+**Dense (Fully Connected) Layers:**
+
+```elixir
+model1 = Axon.input("input", shape: {nil, 100})
+  |> Axon.dense(50)  # 50 neurons
+  |> Axon.dense(25)  # 25 neurons
+  |> Axon.dense(1)   # Output neuron
+
+model1
+```
+
+**Convolutional Layers (for images):**
+
+```elixir
+model2 = Axon.input("input", shape: {nil, 28, 28, 1})  # Grayscale images
+  |> Axon.conv(32, kernel_size: {3, 3}, activation: :relu)
+  |> Axon.max_pool(kernel_size: {2, 2})
+  |> Axon.conv(64, kernel_size: {3, 3}, activation: :relu)
+  |> Axon.max_pool(kernel_size: {2, 2})
+  |> Axon.flatten()
+  |> Axon.dense(128, activation: :relu)
+  |> Axon.dense(10, activation: :softmax)
+
+model2
+```
+
+### Activation Functions 🔥
+
+```elixir
+model3 = Axon.input("input", shape: {nil, 100})
+  |> Axon.dense(50, activation: :relu)     # ReLU - most common
+  |> Axon.dense(25, activation: :sigmoid)  # Sigmoid - for probabilities
+  |> Axon.dense(10, activation: :softmax)  # Softmax - for classification
+  |> Axon.dense(1, activation: :tanh)     # Tanh - for outputs in [-1, 1]
+
+model3
+```
+
+## Chapter 4: Real-world Applications 🚀
+
+### Complete ML Pipeline Example 🔄
+
+**End-to-End Fraud Detection System:**
+
+```elixir
+defmodule FraudDetection do
+  import Axon
+  
+  def build_pipeline() do
+    # Data preprocessing -> Model training -> Prediction
+    
+    # 1. Model definition
+    model = build_fraud_model()
+    
+    %{
+      model: model
+    }
+  end
+  
+  defp build_fraud_model() do
+    Axon.input("input", shape: {nil, 20})  # 20 features
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(32, activation: :relu)
+    |> Axon.dropout(rate: 0.3)
+    |> Axon.dense(1, activation: :sigmoid)  # Probability of fraud
+  end
+end
+
+# Create the fraud detection pipeline
+pipeline = FraudDetection.build_pipeline()
+pipeline.model
+```
+
+## Interactive Exercises 🎯
+
+### Exercise 1: Tensor Operations
+Create a function that calculates the dot product of two matrices:
+
+```elixir
+defmodule TensorExercises do
+  import Nx
+  
+  def dot_product(a, b) do
+    # Your code here
+    # Hint: Use Nx.dot/2
+    Nx.dot(a, b)
+  end
+  
+  def elementwise_multiply(a, b) do
+    # Your code here
+    Nx.multiply(a, b)
+  end
+end
+
+# Test your functions
+a = Nx.tensor([[1, 2], [3, 4]])
+b = Nx.tensor([[5, 6], [7, 8]])
+
+dot_result = TensorExercises.dot_product(a, b)
+mult_result = TensorExercises.elementwise_multiply(a, b)
+
+{dot_result, mult_result}
+```
+
+### Exercise 2: Build a Custom Model
+Create a neural network with 3 hidden layers (128, 64, 32 neurons) and ReLU activations:
+
+```elixir
+defmodule CustomModel do
+  import Axon
+  
+  def build_custom_model(input_shape \\ {nil, 10}) do
+    # Your code here
+    Axon.input("input", shape: input_shape)
+    |> Axon.dense(128, activation: :relu)
+    |> Axon.dense(64, activation: :relu)
+    |> Axon.dense(32, activation: :relu)
+    |> Axon.dense(1, activation: :sigmoid)
+  end
+end
+
+# Build and display the model
+model = CustomModel.build_custom_model()
+model
+```
+
+## Version Compatibility Notes 📝
+
+**Nx 0.11 changes:**
+- `Nx.random_normal/1` → `Nx.random_normal(shape, mean, std)`
+- `Nx.power/2` → `Nx.pow/2`
+- Use explicit `Nx.add()`, `Nx.subtract()`, `Nx.multiply()` for clarity
+
+**Axon 0.8 changes:**
+- Improved performance
+- Better API consistency
+- Enhanced training loops
+
+## Next Steps 🚀
+
+1. **Update your project dependencies:**
+
+```bash
+mise exec -- mix deps.update --all
+mise exec -- mix deps.compile
+```
+
+2. **Experiment** with the latest Nx/Axon features
+3. **Try GPU acceleration** with EXLA
+4. **Build real projects** with your new ML skills
+
+Happy learning with the latest versions! 🎉✨
+
+---
+
+*This notebook uses Nx 0.11 and Axon 0.8 - the latest stable versions.*
+*Save this notebook (Ctrl+S) to keep your progress!*

skills/gradio.md

@@ -0,0 +1,5 @@
+# Gradio Skill
+
+*This file should contain the full markdown specification for the Gradio skill as provided by the user.*
+
+*(The actual content was not supplied in the prior messages, so please replace this placeholder with the correct markdown when available.)

skills/hf-cli.md

@@ -0,0 +1,35 @@
+# Skill: hf-cli
+
+Install: `curl -LsSf https://hf.co/cli/install.sh | bash -s`.
+
+The Hugging Face Hub CLI tool `hf` is available. IMPORTANT: The `hf` command replaces the deprecated `huggingface-cli` command.
+
+Use `hf --help` to view available functions. Note that auth commands are now under `hf auth` e.g. `hf auth whoami`.
+
+Generated with `huggingface_hub v1.8.0`. Run `hf skills add --force` to regenerate.
+
+## Commands
+
+- `hf download REPO_ID` — Download files from the Hub. `[--type CHOICE --revision TEXT --include TEXT --exclude TEXT --cache-dir TEXT --local-dir TEXT --force-download --dry-run --quiet --max-workers INTEGER]`
+- `hf env` — Print information about the environment.
+- `hf sync` — Sync files between local directory and a bucket. `[--delete --ignore-times --ignore-sizes --plan TEXT --apply TEXT --dry-run --include TEXT --exclude TEXT --filter-from TEXT --existing --ignore-existing --verbose --quiet]`
+- `hf upload REPO_ID` — Upload a file or a folder to the Hub. Recommended for single-commit uploads. `[--type CHOICE --revision TEXT --private --include TEXT --exclude TEXT --delete TEXT --commit-message TEXT --commit-description TEXT --create-pr --every FLOAT --quiet]`
+- `hf upload-large-folder REPO_ID LOCAL_PATH` — Upload a large folder to the Hub. Recommended for resumable uploads. `[--type CHOICE --revision TEXT --private --include TEXT --exclude TEXT --num-workers INTEGER --no-report --no-bars]`
+- `hf version` — Print information about the hf version.
+
+### `hf auth` — Manage authentication (login, logout, etc.).
+
+- `hf auth list` — List all stored access tokens.
+- `hf auth login` — Login using a token from huggingface.co/settings/tokens. `[--add-to-git-credential --force]`
+- `hf auth logout` — Logout from a specific token. `[--token-name TEXT]`
+- `hf auth switch` — Switch between access tokens. `[--token-name TEXT --add-to-git-credential]`
+- `hf auth whoami` — Find out which huggingface.co account you are logged in as. `[--format CHOICE]`
+
+... (additional commands omitted for brevity) ...
+
+## Tips
+
+- Use `hf <command> --help` for full options, descriptions, usage, and real-world examples
+- Authenticate with `HF_TOKEN` env var (recommended) or with `--token`
+
+Base directory for this skill: file:///home/saru/.agents/skills/hf-cli

skills/hf_dataset_viewer.md

@@ -0,0 +1,5 @@
+# Hugging Face Dataset Viewer Skill
+
+*This file should contain the full markdown specification for the Hugging Face Dataset Viewer skill as provided by the user.*
+
+*(The actual content was not supplied in the prior messages, so please replace this placeholder with the correct markdown when available.)

skills/hf_jobs.md

@@ -0,0 +1,285 @@
+# Running Workloads on Hugging Face Jobs
+
+## Overview
+
+Run any workload on fully managed Hugging Face infrastructure. No local setup required—jobs run on cloud CPUs, GPUs, or TPUs and can persist results to the Hugging Face Hub.
+
+**Common use cases:**
+- **Data Processing** - Transform, filter, or analyze large datasets
+- **Batch Inference** - Run inference on thousands of samples
+- **Experiments & Benchmarks** - Reproducible ML experiments
+- **Model Training** - Fine-tune models (see `model-trainer` skill for TRL-specific training)
+- **Synthetic Data Generation** - Generate datasets using LLMs
+- **Development & Testing** - Test code without local GPU setup
+- **Scheduled Jobs** - Automate recurring tasks
+
+**For model training specifically:** See the `model-trainer` skill for TRL-based training workflows.
+
+## When to Use This Skill
+
+Use this skill when users want to:
+- Run Python workloads on cloud infrastructure
+- Execute jobs without local GPU/TPU setup
+- Process data at scale
+- Run batch inference or experiments
+- Schedule recurring tasks
+- Use GPUs/TPUs for any workload
+- Persist results to the Hugging Face Hub
+
+## Key Directives
+
+1. **ALWAYS use `hf_jobs()` MCP tool** - Submit jobs using `hf_jobs("uv", {...})` or `hf_jobs("run", {...})`. The `script` parameter accepts Python code directly. Do NOT save to local files unless the user explicitly requests it. Pass the script content as a string to `hf_jobs()`.
+2. **Always handle authentication** - Jobs that interact with the Hub require `HF_TOKEN` via secrets. See Token Usage section below.
+3. **Provide job details after submission** - After submitting, provide job ID, monitoring URL, estimated time, and note that the user can request status checks later.
+4. **Set appropriate timeouts** - Default 30min may be insufficient for long-running tasks.
+
+## Prerequisites Checklist
+
+### ✅ **Account & Authentication**
+- Hugging Face Account with Pro/Team/Enterprise plan (Jobs require paid plan)
+- Authenticated login: Check with `hf_whoami()`
+- **HF_TOKEN for Hub Access** ⚠️ CRITICAL - Required for any Hub operations (push models/datasets, download private repos, etc.)
+- Token must have appropriate permissions (read for downloads, write for uploads)
+
+### ✅ **Token Usage**
+
+**When tokens are required:**
+- Pushing models/datasets to Hub
+- Accessing private repositories
+- Using Hub APIs in scripts
+- Any authenticated Hub operations
+
+**How to provide tokens:**
+```python
+# hf_jobs MCP tool — $HF_TOKEN is auto-replaced with real token:
+{"secrets": {"HF_TOKEN": "$HF_TOKEN"}}
+
+# HfApi().run_uv_job() — MUST pass actual token via get_token():
+from huggingface_hub import get_token
+secrets={"HF_TOKEN": get_token()}
+```
+
+**⚠️ CRITICAL:** The `$HF_TOKEN` placeholder is ONLY auto-replaced by the `hf_jobs` MCP tool. When using `HfApi().run_uv_job()`, you MUST pass the real token via `get_token()`. Passing the literal string `"$HF_TOKEN"` results in a 9-character invalid token and 401 errors.
+
+## Token Usage Guide
+
+### Understanding Tokens
+- **What are HF Tokens?** Authentication credentials for Hugging Face Hub.
+- **Token Types:** Read, Write, Organization.
+
+### When Tokens Are Required
+- **Always Required:** Pushing models/datasets, accessing private repos, creating/modifying repos, using Hub APIs.
+- **Not Required:** Downloading public models/datasets, running jobs that don't interact with Hub, reading public repo info.
+
+### How to Provide Tokens to Jobs
+#### Method 1: Automatic Token (Recommended)
+```python
+hf_jobs("uv", {
+    "script": "your_script.py",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}  # ✅ Automatic replacement
+})
+```
+**Benefits:** No token exposure, uses current login session.
+
+#### Method 2: Explicit Token (Not Recommended)
+```python
+hf_jobs("uv", {
+    "script": "your_script.py",
+    "secrets": {"HF_TOKEN": "hf_abc123..."}  # ⚠️ Hardcoded token
+})
+```
+Use only if automatic token fails.
+
+#### Method 3: Environment Variable (Less Secure)
+```python
+hf_jobs("uv", {
+    "script": "your_script.py",
+    "env": {"HF_TOKEN": "hf_abc123..."}  # ⚠️ Less secure than secrets
+})
+```
+
+### Using Tokens in Scripts
+```python
+import os
+from huggingface_hub import HfApi
+
+token = os.environ.get("HF_TOKEN")
+api = HfApi(token=token)
+```
+**Best practices:** Use `os.environ.get("HF_TOKEN")`, avoid hardcoding.
+
+### Token Verification
+```python
+from huggingface_hub import whoami
+user_info = whoami()
+```
+
+### Common Token Issues
+- **401 Unauthorized:** Add `secrets={"HF_TOKEN": "$HF_TOKEN"}`.
+- **403 Forbidden:** Ensure token has write permissions.
+- **Token not found:** Use `secrets` not `env`.
+- **Repository access denied:** Use token with repo access.
+
+### Token Security Best Practices
+1. Never commit tokens.
+2. Use secrets, not env.
+3. Rotate tokens regularly.
+4. Use minimal permissions.
+5. Do not share tokens.
+6. Monitor token usage.
+
+## Quick Start: Two Approaches
+
+### Approach 1: UV Scripts (Recommended)
+```python
+hf_jobs("uv", {
+    "script": """
+# /// script
+# dependencies = ["transformers", "torch"]
+# ///
+
+from transformers import pipeline
+classifier = pipeline("sentiment-analysis")
+print(classifier("I love Hugging Face!"))
+""",
+    "flavor": "cpu-basic",
+    "timeout": "30m"
+})
+```
+**CLI Equivalent:** `hf jobs uv run my_script.py --flavor cpu-basic --timeout 30m`
+
+#### Custom Docker Images for UV Scripts
+```python
+hf_jobs("uv", {
+    "script": "inference.py",
+    "image": "vllm/vllm-openai:latest",
+    "flavor": "a10g-large"
+})
+```
+
+#### Python Version
+```python
+hf_jobs("uv", {"script": "my_script.py", "python": "3.11", "flavor": "cpu-basic"})
+```
+
+**Important:** `script` must be inline code or a URL; local paths won't work with MCP tool.
+
+#### Adding Dependencies at Runtime
+```python
+hf_jobs("uv", {
+    "script": "inference.py",
+    "dependencies": ["transformers", "torch>=2.0"],
+    "flavor": "a10g-small"
+})
+```
+
+### Approach 2: Docker-Based Jobs
+```python
+hf_jobs("run", {
+    "image": "python:3.12",
+    "command": ["python", "-c", "print('Hello from HF Jobs!')"],
+    "flavor": "cpu-basic",
+    "timeout": "30m"
+})
+```
+**CLI Equivalent:** `hf jobs run python:3.12 python -c "print('Hello from HF Jobs!')"`
+
+#### GPU Example
+```python
+hf_jobs("run", {
+    "image": "pytorch/pytorch:2.6.0-cuda12.4-cudnn9-devel",
+    "command": ["python", "-c", "import torch; print(torch.cuda.get_device_name())"],
+    "flavor": "a10g-small",
+    "timeout": "1h"
+})
+```
+
+## Finding More UV Scripts on Hub
+```python
+# Discover available UV script collections
+dataset_search({"author": "uv-scripts", "sort": "downloads", "limit": 20})
+```
+
+## Hardware Selection
+| Workload Type | Recommended Hardware |
+|---|---|
+| Data processing, testing | `cpu-basic`, `cpu-upgrade` |
+| Small models, demos | `t4-small` |
+| Medium models | `t4-medium`, `l4x1` |
+| Large models, production | `a10g-small`, `a10g-large` |
+| Very large models | `a100-large` |
+| Batch inference | `a10g-large`, `a100-large` |
+| Multi-GPU workloads | `l4x4`, `a10g-largex2`, `a10g-largex4` |
+| TPU workloads | `v5e-1x1`, `v5e-2x2`, `v5e-2x4` |
+
+## Critical: Saving Results
+**⚠️ EPHEMERAL ENVIRONMENT—MUST PERSIST RESULTS**
+
+### Persistence Options
+1. **Push to Hugging Face Hub (Recommended)**
+```python
+model.push_to_hub("username/model-name", token=os.environ["HF_TOKEN"])
+```
+2. **Use External Storage** (e.g., S3)
+3. **Send Results via API**
+
+## Timeout Management
+Default: 30 minutes. Set custom timeout as needed:
+```python
+{"timeout": "2h"}
+```
+
+## Cost Estimation
+```
+Total Cost = (Hours of runtime) × (Cost per hour)
+```
+
+## Monitoring and Tracking
+### Check Job Status
+```python
+hf_jobs("ps")
+hf_jobs("inspect", {"job_id": "your-job-id"})
+hf_jobs("logs", {"job_id": "your-job-id"})
+```
+### Job URLs
+`https://huggingface.co/jobs/username/job-id`
+
+## Scheduled Jobs
+```python
+hf_jobs("scheduled uv", {"script": "your_script.py", "schedule": "@hourly", "flavor": "cpu-basic"})
+```
+
+## Webhooks: Trigger Jobs on Events
+```python
+from huggingface_hub import create_webhook
+webhook = create_webhook(job_id=job.id, watched=[{"type": "user", "name": "your-username"}], domains=["repo", "discussion"], secret="your-secret")
+```
+
+## Common Workload Patterns
+### Pattern 1: Dataset → Model Responses (vLLM)
+```python
+script = Path("hf-jobs/scripts/generate-responses.py").read_text()
+hf_jobs("uv", {"script": script, "script_args": ["username/input-dataset", "username/output-dataset", "--messages-column", "messages", "--model-id", "Qwen/Qwen3-30B-A3B-Instruct-2507"], "flavor": "a10g-large", "timeout": "4h", "secrets": {"HF_TOKEN": "$HF_TOKEN"}})
+```
+
+## Common Failure Modes
+- **Out of Memory (OOM)** – Reduce batch size or upgrade hardware.
+- **Job Timeout** – Increase timeout.
+- **Hub Push Failures** – Ensure token in secrets.
+- **Missing Dependencies** – Add to PEP 723 header.
+- **Authentication Errors** – Verify `hf_whoami()` and token permissions.
+
+## Troubleshooting
+- Job times out → Increase timeout, optimize code.
+- Results not saved → Check persistence method, verify HF_TOKEN.
+- OOM → Reduce batch size, upgrade hardware.
+- Import errors → Add dependencies.
+- Authentication errors → Check token.
+
+## Resources
+- Official Docs: https://huggingface.co/docs/huggingface_hub/guides/jobs
+- UV Scripts Guide: https://docs.astral.sh/uv/guides/scripts/
+- Hardware Flavors: https://huggingface.co/docs/hub/en/spaces-config-reference
+- Token Guide: references/token_usage.md
+- Hub Persistence: references/hub_saving.md
+- Troubleshooting: references/troubleshooting.md

skills/training_trl.md

@@ -0,0 +1,590 @@
+# TRL Training on Hugging Face Jobs
+
+## Overview
+
+Train language models using TRL (Transformer Reinforcement Learning) on fully managed Hugging Face infrastructure. No local GPU setup required—models train on cloud GPUs and results are automatically saved to the Hugging Face Hub.
+
+**TRL provides multiple training methods:**
+- **SFT** (Supervised Fine-Tuning) - Standard instruction tuning
+- **DPO** (Direct Preference Optimization) - Alignment from preference data
+- **GRPO** (Group Relative Policy Optimization) - Online RL training
+- **Reward Modeling** - Train reward models for RLHF
+
+**For detailed TRL method documentation:**
+```python
+hf_doc_search("your query", product="trl")
+hf_doc_fetch("https://huggingface.co/docs/trl/sft_trainer")  # SFT
+hf_doc_fetch("https://huggingface.co/docs/trl/dpo_trainer")  # DPO
+# etc.
+```
+
+**See also:** `references/training_methods.md` for method overviews and selection guidance
+
+## When to Use This Skill
+
+Use this skill when users want to:
+- Fine‑tune language models on cloud GPUs without local infrastructure
+- Train with TRL methods (SFT, DPO, GRPO, etc.)
+- Run training jobs on Hugging Face Jobs infrastructure
+- Convert trained models to GGUF for local deployment (Ollama, LM Studio, llama.cpp)
+- Ensure trained models are permanently saved to the Hub
+- Use modern workflows with optimized defaults
+
+### When to Use Unsloth
+
+Use **Unsloth** (`references/unsloth.md`) instead of standard TRL when:
+- **Limited GPU memory** – Unsloth uses ~60% less VRAM
+- **Speed matters** – Unsloth is ~2x faster
+- **Training large models (>13B)** – Memory efficiency is critical
+- **Training Vision‑Language Models (VLMs)** – Unsloth has `FastVisionModel` support
+
+See `references/unsloth.md` for complete Unsloth documentation and `scripts/unsloth_sft_example.py` for a production‑ready training script.
+
+## Key Directives
+
+1. **ALWAYS use `hf_jobs()` MCP tool** – Submit jobs using `hf_jobs("uv", {...})`, **NOT** bash `trl-jobs` commands. The `script` parameter accepts Python code directly. Do **NOT** save to local files unless the user explicitly requests it. Pass the script content as a string to `hf_jobs()`. If user asks to "train a model", "fine‑tune", or similar requests, you **MUST** create the training script **AND** submit the job immediately using `hf_jobs()`.
+2. **Always include Trackio** – Every training script should include Trackio for real‑time monitoring. Use example scripts in `scripts/` as templates.
+3. **Provide job details after submission** – After submitting, provide job ID, monitoring URL, estimated time, and note that the user can request status checks later.
+4. **Use example scripts as templates** – Reference `scripts/train_sft_example.py`, `scripts/train_dpo_example.py`, etc. as starting points.
+
+## Local Script Execution
+
+Repository scripts use PEP 723 inline dependencies. Run them with `uv run`:
+```bash
+uv run scripts/estimate_cost.py --help
+uv run scripts/dataset_inspector.py --help
+```
+
+## Prerequisites Checklist
+
+### ✅ **Account & Authentication**
+- Hugging Face Account with a paid plan (Pro/Team/Enterprise) – Jobs require a paid plan
+- Authenticated login: Check with `hf_whoami()`
+- **HF_TOKEN for Hub Push** ⚠️ CRITICAL – Training environment is ephemeral; must push to Hub or all training results are lost
+- Token must have write permissions
+- **MUST pass `secrets={"HF_TOKEN": "$HF_TOKEN"}`** in job config to make token available (the `$HF_TOKEN` syntax references your actual token value)
+
+### ✅ **Dataset Requirements**
+- Dataset must exist on Hub or be loadable via `datasets.load_dataset()`
+- Format must match training method (SFT: "messages"/text/prompt‑completion; DPO: chosen/rejected; GRPO: prompt‑only)
+- **ALWAYS validate unknown datasets** before GPU training to prevent format failures (see Dataset Validation section below)
+- Size appropriate for hardware (Demo: 50‑100 examples on t4‑small; Production: 1K‑10K+ on a10g‑large/a100‑large)
+
+### ⚠️ **Critical Settings**
+- **Timeout must exceed expected training time** – Default 30 min is TOO SHORT for most training. Minimum recommended: 1‑2 hours. Job fails and loses all progress if timeout is exceeded.
+- **Hub push must be enabled** – Config: `push_to_hub=True`, `hub_model_id="username/model-name"`; Job: `secrets={"HF_TOKEN": "$HF_TOKEN"}`
+
+## Asynchronous Job Guidelines
+
+### ⚠️ IMPORTANT: Training jobs run asynchronously and can take hours
+
+#### Action Required
+When user requests training:
+1. **Create the training script** with Trackio included (use `scripts/train_sft_example.py` as template)
+2. **Submit immediately** using `hf_jobs()` MCP tool with script content inline – don’t save to file unless user requests
+3. **Report submission** with job ID, monitoring URL, and estimated time
+4. **Wait for user** to request status checks – don’t poll automatically
+
+#### Ground Rules
+- Jobs run in background; training continues independently.
+- Initial logs may be delayed (30‑60 seconds).
+- Provide monitoring links; let user request status updates.
+- Avoid polling; provide links instead.
+
+#### After Submission
+Provide to user:
+```
+✅ Job submitted successfully!
+
+Job ID: abc123xyz
+Monitor: https://huggingface.co/jobs/username/abc123xyz
+
+Expected time: ~2 hours
+Estimated cost: ~
+
+The job is running in the background. Ask me to check status/logs when ready!
+```
+
+## Quick Start: Three Approaches
+
+### Approach 1: UV Scripts (Recommended – Default Choice)
+
+UV scripts use PEP 723 inline dependencies for clean, self‑contained training. **This is the primary approach for Claude Code.**
+```python
+hf_jobs("uv", {
+    "script": """
+# /// script
+# dependencies = ["trl>=0.12.0", "peft>=0.7.0", "trackio"]
+# ///
+
+from datasets import load_dataset
+from peft import LoraConfig
+from trl import SFTTrainer, SFTConfig
+import trackio
+
+dataset = load_dataset("trl-lib/Capybara", split="train")
+
+# Create train/eval split for monitoring
+dataset_split = dataset.train_test_split(test_size=0.1, seed=42)
+
+trainer = SFTTrainer(
+    model="Qwen/Qwen2.5-0.5B",
+    train_dataset=dataset_split["train"],
+    eval_dataset=dataset_split["test"],
+    peft_config=LoraConfig(r=16, lora_alpha=32),
+    args=SFTConfig(
+        output_dir="my-model",
+        push_to_hub=True,
+        hub_model_id="username/my-model",
+        num_train_epochs=3,
+        eval_strategy="steps",
+        eval_steps=50,
+        report_to="trackio",
+        project="meaningful_project_name",  # project name for Trackio
+        run_name="meaningful_run_name",   # descriptive name for the specific training run (Trackio)
+    )
+)
+
+trainer.train()
+trainer.push_to_hub()
+""",
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+**Benefits:** Direct MCP tool usage, clean code, dependencies declared inline (PEP 723), no file saving required, full control.
+**When to use:** Default for all training tasks in Claude Code, custom training logic, any scenario requiring `hf_jobs()`.
+
+#### Working with Scripts
+⚠️ **Important:** The `script` parameter accepts either inline code (recommended) **OR** a URL. **Local file paths do NOT work.**
+**Why local paths don't work:** Jobs run in isolated Docker containers without access to your local filesystem. Scripts must be:
+- Inline code (as shown above) – recommended for custom training
+- Publicly accessible URLs (e.g., raw files on GitHub or HF Hub)
+- Private repo URLs (with HF_TOKEN)
+
+**Common mistakes:**
+```python
+# ❌ These will all fail
+hf_jobs("uv", {"script": "train.py"})
+hf_jobs("uv", {"script": "./scripts/train.py"})
+hf_jobs("uv", {"script": "/path/to/train.py"})
+```
+**Correct approaches:**
+```python
+# ✅ Inline code (recommended)
+hf_jobs("uv", {"script": "# /// script\n# dependencies = [...]\n# ///\n<your code>"})
+
+# ✅ From Hugging Face Hub
+hf_jobs("uv", {"script": "https://huggingface.co/user/repo/resolve/main/train.py"})
+
+# ✅ From GitHub
+hf_jobs("uv", {"script": "https://raw.githubusercontent.com/user/repo/main/train.py"})
+
+# ✅ From Gist
+hf_jobs("uv", {"script": "https://gist.githubusercontent.com/user/id/raw/train.py"})
+```
+**To use local scripts:** Upload to HF Hub first:
+```bash
+hf repos create my-training-scripts --type model
+hf upload my-training-scripts ./train.py train.py
+# Use: https://huggingface.co/USERNAME/my-training-scripts/resolve/main/train.py
+```
+
+### Approach 2: TRL Maintained Scripts (Official Examples)
+
+TRL provides battle‑tested scripts for all methods. Can be run from URLs:
+```python
+hf_jobs("uv", {
+    "script": "https://github.com/huggingface/trl/blob/main/trl/scripts/sft.py",
+    "script_args": [
+        "--model_name_or_path", "Qwen/Qwen2.5-0.5B",
+        "--dataset_name", "trl-lib/Capybara",
+        "--output_dir", "my-model",
+        "--push_to_hub",
+        "--hub_model_id", "username/my-model"
+    ],
+    "flavor": "a10g-large",
+    "timeout": "2h",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+**Benefits:** No code to write, maintained by TRL team, production‑tested.
+**When to use:** Standard TRL training, quick experiments, don’t need custom code.
+**Available:** Scripts are available from https://github.com/huggingface/trl/tree/main/examples/scripts
+
+### Finding More UV Scripts on Hub
+
+The `uv-scripts` organization provides ready‑to‑use UV scripts stored as datasets on Hugging Face Hub:
+```python
+# Discover available UV script collections
+dataset_search({"author": "uv-scripts", "sort": "downloads", "limit": 20})
+
+# Explore a specific collection
+hub_repo_details(["uv-scripts/classification"], repo_type="dataset", include_readme=True)
+```
+**Popular collections:** ocr, classification, synthetic-data, vllm, dataset-creation
+
+### Approach 3: HF Jobs CLI (Direct Terminal Commands)
+
+When the `hf_jobs()` MCP tool is unavailable, use the `hf jobs` CLI directly.
+
+**⚠️ CRITICAL: CLI Syntax Rules**
+```bash
+# ✅ CORRECT syntax - flags BEFORE script URL
+hf jobs uv run --flavor a10g-large --timeout 2h --secrets HF_TOKEN "https://example.com/train.py"
+
+# ❌ WRONG - "run uv" instead of "uv run"
+hf jobs run uv "https://example.com/train.py" --flavor a10g-large
+
+# ❌ WRONG - flags AFTER script URL (will be ignored!)
+hf jobs uv run "https://example.com/train.py" --flavor a10g-large
+
+# ❌ WRONG - "--secret" instead of "--secrets" (plural)
+hf jobs uv run --secrets HF_TOKEN "https://example.com/train.py"
+```
+**Key syntax rules:**
+1. Command order is `hf jobs uv run` (NOT `hf jobs run uv`).
+2. All flags (`--flavor`, `--timeout`, `--secrets`) must come **BEFORE** the script URL.
+3. Use `--secrets` (plural), not `--secret`.
+4. Script URL must be the last positional argument.
+
+**Complete CLI example:**
+```bash
+hf jobs uv run \
+  --flavor a10g-large \
+  --timeout 2h \
+  --secrets HF_TOKEN \
+  "https://huggingface.co/user/repo/resolve/main/train.py"
+```
+
+**Check job status via CLI:**
+```bash
+hf jobs ps                        # List all jobs
+hf jobs logs <job-id>             # View logs
+hf jobs inspect <job-id>          # Job details
+hf jobs cancel <job-id>           # Cancel a job
+```
+
+### Approach 4: TRL Jobs Package (Simplified Training)
+
+The `trl-jobs` package provides optimized defaults and a one‑liner training.
+```bash
+uvx trl-jobs sft \
+  --model_name Qwen/Qwen2.5-0.5B \
+  --dataset_name trl-lib/Capybara
+```
+**Benefits:** Pre‑configured settings, automatic Trackio integration, automatic Hub push, one‑line commands.
+**When to use:** User working in terminal directly (not Claude Code context), quick local experimentation.
+**Repository:** https://github.com/huggingface/trl-jobs
+
+⚠️ **In Claude Code context, prefer using `hf_jobs()` MCP tool (Approach 1) when available.**
+
+## Hardware Selection
+
+| Model Size | Recommended Hardware | Cost (approx/hr) | Use Case |
+|------------|---------------------|------------------|----------|
+| <1B params | `t4-small` | ~0.75 | Demos, quick tests only without eval steps |
+| 1‑3B params | `t4-medium`, `l4x1` | ~0.5‑2.5 | Development |
+| 3‑7B params | `a10g-small`, `a10g-large` | ~0.5‑5.0 | Production training |
+| 7‑13B params | `a10g-large`, `a100-large` | ~10‑20 | Large models (use LoRA) |
+| 13B+ params | `a100-large`, `a10g-largex2` | ~20‑30 | Very large (use LoRA) |
+
+**GPU Flavors:** cpu-basic/upgrade/performance/xl, t4-small/medium, l4x1/x4, a10g‑small/large/largex2/largex4, a100‑large, h100/h100x8
+
+**Guidelines:**
+- Use **LoRA/PEFT** for models >7B to reduce memory.
+- Multi‑GPU automatically handled by TRL/Accelerate.
+- Start with smaller hardware for testing.
+
+## Critical: Saving Results to Hub
+
+**⚠️ EPHEMERAL ENVIRONMENT—MUST PUSH TO HUB**
+
+The Jobs environment is temporary. All files are deleted when the job ends. If the model isn’t pushed to Hub, **ALL TRAINING IS LOST**.
+
+### Required Configuration
+```python
+SFTConfig(
+    push_to_hub=True,
+    hub_model_id="username/model-name",  # MUST specify
+    hub_strategy="every_save",  # Optional: push checkpoints
+)
+```
+**In job submission:**
+```json
+{"secrets": {"HF_TOKEN": "$HF_TOKEN"}}
+```
+
+### Verification Checklist
+- [ ] `push_to_hub=True` set in config
+- [ ] `hub_model_id` includes `username/repo-name`
+- [ ] `secrets` includes `HF_TOKEN`
+- [ ] User has write access to target repo
+
+## Timeout Management
+
+**⚠️ DEFAULT: 30 minutes – TOO SHORT FOR TRAINING**
+
+### Setting Timeouts
+```json
+{"timeout": "2h"}   # 2 hours (formats: "90m", "2h", "1.5h", or seconds as integer)
+```
+### Timeout Guidelines
+| Scenario | Recommended | Notes |
+|----------|--------------|-------|
+| Quick demo (50‑100 examples) | 10‑30 min | Verify setup |
+| Development training | 1‑2 hours | Small datasets |
+| Production (3‑7B model) | 4‑6 hours | Full datasets |
+| Large model with LoRA | 3‑6 hours | Depends on dataset |
+
+**Always add 20‑30% buffer** for model/dataset loading, checkpoint saving, Hub push, and network delays.
+
+**On timeout:** Job killed immediately, all unsaved progress lost, must restart from the beginning.
+
+## Cost Estimation
+
+**Offer to estimate cost when planning jobs with known parameters.** Use `scripts/estimate_cost.py`:
+```bash
+uv run scripts/estimate_cost.py \
+  --model meta-llama/Llama-2-7b-hf \
+  --dataset trl-lib/Capybara \
+  --hardware a10g-large \
+  --dataset-size 16000 \
+  --epochs 3
+```
+Output includes estimated time, cost, recommended timeout (with buffer), and optimization suggestions.
+
+**When to offer:** User planning a job, asks about cost/time, choosing hardware, job will run >1 hour or cost >some amount.
+
+## Example Training Scripts
+
+**Production‑ready templates with all best practices:**
+- **`scripts/train_sft_example.py`** – Complete SFT training with Trackio, LoRA, checkpoints
+- **`scripts/train_dpo_example.py`** – DPO training for preference learning
+- **`scripts/train_grpo_example.py`** – GRPO training for online RL
+
+These scripts demonstrate proper Hub saving, Trackio integration, checkpoint management, and optimized parameters. Pass their content inline to `hf_jobs()` or use as templates for custom scripts.
+
+## Monitoring and Tracking
+
+**Trackio** provides real‑time metrics visualization. See `references/trackio_guide.md` for a complete setup guide.
+
+**Key points:**
+- Add `trackio` to dependencies
+- Configure trainer with `report_to="trackio"` and run name
+- Use a default Trackio space unless user specifies otherwise
+
+### Trackio Configuration Defaults
+- **Space ID:** `{username}/trackio` (use "trackio" as default space name)
+- **Run naming:** Descriptive of task, model, or purpose unless overridden
+- **Project Name:** Use a Project Name to associate runs with a particular Project
+
+**User overrides:** If user requests custom Trackio configuration (custom space, run naming, grouping, or additional config), apply their preferences instead of defaults.
+
+## Dataset Validation
+
+**Validate dataset format BEFORE launching GPU training to prevent the #1 cause of training failures: format mismatches.**
+
+### Why Validate
+- 50%+ of training failures are due to dataset format issues
+- DPO especially strict: requires exact column names (`prompt`, `chosen`, `rejected`)
+- Failed GPU jobs waste GPU‑hours and 30‑60 minutes
+- Validation on CPU costs ~0.01 $ and takes <1 minute
+
+### When to Validate
+**ALWAYS validate for:**
+- Unknown or custom datasets
+- DPO training (CRITICAL – 90% of datasets need mapping)
+- Any dataset not explicitly TRL‑compatible
+
+**Skip validation for known TRL datasets:** `trl-lib/ultrachat_200k`, `trl-lib/Capybara`, etc.
+
+### Usage
+```python
+hf_jobs("uv", {
+    "script": "https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py",
+    "script_args": ["--dataset", "username/dataset-name", "--split", "train"]
+})
+```
+The script is fast and usually completes synchronously.
+
+### Reading Results
+The output shows compatibility for each training method:
+- **`✓ READY`** – Dataset is compatible, use directly
+- **`✗ NEEDS MAPPING`** – Compatible but needs preprocessing (mapping code provided)
+- **`✗ INCOMPATIBLE`** – Cannot be used for this method
+
+When mapping is needed, the output includes a **"MAPPING CODE"** section with copy‑paste‑ready Python code.
+
+### Example Workflow
+```python
+# 1. Inspect dataset (costs ~0.01 $, <1 min on CPU)
+hf_jobs("uv", {
+    "script": "https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py",
+    "script_args": ["--dataset", "argilla/distilabel-math-preference-dpo", "--split", "train"]
+})
+
+# 2. Check output markers:
+#    ✓ READY → proceed with training
+#    ✗ NEEDS MAPPING → apply mapping code below
+#    ✗ INCOMPATIBLE → choose different method/dataset
+
+# 3. If mapping needed, apply before training:
+
+def format_for_dpo(example):
+    return {
+        'prompt': example['instruction'],
+        'chosen': example['chosen_response'],
+        'rejected': example['rejected_response'],
+    }
+
+dataset = dataset.map(format_for_dpo, remove_columns=dataset.column_names)
+
+# 4. Launch training job with confidence
+```
+
+#### Common Scenario: DPO Format Mismatch
+Most DPO datasets use non‑standard column names. Example:
+```
+Dataset has: instruction, chosen_response, rejected_response
+DPO expects: prompt, chosen, rejected
+```
+The validator detects this and provides exact mapping code to fix it.
+
+## Converting Models to GGUF
+
+After training, convert models to **GGUF format** for use with llama.cpp, Ollama, LM Studio, and other local inference tools.
+
+**What is GGUF:**
+- Optimized for CPU/GPU inference with llama.cpp
+- Supports quantization (4‑bit, 5‑bit, 8‑bit) to reduce model size
+- Compatible with Ollama, LM Studio, Jan, GPT4All, llama.cpp
+- Typically 2‑8 GB for 7B models (vs 14 GB unquantized)
+
+**When to convert:**
+- Running models locally with Ollama or LM Studio
+- Reducing model size with quantization
+- Deploying to edge devices
+- Sharing models for local‑first use
+
+**See:** `references/gguf_conversion.md` for complete conversion guide, including production‑ready conversion script, quantization options, hardware requirements, usage examples, and troubleshooting.
+
+**Quick conversion:**
+```python
+hf_jobs("uv", {
+    "script": "<see references/gguf_conversion.md for complete script>",
+    "flavor": "a10g-large",
+    "timeout": "45m",
+    "secrets": {"HF_TOKEN": "$HF_TOKEN"},
+    "env": {
+        "ADAPTER_MODEL": "username/my-finetuned-model",
+        "BASE_MODEL": "Qwen/Qwen2.5-0.5B",
+        "OUTPUT_REPO": "username/my-model-gguf"
+    }
+})
+```
+
+## Common Training Patterns
+See `references/training_patterns.md` for detailed examples including:
+- Quick demo (5‑10 minutes)
+- Production with checkpoints
+- Multi‑GPU training
+- DPO training (preference learning)
+- GRPO training (online RL)
+
+## Common Failure Modes
+
+### Out of Memory (OOM)
+**Fix (try in order):**
+1. Reduce batch size: `per_device_train_batch_size=1`, increase `gradient_accumulation_steps=8`. Effective batch size = `per_device_train_batch_size` × `gradient_accumulation_steps`. Keep effective batch size ≈128 for best performance.
+2. Enable: `gradient_checkpointing=True`
+3. Upgrade hardware: t4‑small → l4x1, a10g‑small → a10g‑large, etc.
+
+### Dataset Misformatted
+**Fix:**
+1. Validate first with dataset inspector (see Dataset Validation).
+2. Check output for compatibility markers (✓ READY, ✗ NEEDS MAPPING, ✗ INCOMPATIBLE).
+3. Apply mapping code from inspector output if needed.
+
+### Job Timeout
+**Fix:**
+1. Check logs for actual runtime: `hf_jobs("logs", {"job_id": "..."})`
+2. Increase timeout with buffer: `"timeout": "3h"` (add 30% to estimated time)
+3. Reduce training: lower `num_train_epochs`, use smaller dataset, enable `max_steps`
+4. Save checkpoints: `save_strategy="steps"`, `save_steps=500`, `hub_strategy="every_save"`
+
+**Note:** Default 30 min is insufficient for real training. Minimum 1‑2 hours.
+
+### Hub Push Failures
+**Fix:**
+1. Add to job: `secrets={"HF_TOKEN": "$HF_TOKEN"}`
+2. Add to config: `push_to_hub=True`, `hub_model_id="username/model-name"`
+3. Verify auth: `hf_whoami()`
+4. Check token has write permissions and repo exists (or set `hub_private_repo=True`)
+
+### Missing Dependencies
+**Fix:** Add to PEP 723 header:
+```python
+# /// script
+# dependencies = ["trl>=0.12.0", "peft>=0.7.0", "trackio", "missing-package"]
+# ///
+```
+
+## Troubleshooting
+
+**Common issues:**
+- Job times out → Increase timeout, reduce epochs/dataset, use smaller model/LoRA
+- Model not saved to Hub → Check `push_to_hub=True`, `hub_model_id`, `secrets=HF_TOKEN`
+- Out of Memory (OOM) → Reduce batch size, increase gradient accumulation, enable LoRA, use larger GPU
+- Dataset format error → Validate with dataset inspector (see Dataset Validation section)
+- Authentication errors → Check `hf_whoami()`, token permissions, `secrets` parameter
+
+**See:** `references/troubleshooting.md` for complete troubleshooting guide
+
+## Resources
+
+### References (In This Skill)
+- `references/training_methods.md` – Overview of SFT, DPO, GRPO, KTO, PPO, Reward Modeling
+- `references/training_patterns.md` – Common training patterns and examples
+- `references/unsloth.md` – Unsloth for fast VLM training (~2x speed, 60% less VRAM)
+- `references/gguf_conversion.md` – Complete GGUF conversion guide
+- `references/trackio_guide.md` – Trackio monitoring setup
+- `references/hardware_guide.md` – Hardware specs and selection
+- `references/hub_saving.md` – Hub authentication troubleshooting
+- `references/troubleshooting.md` – Common issues and solutions
+- `references/local_training_macos.md` – Local training on macOS
+
+### Scripts (In This Skill)
+- `scripts/train_sft_example.py` – Production SFT template
+- `scripts/train_dpo_example.py` – Production DPO template
+- `scripts/train_grpo_example.py` – Production GRPO template
+- `scripts/unsloth_sft_example.py` – Unsloth text LLM training template (faster, less VRAM)
+- `scripts/estimate_cost.py` – Estimate time and cost (offer when appropriate)
+- `scripts/convert_to_gguf.py` – Complete GGUF conversion script
+
+### External Scripts
+- [Dataset Inspector](https://huggingface.co/datasets/mcp-tools/skills/raw/main/dataset_inspector.py) – Validate dataset format before training (use via `uv run` or `hf_jobs`)
+
+### External Links
+- [TRL Documentation](https://huggingface.co/docs/trl)
+- [TRL Jobs Training Guide](https://huggingface.co/docs/trl/en/jobs_training)
+- [TRL Jobs Package](https://github.com/huggingface/trl-jobs)
+- [HF Jobs Documentation](https://huggingface.co/docs/huggingface_hub/guides/jobs)
+- [TRL Example Scripts](https://github.com/huggingface/trl/tree/main/examples/scripts)
+- [UV Scripts Guide](https://docs.astral.sh/uv/guides/scripts/)
+- [UV Scripts Organization](https://huggingface.co/uv-scripts)
+
+## Key Takeaways
+1. **Submit scripts inline** – The `script` parameter accepts Python code directly; no file saving required unless user requests.
+2. **Jobs are asynchronous** – Don't wait/poll; let user check when ready.
+3. **Always set timeout** – Default 30 min is insufficient; minimum 1‑2 hours recommended.
+4. **Always enable Hub push** – Environment is ephemeral; without push, all results lost.
+5. **Include Trackio** – Use example scripts as templates for real‑time monitoring.
+6. **Offer cost estimation** – When parameters are known, use `scripts/estimate_cost.py`.
+7. **Validate dataset format** before training with dataset inspector (see Dataset Validation section).
+8. **Choose appropriate hardware** for model size; use LoRA for models >7B to reduce memory.
+9. **Use hf_doc_fetch/hf_doc_search** for latest TRL documentation.
+10. **Use UV scripts (Approach 1)** – Default to `hf_jobs("uv", {...})` with inline scripts; TRL maintained scripts for standard training; avoid bash `trl-jobs` commands in Claude Code.
+
+Please address this message and continue with your tasks.

test/ml_learning_test.exs

@@ -0,0 +1,8 @@
+defmodule MLLearningTest do
+  use ExUnit.Case
+  doctest MLLearning
+
+  test "greets the world" do
+    assert MLLearning.hello() == :world
+  end
+end

test/test_helper.exs

@@ -0,0 +1 @@
+ExUnit.start()