Add visual step-by-step DynaFall notebook

notebooks/dynafall_step_by_step.ipynb

@@ -0,0 +1,526 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5b77cca7",
+   "metadata": {},
+   "source": [
+    "# DynaFall - notebook trực quan bằng data thật URFD/MCFD\n",
+    "\n",
+    "Notebook này được tổ chức như một bài học thực hành. Mỗi bước đều có phần quan sát trực quan: xem data gốc, xem khung xương trên ảnh/video, xem chuyển động skeleton, xem feature dynamics, rồi mới train/evaluate model.\n",
+    "\n",
+    "**Không dùng data tự tạo.** Tất cả mẫu trong notebook lấy từ `data/raw/URFD`, `data/raw/MCFD`, `data/poses/*_keypoints.pkl`, và `data/processed/*` đã tải từ Hugging Face."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e45c5067",
+   "metadata": {},
+   "source": [
+    "## 1. Cài thư viện và chuẩn bị môi trường"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd135b78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import os, sys, json, subprocess, pickle\n",
+    "\n",
+    "def find_repo_root():\n",
+    "    candidates = [Path.cwd(), *Path.cwd().parents, Path('/root/fall')]\n",
+    "    for candidate in candidates:\n",
+    "        if (candidate / 'requirements.txt').exists() and (candidate / 'src' / 'dynafall').exists():\n",
+    "            return candidate.resolve()\n",
+    "    raise RuntimeError('Không tìm thấy repo root chứa requirements.txt và src/dynafall')\n",
+    "\n",
+    "ROOT = find_repo_root()\n",
+    "print('Repo root =', ROOT)\n",
+    "subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', str(ROOT / 'requirements.txt'), 'matplotlib', 'gradio', 'opencv-python-headless', 'ipywidgets'])\n",
+    "\n",
+    "os.chdir(ROOT)\n",
+    "sys.path.insert(0, str(ROOT / 'src'))\n",
+    "sys.path.insert(0, str(ROOT / 'scripts'))\n",
+    "\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from IPython.display import Video, display\n",
+    "\n",
+    "from common import load_config\n",
+    "from dynafall.data import load_pickle, FallClipDataset, save_pickle\n",
+    "from dynafall.features import COCO_BONES, body_aspect_ratio, bone_features, dynamics_features, normalize_pose, resample_or_pad\n",
+    "\n",
+    "cfg = load_config('configs/default.yaml')\n",
+    "print('ROOT =', ROOT)\n",
+    "print('clip_len =', cfg['clip_len'], '| stride =', cfg['stride'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "efae7ac8",
+   "metadata": {},
+   "source": [
+    "## 2. Kiểm tra data thật đã có\n",
+    "\n",
+    "Ta kiểm tra 3 tầng dữ liệu:\n",
+    "\n",
+    "1. `data/raw`: ảnh/video gốc.\n",
+    "2. `data/poses`: keypoints COCO-17 đã trích bằng YOLO pose.\n",
+    "3. `data/processed`: clip 32 frame đã normalize để đưa vào model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89422656",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "summary = []\n",
+    "for dataset in ['URFD', 'MCFD']:\n",
+    "    recs = load_pickle(f'data/poses/{dataset}_keypoints.pkl')\n",
+    "    row = {\n",
+    "        'dataset': dataset,\n",
+    "        'video_records': len(recs),\n",
+    "        'fall_records': sum(int(r['label']) == 1 for r in recs),\n",
+    "        'nonfall_records': sum(int(r['label']) == 0 for r in recs),\n",
+    "    }\n",
+    "    for split in ['train', 'val', 'test']:\n",
+    "        rows = load_pickle(f'data/processed/{dataset}/{split}.pkl')\n",
+    "        row[f'{split}_clips'] = len(rows)\n",
+    "    summary.append(row)\n",
+    "\n",
+    "pd.DataFrame(summary)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aaa58a76",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for dataset in ['URFD', 'MCFD']:\n",
+    "    recs = load_pickle(f'data/poses/{dataset}_keypoints.pkl')\n",
+    "    print('\\n', dataset)\n",
+    "    for rec in recs[:3]:\n",
+    "        print(' ', rec['video_id'], '| label=', 'fall' if rec['label'] else 'nonfall', '| keypoints=', rec['keypoints'].shape, '| source=', rec['path'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "286f0e9a",
+   "metadata": {},
+   "source": [
+    "## 3. Xem một số video/sequence gốc trong data\n",
+    "\n",
+    "Cell dưới tạo 4 video preview ngắn từ raw data thật:\n",
+    "\n",
+    "- 2 mẫu URFD fall\n",
+    "- 1 mẫu MCFD fall\n",
+    "- 1 mẫu URFD ADL non-fall rõ ràng\n",
+    "\n",
+    "Mỗi video có file `.npz` đi kèm chứa keypoints thật tương ứng."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c8d7d24e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run(cmd):\n",
+    "    print('$', ' '.join(cmd))\n",
+    "    subprocess.run(cmd, check=True)\n",
+    "\n",
+    "run([sys.executable, 'scripts/create_real_demo_assets.py'])\n",
+    "preview_videos = sorted(Path('demo_assets_real').glob('*.mp4'))\n",
+    "for p in preview_videos:\n",
+    "    meta = np.load(p.with_suffix('.npz'))\n",
+    "    print(p.name, '| dataset=', str(meta['dataset']), '| label=', 'fall' if int(meta['label']) else 'nonfall')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15347920",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for p in preview_videos:\n",
+    "    print('\\nRAW PREVIEW:', p.name)\n",
+    "    display(Video(str(p), embed=True, width=460))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d0622d0",
+   "metadata": {},
+   "source": [
+    "## 4. Từ ảnh/video gốc sang khung xương\n",
+    "\n",
+    "Ở bước này ta đặt keypoints lên frame gốc để thấy rõ YOLO pose đã lấy những điểm nào trên người. Đây là cầu nối quan trọng giữa dữ liệu ảnh/video và dữ liệu skeleton mà model sử dụng."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09975748",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "IMAGE_EXTS = {'.png', '.jpg', '.jpeg', '.bmp'}\n",
+    "\n",
+    "def load_raw_frame(source, frame_idx=0):\n",
+    "    source = Path(source)\n",
+    "    if source.is_dir():\n",
+    "        images = sorted([p for p in source.iterdir() if p.suffix.lower() in IMAGE_EXTS])\n",
+    "        frame_idx = min(frame_idx, len(images) - 1)\n",
+    "        img = cv2.imread(str(images[frame_idx]))\n",
+    "        return cv2.cvtColor(img, cv2.COLOR_BGR2RGB), frame_idx\n",
+    "    cap = cv2.VideoCapture(str(source))\n",
+    "    cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)\n",
+    "    ok, frame = cap.read()\n",
+    "    cap.release()\n",
+    "    if not ok:\n",
+    "        raise RuntimeError(f'Cannot read frame {frame_idx} from {source}')\n",
+    "    return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), frame_idx\n",
+    "\n",
+    "def draw_pose_on_image(image, keypoints):\n",
+    "    out = image.copy()\n",
+    "    pts = keypoints[:, :2].astype(int)\n",
+    "    conf = keypoints[:, 2]\n",
+    "    for a, b in COCO_BONES:\n",
+    "        if conf[a] > 0 and conf[b] > 0:\n",
+    "            cv2.line(out, tuple(pts[a]), tuple(pts[b]), (255, 120, 20), 3, cv2.LINE_AA)\n",
+    "    for j, p in enumerate(pts):\n",
+    "        if conf[j] > 0:\n",
+    "            cv2.circle(out, tuple(p), 5, (20, 20, 255), -1, cv2.LINE_AA)\n",
+    "    return out\n",
+    "\n",
+    "def select_records_for_display():\n",
+    "    wanted = [\n",
+    "        ('URFD', 'fall/fall-01-cam0-rgb/fall-01-cam0-rgb'),\n",
+    "        ('URFD', 'nonfall/adl-01-cam0-rgb/adl-01-cam0-rgb'),\n",
+    "        ('MCFD', 'fall/chute01/chute01/cam1'),\n",
+    "    ]\n",
+    "    out = []\n",
+    "    for dataset, video_id in wanted:\n",
+    "        recs = load_pickle(f'data/poses/{dataset}_keypoints.pkl')\n",
+    "        out.append(next(r for r in recs if r['video_id'] == video_id))\n",
+    "    return out\n",
+    "\n",
+    "records_to_show = select_records_for_display()\n",
+    "fig, axes = plt.subplots(len(records_to_show), 2, figsize=(12, 12))\n",
+    "for row, rec in enumerate(records_to_show):\n",
+    "    kpts = rec['keypoints']\n",
+    "    frame_idx = min(len(kpts) // 2, len(kpts) - 1)\n",
+    "    img, actual_idx = load_raw_frame(rec['path'], frame_idx)\n",
+    "    overlay = draw_pose_on_image(img, kpts[actual_idx])\n",
+    "    label = 'fall' if rec['label'] else 'nonfall'\n",
+    "    axes[row, 0].imshow(img)\n",
+    "    axes[row, 0].set_title(f\"{rec['video_id']} | raw | {label}\")\n",
+    "    axes[row, 1].imshow(overlay)\n",
+    "    axes[row, 1].set_title('raw + skeleton keypoints')\n",
+    "    for ax in axes[row]:\n",
+    "        ax.axis('off')\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16f9eb71",
+   "metadata": {},
+   "source": [
+    "## 5. Chuyển động khung xương theo thời gian\n",
+    "\n",
+    "Sau khi trích keypoints, mỗi video trở thành chuỗi `(T, 17, 3)`:\n",
+    "\n",
+    "- `T`: số frame\n",
+    "- `17`: số keypoints COCO\n",
+    "- `3`: `(x, y, confidence)`\n",
+    "\n",
+    "Cell dưới render lại chuyển động skeleton để học sinh thấy model thực sự nhìn chuỗi khung xương chứ không nhìn trực tiếp ảnh RGB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c66fb78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def skeleton_points(frame, width=420, height=420):\n",
+    "    xy = frame[:, :2].copy()\n",
+    "    x = (xy[:, 0] + 1.8) / 3.6 * width\n",
+    "    y = (xy[:, 1] + 1.8) / 3.6 * height\n",
+    "    pts = np.stack([x, y], axis=1)\n",
+    "    return np.clip(pts, 0, [width - 1, height - 1]).astype(np.int32)\n",
+    "\n",
+    "def render_skeleton_preview(keypoints, out_path, fps=15, width=420, height=420):\n",
+    "    out_path = Path(out_path)\n",
+    "    writer = cv2.VideoWriter(str(out_path), cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))\n",
+    "    for idx, frame in enumerate(keypoints):\n",
+    "        canvas = np.full((height, width, 3), 248, dtype=np.uint8)\n",
+    "        pts = skeleton_points(frame, width, height)\n",
+    "        cv2.putText(canvas, f'frame {idx+1}/{len(keypoints)}', (14, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (60,60,60), 2, cv2.LINE_AA)\n",
+    "        for a, b in COCO_BONES:\n",
+    "            if frame[a, 2] > 0 and frame[b, 2] > 0:\n",
+    "                cv2.line(canvas, tuple(pts[a]), tuple(pts[b]), (36, 115, 220), 3, cv2.LINE_AA)\n",
+    "        for j, point in enumerate(pts):\n",
+    "            if frame[j, 2] > 0:\n",
+    "                cv2.circle(canvas, tuple(point), 5, (20,20,20), -1, cv2.LINE_AA)\n",
+    "        writer.write(canvas)\n",
+    "    writer.release()\n",
+    "    return out_path\n",
+    "\n",
+    "skeleton_dir = Path('demo_assets_real/skeleton_previews')\n",
+    "skeleton_dir.mkdir(exist_ok=True)\n",
+    "for video_path in preview_videos:\n",
+    "    data = np.load(video_path.with_suffix('.npz'))\n",
+    "    keypoints = data['keypoints'].astype(np.float32)\n",
+    "    out_path = skeleton_dir / f'{video_path.stem}_skeleton.mp4'\n",
+    "    render_skeleton_preview(keypoints, out_path)\n",
+    "    print('\\nSKELETON MOTION:', video_path.name)\n",
+    "    display(Video(str(out_path), embed=True, width=420))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30389b06",
+   "metadata": {},
+   "source": [
+    "## 6. Chuẩn hóa pose và cắt clip 32 frame\n",
+    "\n",
+    "Model không dùng tọa độ pixel gốc trực tiếp. Pipeline chuẩn hóa pose theo bounding box người trong từng frame, sau đó resample/pad thành clip 32 frame. Nhờ vậy model ít phụ thuộc vào kích thước ảnh, vị trí camera, hoặc người đứng xa/gần."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ce210d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "raw_rec = records_to_show[0]\n",
+    "raw_kpts = raw_rec['keypoints'].astype(np.float32)\n",
+    "norm_kpts = normalize_pose(raw_kpts)\n",
+    "clip = resample_or_pad(norm_kpts, cfg['clip_len'])\n",
+    "\n",
+    "print('Raw keypoints:', raw_kpts.shape, 'range x/y:', raw_kpts[..., :2].min(), raw_kpts[..., :2].max())\n",
+    "print('Normalized keypoints:', norm_kpts.shape, 'range x/y:', round(float(norm_kpts[..., :2].min()), 3), round(float(norm_kpts[..., :2].max()), 3))\n",
+    "print('Model clip:', clip.shape)\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
+    "axes[0].scatter(raw_kpts[0,:,0], raw_kpts[0,:,1], c=raw_kpts[0,:,2], cmap='viridis')\n",
+    "axes[0].invert_yaxis(); axes[0].set_title('Frame 0: pixel coordinates'); axes[0].grid(alpha=.25)\n",
+    "axes[1].scatter(norm_kpts[0,:,0], norm_kpts[0,:,1], c=norm_kpts[0,:,2], cmap='viridis')\n",
+    "axes[1].invert_yaxis(); axes[1].set_title('Frame 0: normalized coordinates'); axes[1].grid(alpha=.25)\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "358af3d7",
+   "metadata": {},
+   "source": [
+    "## 7. Joint, bone và dynamics features\n",
+    "\n",
+    "DynaFall không chỉ nhìn tọa độ khớp (`joint`). Pipeline còn tạo:\n",
+    "\n",
+    "- `bone`: vector giữa các khớp nối theo COCO skeleton\n",
+    "- `dynamics`: vận tốc, gia tốc, center motion, hip drop, torso angle, body aspect ratio\n",
+    "\n",
+    "Các tín hiệu động học này giúp phân biệt chuyển động ngã với hoạt động bình thường."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09eb9bb6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "joint = clip\n",
+    "bone = bone_features(joint)\n",
+    "dyn = dynamics_features(joint)\n",
+    "print('joint:', joint.shape, '| bone:', bone.shape, '| dyn:', dyn.shape)\n",
+    "\n",
+    "xy = joint[..., :2]\n",
+    "conf = joint[..., 2:3]\n",
+    "center_y = (xy[..., 1:2] * conf).sum(axis=1).squeeze(-1) / (conf.sum(axis=1).squeeze(-1) + 1e-6)\n",
+    "hip_y = xy[:, [11, 12], 1].mean(axis=1)\n",
+    "aspect = body_aspect_ratio(xy, conf).squeeze(1)\n",
+    "speed = np.linalg.norm(dyn[:, :, :2], axis=2).mean(axis=1)\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(12, 7))\n",
+    "axes[0,0].plot(center_y, label='body center y'); axes[0,0].plot(hip_y, label='hip y'); axes[0,0].legend(); axes[0,0].set_title('Vertical motion')\n",
+    "axes[0,1].plot(aspect, color='tab:purple'); axes[0,1].set_title('Body aspect ratio')\n",
+    "axes[1,0].plot(speed, color='tab:orange'); axes[1,0].set_title('Mean keypoint speed')\n",
+    "axes[1,1].imshow(joint[...,2].T, aspect='auto', cmap='viridis', vmin=0, vmax=1); axes[1,1].set_title('Keypoint confidence heatmap')\n",
+    "for ax in axes.ravel(): ax.grid(alpha=.25)\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d58ea54",
+   "metadata": {},
+   "source": [
+    "## 8. Xem batch đầu vào model\n",
+    "\n",
+    "DataLoader trả về dictionary có `joint`, `bone`, `dyn`, `label`. Đây là đúng format mà các model trong `src/dynafall/models.py` nhận vào."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "117769ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_ds = FallClipDataset('data/processed/URFD/train.pkl')\n",
+    "item = train_ds[0]\n",
+    "for key, value in item.items():\n",
+    "    if hasattr(value, 'shape'):\n",
+    "        print(key, tuple(value.shape))\n",
+    "    else:\n",
+    "        print(key, value)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53d0db4c",
+   "metadata": {},
+   "source": [
+    "## 9. Train nhanh trên URFD thật\n",
+    "\n",
+    "Để notebook chạy nhanh, cell này train 4 epoch. Khi làm thí nghiệm đầy đủ, tăng epoch hoặc chạy `scripts/run_experiments.py`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "851945ee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run([sys.executable, 'scripts/train.py', '--dataset', 'URFD', '--method', 'dynafall', '--epochs', '4'])\n",
+    "run([sys.executable, 'scripts/evaluate.py', '--dataset', 'URFD', '--method', 'dynafall'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66c5024e",
+   "metadata": {},
+   "source": [
+    "## 10. Trực quan hóa training history và metric"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "422fd8d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history = pd.read_json('results/URFD/dynafall/history.json')\n",
+    "metrics = json.loads(Path('results/URFD/dynafall/metrics_test_clean.json').read_text())\n",
+    "display(history)\n",
+    "display(pd.DataFrame([metrics]))\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n",
+    "axes[0].plot(history['epoch'], history['loss'], marker='o'); axes[0].set_title('Train loss'); axes[0].grid(alpha=.25)\n",
+    "for col in ['val_accuracy', 'val_f1', 'val_recall', 'val_precision']:\n",
+    "    if col in history:\n",
+    "        axes[1].plot(history['epoch'], history[col], marker='o', label=col)\n",
+    "axes[1].legend(); axes[1].set_ylim(0, 1.05); axes[1].set_title('Validation metrics'); axes[1].grid(alpha=.25)\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "metric_names = ['accuracy', 'precision', 'recall', 'specificity', 'f1', 'macro_f1']\n",
+    "plt.figure(figsize=(8, 4))\n",
+    "plt.bar(metric_names, [metrics[m] for m in metric_names])\n",
+    "plt.ylim(0, 1.05); plt.title('Test metrics'); plt.grid(axis='y', alpha=.25); plt.xticks(rotation=30); plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc0302e8",
+   "metadata": {},
+   "source": [
+    "## 11. Dùng checkpoint đã train sẵn để demo\n",
+    "\n",
+    "Repo có checkpoint benchmark đã train sẵn. App demo tự chọn checkpoint theo dataset của mẫu:\n",
+    "\n",
+    "- URFD sample -> `results/main/seed_7/URFD/dynafall/best.pt`\n",
+    "- MCFD sample -> `results/main/seed_7/MCFD/dynafall/best.pt`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3c6571e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from app_demo import predict, DEFAULT_CHECKPOINT\n",
+    "\n",
+    "rows = []\n",
+    "for p in preview_videos:\n",
+    "    summary, skeleton_video, fig, details_json = predict(str(p), str(DEFAULT_CHECKPOINT), 'dynafall')\n",
+    "    details = json.loads(details_json)\n",
+    "    rows.append(details)\n",
+    "pd.DataFrame(rows)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0035275e",
+   "metadata": {},
+   "source": [
+    "## 12. Mở giao diện demo Gradio\n",
+    "\n",
+    "Giao diện cho phép chọn video có sẵn hoặc upload video mới. Với video mới, app sẽ tự chạy YOLO pose để trích keypoints rồi dự đoán."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb6d110b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from app_demo import build_app\n",
+    "app = build_app()\n",
+    "app.launch(server_name='127.0.0.1', server_port=7860, inline=False)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}