{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.11","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":10384,"databundleVersionId":120379,"sourceType":"competition"},{"sourceId":11949195,"sourceType":"datasetVersion","datasetId":7512250}],"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2025-05-24T23:44:50.11549Z","iopub.status.idle":"2025-05-24T23:44:50.116256Z","shell.execute_reply.started":"2025-05-24T23:44:50.115666Z","shell.execute_reply":"2025-05-24T23:44:50.115682Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Using Approach of Paper 2 ","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torchvision.models as models\nfrom torch.utils.data import Dataset, DataLoader\nimport matplotlib.pyplot as plt\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import MinMaxScaler\nfrom tqdm import tqdm\nimport cv2\nimport os\n\n# --- Dataset Definition ---\nclass LightCurveDataset(Dataset):\n    def __init__(self, meta_df, lc_df, label_map=None, mode='train'):\n        self.meta = meta_df\n        self.lc = lc_df\n        self.label_map = label_map\n        self.mode = mode\n        self.object_ids = meta_df['object_id'].values\n\n    def __len__(self):\n        return len(self.object_ids)\n\n    def __getitem__(self, idx):\n        obj_id = self.object_ids[idx]\n        obj_meta = self.meta[self.meta['object_id'] == obj_id].iloc[0]\n        obj_lc = self.lc[self.lc['object_id'] == obj_id]\n\n        # Normalize and generate LC image\n        mjd = obj_lc['mjd'].values\n        flux = obj_lc['flux'].values\n        img = np.zeros((256, 512))\n        if len(mjd) > 1:\n            mjd = MinMaxScaler().fit_transform(mjd.reshape(-1, 1)).flatten()\n            flux = MinMaxScaler().fit_transform(flux.reshape(-1, 1)).flatten()\n            for x, y in zip(mjd, flux):\n                ix = int(x * (img.shape[1] - 1))\n                iy = int((1 - y) * (img.shape[0] - 1))\n                img[iy, ix] = 1.0\n\n        img_tensor = torch.tensor(img, dtype=torch.float32).unsqueeze(0)  # [1, H, W]\n\n        if self.mode == 'train':\n            label = int(obj_meta['label'])  # previously obj_meta['target']\n  # Ensure integer key\n         \n\n            return img_tensor, torch.tensor(label, dtype=torch.long)\n        else:\n            return img_tensor, obj_id\n\n# --- Model ---\nclass DeepLCNet(nn.Module):\n    def __init__(self, num_classes):\n        super().__init__()\n        self.resnet = models.resnet18(pretrained=True)\n        self.resnet.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)\n        self.resnet.fc = nn.Linear(512, num_classes)\n\n    def forward(self, x):\n        return self.resnet(x)\n\n# --- Training ---\ndef train_model(model, train_loader, val_loader, classes, device, epochs=50):\n    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\n    criterion = nn.CrossEntropyLoss()\n    model.to(device)\n\n    for epoch in range(epochs):\n        model.train()\n        total_loss = 0\n        for x, y in tqdm(train_loader, desc=f\"Epoch {epoch+1}\"):\n            x, y = x.to(device), y.to(device)\n            optimizer.zero_grad()\n            output = model(x)\n            loss = criterion(output, y)\n            loss.backward()\n            optimizer.step()\n            total_loss += loss.item()\n        print(f\"Epoch {epoch+1}, Loss: {total_loss/len(train_loader):.4f}\")\n        evaluate_model(model, val_loader, device, classes)\n\n\n# --- Evaluation ---\nfrom sklearn.metrics import classification_report, confusion_matrix, accuracy_score\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n\ndef evaluate_model(model, val_loader, device, classes):\n    model.eval()\n    y_true, y_pred = [], []\n\n    with torch.no_grad():\n        for x, y in val_loader:\n            x = x.to(device)\n            logits = model(x)\n            preds = torch.argmax(logits, dim=1).cpu().numpy()\n            y_pred.extend(preds)\n            y_true.extend(y.numpy())\n\n    acc = accuracy_score(y_true, y_pred)\n    print(f\"\\n📊 Validation Accuracy: {acc:.4f}\\n\")\n    print(\"📋 Classification Report:\")\n    print(classification_report(y_true, y_pred, digits=4))\n\n    # Confusion Matrix\n    cm = confusion_matrix(y_true, y_pred, labels=range(len(classes)))\n    plt.figure(figsize=(10, 8))\n    sns.heatmap(cm, annot=True, fmt='d', cmap=\"Blues\", xticklabels=classes, yticklabels=classes)\n    plt.title(\"Confusion Matrix\")\n    plt.xlabel(\"Predicted\")\n    plt.ylabel(\"True\")\n    plt.show()\n\n\n# --- Inference ---\ndef predict_test(model, test_loader, label_map, device):\n    model.eval()\n    rev_map = {v: k for k, v in label_map.items()}\n    pred_dict = {}\n\n    with torch.no_grad():\n        for x, obj_ids in tqdm(test_loader, desc=\"Predicting\"):\n            x = x.to(device)\n            preds = F.softmax(model(x), dim=1).cpu().numpy()\n            for i, obj_id in enumerate(obj_ids):\n                pred_dict[int(obj_id)] = preds[i]\n\n    submission = pd.DataFrame.from_dict(pred_dict, orient='index')\n    submission.columns = [f'class_{rev_map[i]}' for i in range(len(rev_map))]\n    submission['class_99'] = 1 - submission.max(axis=1)\n    submission.insert(0, 'object_id', submission.index)\n    submission.to_csv(\"submission.csv\", index=False)\n    print(\"submission.csv saved!\")\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-24T23:46:11.428728Z","iopub.execute_input":"2025-05-24T23:46:11.42899Z","iopub.status.idle":"2025-05-24T23:46:11.445021Z","shell.execute_reply.started":"2025-05-24T23:46:11.428965Z","shell.execute_reply":"2025-05-24T23:46:11.444367Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# --- Main ---\nif __name__ == \"__main__\":\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n    # Load full training data\n    meta = pd.read_csv(\"/kaggle/input/PLAsTiCC-2018/training_set_metadata.csv\")\n    lc = pd.read_csv(\"/kaggle/input/PLAsTiCC-2018/training_set.csv\")\n\n    # Build label map\n    original_classes = sorted(meta['target'].unique())\n    label_map = {cls: i for i, cls in enumerate(original_classes)}\n    inverse_label_map = {i: cls for cls, i in label_map.items()}\n    meta['label'] = meta['target'].map(label_map)\n\n    # ⚠️ Phase 1: Only focus on training set, split it 85:15\n    train_meta, val_meta = train_test_split(\n        meta, test_size=0.15, stratify=meta['label'], random_state=42\n    )\n\n    # Prepare datasets and loaders\n    train_ds = LightCurveDataset(train_meta, lc, label_map, mode='train')\n    val_ds = LightCurveDataset(val_meta, lc, label_map, mode='train')\n\n    train_loader = DataLoader(train_ds, batch_size=32, shuffle=True, num_workers=2)\n    val_loader = DataLoader(val_ds, batch_size=32, shuffle=False, num_workers=2)\n\n    # Initialize and train the model\n    model = DeepLCNet(num_classes=len(label_map))\n    train_model(model, train_loader, val_loader, original_classes, device, epochs=50)\n\n    # Evaluate on held-out 15% set (offline evaluation)\n    evaluate_model(model, val_loader, device, original_classes)\n\n    # ⚠️ No inference on actual test set in Phase 1\n    # test_meta = pd.read_csv(\"/kaggle/input/plasticc/test_metadata.csv\")\n    # test_lc = pd.read_csv(\"/kaggle/input/plasticc/test.csv\")\n    # test_ds = LightCurveDataset(test_meta, test_lc, label_map, mode='test')\n    # test_loader = DataLoader(test_ds, batch_size=32, shuffle=False, num_workers=2)\n    # predict_test(model, test_loader, label_map, device)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-24T23:46:16.721692Z","iopub.execute_input":"2025-05-24T23:46:16.722367Z","execution_failed":"2025-05-25T00:44:27.717Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Above code doesn't give good results. So try with same approach but with different resnet blocks.**","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torchvision.models as models\nimport torchvision.transforms as transforms\nfrom torchvision.models import ResNet50_Weights\nfrom torch.utils.data import Dataset, DataLoader\nimport matplotlib.pyplot as plt\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import MinMaxScaler\nfrom sklearn.metrics import classification_report, confusion_matrix, accuracy_score, log_loss\nimport seaborn as sns\nfrom tqdm import tqdm\nimport cv2\n\n# --- Dataset ---\nclass LightCurveDataset(Dataset):\n    def __init__(self, meta_df, lc_df, label_map=None, mode='train'):\n        self.meta = meta_df\n        self.lc = lc_df\n        self.label_map = label_map\n        self.mode = mode\n        self.object_ids = meta_df['object_id'].values\n\n        if self.mode == 'train':\n            self.augment = transforms.Compose([\n                transforms.ToPILImage(),\n                transforms.Resize((288, 576)),\n                transforms.RandomRotation(10),\n                transforms.RandomCrop((256, 512)),\n                transforms.ToTensor(),\n            ])\n        else:\n            self.augment = transforms.Compose([\n                transforms.ToPILImage(),\n                transforms.Resize((256, 512)),\n                transforms.ToTensor(),\n            ])\n\n    def __len__(self):\n        return len(self.object_ids)\n\n    def __getitem__(self, idx):\n        obj_id = self.object_ids[idx]\n        obj_meta = self.meta[self.meta['object_id'] == obj_id].iloc[0]\n        obj_lc = self.lc[self.lc['object_id'] == obj_id]\n\n        mjd = obj_lc['mjd'].values\n        flux = obj_lc['flux'].values\n        img = np.zeros((256, 512), dtype=np.uint8)\n\n        if len(mjd) > 1:\n            mjd = MinMaxScaler().fit_transform(mjd.reshape(-1, 1)).flatten()\n            flux = MinMaxScaler().fit_transform(flux.reshape(-1, 1)).flatten()\n            for x, y in zip(mjd, flux):\n                ix = int(x * (img.shape[1] - 1))\n                iy = int((1 - y) * (img.shape[0] - 1))\n                img[iy, ix] = 255\n\n        img = np.stack([img], axis=0).squeeze(0)\n        img_tensor = self.augment(img)\n\n        if self.mode == 'train':\n            label = int(obj_meta['label'])\n            return img_tensor, torch.tensor(label, dtype=torch.long)\n        else:\n            return img_tensor, obj_id\n\n# --- Model ---\nclass DeepLCNet(nn.Module):\n    def __init__(self, num_classes):\n        super().__init__()\n        self.resnet = models.resnet50(weights=ResNet50_Weights.DEFAULT)\n        self.resnet.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)\n        self.resnet.fc = nn.Sequential(\n            nn.Linear(2048, 512),\n            nn.BatchNorm1d(512),\n            nn.ReLU(),\n            nn.Dropout(0.4),\n            nn.Linear(512, 128),\n            nn.BatchNorm1d(128),\n            nn.ReLU(),\n            nn.Dropout(0.4),\n            nn.Linear(128, num_classes)\n        )\n\n    def forward(self, x):\n        return self.resnet(x)\n\n# --- Training ---\ndef train_model(model, train_loader, val_loader, classes, device, epochs=10):\n    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\n    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)\n    criterion = nn.CrossEntropyLoss()\n    model.to(device)\n\n    for epoch in range(epochs):\n        model.train()\n        total_loss = 0\n        for x, y in tqdm(train_loader, desc=f\"Epoch {epoch+1}\"):\n            x, y = x.to(device), y.to(device)\n            optimizer.zero_grad()\n            output = model(x)\n            loss = criterion(output, y)\n            loss.backward()\n            optimizer.step()\n            total_loss += loss.item()\n        scheduler.step()\n\n        print(f\"Epoch {epoch+1}, Train Loss: {total_loss/len(train_loader):.4f}\")\n        evaluate_model(model, val_loader, device, classes)\n\n# --- Evaluation ---\ndef evaluate_model(model, val_loader, device, classes):\n    model.eval()\n    y_true, y_pred_labels, y_pred_probs = [], [], []\n\n    with torch.no_grad():\n        for x, y in val_loader:\n            x = x.to(device)\n            logits = model(x)\n            probs = F.softmax(logits, dim=1).cpu().numpy()\n            preds = np.argmax(probs, axis=1)\n\n            y_pred_labels.extend(preds)\n            y_pred_probs.extend(probs)\n            y_true.extend(y.numpy())\n\n    acc = accuracy_score(y_true, y_pred_labels)\n    logloss = log_loss(y_true, y_pred_probs)\n    print(f\"\\n✅ Validation Accuracy: {acc:.4f}\")\n    print(f\"🧮 Log Loss: {logloss:.4f}\")\n    print(\"📋 Classification Report:\")\n    print(classification_report(y_true, y_pred_labels, digits=4))\n\n    cm = confusion_matrix(y_true, y_pred_labels, labels=range(len(classes)))\n    plt.figure(figsize=(10, 8))\n    sns.heatmap(cm, annot=True, fmt='d', cmap=\"Blues\", xticklabels=classes, yticklabels=classes)\n    plt.title(\"Confusion Matrix\")\n    plt.xlabel(\"Predicted\")\n    plt.ylabel(\"True\")\n    plt.show()\n\n# --- Main ---\nif __name__ == \"__main__\":\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n    meta = pd.read_csv(\"/kaggle/input/PLAsTiCC-2018/training_set_metadata.csv\")\n    lc = pd.read_csv(\"/kaggle/input/PLAsTiCC-2018/training_set.csv\")\n\n    original_classes = sorted(meta['target'].unique())\n    label_map = {cls: i for i, cls in enumerate(original_classes)}\n    meta['label'] = meta['target'].map(label_map)\n\n    # Phase 1: offline evaluation on train split\n    train_meta, val_meta = train_test_split(\n        meta, test_size=0.15, stratify=meta['label'], random_state=42\n    )\n\n    train_ds = LightCurveDataset(train_meta, lc, label_map, mode='train')\n    val_ds = LightCurveDataset(val_meta, lc, label_map, mode='train')\n\n    train_loader = DataLoader(train_ds, batch_size=32, shuffle=True, num_workers=2)\n    val_loader = DataLoader(val_ds, batch_size=32, shuffle=False, num_workers=2)\n\n    model = DeepLCNet(num_classes=len(label_map))\n    train_model(model, train_loader, val_loader, original_classes, device, epochs=10)\n\n    # Final evaluation\n    evaluate_model(model, val_loader, device, original_classes)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-25T12:53:26.855072Z","iopub.execute_input":"2025-05-25T12:53:26.855444Z","iopub.status.idle":"2025-05-25T13:21:09.806776Z","shell.execute_reply.started":"2025-05-25T12:53:26.855417Z","shell.execute_reply":"2025-05-25T13:21:09.806054Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Both methods giving accuracy of 50 to 60 percent. so we try a new model named as \"HistGradientBoostingClassifier\"**","metadata":{}},{"cell_type":"code","source":"import pandas as pd, numpy as np\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import StratifiedKFold, train_test_split\nfrom sklearn.metrics import classification_report, log_loss, accuracy_score\n\n# --- Load data (example file paths) ---\nlc = pd.read_csv('/kaggle/input/PLAsTiCC-2018/training_set.csv')   # has object_id,mjd,passband,flux,flux_err,detected\nmeta = pd.read_csv('/kaggle/input/PLAsTiCC-2018/training_set_metadata.csv')   # has object_id, ra,dec,gal_l,gal_b,hostgal_photoz,...,target\n\n# --- Group by object and compute features ---\ngroups = lc.groupby('object_id')\nfeatures = []\nfor oid, grp in groups:\n    feat = {'object_id': oid}\n    # Basic stats\n    flux = grp['flux']\n    feat['flux_mean'] = flux.mean()\n    feat['flux_std']  = flux.std()\n    feat['flux_max']  = flux.max()\n    feat['flux_min']  = flux.min()\n    feat['duration']  = grp['mjd'].max() - grp['mjd'].min()\n    feat['count']     = len(grp)\n    # Count of detections\n    feat['n_detections'] = grp['detected'].sum()\n    # Per-passband stats\n    for pb in range(6):\n        pb_grp = grp[grp['passband']==pb]['flux']\n        feat[f'flux_mean_pb{pb}'] = pb_grp.mean() if len(pb_grp)>0 else 0.0\n        feat[f'flux_std_pb{pb}']  = pb_grp.std() if len(pb_grp)>0 else 0.0\n        feat[f'count_pb{pb}']     = len(pb_grp)\n    features.append(feat)\nX_feats = pd.DataFrame(features).fillna(0.0)\n\n# Merge with metadata and labels\ndata = X_feats.merge(meta, on='object_id')\ny = data.pop('target')\nX = data.drop(columns=['object_id'])\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import classification_report, log_loss, accuracy_score\n\n# Split into train/test (stratified)\nX_train, X_val, y_train, y_val = train_test_split(\n    X, y, test_size=0.2, stratify=y, random_state=42\n)\nfrom sklearn.ensemble import HistGradientBoostingClassifier\n\nmodel = HistGradientBoostingClassifier(random_state=1)\nmodel.fit(X_train, y_train)\n\n\n# Predict on validation\ny_pred = model.predict(X_val)\ny_prob = model.predict_proba(X_val)\n\n# Evaluate\nprint(\"Validation accuracy: %.3f\" % accuracy_score(y_val, y_pred))\nprint(\"Validation log-loss: %.3f\" % log_loss(y_val, y_prob))\nprint(\"\\nClassification report:\")\nprint(classification_report(y_val, y_pred))\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-25T14:58:43.108493Z","iopub.execute_input":"2025-05-25T14:58:43.109201Z","iopub.status.idle":"2025-05-25T14:59:07.345019Z","shell.execute_reply.started":"2025-05-25T14:58:43.109177Z","shell.execute_reply":"2025-05-25T14:59:07.344429Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Using HistGradientBoostingClassifier for Testing data**","metadata":{}},{"cell_type":"code","source":"import pandas as pd, numpy as np\nfrom sklearn.ensemble import HistGradientBoostingClassifier\nfrom tqdm import tqdm\nimport os\n\n# --- Step 1: Train the model on full training data ---\nprint(\"Training on full training set...\")\nlc_train = pd.read_csv('/kaggle/input/PLAsTiCC-2018/training_set.csv')\nmeta_train = pd.read_csv('/kaggle/input/PLAsTiCC-2018/training_set_metadata.csv')\n\n# Feature extraction function\ndef extract_features(grp):\n    feat = {}\n    flux = grp['flux']\n    feat['flux_mean'] = flux.mean()\n    feat['flux_std']  = flux.std()\n    feat['flux_max']  = flux.max()\n    feat['flux_min']  = flux.min()\n    feat['duration']  = grp['mjd'].max() - grp['mjd'].min()\n    feat['count']     = len(grp)\n    feat['n_detections'] = grp['detected'].sum()\n    for pb in range(6):\n        pb_grp = grp[grp['passband']==pb]['flux']\n        feat[f'flux_mean_pb{pb}'] = pb_grp.mean() if len(pb_grp)>0 else 0.0\n        feat[f'flux_std_pb{pb}']  = pb_grp.std() if len(pb_grp)>0 else 0.0\n        feat[f'count_pb{pb}']     = len(pb_grp)\n    return feat\n\n# Extract features for training set\ngroups = lc_train.groupby('object_id')\ntrain_features = []\nfor oid, grp in tqdm(groups):\n    feat = {'object_id': oid}\n    feat.update(extract_features(grp))\n    train_features.append(feat)\nX_feats = pd.DataFrame(train_features).fillna(0.0)\n\n# Merge with metadata\ndata = X_feats.merge(meta_train, on='object_id')\ny_train = data.pop('target')\nX_train = data.drop(columns=['object_id'])\n\n# Train model\nmodel = HistGradientBoostingClassifier(random_state=1)\nmodel.fit(X_train, y_train)\n\n# --- Step 2: Predict on batched test files ---\nprint(\"Processing test batches...\")\nmeta_test = pd.read_csv('/kaggle/input/PLAsTiCC-2018/test_set_metadata.csv')\ntest_batches = [f\"/kaggle/input/PLAsTiCC-2018/test_set_batch{i}.csv\" for i in range(1, 12)]\n\nsubmission_rows = []\n\nfor batch_path in tqdm(test_batches):\n    test_df = pd.read_csv(batch_path)\n    batch_results = []\n\n    for oid, grp in test_df.groupby('object_id'):\n        feat = extract_features(grp)\n        feat['object_id'] = oid\n        batch_results.append(feat)\n\n    X_test_feats = pd.DataFrame(batch_results).fillna(0.0)\n\n    # Merge with test metadata\n    merged = X_test_feats.merge(meta_test, on='object_id')\n    object_ids = merged['object_id']\n    X_test = merged.drop(columns=['object_id'])\n\n    # Predict\n    y_pred = model.predict(X_test)\n\n    # Collect predictions\n    submission_rows.extend(zip(object_ids, y_pred))\n\n# --- Step 3: Write final submission ---\nsubmission_df = pd.DataFrame(submission_rows, columns=['object_id', 'target'])\nsubmission_df.to_csv('submission.csv', index=False)\nprint(\"✅ submission.csv saved.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-25T15:19:43.833283Z","iopub.execute_input":"2025-05-25T15:19:43.833544Z","iopub.status.idle":"2025-05-25T17:26:59.931735Z","shell.execute_reply.started":"2025-05-25T15:19:43.833523Z","shell.execute_reply":"2025-05-25T17:26:59.93113Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Changing Format of submission file according to Kaggle Format.**","metadata":{}},{"cell_type":"code","source":"import pandas as pd\n\n# Load your original submission (predicted targets)\nsubmission = pd.read_csv(\"/kaggle/input/submissionfile/submission.csv\")  # has 'object_id' and 'target'\n\n# Load sample submission to get correct class structure\nsample_submission = pd.read_csv(\"/kaggle/input/PLAsTiCC-2018/sample_submission.csv\")\nclass_cols = [col for col in sample_submission.columns if col != 'object_id']\n\n# Initialize a new submission with all zeros\nnew_submission = pd.DataFrame(0.0, index=submission.index, columns=class_cols)\nnew_submission.insert(0, 'object_id', submission['object_id'])\n\n# Set predicted class column to 1.0 for each object\nfor i, row in submission.iterrows():\n    class_name = f'class_{int(row[\"target\"])}'\n    if class_name in new_submission.columns:\n        new_submission.at[i, class_name] = 1.0\n    else:\n        # Predicted class not in known classes (very rare), assign 1.0 to class_99\n        new_submission.at[i, 'class_99'] = 1.0\n\n# Save final reformatted submission\nnew_submission.to_csv(\"submission.csv\", index=False)\nprint(\"✅ Reformatted submission saved as 'submission.csv'\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-25T20:54:19.76194Z","iopub.execute_input":"2025-05-25T20:54:19.762479Z","iopub.status.idle":"2025-05-25T20:58:14.570298Z","shell.execute_reply.started":"2025-05-25T20:54:19.762444Z","shell.execute_reply":"2025-05-25T20:58:14.569433Z"}},"outputs":[],"execution_count":null}]}