Upload semanticallysegmentdeezglaciers.ipynb

semanticallysegmentdeezglaciers.ipynb

@@ -2,7 +2,7 @@
   "cells": [
     {
       "cell_type": "code",
-      "execution_count": 1,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -10,24 +10,7 @@
         "id": "c0C76YvrvDbu",
         "outputId": "526c8200-e257-45d7-89ec-6c4d6f30d5d0"
       },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "1\n",
-            "2\n",
-            "3\n",
-            "4\n",
-            "5\n",
-            "5.1\n",
-            "5.2\n",
-            "5.3\n",
-            "6\n",
-            "7\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "import torch\n",
         "import matplotlib.pyplot as plt\n",
@@ -68,7 +51,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 22,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -156,43 +139,12 @@
         "id": "kOiKU_-vvDb1",
         "outputId": "531092ef-a3b9-4156-9d9c-a1835feece0a"
       },
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "Found cached dataset parquet (C:/Users/aashr/.cache/huggingface/datasets/glacierscopessegmentation___parquet/glacierscopessegmentation--secondleg-718284968c2f234c/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n"
-          ]
-        },
-        {
-          "data": {
-            "application/vnd.jupyter.widget-view+json": {
-              "model_id": "593aa8d59e094d338a2fc5cf0121e1db",
-              "version_major": 2,
-              "version_minor": 0
-            },
-            "text/plain": [
-              "  0%|          | 0/1 [00:00<?, ?it/s]"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        },
-        {
-          "data": {
-            "text/plain": [
-              "(8033, 423)"
-            ]
-          },
-          "execution_count": 22,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
+      "outputs": [],
       "source": [
-        "ds = load_dataset(\"glacierscopessegmentation/secondleg\")\n",
+        "ds = load_dataset(\"glacierscopessegmentation/scopes\",keep_in_memory=True,)\n",
+        "ds = datasets.concatenate_datasets((ds[\"test\"], ds[\"train\"]))\n",
         "\n",
-        "ds = ds[\"train\"].train_test_split(.05)\n",
+        "ds = ds.train_test_split(.05)\n",
         "train_ds = ds[\"train\"]\n",
         "test_ds = ds[\"test\"]\n",
         "\n",
@@ -211,7 +163,33 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 17,
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "ds = load_dataset(\"glacierscopessegmentation/scopes\",keep_in_memory=True,)\n",
+        "# ds = datasets.concatenate_datasets((ds[\"test\"], ds[\"train\"]))\n",
+        "\n",
+        "# ds = ds.train_test_split(.05)\n",
+        "# train_ds = ds[\"train\"]\n",
+        "# test_ds = ds[\"test\"]\n",
+        "\n",
+        "id2label = {\n",
+        "    \"0\": \"sky\", # This is given by the rgb value of 00 00 00 for the mask\n",
+        "    \"1\": \"surface-to-bed\", # This is given by the rgb value of 01 01 01 for the mask\n",
+        "    \"2\": \"bed-to-bottom\", # This is given by the rgb value of 02 02 02 for the mask\n",
+        "}\n",
+        "\n",
+        "id2label = {int(k): v for k, v in id2label.items()}\n",
+        "label2id = {v: k for k, v in id2label.items()}\n",
+        "num_labels = len(id2label)\n",
+        "\n",
+        "len(train_ds), len(test_ds)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -233,20 +211,7 @@
         "id": "PAvIJWo1vDb3",
         "outputId": "06c909f3-8500-49f6-bca7-b475b1d86885"
       },
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "c:\\Program Files\\Python310\\lib\\site-packages\\transformers\\models\\segformer\\image_processing_segformer.py:99: FutureWarning: The `reduce_labels` parameter is deprecated and will be removed in a future version. Please use `do_reduce_labels` instead.\n",
-            "  warnings.warn(\n",
-            "C:\\Users\\aashr\\AppData\\Roaming\\Python\\Python310\\site-packages\\torch\\storage.py:315: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly.\n",
-            "  warnings.warn(message, UserWarning)\n",
-            "Some weights of SegformerForSemanticSegmentation were not initialized from the model checkpoint at nvidia/MiT-b0 and are newly initialized: ['decode_head.linear_c.3.proj.weight', 'decode_head.linear_fuse.weight', 'decode_head.classifier.weight', 'decode_head.batch_norm.bias', 'decode_head.linear_c.1.proj.bias', 'decode_head.linear_c.0.proj.bias', 'decode_head.linear_c.1.proj.weight', 'decode_head.linear_c.0.proj.weight', 'decode_head.batch_norm.running_mean', 'decode_head.linear_c.3.proj.bias', 'decode_head.linear_c.2.proj.weight', 'decode_head.batch_norm.num_batches_tracked', 'decode_head.batch_norm.running_var', 'decode_head.classifier.bias', 'decode_head.linear_c.2.proj.bias', 'decode_head.batch_norm.weight']\n",
-            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Define the checkpoint from which to load the pre-trained model preprocessor\n",
         "checkpoint = \"nvidia/MiT-b0\" # We need to use this processor for resizing the images from the dataset to the size expected by the model; the main problem with this is the output scaling for training and testing, so using the right prepreocessor is important\n",
@@ -267,13 +232,15 @@
         "test_image_processor = SegformerImageProcessor.from_pretrained(checkpoint)\n",
         "\n",
         "# Create a Segformer model for semantic segmentation using the test configuration and move it to the GPU\n",
-        "test_model = SegformerForSemanticSegmentation(test_config).to(\"cuda:0\")\n",
-        "\n"
+        "\n",
+        "# The line below initializes a blank model, while the new line initializes the model from the huggingface hub\n",
+        "# test_model = SegformerForSemanticSegmentation(test_config).to(\"cuda:0\")\n",
+        "test_model = SegformerForSemanticSegmentation.from_pretrained(hf_model_name,id2label = id2label, label2id = label2id).to(\"cuda:0\")\n"
       ]
     },
     {
       "cell_type": "code",
-      "execution_count": 13,
+      "execution_count": null,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -291,7 +258,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 24,
+      "execution_count": null,
       "metadata": {
         "id": "L-Eojv9VvDb3"
       },
@@ -337,15 +304,21 @@
         "        # This is input that has gone through the model's forward pass\n",
         "        logits, labels = eval_pred\n",
         "        logits_tensor = torch.from_numpy(logits)\n",
+        "        \n",
+        "        logits_tensor = logits_tensor.argmax(dim=1)\n",
+        "        logits_tensor = logits_tensor.unsqueeze(1).to(float)\n",
         "        # this can lead to very high ram usage for the upscaling\n",
         "        logits_tensor = nn.functional.interpolate(\n",
         "            logits_tensor,\n",
-        "            size=labels.shape[-2:],\n",
+        "            size = labels.shape[-2:],\n",
         "            mode=\"bilinear\",\n",
         "            align_corners=False,\n",
         "        )\n",
+        "\n",
+        "        # logits_tensor = logits_tensor.argmax(dim=1)\n",
+        "        logits_tensor = torch.squeeze(logits_tensor,dim = 1)\n",
+        "\n",
         "        # Take the argmax of the logits tensor along dimension 1 to get the predicted labels\n",
-        "        logits_tensor = logits_tensor.argmax(dim=1)\n",
         "        # Detach the predicted labels from the computation graph and move them to the CPU \n",
         "        # (although they are already on the CPU) to save memory and to use numpy features like the metrics module\n",
         "        pred_labels = logits_tensor.detach().cpu().numpy()\n",
@@ -374,15 +347,15 @@
         "training_args = TrainingArguments(\n",
         "    output_dir=\"glacformer\",  # The output directory for the model predictions and checkpoints\n",
         "    learning_rate=6e-5,  # The initial learning rate for Adam\n",
-        "    num_train_epochs=1,  # Total number of training epochs to perform\n",
+        "    num_train_epochs=6,  # Total number of training epochs to perform\n",
         "    auto_find_batch_size=True,  # Whether to automatically find an appropriate batch size\n",
         "    save_total_limit=3,  # Limit the total amount of checkpoints and delete the older checkpoints\n",
-        "    eval_accumulation_steps=0,  # Number of steps to accumulate gradients before performing a backward/update pass\n",
+        "    # eval_accumulation_steps=1,  # Number of steps to accumulate gradients before performing a backward/update pass\n",
         "    evaluation_strategy=\"epoch\",  # The evaluation strategy to adopt during training\n",
         "    save_strategy=\"epoch\",  # The checkpoint save strategy to adopt during training\n",
         "    save_steps=1,  # Number of updates steps before two checkpoint saves\n",
         "    eval_steps=1,  # Number of update steps before two evaluations\n",
-        "    logging_steps=30,  # Number of update steps before logging learning rate and other metrics\n",
+        "    # logging_steps=30,  # Number of update steps before logging learning rate and other metrics\n",
         "    remove_unused_columns=False,  # Whether to remove columns not used by the model when using a dataset\n",
         "    fp16=True,  # Whether to use 16-bit float precision instead of 32-bit for saving memory\n",
         "    tf32=True,  # Whether to use tf32 precision instead of 32-bit for saving memory\n",
@@ -400,6 +373,13 @@
         ")"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -419,12 +399,21 @@
         "trainer.model.save_pretrained(\"glacformer\")\n",
         "\n",
         "# Create a repository object for the specified repository on Hugging Face's hub, cloning from the specified source\n",
-        "repo = huggingface_hub.Repository(\"glacformer\", clone_from=hf_model_name)\n",
+        "repo = huggingface_hub.Repository(\"glacformer1\", clone_from=hf_model_name)\n",
+        "\n",
+        "! cp -r glacformer/* glacformer1/\n",
         "\n",
         "repo.git_pull()\n",
         "repo.push_to_hub()"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -486,6 +475,287 @@
         "\n",
         "glacformer.display(display)"
       ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "032abac7315f4925b32b07a1dd8e8db3",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Map:   0%|          | 0/1848 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "34a7142f36734fff959971c8c335b1c0",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Pushing dataset shards to the dataset hub:   0%|          | 0/1 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "8be902f9846b426c82d9c2ea0bccf561",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Creating parquet from Arrow format:   0%|          | 0/19 [00:00<?, ?ba/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "607b7ae0e6d345cfbec7ebf10c6e38ac",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Deleting unused files from dataset repository:   0%|          | 0/6 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "e5d424e575d54d5abfb984ef40d16fb7",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Map:   0%|          | 0/5851 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "09796dba22ff47d5ba3204dbe0c79ae1",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Pushing dataset shards to the dataset hub:   0%|          | 0/6 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "c98ca8c9d2264ac6bf8cc2a48e0ed268",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Creating parquet from Arrow format:   0%|          | 0/59 [00:00<?, ?ba/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "520f907923fe4f8e9d52e274eca484c6",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Map:   0%|          | 0/5850 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "304c1699e4e547e49b99b98efb0c92de",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Creating parquet from Arrow format:   0%|          | 0/59 [00:00<?, ?ba/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "c6586231c59049018016158fb6794f61",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Map:   0%|          | 0/5850 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "f07e6acfc0d74df9a33aafb88afa8821",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Creating parquet from Arrow format:   0%|          | 0/59 [00:00<?, ?ba/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "12fdc097fbf44edd95eccb5c6c953f3a",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Map:   0%|          | 0/5850 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "9a20d65772b245f5bff202c4f6ed0141",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Creating parquet from Arrow format:   0%|          | 0/59 [00:00<?, ?ba/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "2911bb4684894749b9188e1cd9e5d977",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Map:   0%|          | 0/5850 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "397fc1c8116f4280a49160432314e4d6",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Creating parquet from Arrow format:   0%|          | 0/59 [00:00<?, ?ba/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "aa14f6db540e4633a84ef3edfffec6a3",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Map:   0%|          | 0/5850 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "7c675a39c05a4288bce0248991e7a568",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Creating parquet from Arrow format:   0%|          | 0/59 [00:00<?, ?ba/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "ad22a4f84b56495e86319a5715064cb9",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Deleting unused files from dataset repository:   0%|          | 0/1 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "ab8fcfdc61534e718e2672baf9b103b4",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading metadata:   0%|          | 0.00/664 [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "from datasets import DatasetDict\n",
+        "\n",
+        "dd = DatasetDict({\"test\":test_ds,\"train\":train_ds})\n",
+        "\n",
+        "dd.push_to_hub(\"glacierscopessegmentation/scopes\")\n",
+        "\n"
+      ]
     }
   ],
   "metadata": {
@@ -508,7 +778,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.10.11"
+      "version": "3.11.5"
     },
     "widgets": {
       "application/vnd.jupyter.widget-state+json": {