f

demo/app.py

@@ -0,0 +1,204 @@
+"""
+app.py
+------
+Gradio chatbot demo for the trained CXR-VLM.
+
+Flow
+----
+  1. Upload a chest X-ray image.
+  2. The model auto-generates a report — Findings + Impression (cascade,
+     matching report_mode=split_cascade) — as the assistant's first message.
+  3. Ask any follow-up question about the same image; it's answered VQA-style,
+     the way the model was trained.
+
+The image stays "loaded" for the whole conversation; uploading a new image
+resets the chat and produces a fresh report.
+
+Usage (Colab / cloud GPU — auto-download the checkpoint from the HF runs repo)
+-----------------------------------------------------------------------------
+  python -m demo.app \
+      --hf_repo  hieu3636/cxr-vlm-runs \
+      --run_id   MIMIC-CXR_resized_run_3 \
+      --share                       # public Gradio link (needed on Colab)
+
+Usage (local — checkpoint already on disk)
+------------------------------------------
+  python -m demo.app \
+      --checkpoint checkpoints/IU-Xray_run_1/stage2_instruct   # dir OR .pt
+
+Notes
+-----
+  * On Colab pass --share so you get a public URL (the in-VM port isn't
+    reachable otherwise).
+  * --hf_token is optional if the runs repo is public or $HF_TOKEN is set.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from demo.cxr_demo import CXRChatbot, download_checkpoint_from_hf
+
+
+WELCOME = (
+    "Upload a chest X-ray to begin. CXR-HIEU writes a radiology report for it, "
+    "then you can ask any follow-up question about the same image."
+)
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="CXR-VLM chatbot demo (Gradio)")
+    # Checkpoint source — either a local path OR an HF runs-repo coordinate.
+    p.add_argument("--checkpoint", type=str, default=None,
+                   help="Local checkpoint dir (contains checkpoint_projection.pt "
+                        "+ checkpoint_lora/) or a stage2_final.pt path. "
+                        "If omitted, --hf_repo + --run_id are used to download.")
+    p.add_argument("--hf_repo", type=str, default="hieu3636/cxr-vlm-runs",
+                   help="HF runs repo to pull the checkpoint from.")
+    p.add_argument("--run_id", type=str, default="MIMIC-CXR_resized_run_3",
+                   help="Run id on the HF runs repo, e.g. MIMIC-CXR_resized_run_3.")
+    p.add_argument("--stage", type=str, default="stage2",
+                   choices=["stage2", "stage1"],
+                   help="Which stage's checkpoint to load (default stage2).")
+    p.add_argument("--which", type=str, default="best",
+                   choices=["best", "last"],
+                   help="best (lowest eval_loss) or last (default best).")
+    p.add_argument("--hf_token", type=str, default=None,
+                   help="HF token (defaults to $HF_TOKEN). Needed for private repos.")
+    p.add_argument("--model_config", type=str, default="configs/model_config.yaml")
+    p.add_argument("--device", type=str, default="auto",
+                   choices=["auto", "cuda", "cpu"])
+    p.add_argument("--max_new_tokens", type=int, default=300)
+    p.add_argument("--share", action="store_true",
+                   help="Create a public Gradio link (use this on Colab).")
+    p.add_argument("--server_name", type=str, default="0.0.0.0")
+    p.add_argument("--server_port", type=int, default=7860)
+    return p.parse_args()
+
+
+def resolve_checkpoint(args) -> str:
+    if args.checkpoint:
+        return args.checkpoint
+    if not args.run_id:
+        raise SystemExit(
+            "Provide --checkpoint <path>, OR --run_id <id> (with --hf_repo) "
+            "to auto-download from the HF runs repo."
+        )
+    print(f"[app] downloading {args.run_id}/{args.stage}/{args.which} "
+          f"from {args.hf_repo} …")
+    return download_checkpoint_from_hf(
+        repo_id = args.hf_repo,
+        run_id  = args.run_id,
+        stage   = args.stage,
+        which   = args.which,
+        token   = args.hf_token,
+    )
+
+
+def build_ui(bot: CXRChatbot, max_new_tokens: int):
+    import gradio as gr
+
+    with gr.Blocks(title="CXR-HIEU Demo", theme=gr.themes.Soft()) as demo:
+        gr.Markdown(
+            "# 🩻 CXR-HIEU — Chest X-ray Report & Q&A\n"
+            "Upload a chest X-ray. CXR-HIEU generates a radiology report and "
+            "answers questions about the image."
+        )
+
+        # Holds the active conversation's session dict {img, pnu}. The image
+        # (and its predicted PNU) persist across follow-up questions; a new
+        # upload replaces it → the bot answers about the new image.
+        sess_state = gr.State(value=None)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                image_in = gr.Image(type="pil", label="Chest X-ray image",
+                                    height=380)
+                analyze_btn = gr.Button("🔍 Analyze image", variant="primary")
+                gr.Markdown(
+                    "_Upload an image and click **Analyze image** (it also "
+                    "analyzes automatically on upload). Then ask questions on "
+                    "the right._"
+                )
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(label="Conversation", height=460,
+                                     type="messages")
+                with gr.Row():
+                    msg = gr.Textbox(
+                        placeholder="Ask about this image, e.g. Is there pleural effusion?",
+                        scale=5, show_label=False, container=False,
+                    )
+                    send_btn = gr.Button("Send", scale=1, variant="primary")
+                clear_btn = gr.Button("🗑️ Clear conversation")
+
+        # ── handlers ───────────────────────────────────────────────────────
+
+        def on_analyze(image):
+            """New image → new session, reset chat, generate the report."""
+            if image is None:
+                return None, [{
+                    "role": "assistant",
+                    "content": "⚠️ Please upload a chest X-ray first.",
+                }]
+            session = bot.prepare(image)
+            report = bot.generate_report(session, max_new_tokens=max_new_tokens)
+            history = [{"role": "assistant", "content": report}]
+            return session, history
+
+        def on_send(message, history, session):
+            history = history or []
+            if not message or not message.strip():
+                return "", history
+            if session is None:
+                history.append({"role": "user", "content": message})
+                history.append({
+                    "role": "assistant",
+                    "content": "⚠️ Please upload an image and click "
+                               "**Analyze image** before asking questions.",
+                })
+                return "", history
+            answer = bot.answer_question(session, message.strip(),
+                                         max_new_tokens=max_new_tokens)
+            history.append({"role": "user", "content": message})
+            history.append({"role": "assistant", "content": answer})
+            return "", history
+
+        def on_clear():
+            return None, None, ""
+
+        # Auto-analyze on upload AND via the button.
+        image_in.upload(on_analyze, inputs=image_in,
+                        outputs=[sess_state, chatbot])
+        analyze_btn.click(on_analyze, inputs=image_in,
+                          outputs=[sess_state, chatbot])
+        send_btn.click(on_send, inputs=[msg, chatbot, sess_state],
+                       outputs=[msg, chatbot])
+        msg.submit(on_send, inputs=[msg, chatbot, sess_state],
+                   outputs=[msg, chatbot])
+        clear_btn.click(on_clear, outputs=[sess_state, chatbot, msg])
+
+        gr.Markdown(f"\n\n_{WELCOME}_")
+
+    return demo
+
+
+def main():
+    args = parse_args()
+    ckpt = resolve_checkpoint(args)
+    bot = CXRChatbot(
+        checkpoint_dir = ckpt,
+        model_config   = args.model_config,
+        device         = args.device,
+    )
+    demo = build_ui(bot, args.max_new_tokens)
+    demo.queue().launch(
+        share       = args.share,
+        server_name = args.server_name,
+        server_port = args.server_port,
+    )
+
+
+if __name__ == "__main__":
+    main()

demo/cxr_demo.py

@@ -0,0 +1,261 @@
+"""
+cxr_demo.py
+-----------
+Reusable inference core for the CXR-VLM chatbot demo.
+
+Wraps the trained model into the operations the UI needs:
+
+  1. download_checkpoint_from_hf(...)  — pull {run_id}/stage2/best/ from the HF
+     runs repo into a local dir that `load_checkpoint` understands.
+  2. CXRChatbot(...)                   — loads the model once, then:
+       .prepare(PIL.Image)             → session dict {img, pnu} kept in UI state
+       .generate_report(session)       → cascade findings → impression
+       .answer_question(session, q)    → VQA-style free-form answer
+
+PNU (CheXpert classifier) support
+---------------------------------
+Runs trained on MIMIC-CXR with the Stage-0 classifier ship a
+`checkpoint_chexpert_classifier.pt` inside `stage2/best/`. When that file is
+present we ENABLE the classifier and, per image, predict the PNU 3-section
+string ("Positive/Negative/Uncertain Abnormalities: ...") and prepend it to the
+findings + VQA prompts — exactly the abnormality-guidance the model saw in
+training. IU-Xray runs have no such file → PNU is disabled automatically.
+
+Cascade (report_mode=split_cascade) mirrors training:
+  • findings  — prompt context = PNU (or none if no classifier)
+  • impression — prompt context = "Findings: <generated findings>"  (NOT PNU)
+  • vqa       — prompt context = PNU (or none)
+
+So at inference we generate findings first, then feed them back as the
+impression's context. No ground truth needed.
+
+The model is single-turn: each answer is conditioned on (image + current
+prompt) only — it does NOT carry prior chat turns as text. The UI keeps the
+image (and its PNU) in session state so follow-up questions stay about the same
+image, and a new upload starts a fresh session.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# Make the repo root importable when this file is run directly.
+_REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+# Silence per-shard HF download tqdm spam before transformers is imported.
+import utils._quiet  # noqa: F401,E402
+
+CLASSIFIER_FILE = "checkpoint_chexpert_classifier.pt"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Checkpoint download
+# ──────────────────────────────────────────────────────────────────────────
+
+def download_checkpoint_from_hf(
+    repo_id: str,
+    run_id: str,
+    stage: str = "stage2",
+    which: str = "best",
+    token: Optional[str] = None,
+    local_root: str = "checkpoints/_demo_ckpt",
+) -> str:
+    """
+    Download `{run_id}/{stage}/{which}/` from the HF *runs* repo and return the
+    local directory holding `checkpoint_projection.pt`, `checkpoint_lora/`, and
+    (for MIMIC runs) `checkpoint_chexpert_classifier.pt`.
+
+    The returned path is passed straight to `utils.checkpoint.load_checkpoint`,
+    which (given a directory) loads files prefixed with `checkpoint_` — the
+    exact names the training callbacks upload to `{stage}/best/`.
+
+    Args:
+        repo_id:    e.g. "hieu3636/cxr-vlm-runs"
+        run_id:     e.g. "MIMIC-CXR_resized_run_3"
+        stage:      "stage2" (instruction-tuned, default) or "stage1"
+        which:      "best" (lowest eval_loss, default) or "last"
+        token:      HF token; falls back to $HF_TOKEN.
+        local_root: where to mirror the repo subtree locally.
+
+    Returns:
+        Absolute path to the local `{which}/` directory.
+    """
+    from huggingface_hub import snapshot_download
+
+    token = token or os.environ.get("HF_TOKEN")
+    subpath = f"{run_id}/{stage}/{which}"
+    staging = Path(local_root)
+    staging.mkdir(parents=True, exist_ok=True)
+
+    snapshot_download(
+        repo_id        = repo_id,
+        repo_type      = "model",
+        token          = token,
+        allow_patterns = [f"{subpath}/**"],
+        local_dir      = str(staging),
+    )
+
+    ckpt_dir = staging / run_id / stage / which
+    if not ckpt_dir.is_dir():
+        raise FileNotFoundError(
+            f"Expected {subpath}/ in {repo_id} but nothing was downloaded to "
+            f"{ckpt_dir}. Check repo_id / run_id / stage / which."
+        )
+    proj = ckpt_dir / "checkpoint_projection.pt"
+    if not proj.is_file():
+        found = "\n  ".join(p.name for p in ckpt_dir.iterdir())
+        raise FileNotFoundError(
+            f"{proj} not found. Files present in {ckpt_dir}:\n  {found}\n"
+            f"(The loader needs checkpoint_projection.pt + checkpoint_lora/.)"
+        )
+    return str(ckpt_dir)
+
+
+# ──────────────────────────────���───────────────────────────────────────────
+# Chatbot core
+# ──────────────────────────────────────────────────────────────────────────
+
+class CXRChatbot:
+    """Loads the trained CXR-VLM once and serves report + VQA generation."""
+
+    def __init__(
+        self,
+        checkpoint_dir: str,
+        model_config: str = "configs/model_config.yaml",
+        device: str = "auto",
+        cpu_dtype: str = "float32",
+        use_pnu: str = "auto",   # "auto" | True | False
+    ):
+        import torch
+        from omegaconf import OmegaConf
+        from model import CXRVisionLanguageModel
+        from model.rad_dino import BioViLTEncoder
+        from utils.checkpoint import load_checkpoint
+
+        self.torch = torch
+        self.device = self._resolve_device(device)
+
+        # Enable the CheXpert (PNU) classifier iff the checkpoint ships one,
+        # unless the caller forces it on/off.
+        clf_file = Path(checkpoint_dir) / CLASSIFIER_FILE
+        if use_pnu == "auto":
+            self.use_pnu = clf_file.is_file()
+        else:
+            self.use_pnu = bool(use_pnu)
+            if self.use_pnu and not clf_file.is_file():
+                print(f"[CXRChatbot] WARNING: use_pnu forced on but {clf_file} "
+                      "is missing — PNU prediction will use random weights.")
+
+        model_cfg = OmegaConf.load(model_config)
+        self._patch_cfg_for_device(model_cfg, self.device, cpu_dtype)
+        model_cfg.chexpert_classifier.enabled = self.use_pnu
+
+        print(f"[CXRChatbot] building model on device={self.device} "
+              f"(PNU/CheXpert guidance: {'ON' if self.use_pnu else 'OFF'}) …")
+        self.model = CXRVisionLanguageModel(model_cfg)
+        load_checkpoint(self.model, checkpoint_dir)
+
+        # device_map already placed the (quantized) LLM; move the rest.
+        self.model = self.model.to(self.device)
+        self.model.eval()
+
+        self.transform = BioViLTEncoder.get_transform("val")
+        print("[CXRChatbot] ready.")
+
+    # ── device helpers (mirror evaluation/inference.py) ────────────────────
+
+    def _resolve_device(self, choice: str) -> str:
+        import torch
+        if choice == "auto":
+            return "cuda" if torch.cuda.is_available() else "cpu"
+        if choice == "cuda" and not torch.cuda.is_available():
+            raise SystemExit("device=cuda requested but no CUDA GPU is visible.")
+        return choice
+
+    def _patch_cfg_for_device(self, model_cfg, device: str, cpu_dtype: str):
+        if device == "cpu":
+            model_cfg.llm.load_in_4bit = False
+            model_cfg.llm.load_in_8bit = False
+            model_cfg.llm.torch_dtype = cpu_dtype
+            model_cfg.llm.device_map = None
+            print("[CXRChatbot] CPU mode: 4-bit/8-bit disabled "
+                  f"(dtype={cpu_dtype}, expect very slow generation).")
+
+    # ── session setup ───────────────────────────────────────────────────────
+
+    def prepare(self, image) -> Dict[str, Any]:
+        """
+        PIL.Image → session dict for the conversation:
+            {"img": (1,C,H,W) tensor on device, "pnu": str|None}
+        PNU is predicted once here and reused for every follow-up question, so
+        the (expensive) encoder pass that drives it runs a single time per image.
+        """
+        img = image.convert("RGB")
+        img_t = self.transform(img).unsqueeze(0).to(self.device)
+        pnu = None
+        if self.use_pnu:
+            try:
+                pnu = self.model.predict_structured_findings(img_t)[0]
+            except Exception as e:
+                print(f"[CXRChatbot] PNU prediction failed ({type(e).__name__}: "
+                      f"{e}); continuing without abnormality guidance.")
+        return {"img": img_t, "pnu": pnu}
+
+    # ── generation ─────────────────────────────────────────────────────────
+
+    def _generate(self, img_t, prompt: str, max_new_tokens: int) -> str:
+        out = self.model.generate(
+            images               = img_t,
+            prompts              = [prompt],
+            max_new_tokens       = max_new_tokens,
+            temperature          = 1e-5,   # greedy; HF complains if exactly 0
+            do_sample            = False,
+            num_beams            = 1,
+            repetition_penalty   = 1.2,    # break the greedy template loop
+            no_repeat_ngram_size = 3,
+        )[0]
+        return out.strip()
+
+    def generate_findings(self, session, max_new_tokens: int = 300) -> str:
+        from data.prompt_templates import build_findings_prompt
+        prompt = build_findings_prompt(
+            structured_findings=session.get("pnu"), randomize=False)
+        return self._generate(session["img"], prompt, max_new_tokens)
+
+    def generate_impression(self, session, findings: str,
+                            max_new_tokens: int = 200) -> str:
+        """Impression conditioned on the (just-generated) findings text."""
+        from data.prompt_templates import build_impression_prompt
+        ctx = f"Findings: {findings.strip()}" if findings.strip() else None
+        prompt = build_impression_prompt(structured_findings=ctx, randomize=False)
+        return self._generate(session["img"], prompt, max_new_tokens)
+
+    def generate_report(self, session, max_new_tokens: int = 300) -> str:
+        """
+        Cascade: findings → impression, returned as ONE flowing paragraph —
+        the findings sentences first, the impression sentences appended at the
+        end, with no "Findings:" / "Impression:" labels. Matches the
+        split_cascade training recipe (impression sees findings; findings/VQA
+        see the PNU abnormality guidance when available).
+        """
+        findings = self.generate_findings(session, max_new_tokens).strip()
+        impression = self.generate_impression(session, findings).strip()
+
+        report = findings
+        if impression:
+            if report and not report.endswith((".", "!", "?")):
+                report += "."
+            report = (report + " " + impression).strip()
+        return report if report else "(no output)"
+
+    def answer_question(self, session, question: str,
+                        max_new_tokens: int = 200) -> str:
+        """Free-form / VQA answer about the image (as the model was trained)."""
+        from data.prompt_templates import build_vqa_prompt
+        prompt = build_vqa_prompt(question, structured_findings=session.get("pnu"))
+        return self._generate(session["img"], prompt, max_new_tokens)

model/a.py

@@ -0,0 +1,4 @@
+from rad_dino import RadDino
+from rad_dino.utils import download_sample_image
+model = RadDino.from_pretrained("rad-dino/rad-dino-base")
+print(model)

scripts/cxrvlm_demo.ipynb

@@ -0,0 +1,154 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bc39a82e",
+   "metadata": {},
+   "source": [
+    "# CXR-HIEU — Demo Chatbot (Colab)\n",
+    "\n",
+    "Upload a chest X-ray and CXR-HIEU writes a radiology report, then answers follow-up questions (VQA) about the image.\n",
+    "\n",
+    "**Before running:** `Runtime → Change runtime type → GPU` (T4/L4/A100 all work).\n",
+    "\n",
+    "Just set `RUN_ID` (and `HF_TOKEN` if the runs repo is private) in the config cell, then `Runtime → Run all`. Finally click the `*.gradio.live` link."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98eae020",
+   "metadata": {},
+   "source": [
+    "## 1. Configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21bc5b03",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "# ── REQUIRED: id of the trained run on the HF runs repo ──\n",
+    "RUN_ID    = \"MIMIC-CXR_resized_run_3\"  # run that ships the full PNU CheXpert classifier\n",
+    "HF_RUNS   = \"hieu3636/cxr-vlm-runs\"   # repo holding the run checkpoints\n",
+    "HF_CODE   = \"hieu3636/cxr-vlm-code\"   # repo holding the source code\n",
+    "STAGE     = \"stage2\"                  # stage2 = instruction-tuned (default)\n",
+    "WHICH     = \"best\"                    # best (lowest eval_loss) | last\n",
+    "\n",
+    "# ── HF token: needed if the runs repo is private. Prefer Colab Secrets. ──\n",
+    "try:\n",
+    "    from google.colab import userdata\n",
+    "    os.environ[\"HF_TOKEN\"] = userdata.get(\"HF_TOKEN\")\n",
+    "except Exception:\n",
+    "    os.environ.setdefault(\"HF_TOKEN\", \"\")  # hoặc dán token trực tiếp vào đây\n",
+    "\n",
+    "print(\"RUN_ID =\", RUN_ID)\n",
+    "print(\"HF_TOKEN set:\", bool(os.environ.get(\"HF_TOKEN\")))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b30211d",
+   "metadata": {},
+   "source": [
+    "## 2. Pull source code from HF\n",
+    "Download the code repo snapshot to `/content/cxr-vlm-code` and `cd` into it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a94bc32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import snapshot_download\n",
+    "import os\n",
+    "\n",
+    "CODE_DIR = snapshot_download(\n",
+    "    repo_id=HF_CODE, repo_type='model',\n",
+    "    token=os.environ.get('HF_TOKEN') or None,\n",
+    "    local_dir='/content/cxr-vlm-code',\n",
+    ")\n",
+    "os.chdir(CODE_DIR)\n",
+    "print('code dir:', CODE_DIR)\n",
+    "!ls"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6807e7d1",
+   "metadata": {},
+   "source": [
+    "## 3. Install dependencies\n",
+    "Install the pinned versions from `requirements.txt` (including `gradio`). PEFT/hub are pinned to match `transformers==4.49`. May take a few minutes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ff256b17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q gradio==5.9.1\n",
+    "!pip install -q transformers==4.49.0 peft==0.14.0 accelerate==1.13.0 \\\n",
+    "    bitsandbytes==0.49.2 'huggingface_hub>=0.27,<1.0' httpx==0.28.1 \\\n",
+    "    omegaconf==2.3.0 sentencepiece==0.2.1 timm==1.0.26\n",
+    "print('done')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3baf9e4d",
+   "metadata": {},
+   "source": [
+    "## 4. Load model & launch the demo\n",
+    "The first run downloads RAD-DINO + Vicuna-7B (4-bit) + your checkpoint — a few minutes. When ready, open the **`https://....gradio.live`** link printed below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6f60d45",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import utils._httpx_compat  # noqa: F401  (httpx 0.28 compat, safe)\n",
+    "from demo.cxr_demo import CXRChatbot, download_checkpoint_from_hf\n",
+    "from demo.app import build_ui\n",
+    "\n",
+    "ckpt_dir = download_checkpoint_from_hf(\n",
+    "    repo_id=HF_RUNS, run_id=RUN_ID, stage=STAGE, which=WHICH,\n",
+    "    token=os.environ.get('HF_TOKEN') or None,\n",
+    ")\n",
+    "print('checkpoint:', ckpt_dir)\n",
+    "\n",
+    "bot = CXRChatbot(checkpoint_dir=ckpt_dir,\n",
+    "                 model_config='configs/model_config.yaml',\n",
+    "                 device='auto')\n",
+    "\n",
+    "demo = build_ui(bot, max_new_tokens=300)\n",
+    "demo.queue().launch(share=True)   # share=True → link công khai *.gradio.live"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}