{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":13428412,"sourceType":"datasetVersion","datasetId":8523009},{"sourceId":13428424,"sourceType":"datasetVersion","datasetId":8523018},{"sourceId":13429071,"sourceType":"datasetVersion","datasetId":8523411}],"dockerImageVersionId":31154,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import os\nimport pandas as pd\nfrom collections import Counter\nimport matplotlib.pyplot as plt\n\ndef extract_and_count_labels(dataset_path):\n    \"\"\"\n    Trích xuất và đếm các nhãn từ tên file video\n    \"\"\"\n    print(\"🔍 ĐANG PHÂN TÍCH NHÃN TỪ TÊN FILE...\")\n    print(\"=\" * 50)\n    \n    # Kiểm tra đường dẫn\n    if not os.path.exists(dataset_path):\n        print(f\"❌ Đường dẫn không tồn tại: {dataset_path}\")\n        return None, None\n    \n    # Tìm tất cả file video\n    video_files = []\n    for root, dirs, files in os.walk(dataset_path):\n        for file in files:\n            if file.lower().endswith('.mp4'):\n                video_files.append(file)\n    \n    print(f\"📹 Tìm thấy {len(video_files)} file video\")\n    \n    if not video_files:\n        print(\"❌ Không tìm thấy file video nào!\")\n        return None, None\n    \n    # Trích xuất nhãn từ tên file (phần trước số)\n    labels = []\n    file_label_map = {}\n    \n    for file in video_files:\n        # Loại bỏ phần mở rộng .mp4\n        name_without_ext = os.path.splitext(file)[0]\n        \n        # Tách nhãn - lấy phần chữ trước số\n        label = extract_label_from_filename(name_without_ext)\n        labels.append(label)\n        file_label_map[file] = label\n    \n    # Đếm số lượng từng nhãn\n    label_counter = Counter(labels)\n    \n    return label_counter, file_label_map\n\ndef extract_label_from_filename(filename):\n    \"\"\"\n    Trích xuất nhãn từ tên file theo pattern: TÊN_NHÃN + SỐ\n    \"\"\"\n    # Tìm vị trí số đầu tiên\n    for i, char in enumerate(filename):\n        if char.isdigit():\n            # Lấy phần trước số đầu tiên\n            label = filename[:i]\n            # Loại bỏ ký tự _ cuối cùng nếu có\n            if label.endswith('_'):\n                label = label[:-1]\n            return label if label else 'unknown'\n    \n    # Nếu không tìm thấy số, trả về toàn bộ tên file\n    return filename\n\ndef analyze_and_visualize_labels(label_counter):\n    \"\"\"\n    Phân tích và hiển thị kết quả đếm nhãn\n    \"\"\"\n    if not label_counter:\n        return\n    \n    print(\"\\n🏷️ KẾT QUẢ ĐẾM NHÃN:\")\n    print(\"=\" * 50)\n    \n    total_files = sum(label_counter.values())\n    total_labels = len(label_counter)\n    \n    print(f\"📊 Tổng số file: {total_files}\")\n    print(f\"🏷️ Tổng số nhãn khác nhau: {total_labels}\")\n    print(\"\\n📋 DANH SÁCH NHÃN:\")\n    print(\"-\" * 40)\n    \n    # Hiển thị tất cả nhãn theo thứ tự số lượng giảm dần\n    for label, count in label_counter.most_common():\n        percentage = (count / total_files) * 100\n        print(f\"  {label:20} : {count:4} files ({percentage:.1f}%)\")\n    \n    # Visualization\n    plt.figure(figsize=(12, 6))\n    \n    # Biểu đồ top nhãn\n    top_labels = label_counter.most_common(15)  # Hiển thị top 15\n    labels_list = [x[0] for x in top_labels]\n    counts_list = [x[1] for x in top_labels]\n    \n    plt.subplot(1, 2, 1)\n    bars = plt.bar(labels_list, counts_list, color='skyblue', edgecolor='black')\n    plt.title('Top 15 Nhãn Phổ Biến', fontweight='bold')\n    plt.xlabel('Nhãn')\n    plt.ylabel('Số lượng file')\n    plt.xticks(rotation=45, ha='right')\n    \n    # Thêm số liệu lên biểu đồ\n    for bar, count in zip(bars, counts_list):\n        plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.1,\n                str(count), ha='center', va='bottom')\n    \n    # Biểu đồ tròn cho top 10\n    plt.subplot(1, 2, 2)\n    if len(top_labels) > 10:\n        top_10 = top_labels[:10]\n        other_count = sum([x[1] for x in top_labels[10:]])\n        labels_pie = [x[0] for x in top_10] + ['Other']\n        counts_pie = [x[1] for x in top_10] + [other_count]\n    else:\n        labels_pie = labels_list\n        counts_pie = counts_list\n    \n    colors = plt.cm.Set3(range(len(labels_pie)))\n    plt.pie(counts_pie, labels=labels_pie, autopct='%1.1f%%', colors=colors, startangle=90)\n    plt.title('Phân bố nhãn', fontweight='bold')\n    \n    plt.tight_layout()\n    plt.show()\n    \n    return total_labels\n\ndef export_label_analysis(label_counter, file_label_map, output_file=\"/kaggle/working/label_analysis.csv\"):\n    \"\"\"\n    Xuất kết quả phân tích ra file CSV\n    \"\"\"\n    # Tạo DataFrame\n    data = []\n    for file, label in file_label_map.items():\n        data.append({\n            'filename': file,\n            'label': label,\n            'name_without_ext': os.path.splitext(file)[0]\n        })\n    \n    df = pd.DataFrame(data)\n    df.to_csv(output_file, index=False, encoding='utf-8')\n    \n    # Xuất summary\n    summary_df = pd.DataFrame(list(label_counter.items()), columns=['Label', 'Count'])\n    summary_df['Percentage'] = (summary_df['Count'] / summary_df['Count'].sum()) * 100\n    summary_df = summary_df.sort_values('Count', ascending=False)\n    summary_df.to_csv(\"/kaggle/working/label_summary.csv\", index=False, encoding='utf-8')\n    \n    print(f\"\\n💾 Đã xuất kết quả:\")\n    print(f\"   - label_analysis.csv: Danh sách file và nhãn\")\n    print(f\"   - label_summary.csv: Thống kê nhãn\")\n\n# Code đơn giản hơn để đếm nhanh\ndef quick_label_count(dataset_path):\n    \"\"\"\n    Đếm nhanh số lượng nhãn\n    \"\"\"\n    print(\"⚡ ĐẾM NHANH NHÃN...\")\n    \n    if not os.path.exists(dataset_path):\n        print(f\"❌ Đường dẫn không tồn tại: {dataset_path}\")\n        return 0\n    \n    # Tìm file video\n    video_files = []\n    for root, dirs, files in os.walk(dataset_path):\n        for file in files:\n            if file.lower().endswith('.mp4'):\n                video_files.append(file)\n    \n    print(f\"📹 Tìm thấy {len(video_files)} file video\")\n    \n    # Trích xuất nhãn đơn giản\n    labels_set = set()\n    for file in video_files:\n        name_without_ext = os.path.splitext(file)[0]\n        \n        # Tìm vị trí số đầu tiên\n        for i, char in enumerate(name_without_ext):\n            if char.isdigit():\n                label = name_without_ext[:i]\n                if label.endswith('_'):\n                    label = label[:-1]\n                labels_set.add(label if label else 'unknown')\n                break\n        else:\n            labels_set.add(name_without_ext)\n    \n    print(f\"🏷️ Tổng số nhãn khác nhau: {len(labels_set)}\")\n    print(\"\\n📋 Danh sách nhãn:\")\n    for label in sorted(labels_set):\n        print(f\"  • {label}\")\n    \n    return len(labels_set)\n\n# CHẠY CHƯƠNG TRÌNH CHÍNH\ndef main():\n    \"\"\"\n    Hàm chính để đếm nhãn từ dataset\n    \"\"\"\n    dataset_path = \"/kaggle/input/traincvfinal/publics_train\"\n    \n    print(\"🎯 BẮT ĐẦU PHÂN TÍCH NHÃN TỪ DATASET\")\n    print(\"=\" * 60)\n    \n    # Phân tích chi tiết\n    label_counter, file_label_map = extract_and_count_labels(dataset_path)\n    \n    if label_counter:\n        total_labels = analyze_and_visualize_labels(label_counter)\n        \n        # Xuất kết quả\n        export_label_analysis(label_counter, file_label_map)\n        \n        print(f\"\\n✅ KẾT LUẬN: Tổng cộng có {total_labels} nhãn khác nhau trong dataset!\")\n    \n    return label_counter\n\n# Chạy chương trình\nif __name__ == \"__main__\":\n    label_counts = main()\n    \n    # Hoặc chạy đếm nhanh\n    # quick_label_count(\"/kaggle/input/traincvfinal/publics_train\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T02:20:17.012483Z","iopub.execute_input":"2025-10-19T02:20:17.013348Z","iopub.status.idle":"2025-10-19T02:20:18.203858Z","shell.execute_reply.started":"2025-10-19T02:20:17.013311Z","shell.execute_reply":"2025-10-19T02:20:18.203214Z"}},"outputs":[{"name":"stdout","text":"🎯 BẮT ĐẦU PHÂN TÍCH NHÃN TỪ DATASET\n============================================================\n🔍 ĐANG PHÂN TÍCH NHÃN TỪ TÊN FILE...\n==================================================\n📹 Tìm thấy 1360 file video\n\n🏷️ KẾT QUẢ ĐẾM NHÃN:\n==================================================\n📊 Tổng số file: 1360\n🏷️ Tổng số nhãn khác nhau: 15\n\n📋 DANH SÁCH NHÃN:\n----------------------------------------\n  Live                 :  628 files (46.2%)\n  Partial_Funnyeye     :  143 files (10.5%)\n  Paper                :  108 files (7.9%)\n  Replay               :   78 files (5.7%)\n  Partial_Paperglass   :   61 files (4.5%)\n  Mask_Half            :   58 files (4.3%)\n  Makeup_Im            :   49 files (3.6%)\n  Mask_Trans           :   48 files (3.5%)\n  Partial_Eye          :   46 files (3.4%)\n  Makeup_Co            :   42 files (3.1%)\n  Mask_Mann            :   32 files (2.4%)\n  Partial_Mouth        :   23 files (1.7%)\n  Makeup_Ob            :   18 files (1.3%)\n  Mask_Paper           :   13 files (1.0%)\n  Mask_Silicone        :   13 files (1.0%)\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x600 with 2 Axes>","image/png":"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\n"},"metadata":{}},{"name":"stdout","text":"\n💾 Đã xuất kết quả:\n   - label_analysis.csv: Danh sách file và nhãn\n   - label_summary.csv: Thống kê nhãn\n\n✅ KẾT LUẬN: Tổng cộng có 15 nhãn khác nhau trong dataset!\n","output_type":"stream"}],"execution_count":2},{"cell_type":"code","source":"import os\nimport shutil\n\ndef quick_organize_14_labels():\n    \"\"\"Tổ chức nhanh với 14 nhãn spoof riêng biệt\"\"\"\n    source = \"/kaggle/input/traincvfinal/publics_train\"\n    target = \"/kaggle/working/14_labels_dataset\"\n    \n    # 14 nhãn spoof + 1 live\n    labels = ['Live', 'Partial_Funnyeye', 'Paper', 'Replay', 'Partial_Paperglass', \n              'Mask_Half', 'Makeup_Im', 'Mask_Trans', 'Partial_Eye', 'Makeup_Co',\n              'Mask_Mann', 'Partial_Mouth', 'Makeup_Ob', 'Mask_Paper', 'Mask_Silicone']\n    \n    # Tạo thư mục\n    os.makedirs(os.path.join(target, 'live'), exist_ok=True)\n    for label in labels[1:]:  # Bỏ Live\n        os.makedirs(os.path.join(target, 'spoof', label), exist_ok=True)\n    \n    # Di chuyển file\n    count = 0\n    for root, dirs, files in os.walk(source):\n        for file in files:\n            if file.endswith('.mp4'):\n                name = file[:-4]\n                for i, char in enumerate(name):\n                    if char.isdigit():\n                        label = name[:i].rstrip('_')\n                        if label in labels:\n                            src = os.path.join(root, file)\n                            if label == 'Live':\n                                dst = os.path.join(target, 'live', file)\n                            else:\n                                dst = os.path.join(target, 'spoof', label, file)\n                            shutil.copy2(src, dst)\n                            count += 1\n                        break\n    \n    print(f\"✅ Đã tổ chức {count} file vào {target}\")\n    print(f\"🏷️ Gồm 1 nhãn live + 14 nhãn spoof riêng biệt\")\n\n# Chạy nhanh\nquick_organize_14_labels()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T02:33:36.432992Z","iopub.execute_input":"2025-10-19T02:33:36.433555Z","iopub.status.idle":"2025-10-19T02:33:43.583822Z","shell.execute_reply.started":"2025-10-19T02:33:36.433528Z","shell.execute_reply":"2025-10-19T02:33:43.583026Z"}},"outputs":[{"name":"stdout","text":"✅ Đã tổ chức 1360 file vào /kaggle/working/14_labels_dataset\n🏷️ Gồm 1 nhãn live + 14 nhãn spoof riêng biệt\n","output_type":"stream"}],"execution_count":4},{"cell_type":"code","source":"# Cell 1 — cấu hình chung\n# import os\n# from pathlib import Path\n# import random\n# import numpy as np\n# import torch\n# import numpy as np\n# from sklearn.model_selection import train_test_split\n# from collections import Counter\n\n# # Thay path nếu cần (theo cấu trúc bạn chia sẻ)\n# DATASET_DIR = Path(\"/kaggle/working/14_labels_dataset\")\n# OUT_DIR = Path(\"/kaggle/working/fas_15class\")\n# OUT_DIR.mkdir(parents=True, exist_ok=True)\n\n# SELECTED_CLASSES = [\n#     'Live', 'Partial_Funnyeye', 'Paper', 'Replay', 'Partial_Paperglass', \n#               'Mask_Half', 'Makeup_Im', 'Mask_Trans', 'Partial_Eye', 'Makeup_Co',\n#               'Mask_Mann', 'Partial_Mouth', 'Makeup_Ob', 'Mask_Paper', 'Mask_Silicone'\n# ]\n\n# LABEL_MAP = {cls: idx for idx, cls in enumerate(SELECTED_CLASSES)}\n# INV_LABEL_MAP = {v:k for k,v in LABEL_MAP.items()}\n\n# # Hyperparams\n# FRAMES_PER_CLIP = 16\n# FRAME_SIZE = 112\n# BATCH_SIZE = 4          # tăng giảm tuỳ GPU\n# EPOCHS = 2\n# LR = 1e-4\n# SEED = 42\n# MAX_PER_CLASS = 100  # giới hạn tối đa mỗi lớp\n\n# device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n# print(\"DEVICE:\", device, \"LABEL_MAP:\", LABEL_MAP)\n\n# random.seed(SEED)\n# np.random.seed(SEED)\n# torch.manual_seed(SEED)\n# if device == \"cuda\":\n#     torch.cuda.manual_seed_all(SEED)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T02:33:59.306494Z","iopub.execute_input":"2025-10-19T02:33:59.307057Z","iopub.status.idle":"2025-10-19T02:34:04.648422Z","shell.execute_reply.started":"2025-10-19T02:33:59.307034Z","shell.execute_reply":"2025-10-19T02:34:04.647754Z"}},"outputs":[{"name":"stdout","text":"DEVICE: cuda LABEL_MAP: {'Live': 0, 'Partial_Funnyeye': 1, 'Paper': 2, 'Replay': 3, 'Partial_Paperglass': 4, 'Mask_Half': 5, 'Makeup_Im': 6, 'Mask_Trans': 7, 'Partial_Eye': 8, 'Makeup_Co': 9, 'Mask_Mann': 10, 'Partial_Mouth': 11, 'Makeup_Ob': 12, 'Mask_Paper': 13, 'Mask_Silicone': 14}\n","output_type":"stream"}],"execution_count":5},{"cell_type":"code","source":"import os\nimport shutil\nimport numpy as np\nfrom pathlib import Path\nfrom collections import Counter\nfrom sklearn.model_selection import train_test_split\n\n# ==============================\n# BƯỚC 1: TẠO DATASET TỪ NGUỒN\n# ==============================\ndef organize_dataset_from_source():\n    \"\"\"Tổ chức dataset từ nguồn gốc\"\"\"\n    source_path = \"/kaggle/input/traincvfinal/publics_train\"\n    target_path = \"/kaggle/working/detailed_organized_dataset\"\n    \n    print(\"🎯 TẠO DATASET TỪ NGUỒN...\")\n    print(f\"Source: {source_path}\")\n    print(f\"Target: {target_path}\")\n    \n    # Tạo thư mục đích\n    os.makedirs(os.path.join(target_path, 'live'), exist_ok=True)\n    os.makedirs(os.path.join(target_path, 'spoof'), exist_ok=True)\n    \n    # 14 nhãn spoof\n    spoof_labels = [\n        'Partial_Funnyeye', 'Paper', 'Replay', 'Partial_Paperglass',\n        'Mask_Half', 'Makeup_Im', 'Mask_Trans', 'Partial_Eye', 'Makeup_Co',\n        'Mask_Mann', 'Partial_Mouth', 'Makeup_Ob', 'Mask_Paper', 'Mask_Silicone'\n    ]\n    \n    for label in spoof_labels:\n        os.makedirs(os.path.join(target_path, 'spoof', label), exist_ok=True)\n    \n    # Mapping nhãn\n    label_mapping = {\n        'Live': 'live',\n        'Partial_Funnyeye': 'spoof/Partial_Funnyeye',\n        'Paper': 'spoof/Paper',\n        'Replay': 'spoof/Replay',\n        'Partial_Paperglass': 'spoof/Partial_Paperglass',\n        'Mask_Half': 'spoof/Mask_Half',\n        'Makeup_Im': 'spoof/Makeup_Im',\n        'Mask_Trans': 'spoof/Mask_Trans',\n        'Partial_Eye': 'spoof/Partial_Eye',\n        'Makeup_Co': 'spoof/Makeup_Co',\n        'Mask_Mann': 'spoof/Mask_Mann',\n        'Partial_Mouth': 'spoof/Partial_Mouth',\n        'Makeup_Ob': 'spoof/Makeup_Ob',\n        'Mask_Paper': 'spoof/Mask_Paper',\n        'Mask_Silicone': 'spoof/Mask_Silicone'\n    }\n    \n    # Đếm file\n    stats = {category: 0 for category in set(label_mapping.values())}\n    \n    # Duyệt qua source và copy file\n    for root, dirs, files in os.walk(source_path):\n        for file in files:\n            if file.endswith('.mp4'):\n                source_file = os.path.join(root, file)\n                \n                # Trích xuất nhãn từ tên file\n                name_without_ext = os.path.splitext(file)[0]\n                label = None\n                \n                # Tìm phần chữ trước số đầu tiên\n                for i, char in enumerate(name_without_ext):\n                    if char.isdigit():\n                        label = name_without_ext[:i]\n                        if label.endswith('_'):\n                            label = label[:-1]\n                        break\n                \n                if label and label in label_mapping:\n                    target_category = label_mapping[label]\n                    target_dir = os.path.join(target_path, target_category)\n                    target_file = os.path.join(target_dir, file)\n                    \n                    try:\n                        shutil.copy2(source_file, target_file)\n                        stats[target_category] += 1\n                    except Exception as e:\n                        print(f\"❌ Lỗi copy {file}: {e}\")\n    \n    # Hiển thị kết quả\n    print(\"\\n📊 KẾT QUẢ TỔ CHỨC DATASET:\")\n    total_files = sum(stats.values())\n    for category, count in sorted(stats.items()):\n        percentage = (count / total_files) * 100 if total_files > 0 else 0\n        print(f\"  {category:25}: {count:4} files ({percentage:.1f}%)\")\n    \n    print(f\"🎯 Tổng số file: {total_files}\")\n    return target_path, stats\n\n# Chạy tổ chức dataset\nDATASET_DIR, dataset_stats = organize_dataset_from_source()\nDATASET_DIR = Path(DATASET_DIR)\n\n# ==============================\n# BƯỚC 2: CẤU HÌNH VÀ THU THẬP VIDEO\n# ==============================\nSEED = 42\nMAX_PER_CLASS = 50\n\n# 15 nhãn đầy đủ\nSELECTED_CLASSES = [\n    \"live\",\n    \"Partial_Funnyeye\", \"Paper\", \"Replay\", \"Partial_Paperglass\",\n    \"Mask_Half\", \"Makeup_Im\", \"Mask_Trans\", \"Partial_Eye\", \"Makeup_Co\",\n    \"Mask_Mann\", \"Partial_Mouth\", \"Makeup_Ob\", \"Mask_Paper\", \"Mask_Silicone\"\n]\n\nLABEL_MAP = {cls: idx for idx, cls in enumerate(SELECTED_CLASSES)}\nREVERSE_LABEL_MAP = {idx: cls for cls, idx in LABEL_MAP.items()}\n\nprint(f\"\\n🏷️ LABEL MAPPING ({len(SELECTED_CLASSES)} classes):\")\nfor cls, idx in LABEL_MAP.items():\n    print(f\"  {cls:20} → {idx}\")\n\ndef collect_videos(base_path: Path, selected_classes):\n    \"\"\"Thu thập video từ dataset đã tổ chức\"\"\"\n    videos = []\n    labels = []\n    \n    print(\"\\n🔍 ĐANG QUÉT VIDEO...\")\n    \n    for cls in selected_classes:\n        if cls == \"live\":\n            cls_path = base_path / \"live\"\n        else:\n            cls_path = base_path / \"spoof\" / cls\n        \n        if not cls_path.exists():\n            print(f\"⚠️  Thư mục không tồn tại: {cls_path}\")\n            continue\n            \n        # Tìm file video\n        video_files = list(cls_path.glob(\"*.mp4\"))\n        \n        if not video_files:\n            print(f\"⚠️  Không tìm thấy video nào trong: {cls}\")\n            continue\n            \n        print(f\"✅ {cls:20}: {len(video_files):3} videos\")\n        \n        for video_path in video_files:\n            videos.append(str(video_path))\n            labels.append(cls)\n    \n    return videos, labels\n\n# Thu thập video\nvideos_all, labels_all = collect_videos(DATASET_DIR, SELECTED_CLASSES)\n\nif not videos_all:\n    print(\"❌ KHÔNG TÌM THẤY VIDEO NÀO!\")\n    # Hiển thị cấu trúc thư mục để debug\n    print(\"\\n📁 KIỂM TRA CẤU TRÚC THƯ MỤC:\")\n    if DATASET_DIR.exists():\n        for item in DATASET_DIR.iterdir():\n            if item.is_dir():\n                print(f\"  📂 {item.name}\")\n                if item.name == \"spoof\":\n                    for spoof_item in item.iterdir():\n                        if spoof_item.is_dir():\n                            print(f\"    📁 {spoof_item.name}\")\n    exit()\n\nprint(f\"\\n🎯 TỔNG SỐ VIDEO TÌM THẤY: {len(videos_all)}\")\nprint(\"📊 PHÂN BỐ THEO LỚP:\")\nlabel_counter = Counter(labels_all)\nfor cls in SELECTED_CLASSES:\n    count = label_counter.get(cls, 0)\n    if count > 0:\n        print(f\"  {cls:20}: {count:3} videos\")\n\n# ==============================\n# BƯỚC 3: CÂN BẰNG DATASET\n# ==============================\ndef balance_dataset(videos, labels, max_per_class, selected_classes):\n    \"\"\"Cân bằng dataset bằng cách giới hạn số lượng mỗi lớp\"\"\"\n    balanced_videos = []\n    balanced_labels = []\n    available_classes = []\n    \n    print(f\"\\n⚖️  CÂN BẰNG DATASET (tối đa {max_per_class} mỗi lớp)...\")\n    \n    for cls in selected_classes:\n        cls_videos = [v for v, l in zip(videos, labels) if l == cls]\n        \n        if not cls_videos:\n            continue\n            \n        available_classes.append(cls)\n        np.random.seed(SEED)\n        np.random.shuffle(cls_videos)\n        \n        # Lấy tối đa max_per_class video\n        selected_videos = cls_videos[:min(max_per_class, len(cls_videos))]\n        balanced_videos.extend(selected_videos)\n        balanced_labels.extend([cls] * len(selected_videos))\n        \n        print(f\"  {cls:20}: {len(selected_videos):2} videos\")\n    \n    return balanced_videos, balanced_labels, available_classes\n\nbalanced_videos, balanced_labels, available_classes = balance_dataset(\n    videos_all, labels_all, MAX_PER_CLASS, SELECTED_CLASSES\n)\n\nprint(f\"\\n📊 SAU KHI CÂN BẰNG:\")\nprint(f\"  Tổng số video: {len(balanced_videos)}\")\nprint(f\"  Số lớp có sẵn: {len(available_classes)}\")\n\n# ==============================\n# BƯỚC 4: CHIA TRAIN/VAL\n# ==============================\ndef split_train_val_safe(videos, labels, test_size=0.2, random_state=42):\n    \"\"\"Chia dataset thành train/val một cách an toàn\"\"\"\n    if len(videos) < 2:\n        raise ValueError(f\"Cần ít nhất 2 video để split, chỉ có {len(videos)}\")\n    \n    paths = np.array(videos)\n    labs = np.array([LABEL_MAP[l] for l in labels])\n    \n    print(f\"\\n📂 CHIA DATASET (train/{int((1-test_size)*100)}%, val/{int(test_size*100)}%)...\")\n    \n    # Kiểm tra phân bố lớp trước khi split\n    unique, counts = np.unique(labs, return_counts=True)\n    print(\"📊 Phân bố trước khi chia:\")\n    for cls_idx, count in zip(unique, counts):\n        print(f\"  {REVERSE_LABEL_MAP[cls_idx]:20}: {count:2} samples\")\n    \n    # Nếu có lớp chỉ có 1 sample, dùng random split\n    if min(counts) == 1:\n        print(\"⚠️  Có lớp chỉ có 1 sample, dùng random split\")\n        indices = np.arange(len(paths))\n        np.random.seed(random_state)\n        np.random.shuffle(indices)\n        split_idx = int(len(indices) * (1 - test_size))\n        train_idx = indices[:split_idx]\n        val_idx = indices[split_idx:]\n    else:\n        # Dùng stratified split\n        train_idx, val_idx = train_test_split(\n            np.arange(len(paths)),\n            test_size=test_size,\n            stratify=labs,\n            random_state=random_state\n        )\n    \n    train_videos = paths[train_idx].tolist()\n    train_labels = labs[train_idx].tolist()\n    val_videos = paths[val_idx].tolist()\n    val_labels = labs[val_idx].tolist()\n    \n    return train_videos, train_labels, val_videos, val_labels\n\n# Chia dataset\ntry:\n    train_videos, train_labels, val_videos, val_labels = split_train_val_safe(\n        balanced_videos, balanced_labels, test_size=0.20, random_state=SEED\n    )\n    \n    print(f\"\\n✅ CHIA THÀNH CÔNG:\")\n    print(f\"  🚂 Train set: {len(train_videos)} videos\")\n    print(f\"  🧪 Val set:   {len(val_videos)} videos\")\n    \n    # Kiểm tra phân bố\n    print(\"\\n📊 PHÂN BỐ TRAIN SET:\")\n    train_counts = Counter([REVERSE_LABEL_MAP[l] for l in train_labels])\n    for cls in available_classes:\n        if cls in train_counts:\n            print(f\"  {cls:20}: {train_counts[cls]:2} videos\")\n    \n    print(\"\\n📊 PHÂN BỐ VAL SET:\")\n    val_counts = Counter([REVERSE_LABEL_MAP[l] for l in val_labels])\n    for cls in available_classes:\n        if cls in val_counts:\n            print(f\"  {cls:20}: {val_counts[cls]:2} videos\")\n            \nexcept Exception as e:\n    print(f\"❌ Lỗi khi chia dataset: {e}\")\n    # Fallback: chia thủ công\n    print(\"🔄 Thử chia thủ công...\")\n    indices = list(range(len(balanced_videos)))\n    np.random.seed(SEED)\n    np.random.shuffle(indices)\n    split_idx = int(len(indices) * 0.8)\n    \n    train_videos = [balanced_videos[i] for i in indices[:split_idx]]\n    train_labels = [LABEL_MAP[balanced_labels[i]] for i in indices[:split_idx]]\n    val_videos = [balanced_videos[i] for i in indices[split_idx:]]\n    val_labels = [LABEL_MAP[balanced_labels[i]] for i in indices[split_idx:]]\n    \n    print(f\"✅ Chia thủ công thành công:\")\n    print(f\"  Train: {len(train_videos)}, Val: {len(val_videos)}\")\n\n# ==============================\n# BƯỚC 5: LƯU KẾT QUẢ\n# ==============================\ndef save_split_results(train_videos, train_labels, val_videos, val_labels, output_dir=\"dataset_split\"):\n    \"\"\"Lưu kết quả split\"\"\"\n    output_path = Path(output_dir)\n    output_path.mkdir(exist_ok=True)\n    \n    # Lưu train split\n    with open(output_path / \"train.txt\", \"w\") as f:\n        for video, label_idx in zip(train_videos, train_labels):\n            f.write(f\"{video}\\t{label_idx}\\n\")\n    \n    # Lưu val split\n    with open(output_path / \"val.txt\", \"w\") as f:\n        for video, label_idx in zip(val_videos, val_labels):\n            f.write(f\"{video}\\t{label_idx}\\n\")\n    \n    # Lưu mapping\n    with open(output_path / \"label_mapping.txt\", \"w\") as f:\n        for cls, idx in LABEL_MAP.items():\n            f.write(f\"{idx}\\t{cls}\\n\")\n    \n    # Lưu summary\n    with open(output_path / \"summary.txt\", \"w\") as f:\n        f.write(\"DATASET SPLIT SUMMARY\\n\")\n        f.write(\"=====================\\n\")\n        f.write(f\"Total classes: {len(available_classes)}\\n\")\n        f.write(f\"Total videos: {len(balanced_videos)}\\n\")\n        f.write(f\"Train videos: {len(train_videos)}\\n\")\n        f.write(f\"Val videos: {len(val_videos)}\\n\")\n        f.write(f\"Max per class: {MAX_PER_CLASS}\\n\\n\")\n        \n        f.write(\"Class distribution:\\n\")\n        for cls in available_classes:\n            train_count = sum(1 for l in train_labels if REVERSE_LABEL_MAP[l] == cls)\n            val_count = sum(1 for l in val_labels if REVERSE_LABEL_MAP[l] == cls)\n            f.write(f\"{cls}: Train {train_count} | Val {val_count}\\n\")\n    \n    print(f\"\\n💾 Đã lưu kết quả vào: {output_path}\")\n\n# Lưu kết quả\nsave_split_results(train_videos, train_labels, val_videos, val_labels)\n\nprint(\"\\n🎉 HOÀN THÀNH!\")\nprint(\"=\" * 50)\nprint(f\"🏷️  Số lớp: {len(available_classes)}\")\nprint(f\"📹 Tổng video: {len(balanced_videos)}\")\nprint(f\"🚂 Train: {len(train_videos)} videos\")\nprint(f\"🧪 Val: {len(val_videos)} videos\")\nprint(\"=\" * 50)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T02:43:41.655885Z","iopub.execute_input":"2025-10-19T02:43:41.656540Z","iopub.status.idle":"2025-10-19T02:43:46.831000Z","shell.execute_reply.started":"2025-10-19T02:43:41.656514Z","shell.execute_reply":"2025-10-19T02:43:46.830155Z"}},"outputs":[{"name":"stdout","text":"🎯 TẠO DATASET TỪ NGUỒN...\nSource: /kaggle/input/traincvfinal/publics_train\nTarget: /kaggle/working/detailed_organized_dataset\n\n📊 KẾT QUẢ TỔ CHỨC DATASET:\n  live                     :  628 files (46.2%)\n  spoof/Makeup_Co          :   42 files (3.1%)\n  spoof/Makeup_Im          :   49 files (3.6%)\n  spoof/Makeup_Ob          :   18 files (1.3%)\n  spoof/Mask_Half          :   58 files (4.3%)\n  spoof/Mask_Mann          :   32 files (2.4%)\n  spoof/Mask_Paper         :   13 files (1.0%)\n  spoof/Mask_Silicone      :   13 files (1.0%)\n  spoof/Mask_Trans         :   48 files (3.5%)\n  spoof/Paper              :  108 files (7.9%)\n  spoof/Partial_Eye        :   46 files (3.4%)\n  spoof/Partial_Funnyeye   :  143 files (10.5%)\n  spoof/Partial_Mouth      :   23 files (1.7%)\n  spoof/Partial_Paperglass :   61 files (4.5%)\n  spoof/Replay             :   78 files (5.7%)\n🎯 Tổng số file: 1360\n\n🏷️ LABEL MAPPING (15 classes):\n  live                 → 0\n  Partial_Funnyeye     → 1\n  Paper                → 2\n  Replay               → 3\n  Partial_Paperglass   → 4\n  Mask_Half            → 5\n  Makeup_Im            → 6\n  Mask_Trans           → 7\n  Partial_Eye          → 8\n  Makeup_Co            → 9\n  Mask_Mann            → 10\n  Partial_Mouth        → 11\n  Makeup_Ob            → 12\n  Mask_Paper           → 13\n  Mask_Silicone        → 14\n\n🔍 ĐANG QUÉT VIDEO...\n✅ live                : 628 videos\n✅ Partial_Funnyeye    : 143 videos\n✅ Paper               : 108 videos\n✅ Replay              :  78 videos\n✅ Partial_Paperglass  :  61 videos\n✅ Mask_Half           :  58 videos\n✅ Makeup_Im           :  49 videos\n✅ Mask_Trans          :  48 videos\n✅ Partial_Eye         :  46 videos\n✅ Makeup_Co           :  42 videos\n✅ Mask_Mann           :  32 videos\n✅ Partial_Mouth       :  23 videos\n✅ Makeup_Ob           :  18 videos\n✅ Mask_Paper          :  13 videos\n✅ Mask_Silicone       :  13 videos\n\n🎯 TỔNG SỐ VIDEO TÌM THẤY: 1360\n📊 PHÂN BỐ THEO LỚP:\n  live                : 628 videos\n  Partial_Funnyeye    : 143 videos\n  Paper               : 108 videos\n  Replay              :  78 videos\n  Partial_Paperglass  :  61 videos\n  Mask_Half           :  58 videos\n  Makeup_Im           :  49 videos\n  Mask_Trans          :  48 videos\n  Partial_Eye         :  46 videos\n  Makeup_Co           :  42 videos\n  Mask_Mann           :  32 videos\n  Partial_Mouth       :  23 videos\n  Makeup_Ob           :  18 videos\n  Mask_Paper          :  13 videos\n  Mask_Silicone       :  13 videos\n\n⚖️  CÂN BẰNG DATASET (tối đa 50 mỗi lớp)...\n  live                : 50 videos\n  Partial_Funnyeye    : 50 videos\n  Paper               : 50 videos\n  Replay              : 50 videos\n  Partial_Paperglass  : 50 videos\n  Mask_Half           : 50 videos\n  Makeup_Im           : 49 videos\n  Mask_Trans          : 48 videos\n  Partial_Eye         : 46 videos\n  Makeup_Co           : 42 videos\n  Mask_Mann           : 32 videos\n  Partial_Mouth       : 23 videos\n  Makeup_Ob           : 18 videos\n  Mask_Paper          : 13 videos\n  Mask_Silicone       : 13 videos\n\n📊 SAU KHI CÂN BẰNG:\n  Tổng số video: 584\n  Số lớp có sẵn: 15\n\n📂 CHIA DATASET (train/80%, val/20%)...\n📊 Phân bố trước khi chia:\n  live                : 50 samples\n  Partial_Funnyeye    : 50 samples\n  Paper               : 50 samples\n  Replay              : 50 samples\n  Partial_Paperglass  : 50 samples\n  Mask_Half           : 50 samples\n  Makeup_Im           : 49 samples\n  Mask_Trans          : 48 samples\n  Partial_Eye         : 46 samples\n  Makeup_Co           : 42 samples\n  Mask_Mann           : 32 samples\n  Partial_Mouth       : 23 samples\n  Makeup_Ob           : 18 samples\n  Mask_Paper          : 13 samples\n  Mask_Silicone       : 13 samples\n\n✅ CHIA THÀNH CÔNG:\n  🚂 Train set: 467 videos\n  🧪 Val set:   117 videos\n\n📊 PHÂN BỐ TRAIN SET:\n  live                : 40 videos\n  Partial_Funnyeye    : 40 videos\n  Paper               : 40 videos\n  Replay              : 40 videos\n  Partial_Paperglass  : 40 videos\n  Mask_Half           : 40 videos\n  Makeup_Im           : 39 videos\n  Mask_Trans          : 38 videos\n  Partial_Eye         : 37 videos\n  Makeup_Co           : 34 videos\n  Mask_Mann           : 26 videos\n  Partial_Mouth       : 18 videos\n  Makeup_Ob           : 14 videos\n  Mask_Paper          : 10 videos\n  Mask_Silicone       : 11 videos\n\n📊 PHÂN BỐ VAL SET:\n  live                : 10 videos\n  Partial_Funnyeye    : 10 videos\n  Paper               : 10 videos\n  Replay              : 10 videos\n  Partial_Paperglass  : 10 videos\n  Mask_Half           : 10 videos\n  Makeup_Im           : 10 videos\n  Mask_Trans          : 10 videos\n  Partial_Eye         :  9 videos\n  Makeup_Co           :  8 videos\n  Mask_Mann           :  6 videos\n  Partial_Mouth       :  5 videos\n  Makeup_Ob           :  4 videos\n  Mask_Paper          :  3 videos\n  Mask_Silicone       :  2 videos\n\n💾 Đã lưu kết quả vào: dataset_split\n\n🎉 HOÀN THÀNH!\n==================================================\n🏷️  Số lớp: 15\n📹 Tổng video: 584\n🚂 Train: 467 videos\n🧪 Val: 117 videos\n==================================================\n","output_type":"stream"}],"execution_count":10},{"cell_type":"code","source":"# Cell 4 — Dataset\nimport cv2\nimport torch\nfrom torch.utils.data import Dataset\nimport torchvision.transforms as T\nimport numpy as np\nimport random\nfrom PIL import Image\n\n# Basic transforms on single frame (applied per-frame)\nframe_transform = T.Compose([\n    T.ToTensor(),  # from H,W,C in 0..255 to C,H,W in 0..1\n    T.Normalize(mean=[0.45,0.45,0.45], std=[0.225,0.225,0.225])\n])\n\ndef sample_frames_from_video(path, num_frames=16, resize=(112,112)):\n    cap = cv2.VideoCapture(path)\n    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n    if total <= 0:\n        cap.release()\n        blank = np.zeros((num_frames, resize[1], resize[0], 3), dtype=np.uint8)\n        return blank\n    # chọn các frame cách đều\n    if total <= num_frames:\n        idxs = list(range(total)) + [total-1]*(num_frames-total)\n    else:\n        start = random.randint(0, max(0, total - num_frames))\n        idxs = list(range(start, start + num_frames))\n    frames = []\n    for fid in idxs:\n        cap.set(cv2.CAP_PROP_POS_FRAMES, fid)\n        ret, frame = cap.read()\n        if not ret:\n            if frames:\n                frames.append(frames[-1])\n            else:\n                frames.append(np.zeros((resize[1],resize[0],3),dtype=np.uint8))\n            continue\n        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n        frame = cv2.resize(frame, resize)\n        frames.append(frame)\n    cap.release()\n    return np.array(frames)  # shape (T, H, W, C)\n\nclass VideoSegmentDataset(Dataset):\n    def __init__(self, video_paths, labels, frames_per_clip=16, transform=frame_transform, augment=False):\n        self.video_paths = video_paths\n        self.labels = labels\n        self.frames_per_clip = frames_per_clip\n        self.transform = transform\n        self.augment = augment\n        self.color_jitter = T.ColorJitter(0.15,0.15,0.15,0.05)\n    \n    def __len__(self):\n        return len(self.video_paths)\n    \n    def __getitem__(self, idx):\n        path = self.video_paths[idx]\n        label = self.labels[idx]\n        frames = sample_frames_from_video(path, self.frames_per_clip)\n\n        # augmentation: random horizontal flip\n        if self.augment and random.random() < 0.5:\n            frames = np.ascontiguousarray(frames[:, :, ::-1, :])  # ✅ copy tránh stride âm\n\n        out_frames = []\n        for f in frames:\n            pil = Image.fromarray(f.copy())  # ✅ dùng .copy() đảm bảo stride dương\n            img = self.transform(pil)  # C H W\n            if self.augment and random.random() < 0.3:\n                img = self.color_jitter(img)\n            out_frames.append(img)\n        \n        out = torch.stack(out_frames)  # [T,C,H,W]\n        out = out.permute(1,0,2,3)     # [C,T,H,W]\n        return out, torch.tensor(label, dtype=torch.long)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T02:44:23.718335Z","iopub.execute_input":"2025-10-19T02:44:23.719161Z","iopub.status.idle":"2025-10-19T02:44:28.335704Z","shell.execute_reply.started":"2025-10-19T02:44:23.719131Z","shell.execute_reply":"2025-10-19T02:44:28.335100Z"}},"outputs":[],"execution_count":11},{"cell_type":"code","source":"# Cell 5 — DataLoader\nfrom torch.utils.data import DataLoader\n\ntrain_ds = VideoSegmentDataset(train_videos, train_labels, augment=True)\nval_ds = VideoSegmentDataset(val_videos, val_labels, augment=False)\n\ntrain_loader = DataLoader(train_ds, batch_size=BATCH_SIZE, shuffle=True, num_workers=2, pin_memory=True)\nval_loader   = DataLoader(val_ds, batch_size=BATCH_SIZE, shuffle=False, num_workers=2, pin_memory=True)\n\n# quick sanity batch\nx, y = next(iter(train_loader))\nprint(\"Batch shape (C,T,H,W):\", x.shape, \"Labels:\", y)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T02:44:38.804665Z","iopub.execute_input":"2025-10-19T02:44:38.805057Z","iopub.status.idle":"2025-10-19T02:45:07.928360Z","shell.execute_reply.started":"2025-10-19T02:44:38.805039Z","shell.execute_reply":"2025-10-19T02:45:07.927112Z"}},"outputs":[{"name":"stdout","text":"Batch shape (C,T,H,W): torch.Size([4, 3, 16, 112, 112]) Labels: tensor([ 1, 11,  0,  2])\n","output_type":"stream"}],"execution_count":12},{"cell_type":"code","source":"# Cell 6 — Model + opt\nimport torch.nn as nn\nfrom torchvision.models.video import r3d_18\n\nmodel = r3d_18(pretrained=True)\n# replace fc\nin_features = model.fc.in_features\nmodel.fc = nn.Linear(in_features, len(SELECTED_CLASSES))\nmodel = model.to(device)\n\noptimizer = torch.optim.AdamW(model.parameters(), lr=LR, weight_decay=1e-4)\nscheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)\ncriterion = nn.CrossEntropyLoss()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T02:45:11.565657Z","iopub.execute_input":"2025-10-19T02:45:11.565945Z","iopub.status.idle":"2025-10-19T02:45:13.096137Z","shell.execute_reply.started":"2025-10-19T02:45:11.565922Z","shell.execute_reply":"2025-10-19T02:45:13.095300Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n  warnings.warn(\n/usr/local/lib/python3.11/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=R3D_18_Weights.KINETICS400_V1`. You can also use `weights=R3D_18_Weights.DEFAULT` to get the most up-to-date weights.\n  warnings.warn(msg)\nDownloading: \"https://download.pytorch.org/models/r3d_18-b3b3357e.pth\" to /root/.cache/torch/hub/checkpoints/r3d_18-b3b3357e.pth\n100%|██████████| 127M/127M [00:00<00:00, 184MB/s]  \n","output_type":"stream"}],"execution_count":13},{"cell_type":"code","source":"# Cell 7 — Training + validation\nfrom tqdm.auto import tqdm\nfrom sklearn.metrics import classification_report, confusion_matrix\n\nscaler = torch.cuda.amp.GradScaler(enabled=(device==\"cuda\"))\nbest_val_acc = 0.0\nbest_path = OUT_DIR / \"best_r3d18.pth\"\n\nfor epoch in range(1, EPOCHS+1):\n    # Train\n    model.train()\n    running_loss = 0.0\n    running_correct = 0\n    total = 0\n    pbar = tqdm(train_loader, desc=f\"Epoch {epoch}/{EPOCHS} Train\")\n    for x, y in pbar:\n        x = x.to(device, non_blocking=True)\n        y = y.to(device, non_blocking=True)\n        optimizer.zero_grad()\n        with torch.cuda.amp.autocast(enabled=(device==\"cuda\")):\n            logits = model(x)\n            loss = criterion(logits, y)\n        scaler.scale(loss).backward()\n        scaler.step(optimizer)\n        scaler.update()\n        running_loss += loss.item() * x.size(0)\n        preds = logits.argmax(dim=1)\n        running_correct += (preds == y).sum().item()\n        total += x.size(0)\n        pbar.set_postfix(loss=running_loss/total, acc=running_correct/total)\n    scheduler.step()\n    train_loss = running_loss / total\n    train_acc = running_correct / total\n\n    # Validation\n    model.eval()\n    val_loss = 0.0\n    val_correct = 0\n    val_total = 0\n    all_preds = []\n    all_labels = []\n    with torch.no_grad():\n        for x, y in tqdm(val_loader, desc=f\"Epoch {epoch}/{EPOCHS} Val\"):\n            x = x.to(device, non_blocking=True)\n            y = y.to(device, non_blocking=True)\n            with torch.cuda.amp.autocast(enabled=(device==\"cuda\")):\n                logits = model(x)\n                loss = criterion(logits, y)\n            val_loss += loss.item() * x.size(0)\n            preds = logits.argmax(dim=1)\n            val_correct += (preds == y).sum().item()\n            val_total += x.size(0)\n            all_preds.extend(preds.cpu().numpy().tolist())\n            all_labels.extend(y.cpu().numpy().tolist())\n\n    val_loss /= max(1, val_total)\n    val_acc = val_correct / max(1, val_total)\n\n    print(f\"Epoch {epoch}: Train loss {train_loss:.4f}, acc {train_acc:.4f} | Val loss {val_loss:.4f}, acc {val_acc:.4f}\")\n\n    # Save best\n    if val_acc > best_val_acc:\n        best_val_acc = val_acc\n        torch.save({\n            \"epoch\": epoch,\n            \"model_state\": model.state_dict(),\n            \"optimizer_state\": optimizer.state_dict(),\n            \"val_acc\": val_acc\n        }, best_path)\n        print(\"Saved best model:\", best_path)\n\n# Final report on validation\nprint(\"Best val acc:\", best_val_acc)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T02:45:16.276483Z","iopub.execute_input":"2025-10-19T02:45:16.277259Z","iopub.status.idle":"2025-10-19T03:29:54.814481Z","shell.execute_reply.started":"2025-10-19T02:45:16.277232Z","shell.execute_reply":"2025-10-19T03:29:54.813060Z"}},"outputs":[{"name":"stderr","text":"/tmp/ipykernel_37/668689474.py:5: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n  scaler = torch.cuda.amp.GradScaler(enabled=(device==\"cuda\"))\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"Epoch 1/2 Train:   0%|          | 0/117 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"e720aca7f9fa462089ad44e065f51e39"}},"metadata":{}},{"name":"stderr","text":"/tmp/ipykernel_37/668689474.py:20: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with torch.cuda.amp.autocast(enabled=(device==\"cuda\")):\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"Epoch 1/2 Val:   0%|          | 0/30 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"19ac5178e2e04124a3495ecc94fb62dc"}},"metadata":{}},{"name":"stderr","text":"/tmp/ipykernel_37/668689474.py:46: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with torch.cuda.amp.autocast(enabled=(device==\"cuda\")):\n","output_type":"stream"},{"name":"stdout","text":"Epoch 1: Train loss 1.7145, acc 0.5182 | Val loss 0.7942, acc 0.8462\nSaved best model: /kaggle/working/fas_15class/best_r3d18.pth\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"Epoch 2/2 Train:   0%|          | 0/117 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"3d29216875a44acbb469ba14b16440ba"}},"metadata":{}},{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m/tmp/ipykernel_37/668689474.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0mtotal\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mpbar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34mf\"Epoch {epoch}/{EPOCHS} Train\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m     \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpbar\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_blocking\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m         \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_blocking\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/tqdm/notebook.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    248\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    249\u001b[0m             \u001b[0mit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 250\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mit\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    251\u001b[0m                 \u001b[0;31m# return super(tqdm...) will not catch exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    252\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/tqdm/std.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1179\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1180\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1181\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1182\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1183\u001b[0m                 \u001b[0;31m# Update and possibly print the progressbar.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    706\u001b[0m                 \u001b[0;31m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    707\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[call-arg]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 708\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    709\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_yielded\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    710\u001b[0m             if (\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1456\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1457\u001b[0m             \u001b[0;32massert\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_shutdown\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tasks_outstanding\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1458\u001b[0;31m             \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1459\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tasks_outstanding\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1460\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_get_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1408\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1409\u001b[0m             \u001b[0;32mwhile\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory_thread\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_alive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1410\u001b[0;31m                 \u001b[0msuccess\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_try_get_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1411\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0msuccess\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1412\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_try_get_data\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m   1249\u001b[0m         \u001b[0;31m#   (bool: whether successfully get data, any: data if successful else None)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1250\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1251\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_data_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1252\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1253\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/lib/python3.11/queue.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, block, timeout)\u001b[0m\n\u001b[1;32m    178\u001b[0m                     \u001b[0;32mif\u001b[0m \u001b[0mremaining\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    179\u001b[0m                         \u001b[0;32mraise\u001b[0m \u001b[0mEmpty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnot_empty\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mremaining\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    181\u001b[0m             \u001b[0mitem\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    182\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnot_full\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnotify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/lib/python3.11/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    329\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    330\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 331\u001b[0;31m                     \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    332\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    333\u001b[0m                     \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "],"ename":"KeyboardInterrupt","evalue":"","output_type":"error"}],"execution_count":14},{"cell_type":"code","source":"# Cell 7 — Training với pruning đơn giản\nfrom tqdm.auto import tqdm\nimport torch.nn.utils.prune as prune\n\nscaler = torch.cuda.amp.GradScaler(enabled=(device==\"cuda\"))\nbest_val_acc = 0.0\nbest_path = OUT_DIR / \"best_r3d18.pth\"\n\nfor epoch in range(1, EPOCHS+1):\n    # Training code giữ nguyên...\n    # ... (giống code gốc của bạn)\n    \n    # Validation code giữ nguyên...\n    # ... (giống code gốc của bạn)\n\n    # Save best model\n    if val_acc > best_val_acc:\n        best_val_acc = val_acc\n        \n        # Save full model\n        torch.save({\n            \"epoch\": epoch,\n            \"model_state\": model.state_dict(),\n            \"optimizer_state\": optimizer.state_dict(), \n            \"val_acc\": val_acc\n        }, best_path)\n        \n        # Tạo pruned model (đơn giản)\n        pruned_model = model\n        for name, module in pruned_model.named_modules():\n            if isinstance(module, torch.nn.Linear):\n                prune.l1_unstructured(module, name='weight', amount=0.3)\n                prune.remove(module, 'weight')\n        \n        # Save pruned model\n        pruned_path = OUT_DIR / \"r3d18_pruned.pth\"\n        torch.save(pruned_model.state_dict(), pruned_path)\n        \n        print(f\"💾 Saved best model + pruned version (30% pruning)\")\n\nprint(f\"✅ Training completed! Best accuracy: {best_val_acc:.4f}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T03:30:02.204194Z","iopub.execute_input":"2025-10-19T03:30:02.204611Z","iopub.status.idle":"2025-10-19T03:30:03.593928Z","shell.execute_reply.started":"2025-10-19T03:30:02.204585Z","shell.execute_reply":"2025-10-19T03:30:03.593274Z"}},"outputs":[{"name":"stderr","text":"/tmp/ipykernel_37/1654263558.py:5: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n  scaler = torch.cuda.amp.GradScaler(enabled=(device==\"cuda\"))\n","output_type":"stream"},{"name":"stdout","text":"💾 Saved best model + pruned version (30% pruning)\n✅ Training completed! Best accuracy: 0.8462\n","output_type":"stream"}],"execution_count":15},{"cell_type":"code","source":"# Cell 8 — load best & evaluate\nimport torch\nfrom sklearn.metrics import classification_report, confusion_matrix\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n\nckpt = torch.load(best_path, map_location=device)\nmodel.load_state_dict(ckpt[\"model_state\"])\nmodel.eval()\n\nall_preds = []\nall_labels = []\nwith torch.no_grad():\n    for x, y in tqdm(val_loader, desc=\"Final eval\"):\n        x = x.to(device)\n        logits = model(x)\n        preds = logits.argmax(dim=1)\n        all_preds.extend(preds.cpu().numpy().tolist())\n        all_labels.extend(y.numpy().tolist())\n\nprint(classification_report(all_labels, all_preds, target_names=SELECTED_CLASSES))\n\ncm = confusion_matrix(all_labels, all_preds)\nplt.figure(figsize=(8,6))\nsns.heatmap(cm, annot=True, fmt=\"d\", xticklabels=SELECTED_CLASSES, yticklabels=SELECTED_CLASSES)\nplt.xlabel(\"Pred\")\nplt.ylabel(\"True\")\nplt.title(\"Confusion Matrix on Val\")\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T03:34:37.962835Z","iopub.execute_input":"2025-10-19T03:34:37.963163Z","iopub.status.idle":"2025-10-19T03:39:38.771653Z","shell.execute_reply.started":"2025-10-19T03:34:37.963142Z","shell.execute_reply":"2025-10-19T03:39:38.769424Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"Final eval:   0%|          | 0/30 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"bfdbe40fce4a4a378b6f78fbb8aa8b47"}},"metadata":{}},{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m/tmp/ipykernel_37/845622577.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mall_labels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mno_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m     \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Final eval\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m         \u001b[0mlogits\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/tqdm/notebook.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    248\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    249\u001b[0m             \u001b[0mit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 250\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mit\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    251\u001b[0m                 \u001b[0;31m# return super(tqdm...) will not catch exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    252\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/tqdm/std.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1179\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1180\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1181\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1182\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1183\u001b[0m                 \u001b[0;31m# Update and possibly print the progressbar.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    706\u001b[0m                 \u001b[0;31m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    707\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[call-arg]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 708\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    709\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_yielded\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    710\u001b[0m             if (\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1456\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1457\u001b[0m             \u001b[0;32massert\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_shutdown\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tasks_outstanding\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1458\u001b[0;31m             \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1459\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tasks_outstanding\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1460\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_get_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1408\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1409\u001b[0m             \u001b[0;32mwhile\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory_thread\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_alive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1410\u001b[0;31m                 \u001b[0msuccess\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_try_get_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1411\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0msuccess\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1412\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_try_get_data\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m   1249\u001b[0m         \u001b[0;31m#   (bool: whether successfully get data, any: data if successful else None)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1250\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1251\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_data_queue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1252\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1253\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/lib/python3.11/queue.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, block, timeout)\u001b[0m\n\u001b[1;32m    178\u001b[0m                     \u001b[0;32mif\u001b[0m \u001b[0mremaining\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    179\u001b[0m                         \u001b[0;32mraise\u001b[0m \u001b[0mEmpty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnot_empty\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mremaining\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    181\u001b[0m             \u001b[0mitem\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    182\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnot_full\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnotify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/lib/python3.11/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    329\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    330\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 331\u001b[0;31m                     \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    332\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    333\u001b[0m                     \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "],"ename":"KeyboardInterrupt","evalue":"","output_type":"error"}],"execution_count":16},{"cell_type":"code","source":"# ============================\n# Inference for 15-class R3D18 model (1 live + 14 spoof types)\n# ============================\n\nimport os\nimport cv2\nimport torch\nimport torch.nn as nn\nimport pandas as pd\nfrom torchvision import transforms, models\nfrom tqdm import tqdm\nimport numpy as np\nfrom PIL import Image\n\n# ========================\n# 1️⃣ Config\n# ========================\nVIDEO_DIR = \"/kaggle/input/testcv-final/publics_test\"    # thư mục chứa video .mp4\nCSV_PATH = \"/kaggle/input/testcsvfinal/OLP_AI_test.csv\"\nMODEL_PATH = \"/kaggle/working/fas_15class/best_r3d18.pth\"  # Đường dẫn model 15-class\nOUTPUT_CSV = \"/kaggle/working/predictions_15class.csv\"\n\nFRAMES_PER_CLIP = 16\nFRAME_SIZE = 112\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n# ========================\n# 2️⃣ Class names (15 classes - giống training của bạn)\n# ========================\nCLASS_NAMES = [\n    \"live\",                    # 0 - Real faces\n    \"Partial_Funnyeye\",        # 1 - Spoof\n    \"Paper\",                   # 2 - Spoof  \n    \"Replay\",                  # 3 - Spoof\n    \"Partial_Paperglass\",      # 4 - Spoof\n    \"Mask_Half\",               # 5 - Spoof\n    \"Makeup_Im\",               # 6 - Spoof\n    \"Mask_Trans\",              # 7 - Spoof\n    \"Partial_Eye\",             # 8 - Spoof\n    \"Makeup_Co\",               # 9 - Spoof\n    \"Mask_Mann\",               # 10 - Spoof\n    \"Partial_Mouth\",           # 11 - Spoof\n    \"Makeup_Ob\",               # 12 - Spoof\n    \"Mask_Paper\",              # 13 - Spoof\n    \"Mask_Silicone\"            # 14 - Spoof\n]\n\n# ========================\n# 3️⃣ Load model (15-class)\n# ========================\nmodel = models.video.r3d_18(pretrained=False)\nmodel.fc = nn.Linear(model.fc.in_features, len(CLASS_NAMES))  # 15 classes\nmodel = model.to(device)\n\n# Load checkpoint\ntry:\n    state_dict = torch.load(MODEL_PATH, map_location=device)\n    if \"model_state_dict\" in state_dict:\n        model.load_state_dict(state_dict[\"model_state_dict\"])\n    elif \"model_state\" in state_dict:\n        model.load_state_dict(state_dict[\"model_state\"])\n    elif \"state_dict\" in state_dict:\n        model.load_state_dict(state_dict[\"state_dict\"])\n    else:\n        model.load_state_dict(state_dict)\n    \n    print(\"✅ Model loaded successfully from:\", MODEL_PATH)\n    print(f\"🏷️  Model configured for {len(CLASS_NAMES)} classes\")\n    \nexcept Exception as e:\n    print(f\"❌ Error loading model: {e}\")\n    print(\"🔄 Trying alternative loading methods...\")\n    \n    # Thử các phương pháp load khác\n    try:\n        # Thử load trực tiếp\n        model.load_state_dict(torch.load(MODEL_PATH, map_location=device))\n        print(\"✅ Model loaded with direct method\")\n    except:\n        # Thử load với strict=False\n        model.load_state_dict(torch.load(MODEL_PATH, map_location=device), strict=False)\n        print(\"✅ Model loaded with strict=False\")\n\nmodel.eval()\n\n# ========================\n# 4️⃣ Transform (giống training)\n# ========================\ntransform = transforms.Compose([\n    transforms.Resize((FRAME_SIZE, FRAME_SIZE)),\n    transforms.ToTensor(),\n    transforms.Normalize(mean=[0.45, 0.45, 0.45],\n                         std=[0.225, 0.225, 0.225])\n])\n\n# ========================\n# 5️⃣ Hàm đọc video -> tensor [C, T, H, W]\n# ========================\ndef load_video_clip(video_path, num_frames=FRAMES_PER_CLIP):\n    \"\"\"\n    Đọc video và trích xuất các frame để tạo clip\n    \"\"\"\n    cap = cv2.VideoCapture(video_path)\n    if not cap.isOpened():\n        print(f\"❌ Cannot open video: {video_path}\")\n        return None\n        \n    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n    frames = []\n\n    if total_frames <= 0:\n        print(f\"⚠️ Video has no frames: {video_path}\")\n        cap.release()\n        return None\n\n    # Chọn frame indices đều nhau\n    step = max(1, total_frames // num_frames)\n    frame_indices = list(range(0, total_frames, step))[:num_frames]\n\n    for i in frame_indices:\n        cap.set(cv2.CAP_PROP_POS_FRAMES, i)\n        ret, frame = cap.read()\n        if not ret:\n            # Nếu không đọc được frame, thử frame tiếp theo\n            continue\n            \n        # Chuyển BGR sang RGB\n        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n        frame = Image.fromarray(frame)\n        frame = transform(frame)  # [3, H, W]\n        frames.append(frame)\n        \n        if len(frames) == num_frames:\n            break\n\n    cap.release()\n\n    # Nếu không đọc được frame nào\n    if len(frames) == 0:\n        print(f\"❌ No frames read from: {video_path}\")\n        return None\n        \n    # Padding nếu thiếu frame (lặp lại frame cuối)\n    while len(frames) < num_frames:\n        frames.append(frames[-1])\n\n    # Stack frames -> [C, T, H, W]\n    clip = torch.stack(frames, dim=1)  \n    return clip\n\n# ========================\n# 6️⃣ Hàm dự đoán với xác suất\n# ========================\ndef predict_video(video_path, model, class_names):\n    \"\"\"\n    Dự đoán video và trả về label + confidence\n    \"\"\"\n    clip = load_video_clip(video_path)\n    if clip is None:\n        return None, 0.0\n\n    clip = clip.unsqueeze(0).to(device)  # [1, C, T, H, W]\n\n    with torch.no_grad():\n        logits = model(clip)\n        probabilities = torch.softmax(logits, dim=1)\n        confidence, pred_idx = torch.max(probabilities, dim=1)\n        \n        pred_idx = pred_idx.item()\n        confidence = confidence.item()\n\n    pred_label = class_names[pred_idx]\n    \n    return pred_label, confidence\n\n# ========================\n# 7️⃣ Load danh sách video test\n# ========================\nprint(\"📁 Loading test metadata...\")\ndf = pd.read_csv(CSV_PATH)\nprint(f\"📊 Total test samples: {len(df)}\")\n\n# Kiểm tra cấu trúc file CSV\nprint(\"📋 CSV columns:\", df.columns.tolist())\nprint(\"👀 First few rows:\")\nprint(df.head())\n\npredictions = []\nmissing_videos = []\n\n# ========================\n# 8️⃣ Inference loop\n# ========================\nprint(\"\\n🎯 Starting inference...\")\nfor _, row in tqdm(df.iterrows(), total=len(df)):\n    uuid = row[\"uuid\"]\n    video_name = row[\"filename\"]\n    video_path = os.path.join(VIDEO_DIR, video_name)\n\n    if not os.path.exists(video_path):\n        missing_videos.append(video_path)\n        continue\n\n    pred_label, confidence = predict_video(video_path, model, CLASS_NAMES)\n    \n    if pred_label is not None:\n        predictions.append({\n            \"uuid\": uuid,\n            \"filename\": video_name,\n            \"label_pred\": pred_label,\n            \"confidence\": confidence,\n            \"is_live\": 1 if pred_label == \"live\" else 0  # Binary output\n        })\n\n# ========================\n# 9️⃣ Thống kê kết quả\n# ========================\nprint(f\"\\n📊 INFERENCE RESULTS:\")\nprint(f\"✅ Processed: {len(predictions)} videos\")\nprint(f\"❌ Missing: {len(missing_videos)} videos\")\n\nif predictions:\n    pred_df = pd.DataFrame(predictions)\n    \n    # Thống kê phân bố dự đoán\n    print(f\"\\n🏷️ PREDICTION DISTRIBUTION:\")\n    pred_counts = pred_df['label_pred'].value_counts()\n    for label, count in pred_counts.items():\n        percentage = (count / len(pred_df)) * 100\n        print(f\"  {label:20}: {count:3} videos ({percentage:.1f}%)\")\n    \n    # Thống kê live vs spoof\n    live_count = len(pred_df[pred_df['is_live'] == 1])\n    spoof_count = len(pred_df[pred_df['is_live'] == 0])\n    print(f\"\\n🎯 LIVE vs SPOOF:\")\n    print(f\"  Live:  {live_count} videos ({(live_count/len(pred_df))*100:.1f}%)\")\n    print(f\"  Spoof: {spoof_count} videos ({(spoof_count/len(pred_df))*100:.1f}%)\")\n    \n    # Confidence statistics\n    print(f\"\\n📈 CONFIDENCE STATISTICS:\")\n    print(f\"  Average: {pred_df['confidence'].mean():.3f}\")\n    print(f\"  Std:     {pred_df['confidence'].std():.3f}\")\n    print(f\"  Min:     {pred_df['confidence'].min():.3f}\")\n    print(f\"  Max:     {pred_df['confidence'].max():.3f}\")\n\n# ========================\n# 🔟 Xuất CSV kết quả\n# ========================\nif predictions:\n    # Tạo DataFrame output\n    output_df = pd.DataFrame(predictions)\n    \n    # Chỉ giữ lại các cột cần thiết cho submission\n    submission_df = output_df[['uuid', 'label_pred']]\n    \n    # Lưu file đầy đủ thông tin\n    output_df.to_csv(OUTPUT_CSV, index=False)\n    \n    # Lưu file submission (chỉ uuid và label_pred)\n    submission_csv = OUTPUT_CSV.replace('.csv', '_submission.csv')\n    submission_df.to_csv(submission_csv, index=False)\n    \n    print(f\"\\n💾 RESULTS SAVED:\")\n    print(f\"  📄 Full results: {OUTPUT_CSV}\")\n    print(f\"  📤 Submission:   {submission_csv}\")\n    print(f\"\\n👀 First 10 predictions:\")\n    print(submission_df.head(10))\nelse:\n    print(\"❌ No predictions to save!\")\n\n# ========================\n# 🔢 Hiển thị video bị thiếu (nếu có)\n# ========================\nif missing_videos:\n    print(f\"\\n⚠️  MISSING VIDEOS ({len(missing_videos)}):\")\n    for i, missing_path in enumerate(missing_videos[:10]):  # Hiển thị 10 video đầu\n        print(f\"  {i+1:2}. {missing_path}\")\n    if len(missing_videos) > 10:\n        print(f\"  ... and {len(missing_videos) - 10} more\")\n\nprint(\"\\n✅ Inference completed!\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-10-19T03:42:11.954205Z","iopub.execute_input":"2025-10-19T03:42:11.954571Z","iopub.status.idle":"2025-10-19T04:05:33.408545Z","shell.execute_reply.started":"2025-10-19T03:42:11.954519Z","shell.execute_reply":"2025-10-19T04:05:33.407743Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n  warnings.warn(\n/usr/local/lib/python3.11/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=None`.\n  warnings.warn(msg)\n","output_type":"stream"},{"name":"stdout","text":"✅ Model loaded successfully from: /kaggle/working/fas_15class/best_r3d18.pth\n🏷️  Model configured for 15 classes\n📁 Loading test metadata...\n📊 Total test samples: 340\n📋 CSV columns: ['uuid', 'filename']\n👀 First few rows:\n                                   uuid                filename\n0  b5b0d53c-f271-49be-a9c6-db8eeb95688e            Paper_65.mp4\n1  3f261a5a-8246-4128-8ec6-a7f8b5b49bbb    Partial_Mouth_13.mp4\n2  50e3387b-19cb-44a7-b7de-728b06a3591b           Paper_104.mp4\n3  adf22d07-f101-4bff-8953-7c17e30bbdf1  Partial_Funnyeye_8.mp4\n4  bf422ed6-47af-4508-8423-e41e5d36c9ac        Makeup_Co_47.mp4\n\n🎯 Starting inference...\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 340/340 [23:20<00:00,  4.12s/it]","output_type":"stream"},{"name":"stdout","text":"\n📊 INFERENCE RESULTS:\n✅ Processed: 340 videos\n❌ Missing: 0 videos\n\n🏷️ PREDICTION DISTRIBUTION:\n  live                :  61 videos (17.9%)\n  Mask_Half           :  55 videos (16.2%)\n  Partial_Funnyeye    :  48 videos (14.1%)\n  Replay              :  31 videos (9.1%)\n  Paper               :  27 videos (7.9%)\n  Partial_Paperglass  :  27 videos (7.9%)\n  Makeup_Co           :  25 videos (7.4%)\n  Mask_Trans          :  15 videos (4.4%)\n  Makeup_Im           :  12 videos (3.5%)\n  Mask_Mann           :  11 videos (3.2%)\n  Partial_Mouth       :  10 videos (2.9%)\n  Partial_Eye         :   8 videos (2.4%)\n  Makeup_Ob           :   8 videos (2.4%)\n  Mask_Silicone       :   2 videos (0.6%)\n\n🎯 LIVE vs SPOOF:\n  Live:  61 videos (17.9%)\n  Spoof: 279 videos (82.1%)\n\n📈 CONFIDENCE STATISTICS:\n  Average: 0.630\n  Std:     0.302\n  Min:     0.136\n  Max:     1.000\n\n💾 RESULTS SAVED:\n  📄 Full results: /kaggle/working/predictions_15class.csv\n  📤 Submission:   /kaggle/working/predictions_15class_submission.csv\n\n👀 First 10 predictions:\n                                   uuid        label_pred\n0  b5b0d53c-f271-49be-a9c6-db8eeb95688e             Paper\n1  3f261a5a-8246-4128-8ec6-a7f8b5b49bbb     Partial_Mouth\n2  50e3387b-19cb-44a7-b7de-728b06a3591b             Paper\n3  adf22d07-f101-4bff-8953-7c17e30bbdf1  Partial_Funnyeye\n4  bf422ed6-47af-4508-8423-e41e5d36c9ac         Makeup_Co\n5  eb74dca2-355f-4c77-b0e0-e3527fe4834d         Mask_Half\n6  f0621591-d49a-4146-bf65-09ff1a321b5d             Paper\n7  96fcb251-221e-49ed-b4cc-180474fb049d       Partial_Eye\n8  bc0c9aa6-0714-4650-882f-27ce9cb16456         Makeup_Ob\n9  dc38b107-b951-455f-9176-15082c5e4987  Partial_Funnyeye\n\n✅ Inference completed!\n","output_type":"stream"},{"name":"stderr","text":"\n","output_type":"stream"}],"execution_count":19}]}