plot representation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.manifold import TSNE\n",
    "import matplotlib.pyplot as plt\n",
    "import joblib\n",
    "import seaborn as sns\n",
    "sns.set_palette(sns.color_palette(\"hls\", 12))\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "inc = joblib.load('./with_movie/inception_representations.joblib')\n",
    "pca = joblib.load('./with_movie/pca_representation.joblib')\n",
    "res = joblib.load('./with_movie/resnet_representations.joblib')\n",
    "inc_fine = joblib.load(\"./fine_tuned_inception_xxx.joblib\")\n",
    "res_fine = joblib.load(\"./fine_tuned_resnet_xxx.joblib\")\n",
    "_, labels, _ = joblib.load('./with_movie/labels.joblib')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(963, 963)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pca.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_order =  []\n",
    "for label in labels:\n",
    "    if label not in label_order:\n",
    "        label_order.append(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.patches as mpatches\n",
    "def plot_data(X, labels, title=''):\n",
    "    \n",
    "    # find 2 dim representation \n",
    "    tsne = TSNE(n_components=2)\n",
    "    X_tsne = tsne.fit_transform(X)\n",
    "    x, y = zip(*X_tsne)\n",
    "    \n",
    "\n",
    "    # plotting code \n",
    "    cm = []\n",
    "    colors = sns.color_palette()\n",
    "    for label in labels:\n",
    "        idx = label_order.index(label)\n",
    "        cm.append(colors[idx])\n",
    "    plt.scatter(x,y,color=cm, marker='.')\n",
    "    frame1 = plt.gca()\n",
    "    frame1.axes.xaxis.set_ticklabels([])\n",
    "    frame1.axes.yaxis.set_ticklabels([])\n",
    "    patches = []\n",
    "    for label in sorted(label_order):\n",
    "        patches.append( mpatches.Patch(color=colors[label_order.index(label)], label=label))\n",
    "    lgd = plt.legend(handles=patches, loc='upper left', prop=dict(size=14), bbox_to_anchor=(1.02, 1))\n",
    "    plt.title(title)\n",
    "    plt.savefig('{}.png'.format(title), bbox_extra_artists=(lgd,), bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_data(pca, labels, \"PCA'd raw image representations\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_data(inc, labels, \"InceptionNet image representations\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_data(inc_fine, labels, \"InceptionNet Finetuned image representations\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_data(res, labels, \"ResNet image representations\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_data(res_fine, labels, \"ResNet Finetuned image representations\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cluster import KMeans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "def purity_score(clusters, classes):\n",
    "    \n",
    "    A = np.c_[(clusters,classes)]\n",
    "\n",
    "    n_accurate = 0.\n",
    "\n",
    "    for j in np.unique(A[:,0]):\n",
    "        z = A[A[:,0] == j, 1]\n",
    "        x = np.argmax(np.bincount(z))\n",
    "        n_accurate += len(z[z == x])\n",
    "\n",
    "    return n_accurate / A.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.37175493250259606"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmeans = KMeans(n_clusters=11, n_jobs=-1)\n",
    "pca_cluster = kmeans.fit_transform(pca)\n",
    "purity_score(kmeans.labels_.astype(int), np.array([label_order.index(l) for l in labels]).astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3582554517133956"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmeans = KMeans(n_clusters=11, n_jobs=-1)\n",
    "cluster = kmeans.fit_transform(inc)\n",
    "purity_score(kmeans.labels_.astype(int), np.array([label_order.index(l) for l in labels]).astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3790238836967809"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmeans = KMeans(n_clusters=11, n_jobs=-1)\n",
    "cluster = kmeans.fit_transform(inc_fine)\n",
    "purity_score(kmeans.labels_.astype(int), np.array([label_order.index(l) for l in labels]).astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6957424714434061"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmeans = KMeans(n_clusters=11, n_jobs=-1)\n",
    "cluster = kmeans.fit_transform(res)\n",
    "purity_score(kmeans.labels_.astype(int), np.array([label_order.index(l) for l in labels]).astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.731048805815161"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmeans = KMeans(n_clusters=11, n_jobs=-1)\n",
    "cluster = kmeans.fit_transform(res_fine)\n",
    "purity_score(kmeans.labels_.astype(int), np.array([label_order.index(l) for l in labels]).astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(963, 50)"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inc_cluster.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5503634475597092"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "purity_score(kmeans.labels_.astype(int), np.array([label2id[l] for l in labels]).astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "import numpy as np\n",
    "\n",
    "def purity_score(y_true, y_pred):\n",
    "    # matrix which will hold the majority-voted labels\n",
    "    y_labeled_voted = np.zeros(y_true.shape)\n",
    "    labels = np.unique(y_true)\n",
    "    # We set the number of bins to be n_classes+2 so that \n",
    "    # we count the actual occurence of classes between two consecutive bin\n",
    "    # the bigger being excluded [bin_i, bin_i+1[\n",
    "    bins = np.concatenate((labels, [np.max(labels)+1]), axis=0)\n",
    "\n",
    "    for cluster in np.unique(y_pred):\n",
    "        hist, _ = np.histogram(y_true[y_pred==cluster], bins=bins)\n",
    "        # Find the most present label in the cluster\n",
    "        winner = np.argmax(hist)\n",
    "        y_labeled_voted[y_pred==cluster] = winner\n",
    "\n",
    "    return accuracy_score(y_true, y_labeled_voted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.22741433021806853"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "purity_score(kmeans.labels_.astype(int), np.array([label2id[l] for l in labels]).astype(int))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}