create_features_sift.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b18f4af2-a30f-4203-9bff-63dd2fc466e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage import segmentation, io\n",
    "from scipy.cluster.hierarchy import linkage\n",
    "from scipy.spatial.distance import pdist\n",
    "from sklearn.cluster import AgglomerativeClustering\n",
    "from sklearn.metrics.pairwise import euclidean_distances\n",
    "from sklearn.metrics import calinski_harabasz_score\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow import keras\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from utils.utils import generate_synthetic_image, plot_dendrogram\n",
    "from utils.image_manager import ImagesManager\n",
    "from utils.mask_manager import MaskManager\n",
    "from utils.features_manager import FeaturesManager\n",
    "import os\n",
    "import warnings\n",
    "plt.rcParams[\"axes.grid\"] = False\n",
    "from sklearn.preprocessing import scale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f80febae-0b2b-4aed-a5b9-437ca69dc5f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = keras.models.load_model('./model/model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d0adfc8-c9a9-4557-9e0e-f09599289ace",
   "metadata": {},
   "outputs": [],
   "source": [
    "#path_to_images = './data/eval_xai_method/dog_resized'\n",
    "path_to_images ='./data/debug'\n",
    "all_images = os.listdir(path_to_images)\n",
    "all_images = [x for x in all_images if x != '.DS_Store']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9322050b-75f6-455f-9084-9c8005ab3007",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "647db465-0d86-4cfc-903f-c8653bc4d7dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_images = len(all_images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2aa9fc1a-84cf-4d66-b0b7-f989b397139b",
   "metadata": {},
   "outputs": [],
   "source": [
    "images_chosen = np.random.choice(all_images, size=num_images, replace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbc6d227-7a2d-4eca-98ad-fdf0946114d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "images_chosen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "771be7cb-1062-42c4-92c1-ad96c3924c6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "prediction_list = []\n",
    "for image_name in images_chosen:\n",
    "    image_path = os.path.join(path_to_images, image_name)\n",
    "    img = io.imread(image_path)\n",
    "    img_norm = img/255\n",
    "    img_batch = np.expand_dims(img_norm, axis=0)\n",
    "    pred = model.predict(img_batch)\n",
    "    prediction_list.append(pred)\n",
    "    io.imshow(img)\n",
    "    plt.show()\n",
    "    print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dceab4a3-03cf-4f10-a049-513abec0b2c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "ratio_pixels_gaussian_kernel = 0.0075 #Corresponde a sigma=4 para una imagen 200x200\n",
    "chi2_95 = 6\n",
    "\n",
    "for image_name in images_chosen[:1]:\n",
    "    image_path = os.path.join(path_to_images, image_name)\n",
    "    img = io.imread(image_path)\n",
    "    img_norm = img/255\n",
    "    x_pixels, y_pixels, _ = img_norm.shape\n",
    "    area_total = x_pixels*y_pixels\n",
    "    s = np.sqrt(area_total)/200\n",
    "    max_dist = 10*s\n",
    "    ratio = 1/2*s\n",
    "    sigma_sq = area_total*ratio_pixels_gaussian_kernel/(chi2_95*np.pi)\n",
    "    sigma = np.sqrt(sigma_sq)\n",
    "    superpixels = segmentation.quickshift(img_norm, kernel_size=sigma, max_dist=max_dist, ratio=ratio)\n",
    "    num_superpixels_image = np.unique(superpixels).shape[0]\n",
    "    img_batch = np.expand_dims(img_norm, axis=0)\n",
    "    pred = model.predict(img_batch)\n",
    "    print('num_superpixels:', num_superpixels_image)\n",
    "    print('image_shape:', img_norm.shape)\n",
    "    print('sigma:', sigma)\n",
    "    print('max_dist:', max_dist)\n",
    "    print('ratio:', ratio)\n",
    "    io.imshow(segmentation.mark_boundaries(img_norm, superpixels, color=(1,0,0), mode='inner'))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb9423ae-001e-49f3-97c9-5edc6217af92",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from skimage import segmentation, io\n",
    "import cv2\n",
    "\n",
    "class SiftFeaturesManager:\n",
    "    def __init__(self, location, image_name, mask):\n",
    "        self.location = location\n",
    "        self.image_name = image_name\n",
    "        self.mask = mask\n",
    "        self.list_descriptors = []\n",
    "        self.list_tracking = []\n",
    "        self.list_missing = []\n",
    "        \n",
    "    def get_smalles_patch(self, img, mask, num_superpixel):\n",
    "        \n",
    "        idx_mask = np.where(mask == num_superpixel)\n",
    "        min_idx = np.min(idx_mask, axis=-1)\n",
    "        max_idx = np.max(idx_mask, axis=-1)\n",
    "        slicer = []\n",
    "        for min_val, max_val in zip(min_idx, max_idx):\n",
    "            slice_dim = slice(min_val, max_val+1, 1)\n",
    "            slicer.append(slice_dim)\n",
    "            \n",
    "        slicer = tuple(slicer)\n",
    "        sliced_image = img[slicer]\n",
    "        return img[slicer]\n",
    "    \n",
    "    def sift_features(self, s_patch):\n",
    "        sift = cv2.SIFT_create(nfeatures=1)\n",
    "        _, descriptors = sift.detectAndCompute(s_patch, None)\n",
    "        return descriptors\n",
    "    \n",
    "    def prepare_output(self, descriptors, num_superpixel):\n",
    "        if descriptors is not None:\n",
    "            total_descriptors = descriptors.shape[0]\n",
    "            total_features = descriptors.shape[1]\n",
    "            for i in range(total_descriptors):\n",
    "                des = descriptors[i, :]\n",
    "                des = des.reshape((1, total_features))\n",
    "                self.list_descriptors.append(des)\n",
    "                self.list_tracking.append((self.image_name, num_superpixel))\n",
    "        else:\n",
    "            self.list_missing.append((self.image_name, num_superpixel))\n",
    "            \n",
    "    def create_output(self):\n",
    "        if len(self.list_descriptors)>0:\n",
    "            data_np = np.concatenate(self.list_descriptors)\n",
    "            data_pd = pd.DataFrame(data_np)\n",
    "            data_pd.index = self.list_tracking\n",
    "        else:\n",
    "            data_pd = None\n",
    "        \n",
    "        return data_pd, self.list_missing\n",
    "        \n",
    "    def get_sift_features(self):\n",
    "        # Read the image\n",
    "        full_path = os.path.join(self.location, self.image_name)\n",
    "        img = io.imread(full_path)\n",
    "        \n",
    "        # For each superpixel:\n",
    "        list_superpixels = np.unique(mask)\n",
    "        for num_superpixel in list_superpixels:\n",
    "            # Get the smalles patch that contains the superpixel\n",
    "            smallest_patch = self.get_smalles_patch(img, mask, num_superpixel)\n",
    "            # Get SIFT features\n",
    "            descriptors = self.sift_features(s_patch=smallest_patch)\n",
    "            self.prepare_output(descriptors, num_superpixel)\n",
    "        \n",
    "        data, list_missing = self.create_output()\n",
    "        return data, list_missing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca0c2fa1-aeea-487a-b70d-fcb762cc6799",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_superpixels_information(path_to_images, images_extension='jpg',\n",
    "                                kernel_size=4, max_dist=10, ratio=.3):\n",
    "    \n",
    "    images_manager = ImagesManager(location=path_to_images, images_extension=images_extension)\n",
    "    images_names = images_manager.get_images_names()\n",
    "    df_features_list = []\n",
    "    dict_masks = {}\n",
    "    dict_deleted_superpixels = {}\n",
    "    num_superpixels_list = []\n",
    "\n",
    "    for image_name in images_names:\n",
    "        print(image_name)\n",
    "        masks_manager = MaskManager(location=path_to_images, image_name=image_name)\n",
    "        mask = masks_manager.get_mask(kernel_size=kernel_size, max_dist=max_dist, ratio=ratio)\n",
    "        dict_masks[image_name] = mask\n",
    "        num_superpixels_list.append(len(np.unique(mask)))\n",
    "        sift_features_manager = SiftFeaturesManager(location=path_to_images, image_name=image_name, mask=mask)\n",
    "        data, list_missing = sift_features_manager.get_sift_features()\n",
    "        \n",
    "    return data, list_missing, num_superpixels_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c00fa60-3af2-4e94-9bd1-62db59b05621",
   "metadata": {},
   "outputs": [],
   "source": [
    "data, list_missing, num_superpixels_list = get_superpixels_information(path_to_images='./data/debug')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6854dedf-d068-4d72-b7f5-97b09e19cd55",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71037de8-e6c7-4a5e-a81f-192351bdf4d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Clusteriser:\n",
    "    \n",
    "    def __init__(self, num_superpixels, df):\n",
    "        self.num_superpixels = num_superpixels\n",
    "        self.image_name = image_name\n",
    "        self.df = df\n",
    "\n",
    "    def get_fixed_clusters(self, n_cluster):\n",
    "        \n",
    "        cluster = AgglomerativeClustering(n_clusters=n_cluster, linkage='ward')\n",
    "        results = cluster.fit(self.df)\n",
    "        labels = results.labels_\n",
    "        metric = calinski_harabasz_score(self.df, labels)\n",
    "\n",
    "        return metric, labels\n",
    "    \n",
    "    def get_mutiple_clusters(self):\n",
    "\n",
    "        mean_superpixels = round(np.mean(self.num_superpixels))\n",
    "        n_clusters = range(2, mean_superpixels)\n",
    "        n_clusters_list = []\n",
    "        metric_list = []\n",
    "\n",
    "        for n_cluster in n_clusters:\n",
    "            metric, _ = self.get_fixed_clusters(n_cluster)\n",
    "            metric_list.append(metric)\n",
    "            n_clusters_list.append(n_cluster)\n",
    "            print('n_cluster:', n_cluster, 'metric:', metric)\n",
    "\n",
    "        return n_clusters_list, metric_list\n",
    "        \n",
    "    def get_best_clusterisation(self):\n",
    "        n_clusters_list, metric_list = self.get_mutiple_clusters()\n",
    "        idx_best_metric = np.argmax(metric_list)\n",
    "        best_n_clusters = n_clusters_list[idx_best_metric]\n",
    "\n",
    "        _, labels = self.get_fixed_clusters(best_n_clusters)\n",
    "        return np.array(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23dd4ea0-119e-4650-8cec-026f56d75009",
   "metadata": {},
   "outputs": [],
   "source": [
    "cluster = Clusteriser(num_superpixels=num_superpixels_list, df=data)\n",
    "new_segmentation = cluster.get_best_clusterisation()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87ab4489-ec68-43c1-b5f9-a2f779e03f60",
   "metadata": {},
   "source": [
    "# Trash"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "xai_cats_dogs_venv",
   "language": "python",
   "name": "xai_cats_dogs_venv"
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}