Upload oam_vibe_mapping.ipynb with huggingface_hub

oam_vibe_mapping.ipynb

@@ -0,0 +1,647 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b0d58627-d2bc-4a99-834f-ed3427785333",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import h5py\n",
+    "from tqdm import tqdm, trange\n",
+    "import rasterio\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import ipywidgets as widgets\n",
+    "import geopandas as gpd\n",
+    "from ipyleaflet import Map, GeoJSON\n",
+    "from ipywidgets import Output\n",
+    "import shutil\n",
+    "\n",
+    "import torch\n",
+    "import torch, open_clip\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "\n",
+    "from sklearn.cluster import KMeans\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "from torch import Tensor\n",
+    "from transformers import AutoTokenizer, AutoModel\n",
+    "from transformers import AutoModelForCausalLM\n",
+    "\n",
+    "import random\n",
+    "import h5py\n",
+    "import json\n",
+    "\n",
+    "import fiona\n",
+    "from fiona.crs import from_epsg\n",
+    "from shapely.geometry import box, mapping"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "cf1ac5c8-9236-400c-b9fb-08ac4f257b5d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set paths\n",
+    "imagery_path = './south_america_reproj_resize_cog'\n",
+    "embedding_path = './south_america_remoteclip_emb.h5'\n",
+    "extent_path = './south_america_extents.gpkg'\n",
+    "vocabulary_path = './remoteclip_to_qwen3embedding06b_vocabulary.h5'\n",
+    "oam_meta_path = './oam_meta.json'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13900685-b4e4-4b04-adcf-73508b938a10",
+   "metadata": {},
+   "source": [
+    "# Functional"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3d7298cb-87fc-4246-8a85-a3f1b397aeaf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████| 9640554/9640554 [01:05<00:00, 146702.48it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done!\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(oam_meta_path, 'r') as f:\n",
+    "    oam_meta = json.load(f)\n",
+    "\n",
+    "with h5py.File(vocabulary_path, 'r') as f:\n",
+    "    text_vocabulary = f['text'][:]\n",
+    "    remoteclip_vocabulary = f['remoteclip'][:, :]\n",
+    "    qwen3embedding06b_vocabulary = f['qwen3embedding06b'][:, :]\n",
+    "\n",
+    "\n",
+    "class EDS(object):\n",
+    "    def __init__(self, imagery_path, extent_path, embedding_path, embedding_footprint_size):\n",
+    "        self.imagery_path = imagery_path\n",
+    "        self.extent_path = extent_path\n",
+    "        self.embedding_path = embedding_path\n",
+    "\n",
+    "        # Load h5 datasets\n",
+    "        self.h5file = h5py.File(embedding_path, 'r')\n",
+    "        self.embedding_ds = self.h5file['embedding']\n",
+    "        self.fname_ds = self.h5file['fname']\n",
+    "        self.meta_ds = self.h5file['meta']\n",
+    "        self.embedding_footprint_size = embedding_footprint_size\n",
+    "        \n",
+    "        # Prepare file dict\n",
+    "        self.file_dict = dict()\n",
+    "        for i in trange(self.meta_ds.shape[0]):\n",
+    "            file_num, epsg, x, y, coverage = self.meta_ds[i]\n",
+    "            if file_num not in self.file_dict:\n",
+    "                self.file_dict[file_num] = []\n",
+    "            self.file_dict[file_num].append((i, file_num, epsg, x, y, coverage))\n",
+    "        \n",
+    "        # Prepare name dicts\n",
+    "        self.fname_to_fnum = dict()\n",
+    "        self.fnum_to_fname = dict()\n",
+    "        self.fname_to_fpath = dict()\n",
+    "        for fnum, fname in enumerate(self.fname_ds):\n",
+    "            fname = fname.decode('UTF8')\n",
+    "            self.fname_to_fnum[fname] = fnum\n",
+    "            self.fnum_to_fname[fnum] = fname\n",
+    "            self.fname_to_fpath[fname] = os.path.join(imagery_path, fname)\n",
+    "\n",
+    "        self.gdf = gpd.read_file(extent_path)\n",
+    "\n",
+    "    def get_embeddings_by_fname(self, fname):\n",
+    "        xy_list = []\n",
+    "        embedding_list = []\n",
+    "        for i, file_num, epsg, x, y, coverage in self.file_dict[self.fname_to_fnum[fname]]:\n",
+    "            xy_list.append((x, y))\n",
+    "            \n",
+    "            embedding_t = torch.from_numpy(self.embedding_ds[i])\n",
+    "            embedding_t = embedding_t / embedding_t.norm(dim=-1, keepdim=True)\n",
+    "            embedding_list.append(embedding_t)\n",
+    "        return xy_list, embedding_list, epsg\n",
+    "\n",
+    "    def get_tumbnail_and_convert_coordinates_by_fname(self, fname, xy_list=None):\n",
+    "        hw_list = []\n",
+    "        cog_path = self.fname_to_fpath[fname]\n",
+    "        with rasterio.open(cog_path) as src:\n",
+    "            oviews = src.overviews(1)\n",
+    "            decimation = oviews[-1]\n",
+    "            \n",
+    "            read_b = lambda n: src.read(n, out_shape=(1, int(src.height // decimation), int(src.width // decimation)))\n",
+    "            thumbnail = np.stack([read_b(1), read_b(2), read_b(3)], axis=-1)\n",
+    "            thumbnail = thumbnail.astype(np.uint8)\n",
+    "\n",
+    "            if xy_list is not None:\n",
+    "                for x, y in xy_list:\n",
+    "                    ph, pw = src.index(x, y)\n",
+    "                    hw_list.append((ph, pw))\n",
+    "        return thumbnail, hw_list, decimation\n",
+    "                    \n",
+    "    def get_thumbnail_and_embeddings_by_fname(self, fname):\n",
+    "        xy_list, embedding_list, epsg = self.get_embeddings_by_fname(fname)\n",
+    "        thumbnail, hw_list, decimation = self.get_tumbnail_and_convert_coordinates_by_fname(fname, xy_list)\n",
+    "        return thumbnail, decimation, embedding_list, xy_list, hw_list, epsg\n",
+    "\n",
+    "    def __del__(self):\n",
+    "        self.h5file.close()\n",
+    "\n",
+    "\n",
+    "embeddings_dataset = EDS(imagery_path, extent_path, embedding_path, embedding_footprint_size=112)\n",
+    "print('Done!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8e696710-89f9-4424-a60c-d3a509b03ef3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']\n"
+     ]
+    }
+   ],
+   "source": [
+    "prop_cycle = plt.rcParams['axes.prop_cycle']\n",
+    "colors_cycle = prop_cycle.by_key()['color']\n",
+    "print(colors_cycle)\n",
+    "\n",
+    "def hex_to_rgb(hex_color_string):\n",
+    "    \"\"\"\n",
+    "    Converts a hexadecimal color string (e.g., \"#RRGGBB\" or \"RRGGBB\")\n",
+    "    to an RGB tuple (R, G, B).\n",
+    "    \"\"\"\n",
+    "    hex_color_string = hex_color_string.lstrip('#')  # Remove '#' if present\n",
+    "    return tuple(int(hex_color_string[i:i+2], 16) for i in (0, 2, 4))\n",
+    "\n",
+    "\n",
+    "def random_rgb_color():\n",
+    "    return (int(random.randint(0, 255)), int(random.randint(0, 255)), int(random.randint(0, 255)))\n",
+    "\n",
+    "def make_color_map_from_cluster_index(clusters):\n",
+    "    cluster_index_list = sorted(list(set(clusters)))\n",
+    "    color_map = dict()\n",
+    "    if len(cluster_index_list) < 11:\n",
+    "        for i in range(len(cluster_index_list)):\n",
+    "            color_map[cluster_index_list[i]] = hex_to_rgb(colors_cycle[i])\n",
+    "    else:\n",
+    "        for i in range(len(cluster_index_list)):\n",
+    "            color_map[cluster_index_list[i]] = random_rgb_color()\n",
+    "    return color_map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "0ff2154f-2fd4-439a-a439-11f14306c417",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ViT-L-14 is downloaded to checkpoints/models--chendelong--RemoteCLIP/snapshots/bf1d8a3ccf2ddbf7c875705e46373bfe542bce38/RemoteCLIP-ViT-L-14.pt.\n"
+     ]
+    }
+   ],
+   "source": [
+    "class RemoteCLIPTextModel(object):\n",
+    "    def __init__(self):\n",
+    "        model_name = 'ViT-L-14'\n",
+    "        self.tokenizer = open_clip.get_tokenizer(model_name)\n",
+    "        \n",
+    "        checkpoint_path = hf_hub_download(\"chendelong/RemoteCLIP\", f\"RemoteCLIP-{model_name}.pt\", cache_dir='checkpoints')\n",
+    "        print(f'{model_name} is downloaded to {checkpoint_path}.')\n",
+    "        \n",
+    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "        model, _, preprocess = open_clip.create_model_and_transforms(model_name)\n",
+    "        ckpt = torch.load(checkpoint_path, map_location=\"cpu\")\n",
+    "        message = model.load_state_dict(ckpt)\n",
+    "        self.model = model.to(self.device).eval()\n",
+    "\n",
+    "    def __call__(self, text_queries):\n",
+    "        text = self.tokenizer(text_queries)\n",
+    "        with torch.no_grad():\n",
+    "            text_features = self.model.encode_text(text.to(self.device))\n",
+    "            text_features /= text_features.norm(dim=-1, keepdim=True)[0, ...]\n",
+    "\n",
+    "        return text_features.detach()\n",
+    "\n",
+    "remoteclip_text_model = RemoteCLIPTextModel()\n",
+    "\n",
+    "\n",
+    "class Qwen3E06BTextModel(object):\n",
+    "    def __init__(self):\n",
+    "\n",
+    "        self.tokenizer = AutoTokenizer.from_pretrained('Qwen/Qwen3-Embedding-0.6B', padding_side='left')\n",
+    "        self.model = AutoModel.from_pretrained('Qwen/Qwen3-Embedding-0.6B')\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def last_token_pool(last_hidden_states: Tensor,\n",
+    "                     attention_mask: Tensor) -> Tensor:\n",
+    "        left_padding = (attention_mask[:, -1].sum() == attention_mask.shape[0])\n",
+    "        if left_padding:\n",
+    "            return last_hidden_states[:, -1]\n",
+    "        else:\n",
+    "            sequence_lengths = attention_mask.sum(dim=1) - 1\n",
+    "            batch_size = last_hidden_states.shape[0]\n",
+    "            return last_hidden_states[torch.arange(batch_size, device=last_hidden_states.device), sequence_lengths]\n",
+    "\n",
+    "    def __call__(self, text_queries):\n",
+    "        # Tokenize the input texts\n",
+    "        batch_dict = self.tokenizer(\n",
+    "            text_queries,\n",
+    "            padding=True,\n",
+    "            truncation=True,\n",
+    "            max_length=8192,\n",
+    "            return_tensors=\"pt\",\n",
+    "        )\n",
+    "        \n",
+    "        with torch.no_grad(), torch.cuda.amp.autocast():\n",
+    "            batch_dict.to(self.model.device)\n",
+    "            outputs = self.model(**batch_dict)\n",
+    "            embeddings = self.last_token_pool(outputs.last_hidden_state, batch_dict['attention_mask'])\n",
+    "\n",
+    "        return embeddings.detach()\n",
+    "\n",
+    "qwen3embedding06b_text_model = Qwen3E06BTextModel()\n",
+    "\n",
+    "class VocabularyPair(object):\n",
+    "    def __init__(self, remoteclip_text_model, qwen3embedding06b_text_model,\n",
+    "                 qwen3embedding06b_vocabulary, remoteclip_vocabulary,\n",
+    "                 text_vocabulary):\n",
+    "        self.remoteclip_text_model = remoteclip_text_model\n",
+    "        self.qwen3embedding06b_text_model = qwen3embedding06b_text_model\n",
+    "        self.qwen3embedding06b_vocabulary = qwen3embedding06b_vocabulary\n",
+    "        self.remoteclip_vocabulary = remoteclip_vocabulary\n",
+    "        self.text_vocabulary = text_vocabulary\n",
+    "            \n",
+    "    def find_by_embedding_in_qwen3embedding06b_vocabulary(self, query_emb):\n",
+    "    \n",
+    "        query_emb = F.normalize(query_emb, p=2, dim=1)\n",
+    "        score_value_list = list()\n",
+    "        vocabulary_len = self.qwen3embedding06b_vocabulary.shape[0]\n",
+    "        for n in range(vocabulary_len):\n",
+    "            t_text = self.text_vocabulary[n].decode('UTF8')\n",
+    "            t_emb = torch.unsqueeze(torch.from_numpy(self.qwen3embedding06b_vocabulary[n, :]), dim=0)\n",
+    "            t_emb = F.normalize(t_emb, p=2, dim=1)\n",
+    "            score = float((t_emb @ query_emb.T))\n",
+    "            score_value_list.append((score, t_text))\n",
+    "        return sorted(score_value_list, key=lambda x: -x[0])\n",
+    "    \n",
+    "    \n",
+    "    def find_by_text_in_qwen3embedding06b_vocabulary(self, text):\n",
+    "        query_emb = self.qwen3embedding06b_text_model([text, ])\n",
+    "        return self.find_by_embedding_in_qwen3embedding06b_vocabulary(query_emb)\n",
+    "\n",
+    "    \n",
+    "    def find_by_embedding_in_remoteclip_vocabulary(self, query_emb):\n",
+    "        query_emb = F.normalize(query_emb, p=2, dim=1)\n",
+    "        \n",
+    "        score_value_list = list()\n",
+    "        vocabulary_len = self.remoteclip_vocabulary.shape[0]\n",
+    "        for n in range(vocabulary_len):\n",
+    "            t_text = self.text_vocabulary[n].decode('UTF8')\n",
+    "            t_emb = torch.unsqueeze(torch.from_numpy(self.remoteclip_vocabulary[n, :]), dim=0)\n",
+    "            t_emb = F.normalize(t_emb, p=2, dim=1)\n",
+    "            score = float((t_emb @ query_emb.T))\n",
+    "            score_value_list.append((score, t_text))\n",
+    "        return sorted(score_value_list, key=lambda x: -x[0])\n",
+    "    \n",
+    "    def find_by_text_in_remoteclip_vocabulary(self, text):\n",
+    "    \n",
+    "        query_emb = remoteclip_text_model([text, ])\n",
+    "        return self.find_by_embedding_in_remoteclip_vocabulary(query_emb)\n",
+    "\n",
+    "vocabulary_pair = VocabularyPair(remoteclip_text_model, qwen3embedding06b_text_model,\n",
+    "                                 qwen3embedding06b_vocabulary, remoteclip_vocabulary,\n",
+    "                                 text_vocabulary)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "dea2432e-d822-4c83-8400-c23da5b1261a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`torch_dtype` is deprecated! Use `dtype` instead!\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2404f1f6027a4999bc62421c3ee9ddf5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model_name = \"Qwen/Qwen3-4B-Instruct-2507\"\n",
+    "# load the tokenizer and the model\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_name,\n",
+    "    torch_dtype=\"auto\",\n",
+    "    device_map=\"auto\"\n",
+    ")\n",
+    "\n",
+    "def summarize(t):\n",
+    "    prompt = f\"Summarize this words in a one word, which could be used as a map legend, this word should be noun and depict particular type of objects, just one word as output: '{t}'.\"\n",
+    "    messages = [\n",
+    "        {\"role\": \"user\", \"content\": prompt}\n",
+    "    ]\n",
+    "    text = tokenizer.apply_chat_template(\n",
+    "        messages,\n",
+    "        tokenize=False,\n",
+    "        add_generation_prompt=True,\n",
+    "    )\n",
+    "    model_inputs = tokenizer([text], return_tensors=\"pt\").to(model.device)\n",
+    "    \n",
+    "    # conduct text completion\n",
+    "    generated_ids = model.generate(\n",
+    "        **model_inputs,\n",
+    "        max_new_tokens=16384\n",
+    "    )\n",
+    "    output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist() \n",
+    "    \n",
+    "    content = tokenizer.decode(output_ids, skip_special_tokens=True)\n",
+    "    return content"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13c5e790-44e1-4787-85cf-7aa7cb64dccd",
+   "metadata": {},
+   "source": [
+    "# Imgery selection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "094d667d-033f-4972-9e09-3f783e9c1740",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5bf9daf3c1c746eaaaf964c04171d105",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(Map(center=[-34, -58], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_titl…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "center = [-34, -58]\n",
+    "init_feature = {'properties':{'path': '6758c05a6f633f00010ed810.tif'}}\n",
+    "\n",
+    "# Create map\n",
+    "m = Map(center=center, zoom=4)\n",
+    "\n",
+    "# Output widget to capture selection\n",
+    "selected_fnames = [None]\n",
+    "selected_thumbnail_and_embeddings = [None]\n",
+    "\n",
+    "out = Output()\n",
+    "def handle_click(event, feature, **kwargs):\n",
+    "    fname = feature['properties']['path']\n",
+    "    selected_fnames[0] = fname\n",
+    "    \n",
+    "    out.clear_output(wait=True)\n",
+    "    with out:\n",
+    "        thumbnail_and_embeddings = embeddings_dataset.get_thumbnail_and_embeddings_by_fname(fname)\n",
+    "        selected_thumbnail_and_embeddings[0] = thumbnail_and_embeddings\n",
+    "        \n",
+    "        thumbnail, decimation, embedding_list, xy_list, hw_list, epsg = thumbnail_and_embeddings\n",
+    "        fig, axes = plt.subplots(1, 1, figsize=(4, 4))\n",
+    "        axes.set_title(\"Image overview\")\n",
+    "        axes.imshow(thumbnail)\n",
+    "        axes.axis('off')\n",
+    "        plt.tight_layout()\n",
+    "        plt.show()\n",
+    "\n",
+    "\n",
+    "geo_json_data = embeddings_dataset.gdf.__geo_interface__\n",
+    "geo_json = GeoJSON(data=geo_json_data, hover_style={'fillColor': 'red'}, name='GeoJSON')\n",
+    "geo_json.on_click(handle_click)\n",
+    "m.add_layer(geo_json)\n",
+    "\n",
+    "display(widgets.HBox([m, out]))\n",
+    "handle_click(None, init_feature)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc5f1f26-50af-4ad5-a213-7d0db4c63b03",
+   "metadata": {},
+   "source": [
+    "# Vibe Mapping using RemoteCLIP and Qwen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "196ea894-e463-4f09-8641-f046ea2b9bda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Just raw embeddigns\n",
+    "thumbnail_and_embeddings = selected_thumbnail_and_embeddings[0]\n",
+    "thumbnail, decimation, embedding_list, xy_list, hw_list, epsg = thumbnail_and_embeddings\n",
+    "\n",
+    "kmeans = KMeans(n_clusters=6, random_state=42)\n",
+    "clusters = kmeans.fit_predict(torch.stack(embedding_list, dim=0).numpy())\n",
+    "cluster_centers = kmeans.cluster_centers_\n",
+    "clusters_num = cluster_centers.shape[0]\n",
+    "cluster_string_list = []\n",
+    "cluster_string_list_summerized = []\n",
+    "print('LLM Legend sumerisation')\n",
+    "for i in trange(clusters_num):\n",
+    "    emb = cluster_centers[i, :]\n",
+    "    matched_text = vocabulary_pair.find_by_embedding_in_remoteclip_vocabulary(torch.unsqueeze(torch.from_numpy(emb), dim=0))[:4]\n",
+    "    legend_string = ', '.join([i[1] for i in matched_text])\n",
+    "    cluster_string_list.append(legend_string)\n",
+    "    cluster_string_list_summerized.append(summarize(legend_string))\n",
+    "\n",
+    "\n",
+    "color_map = make_color_map_from_cluster_index(clusters)\n",
+    "\n",
+    "thumbnail_embedding_image = np.zeros_like(thumbnail[:,:,:]).astype(np.float32)\n",
+    "cc =  int((embeddings_dataset.embedding_footprint_size / 2) / decimation) + 1\n",
+    "for n in range(len(hw_list)):\n",
+    "    ph, pw = hw_list[n]\n",
+    "    cluster_index = clusters[n]\n",
+    "    color_rgb = np.array(color_map[cluster_index])\n",
+    "    tph, tpw = int(ph / decimation), int(pw / decimation)\n",
+    "    thumbnail_embedding_image[tph-cc:tph+cc, tpw-cc:tpw+cc, :] = color_rgb\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 3, figsize=(12, 4)) \n",
+    "axes[0].imshow(thumbnail)\n",
+    "axes[0].axis('off')\n",
+    "axes[1].imshow(thumbnail_embedding_image.astype(np.uint8))\n",
+    "axes[2].imshow(thumbnail_embedding_image.astype(np.uint8))\n",
+    "\n",
+    "color_map_values = [i for i in color_map.values()]\n",
+    "for n in range(len(color_map_values)):\n",
+    "    color_rgb = np.array(color_map_values[n]) / 255\n",
+    "    axes[2].text(5., 10.0 + (20 * n), f'{str(n)}. {cluster_string_list_summerized[n]}', color=(color_rgb[0], color_rgb[1], color_rgb[2]), fontsize=8,\n",
+    "                 bbox=dict(boxstyle=\"round,pad=0.3\", fc=\"white\", ec=\"white\", lw=0, alpha=1.0))\n",
+    "axes[1].axis('off')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d083b661-fceb-49bd-a431-d409f712d33f",
+   "metadata": {},
+   "source": [
+    "# Attribute and save map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "a2ee8340-9546-4a62-8d6c-c0972ac7660c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vocabulary output:\n",
+      "0 white patchwork buildings, white roofs, community is white, white community\n",
+      "1 quiet forest, lush vegetation, lush wood, lush bush\n",
+      "2 small brown boats, boats is small brown, brown boats, boats is brown\n",
+      "3 thick green forest, light lush green forest, deep green forest, clear green forest\n",
+      "4 boats is brown, small brown boats, brown boats, boats is small brown\n",
+      "5 huts, houses is several vacant, vacant places, community is white\n",
+      "OAM metadata:\n",
+      "\n",
+      "[{'_id': '6758c6da6f633f00010ed814', 'acquisition_end': '2022-11-10T17:00:00.000Z', 'acquisition_start': '2022-11-10T11:00:00.000Z', 'contact': 'Labgeo EMATER,labgeoemater@gmail.com', 'platform': 'aircraft', 'provider': 'EMATER-PARÁ', 'properties': {'license': 'CC BY-NC 4.0', 'sensor': 'Phantom 4 Pro ', 'thumbnail': 'https://oin-hotosm-temp.s3.us-east-1.amazonaws.com/6758c05a6f633f00010ed80f/0/6758c05a6f633f00010ed810.png', 'tms': 'https://tiles.openaerialmap.org/6758c05a6f633f00010ed80f/0/6758c05a6f633f00010ed810/{z}/{x}/{y}', 'wmts': 'https://tiles.openaerialmap.org/6758c05a6f633f00010ed80f/0/6758c05a6f633f00010ed810/wmts'}, 'title': 'Ortomosaico da área urbana do município de Afuá-Pará', 'user': {'_id': '675735e748d17e0001ca9dad', 'name': 'Labgeo EMATER'}, 'uuid': 'https://oin-hotosm-temp.s3.us-east-1.amazonaws.com/6758c05a6f633f00010ed80f/0/6758c05a6f633f00010ed810.tif', 'geojson': {'bbox': [-50.394345, -0.167373, -50.370556, -0.151723], 'coordinates': [[[[-50.394345, -0.151724], [-50.394344, -0.167373], [-50.370556, -0.167373], [-50.370556, -0.151723], [-50.394345, -0.151724]]]], 'type': 'MultiPolygon'}, 'footprint': 'POLYGON ((-50.394345 -0.167373, -50.370556 -0.167373, -50.370556 -0.151723, -50.394345 -0.151723, -50.394345 -0.167373))', 'gsd': 0.0402309168832342, 'file_size': 576548103, 'projection': '\\nPROJCRS[\"SIRGAS 2000 / UTM zone 22S\",\\n    BASEGEOGCRS[\"SIRGAS 2000\",\\n        DATUM[\"Sistema de Referencia Geocentrico para las AmericaS 2000\",\\n            ELLIPSOID[\"GRS 1980\",6378137,298.257222101,\\n                LENGTHUNIT[\"metre\",1]]],\\n        PRIMEM[\"Greenwich\",0,\\n            ANGLEUNIT[\"degree\",0.0174532925199433]],\\n        ID[\"EPSG\",4674]],\\n    CONVERSION[\"UTM zone 22S\",\\n        METHOD[\"Transverse Mercator\",\\n            ID[\"EPSG\",9807]],\\n        PARAMETER[\"Latitude of natural origin\",0,\\n            ANGLEUNIT[\"degree\",0.0174532925199433],\\n            ID[\"EPSG\",8801]],\\n        PARAMETER[\"Longitude of natural origin\",-51,\\n            ANGLEUNIT[\"degree\",0.0174532925199433],\\n            ID[\"EPSG\",8802]],\\n        PARAMETER[\"Scale factor at natural origin\",0.9996,\\n            SCALEUNIT[\"unity\",1],\\n            ID[\"EPSG\",8805]],\\n        PARAMETER[\"False easting\",500000,\\n            LENGTHUNIT[\"metre\",1],\\n            ID[\"EPSG\",8806]],\\n        PARAMETER[\"False northing\",10000000,\\n            LENGTHUNIT[\"metre\",1],\\n            ID[\"EPSG\",8807]]],\\n    CS[Cartesian,2],\\n        AXIS[\"(E)\",east,\\n            ORDER[1],\\n            LENGTHUNIT[\"metre\",1]],\\n        AXIS[\"(N)\",north,\\n            ORDER[2],\\n            LENGTHUNIT[\"metre\",1]],\\n    USAGE[\\n        SCOPE[\"Engineering survey, topographic mapping.\"],\\n        AREA[\"Brazil - between 54°W and 48°W, northern and southern hemispheres, onshore and offshore. In remainder of South America - between 54°W and 48°W, southern hemisphere, onshore and offshore.\"],\\n        BBOX[-54.18,-54,7.04,-47.99]],\\n    ID[\"EPSG\",31982]]', 'meta_uri': 'https://oin-hotosm-temp.s3.us-east-1.amazonaws.com/6758c05a6f633f00010ed80f/0/6758c05a6f633f00010ed810_meta.json', 'uploaded_at': '2024-12-10T22:55:22.296Z', 'bbox': [-50.394345, -0.167373, -50.370556, -0.151723], '__v': 0}]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████| 833/833 [00:01<00:00, 476.33it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Vocabulary output:')\n",
+    "_ = [print(n, i) for (n, i) in enumerate(cluster_string_list)]\n",
+    "\n",
+    "\n",
+    "print('OAM metadata:\\n')\n",
+    "fname = selected_fnames[0]\n",
+    "print([i for i in oam_meta if i['uuid'].endswith(fname)])\n",
+    "\n",
+    "square_size = 56\n",
+    "schema = {\n",
+    "    'geometry': 'Polygon',\n",
+    "    'properties': {'id': 'int', 'name': 'str'}\n",
+    "}\n",
+    "with fiona.open(fname + '.gpkg', 'w', driver='GPKG', crs=from_epsg(epsg), schema=schema, layer='squares') as layer:\n",
+    "    for idx, (x, y) in tqdm(enumerate(xy_list), total=len(xy_list)):\n",
+    "        # Create square around the point\n",
+    "        half_size = square_size / 2\n",
+    "        square = box(x - half_size, y - half_size, x + half_size, y + half_size)\n",
+    "        cluster_index = clusters[idx]\n",
+    "        legend = cluster_string_list_summerized[cluster_index]\n",
+    "        # Write to file\n",
+    "        layer.write({\n",
+    "            'geometry': mapping(square),\n",
+    "            'properties': {'id': idx, 'name': legend}\n",
+    "        })\n",
+    "        \n",
+    "shutil.copy(embeddings_dataset.fname_to_fpath[fname], fname)\n",
+    "print(\"Saved\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ffbb909-7e49-41b5-aad3-59cec0ba22ff",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}