{"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":"nvidiaTeslaT4","dataSources":[{"sourceId":39763,"databundleVersionId":11756775,"sourceType":"competition"},{"sourceId":11568812,"sourceType":"datasetVersion","datasetId":7253205},{"sourceId":11569667,"sourceType":"datasetVersion","datasetId":7253605},{"sourceId":11569755,"sourceType":"datasetVersion","datasetId":7253661},{"sourceId":12038896,"sourceType":"datasetVersion","datasetId":7377931}],"dockerImageVersionId":31041,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"RUN_VALID = True\nRUN_TEST  = True\n\nimport torch\nif not torch.cuda.is_available() or torch.cuda.device_count() < 2:\n    raise RuntimeError(\"Requires >= 2 GPUs with CUDA enabled.\")\n\ntry: \n    import monai\nexcept: \n    !pip install --no-deps monai -q","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2025-06-05T10:02:52.757475Z","iopub.execute_input":"2025-06-05T10:02:52.757626Z","iopub.status.idle":"2025-06-05T10:03:06.697786Z","shell.execute_reply.started":"2025-06-05T10:02:52.757611Z","shell.execute_reply":"2025-06-05T10:03:06.696753Z"}},"outputs":[{"name":"stdout","text":"\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.5/1.5 MB\u001b[0m \u001b[31m18.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n\u001b[?25h","output_type":"stream"}],"execution_count":1},{"cell_type":"markdown","source":"# Caformer Improved Notebook\n\nThis is the final notebook I will release in this competition. I recommend reading the previous notebooks, as many components are reused.\n\n1. [HGNet-V2 - Starter](https://www.kaggle.com/code/brendanartley/hgnet-v2-starter)\n2. [ConvNeXt - Full Resolution Baseline](https://www.kaggle.com/code/brendanartley/convnext-full-resolution-baseline)\n3. [CAFormer - Full Resolution Improved](https://www.kaggle.com/code/brendanartley/caformer-full-resolution-improved)\n\n\nThis notebook features the strongest model I have found so far. A modified CAFormer encoder combined with an improved decoder (pixel shuffle, intermediate convolutions, and SCSE blocks).\n\nLike previous notebooks, I provide a pre-trained model checkpoint (trained for 150 epochs) which achieved a validation MAE of ~24.","metadata":{}},{"cell_type":"code","source":"%%writefile _cfg.py\n\nfrom types import SimpleNamespace\nimport torch\n\ncfg= SimpleNamespace()\ncfg.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\ncfg.local_rank = 0\ncfg.seed = 123\ncfg.subsample = None\n\ncfg.backbone = \"caformer_b36.sail_in22k_ft_in1k\"\ncfg.batch_size_val = 16\ncfg.batch_size_train = 16 # Added for a hypothetical training loop","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-11T08:57:54.87315Z","iopub.execute_input":"2025-06-11T08:57:54.873832Z","iopub.status.idle":"2025-06-11T08:57:54.878526Z","shell.execute_reply.started":"2025-06-11T08:57:54.873806Z","shell.execute_reply":"2025-06-11T08:57:54.877795Z"}},"outputs":[{"name":"stdout","text":"Overwriting _cfg.py\n","output_type":"stream"}],"execution_count":20},{"cell_type":"markdown","source":"# Scheduler\n\nI have removed the training loop from this notebook, though it is the same as previous notebooks. \n\nThe only difference was the use of a custom learning rate scheduler. The scheduler uses a constant learning rate followed by a cosine annealing learning rate. It seems that a learning rate of 1e-4 works well at the beggining, but a lower learning rate is required to achieve lower training and validation MAE.","metadata":{}},{"cell_type":"code","source":"%%writefile _scheduler.py\n\nimport math\nfrom torch.optim.lr_scheduler import _LRScheduler\n\nclass ConstantCosineLR(_LRScheduler):\n    \"\"\"\n    Constant learning rate followed by CosineAnnealing.\n    Added linear warm-up phase.\n    \"\"\"\n    def __init__(\n        self,\n        optimizer,\n        total_steps,\n        pct_cosine,\n        warmup_steps=0,\n        min_lr_factor=0.0,\n        last_epoch=-1,\n    ):\n        self.total_steps = total_steps\n        self.warmup_steps = warmup_steps\n        self.milestone = int(total_steps * (1 - pct_cosine))\n        self.cosine_steps = max(total_steps - self.milestone, 1)\n        self.min_lr_factor = min_lr_factor\n        super().__init__(optimizer, last_epoch)\n\n    def get_lr(self):\n        step = self.last_epoch + 1\n        if step <= self.warmup_steps:\n            # Linear warm-up\n            factor = float(step) / float(max(1, self.warmup_steps))\n        elif step <= self.milestone:\n            # Constant LR\n            factor = 1.0\n        else:\n            # Cosine annealing\n            s = step - self.milestone\n            factor = self.min_lr_factor + (1.0 - self.min_lr_factor) * 0.5 * (1 + math.cos(math.pi * s / self.cosine_steps))\n        return [lr * factor for lr in self.base_lrs]","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-11T08:58:47.277579Z","iopub.execute_input":"2025-06-11T08:58:47.278004Z","iopub.status.idle":"2025-06-11T08:58:47.284019Z","shell.execute_reply.started":"2025-06-11T08:58:47.277963Z","shell.execute_reply":"2025-06-11T08:58:47.283262Z"}},"outputs":[{"name":"stdout","text":"Overwriting _scheduler.py\n","output_type":"stream"}],"execution_count":21},{"cell_type":"code","source":"import torch\nimport matplotlib.pyplot as plt\n\n# Dummy model\nn_steps = 10_000\nmodel = torch.nn.Linear(1, 1)\noptimizer = torch.optim.SGD(model.parameters(), lr=1.0)\n\n# Scheduler\nscheduler = ConstantCosineLR(optimizer, total_steps=n_steps, pct_cosine=0.5)\n\n# Get LRs\narr = []\nfor _ in range(n_steps):\n    scheduler.step()\n    arr.append(optimizer.param_groups[0]['lr'])\n\nplt.plot(arr)\nplt.xlabel(\"Step\")\nplt.ylabel(\"LR\")\nplt.title(\"ConstantCosineLR\")\nplt.show()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-11T08:58:57.239488Z","iopub.execute_input":"2025-06-11T08:58:57.240001Z","iopub.status.idle":"2025-06-11T08:58:57.505547Z","shell.execute_reply.started":"2025-06-11T08:58:57.239976Z","shell.execute_reply":"2025-06-11T08:58:57.504832Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABKaUlEQVR4nO3deVhUZcMG8HsWmAHZZYcBxA0VRUVFXFtQMrX8tNIyF1wqs1IpLSq3Ns3MsnIpc0szzUorI42X1FxwA3FfUQQXNhUGAdnm+f4gpyZRQIEzy/27rrmulzPPmbnP6Q3uzjnPOTIhhAARERGRmZBLHYCIiIioNrHcEBERkVlhuSEiIiKzwnJDREREZoXlhoiIiMwKyw0RERGZFZYbIiIiMissN0RERGRWWG6IiIjIrLDcEBHVkhkzZkAmk0kdg8jisdwQmaCUlBQ8//zzCAwMhFqthoODA7p27Yr58+ejqKhIslyxsbGYMWNGvXzX7t27MWPGDOTm5lb6fnl5OZYvX44HHngALi4uUKlUCAgIQFRUFA4cOFAvGetCamoqZDIZ5s6de9dxAQEBkMlk+leDBg3QqVMnfPPNN/WUlEg6LDdEJua3335D69at8f3336N///74/PPPMWvWLPj5+WHy5MmYMGGCZNliY2Mxc+bMevmu3bt3Y+bMmZWWm6KiIvTr1w+jRo2CEAJvvvkmFi1ahOHDhyMhIQGdOnXCxYsXaz3T22+/LWm5/K+2bdti1apVWLVqFWbMmIG8vDyMGDECS5YskToaUZ1SSh2AiKrv/PnzGDJkCPz9/fHnn3/Cy8tL/9748eNx9uxZ/PbbbxImNA6TJ0/G5s2b8cknn2DixIkG702fPh2ffPJJnXyvUqmEUmk8v1Z9fHzw7LPP6n8eOXIkAgMD8cknn2Ds2LESJiOqWzxyQ2RC5syZgxs3bmDp0qUGxeaWJk2a6I/clJWV4d1330Xjxo31p2TefPNNFBcXG6wTEBCAfv36YefOnejUqRPUajUCAwNvO31RWlqKmTNnomnTplCr1WjYsCG6deuGuLg4ABV/OBcsWAAABqdDbpk7dy66dOmChg0bwsbGBqGhofjhhx9u2waZTIaXXnoJGzduRHBwMFQqFVq1aoXNmzfrx8yYMQOTJ08GADRq1Ej/Xampqbh48SK+/PJL9OrV67ZiAwAKhQKvvfYafH199csOHjyIPn36wMHBAXZ2dnj44YexZ8+eGm3/rVz/veamOttzy6VLlzBq1Ch4eHjoxy1btuy2cffKzc0NQUFBSElJqbXPJDJGxvOfGERUpV9//RWBgYHo0qVLlWPHjBmDlStX4oknnsCrr76KvXv3YtasWThx4gQ2bNhgMPbs2bN44oknMHr0aIwYMQLLli3DyJEjERoailatWgGo+MM9a9YsjBkzBp06dYJWq8WBAweQlJSEXr164fnnn8fly5cRFxeHVatW3ZZn/vz5eOyxxzB06FCUlJRg7dq1ePLJJ7Fp0yb07dvXYOzOnTvx008/4cUXX4S9vT0+++wzDBo0CGlpaWjYsCEGDhyI06dP47vvvsMnn3wCV1dXABV/vNesWYOysjIMGzasWvv02LFj6N69OxwcHDBlyhRYWVnhyy+/xAMPPIDt27cjLCysWtt/N1VtDwBkZmaic+fO+jLk5uaG33//HaNHj4ZWq620qNVUWVkZLl68CGdn5/v+LCKjJojIJOTl5QkA4vHHH69ybHJysgAgxowZY7D8tddeEwDEn3/+qV/m7+8vAIi//vpLvywrK0uoVCrx6quv6peFhISIvn373vV7x48fL+70a6WwsNDg55KSEhEcHCweeughg+UAhLW1tTh79qx+2aFDhwQA8fnnn+uXffTRRwKAOH/+vMH6kyZNEgDEwYMH75r1lgEDBghra2uRkpKiX3b58mVhb28vevTooV9Wne2fPn36bdtf3e0ZPXq08PLyEjk5OQbrDxkyRDg6Our33/nz5wUA8dFHH901i7+/v+jdu7fIzs4W2dnZ4siRI2LYsGECgBg/fvxd1yUydTwtRWQitFotAMDe3r7KsbGxsQCA6Ohog+WvvvoqANx2XU7Lli3RvXt3/c9ubm5o3rw5zp07p1/m5OSEY8eO4cyZM/eU38bGRv+/r1+/jry8PHTv3h1JSUm3jY2IiEDjxo31P7dp0wYODg4Gee6kJvupvLwcf/zxBwYMGIDAwED9ci8vLzzzzDPYuXOn/vPuZ/ur2h4hBH788Uf0798fQgjk5OToX5GRkcjLy6t0P1Xljz/+gJubG9zc3NC6dWusWrUKUVFR+Oijj2r8WUSmhOWGyEQ4ODgAAPLz86sce+HCBcjlcjRp0sRguaenJ5ycnHDhwgWD5X5+frd9hrOzM65fv67/+Z133kFubi6aNWuG1q1bY/LkyTh8+HC182/atAmdO3eGWq2Gi4sL3NzcsGjRIuTl5d02tjp57qQm+yk7OxuFhYVo3rz5be+1aNECOp0O6enpAO5v+6vanuzsbOTm5uKrr77Sl5Fbr6ioKABAVlZWtb7r38LCwhAXF4fNmzdj7ty5cHJywvXr12FtbV3jzyIyJSw3RCbCwcEB3t7eOHr0aLXXqe4N5RQKRaXLhRD6/92jRw+kpKRg2bJlCA4Oxtdff4327dvj66+/rvLzd+zYgcceewxqtRoLFy5EbGws4uLi8Mwzzxh8R03y3ElQUBAA4MiRI1WOrYn72f6qtken0wEAnn32WcTFxVX66tq1a40zu7q6IiIiApGRkXj11VexevVqbNy4EfPnz6/xZxGZEpYbIhPSr18/pKSkICEh4a7j/P39odPpbjuFkpmZidzcXPj7+9/T97u4uCAqKgrfffcd0tPT0aZNG4Ob9t2pTP34449Qq9XYsmULRo0ahT59+iAiIuKeMlT1XX369IFCocDq1aur/Aw3NzfY2tri1KlTt7138uRJyOVyaDQa/bKqtv9eubm5wd7eHuXl5YiIiKj05e7uft/f07dvX/Ts2RMffPABCgoK7vvziIwVyw2RCZkyZQoaNGiAMWPGIDMz87b3U1JSMH/+fDz66KMAgE8//dTg/Xnz5gHAbbOTquPq1asGP9vZ2aFJkyYGU8sbNGgAALfdWE+hUEAmk6G8vFy/LDU1FRs3bqxxjqq+S6PRYOzYsfjjjz/w+eef37aeTqfDxx9/jIsXL0KhUKB37974+eefkZqaqh+TmZmJNWvWoFu3bvrTXNXZ/nulUCgwaNAg/Pjjj5UemcvOzr7v77jl9ddfx9WrV3kjPzJrnApOZEIaN26MNWvWYPDgwWjRogWGDx+O4OBglJSUYPfu3Vi/fj1GjhyJCRMmYMSIEfjqq6+Qm5uLnj17Yt++fVi5ciUGDBiABx98sMbf3bJlSzzwwAMIDQ2Fi4sLDhw4gB9++AEvvfSSfkxoaCgA4JVXXkFkZCQUCgWGDBmCvn37Yt68eXjkkUfwzDPPICsrCwsWLECTJk1qdN3Ov936rrfeegtDhgyBlZUV+vfvjwYNGuDjjz9GSkoKXnnlFfz000/o168fnJ2dkZaWhvXr1+PkyZMYMmQIAOC9995DXFwcunXrhhdffBFKpRJffvkliouLMWfOnBpt//2YPXs2tm7dirCwMIwdOxYtW7bEtWvXkJSUhP/973+4du2awfj4+HjcvHnzts8ZMGAAgoOD7/g9ffr0QXBwMObNm4fx48fDysqqVvITGRUpp2oR0b05ffq0GDt2rAgICBDW1tbC3t5edO3aVXz++efi5s2bQgghSktLxcyZM0WjRo2ElZWV0Gg0IiYmRv/+Lf7+/pVOce7Zs6fo2bOn/uf33ntPdOrUSTg5OQkbGxsRFBQk3n//fVFSUqIfU1ZWJl5++WXh5uYmZDKZwbTopUuXiqZNmwqVSiWCgoLE8uXL7zh1urKpyv7+/mLEiBEGy959913h4+Mj5HL5bdPCy8rKxNdffy26d+8uHB0dhZWVlfD39xdRUVG3TRNPSkoSkZGRws7OTtja2ooHH3xQ7N6922BMdbb/frcnMzNTjB8/Xmg0GmFlZSU8PT3Fww8/LL766iv9mFtTwe/0WrVqlf7z7zR1fcWKFQKAWL58eaXvE5k6mRDVuEKPiIiIyETwmhsiIiIyKyw3REREZFZYboiIiMissNwQERGRWWG5ISIiIrPCckNERERmxeJu4qfT6XD58mXY29tX+7k7REREJC0hBPLz8+Ht7Q25/O7HZiyu3Fy+fNngWTFERERkOtLT0+Hr63vXMRZXbuzt7QFU7Jxbz4whIiIi46bVaqHRaPR/x+/G4srNrVNRDg4OLDdEREQmpjqXlPCCYiIiIjIrLDdERERkVlhuiIiIyKyw3BAREZFZYbkhIiIis8JyQ0RERGaF5YaIiIjMCssNERERmRWWGyIiIjIrLDdERERkViQtN3/99Rf69+8Pb29vyGQybNy4scp1tm3bhvbt20OlUqFJkyZYsWJFneckIiIi0yFpuSkoKEBISAgWLFhQrfHnz59H37598eCDDyI5ORkTJ07EmDFjsGXLljpOSkRERKZC0gdn9unTB3369Kn2+MWLF6NRo0b4+OOPAQAtWrTAzp078cknnyAyMrKuYlZLcVk5svOL7zqmOg/7qmpEVR8hq+ITql6/GiTOUNV+rM423O9+rPLtOt7G6n1GVevf3z+n6pD6/69KBc+8E1kik3oqeEJCAiIiIgyWRUZGYuLEiXdcp7i4GMXF/5QOrVZbJ9mOXdZi4MLddfLZRHRvHG2s4OtsAz8XWwT7OKKtxgkhGifYqUzqVx8R1ZBJ/RuekZEBDw8Pg2UeHh7QarUoKiqCjY3NbevMmjULM2fOrPNsMgAq5d3/K1FU9SFVDgBEFYNEtT6jiver8SFVf0bVOYjqWl5RKfKKSnHssha/H80AAFgpZOjUyAUPB3mgT2tPeDne/nuDiEybSZWbexETE4Po6Gj9z1qtFhqNpta/p52fM069V/1TbFS1apWsKoZUp2NV9T21UeRqo5RW+R2WVo6rGKMTAtk3inHxeiFSsgpw6GIuDqbl4lJuEXadvYpdZ6/ivd+Oo0czNzzVQYPeLT14GovITJhUufH09ERmZqbBsszMTDg4OFR61AYAVCoVVCpVfcSjWlat605q4bqQal5pRCbIuYE1mnnY46Ggf5ady76BP09mYcuxDOxPvY5tp7Kx7VQ2fJ1t8HyPQDzZQQO1lUK60ER030yq3ISHhyM2NtZgWVxcHMLDwyVKRESmJtDNDoFudhjTPRDncwqw/kA61u1Px8XrRZj68zF89udZRPdqhqc6aKCQs/gSmSJJj8HeuHEDycnJSE5OBlAx1Ts5ORlpaWkAKk4pDR8+XD/+hRdewLlz5zBlyhScPHkSCxcuxPfff49JkyZJEZ+ITFwj1waY8kgQdr7+EGY+1go+TjbIzi9GzE9H8Oj8Hdh5JkfqiER0D2SiOifI68i2bdvw4IMP3rZ8xIgRWLFiBUaOHInU1FRs27bNYJ1Jkybh+PHj8PX1xdSpUzFy5Mhqf6dWq4WjoyPy8vLg4OBQC1tBROaipEyHVXsu4LP4M8grKgUAPBHqi7f7toCTrbXE6YgsW03+fktabqTAckNEVcktLMEncafxzZ4LEAJwtVPhg/8LRu9WnlJHI7JYNfn7zakBRET/4WRrjZmPB+OHF8LR2K0Bcm4U47lViZj+81HcLC2XOh4RVYHlhojoDkL9XRA7oTue7xEIAFiZcAEDF+7G+ZwCiZMR0d2w3BAR3YVKqUDMoy2wPKojXBpY4/gVLR77Yif+Op0tdTQiugOWGyKianiwuTtiX+mOUH9n5N8sQ9SK/Vi5O7VaNy0kovrFckNEVE2ejmqsGRuGQe19Ua4TmP7LMUz7+RjKdSw4RMaE5YaIqAZUSgXmPtkGMX2CIJMBq/ZcwIS1B1FSppM6GhH9jeWGiKiGZDIZnu/ZGJ8NaQcrhQybDl/BmG8OoLCkTOpoRASWGyKie9Y/xBtfj+gIGysF/jqdjWFL9+FGMQsOkdRYboiI7kPPZm5YPSYMDmolEi9cR9TyfShgwSGSFMsNEdF9CvV3xrdjOsNercT+1OsYvXI/ikp4sz8iqbDcEBHVgta+jvhmVCfYqZTYc+4axn5zgHczJpIIyw0RUS1p5+eMlaM6ooG1AjvP5iD6+2ROEyeSAMsNEVEtCvV3wZIRHWCtkCP2SAbe3XScN/ojqmcsN0REtaxLY1fMGxwCmQxYsTsVi7efkzoSkUVhuSEiqgP92nhjat+WAIAPN5/EhoMXJU5EZDlYboiI6siobo30TxR//YcjSEq7LnEiIsvAckNEVIdefyQIka08UFKuw3PfJOJKXpHUkYjMHssNEVEdkstlmPdUWwR52iPnRjHGfnOA98AhqmMsN0REdayBSoklwzvApYE1jl7SYvIPhziDiqgOsdwQEdUDjYstFj8bCqW84kGbS3eelzoSkdliuSEiqiedGrlgWv+KGVSzfz+JxAvXJE5EZJ5YboiI6tGwzv7oH+KNMp3AS2sO4lpBidSRiMwOyw0RUT2SyWSYNbA1At0a4EreTUxYe5CPaCCqZSw3RET1zE6lxKKhoVBbybHjTA4Wbj0rdSQis8JyQ0Qkgeae9nh/QGsAwKfxZ3iDP6JaxHJDRCSRQaG+eLytN8p1AhPXJuNGcZnUkYjMAssNEZGE3nk8GD5ONki7VogZvxyTOg6RWWC5ISKSkKONFT4Z3BZyGfBD4kVsOnxZ6khEJo/lhohIYp0aueDFB5oAAN786Qgu5/L5U0T3g+WGiMgITIhoihBfR2hvluH1Hw/z8QxE94HlhojICFgp5Jg3uC1Uyorp4d8fSJc6EpHJYrkhIjISjd3s8GrvZgCA9zad4OkponvEckNEZERGdwtEOz8n5BeXIeanIzw9RXQPWG6IiIyIQi7DR0+0gbVSju2ns7E+8aLUkYhMDssNEZGRaeJuj+heFaen3t10HFfyeHqKqCZYboiIjNCYbo0QonFC/s0yTP+ZN/cjqgmWGyIiI6RUyPHhoNZQymX443gm4o5nSh2JyGSw3BARGakgTweM6R4IAJj+81EU8NlTRNXCckNEZMQmPNwUvs42uJx3E5/EnZY6DpFJYLkhIjJiNtYKvPt4MABg+e5UHLucJ3EiIuPHckNEZOQeDHJH39ZeKNcJvLnhKMp1vPcN0d2w3BARmYBp/VvCXqXEofRcrNl7Qeo4REaN5YaIyAR4OKjxWmRzAMDcP07jWkGJxImIjBfLDRGRiRga5ocgT3vkFZVi7h+npI5DZLRYboiITIRSIcfMx1oBAL7bl4ajl3hxMVFlWG6IiExIWGBD9A/xhhDAjF+O8cGaRJVguSEiMjExfYJgY6XAgQvX8cuhy1LHITI6LDdERCbG28kG4x9sDAD4IPYE71xM9B8sN0REJmhM90D4udgiU1uML7aelToOkVFhuSEiMkFqKwWm9msJAFi64zzSrxVKnIjIeLDcEBGZqIgW7ujWxBUl5TrM2cKp4US3sNwQEZkomUyGmEeDIJMBvx66jINp16WORGQUWG6IiExYK29HDGrvC6Di4mJODSdiuSEiMnmv9m4GtZUc+1OvY8uxTKnjEEmO5YaIyMR5OdpgbPdAAMDs30+gpEwncSIiabHcEBGZged7NoarnTVSrxbyqeFk8SQvNwsWLEBAQADUajXCwsKwb9++u47/9NNP0bx5c9jY2ECj0WDSpEm4efNmPaUlIjJOdiolJvVqBgCYH38GeUWlEiciko6k5WbdunWIjo7G9OnTkZSUhJCQEERGRiIrK6vS8WvWrMEbb7yB6dOn48SJE1i6dCnWrVuHN998s56TExEZn8EdNGjibofrhaVYuI039iPLJWm5mTdvHsaOHYuoqCi0bNkSixcvhq2tLZYtW1bp+N27d6Nr16545plnEBAQgN69e+Ppp5+u8mgPEZElUCrkiOkTBABYsSsVmVoe1SbLJFm5KSkpQWJiIiIiIv4JI5cjIiICCQkJla7TpUsXJCYm6svMuXPnEBsbi0cfffSO31NcXAytVmvwIiIyVw8FuSPU3xnFZTp8Fn9G6jhEkpCs3OTk5KC8vBweHh4Gyz08PJCRkVHpOs888wzeeecddOvWDVZWVmjcuDEeeOCBu56WmjVrFhwdHfUvjUZTq9tBRGRMZDIZpkQ2BwCs25+OC1cLJE5EVP8kv6C4JrZt24YPPvgACxcuRFJSEn766Sf89ttvePfdd++4TkxMDPLy8vSv9PT0ekxMRFT/wgIbomczN5TpBObFnZY6DlG9U0r1xa6urlAoFMjMNLzhVGZmJjw9PStdZ+rUqRg2bBjGjBkDAGjdujUKCgrw3HPP4a233oJcfntXU6lUUKlUtb8BRERGbHJkc2w/nY1fDl3GCz0bo4WXg9SRiOqNZEdurK2tERoaivj4eP0ynU6H+Ph4hIeHV7pOYWHhbQVGoVAAAG85TkT0L8E+jujbxgtCAHP5UE2yMJKeloqOjsaSJUuwcuVKnDhxAuPGjUNBQQGioqIAAMOHD0dMTIx+fP/+/bFo0SKsXbsW58+fR1xcHKZOnYr+/fvrSw4REVV4tVczKOQyxJ/MwoHUa1LHIao3kp2WAoDBgwcjOzsb06ZNQ0ZGBtq2bYvNmzfrLzJOS0szOFLz9ttvQyaT4e2338alS5fg5uaG/v374/3335dqE4iIjFagmx2eDPXF2v3pmLPlFNY91xkymUzqWER1TiYs7HyOVquFo6Mj8vLy4ODAc9BEZN6u5BWh50fbUFKmw4qojnigubvUkYjuSU3+fpvUbCkiIqoZL0cbDO/sDwD4JO40r08ki8ByQ0Rk5l54oDFsrBQ4dDEPW09V/ngbInPCckNEZOZc7VQYHl5x9ObT/53h0Rsyeyw3REQW4LkegbCxUuDwxTz8eZJHb8i8sdwQEVmAhnYqDO/CozdkGVhuiIgsxPM9GsPWWoEjl/IQf4JHb8h8sdwQEVkIlwbWGNElAADwaTxnTpH5YrkhIrIgY7sHooG1AkcvaRF3PLPqFYhMEMsNEZEFMTh6w2tvyEyx3BARWZhbR2+OX9HiDx69ITPEckNEZGGcG1hjZNcAAMB8Hr0hM8RyQ0RkgcZ0C4Tt30dveNdiMjcsN0REFsi5gTWe/fuZU1/8eZZHb8issNwQEVmoMd0bwVopR1JaLhLOXZU6DlGtYbkhIrJQ7vZqDOmoAVBx9IbIXLDcEBFZsOd7NoZSLsPulKtISrsudRyiWsFyQ0RkwXycbPB/7XwAAAt49IbMBMsNEZGFG/dAY8hlQPzJLBy7nCd1HKL7xnJDRGThAt3s0LeNNwBg4dYUidMQ3T+WGyIiwvgHGwMAYo9ewdmsGxKnIbo/LDdERIQgTwf0aukBIYBF23j0hkwbyw0REQEAXnqwCQBgY/IlpF8rlDgN0b1juSEiIgBAiMYJ3Zu6olwn8NVf56SOQ3TPWG6IiEhv3AMV1958fyAdV28US5yG6N6w3BARkV54YEOE+DqiuEyHlbtTpY5DdE9YboiISE8mk+H5nhVHb1YmXEBBcZnEiYhqjuWGiIgMRLbyREBDW+QVlWLd/nSp4xDVGMsNEREZUMhlGNsjEACwdOd5lJbrJE5EVDMsN0REdJtB7X3hameNS7lF2HT4stRxiGqE5YaIiG6jtlIgqmsjAMCX289BCCFxIqLqY7khIqJKPRvmjwbWCpzMyMe209lSxyGqNpYbIiKqlKOtFZ7u5AcA+HI7H8lApoPlhoiI7mh090ZQymXYc+4aktNzpY5DVC0sN0REdEdejjZ4vK0PAB69IdPBckNERHf1fM+KaeGbj2XgfE6BxGmIqsZyQ0REd9XMwx4PB7lDCPCBmmQSWG6IiKhKL/z9QM0fky4ihw/UJCPHckNERFXq4O+MEI0TSsp0WL3ngtRxiO6K5YaIiKokk8kwtnvFTf1WJVzAzdJyiRMR3RnLDRERVcsjrTzh42SDqwUl2HjwktRxiO6I5YaIiKpFqZAjqmsAAODrneeh0/GRDGScWG6IiKjaBnfUwE6lxNmsG9h+ho9kIOPEckNERNVmr7bCkI4aAMDXOzgtnIwTyw0REdXIyK4BUMhl2HX2Ko5f1kodh+g2LDdERFQjvs626BPsCQD4eieP3pDxYbkhIqIaG9O94pEMvx66jEztTYnTEBliuSEiohprq3FCxwBnlJYLrNydKnUcIgMsN0REdE9uHb35dm8aCkvKJE5D9A+WGyIiuicRLTzg39AWeUWl+CHxotRxiPRYboiI6J4o5DKM7lbxSIZlO8+jnDf1IyPBckNERPfsiVBfONpYIfVqIf53IlPqOEQAWG6IiOg+2ForMTTMDwCwdMd5idMQVWC5ISKi+zKiSwCsFDLsS72GwxdzpY5DxHJDRET3x8NBjX5tvAEAy3elShuGCCw3RERUC249LXzT4cvI4k39SGIsN0REdN/a+Dqhg3/FTf1W77kgdRyycJKXmwULFiAgIABqtRphYWHYt2/fXcfn5uZi/Pjx8PLygkqlQrNmzRAbG1tPaYmI6E6iulZMC/92bxpulpZLnIYsmaTlZt26dYiOjsb06dORlJSEkJAQREZGIisrq9LxJSUl6NWrF1JTU/HDDz/g1KlTWLJkCXx8fOo5ORER/VdkKw94O6pxtaAEvx66LHUcsmCSlpt58+Zh7NixiIqKQsuWLbF48WLY2tpi2bJllY5ftmwZrl27ho0bN6Jr164ICAhAz549ERISUs/JiYjov5QKOYZ3CQAALNuVCiF4Uz+ShmTlpqSkBImJiYiIiPgnjFyOiIgIJCQkVLrOL7/8gvDwcIwfPx4eHh4IDg7GBx98gPLyOx/+LC4uhlarNXgREVHdGNJRA7WVHCeuaLH3/DWp45CFkqzc5OTkoLy8HB4eHgbLPTw8kJGRUek6586dww8//IDy8nLExsZi6tSp+Pjjj/Hee+/d8XtmzZoFR0dH/Uuj0dTqdhAR0T+cbK0xsL0vgIpHMhBJQfILimtCp9PB3d0dX331FUJDQzF48GC89dZbWLx48R3XiYmJQV5env6Vnp5ej4mJiCxP1N+npuJOZCL9WqG0YcgiSVZuXF1doVAokJlp+CySzMxMeHp6VrqOl5cXmjVrBoVCoV/WokULZGRkoKSkpNJ1VCoVHBwcDF5ERFR3mnrYo3tTVwgBrNydKnUcskCSlRtra2uEhoYiPj5ev0yn0yE+Ph7h4eGVrtO1a1ecPXsWOp1Ov+z06dPw8vKCtbV1nWcmIqLqGfX308LX7U/HjeIyidOQpZH0tFR0dDSWLFmClStX4sSJExg3bhwKCgoQFRUFABg+fDhiYmL048eNG4dr165hwoQJOH36NH777Td88MEHGD9+vFSbQERElejZ1A2Brg2QX1yGHxMvSh2HLIxSyi8fPHgwsrOzMW3aNGRkZKBt27bYvHmz/iLjtLQ0yOX/9C+NRoMtW7Zg0qRJaNOmDXx8fDBhwgS8/vrrUm0CERFVQi6XYWTXAEz7+RhW7E7FsM7+kMtlUsciCyETFnYjAq1WC0dHR+Tl5fH6GyKiOlRQXIbOs+KRf7MMy0Z2wENBHlWvRHQHNfn7bVKzpYiIyHQ0UCkxpGPF7Tf4tHCqTyw3RERUZ4aHB0AuA3acycHpzHyp45CFYLkhIqI6o3GxRe+WFbf34NEbqi8sN0REVKeiugYAADYcvIjcwsrvSUZUm1huiIioTnVq5IJW3g64WarDd/t4l3iqeyw3RERUp2QyGaK6VtzU75uEVJSW66pYg+j+sNwQEVGd6x/iBVc7a1zJu4ktxyp/ODJRbWG5ISKiOqdSKvBMmD8AYAUvLKY6xnJDRET14tkwP1gpZDhw4TqOXMyTOg6ZMZYbIiKqF+4OavRt7QUAWL7rvMRpyJyx3BARUb25dWHxr4cvIyv/psRpyFyx3BARUb0J0TihvZ8TSssF1uxNkzoOmSmWGyIiqlcj/z56s3pPGorLyiVOQ+aI5YaIiOpVn2BPeDqokXOjGLFHrkgdh8wQyw0REdUrK4Ucw8IrpoUv35UKIYTEicjcsNwQEVG9G9JRA2ulHIcv5iEpLVfqOGRmWG6IiKjeNbRTYUBbbwCcFk61j+WGiIgkMbJLxYXFvx/NwJW8IonTkDlhuSEiIkm09HZAWCMXlOsEVu+5IHUcMiMsN0REJJlbN/VbszcNN0s5LZxqB8sNERFJpldLD/g42eB6YSl+Tr4kdRwyEyw3REQkGYVchhFdOC2caletlpukpCT069evNj+SiIjM3OAOfrCxUuBkRj72nLsmdRwyAzUuN1u2bMFrr72GN998E+fOnQMAnDx5EgMGDEDHjh2h0+lqPSQREZkvR1srDGzvAwBYsZvTwun+1ajcLF26FH369MGKFSvw4YcfonPnzli9ejXCw8Ph6emJo0ePIjY2tq6yEhGRmRrZJQAAEHc8E+nXCqUNQyavRuVm/vz5+PDDD5GTk4Pvv/8eOTk5WLhwIY4cOYLFixejRYsWdZWTiIjMWFMPe3Rv6gqdAL5JSJU6Dpm4GpWblJQUPPnkkwCAgQMHQqlU4qOPPoKvr2+dhCMiIssR1TUAALB2fzoKisukDUMmrUblpqioCLa2tgAAmUwGlUoFLy+vOglGRESW5YFm7ghoaIv8m2X46SCnhdO9U9Z0ha+//hp2dnYAgLKyMqxYsQKurq4GY1555ZXaSUdERBZDLpdhRJcAzPz1OFbsOo+hnfwgl8ukjkUmSCZqcFOBgIAAyGR3/z+aTCbTz6IyRlqtFo6OjsjLy4ODg4PUcYiI6F/yb5YifNafuFFchm9GdUKPZm5SRyIjUZO/3zU6cpOamnrX9y9evIh33nmnJh9JRESkZ6+2wpMdfLF8VyqW7zrPckP3pFZv4nf16lUsXbq0Nj+SiIgszIjwAMhkwNZT2TifUyB1HDJBfPwCEREZlQDXBniouTsAYOXuVGnDkEliuSEiIqMz8u9p4esPpEN7s1TaMGRyWG6IiMjodGviiqbudigoKccPBy5KHYdMTI0uKB44cOBd38/Nzb2fLERERAAqZt6O7BqAtzYcxcqEVIzoEgAFp4VTNdWo3Dg6Olb5/vDhw+8rEBEREQD8XzsffPj7SVy4WoitJ7MQ0dJD6khkImpUbpYvX15XOYiIiAzYWivxdCc/fPnXOazYncpyQ9XGa26IiMhoDQv3h1wG7Dybg9OZ+VLHIRPBckNEREbL19kWvVt6AgCW70qVNgyZDJYbIiIyareeFr7h4EXkFpZIG4ZMAssNEREZtU6NXNDCywE3S3VYuz9d6jhkAlhuiIjIqMlkMv3Rm1UJF1BWrpM2EBk9lhsiIjJ6j4V4w6WBNS7lFiHueKbUccjIsdwQEZHRU1sp8EwnPwC8sJiqxnJDREQmYVi4P5RyGfalXsPRS3lSxyEjxnJDREQmwcNBjUdbewEAVvBp4XQXLDdERGQybj0t/Jfky8i5USxtGDJaLDdERGQy2vs5I0TjhJJyHb7bmyZ1HDJSLDdERGRSoroEAABW7bmAkjJOC6fbsdwQEZFJebS1F9ztVcjKL8bvR69IHYeMEMsNERGZFGulHM929gfAaeFUOZYbIiIyOU938oO1Qo7k9FwcTLsudRwyMiw3RERkctzsVegf4g2A08Lpdiw3RERkkm49b+q3w1eQqb0pbRgyKiw3RERkkoJ9HNExwBllOoHVey5IHYeMiFGUmwULFiAgIABqtRphYWHYt29ftdZbu3YtZDIZBgwYULcBiYjIKEV1bQQAWLM3DTdLyyVOQ8ZC8nKzbt06REdHY/r06UhKSkJISAgiIyORlZV11/VSU1Px2muvoXv37vWUlIiIjE3vlh7wdlTjakEJfj10Weo4ZCQkLzfz5s3D2LFjERUVhZYtW2Lx4sWwtbXFsmXL7rhOeXk5hg4dipkzZyIwMLAe0xIRkTFRKuQYFh4AoGJauBBC2kBkFCQtNyUlJUhMTERERIR+mVwuR0REBBISEu643jvvvAN3d3eMHj26PmISEZERe7qTBmorOY5f0WJ/KqeFk8TlJicnB+Xl5fDw8DBY7uHhgYyMjErX2blzJ5YuXYolS5ZU6zuKi4uh1WoNXkREZD6cbK3xf+18AADLd52XOA0ZA8lPS9VEfn4+hg0bhiVLlsDV1bVa68yaNQuOjo76l0ajqeOURERU30Z2qbiweMuxDFzKLZI4DUlN0nLj6uoKhUKBzMxMg+WZmZnw9PS8bXxKSgpSU1PRv39/KJVKKJVKfPPNN/jll1+gVCqRkpJy2zoxMTHIy8vTv9LT0+tse4iISBrNPe3RtUlD6ATwTUKq1HFIYpKWG2tra4SGhiI+Pl6/TKfTIT4+HuHh4beNDwoKwpEjR5CcnKx/PfbYY3jwwQeRnJxc6VEZlUoFBwcHgxcREZmfW0dv1u5LR2FJmcRpSEpKqQNER0djxIgR6NChAzp16oRPP/0UBQUFiIqKAgAMHz4cPj4+mDVrFtRqNYKDgw3Wd3JyAoDblhMRkWV5KMgdfi62SLtWiI0HL+OZMD+pI5FEJC83gwcPRnZ2NqZNm4aMjAy0bdsWmzdv1l9knJaWBrncpC4NIiIiCSjkMozoEoB3Nx3Hit3n8XQnDWQymdSxSAIyYWE3BdBqtXB0dEReXh5PURERmRntzVKEfxCPgpJyrB4dhm5Nqzf5hIxfTf5+85AIERGZDQe1FZ4I9QUArNjNaeGWiuWGiIjMyvAuAQCA+JNZuHC1QNowJAmWGyIiMiuN3ezwQHM3CAGs3M2nhVsilhsiIjI7t54Wvv5AOm4Uc1q4pWG5ISIis9O9iSsC3Rogv7gMPxzgzVstDcsNERGZHblchqi/r71ZmXABOp1FTQy2eCw3RERklga294W9WonzOQXYfjpb6jhUj1huiIjILDVQKTG4Q8VjeZbxaeEWheWGiIjM1oguAZDJgB1ncnA2K1/qOFRPWG6IiMhsaVxsEdGi4nE+y3alShuG6g3LDRERmbXR3Sqmhf+YeBE5N4olTkP1geWGiIjMWlgjF4T4OqK4TIdVCbypnyVguSEiIrMmk8kwtkcgAOCbhFQUlZRLnIjqGssNERGZvUdaeULjYoPrhaX4Iemi1HGojrHcEBGR2VMq5Bj99yMZvt5xDuW8qZ9ZY7khIiKL8FRHDRxtrHDhaiHijmdIHYfqEMsNERFZBFtrJYZ19gcAfPnXOQjBozfmiuWGiIgsxoguAbBWyHEwLReJF65LHYfqCMsNERFZDDd7FQa29wFQcfSGzBPLDRERWZQx3Sumhf/vRCZSsm9InIbqAssNERFZlCbudoho4Q4hgK938IGa5ojlhoiILM5zPRoDAH5MuojsfD6Swdyw3BARkcXpGOCMEI0TSsp0WJWQKnUcqmUsN0REZHFkMhmev/VIhj0XUFhSJnEiqk0sN0REZJEiW3nCz8UWuYWlWH+Aj2QwJyw3RERkkRRyGcZ0r3gkw5Id51BWrpM4EdUWlhsiIrJYT4Zq0LCBNS5eL8Kvhy9LHYdqCcsNERFZLBtrBUZ1qzh6s2hbCnR8oKZZYLkhIiKL9mxnf9iplDideQPxJ7OkjkO1gOWGiIgsmqONFZ79+4GaC7ed5QM1zQDLDRERWbxR3QJgrax4oOaec9ekjkP3ieWGiIgsnru9Gk918AVQcfSGTBvLDREREYDnezSGQi7DjjM5OHIxT+o4dB9YboiIiABoXGzRv40XAGDRdh69MWUsN0RERH8b90ATAMDvRzOQkn1D4jR0r1huiIiI/tbc0x4RLTwgBPDl9hSp49A9YrkhIiL6lxcfbAwA2HDwEq7kFUmchu4Fyw0REdG/tPdzRudAF5SWCyz567zUcegesNwQERH9x4t/X3uzZt8F5NwoljgN1RTLDRER0X90b+qKEF9H3CzVYcmOc1LHoRpiuSEiIvoPmUyGVx5uCgBYlXAB1wpKJE5ENcFyQ0REVImHgtzR2scRhSXl+JpHb0wKyw0REVEl/n30ZuXuVFzn0RuTwXJDRER0BxEt3NHSywEFJeVYtoszp0wFyw0REdEd/PvozYpdqcgrLJU4EVUHyw0REdFd9G7pgSBPe+QXl2Epj96YBJYbIiKiu5DL/zl6s3zXeeQV8eiNsWO5ISIiqsIjrTzRzMMO+TfLsGJXqtRxqAosN0RERFWQy2V4+aGKozdLd55D/k0evTFmLDdERETV8GhrLzR2awAtj94YPZYbIiKialD869qbr3ac48wpI8ZyQ0REVE3923ijuYc98m+W8ZlTRozlhoiIqJrkchkm9WoGAFi26zyfGG6kWG6IiIhqILKVB9r4VjxzatG2FKnjUCVYboiIiGpAJpPh1d7NAQCr9lxARt5NiRPRf7HcEBER1VCPpq7oGOCMkjIdPv/zjNRx6D+MotwsWLAAAQEBUKvVCAsLw759++44dsmSJejevTucnZ3h7OyMiIiIu44nIiKqbTKZDK/9ffRm3f50pF0tlDgR/Zvk5WbdunWIjo7G9OnTkZSUhJCQEERGRiIrK6vS8du2bcPTTz+NrVu3IiEhARqNBr1798alS5fqOTkREVmysMCG6N7UFWU6gfnxPHpjTGRCCCFlgLCwMHTs2BFffPEFAECn00Gj0eDll1/GG2+8UeX65eXlcHZ2xhdffIHhw4dXOV6r1cLR0RF5eXlwcHC47/xERGS5ktNzMWDBLshlwB+TeqCJu73UkcxWTf5+S3rkpqSkBImJiYiIiNAvk8vliIiIQEJCQrU+o7CwEKWlpXBxcamrmERERJVqq3FCr5Ye0AlgXtxpqePQ3yQtNzk5OSgvL4eHh4fBcg8PD2RkZFTrM15//XV4e3sbFKR/Ky4uhlarNXgRERHVlld7N4NMBsQeycDBtOtSxyEYwTU392P27NlYu3YtNmzYALVaXemYWbNmwdHRUf/SaDT1nJKIiMxZkKcDBrX3BQDM+v0kJL7agyBxuXF1dYVCoUBmZqbB8szMTHh6et513blz52L27Nn4448/0KZNmzuOi4mJQV5env6Vnp5eK9mJiIhuie7VDCqlHPvOX0P8iconxFD9kbTcWFtbIzQ0FPHx8fplOp0O8fHxCA8Pv+N6c+bMwbvvvovNmzejQ4cOd/0OlUoFBwcHgxcREVFt8naywahujQAAszefRFm5TuJElk3y01LR0dFYsmQJVq5ciRMnTmDcuHEoKChAVFQUAGD48OGIiYnRj//www8xdepULFu2DAEBAcjIyEBGRgZu3Lgh1SYQERHhhZ6N4WRrhbNZN/BD4kWp41g0ycvN4MGDMXfuXEybNg1t27ZFcnIyNm/erL/IOC0tDVeuXNGPX7RoEUpKSvDEE0/Ay8tL/5o7d65Um0BERARHGyu8/FBTABUzpwpLyiROZLkkv89NfeN9boiIqK4Ul5UjYt52pF8rwqu9muHlh5tKHclsmMx9boiIiMyJSqnA5MggAMDi7SnIuVEscSLLxHJDRERUi/q19kIbX0cUlJRj/v/4WAYpsNwQERHVIrlchpg+LQAA3+69gJMZvHlsfWO5ISIiqmXhjRuiT7AndAJ459fjvLFfPWO5ISIiqgNvPtoC1ko5dqdcxR/HM6tegWoNyw0REVEd0LjYYmz3ihv7vf/bCRSXlUucyHKw3BAREdWRFx9oAnd7FdKuFWLZzlSp41gMlhsiIqI60kClxBt9KqaGf/HnGWRpb0qcyDKw3BAREdWhAW190FbjhIKScny05ZTUcSwCyw0REVEdkstlmN6/JQBgfeJFHEy7LnEi88dyQ0REVMfa+TljUHtfAMBbG47yqeF1jOWGiIioHsQ8GgRHGyscv6LFNwkXpI5j1lhuiIiI6oGrnQpTHmkOoOKp4Zm8uLjOsNwQERHVk6c7+qGtxgk3isvwzqbjUscxWyw3RERE9UQul+G9AcGQy4DfDl/BX6ezpY5kllhuiIiI6lGwjyNGdAkAAEz7+ShulvLOxbWN5YaIiKieRfdqBnd7FVKvFmLB1rNSxzE7LDdERET1zF5thRmPtQIALNqWguOXtRInMi8sN0RERBLoE+yJyFYeKNMJTPnxEO99U4tYboiIiCQgk8nw7uPBcFArcfSSFl/tOCd1JLPBckNERCQRdwc1pvWvOD316f/OICX7hsSJzAPLDRERkYQGtfdBz2ZuKCnT4fUfDkOnE1JHMnksN0RERBKSyWT4YGBrNLBW4MCF61ixO1XqSCaP5YaIiEhiPk42eOPRFgCADzefxJnMfIkTmTaWGyIiIiPwbJgfejZzQ3GZDhPXJaOkjLOn7hXLDRERkRGQyWT46Ik2cLa1wrHLWnz6v9NSRzJZLDdERERGwt1BjVkDWwMAFm9Pwf7UaxInMk0sN0REREbkkWAvPBHqC50AJq1LRv7NUqkjmRyWGyIiIiMzvX9L+Drb4OL1Iry98SiE4PTwmmC5ISIiMjL2aivMH9IWCrkMPydfxnf70qWOZFJYboiIiIxQqL8LpkQ2BwDM+PUYH65ZAyw3RERERmps90A8FOSOkjIdxq9J4vU31cRyQ0REZKTkchk+fjIE3o5qnM8pQMxPR3j9TTWw3BARERkx5wbW+PyZ9lDKZdh0+AqW7jwvdSSjx3JDRERk5EL9nfHm349n+CD2BHaeyZE4kXFjuSEiIjIBUV0D9Pe/Gb8mCReuFkgdyWix3BAREZkAmUyG9wYEo63GCXlFpRj7zQHcKC6TOpZRYrkhIiIyEWorBb4aFgoPBxVOZ97AxLUHUa7jBcb/xXJDRERkQtwd1PhyWAdYK+X434kszPjlGGdQ/QfLDRERkYlpq3HC/MFtIZMBq/ZcwMJtKVJHMiosN0RERCaoT2svTOvXEgDw0ZZT+CnposSJjAfLDRERkYmK6toIz/UIBABM+eEwtp7MkjiRcWC5ISIiMmFvPBKEx0K8UaYTeH51Iu+BA5YbIiIikyaXy/DxUyHo1dIDJWU6jPlmP/acuyp1LEmx3BAREZk4K4UcXzzTDg82d8PNUh1GrdiPA6nXpI4lGZYbIiIiM6BSKrDo2VB0a+KKwpJyDFu6DzvOZEsdSxIsN0RERGZCbaXAkuEd0KOZG4pKyzFqxX78fuSK1LHqHcsNERGRGbGxVuDr4R3Qt7UXSssFxq9Jwrr9aVLHqlcsN0RERGbGWinHZ0+3w+AOGugE8PqPRzD795PQWcijGlhuiIiIzJBCLsPsQa3x8kNNAACLt6fg+dWJKLCAh22y3BAREZkpmUyGV3s3x/whbWGtlCPueCYGLdqNlOwbUkerUyw3REREZu7xtj5Y+1xnuNqpcDIjH/0/34kNB833cQ0sN0RERBagvZ8zYl/phvDAhigsKcekdYfw6veHkFdUKnW0WsdyQ0REZCHcHdRYPSYMkyKaQS4Dfky6iF7ztuOPYxlSR6tVLDdEREQWRCGXYUJEU6x7PhyNXBsgK78Yz61KxIvfJiL9WqHU8WoFyw0REZEF6hjggt8ndMe4BxpDIZch9kgGHv54Oz6IPWHyp6pkQgjLmPT+N61WC0dHR+Tl5cHBwUHqOERERJI7flmLD2JPYOfZiieK26uUGNrZH6O6BcDdXi1xugo1+fttFEduFixYgICAAKjVaoSFhWHfvn13Hb9+/XoEBQVBrVajdevWiI2NraekRERE5qeltwNWje6E5SM7opmHHfKLy7B4ewq6fbgVk9YlY/fZHJO6AaDk5WbdunWIjo7G9OnTkZSUhJCQEERGRiIrK6vS8bt378bTTz+N0aNH4+DBgxgwYAAGDBiAo0eP1nNyIiIi8yGTyfBgkDs2T+iBJcM7oL2fE0rKdNhw8BKe+Xovus/Zihm/HMP209m4WVouddy7kvy0VFhYGDp27IgvvvgCAKDT6aDRaPDyyy/jjTfeuG384MGDUVBQgE2bNumXde7cGW3btsXixYur/D6eliIiIqqaEALJ6blYn3gRvyZfRv6/7mxsrZAjyMserX0cEehmBx8nNTwc1GigUkKtVKCBSoGGdqpazVOTv9/KWv3mGiopKUFiYiJiYmL0y+RyOSIiIpCQkFDpOgkJCYiOjjZYFhkZiY0bN1Y6vri4GMXFxfqftVrt/QcnIiIyczKZDO38nNHOzxnT+rXEtlPZ2H46C1tPZiNDexOHL+bh8MW8StcN8XXEzy91q+fE/5C03OTk5KC8vBweHh4Gyz08PHDy5MlK18nIyKh0fEZG5XP0Z82ahZkzZ9ZOYCIiIguktlLgkWBPPBLsCSEELl4vwuGLeThyKQ/p1wtxObcIWdpiFJWW42ZpOWytJa0X0pab+hATE2NwpEer1UKj0UiYiIiIyHTJZDJoXGyhcbFF3zZeUseplKTlxtXVFQqFApmZmQbLMzMz4enpWek6np6eNRqvUqmgUtXueT8iIiIyXpLOlrK2tkZoaCji4+P1y3Q6HeLj4xEeHl7pOuHh4QbjASAuLu6O44mIiMiySH5aKjo6GiNGjECHDh3QqVMnfPrppygoKEBUVBQAYPjw4fDx8cGsWbMAABMmTEDPnj3x8ccfo2/fvli7di0OHDiAr776SsrNICIiIiMhebkZPHgwsrOzMW3aNGRkZKBt27bYvHmz/qLhtLQ0yOX/HGDq0qUL1qxZg7fffhtvvvkmmjZtio0bNyI4OFiqTSAiIiIjIvl9buob73NDRERkekzu8QtEREREtYXlhoiIiMwKyw0RERGZFZYbIiIiMissN0RERGRWWG6IiIjIrLDcEBERkVlhuSEiIiKzwnJDREREZkXyxy/Ut1s3ZNZqtRInISIiouq69Xe7Og9WsLhyk5+fDwDQaDQSJyEiIqKays/Ph6Oj413HWNyzpXQ6HS5fvgx7e3vIZLJa/WytVguNRoP09HQ+t6oOcT/XD+7n+sH9XH+4r+tHXe1nIQTy8/Ph7e1t8EDtyljckRu5XA5fX986/Q4HBwf+i1MPuJ/rB/dz/eB+rj/c1/WjLvZzVUdsbuEFxURERGRWWG6IiIjIrLDc1CKVSoXp06dDpVJJHcWscT/XD+7n+sH9XH+4r+uHMexni7ugmIiIiMwbj9wQERGRWWG5ISIiIrPCckNERERmheWGiIiIzArLTS1ZsGABAgICoFarERYWhn379kkdyajNmjULHTt2hL29Pdzd3TFgwACcOnXKYMzNmzcxfvx4NGzYEHZ2dhg0aBAyMzMNxqSlpaFv376wtbWFu7s7Jk+ejLKyMoMx27ZtQ/v27aFSqdCkSROsWLGirjfPKM2ePRsymQwTJ07UL+M+rj2XLl3Cs88+i4YNG8LGxgatW7fGgQMH9O8LITBt2jR4eXnBxsYGEREROHPmjMFnXLt2DUOHDoWDgwOcnJwwevRo3Lhxw2DM4cOH0b17d6jVamg0GsyZM6dets8YlJeXY+rUqWjUqBFsbGzQuHFjvPvuuwbPGuJ+rrm//voL/fv3h7e3N2QyGTZu3Gjwfn3u0/Xr1yMoKAhqtRqtW7dGbGzsvW2UoPu2du1aYW1tLZYtWyaOHTsmxo4dK5ycnERmZqbU0YxWZGSkWL58uTh69KhITk4Wjz76qPDz8xM3btzQj3nhhReERqMR8fHx4sCBA6Jz586iS5cu+vfLyspEcHCwiIiIEAcPHhSxsbHC1dVVxMTE6MecO3dO2NraiujoaHH8+HHx+eefC4VCITZv3lyv2yu1ffv2iYCAANGmTRsxYcIE/XLu49px7do14e/vL0aOHCn27t0rzp07J7Zs2SLOnj2rHzN79mzh6OgoNm7cKA4dOiQee+wx0ahRI1FUVKQf88gjj4iQkBCxZ88esWPHDtGkSRPx9NNP69/Py8sTHh4eYujQoeLo0aPiu+++EzY2NuLLL7+s1+2Vyvvvvy8aNmwoNm3aJM6fPy/Wr18v7OzsxPz58/VjuJ9rLjY2Vrz11lvip59+EgDEhg0bDN6vr326a9cuoVAoxJw5c8Tx48fF22+/LaysrMSRI0dqvE0sN7WgU6dOYvz48fqfy8vLhbe3t5g1a5aEqUxLVlaWACC2b98uhBAiNzdXWFlZifXr1+vHnDhxQgAQCQkJQoiKfyHlcrnIyMjQj1m0aJFwcHAQxcXFQgghpkyZIlq1amXwXYMHDxaRkZF1vUlGIz8/XzRt2lTExcWJnj176ssN93Htef3110W3bt3u+L5OpxOenp7io48+0i/Lzc0VKpVKfPfdd0IIIY4fPy4AiP379+vH/P7770Imk4lLly4JIYRYuHChcHZ21u/7W9/dvHnz2t4ko9S3b18xatQog2UDBw4UQ4cOFUJwP9eG/5ab+tynTz31lOjbt69BnrCwMPH888/XeDt4Wuo+lZSUIDExEREREfplcrkcERERSEhIkDCZacnLywMAuLi4AAASExNRWlpqsF+DgoLg5+en368JCQlo3bo1PDw89GMiIyOh1Wpx7Ngx/Zh/f8atMZb0z2b8+PHo27fvbfuB+7j2/PLLL+jQoQOefPJJuLu7o127dliyZIn+/fPnzyMjI8NgPzk6OiIsLMxgXzs5OaFDhw76MREREZDL5di7d69+TI8ePWBtba0fExkZiVOnTuH69et1vZmS69KlC+Lj43H69GkAwKFDh7Bz50706dMHAPdzXajPfVqbv0tYbu5TTk4OysvLDX75A4CHhwcyMjIkSmVadDodJk6ciK5duyI4OBgAkJGRAWtrazg5ORmM/fd+zcjIqHS/33rvbmO0Wi2KiorqYnOMytq1a5GUlIRZs2bd9h73ce05d+4cFi1ahKZNm2LLli0YN24cXnnlFaxcuRLAP/vqbr8nMjIy4O7ubvC+UqmEi4tLjf55mLM33ngDQ4YMQVBQEKysrNCuXTtMnDgRQ4cOBcD9XBfqc5/eacy97HOLeyo4GZ/x48fj6NGj2Llzp9RRzEp6ejomTJiAuLg4qNVqqeOYNZ1Ohw4dOuCDDz4AALRr1w5Hjx7F4sWLMWLECInTmY/vv/8e3377LdasWYNWrVohOTkZEydOhLe3N/czGeCRm/vk6uoKhUJx2wyTzMxMeHp6SpTKdLz00kvYtGkTtm7dCl9fX/1yT09PlJSUIDc312D8v/erp6dnpfv91nt3G+Pg4AAbG5va3hyjkpiYiKysLLRv3x5KpRJKpRLbt2/HZ599BqVSCQ8PD+7jWuLl5YWWLVsaLGvRogXS0tIA/LOv7vZ7wtPTE1lZWQbvl5WV4dq1azX652HOJk+erD9607p1awwbNgyTJk3SH5nkfq599blP7zTmXvY5y819sra2RmhoKOLj4/XLdDod4uPjER4eLmEy4yaEwEsvvYQNGzbgzz//RKNGjQzeDw0NhZWVlcF+PXXqFNLS0vT7NTw8HEeOHDH4lyouLg4ODg76PzTh4eEGn3FrjCX8s3n44Ydx5MgRJCcn618dOnTA0KFD9f+b+7h2dO3a9bZbGZw+fRr+/v4AgEaNGsHT09NgP2m1Wuzdu9dgX+fm5iIxMVE/5s8//4ROp0NYWJh+zF9//YXS0lL9mLi4ODRv3hzOzs51tn3GorCwEHK54Z8thUIBnU4HgPu5LtTnPq3V3yU1vgSZbrN27VqhUqnEihUrxPHjx8Vzzz0nnJycDGaYkKFx48YJR0dHsW3bNnHlyhX9q7CwUD/mhRdeEH5+fuLPP/8UBw4cEOHh4SI8PFz//q1pyr179xbJycli8+bNws3NrdJpypMnTxYnTpwQCxYssLhpyv/279lSQnAf15Z9+/YJpVIp3n//fXHmzBnx7bffCltbW7F69Wr9mNmzZwsnJyfx888/i8OHD4vHH3+80um07dq1E3v37hU7d+4UTZs2NZhOm5ubKzw8PMSwYcPE0aNHxdq1a4Wtra3ZTlH+rxEjRggfHx/9VPCffvpJuLq6iilTpujHcD/XXH5+vjh48KA4ePCgACDmzZsnDh48KC5cuCCEqL99umvXLqFUKsXcuXPFiRMnxPTp0zkVXGqff/658PPzE9bW1qJTp05iz549UkcyagAqfS1fvlw/pqioSLz44ovC2dlZ2Nraiv/7v/8TV65cMfic1NRU0adPH2FjYyNcXV3Fq6++KkpLSw3GbN26VbRt21ZYW1uLwMBAg++wNP8tN9zHtefXX38VwcHBQqVSiaCgIPHVV18ZvK/T6cTUqVOFh4eHUKlU4uGHHxanTp0yGHP16lXx9NNPCzs7O+Hg4CCioqJEfn6+wZhDhw6Jbt26CZVKJXx8fMTs2bPrfNuMhVarFRMmTBB+fn5CrVaLwMBA8dZbbxlML+Z+rrmtW7dW+vt4xIgRQoj63afff/+9aNasmbC2thatWrUSv/322z1tk0yIf93akYiIiMjE8ZobIiIiMissN0RERGRWWG6IiIjIrLDcEBERkVlhuSEiIiKzwnJDREREZoXlhoiIiMwKyw0RERGZFZYbIjJK2dnZGDduHPz8/KBSqeDp6YnIyEjs2rULACCTybBx40ZpQxKRUVJKHYCIqDKDBg1CSUkJVq5cicDAQGRmZiI+Ph5Xr16VOhoRGTk+foGIjE5ubi6cnZ2xbds29OzZ87b3AwICcOHCBf3P/v7+SE1NBQD8/PPPmDlzJo4fPw5vb2+MGDECb731FpTKiv+Wk8lkWLhwIX755Rds27YNXl5emDNnDp544ol62TYiqns8LUVERsfOzg52dnbYuHEjiouLb3t///79AIDly5fjypUr+p937NiB4cOHY8KECTh+/Di+/PJLrFixAu+//77B+lOnTsWgQYNw6NAhDB06FEOGDMGJEyfqfsOIqF7wyA0RGaUff/wRY8eORVFREdq3b4+ePXtiyJAhaNOmDYCKIzAbNmzAgAED9OtERETg4YcfRkxMjH7Z6tWrMWXKFFy+fFm/3gsvvIBFixbpx3Tu3Bnt27fHwoUL62fjiKhO8cgNERmlQYMG4fLly/jll1/wyCOPYNu2bWjfvj1WrFhxx3UOHTqEd955R3/kx87ODmPHjsWVK1dQWFioHxceHm6wXnh4OI/cEJkRXlBMREZLrVajV69e6NWrF6ZOnYoxY8Zg+vTpGDlyZKXjb9y4gZkzZ2LgwIGVfhYRWQYeuSEik9GyZUsUFBQAAKysrFBeXm7wfvv27XHq1Ck0adLktpdc/s+vuz179hist2fPHrRo0aLuN4CI6gWP3BCR0bl69SqefPJJjBo1Cm3atIG9vT0OHDiAOXPm4PHHHwdQMWMqPj4eXbt2hUqlgrOzM6ZNm4Z+/frBz88PTzzxBORyOQ4dOoSjR4/ivffe03/++vXr0aFDB3Tr1g3ffvst9u3bh6VLl0q1uURUy3hBMREZneLiYsyYMQN//PEHUlJSUFpaCo1GgyeffBJvvvkmbGxs8OuvvyI6Ohqpqanw8fHRTwXfsmUL3nnnHRw8eBBWVlYICgrCmDFjMHbsWAAVFxQvWLAAGzduxF9//QUvLy98+OGHeOqppyTcYiKqTSw3RGRRKptlRUTmhdfcEBERkVlhuSEiIiKzwguKicii8Ew8kfnjkRsiIiIyKyw3REREZFZYboiIiMissNwQERGRWWG5ISIiIrPCckNERERmheWGiIiIzArLDREREZkVlhsiIiIyK/8Pv6XxIiWWDdsAAAAASUVORK5CYII=\n"},"metadata":{}}],"execution_count":22},{"cell_type":"markdown","source":"### Dataset\n\nSame as previous notebook. ","metadata":{}},{"cell_type":"code","source":"%%writefile _dataset.py\n\nimport os\nimport glob\nimport numpy as np\nimport pandas as pd\nfrom tqdm import tqdm\nimport torch\n\nclass CustomDataset(torch.utils.data.Dataset):\n    def __init__(self, cfg, mode=\"train\"):\n        self.cfg = cfg\n        self.mode = mode\n        self.data, self.labels, self.records = self.load_metadata()\n\n    def load_metadata(self):\n        # ... (rest of the function is the same as your original)\n        df = pd.read_csv(\"/kaggle/input/openfwi-preprocessed-72x72/folds.csv\")\n        if self.cfg.subsample is not None:\n            df = df.groupby([\"dataset\", \"fold\"]).head(self.cfg.subsample)\n\n        if self.mode == \"train\":\n            df = df[df[\"fold\"] != self.cfg.fold_to_validate] # Use a config parameter for fold\n        else:\n            df = df[df[\"fold\"] == self.cfg.fold_to_validate] # Use a config parameter for fold\n\n        data = []\n        labels = []\n        records = []\n        mmap_mode = \"r\"\n        for idx, row in tqdm(df.iterrows(), total=len(df), disable=self.cfg.local_rank != 0):\n            row = row.to_dict()\n            p1 = os.path.join(\"/kaggle/input/open-wfi-1/openfwi_float16_1/\", row[\"data_fpath\"])\n            p2 = os.path.join(\"/kaggle/input/open-wfi-1/openfwi_float16_1/\", row[\"data_fpath\"].split(\"/\")[0], \"*\", row[\"data_fpath\"].split(\"/\")[-1])\n            p3 = os.path.join(\"/kaggle/input/open-wfi-2/openfwi_float16_2/\", row[\"data_fpath\"])\n            p4 = os.path.join(\"/kaggle/input/open-wfi-2/openfwi_float16_2/\", row[\"data_fpath\"].split(\"/\")[0], \"*\", row[\"data_fpath\"].split(\"/\")[-1])\n            farr = glob.glob(p1) + glob.glob(p2) + glob.glob(p3) + glob.glob(p4)\n            farr = farr[0]\n            flbl = farr.replace('seis', 'vel').replace('data', 'model')\n            arr = np.load(farr, mmap_mode=mmap_mode)\n            lbl = np.load(flbl, mmap_mode=mmap_mode)\n            data.append(arr)\n            labels.append(lbl)\n            records.append(row[\"dataset\"])\n        return data, labels, records\n\n    def __getitem__(self, idx):\n        row_idx = idx // 500\n        col_idx = idx % 500\n        d = self.records[row_idx]\n        x = self.data[row_idx][col_idx, ...].astype(np.float32) # Use float32 for augs\n        y = self.labels[row_idx][col_idx, ...].astype(np.float32)\n\n        # Augmentations for training mode\n        if self.mode == \"train\":\n            # Temporal flip (your original augmentation)\n            if np.random.random() < 0.5:\n                x = x[::-1, :, ::-1]\n                y = y[..., ::-1]\n\n            # --- NEW AUGMENTATIONS ---\n            # 1. Gain Adjustment\n            if np.random.random() < 0.5:\n                gain = np.random.uniform(0.9, 1.1)\n                x *= gain\n\n            # 2. Add Gaussian Noise\n            if np.random.random() < 0.5:\n                noise_level = np.random.uniform(0.005, 0.015)\n                x += np.random.normal(0, noise_level, x.shape).astype(x.dtype)\n            \n            # 3. Cutout / Masking\n            if np.random.random() < 0.5:\n                # Time masking\n                time_mask_size = np.random.randint(5, 15)\n                t0 = np.random.randint(0, x.shape[0] - time_mask_size)\n                x[t0:t0 + time_mask_size, :, :] = 0\n\n                # Receiver/channel masking\n                receiver_mask_size = np.random.randint(4, 10)\n                r0 = np.random.randint(0, x.shape[1] - receiver_mask_size)\n                x[:, r0:r0 + receiver_mask_size, :] = 0\n            # --- END NEW AUGMENTATIONS ---\n\n        x = x.copy()\n        y = y.copy()\n        \n        return x, y\n\n    def __len__(self):\n        return len(self.records) * 500","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-11T09:22:32.104728Z","iopub.execute_input":"2025-06-11T09:22:32.105388Z","iopub.status.idle":"2025-06-11T09:22:32.111439Z","shell.execute_reply.started":"2025-06-11T09:22:32.105362Z","shell.execute_reply":"2025-06-11T09:22:32.110704Z"}},"outputs":[{"name":"stdout","text":"Overwriting _dataset.py\n","output_type":"stream"}],"execution_count":44},{"cell_type":"markdown","source":"# Model\n\nThis time we use the `CAFormer` backbone from timm. See more info on this backbone [here](https://huggingface.co/timm/caformer_b36.sail_in22k_ft_in1k) and the original paper [here](https://arxiv.org/abs/2210.13452).\n\n\n### Encoder\n\nLike with Convnext, we modify the encoder so that the feature maps are aligned with the target output shape. I think there is room for improvement at the `nn.ReflectionPad2d` step. Currently, the model uses lots of padding here and I am afraid the detail in the shallowest feature map is lacking.\n\n### Decoder\n\nThe biggest changes in this notebook are to the decoder. \n\nFirst, we use PixelShuffle for upsampling. Pixelshuffle typically works well when fine detail is important, though it is more computatially expensive. Second, we add SCSE blocks. These are commonly used to increase decoder capacity with a minimal increase in parameter count and runtime. Finally, we add intermediate convolutions between the encoder output and decoder blocks. I beleive this trick was first introduced on Kaggle in the 3rd place solution of the Contrails Competition [here](https://www.kaggle.com/competitions/google-research-identify-contrails-redu), and also increases decoder capacity.","metadata":{}},{"cell_type":"code","source":"%%writefile Model.py\n\nfrom copy import deepcopy\nfrom types import MethodType\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nimport timm\n\nfrom monai.networks.blocks import UpSample, SubpixelUpsample\n\n####################\n## EMA + Ensemble ##\n####################\n\nclass ModelEMA(nn.Module):\n    def __init__(self, model, decay=0.99, device=None):\n        super().__init__()\n        self.module = deepcopy(model)\n        self.module.eval()\n        self.decay = decay\n        self.device = device\n        if self.device is not None:\n            self.module.to(device=device)\n\n    def _update(self, model, update_fn):\n        with torch.no_grad():\n            for ema_v, model_v in zip(self.module.state_dict().values(), model.state_dict().values()):\n                if self.device is not None:\n                    model_v = model_v.to(device=self.device)\n                ema_v.copy_(update_fn(ema_v, model_v))\n\n    def update(self, model):\n        self._update(model, update_fn=lambda e, m: self.decay * e + (1. - self.decay) * m)\n\n    def set(self, model):\n        self._update(model, update_fn=lambda e, m: m)\n\n\nclass EnsembleModel(nn.Module):\n    def __init__(self, models, weights=None): # Added weights parameter\n        super().__init__()\n        self.models = nn.ModuleList(models).eval()\n        self.weights = None\n        if weights is not None:\n            self.weights = torch.tensor(weights, dtype=torch.float32)\n            if self.weights.sum() != 0: # Avoid division by zero if all weights are zero\n                self.weights = self.weights / self.weights.sum() # Normalize weights\n\n    def forward(self, x):\n        output = None\n\n        for i, m in enumerate(self.models):\n            logits = m(x)\n\n            if output is None:\n                output = logits * (self.weights[i] if self.weights is not None else 1.0)\n            else:\n                output += logits * (self.weights[i] if self.weights is not None else 1.0)\n\n        if self.weights is None or self.weights.sum() == 0: # Default to equal weighting if no weights or sum is zero\n            output /= len(self.models)\n        return output\n\n\n#############\n## Decoder ##\n#############\n\nclass ConvBnAct2d(nn.Module):\n    def __init__(\n        self,\n        in_channels,\n        out_channels,\n        kernel_size,\n        padding: int = 0,\n        stride: int = 1,\n        norm_layer: nn.Module = nn.Identity,\n        act_layer: nn.Module = nn.ReLU,\n    ):\n        super().__init__()\n\n        self.conv= nn.Conv2d(\n            in_channels,\n            out_channels,\n            kernel_size,\n            stride=stride,\n            padding=padding,\n            bias=False,\n        )\n        self.norm = norm_layer(out_channels) if norm_layer != nn.Identity else nn.Identity()\n        self.act= act_layer(inplace=True)\n\n    def forward(self, x):\n        x = self.conv(x)\n        x = self.norm(x)\n        x = self.act(x)\n        return x\n\n\nclass SCSEModule2d(nn.Module):\n    def __init__(self, in_channels, reduction=16):\n        super().__init__()\n        self.cSE = nn.Sequential(\n            nn.AdaptiveAvgPool2d(1),\n            nn.Conv2d(in_channels, in_channels // reduction, 1),\n            nn.Tanh(),\n            nn.Conv2d(in_channels // reduction, in_channels, 1),\n            nn.Sigmoid(),\n        )\n        self.sSE = nn.Sequential(\n            nn.Conv2d(in_channels, 1, 1),\n            nn.Sigmoid(),\n            )\n\n    def forward(self, x):\n        return x * self.cSE(x) + x * self.sSE(x)\n\nclass Attention2d(nn.Module):\n    def __init__(self, name, **params):\n        super().__init__()\n        if name is None:\n            self.attention = nn.Identity(**params)\n        elif name == \"scse\":\n            self.attention = SCSEModule2d(**params)\n        else:\n            raise ValueError(\"Attention {} is not implemented\".format(name))\n\n    def forward(self, x):\n        return self.attention(x)\n\nclass DecoderBlock2d(nn.Module):\n    def __init__(\n        self,\\\n        in_channels,\n        skip_channels,\n        out_channels,\n        norm_layer: nn.Module = nn.Identity,\n        attention_type: str = None,\n        intermediate_conv: bool = False,\n        upsample_mode: str = \"deconv\",\n        scale_factor: int = 2,\n    ):\\\n        super().__init__()\n\n        # Upsample block\n        if upsample_mode == \"pixelshuffle\":\n            self.upsample= SubpixelUpsample(\n                spatial_dims= 2,\n                in_channels= in_channels,\n                scale_factor= scale_factor,\n            )\n        else:\n            self.upsample = UpSample(\n                spatial_dims= 2,\n                in_channels= in_channels,\n                out_channels= in_channels,\n                scale_factor= scale_factor,\n                mode= upsample_mode,\n            )\n\n        if intermediate_conv:\n            k= 3\n            c= skip_channels if skip_channels != 0 else in_channels\n            self.intermediate_conv = nn.Sequential(\n                ConvBnAct2d(c, c, k, k//2),\n                ConvBnAct2d(c, c, k, k//2),\n                )\n        else:\n            self.intermediate_conv= None\n\n        self.attention1 = Attention2d(\n            name= attention_type,\n            in_channels= in_channels + skip_channels,\n            )\n\n        self.conv1 = ConvBnAct2d(\n            in_channels + skip_channels,\n            out_channels,\n            kernel_size= 3,\n            padding= 1,\n            norm_layer= norm_layer,\n        )\n\n        self.conv2 = ConvBnAct2d(\n            out_channels,\n            out_channels,\n            kernel_size= 3,\n            padding= 1,\n            norm_layer= norm_layer,\n        )\n        self.attention2 = Attention2d(\n            name= attention_type,\n            in_channels= out_channels,\n            )\n\n    def forward(self, x, skip=None):\n        x = self.upsample(x)\n\n        if self.intermediate_conv is not None:\n            if skip is not None:\n                skip = self.intermediate_conv(skip)\n            else:\n                x = self.intermediate_conv(x)\n\n        if skip is not None:\n            # print(x.shape, skip.shape)\n            x = torch.cat([x, skip], dim=1)\n            x = self.attention1(x)\n\n        x = self.conv1(x)\n        x = self.conv2(x)\n        x = self.attention2(x)\n        return x\n\n\nclass UnetDecoder2d(nn.Module):\n    \"\"\"\n    Unet decoder.\n    Source: https://arxiv.org/abs/1505.04597\n    \"\"\"\n    def __init__(\n        self,\n        encoder_channels: tuple[int],\n        skip_channels: tuple[int] = None,\n        decoder_channels: tuple = (256, 128, 64, 32),\n        scale_factors: tuple = (2,2,2,2),\n        norm_layer: nn.Module = nn.Identity,\n        attention_type: str = \"scse\",\n        intermediate_conv: bool = True,\n        upsample_mode: str = \"pixelshuffle\",\n    ):\n        super().__init__()\n\n        if len(encoder_channels) == 4:\n            decoder_channels= decoder_channels[1:]\n        self.decoder_channels= decoder_channels\n\n        if skip_channels is None:\n            skip_channels= list(encoder_channels[1:]) + [0]\n\n        # Build decoder blocks\n        in_channels= [encoder_channels[0]] + list(decoder_channels[:-1])\n        self.blocks = nn.ModuleList()\n\n        for i, (ic, sc, dc) in enumerate(zip(in_channels, skip_channels, decoder_channels)):\n            # print(i, ic, sc, dc)\n            self.blocks.append(\n                DecoderBlock2d(\n                    ic, sc, dc,\n                    norm_layer= norm_layer,\n                    attention_type= attention_type,\n                    intermediate_conv= intermediate_conv,\n                    upsample_mode= upsample_mode,\n                    scale_factor= scale_factors[i],\n                    )\n            )\n\n    def forward(self, feats: list[torch.Tensor]):\n        res= [feats[0]]\n        feats= feats[1:]\n\n        # Decoder blocks\n        for i, b in enumerate(self.blocks):\n            skip= feats[i] if i < len(feats) else None\n            res.append(\n                b(res[-1], skip=skip),\n                )\n\n        return res\n\nclass SegmentationHead2d(nn.Module):\n    def __init__(\n        self,\n        in_channels,\n        out_channels,\n        scale_factor: tuple[int] = (2,2),\n        kernel_size: int = 3,\n        mode: str = \"nontrainable\",\n    ):\n        super().__init__()\n        self.conv= nn.Conv2d(\n            in_channels, out_channels, kernel_size= kernel_size,\n            padding= kernel_size//2\n        )\n        self.upsample = UpSample(\n            spatial_dims= 2,\n            in_channels= out_channels,\n            out_channels= out_channels,\n            scale_factor= scale_factor,\n            mode= mode,\n        )\n\n    def forward(self, x):\n        x = self.conv(x)\n        x = self.upsample(x)\n        return x\n\n\n#############\n## Encoder ##\n#############\n\nclass Net(nn.Module):\n    def __init__(\n        self,\n        backbone: str,\n        pretrained: bool = True,\n    ):\n        super().__init__()\n\n        # Encoder\n        self.backbone= timm.create_model(\n            backbone,\n            in_chans= 5,\n            pretrained= pretrained,\n            features_only= True,\n            drop_path_rate=0.0,\\\n            )\n        ecs= [_[\"num_chs\"] for _ in self.backbone.feature_info][::-1]\n\n        # Decoder\n        self.decoder= UnetDecoder2d(\n            encoder_channels= ecs,\n        )\n\n        self.seg_head= SegmentationHead2d(\n            in_channels= self.decoder.decoder_channels[-1],\n            out_channels= 1,\n            scale_factor= 1,\n        )\n\n        self._update_stem(backbone)\n\n    def _update_stem(self, backbone):\n        m = self.backbone\n\n        m.stem.conv.stride=(4,1)\n        m.stem.conv.padding=(0,4)\n        m.stages_0.downsample = nn.AvgPool2d(kernel_size=(4,1), stride=(4,1))\n        m.stem= nn.Sequential(\n            nn.ReflectionPad2d((0,0,78,78)),\n            m.stem,\n        )\n\n        pass\n\n\n    def proc_flip(self, x_in):\n        # This flip is now assumed to operate on the (C, H, W) input after initial loading\n        # The original code's interpretation of \"temporal flip\" on these dimensions is preserved.\n        x_in_flipped = torch.flip(x_in, dims=[0, 1, 2]) # Assuming 0=Channels, 1=H, 2=W for this flip\n        x= self.backbone(x_in_flipped)\n        x= x[::-1]\n\n        # Decoder\n        x= self.decoder(x)\n        x_seg= self.seg_head(x[-1])\n        x_seg= x_seg[..., 1:-1, 1:-1] # Original cropping\n        x_seg= torch.flip(x_seg, dims=[-1]) # Original flip\n        x_seg= x_seg * 1500 + 3000\n        return x_seg\n\n    def forward(self, batch):\n        x= batch\n\n        # Encoder\n        x_in = x\n        x= self.backbone(x)\n        # print([_.shape for _ in x])\n        x= x[::-1]\n\n        # Decoder\n        x= self.decoder(x)\n        # print([_.shape for _ in x])\n        x_seg= self.seg_head(x[-1])\n        x_seg= x_seg[..., 1:-1, 1:-1] # Original cropping\n        x_seg= x_seg * 1500 + 3000\n\n        if self.training:\n            return x_seg\n        else:\n            # Test-time augmentation (TTA) with the specific flip\n            p1 = self.proc_flip(x_in)\n            x_seg = torch.mean(torch.stack([x_seg, p1]), dim=0)\n            return x_seg","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-11T09:22:36.636359Z","iopub.execute_input":"2025-06-11T09:22:36.636637Z","iopub.status.idle":"2025-06-11T09:22:36.646208Z","shell.execute_reply.started":"2025-06-11T09:22:36.636617Z","shell.execute_reply":"2025-06-11T09:22:36.645334Z"}},"outputs":[{"name":"stdout","text":"Overwriting Model.py\n","output_type":"stream"}],"execution_count":45},{"cell_type":"markdown","source":"### Utils\n\nSame as previous notebook. ","metadata":{}},{"cell_type":"code","source":"import datetime\n\ndef format_time(elapsed):\n    elapsed_rounded = int(round((elapsed)))\n    return str(datetime.timedelta(seconds=elapsed_rounded))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-11T09:22:41.275245Z","iopub.execute_input":"2025-06-11T09:22:41.275979Z","iopub.status.idle":"2025-06-11T09:22:41.279613Z","shell.execute_reply.started":"2025-06-11T09:22:41.275956Z","shell.execute_reply":"2025-06-11T09:22:41.278798Z"}},"outputs":[],"execution_count":46},{"cell_type":"markdown","source":"### Pretrained Model\n\nNext, we load in the pretrained model. This model was trained with a batch size of 16 for 200 epochs.","metadata":{}},{"cell_type":"code","source":"import glob\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom _cfg import cfg\n\nif RUN_VALID or RUN_TEST:\n\n    # Load pretrained models\n    models = []\n    for f in sorted(glob.glob(\"/kaggle/input/openfwi-preprocessed-72x72/models_1000x70/unet2d_caformer*.pt\")):\n        print(\"Loading: \", f)\n        m = Net(\n            backbone=cfg.backbone,\n            pretrained=False,\n        )\n        state_dict= torch.load(f, map_location=cfg.device, weights_only=True)\n        state_dict= {k.removeprefix(\"_orig_mod.\"):v for k,v in state_dict.items()} # Remove torch.compile() prefix\n\n        m.load_state_dict(state_dict)\n        models.append(m)\n    \n    # Combine\n    model = EnsembleModel(models)\n    model = model.to(cfg.device)\n    model = model.eval()\n    print(\"n_models: {:_}\".format(len(models)))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-11T09:22:43.955005Z","iopub.execute_input":"2025-06-11T09:22:43.955728Z","iopub.status.idle":"2025-06-11T09:22:46.319695Z","shell.execute_reply.started":"2025-06-11T09:22:43.955704Z","shell.execute_reply":"2025-06-11T09:22:46.318998Z"}},"outputs":[{"name":"stdout","text":"Loading:  /kaggle/input/openfwi-preprocessed-72x72/models_1000x70/unet2d_caformer_seed3_epochbest.pt\nn_models: 1\n","output_type":"stream"}],"execution_count":47},{"cell_type":"markdown","source":"# Valid\n\nNext, we score the ensemble on the validation set.","metadata":{}},{"cell_type":"code","source":"from tqdm import tqdm\nimport numpy as np\n\nimport torch\nimport torch.nn as nn\nfrom torch.amp import autocast\n\nfrom _dataset import CustomDataset\n\n\nif RUN_VALID:\n\n    # Dataset / Dataloader\n    valid_ds = CustomDataset(cfg=cfg, mode=\"valid\")\n    sampler = torch.utils.data.SequentialSampler(valid_ds)\n    valid_dl = torch.utils.data.DataLoader(\n        valid_ds, \n        sampler= sampler,\n        batch_size= cfg.batch_size_val, \n        num_workers= 4,\n    )\n\n    # Valid loop\n    criterion = nn.L1Loss()\n    val_logits = []\n    val_targets = []\n    \n    with torch.no_grad():\n        for x, y in tqdm(valid_dl):\n            x = x.to(cfg.device)\n            y = y.to(cfg.device)\n    \n            with autocast(cfg.device.type):\n                out = model(x)\n    \n            val_logits.append(out.cpu())\n            val_targets.append(y.cpu())\n    \n        val_logits= torch.cat(val_logits, dim=0)\n        val_targets= torch.cat(val_targets, dim=0)\n    \n        total_loss= criterion(val_logits, val_targets).item()\n    \n    # Dataset Scores\n    ds_idxs= np.array([valid_ds.records])\n    ds_idxs= np.repeat(ds_idxs, repeats=500)\n    \n    print(\"=\"*25)\n    with torch.no_grad():    \n        for idx in sorted(np.unique(ds_idxs)):\n    \n            # Mask\n            mask = ds_idxs == idx\n            logits_ds = val_logits[mask]\n            targets_ds = val_targets[mask]\n    \n            # Score predictions\n            loss = criterion(val_logits[mask], val_targets[mask]).item()\n            print(\"{:15} {:.2f}\".format(idx, loss))\n    print(\"=\"*25)\n    print(\"Val MAE: {:.2f}\".format(total_loss))\n    print(\"=\"*25)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-11T09:22:51.468507Z","iopub.execute_input":"2025-06-11T09:22:51.469221Z","iopub.status.idle":"2025-06-11T09:22:53.81298Z","shell.execute_reply.started":"2025-06-11T09:22:51.469196Z","shell.execute_reply":"2025-06-11T09:22:53.811911Z"}},"outputs":[{"name":"stderr","text":"100%|██████████| 20/20 [00:00<00:00, 37.62it/s]\n","output_type":"stream"},{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m/tmp/ipykernel_115/3525267222.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m     \u001b[0;31m# Dataset / Dataloader\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m     \u001b[0mvalid_ds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCustomDataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcfg\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcfg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"valid\"\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[0msampler\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSequentialSampler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalid_ds\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     valid_dl = torch.utils.data.DataLoader(\n","\u001b[0;32m/kaggle/working/_dataset.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, cfg, mode)\u001b[0m\n\u001b[1;32m     41\u001b[0m             \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     42\u001b[0m             \u001b[0mlabels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlbl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m             \u001b[0mrecords\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"dataset\"\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     44\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrecords\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mTypeError\u001b[0m: ScaleIntensityRange.__init__() got an unexpected keyword argument 'a'"],"ename":"TypeError","evalue":"ScaleIntensityRange.__init__() got an unexpected keyword argument 'a'","output_type":"error"}],"execution_count":48},{"cell_type":"markdown","source":"# Test\n\nFinally, we make predictions on the test data.","metadata":{}},{"cell_type":"code","source":"import torch\n\nclass TestDataset(torch.utils.data.Dataset):\n    def __init__(self, test_files):\n        self.test_files = test_files\n\n    def __len__(self):\n        return len(self.test_files)\n\n    def __getitem__(self, i):\n        test_file = self.test_files[i]\n        test_stem = test_file.split(\"/\")[-1].split(\".\")[0]\n        return np.load(test_file), test_stem","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-05T10:13:36.866373Z","iopub.execute_input":"2025-06-05T10:13:36.867121Z","iopub.status.idle":"2025-06-05T10:13:36.871945Z","shell.execute_reply.started":"2025-06-05T10:13:36.867091Z","shell.execute_reply":"2025-06-05T10:13:36.871275Z"}},"outputs":[],"execution_count":10},{"cell_type":"code","source":"import csv\nimport time\nimport glob\nfrom tqdm import tqdm\nimport numpy as np\nimport pandas as pd\n\n\nif RUN_TEST:\n\n    ss= pd.read_csv(\"/kaggle/input/waveform-inversion/sample_submission.csv\")    \n    row_count = 0\n    t0 = time.time()\n    \n    test_files = sorted(glob.glob(\"/kaggle/input/open-wfi-test/test/*.npy\"))\n    x_cols = [f\"x_{i}\" for i in range(1, 70, 2)]\n    fieldnames = [\"oid_ypos\"] + x_cols\n    \n    test_ds = TestDataset(test_files)\n    test_dl = torch.utils.data.DataLoader(\n        test_ds, \n        sampler=torch.utils.data.SequentialSampler(test_ds),\n        batch_size=cfg.batch_size_val, \n        num_workers=4,\n    )\n    \n    with open(\"submission.csv\", \"wt\", newline=\"\") as csvfile:\n        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n        writer.writeheader()\n\n        with torch.inference_mode():\n            with torch.autocast(cfg.device.type):\n                for inputs, oids_test in tqdm(test_dl, total=len(test_dl)):\n                    inputs = inputs.to(cfg.device)\n            \n                    outputs = model(inputs)\n                            \n                    y_preds = outputs[:, 0].cpu().numpy()\n                    \n                    for y_pred, oid_test in zip(y_preds, oids_test):\n                        for y_pos in range(70):\n                            row = dict(zip(x_cols, [y_pred[y_pos, x_pos] for x_pos in range(1, 70, 2)]))\n                            row[\"oid_ypos\"] = f\"{oid_test}_y_{y_pos}\"\n            \n                            writer.writerow(row)\n                            row_count += 1\n\n                            # Clear buffer\n                            if row_count % 100_000 == 0:\n                                csvfile.flush()\n    \n    t1 = format_time(time.time() - t0)\n    print(f\"Inference Time: {t1}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-05T10:13:39.397652Z","iopub.execute_input":"2025-06-05T10:13:39.397919Z","iopub.status.idle":"2025-06-05T10:57:38.889468Z","shell.execute_reply.started":"2025-06-05T10:13:39.397899Z","shell.execute_reply":"2025-06-05T10:57:38.888508Z"}},"outputs":[{"name":"stderr","text":"100%|██████████| 4114/4114 [43:32<00:00,  1.57it/s]","output_type":"stream"},{"name":"stdout","text":"Inference Time: 0:43:34\n","output_type":"stream"},{"name":"stderr","text":"\n","output_type":"stream"}],"execution_count":11},{"cell_type":"markdown","source":"We can also view a few samples to make sure things look reasonable.","metadata":{}},{"cell_type":"code","source":"import matplotlib.pyplot as plt \n\nif RUN_TEST:\n    # Plot a few samples\n    fig, axes = plt.subplots(3, 5, figsize=(10, 6))\n    axes= axes.flatten()\n\n    n = min(len(outputs), len(axes))\n    \n    for i in range(n):\n        img= outputs[0, 0, ...].cpu().numpy()\n        img = outputs[i, 0].cpu().numpy()\n        idx= oids_test[i]\n    \n        # Plot\n        axes[i].imshow(img, cmap='gray')\n        axes[i].set_title(idx)\n        axes[i].axis('off')\n\n    for i in range(n, len(axes)):\n        axes[i].axis('off')\n    \n    plt.tight_layout()\n    plt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-05T10:58:17.5937Z","iopub.execute_input":"2025-06-05T10:58:17.594142Z","iopub.status.idle":"2025-06-05T10:58:18.690523Z","shell.execute_reply.started":"2025-06-05T10:58:17.594107Z","shell.execute_reply":"2025-06-05T10:58:18.689714Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1000x600 with 15 Axes>","image/png":"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\n"},"metadata":{}}],"execution_count":12},{"cell_type":"code","source":"!pip install --no-deps monai timm -q","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T09:41:58.760428Z","iopub.execute_input":"2025-06-12T09:41:58.760747Z","iopub.status.idle":"2025-06-12T09:41:58.914776Z","shell.execute_reply.started":"2025-06-12T09:41:58.760712Z","shell.execute_reply":"2025-06-12T09:41:58.913377Z"}},"outputs":[{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)","\u001b[0;32m/tmp/ipykernel_35/4063839522.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'pip install --no-deps monai timm -q'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/ipykernel/zmqshell.py\u001b[0m in \u001b[0;36msystem_piped\u001b[0;34m(self, cmd)\u001b[0m\n\u001b[1;32m    631\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_ns\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"_exit_code\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcmd\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    632\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[0;32m--> 633\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_ns\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"_exit_code\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar_expand\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcmd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdepth\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\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    634\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    635\u001b[0m     \u001b[0;31m# Ensure new system_piped implementation is used\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/IPython/utils/_process_posix.py\u001b[0m in \u001b[0;36msystem\u001b[0;34m(self, cmd)\u001b[0m\n\u001b[1;32m    160\u001b[0m                 \u001b[0;31m# res is the index of the pattern that caused the match, so we\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    161\u001b[0m                 \u001b[0;31m# know whether we've finished (if we matched EOF) or not\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 162\u001b[0;31m                 \u001b[0mres_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mchild\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpect_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpatterns\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_timeout\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    163\u001b[0m                 \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchild\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbefore\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mout_size\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'replace'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\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    164\u001b[0m                 \u001b[0mflush\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/local/lib/python3.11/dist-packages/pexpect/spawnbase.py\u001b[0m in \u001b[0;36mexpect_list\u001b[0;34m(self, pattern_list, timeout, searchwindowsize, async_, **kw)\u001b[0m\n\u001b[1;32m    381\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mexpect_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexp\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[1;32m    382\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[0;32m--> 383\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mexp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpect_loop\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    384\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    385\u001b[0m     def expect_exact(self, pattern_list, timeout=-1, searchwindowsize=-1,\n","\u001b[0;32m/usr/local/lib/python3.11/dist-packages/pexpect/expect.py\u001b[0m in \u001b[0;36mexpect_loop\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    167\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\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[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m                 \u001b[0;31m# Still have time left, so read more data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 169\u001b[0;31m                 \u001b[0mincoming\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mspawn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_nonblocking\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mspawn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmaxread\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    170\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspawn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdelayafterread\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    171\u001b[0m                     \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspawn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdelayafterread\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/pexpect/pty_spawn.py\u001b[0m in \u001b[0;36mread_nonblocking\u001b[0;34m(self, size, timeout)\u001b[0m\n\u001b[1;32m    456\u001b[0m         \u001b[0;31m# * https://github.com/pexpect/pexpect/pull/304\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    457\u001b[0m         \u001b[0;31m# * http://trac.sagemath.org/ticket/10295\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 458\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0mselect\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[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    459\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    460\u001b[0m                 \u001b[0mincoming\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mspawn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_nonblocking\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\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/pexpect/pty_spawn.py\u001b[0m in \u001b[0;36mselect\u001b[0;34m(timeout)\u001b[0m\n\u001b[1;32m    448\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    449\u001b[0m             \u001b[0;32mdef\u001b[0m \u001b[0mselect\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[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 450\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mselect_ignore_interrupts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchild_fd\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[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m)\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[0m\u001b[1;32m    451\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    452\u001b[0m         \u001b[0;31m# If there is data available to read right now, read as much as\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/pexpect/utils.py\u001b[0m in \u001b[0;36mselect_ignore_interrupts\u001b[0;34m(iwtd, owtd, ewtd, timeout)\u001b[0m\n\u001b[1;32m    141\u001b[0m     \u001b[0;32mwhile\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    142\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--> 143\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mselect\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miwtd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mowtd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mewtd\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    144\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mInterruptedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    145\u001b[0m             \u001b[0merr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexc_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mValueError\u001b[0m: filedescriptor out of range in select()"],"ename":"ValueError","evalue":"filedescriptor out of range in select()","output_type":"error"}],"execution_count":3},{"cell_type":"code","source":"# %% [markdown]\n# # Setup and Imports\n# This cell installs and imports all necessary libraries for the notebook.\n\n# %% [code]\n\n\nimport numpy as np\nimport pandas as pd\nimport glob\nimport os\nimport gc\nimport time\nimport csv\nimport math\nimport datetime\nfrom tqdm.notebook import tqdm\nfrom types import SimpleNamespace\nfrom copy import deepcopy\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.optim.lr_scheduler import _LRScheduler\nfrom torch.utils.data import Dataset, DataLoader, SequentialSampler\nfrom torch.amp import autocast, GradScaler\n\nimport timm\nfrom monai.networks.blocks import UpSample, SubpixelUpsample\nimport matplotlib.pyplot as plt\n\n# %% [markdown]\n# # Configuration\n# All hyperparameters and settings are controlled from this central configuration object.\n\n# %% [code]\ncfg = SimpleNamespace()\n\n# --- General ---\ncfg.seed = 42\ncfg.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\ncfg.debug = False # Set to True to run a quick test on a small subset of data\n\n# --- Model ---\ncfg.backbone = \"caformer_b36.sail_in22k_ft_in1k\"\ncfg.in_chans = 5\n\n# --- Data ---\ncfg.subsample = 10 if cfg.debug else None\ncfg.data_path_root = \"/kaggle/input/openfwi-preprocessed-72x72/\"\ncfg.folds_csv = os.path.join(cfg.data_path_root, \"folds.csv\")\n\n# --- Training ---\ncfg.folds_to_train = [0] if cfg.debug else [0, 1, 2, 3, 4] # Train on all 5 folds\ncfg.epochs = 2 if cfg.debug else 150\ncfg.batch_size_train = 8\ncfg.batch_size_val = 16\ncfg.num_workers = 2\n\n# --- Optimizer & Scheduler ---\ncfg.lr = 1e-4\ncfg.wd = 1e-5\ncfg.pct_cosine = 0.8 # Use 80% of training for cosine decay\n\n# %% [markdown]\n# # Utility Functions\n# This section contains helper classes and functions, like the learning rate scheduler.\n\n# %% [code]\ndef format_time(elapsed):\n    elapsed_rounded = int(round((elapsed)))\n    return str(datetime.timedelta(seconds=elapsed_rounded))\n\nclass ConstantCosineLR(_LRScheduler):\n    \"\"\"\n    Constant learning rate followed by CosineAnnealing.\n    \"\"\"\n    def __init__(self, optimizer, total_steps, pct_cosine, last_epoch=-1):\n        self.total_steps = total_steps\n        self.milestone = int(total_steps * (1 - pct_cosine))\n        self.cosine_steps = max(total_steps - self.milestone, 1)\n        self.min_lr = 0\n        super().__init__(optimizer, last_epoch)\n\n    def get_lr(self):\n        step = self.last_epoch + 1\n        if step <= self.milestone:\n            factor = 1.0\n        else:\n            s = step - self.milestone\n            factor = 0.5 * (1 + math.cos(math.pi * s / self.cosine_steps))\n        return [lr * factor for lr in self.base_lrs]\n\n# %% [markdown]\n# # Dataset with Augmentations\n# The updated `CustomDataset` class now includes advanced augmentations (Noise, Gain, Cutout) for the training set and is configured to handle k-fold cross-validation.\n\n# %% [code]\nclass CustomDataset(Dataset):\n    def __init__(self, cfg, mode=\"train\"):\n        self.cfg = cfg\n        self.mode = mode\n        self.data, self.labels, self.records = self.load_metadata()\n\n    def load_metadata(self):\n        df = pd.read_csv(self.cfg.folds_csv)\n        if self.cfg.subsample is not None:\n            df = df.groupby([\"dataset\", \"fold\"]).head(self.cfg.subsample)\n\n        if self.mode == \"train\":\n            df = df[df[\"fold\"] != self.cfg.fold_to_validate]\n        else:\n            df = df[df[\"fold\"] == self.cfg.fold_to_validate]\n\n        data, labels, records = [], [], []\n        mmap_mode = \"r\"\n        for idx, row in tqdm(df.iterrows(), total=len(df), desc=f\"Loading {self.mode} data for fold {self.cfg.fold_to_validate}\"):\n            row = row.to_dict()\n            p1 = os.path.join(\"/kaggle/input/open-wfi-1/openfwi_float16_1/\", row[\"data_fpath\"])\n            p2 = os.path.join(\"/kaggle/input/open-wfi-1/openfwi_float16_1/\", row[\"data_fpath\"].split(\"/\")[0], \"*\", row[\"data_fpath\"].split(\"/\")[-1])\n            p3 = os.path.join(\"/kaggle/input/open-wfi-2/openfwi_float16_2/\", row[\"data_fpath\"])\n            p4 = os.path.join(\"/kaggle/input/open-wfi-2/openfwi_float16_2/\", row[\"data_fpath\"].split(\"/\")[0], \"*\", row[\"data_fpath\"].split(\"/\")[-1])\n            farr = glob.glob(p1) + glob.glob(p2) + glob.glob(p3) + glob.glob(p4)\n            if not farr: continue\n            \n            farr = farr[0]\n            flbl = farr.replace('seis', 'vel').replace('data', 'model')\n            arr = np.load(farr, mmap_mode=mmap_mode)\n            lbl = np.load(flbl, mmap_mode=mmap_mode)\n            data.append(arr)\n            labels.append(lbl)\n            records.append(row[\"dataset\"])\n        return data, labels, records\n\n    def __getitem__(self, idx):\n        row_idx = idx // 500\n        col_idx = idx % 500\n        x = self.data[row_idx][col_idx, ...].astype(np.float32)\n        y = self.labels[row_idx][col_idx, ...].astype(np.float32)\n\n        # Augmentations for training mode\n        if self.mode == \"train\":\n            # Temporal flip\n            if np.random.random() < 0.5:\n                x = x[::-1, ::-1].copy() # Use .copy() after flips\n                y = y[..., ::-1].copy()\n\n            # Gain Adjustment\n            if np.random.random() < 0.5:\n                gain = np.random.uniform(0.9, 1.1)\n                x *= gain\n\n            # Add Gaussian Noise\n            if np.random.random() < 0.5:\n                noise_level = np.random.uniform(0.005, 0.015)\n                x += np.random.normal(0, noise_level, x.shape).astype(x.dtype)\n        \n            # Cutout / Masking (with safety checks)\n            if np.random.random() < 0.5:\n                # Time masking\n                time_mask_size = np.random.randint(5, 15)\n                # --- FIX: Only apply if the image is larger than the mask ---\n                if x.shape[0] > time_mask_size:\n                    t0 = np.random.randint(0, x.shape[0] - time_mask_size)\n                    # --- FIX: Corrected indexing for 2D array ---\n                    x[t0:t0 + time_mask_size, :] = 0\n\n                # Receiver/channel masking\n                receiver_mask_size = np.random.randint(4, 10)\n                # --- FIX: Only apply if the image is larger than the mask ---\n                if x.shape[1] > receiver_mask_size:\n                    r0 = np.random.randint(0, x.shape[1] - receiver_mask_size)\n                    # --- FIX: Corrected indexing for 2D array ---\n                    x[:, r0:r0 + receiver_mask_size] = 0\n\n    # The model expects a channel dimension.\n    # Reshape (H, W) -> (C, H, W) if it's not already.\n    # Based on your model, it seems to handle this internally, but if not,\n    # you might need to add a channel dimension here.\n    # Example: x = np.expand_dims(x, axis=0)\n    \n        return x.copy(), y.copy()\n\n    def __len__(self):\n        return len(self.records) * 500\n\n# %% [markdown]\n# # Model Architecture\n# This section contains the full model definition, including the U-Net style decoder and the `EnsembleModel` wrapper. This code is taken directly from your notebook.\n\n# %% [code]\nclass ModelEMA(nn.Module):\n    # ... (code from your notebook)\n    def __init__(self, model, decay=0.99, device=None):\n        super().__init__()\n        self.module = deepcopy(model)\n        self.module.eval()\n        self.decay = decay\n        self.device = device\n        if self.device is not None:\n            self.module.to(device=device)\n\n    def _update(self, model, update_fn):\n        with torch.no_grad():\n            for ema_v, model_v in zip(self.module.state_dict().values(), model.state_dict().values()):\n                if self.device is not None:\n                    model_v = model_v.to(device=self.device)\n                ema_v.copy_(update_fn(ema_v, model_v))\n\n    def update(self, model):\n        self._update(model, update_fn=lambda e, m: self.decay * e + (1. - self.decay) * m)\n\n    def set(self, model):\n        self._update(model, update_fn=lambda e, m: m)\n\n\nclass EnsembleModel(nn.Module):\n    # ... (code from your notebook)\n    def __init__(self, models):\n        super().__init__()\n        self.models = nn.ModuleList(models)\n        self.eval()\n\n    def forward(self, x):\n        output = None\n        for m in self.models:\n            logits= m(x)\n            if output is None:\n                output = logits\n            else:\n                output += logits\n        output /= len(self.models)\n        return output\n\nclass ConvBnAct2d(nn.Module):\n    # ... (code from your notebook)\n    def __init__(self, in_channels, out_channels, kernel_size, padding: int = 0, stride: int = 1, norm_layer: nn.Module = nn.Identity, act_layer: nn.Module = nn.ReLU):\n        super().__init__()\n        self.conv= nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, bias=False)\n        self.norm = norm_layer(out_channels) if norm_layer != nn.Identity else nn.Identity()\n        self.act= act_layer(inplace=True)\n\n    def forward(self, x):\n        x = self.conv(x)\n        x = self.norm(x)\n        x = self.act(x)\n        return x\n\nclass SCSEModule2d(nn.Module):\n    # ... (code from your notebook)\n    def __init__(self, in_channels, reduction=16):\n        super().__init__()\n        self.cSE = nn.Sequential(nn.AdaptiveAvgPool2d(1), nn.Conv2d(in_channels, in_channels // reduction, 1), nn.Tanh(), nn.Conv2d(in_channels // reduction, in_channels, 1), nn.Sigmoid())\n        self.sSE = nn.Sequential(nn.Conv2d(in_channels, 1, 1), nn.Sigmoid())\n\n    def forward(self, x):\n        return x * self.cSE(x) + x * self.sSE(x)\n\nclass Attention2d(nn.Module):\n    # ... (code from your notebook)\n    def __init__(self, name, **params):\n        super().__init__()\n        if name is None: self.attention = nn.Identity(**params)\n        elif name == \"scse\": self.attention = SCSEModule2d(**params)\n        else: raise ValueError(f\"Attention {name} is not implemented\")\n\n    def forward(self, x):\n        return self.attention(x)\n\nclass DecoderBlock2d(nn.Module):\n    # ... (code from your notebook)\n    def __init__(self, in_channels, skip_channels, out_channels, norm_layer: nn.Module = nn.Identity, attention_type: str = None, intermediate_conv: bool = False, upsample_mode: str = \"deconv\", scale_factor: int = 2):\n        super().__init__()\n        if upsample_mode == \"pixelshuffle\": self.upsample= SubpixelUpsample(spatial_dims=2, in_channels=in_channels, scale_factor=scale_factor)\n        else: self.upsample = UpSample(spatial_dims=2, in_channels=in_channels, out_channels=in_channels, scale_factor=scale_factor, mode=upsample_mode)\n        \n        if intermediate_conv:\n            k=3\n            c= skip_channels if skip_channels !=0 else in_channels\n            self.intermediate_conv = nn.Sequential(ConvBnAct2d(c,c,k,k//2), ConvBnAct2d(c,c,k,k//2))\n        else: self.intermediate_conv=None\n\n        self.attention1 = Attention2d(name=attention_type, in_channels=in_channels + skip_channels)\n        self.conv1 = ConvBnAct2d(in_channels+skip_channels, out_channels, kernel_size=3, padding=1, norm_layer=norm_layer)\n        self.conv2 = ConvBnAct2d(out_channels, out_channels, kernel_size=3, padding=1, norm_layer=norm_layer)\n        self.attention2 = Attention2d(name=attention_type, in_channels=out_channels)\n        \n    def forward(self, x, skip=None):\n        x = self.upsample(x)\n        if self.intermediate_conv is not None:\n            if skip is not None: skip = self.intermediate_conv(skip)\n            else: x = self.intermediate_conv(x)\n        if skip is not None:\n            x = torch.cat([x, skip], dim=1)\n            x = self.attention1(x)\n        x = self.conv1(x)\n        x = self.conv2(x)\n        x = self.attention2(x)\n        return x\n\nclass UnetDecoder2d(nn.Module):\n    # ... (code from your notebook)\n    def __init__(self, encoder_channels: tuple[int], skip_channels: tuple[int] = None, decoder_channels: tuple = (256, 128, 64, 32), scale_factors: tuple = (2,2,2,2), norm_layer: nn.Module = nn.Identity, attention_type: str = \"scse\", intermediate_conv: bool = True, upsample_mode: str = \"pixelshuffle\"):\n        super().__init__()\n        if len(encoder_channels) == 4: decoder_channels = decoder_channels[1:]\n        self.decoder_channels = decoder_channels\n        if skip_channels is None: skip_channels = list(encoder_channels[1:]) + [0]\n        in_channels = [encoder_channels[0]] + list(decoder_channels[:-1])\n        self.blocks = nn.ModuleList()\n        for i, (ic, sc, dc) in enumerate(zip(in_channels, skip_channels, decoder_channels)):\n            self.blocks.append(DecoderBlock2d(ic, sc, dc, norm_layer=norm_layer, attention_type=attention_type, intermediate_conv=intermediate_conv, upsample_mode=upsample_mode, scale_factor=scale_factors[i]))\n    \n    def forward(self, feats: list[torch.Tensor]):\n        res = [feats[0]]\n        feats = feats[1:]\n        for i, b in enumerate(self.blocks):\n            skip = feats[i] if i < len(feats) else None\n            res.append(b(res[-1], skip=skip))\n        return res\n\nclass SegmentationHead2d(nn.Module):\n    # ... (code from your notebook)\n    def __init__(self, in_channels, out_channels, scale_factor: tuple[int] = (2,2), kernel_size: int = 3, mode: str = \"nontrainable\"):\n        super().__init__()\n        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, padding=kernel_size//2)\n        self.upsample = UpSample(spatial_dims=2, in_channels=out_channels, out_channels=out_channels, scale_factor=scale_factor, mode=mode)\n    \n    def forward(self, x):\n        x = self.conv(x)\n        x = self.upsample(x)\n        return x\n\nclass Net(nn.Module):\n    # ... (code from your notebook, with minor adjustment for cfg.in_chans)\n    def __init__(self, backbone: str, pretrained: bool = True):\n        super().__init__()\n        self.backbone = timm.create_model(backbone, in_chans=cfg.in_chans, pretrained=pretrained, features_only=True, drop_path_rate=0.0)\n        ecs = [_[\"num_chs\"] for _ in self.backbone.feature_info][::-1]\n        self.decoder = UnetDecoder2d(encoder_channels=ecs)\n        self.seg_head = SegmentationHead2d(in_channels=self.decoder.decoder_channels[-1], out_channels=1, scale_factor=1)\n        self._update_stem(backbone)\n        \n    def _update_stem(self, backbone):\n        m = self.backbone\n        m.stem.conv.stride = (4, 1)\n        m.stem.conv.padding = (0, 4)\n        m.stages_0.downsample = nn.AvgPool2d(kernel_size=(4, 1), stride=(4, 1))\n        m.stem = nn.Sequential(nn.ReflectionPad2d((0, 0, 78, 78)), m.stem)\n        \n    def proc_flip(self, x_in):\n        x_in = torch.flip(x_in, dims=[-3, -1])\n        x = self.backbone(x_in)\n        x = x[::-1]\n        x = self.decoder(x)\n        x_seg = self.seg_head(x[-1])\n        x_seg = x_seg[..., 1:-1, 1:-1]\n        x_seg = torch.flip(x_seg, dims=[-1])\n        x_seg = x_seg * 1500 + 3000\n        return x_seg\n        \n    def forward(self, batch):\n        x_in = batch\n        x = self.backbone(x_in)\n        x = x[::-1]\n        x = self.decoder(x)\n        x_seg = self.seg_head(x[-1])\n        x_seg = x_seg[..., 1:-1, 1:-1]\n        x_seg = x_seg * 1500 + 3000\n        if self.training:\n            return x_seg\n        else:\n            p1 = self.proc_flip(x_in)\n            return torch.mean(torch.stack([x_seg, p1]), dim=0)\n            \n# %% [markdown]\n# # K-Fold Training Loop\n# This is the main training logic. It iterates through the folds defined in `cfg.folds_to_train`, training one model per fold and saving the one with the best validation MAE.\n\n# %% [code]\ndef train_one_epoch(model, loader, optimizer, scaler, criterion):\n    model.train()\n    total_loss = 0.0\n    \n    for x, y in tqdm(loader, desc=\"Training\"):\n        x, y = x.to(cfg.device), y.to(cfg.device)\n        \n        optimizer.zero_grad()\n        \n        with autocast(device_type=cfg.device.type):\n            preds = model(x)\n            loss = criterion(preds, y)\n\n        scaler.scale(loss).backward()\n        scaler.step(optimizer)\n        scaler.update()\n        \n        total_loss += loss.item()\n        \n    return total_loss / len(loader)\n\n\ndef validate_one_epoch(model, loader, criterion):\n    model.eval()\n    total_loss = 0.0\n    \n    with torch.no_grad():\n        for x, y in tqdm(loader, desc=\"Validating\"):\n            x, y = x.to(cfg.device), y.to(cfg.device)\n            \n            with autocast(device_type=cfg.device.type):\n                preds = model(x)\n                loss = criterion(preds, y)\n                \n            total_loss += loss.item()\n            \n    return total_loss / len(loader)\n\n# --- Main Training Execution ---\nif __name__ == \"__main__\":\n    \n    all_fold_metrics = []\n    \n    for fold_num in cfg.folds_to_train:\n        print(f\"\\n========== FOLD {fold_num} ==========\")\n        cfg.fold_to_validate = fold_num\n        \n        # Create datasets and dataloaders\n        train_ds = CustomDataset(cfg, mode=\"train\")\n        valid_ds = CustomDataset(cfg, mode=\"valid\")\n        \n        train_dl = DataLoader(train_ds, batch_size=cfg.batch_size_train, shuffle=True, num_workers=cfg.num_workers)\n        valid_dl = DataLoader(valid_ds, batch_size=cfg.batch_size_val, shuffle=False, num_workers=cfg.num_workers)\n        \n        # Initialize model, optimizer, etc.\n        model = Net(cfg.backbone, pretrained=True).to(cfg.device)\n        optimizer = torch.optim.AdamW(model.parameters(), lr=cfg.lr, weight_decay=cfg.wd)\n        \n        num_train_steps = len(train_dl) * cfg.epochs\n        scheduler = ConstantCosineLR(optimizer, total_steps=num_train_steps, pct_cosine=cfg.pct_cosine)\n        \n        criterion = nn.L1Loss()\n        scaler = GradScaler()\n        \n        best_val_mae = float('inf')\n        \n        for epoch in range(cfg.epochs):\n            epoch_start_time = time.time()\n            \n            train_loss = train_one_epoch(model, train_dl, optimizer, scaler, criterion)\n            val_loss = validate_one_epoch(model, valid_dl, criterion)\n            scheduler.step()\n            \n            epoch_time = format_time(time.time() - epoch_start_time)\n            print(f\"Epoch {epoch+1}/{cfg.epochs} | Train Loss: {train_loss:.4f} | Val MAE: {val_loss:.4f} | Time: {epoch_time}\")\n            \n            if val_loss < best_val_mae:\n                best_val_mae = val_loss\n                model_path = f\"caformer_fold{fold_num}_best_mae_{val_loss:.4f}.pt\"\n                print(f\"Validation MAE improved. Saving model to {model_path}\")\n                torch.save(model.state_dict(), model_path)\n        \n        all_fold_metrics.append(best_val_mae)\n        del model, optimizer, scheduler, train_ds, valid_ds, train_dl, valid_dl\n        gc.collect()\n        torch.cuda.empty_cache()\n        \n    print(f\"\\nK-Fold Training Finished. CV MAE: {np.mean(all_fold_metrics):.4f}\")\n\n\n# %% [markdown]\n# # Inference and Submission\n# This section loads the ensemble of best models from the k-fold training, runs predictions on the test set, and generates the `submission.csv` file.\n\n# %% [code]\nclass TestDataset(Dataset):\n    def __init__(self, test_files):\n        self.test_files = test_files\n    def __len__(self):\n        return len(self.test_files)\n    def __getitem__(self, i):\n        test_file = self.test_files[i]\n        test_stem = os.path.splitext(os.path.basename(test_file))[0]\n        return np.load(test_file).astype(np.float32), test_stem\n\nif __name__ == \"__main__\":\n    # --- Load Ensemble of Models ---\n    models_to_ensemble = []\n    model_paths = glob.glob(\"caformer_fold*_best_mae_*.pt\")\n    \n    if not model_paths:\n        print(\"No trained models found. Please run the training loop first.\")\n    else:\n        print(f\"Loading {len(model_paths)} models for ensembling...\")\n        for path in model_paths:\n            print(f\"  - Loading {path}\")\n            m = Net(cfg.backbone, pretrained=False)\n            state_dict = torch.load(path, map_location=cfg.device)\n            m.load_state_dict(state_dict)\n            models_to_ensemble.append(m)\n\n        ensemble_model = EnsembleModel(models_to_ensemble).to(cfg.device)\n        ensemble_model.eval()\n\n        # --- Create Test Dataloader ---\n        test_files = sorted(glob.glob(\"/kaggle/input/open-wfi-test/test/*.npy\"))\n        test_ds = TestDataset(test_files)\n        test_dl = DataLoader(\n            test_ds, \n            batch_size=cfg.batch_size_val, \n            sampler=SequentialSampler(test_ds),\n            num_workers=cfg.num_workers,\n        )\n\n        # --- Generate Submission ---\n        row_count = 0\n        t0 = time.time()\n        x_cols = [f\"x_{i}\" for i in range(1, 70, 2)]\n        fieldnames = [\"oid_ypos\"] + x_cols\n        \n        with open(\"submission.csv\", \"w\", newline=\"\") as csvfile:\n            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n            writer.writeheader()\n\n            with torch.inference_mode():\n                for inputs, oids_test in tqdm(test_dl, desc=\"Generating Submission\"):\n                    inputs = inputs.to(cfg.device)\n                    \n                    with autocast(device_type=cfg.device.type):\n                        outputs = ensemble_model(inputs)\n                    \n                    y_preds = outputs[:, 0].cpu().numpy()\n                    \n                    for y_pred, oid_test in zip(y_preds, oids_test):\n                        for y_pos in range(70):\n                            row = dict(zip(x_cols, [y_pred[y_pos, x_pos] for x_pos in range(1, 70, 2)]))\n                            row[\"oid_ypos\"] = f\"{oid_test}_y_{y_pos}\"\n                            writer.writerow(row)\n                            row_count += 1\n                            if row_count % 100_000 == 0:\n                                csvfile.flush()\n        \n        t1 = format_time(time.time() - t0)\n        print(f\"Inference complete. Time: {t1}\")\n\n        # --- Plot a few samples ---\n        fig, axes = plt.subplots(3, 5, figsize=(10, 6))\n        axes = axes.flatten()\n        n = min(len(outputs), len(axes))\n        for i in range(n):\n            img = outputs[i, 0].cpu().numpy()\n            idx = oids_test[i]\n            axes[i].imshow(img, cmap='gray')\n            axes[i].set_title(idx)\n            axes[i].axis('off')\n        for i in range(n, len(axes)):\n            axes[i].axis('off')\n        plt.tight_layout()\n        plt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T09:42:11.040052Z","iopub.execute_input":"2025-06-12T09:42:11.040377Z"}},"outputs":[{"name":"stdout","text":"\n========== FOLD 0 ==========\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"Loading train data for fold 0:   0%|          | 0/920 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"88be2f6831fe490da3dba494033c0a91"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Loading valid data for fold 0:   0%|          | 0/20 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"70a89178b8fa4348899266b69179d2f7"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Training:   0%|          | 0/57500 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"8ff978457ea24e1e8776ad57f7a4238b"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"Validating:   0%|          | 0/625 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"9d211b89743f4e49b8d4617b81c69a83"}},"metadata":{}},{"name":"stdout","text":"Epoch 1/150 | Train Loss: 171.5441 | Val MAE: 116.7405 | Time: 8:08:15\nValidation MAE improved. Saving model to caformer_fold0_best_mae_116.7405.pt\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"Training:   0%|          | 0/57500 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"30355145f6194af3a45441486e45c84e"}},"metadata":{}}],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}