{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":87323,"databundleVersionId":9934427,"sourceType":"competition"},{"sourceId":10390663,"sourceType":"datasetVersion","datasetId":6437244}],"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"### Acknowledgements:\n\n- The majority of the code in this notebook was inspired by **[Ronak Bedi](https://www.kaggle.com/ronakbedi)** and their [notebook](https://www.kaggle.com/code/ronakbedi/classification-using-vision-transformers) 😁. I am incredibly grateful for the opportunity to learn and reflect on their work, which has allowed me to stand on their shoulders and make significant progress in my understanding. Thank you, @Ronak Bedi!\n\n---\n\n### Contributions in This Work:\n\n- Replaced **ViT** with **Swin Transformer** for the classification task.\n- Hyperparameter optimization.\n- Implemented **ReduceLROnPlateau** as the learning rate scheduler.\n- Achieved **train_loss** and **val_loss** of 0.0033 and 0.0004, respectively, after 50 epochs of training.\n![image.png](attachment:9cf48433-756e-4c04-b2c6-17ff935823c9.png)\n\nUnfortunately, despite these efforts, the final test submission did not show significant improvement 😅.\n\n---\n\n### Future Work:\n\n1. Incorporating **luminance feature fusion**.\n2. Performing **hyperparameter optimization**.\n3. Exploring more **data augmentation techniques**.\n\n","metadata":{},"attachments":{"9cf48433-756e-4c04-b2c6-17ff935823c9.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"### Swin Transformer: A Brief Introduction\n\nThe **Swin Transformer** (Shifted Window Transformer) is a state-of-the-art architecture designed for computer vision tasks, introduced by Microsoft Research. It improves upon traditional vision transformers (ViT) by addressing scalability and efficiency issues, making it suitable for high-resolution images and various vision tasks.\n\n---\n\n### Key Features:\n\n1. **Hierarchical Representation**:\n   - Unlike ViT's flat structure, Swin Transformer uses a hierarchical design similar to convolutional neural networks (CNNs). This structure enables it to capture both local and global features effectively.\n\n2. **Shifted Window Attention**:\n   - The core innovation is **shifted window attention**, which divides an image into non-overlapping windows for self-attention. In subsequent layers, the windows are shifted to capture cross-window connections, reducing computational complexity while retaining context.\n\n3. **Efficiency**:\n   - Swin Transformer scales linearly with image size, making it highly efficient for large images compared to traditional transformers.\n\n4. **Flexibility**:\n   - It serves as a backbone for various vision tasks such as image classification, object detection, and semantic segmentation.\n\n---\n\n### Applications:\n\n- **Image Classification**: Achieves competitive performance on benchmarks like ImageNet.\n- **Object Detection**: Serves as the backbone in models like Mask R-CNN for detecting objects in images.\n- **Semantic Segmentation**: Used in tasks requiring pixel-level understanding, such as segmentation of medical images or road scenes.\n\n### Example Achievements:\n- Outperformed traditional CNNs and other transformer-based architectures in multiple vision benchmarks with a better trade-off between accuracy and efficiency.\n\nSwin Transformer represents a significant step forward in adapting transformer architectures to visual data, bridging the gap between transformers and CNNs in terms of computational efficiency and scalability.","metadata":{}},{"cell_type":"code","source":"import os\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import roc_auc_score\nfrom torchvision import transforms\nfrom torch.utils.data import Dataset, DataLoader\nfrom transformers import ViTForImageClassification, ViTFeatureExtractor\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom PIL import Image","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-01-15T13:12:35.603971Z","iopub.execute_input":"2025-01-15T13:12:35.604308Z","iopub.status.idle":"2025-01-15T13:12:51.223906Z","shell.execute_reply.started":"2025-01-15T13:12:35.604273Z","shell.execute_reply":"2025-01-15T13:12:51.223241Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class CustomDataset(Dataset):\n    def __init__(self, image_paths, labels=None, transform=None):\n        \"\"\"\n        Args:\n            image_paths (list): List of image file paths.\n            labels (list, optional): List of labels corresponding to the images.\n            transform (callable, optional): Transform to be applied to the images.\n        \"\"\"\n        self.image_paths = image_paths\n        self.labels = labels\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.image_paths)\n\n    def __getitem__(self, idx):\n        img_path = self.image_paths[idx]\n        image = Image.open(img_path).convert(\"RGB\")\n        if self.transform:\n            image = self.transform(image)\n\n        if self.labels is not None:\n            label = self.labels[idx]\n            return image, torch.tensor(label, dtype=torch.float32)\n        else:\n            return image, os.path.basename(img_path)  # For test set","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-01-15T13:12:51.224988Z","iopub.execute_input":"2025-01-15T13:12:51.225513Z","iopub.status.idle":"2025-01-15T13:12:51.230607Z","shell.execute_reply.started":"2025-01-15T13:12:51.225488Z","shell.execute_reply":"2025-01-15T13:12:51.229800Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from transformers import SwinForImageClassification\nfrom torch.optim.lr_scheduler import ReduceLROnPlateau\n\ndef train_vit_model(train_loader, val_loader, device, epochs=10, lr=5e-5):\n    \"\"\"Trains the Swin Transformer model.\"\"\"\n\n    model = SwinForImageClassification.from_pretrained(\n    \"microsoft/swin-base-patch4-window7-224\",  # Swin transformer model\n    num_labels=1,\n    problem_type=\"binary_classification\",\n    ignore_mismatched_sizes=True\n    \n    )\n    model.to(device)\n\n\n    # Loss and optimizer\n    criterion = nn.BCEWithLogitsLoss()\n\n\n    optimizer = optim.AdamW(model.parameters(), \n                            lr=lr,  \n                            weight_decay=0.01)\n    \n\n    \n    # 定义学习率调度器\n    lr_scheduler = ReduceLROnPlateau(\n        optimizer,             \n        mode='min',            \n        factor=0.1,            \n        patience=3,            \n        verbose=True,         \n        threshold=1e-4,        \n        threshold_mode='abs',  \n        min_lr=1e-6            \n    )\n\n    best_auc = 0\n    for epoch in range(epochs):\n        # Training\n        model.train()\n        train_loss = 0\n        for images, labels in train_loader:\n            images, labels = images.to(device), labels.to(device)\n            optimizer.zero_grad()\n            outputs = model(images).logits.squeeze()\n            loss = criterion(outputs, labels)\n            loss.backward()\n            optimizer.step()\n            train_loss += loss.item()\n        # Validation\n        model.eval()\n        val_loss = 0\n        all_labels = []\n        all_preds = []\n        with torch.no_grad():\n            for images, labels in val_loader:\n                images, labels = images.to(device), labels.to(device)\n                outputs = model(images).logits.squeeze()\n                loss = criterion(outputs, labels)\n                val_loss += loss.item()\n                all_labels.extend(labels.cpu().numpy())\n                all_preds.extend(torch.sigmoid(outputs).cpu().numpy())\n\n        val_auc = roc_auc_score(all_labels, all_preds)\n        print(f\"Epoch {epoch + 1}/{epochs} | Train Loss: {train_loss / len(train_loader):.4f} | \"\n              f\"Val Loss: {val_loss / len(val_loader):.4f} | Val AUC: {val_auc:.4f}\")\n\n        lr_scheduler.step(val_loss)\n        \n        # Save best model\n        if val_auc > best_auc:\n            best_auc = val_auc\n            torch.save(model.state_dict(), \"best_vit_model.pth\")\n\n    return model\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-01-15T13:12:51.232206Z","iopub.execute_input":"2025-01-15T13:12:51.232493Z","iopub.status.idle":"2025-01-15T13:12:51.257226Z","shell.execute_reply.started":"2025-01-15T13:12:51.232467Z","shell.execute_reply":"2025-01-15T13:12:51.256387Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def predict_with_vit(model, test_loader, device, submission_path):\n    \"\"\"Generates predictions using the trained ViT model.\"\"\"\n    model.eval()\n    predictions = []\n    image_names = []\n    with torch.no_grad():\n        for images, names in test_loader:\n            images = images.to(device)\n            outputs = model(images).logits.squeeze()\n            predictions.extend(torch.sigmoid(outputs).cpu().numpy())\n            image_names.extend(names)\n\n    # Save submission file\n    submission_df = pd.DataFrame({\n        \"image\": image_names,\n        \"label\": predictions\n    })\n    submission_df.to_csv(submission_path, index=False)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-01-15T13:12:51.258266Z","iopub.execute_input":"2025-01-15T13:12:51.258547Z","iopub.status.idle":"2025-01-15T13:12:51.263374Z","shell.execute_reply.started":"2025-01-15T13:12:51.258518Z","shell.execute_reply":"2025-01-15T13:12:51.262727Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"if __name__ == \"__main__\":\n    # Configuration\n    TRAIN_DIR = \"/kaggle/input/cidaut-ai-fake-scene-classification-2024/Train\"\n    TEST_DIR = \"/kaggle/input/cidaut-ai-fake-scene-classification-2024/Test\"\n    LABELS_PATH = \"/kaggle/input/fvsvdvs/train.csv\"  \n    BATCH_SIZE = 32\n    EPOCHS = 50\n    IMG_SIZE = 224\n    DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n    # Read labels\n    df_labels = pd.read_csv(LABELS_PATH)\n    image_paths = [os.path.join(TRAIN_DIR, img) for img in df_labels[\"image\"]]\n    labels = df_labels[\"label\"].astype(float).values\n\n    # Split data\n    train_paths, val_paths, train_labels, val_labels = train_test_split(\n        image_paths, labels, test_size=0.2, random_state=42\n    )\n\n    # Transformations\n    train_transform = transforms.Compose([\n        transforms.Resize((IMG_SIZE, IMG_SIZE)),\n        transforms.RandomHorizontalFlip(0.8),\n        transforms.ToTensor(),\n        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n    ])\n    \n    val_transform = transforms.Compose([\n        transforms.Resize((IMG_SIZE, IMG_SIZE)),\n        transforms.ToTensor(),\n        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n    ])\n\n    # Create datasets and loaders\n    train_dataset = CustomDataset(train_paths, train_labels, transform=train_transform)\n    val_dataset = CustomDataset(val_paths, val_labels, transform=val_transform)\n    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)\n\n    # Train the model\n    vit_model = train_vit_model(train_loader, val_loader, DEVICE, epochs=EPOCHS)\n\n    # Prepare test dataset and loader\n    test_files = sorted([f for f in os.listdir(TEST_DIR) if f.endswith(\".jpg\")])\n    test_paths = [os.path.join(TEST_DIR, f) for f in test_files]\n    test_dataset = CustomDataset(test_paths, transform=val_transform)\n    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)\n\n    # Predict and save submission\n    predict_with_vit(vit_model, test_loader, DEVICE, \"submission.csv\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-01-15T13:12:51.264075Z","iopub.execute_input":"2025-01-15T13:12:51.264277Z","iopub.status.idle":"2025-01-15T13:39:26.148587Z","shell.execute_reply.started":"2025-01-15T13:12:51.264243Z","shell.execute_reply":"2025-01-15T13:39:26.147623Z"}},"outputs":[],"execution_count":null}]}