resnet_experiment_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import json\n",
    "import matplotlib.pyplot as plt\n",
    "from pathlib import Path\n",
    "import seaborn as sns\n",
    "from time import time\n",
    "import numpy as np\n",
    "from util._telegram import send_simple_message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distances = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EXPERIMENT_ID = 436\n",
    "EXPERIMENT_FODLER = Path(\"experiments\", \"20230327183259_results_nb\", f\"{str(EXPERIMENT_ID).zfill(5)}_individuals\")\n",
    "ONLY_MAIN_CHARTS = True\n",
    "CLUSTER_ID = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DLIB_DISTANCES_FILE = Path(\"fr\", \"distances_dlib.json\")\n",
    "RESNET_DISTANCES_FILE = Path(\"fr\", \"distances_resnet.json\")\n",
    "RESNET_FACEPARTS_DISTANCES_FILE = Path(\"fr\", \"distances_resnet_faceparts.json\")\n",
    "DLIB_DATASET_CLUSTERS_FILE = Path(\"fr\", \"dlib_clusters.json\")\n",
    "\n",
    "DLIB_RESNET_BEST_COMB = EXPERIMENT_FODLER.joinpath(\"best_individual.json\")\n",
    "DLIB_RESNET_BEST_COMBS = EXPERIMENT_FODLER.joinpath(\"best_individuals.json\")\n",
    "\n",
    "PRECISION_RECALL_FILE_PATH = EXPERIMENT_FODLER.joinpath(f\"precision_recall.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load distances from raw files into dataframes\n",
    "\n",
    "# DLIB Distances ( <pair>: {'dlib': distance}} )\n",
    "if distances is None:\n",
    "    tmp_raw_data = json.load(open(DLIB_DISTANCES_FILE, \"r\"))\n",
    "    dlib_distances = pd.DataFrame(dict(pair=tmp_raw_data.keys(), dlib_distance=(d['dlib'] for d in tmp_raw_data.values())))\n",
    "    del tmp_raw_data\n",
    "\n",
    "    # ResNET Distances ({<pair>: distance})\n",
    "    tmp_raw_data = json.load(open(RESNET_DISTANCES_FILE, \"r\"))\n",
    "    resnet_distances = pd.DataFrame(dict(pair=tmp_raw_data.keys(), resnet_distance=tmp_raw_data.values()))\n",
    "    del tmp_raw_data\n",
    "\n",
    "    # ResNET Faceparts Distances\n",
    "    def rows_generator(resnet_faceparts_raw_data):\n",
    "        for pair, distances in resnet_faceparts_raw_data.items():\n",
    "            distances.update({'pair': pair})\n",
    "            yield distances\n",
    "\n",
    "    tmp_raw_data = json.load(open(RESNET_FACEPARTS_DISTANCES_FILE, \"r\"))\n",
    "    generator = rows_generator(tmp_raw_data)\n",
    "    del tmp_raw_data\n",
    "\n",
    "    resnet_faceparts_distances = pd.DataFrame(generator)\n",
    "\n",
    "    # Join distances into a sigle dataframe\n",
    "    distances = dlib_distances.merge(resnet_distances, on='pair', how='outer')\n",
    "    distances = distances.merge(resnet_faceparts_distances, on='pair', how='outer')\n",
    "\n",
    "    # Filter only images with \"n\" (from VGGFACE2)\n",
    "    distances = distances[distances.pair.apply(lambda p: \"n\" in p)]\n",
    "\n",
    "    # Generate extra columns\n",
    "    distances[\"img1\"] = distances.pair.apply(lambda p: p.split(\" x \")[0])\n",
    "    distances[\"img2\"] = distances.pair.apply(lambda p: p.split(\" x \")[1])\n",
    "    distances[\"person1\"] = distances.img1.apply(lambda p: p.split(\"_\")[0])\n",
    "    distances[\"person2\"] = distances.img2.apply(lambda p: p.split(\"_\")[0])\n",
    "    distances[\"same_person\"] = (distances.person1 == distances.person2).apply(lambda s: \"same\" if s else \"different\")\n",
    "\n",
    "    # Delete unnecessary columns\n",
    "    distances.drop(columns='pair', inplace=True)\n",
    "\n",
    "    # Sort columns by name\n",
    "    distances = distances.reindex(sorted(distances.columns), axis=1)\n",
    "\n",
    "    # Load clusters\n",
    "    if CLUSTER_ID is not None:\n",
    "        clusters_ref = pd.DataFrame(data=json.load(open(DLIB_DATASET_CLUSTERS_FILE, \"r\")))\n",
    "        clusters_ref.set_index('label', inplace=True)\n",
    "\n",
    "        distances['img1_cluster'] = distances.img1.apply(lambda i: clusters_ref.cluster.get(i, None))\n",
    "        distances['img2_cluster'] = distances.img2.apply(lambda i: clusters_ref.cluster.get(i, None))\n",
    "\n",
    "        distances = distances[(distances.img1_cluster == CLUSTER_ID) & (distances.img2_cluster == CLUSTER_ID)]\n",
    "\n",
    "        del clusters_ref\n",
    "\n",
    "    # Normalize distances\n",
    "    distances_num = distances.select_dtypes(include=\"number\")\n",
    "    for col in distances_num.columns:\n",
    "        distances_num[col] = (distances_num[col]-distances_num[col].min())/(distances_num[col].max()-distances_num[col].min())\n",
    "\n",
    "    distances[distances_num.columns] = distances_num\n",
    "\n",
    "    del dlib_distances\n",
    "    del resnet_distances\n",
    "    del resnet_faceparts_distances\n",
    "    del distances_num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate best combination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load best combination of dlib and resnet\n",
    "dlib_resnet_best_comb = json.load(open(DLIB_RESNET_BEST_COMB, \"r\"))\n",
    "dlib_resnet_best_comb = pd.DataFrame(dict(resnet_part=dlib_resnet_best_comb.keys(), multiplier=dlib_resnet_best_comb.values()))\n",
    "dlib_resnet_best_comb.sort_values(by=\"resnet_part\", inplace=True)\n",
    "\n",
    "# Calculate resnet_combination column\n",
    "best_multipliers_lst = dlib_resnet_best_comb.multiplier.tolist()\n",
    "individual_sum = sum(best_multipliers_lst)\n",
    "best_multipliers_lst = [i/individual_sum for i in best_multipliers_lst]\n",
    "distances[\"resnet_comb\"] = distances.loc[:, dlib_resnet_best_comb.resnet_part].dot(best_multipliers_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utilitaty funcion for charts\n",
    "def next_axis(rows, cols):\n",
    "    i = 0\n",
    "    j = 0\n",
    "    while True:\n",
    "        yield (i, j)\n",
    "        j += 1\n",
    "        if j == cols:\n",
    "            j = 0\n",
    "            i += 1\n",
    "        \n",
    "        if i > rows:\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "COLUMNS_TO_IGNORE = [\"person1\", \"person2\", \"img1\", \"img2\", \"same_person\", \"img1_cluster\", \"img2_cluster\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Best Combination Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dlib_resnet_best_combs = pd.DataFrame(json.load(open(DLIB_RESNET_BEST_COMBS, \"r\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set(rc={\"figure.figsize\": (30,15)})\n",
    "ax = sns.lineplot(x=\"generation\", y=\"fitness\", data=dlib_resnet_best_combs)\n",
    "ax = ax.set_title(\"Best Combination of DLIB Search\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set(rc={\"figure.figsize\": (20,10)})\n",
    "plot_data = dlib_resnet_best_combs.iloc[-1].best_data\n",
    "plot_data = pd.DataFrame(dict(resnet_part=plot_data.keys(), coefficient=plot_data.values()))\n",
    "plot_data.coefficient = plot_data.coefficient / plot_data.coefficient.sum()\n",
    "plot_data.sort_values(by=\"coefficient\", inplace=True, ascending=False)\n",
    "ax = sns.barplot(x=\"resnet_part\", y=\"coefficient\", data=plot_data)\n",
    "ax = ax.set_title(\"Best ResNET Combination Found\")\n",
    "_ = plt.xticks(rotation=45)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Correlation Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not ONLY_MAIN_CHARTS:\n",
    "    sns.set(rc={\"figure.figsize\": (30,20)})\n",
    "    corr = distances.corr()\n",
    "    plt.matshow(corr)\n",
    "    plt.xticks(range(distances.select_dtypes(['number']).shape[1]), distances.select_dtypes(['number']).columns, fontsize=14, rotation=45)\n",
    "    plt.yticks(range(distances.select_dtypes(['number']).shape[1]), distances.select_dtypes(['number']).columns, fontsize=14)\n",
    "    cb = plt.colorbar()\n",
    "    cb.ax.tick_params(labelsize=14)\n",
    "    plt.title('Correlation Matrix (Pearson)', fontsize=16)\n",
    "\n",
    "    for (i, j), z in np.ndenumerate(corr):\n",
    "        plt.text(j, i, '{:0.1f}'.format(z), ha='center', va='center', size=14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distances Correlation with DLIB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ROWS = 5\n",
    "COLS = 5\n",
    "fig, axes = plt.subplots(nrows=ROWS, ncols=COLS, figsize=(35,40))\n",
    "\n",
    "dlib_col = \"dlib_distance\"\n",
    "make_idx_generator = next_axis(rows=ROWS, cols=COLS)\n",
    "columns = list(distances.columns)\n",
    "for distance_col in columns:\n",
    "    if distance_col in COLUMNS_TO_IGNORE:\n",
    "        continue\n",
    "    row_idx, col_idx = make_idx_generator.__next__()\n",
    "    axes[row_idx, col_idx].set_title(f'dlib_distance vs {distance_col}')\n",
    "    g = sns.scatterplot(ax=axes[row_idx, col_idx], x=dlib_col, y=distance_col, data=distances, hue='same_person', style='same_person')\n",
    "    # g = sns.histplot(ax=axes[row_idx, col_idx], data=distances, x=dlib_col, y=distance_col, hue=\"same_person\", fill=True, kde=True)\n",
    "    g.axvline(0.55, color='r')\n",
    "    g.set(xlim=(0,1), ylim=(0, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distances Correlation with DLIB (Only pairs of same persons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not ONLY_MAIN_CHARTS:\n",
    "    ROWS = 5\n",
    "    COLS = 5\n",
    "    fig, axes = plt.subplots(nrows=ROWS, ncols=COLS, figsize=(35,40))\n",
    "\n",
    "    dlib_col = \"dlib_distance\"\n",
    "    make_idx_generator = next_axis(rows=ROWS, cols=COLS)\n",
    "    columns = list(distances.columns)\n",
    "    for distance_col in columns:\n",
    "        if distance_col in COLUMNS_TO_IGNORE:\n",
    "            continue\n",
    "        row_idx, col_idx = make_idx_generator.__next__()\n",
    "        axes[row_idx, col_idx].set_title(f'dlib_distance vs {distance_col}')\n",
    "        # g = sns.scatterplot(ax=axes[row_idx, col_idx], x=dlib_col, y=distance_col, data=distances[distances.same_person == \"same\"], hue='same_person', style='same_person')\n",
    "        g = sns.histplot(ax=axes[row_idx, col_idx], data=distances[distances.same_person == \"same\"], x=dlib_col, y=distance_col, hue=\"same_person\", fill=True, kde=True)\n",
    "        g.axvline(0.55, color='r')\n",
    "        g.set(xlim=(0,1), ylim=(0, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distances Correlation with DLIB (Only pairs of different persons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not ONLY_MAIN_CHARTS:\n",
    "    ROWS = 5\n",
    "    COLS = 5\n",
    "    fig, axes = plt.subplots(nrows=ROWS, ncols=COLS, figsize=(35,40))\n",
    "\n",
    "    dlib_col = \"dlib_distance\"\n",
    "    make_idx_generator = next_axis(rows=ROWS, cols=COLS)\n",
    "    columns = list(distances.columns)\n",
    "    for distance_col in columns:\n",
    "        if distance_col in COLUMNS_TO_IGNORE:\n",
    "            continue\n",
    "        row_idx, col_idx = make_idx_generator.__next__()\n",
    "        axes[row_idx, col_idx].set_title(f'dlib_distance vs {distance_col}')\n",
    "        # g = sns.scatterplot(ax=axes[row_idx, col_idx], x=dlib_col, y=distance_col, data=distances[distances.same_person != \"same\"], style='same_person', color=\"orange\")\n",
    "        g = sns.histplot(ax=axes[row_idx, col_idx], data=distances[distances.same_person != \"same\"], x=dlib_col, y=distance_col, hue=\"same_person\", fill=True, kde=True, color=\"orange\")\n",
    "        \n",
    "        g.axvline(0.55, color='r')\n",
    "        g.set(xlim=(0,1), ylim=(0, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distances Distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not ONLY_MAIN_CHARTS:\n",
    "    ROWS = 5\n",
    "    COLS = 5\n",
    "\n",
    "    columns = list(distances.columns)\n",
    "    idx_generator = next_axis(rows=ROWS, cols=COLS)\n",
    "    fig, axes = plt.subplots(nrows=ROWS, ncols=COLS, figsize=(35,30))\n",
    "    for tmp_col in columns:\n",
    "        if tmp_col in COLUMNS_TO_IGNORE:\n",
    "            continue\n",
    "        row_idx, col_idx = idx_generator.__next__()\n",
    "        axes[row_idx, col_idx].set_title(f\"{tmp_col}\")\n",
    "        ax1 = sns.histplot(ax=axes[row_idx, col_idx], data=distances[tmp_col], bins=100, kde=True)\n",
    "        ax1.set_xlabel(\"Distâncias\")\n",
    "        ax1.set_ylabel(\"Quantidade\")\n",
    "        ax1.set(xlim=(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ROWS = 5\n",
    "COLS = 5\n",
    "columns = list(distances.columns)\n",
    "idx_generator = next_axis(rows=ROWS, cols=COLS)\n",
    "fig, axes = plt.subplots(nrows=ROWS, ncols=COLS, figsize=(35,30))\n",
    "for tmp_col in columns:\n",
    "    if tmp_col in COLUMNS_TO_IGNORE:\n",
    "        continue\n",
    "\n",
    "    row_idx, col_idx = idx_generator.__next__()\n",
    "    axes[row_idx, col_idx].set_title(f\"DLIB vs {tmp_col}\")\n",
    "    ax = sns.kdeplot(ax=axes[row_idx, col_idx], data=distances[(distances.img1 != distances.img2)][\"dlib_distance\"], color=\"blue\", shade=True)\n",
    "    ax = sns.kdeplot(ax=axes[row_idx, col_idx], data=distances[(distances.img1 != distances.img2)][tmp_col], color=\"purple\", shade=True)\n",
    "    ax.set(xlim=(0,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distances Distribution (Same person vs Different persons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ROWS = 5\n",
    "COLS = 5\n",
    "columns = list(distances.columns)\n",
    "idx_generator = next_axis(rows=ROWS, cols=COLS)\n",
    "fig, axes = plt.subplots(nrows=ROWS, ncols=COLS, figsize=(35,30))\n",
    "for tmp_col in columns:\n",
    "    if tmp_col in COLUMNS_TO_IGNORE:\n",
    "        continue\n",
    "\n",
    "    row_idx, col_idx = idx_generator.__next__()\n",
    "    axes[row_idx, col_idx].set_title(f\"{tmp_col}\")\n",
    "    ax = sns.kdeplot(ax=axes[row_idx, col_idx], data=distances[(distances.same_person == \"same\") & (distances.img1 != distances.img2)][tmp_col], color=\"green\", shade=True)\n",
    "    ax = sns.kdeplot(ax=axes[row_idx, col_idx], data=distances[distances.same_person != \"same\"][tmp_col], color=\"red\", shade=True)\n",
    "    ax.set(xlim=(0,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Person Recovery Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not ONLY_MAIN_CHARTS:\n",
    "    # Try recover the precision and recall from the excel file\n",
    "    try:\n",
    "        precision_recall = pd.DataFrame(json.load(open(PRECISION_RECALL_FILE_PATH, \"r\")))\n",
    "        print(f\"Precision vs Recall data recovered from {PRECISION_RECALL_FILE_PATH}\")\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "        precision_recall = None\n",
    "\n",
    "    # If the excel file is not found, calculate precion vs recall and save to file\n",
    "    if precision_recall is None:\n",
    "        start_total_time = time()\n",
    "        persons = list(distances.person1.unique())\n",
    "        cols = list(distances.columns)\n",
    "        recovered_results = []\n",
    "        for c in cols:\n",
    "\n",
    "            if c in COLUMNS_TO_IGNORE:\n",
    "                continue\n",
    "\n",
    "            print(f\"Calculating Precision vs Recall for col {c}\")\n",
    "\n",
    "            start_time = time()\n",
    "\n",
    "            # Calculalate how many images method (columns of distaneces) get right for each person\n",
    "            distances.sort_values(by=[c], inplace=True)\n",
    "            for person in persons:\n",
    "                person_imgs_count = distances[(distances.person1 == person) & (distances.same_person == \"same\")].shape[0]\n",
    "                for imgs_to_recover in range(1, person_imgs_count, 1):\n",
    "                    recovered = distances[distances['person1'] == person].head(imgs_to_recover)\n",
    "                    imgs_of_person_recovered = recovered[(recovered.same_person == \"same\")].shape[0]\n",
    "                    wrong_recovered = recovered[recovered.person2 != person].shape[0]\n",
    "                    recovered_results.append({\n",
    "                                                \"method\": c,\n",
    "                                                \"person\": person,\n",
    "                                                \"imgs_of_person\": person_imgs_count,\n",
    "                                                \"imgs_recovered\": imgs_to_recover,  \n",
    "                                                \"imgs_of_person_recovered\": imgs_of_person_recovered,\n",
    "                                                \"wrong_recovered\": wrong_recovered,\n",
    "                                                \"max_imgs_of_person_available\": min(imgs_to_recover, person_imgs_count),\n",
    "                                            })\n",
    "\n",
    "            precision_recall = pd.DataFrame(recovered_results)\n",
    "            precision_recall['precision'] = precision_recall.imgs_of_person_recovered / precision_recall.max_imgs_of_person_available\n",
    "            precision_recall['recall'] = precision_recall.imgs_of_person_recovered / precision_recall.imgs_of_person\n",
    "            precision_recall.to_json(PRECISION_RECALL_FILE_PATH, orient=\"records\")\n",
    "\n",
    "            print(f\"Precision vs Recall done for col {c} in {(time() - start_time) // 60} minutes.\")\n",
    "            send_simple_message(f\"Precision vs Recall done for col {c} in {(time() - start_time) // 60} minutes.\")\n",
    "\n",
    "        print(f\"Precision vs Recall done for all columns in {(time() - start_total_time) // 60} minutes.\")\n",
    "        send_simple_message(f\"Precision vs Recall done for all columns in {(time() - start_total_time) // 60} minutes.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not ONLY_MAIN_CHARTS:\n",
    "    plot_data = precision_recall.loc[:, [\"method\", \"precision\", \"recall\"]]\n",
    "    dlib_data = precision_recall[precision_recall.method == \"dlib_distance\"]\n",
    "    resnet_data = precision_recall[precision_recall.method == \"resnet_distance\"]\n",
    "\n",
    "    ROWS = 4\n",
    "    COLS = 5\n",
    "    methods = list(plot_data.method.unique())\n",
    "    idx_generator = next_axis(rows=ROWS, cols=COLS)\n",
    "    fig, axes = plt.subplots(nrows=ROWS, ncols=COLS, figsize=(35,30))\n",
    "    for tmp_method in methods:\n",
    "        if tmp_method == \"dlib_distance\" or tmp_method == \"resnet_distance\" or tmp_method == \"same\":\n",
    "            continue\n",
    "\n",
    "        row_idx, col_idx = idx_generator.__next__()\n",
    "        axes[row_idx, col_idx].set_title(\"Precision vs Recall\")\n",
    "        ax1 = sns.lineplot(ax=axes[row_idx, col_idx], x=\"recall\", y=\"precision\", data=dlib_data, color=\"green\")\n",
    "        ax1 = sns.lineplot(ax=axes[row_idx, col_idx], x=\"recall\", y=\"precision\", data=resnet_data, color=\"blue\")\n",
    "        ax1 = sns.lineplot(ax=axes[row_idx, col_idx], x=\"recall\", y=\"precision\", data=plot_data[plot_data.method == tmp_method], color=\"red\")\n",
    "        _ = ax1.set_xlabel(\"Recall\")\n",
    "        _ = ax1.set_ylabel(\"Precision\")\n",
    "        _ = ax1.set_title(f\"Precision vs Recall {tmp_method}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# send_simple_message(\"ResNET Experiment Analysis done.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(distances.img1.unique())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('tf2_resnet')",
   "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.9.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "599a4db38103377133a9d21b7d02324d7e7685cce2f1b75d4c68b493ddfcf076"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}