Data Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Extracting visual features from the TotallyLooksLike Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 534,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline\n",
    "from scipy.spatial.distance import cdist\n",
    "# basic function for reading an image pair and splitting to left and right halves\n",
    "# and other utility functions\n",
    "def readAndSplit(p):\n",
    "    I = imread(p)\n",
    "    I = I[:245,:400,:3]\n",
    "    s = hsplit(I,2)\n",
    "    return s[0],s[1]\n",
    "  \n",
    "# now we extract features from all left and right images.\n",
    "\n",
    "\n",
    "import errno    \n",
    "import os\n",
    "def mkdir_p(path):\n",
    "    try:\n",
    "        os.makedirs(path)\n",
    "    except OSError as exc:  # Python >2.5\n",
    "        if exc.errno == errno.EEXIST and os.path.isdir(path):\n",
    "            pass\n",
    "        else:\n",
    "            raise\n",
    "\n",
    "# Let's make a bunch of models.\n",
    "\n",
    "toSaveFigures = False\n",
    "saveFigsBaseDir = 'figures'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Extraction\n",
    "## Generic Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 535,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extracting features using all networks...\n",
      "checking for /home/amir/TotallyLooksLike/results/resnet18.pkl ...\n",
      "exists! - skipping\n",
      "checking for /home/amir/TotallyLooksLike/results/resnet50.pkl ...\n",
      "exists! - skipping\n",
      "checking for /home/amir/TotallyLooksLike/results/vgg16.pkl ...\n",
      "exists! - skipping\n",
      "checking for /home/amir/TotallyLooksLike/results/densenet201.pkl ...\n",
      "exists! - skipping\n",
      "checking for /home/amir/TotallyLooksLike/results/densenet121.pkl ...\n",
      "exists! - skipping\n",
      "checking for /home/amir/TotallyLooksLike/results/resnet152.pkl ...\n",
      "exists! - skipping\n",
      "checking for /home/amir/TotallyLooksLike/results/densenet169.pkl ...\n",
      "exists! - skipping\n",
      "checking for /home/amir/TotallyLooksLike/results/alexnet.pkl ...\n",
      "exists! - skipping\n",
      "DONE\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import pickle\n",
    "\n",
    "import torch,os\n",
    "from glob import glob\n",
    "import torch.nn as nn\n",
    "from torchvision import models\n",
    "from torchvision import transforms\n",
    "normalize = transforms.Normalize(\n",
    "   mean=[0.485, 0.456, 0.406],\n",
    "   std=[0.229, 0.224, 0.225]\n",
    ")\n",
    "preprocess = transforms.Compose([\n",
    "   transforms.Scale(256),\n",
    "   transforms.CenterCrop(224),\n",
    "   transforms.ToTensor(),\n",
    "   normalize\n",
    "])\n",
    "networks = dict(resnet18 = models.resnet18,\n",
    "                resnet50 = models.resnet50,\n",
    "                resnet152 = models.resnet152,\n",
    "                densenet121 = models.densenet121,\n",
    "                densenet169 = models.densenet169,\n",
    "                densenet201 = models.densenet201,\n",
    "                alexnet = models.alexnet,\n",
    "                vgg16=models.vgg16)\n",
    "class VGG_features(nn.Module):\n",
    "    def __init__(self, vgg_net):\n",
    "        super(VGG_features, self).__init__()\n",
    "        self.vgg_net = vgg_net\n",
    "        self.C = nn.Sequential(*list(vgg_net.classifier.children())[:-2])\n",
    "    def forward(self, x):\n",
    "        x = self.vgg_net.features(x)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.C(x)\n",
    "        return x\n",
    "def getNetwork(networkName):   \n",
    "    model = networks[networkName](pretrained=True)\n",
    "    if 'resnet' in networkName:        \n",
    "        model = nn.Sequential(*list(model.children())[:-1])\n",
    "    elif 'densenet' in networkName:\n",
    "        return nn.Sequential(model.features,nn.AvgPool2d(7,stride=1))\n",
    "    else:\n",
    "        assert 'vgg' in networkName or 'alexnet' in networkName\n",
    "        return VGG_features(model)\n",
    "    return model\n",
    "homedir=os.path.expanduser('~')\n",
    "baseDir = os.path.join(homedir,'TotallyLooksLike')\n",
    "imageDir=os.path.join(baseDir,'Images')\n",
    "outputDir=os.path.join(baseDir,'results')\n",
    "\n",
    "imageNames = []\n",
    "import PIL\n",
    "from PIL import Image\n",
    "from torch.autograd import Variable\n",
    "import os\n",
    "import cPickle as pickle\n",
    "from tqdm import tqdm\n",
    "print 'extracting features using all networks...'\n",
    "G = sorted(glob(os.path.join(imageDir,'*.jpg'))) # get all images names, sorted \n",
    "for networkName,networkFun in networks.items():\n",
    "    curOutPath = os.path.join(outputDir,networkName+'.pkl')\n",
    "    print 'checking for',curOutPath,'...'\n",
    "    if os.path.isfile(curOutPath):\n",
    "        print 'exists! - skipping'\n",
    "        continue\n",
    "    m = getNetwork(networkName)    \n",
    "    m.eval()\n",
    "    print 'networkName',networkName    \n",
    "    m.cuda();\n",
    "    leftResults = []\n",
    "    rightResults = []\n",
    "    for imgPath in tqdm(G):\n",
    "        #resPath = imgPath.replace('.jpg','.pkl')\n",
    "        #if os.path.isfile(resPath):\n",
    "        #    continue\n",
    "        #print imgPath\n",
    "        I = imread(imgPath)[:,:,:3]\n",
    "        I = I[:245,:400,:]\n",
    "        s = hsplit(I,2)\n",
    "        curImage = s[0]\n",
    "        leftResult = m(Variable(preprocess(Image.fromarray(curImage)).unsqueeze(0).cuda())).squeeze().data.cpu().numpy()\n",
    "        curImage = s[1]\n",
    "        rightResult = m(Variable(preprocess(Image.fromarray(curImage)).unsqueeze(0).cuda())).squeeze().data.cpu().numpy()\n",
    "        \n",
    "        leftResults.append(leftResult)\n",
    "        rightResults.append(rightResult)\n",
    "        \n",
    "    pickle.dump(dict(leftResults=leftResults,rightResults=rightResults,G=G),open(curOutPath,'wb'))        \n",
    "    #pickle.dump(d\n",
    "print 'DONE'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generic Face Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generic face features exist - skipping.\n"
     ]
    }
   ],
   "source": [
    "m = getNetwork('densenet121')\n",
    "m.eval()\n",
    "m.cuda()\n",
    "faces_generic_feats = {}\n",
    "curOutPath = os.path.join(outputDir,'faces_generic_feats.pkl')\n",
    "if os.path.isfile(curOutPath):\n",
    "    print 'generic face features exist - skipping.' \n",
    "    faces_generic_feats = pickle.load(open(curOutPath,'rb'))    \n",
    "else:\n",
    "    for k,v in tqdm(a.items()):\n",
    "        left_feats = []\n",
    "        right_feats = []\n",
    "        for img in v['left_face_imgs']:\n",
    "            res = m(Variable(preprocess(Image.fromarray(img)).unsqueeze(0).cuda())).squeeze().data.cpu().numpy()\n",
    "            left_feats.append(res)\n",
    "        for img in v['right_face_imgs']:\n",
    "            res = m(Variable(preprocess(Image.fromarray(img)).unsqueeze(0).cuda())).squeeze().data.cpu().numpy()\n",
    "            right_feats.append(res)\n",
    "        faces_generic_feats[k]=dict(left_feats=left_feats,right_feats=right_feats)    \n",
    "    print('dumping')\n",
    "    pickle.dump(faces_generic_feats,open(curOutPath,'wb'),protocol=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Face detection stats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 537,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let's show both the correlation between the number of left, right faces, as well as the distribution of faces overall.\n",
    "face_enc_path = os.path.join(outputDir,'face_encodings.pkl')\n",
    "a = pickle.load(open(face_enc_path,'rb'))\n",
    "import seaborn as sns\n",
    "n_faces_left = zeros(len(a))\n",
    "n_faces_right = zeros(len(a))\n",
    "for i,aa in enumerate(a.values()):\n",
    "    n_faces_left[i]=len(aa['left_enc'])\n",
    "    n_faces_right[i]=len(aa['right_enc'])\n",
    "    \n",
    "# plot for each condition the number of total faces and the agreement\n",
    "r = []\n",
    "r_left = []\n",
    "r_right = []\n",
    "R=4\n",
    "for cc in range(R):\n",
    "    c=n_faces_left==cc\n",
    "    r.append(sum(logical_and(n_faces_left==cc,n_faces_right==cc)))\n",
    "    r_left.append(sum(n_faces_left==cc))\n",
    "    r_right.append(sum(n_faces_right==cc))\n",
    "    #r.append(sum(n_faces_left[c]==n_faces_right[c])/float(sum(c)))\n",
    "    #r_left = len(n_faces_left[c])\n",
    "ax = plt.subplot(111)\n",
    "w = 0.3\n",
    "x=array(range(R)).astype(float)\n",
    "ax.bar(x-w, r,width=w,label='both')#,color='b',align='center')\n",
    "ax.bar(x, r_left,width=w,label='left')#,color='g',align='center')\n",
    "ax.bar(x+w, r_right,width=w,label='right')#,color='r',align='center')\n",
    "legend()\n",
    "xlabel('no. faces')\n",
    "ylabel('no. images')\n",
    "\n",
    "if toSaveFigures:\n",
    "  savefig(os.path.join(saveFigsBaseDir,'face_counts.pdf'),bbox_inches='tight')\n",
    "#bar(height=[r,r_left,r_right])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compute all pairwise distances\n",
    "## Left-to-RightDistances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/amir/TotallyLooksLike/results/resnet18.pkl.dist exist - skipping\n",
      "/home/amir/TotallyLooksLike/results/resnet50.pkl.dist exist - skipping\n",
      "/home/amir/TotallyLooksLike/results/vgg16.pkl.dist exist - skipping\n",
      "/home/amir/TotallyLooksLike/results/densenet201.pkl.dist exist - skipping\n",
      "/home/amir/TotallyLooksLike/results/densenet121.pkl.dist exist - skipping\n",
      "/home/amir/TotallyLooksLike/results/resnet152.pkl.dist exist - skipping\n",
      "/home/amir/TotallyLooksLike/results/densenet169.pkl.dist exist - skipping\n",
      "/home/amir/TotallyLooksLike/results/alexnet.pkl.dist exist - skipping\n"
     ]
    }
   ],
   "source": [
    "# ok, now let's compute the pairwise distances between all left/right images.\n",
    "for networkName,networkFun in networks.items():\n",
    "    curOutPath = os.path.join(outputDir,networkName+'.pkl')\n",
    "    dists_out_path = curOutPath+'.dist'    \n",
    "    if os.path.isfile(dists_out_path):\n",
    "        print dists_out_path,'exist - skipping'\n",
    "        continue\n",
    "    else:\n",
    "        print 'calculating distances....',\n",
    "        a = pickle.load(open(curOutPath))\n",
    "        L = stack(a['leftResults'])\n",
    "        R = stack(a['rightResults'])\n",
    "        D = cdist(L,R)\n",
    "        D1 = cdist(L,R,metric='cosine')\n",
    "        pickle.dump(dict(D_euclid=D.astype(float32),D_cosine=D1.astype(float32),G=G),open(dists_out_path,'wb'),protocol=2)\n",
    "        print('done!')\n",
    "        \n",
    "# calculate the inner distance to decide which pairs to discard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Internal distances\n",
    "### Generic Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('generic features', '/home/amir/TotallyLooksLike/results/generic_inner_distances.pkl', 'exists - skipping')\n"
     ]
    }
   ],
   "source": [
    "curOutPath=os.path.join(outputDir,'densenet121.pkl')\n",
    "generic_inner_path = os.path.join(outputDir,'generic_inner_distances.pkl')\n",
    "if os.path.isfile(generic_inner_path):\n",
    "    print('generic features',generic_inner_path,'exists - skipping')\n",
    "    generic_inner_dists_sorted = pickle.load(open(generic_inner_path))\n",
    "else:\n",
    "    a = pickle.load(open(curOutPath))\n",
    "    L = stack(a['leftResults'])\n",
    "    R = stack(a['rightResults'])\n",
    "    print 'computing inner left distances'\n",
    "    D1_LL = cdist(L,L,metric='cosine').astype(float32)\n",
    "    print 'computing inner right distances'\n",
    "    D1_RR = cdist(R,R,metric='cosine').astype(float32)\n",
    "    #L_sorted = D1_LL.argsort(1).astype(int16)\n",
    "    #R_sorted = D1_RR.argsort(1).astype(int16)\n",
    "    generic_inner_dists_sorted = dict(D1_LL=D1_LL, D1_RR=D1_RR)\n",
    "    print('dumping...')\n",
    "    #pickle.dump(generic_inner_dists_sorted, open(generic_inner_path,'wb'), protocol=2)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Face features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left_enc\n",
      "file already exists - loading pre-computed... done\n",
      "left_enc\n",
      "file already exists - loading pre-computed... done\n",
      "right_enc\n",
      "file already exists - loading pre-computed... done\n",
      "right_enc\n",
      "file already exists - loading pre-computed... done\n"
     ]
    }
   ],
   "source": [
    "# left-left faces and right-right faces.\n",
    "side1 = 'left_enc'\n",
    "side2 = 'right_enc'\n",
    "for cur_side in [side1,side2]:\n",
    "    for is_generic in [False,True]:\n",
    "        print cur_side\n",
    "        G = sorted(glob(os.path.join(imageDir,'*.jpg')))\n",
    "        if is_generic:\n",
    "            face_dists_path_inner = os.path.join(outputDir,'faces_generic_dists_inner_{}.pkl'.format(cur_side)) \n",
    "            chosen_metric = 'cosine'\n",
    "        else:\n",
    "            face_dists_path_inner = os.path.join(outputDir,'faces_dists_inner_{}.pkl'.format(cur_side)) \n",
    "            chosen_metric='euclidean'\n",
    "        if os.path.isfile(face_dists_path_inner):\n",
    "            print 'file already exists - loading pre-computed...',\n",
    "            face_dists = pickle.load(open(face_dists_path_inner,'rb'))\n",
    "            print 'done'\n",
    "        else:\n",
    "            if is_generic:\n",
    "                print 'loading generic feats....'\n",
    "                face_enc_path = os.path.join(outputDir,'faces_generic_feats.pkl')\n",
    "                cur_side = 'left_feats' if cur_side==side1 else 'right_feats' # small fix because of inconsistent naming.\n",
    "            else:\n",
    "                face_enc_path = os.path.join(outputDir,'face_encodings.pkl')\n",
    "            a = pickle.load(open(face_enc_path,'rb'))\n",
    "            sorted_files = [g.split('/')[-1] for g in G]\n",
    "            n_images = len(sorted_files)\n",
    "            print n_images\n",
    "            face_dists_inner = 10**9*np.ones((n_images,n_images),dtype=float32)\n",
    "            dd = {}\n",
    "            for i,s_i in enumerate(sorted_files):\n",
    "                if i % 100 == 0:\n",
    "                    print\n",
    "                left_feats = a[s_i][cur_side]\n",
    "                if len(left_feats) == 0:\n",
    "                    print '-',\n",
    "                    continue\n",
    "                print '*',\n",
    "                left_feats=stack(left_feats)\n",
    "                for j,s_j in enumerate(sorted_files):\n",
    "                    left_feats1 = a[s_j][cur_side]\n",
    "                    if len(left_feats1) == 0:\n",
    "                        continue\n",
    "                    left_feats1=stack(left_feats1)                \n",
    "                    face_dists_inner[i,j] = min(face_dists_inner[i,j], cdist(left_feats,left_feats1,metric=chosen_metric).ravel().min())\n",
    "            dd[cur_side] = face_dists_inner.astype(float32)\n",
    "            print('dumping...')\n",
    "            pickle.dump(dd,open(face_dists_path_inner,'wb'),protocol=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyze internal distances to detect duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def makeDupsGallery(dists,mins,thresh=.15,suff='',sides=[0,0]):\n",
    "    G = sorted(glob(os.path.join(imageDir,'*.jpg')))\n",
    "    outDir = '/media/amir/newhd/TotallyLooksLike/sorted_for_dups_{}/'.format(suff)\n",
    "    if not os.path.isdir(outDir):\n",
    "        os.mkdir(outDir)\n",
    "    for k in range(len(dists)):\n",
    "        if k % 100 == 0:\n",
    "            print '.',k,\n",
    "        d = dists[k]\n",
    "        dd = mins[k]\n",
    "        cur_dist = d\n",
    "        if cur_dist > thresh:\n",
    "            continue\n",
    "        z=[ readAndSplit(G[k])[sides[0]]    ,readAndSplit(G[dd])[sides[1]]]\n",
    "        imsave('{}/{:02.10f}_{}.jpg'.format(outDir,d,str(k).zfill(5)),hstack(z),format='jpg')\n",
    "        if k > 1000:\n",
    "            break\n",
    "    #4242\n",
    "#right_dists_second = D1_RR[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 538,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from copy import deepcopy\n",
    "generic_dup_threshold = .15\n",
    "face_dup_threshold = .4\n",
    "a = pickle.load(open(generic_inner_path))\n",
    "#L_sorted = D1_LL.argsort(1).astype(int16)\n",
    "#R_sorted = D1_RR.argsort(1).astype(int16)\n",
    "D1_LL = deepcopy(a['D1_LL'])\n",
    "D1_LL = D1_LL+eye(len(D1_RR))*100;\n",
    "mins  = D1_LL.argmin(1)\n",
    "dists = D1_LL.min(1)\n",
    "dists_left = D1_LL.min(1)\n",
    "\n",
    "\n",
    "D1_RR = deepcopy(a['D1_RR'])\n",
    "D1_RR = D1_RR+eye(len(D1_RR))*100;\n",
    "mins  = D1_RR.argmin(1)\n",
    "dists_right = D1_RR.min(1)\n",
    "#makeDupsGallery(dists_right,mins,10,'generic_RR')\n",
    "#makeDupsGallery(dists,mins,10,'generic_LL',[0,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 539,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading...\n"
     ]
    }
   ],
   "source": [
    "# Now, let us look at cross-duplicates.\n",
    "networkName='densenet121'       \n",
    "curOutPath = os.path.join(outputDir,networkName+'.pkl')\n",
    "dists_out_path = curOutPath+'.dist'\n",
    "print 'loading...'\n",
    "a = pickle.load(open(dists_out_path))\n",
    "a1 = deepcopy(a['D_cosine'])\n",
    "a1 = a1 +100*eye(size(a1[0]))\n",
    "cross_dists = a1.min(1)\n",
    "cross_mins = a1.argmin(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 621,
   "metadata": {},
   "outputs": [],
   "source": [
    "right_generic_thresh=.1\n",
    "is_dup_right = dists_right <=right_generic_thresh\n",
    "is_dup_left = dists_left <=right_generic_thresh\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 542,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_dists_path_inner_left = os.path.join(outputDir,'faces_dists_inner_{}.pkl'.format(side1)) \n",
    "face_dists = pickle.load(open(face_dists_path_inner_left,'rb'))\n",
    "D1_LL = deepcopy(face_dists[side1])\n",
    "D1_LL.sort(1);\n",
    "face_dists_path_inner_right = os.path.join(outputDir,'faces_dists_inner_{}.pkl'.format(side2));\n",
    "face_dists = pickle.load(open(face_dists_path_inner_right,'rb'))\n",
    "D1_RR = deepcopy(face_dists[side2])\n",
    "D1_RR.sort(1);\n",
    "left_dists_second=D1_LL[:,1]\n",
    "right_dists_second=D1_RR[:,1]\n",
    "face_dups_left = (left_dists_second<=.4)\n",
    "face_dups_right = (right_dists_second<=.4)\n",
    "face_feature_dups=dict(face_dups_left=face_dups_left,face_dups_right=face_dups_right,left_dists_second=left_dists_second,right_dists_second=right_dists_second)\n",
    "\n",
    "# and do the same for the face dists....\n",
    "\n",
    "# do it with faces.\n",
    "face_dists_path = os.path.join(outputDir,'faces_dists.pkl') \n",
    "if os.path.isfile(face_dists_path):\n",
    "    face_dists = pickle.load(open(face_dists_path,'rb'))\n",
    "a = pickle.load(open(face_enc_path,'rb'))\n",
    "G=[]\n",
    "for z in a.keys():\n",
    "    G.append(os.path.join('/media/amir/newhd/TotallyLooksLike/Images/',z))\n",
    "\n",
    "a_face_dist = pickle.load(open(face_dists_path));\n",
    "a_face_dist = a_face_dist +100*eye(len(a_face_dist))\n",
    "cross_face_dists = a_face_dist.min(1)\n",
    "cross_face_mins = a_face_dist.argmin(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 543,
   "metadata": {},
   "outputs": [],
   "source": [
    "####### Now, generic features.\n",
    "#cur_side = 'left_feats' if cur_side==side1 else 'right_feats'\n",
    "face_dists_path_inner_left = os.path.join(outputDir,'faces_generic_dists_inner_{}.pkl'.format(side1));\n",
    "face_dists = pickle.load(open(face_dists_path_inner_left,'rb'))\n",
    "D1_LL = deepcopy(face_dists['left_feats'])\n",
    "D1_LL.sort(1);\n",
    "face_dists_path_inner_right = os.path.join(outputDir,'faces_generic_dists_inner_{}.pkl'.format(side2));\n",
    "face_dists = pickle.load(open(face_dists_path_inner_right,'rb'))\n",
    "D1_RR = deepcopy(face_dists['right_feats'])\n",
    "D1_RR.sort(1);\n",
    "left_dists_second=D1_LL[:,1]\n",
    "right_dists_second=D1_RR[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 544,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_dups_left = (left_dists_second<=.15)\n",
    "face_dups_right = (right_dists_second<=.15)\n",
    "face_generic_feature_dups=dict(face_dups_left=face_dups_left,face_dups_right=face_dups_right,left_dists_second=left_dists_second,right_dists_second=right_dists_second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 547,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_dists_path_inner_left = os.path.join(outputDir,'faces_dists_inner_{}.pkl'.format(side1)) \n",
    "face_dists = pickle.load(open(face_dists_path_inner_left,'rb'))\n",
    "D1_LL = deepcopy(face_dists[side1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 548,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_dists_path_inner_left = os.path.join(outputDir,'faces_dists_inner_left_enc.pkl');\n",
    "face_dists = pickle.load(open(face_dists_path_inner_left,'rb'))\n",
    "D1_LL = deepcopy(face_dists['left_enc'])\n",
    "D1_LL = D1_LL+eye(len(D1_LL))*100;\n",
    "mins_face_left  = D1_LL.argmin(1)\n",
    "dists_face_left = D1_LL.min(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "IOError",
     "evalue": "[Errno 2] No such file or directory: '/media/amir/newhd/TotallyLooksLike/results/faces_dists_inner_left_enc.pkl'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIOError\u001b[0m                                   Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-cc899b77f668>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mface_dists_path_inner_left\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputDir\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'/media/amir/newhd/TotallyLooksLike/results/faces_dists_inner_left_enc.pkl'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mface_dists\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpickle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mface_dists_path_inner_left\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mD1_LL\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mface_dists\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'left_enc'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mD1_LL\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mD1_LL\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0meye\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mD1_LL\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mmins_face_left\u001b[0m  \u001b[0;34m=\u001b[0m \u001b[0mD1_LL\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIOError\u001b[0m: [Errno 2] No such file or directory: '/media/amir/newhd/TotallyLooksLike/results/faces_dists_inner_left_enc.pkl'"
     ]
    }
   ],
   "source": [
    "#makeDupsGallery(dists_face_left,mins_face_left,1.5,'faces_LL',[0,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 549,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_dists_path_inner_right = os.path.join(outputDir,'faces_dists_inner_right_enc.pkl');\n",
    "face_dists = pickle.load(open(face_dists_path_inner_right,'rb'))\n",
    "D1_RR = deepcopy(face_dists['right_enc'])\n",
    "D1_RR = D1_RR+eye(len(D1_LL))*100;\n",
    "mins_face_right  = D1_RR.argmin(1)\n",
    "dists_face_right = D1_RR.min(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 550,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0.05\n",
    "face_thresh = 0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 551,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_dists_path_inner_right = os.path.join(outputDir,'faces_dists_inner_right_enc.pkl');\n",
    "face_dists = pickle.load(open(face_dists_path_inner_right,'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 552,
   "metadata": {},
   "outputs": [],
   "source": [
    "D1_RR = deepcopy(face_dists['right_enc'])\n",
    "D1_RR = D1_RR+eye(len(D1_RR))*100;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 553,
   "metadata": {},
   "outputs": [],
   "source": [
    "mins_face  = D1_RR.argmin(1)\n",
    "dists_face = D1_RR.min(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 555,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_dups = logical_or(mins_face_left <=.4,mins_face_right<=.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 556,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3206"
      ]
     },
     "execution_count": 556,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "face_dups.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_dups_path = os.path.join(baseDir,'results/dup.pkl')\n",
    "if not os.path.isfile(all_dups_path):\n",
    "    dup_dict = dict(is_dup_right=is_dup_right,face_dups=face_dups)\n",
    "    \n",
    "    pickle.dump(dup_dict,open(all_dups_path,'wb'),protocol=2)\n",
    "else:\n",
    "    dup_dict = pickle.load(open(all_dups_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "metadata": {},
   "outputs": [],
   "source": [
    "#L = stack(a['rightResults'])\n",
    "curOutPath=os.path.join(baseDir,'results/densenet121.pkl')\n",
    "a = pickle.load(open(curOutPath))\n",
    "L = stack(a['leftResults'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Do this for faces, too : find sets of duplicate faces...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 563,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_enc_path = os.path.join(outputDir,'face_encodings.pkl')\n",
    "#/media/amir/newhd/TotallyLooksLike/results/face_encodings.pkl_2\n",
    "a_face = pickle.load(open(face_enc_path,'rb'))\n",
    "has_face = {}\n",
    "for k,v in a_face.items():\n",
    "    has_face[k] = max(len(v['left_enc']),len(v['right_enc'])) \n",
    "new_sel=[]\n",
    "for k in a['G']:\n",
    "    new_sel.append(has_face[k.split('/')[-1]]==1)\n",
    "sel_face=array(new_sel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ok, now calculate distances for each pair of images for each pair of faces within, skipping images with no faces (set their face distance to INF). Note this is done only for the L2 distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 564,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_style('ticks')\n",
    "sns.set_context('paper',font_scale=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 565,
   "metadata": {},
   "outputs": [],
   "source": [
    "networkName = 'densenet121'\n",
    "curOutPath = os.path.join(outputDir,networkName+'.pkl')\n",
    "dists_out_path = curOutPath+'.dist'\n",
    "a = pickle.load(open(dists_out_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 566,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv(os.path.join(baseDir,'Votes/test2.csv'))\n",
    "#df.sort_values('id').wins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test any correlation between cosine distance and upvotes on website"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 567,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "sns.set_style('ticks')\n",
    "sns.set_context('paper',font_scale=2)\n",
    "#ax = sns.kdeplot(ff/max(ff), ww/max(ww), shade=False,n_levels=10)\n",
    "zz = df.sort_values('id').wins.map(float)\n",
    "zz_L=df.sort_values('id').fails.map(float)\n",
    "zz = array(zz)\n",
    "ax=sns.jointplot(zz,diag(a['D_cosine']),  kind=\"kde\")#,xlim=[1.5,3.5],ylim=[.4,3])\n",
    "#xlabe\n",
    "#ax.set(xlim=[0,.5],ylim=[0,.5])\n",
    "\n",
    "#ax.set_axis_labels(xlabel='$log10(wins)$',ylabel='$log10(fails)$') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 568,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SpearmanrResult(correlation=-0.07543714468885346, pvalue=4.677570319625186e-09)"
      ]
     },
     "execution_count": 568,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.stats import spearmanr,pearsonr\n",
    "scores = diag(a['D_cosine'])\n",
    "spearmanr(zz_L ,scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 584,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "resnet18\n",
      "resnet50\n",
      "vgg16\n",
      "densenet201\n",
      "densenet121\n",
      "resnet152\n",
      "densenet169\n",
      "alexnet\n"
     ]
    }
   ],
   "source": [
    "zs = []\n",
    "for networkName,networkFun in networks.items():\n",
    "    print networkName\n",
    "    curOutPath = os.path.join(outputDir,networkName+'.pkl')\n",
    "    dists_out_path = curOutPath+'.dist'\n",
    "    a = pickle.load(open(dists_out_path))\n",
    "    for k in ['D_cosine','D_euclid']:\n",
    "        D = a[k]\n",
    "        D_sorted=D.argsort(axis=1)\n",
    "        #N=float(len(D))\n",
    "        N=len(D)\n",
    "        D_true = array(range(N)).reshape(N,1)\n",
    "        d=((D_sorted==D_true).sum(0)).astype(float)\n",
    "        #plot(arange(0,1,1./N), cumsum(d)/sum(d))#,xlabel='index')#,ylabel=)\n",
    "        # plot the recall at different points.    \n",
    "        zz=cumsum(sum(D_sorted==D_true,0))\n",
    "        zs.append((networkName,k,zz))    \n",
    "if False:\n",
    "    N = float(N)\n",
    "    print 'recall @ 0,5,10,100:',100*zz[[0,4,9,99]]/N\n",
    "    z=nonzero(D_sorted==D_true)[1]\n",
    "    aa=hist(z[z<=inf],100,normed=True,cumulative=True,histtype='step',linewidth=2)\n",
    "    xlabel('no images');\n",
    "    ylabel('$p(hit)$');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 570,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#%pylab inline\n",
    "map_net_type = lambda x:x.replace('resnet','Res').replace('densenet','Den')\n",
    "euclids = []\n",
    "coss = []\n",
    "types = []\n",
    "for net_type,dist_type,recalls in zs:\n",
    "    if dist_type=='D_cosine':\n",
    "        coss.append(recalls)\n",
    "        types.append(map_net_type(net_type))\n",
    "    else:\n",
    "        euclids.append(recalls)    \n",
    "from matplotlib.font_manager import FontProperties\n",
    "fontP = FontProperties()\n",
    "fontP.set_size('large') \n",
    "# large, medium, smaller, None, small, x-large, xx-small, larger, x-small, xx-large\n",
    "#plot( (array(coss)-array(euclids)).T);legend(types,ncol=1,fancybox=True,shadow=True,prop=fontP)\n",
    "plot( (array(coss)-array(euclids)).T);legend(types,ncol=1,fancybox=True,shadow=True,prop=fontP)\n",
    "xlabel('no. image')\n",
    "ylabel('recall(COS-L2)')\n",
    "if toSaveFigures:\n",
    "  savefig(os.path.join(saveFigsBaseDir,'recall_COS_vs_L2.pdf'),bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 572,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_context('paper',font_scale=2)\n",
    "sns.set_style('ticks')\n",
    "nb = 0\n",
    "#z1 = [q[2] for q in zs[2*nb:2*nb+2]]\n",
    "#z1 = [q[2] for q in zs[::2]]\n",
    "zs1 = [q for q in zs if q[1]=='D_cosine']\n",
    "z1 = [q[2] for q in zs1]# if q[1]=='D_cosine']\n",
    "mm=1\n",
    "nn=2\n",
    "subplot(mm,nn,1);plot(array(z1).T/float(N),'-'); \n",
    "xs = range(0,N,2000)\n",
    "labels=map(lambda x: str(x/1000)+'K' if x > 0 else '0',xs)\n",
    "xlabel('no. images');xticks(xs,labels,rotation=0)\n",
    "ylabel('recall')\n",
    "xs = [0,5,10,20]\n",
    "subplot(mm,nn,2);plot(array(z1).T[xs,:]/float(N),'-o');xticks(range(len(xs)),[str(x) for x in xs])\n",
    "xlabel('no. images');\n",
    "#legend_values=[map_net_type(q[0])+' / '+ d1[q[1]] for q in zs1]\n",
    "legend_values=[map_net_type(q[0]) for q in zs1]\n",
    "d1 = {'D_cosine':'COS','D_euclid':'L2'}\n",
    "gca().legend(legend_values,loc='center left',bbox_to_anchor=(1, .5),ncol=1)#, fancybox=True, shadow=True)\n",
    "plt.tight_layout();\n",
    "if toSaveFigures:\n",
    "  savefig(os.path.join(saveFigsBaseDir,'recall_and_zoom_without_duplicates.pdf'),bbox_inches='tight')\n",
    "#legend(legend_values,loc='right')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 695,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('number of images afer de-duplication:', 1828)\n",
      "resnet18\n",
      "resnet50\n",
      "vgg16\n",
      "densenet201\n",
      "densenet121\n",
      "resnet152\n",
      "densenet169\n",
      "alexnet\n"
     ]
    }
   ],
   "source": [
    "#all_dups = is_dup_right | is_dup_left | face_dups | (cross_dists <= .15)# | (cross_face_dists <= .4)\n",
    "right_generic_thresh=.1\n",
    "is_dup_right = dists_right <=right_generic_thresh\n",
    "is_dup_left = dists_left <=right_generic_thresh\n",
    "all_dups = is_dup_right | is_dup_left | face_dups | (cross_dists <= .15) | (cross_face_dists <= .4)\n",
    "zs = []\n",
    "sel = logical_not(all_dups)\n",
    "print('number of images afer de-duplication:',sum(sel))\n",
    "#sel = logical_and(sel,~sel_face)\n",
    "for networkName,networkFun in networks.items():\n",
    "    print networkName\n",
    "    #if networkName!='densenet121':\n",
    "    #    continue\n",
    "    curOutPath = os.path.join(outputDir,networkName+'.pkl')\n",
    "    dists_out_path = curOutPath+'.dist'\n",
    "    a = pickle.load(open(dists_out_path))\n",
    "    G = array(a['G'])\n",
    "    k = 'D_cosine'    \n",
    "    for k in ['D_cosine']:\n",
    "        D = a[k]\n",
    "        D = a[k]\n",
    "        D = D[sel]\n",
    "        D = D[:,sel]        \n",
    "        D_sorted=D.argsort(axis=1)\n",
    "        #N=float(len(D))\n",
    "        N=len(D)\n",
    "        D_true = array(range(N)).reshape(N,1)\n",
    "        d=((D_sorted==D_true).sum(0)).astype(float)\n",
    "        #plot(arange(0,1,1./N), cumsum(d)/sum(d))#,xlabel='index')#,ylabel=)\n",
    "        # plot the recall at different points.    \n",
    "        zz=cumsum(sum(D_sorted==D_true,0))\n",
    "        zs.append((networkName,k,zz))    \n",
    "    #break\n",
    "if False:\n",
    "    N = float(N)\n",
    "    print 'recall @ 0,5,10,100:',100*zz[[0,4,9,99]]/N\n",
    "    z=nonzero(D_sorted==D_true)[1]\n",
    "    aa=hist(z[z<=inf],100,normed=True,cumulative=True,histtype='step',linewidth=2)\n",
    "    xlabel('no images');\n",
    "    ylabel('$p(hit)$');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 696,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotDistanceFigures(zs):\n",
    "    import seaborn as sns\n",
    "    map_net_type = lambda x:x.replace('resnet','Res').replace('densenet','Den')\n",
    "    sns.set_context('paper',font_scale=2)\n",
    "    sns.set_style('ticks')\n",
    "    nb = 0\n",
    "    #z1 = [q[2] for q in zs[2*nb:2*nb+2]]\n",
    "    #z1 = [q[2] for q in zs[::2]]\n",
    "    zs1 = [q for q in zs if q[1]=='D_cosine']\n",
    "    z1 = [q[2] for q in zs1]# if q[1]=='D_cosine']\n",
    "    mm=1\n",
    "    nn=2\n",
    "    subplot(mm,nn,1);plot(array(z1).T/float(N),'-'); \n",
    "    Q=700\n",
    "    xs = range(0,N,Q)\n",
    "    labels=map(lambda x: str(x) if x > 0 else '0',xs)\n",
    "    xlabel('no. images');xticks(xs,labels,rotation=0)\n",
    "    ylabel('recall')\n",
    "    xs = [0,4,9,19]\n",
    "    subplot(mm,nn,2);plot(array(z1).T[xs,:]/float(N),'-o');xticks(range(len(xs)),[str(x+1) for x in xs])\n",
    "    xlabel('no. images');\n",
    "    #legend_values=[map_net_type(q[0])+' / '+ d1[q[1]] for q in zs1]\n",
    "    legend_values=[map_net_type(q[0]) for q in zs1]\n",
    "    d1 = {'D_cosine':'COS','D_euclid':'L2'}\n",
    "    gca().legend(legend_values,loc='center left',bbox_to_anchor=(1, .5),ncol=1)#, fancybox=True, shadow=True)\n",
    "    plt.tight_layout();\n",
    "    return z1,xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 697,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "z1,xs=plotDistanceFigures(zs)\n",
    "if toSaveFigures:\n",
    "  savefig(os.path.join(saveFigsBaseDir,'recall_and_zoom_without_duplicates.pdf'),bbox_inches='tight')\n",
    "##legend(legend_values,loc='right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Produce Table 1 from paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 698,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>R@1</th>\n",
       "      <th>R@5</th>\n",
       "      <th>R@10</th>\n",
       "      <th>R@20</th>\n",
       "      <th>R@50</th>\n",
       "      <th>R@100</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>alexnet</th>\n",
       "      <td>3.67</td>\n",
       "      <td>8.53</td>\n",
       "      <td>11.71</td>\n",
       "      <td>14.99</td>\n",
       "      <td>22.59</td>\n",
       "      <td>30.63</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vgg16</th>\n",
       "      <td>3.77</td>\n",
       "      <td>7.88</td>\n",
       "      <td>12.04</td>\n",
       "      <td>16.90</td>\n",
       "      <td>24.02</td>\n",
       "      <td>32.39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Res50</th>\n",
       "      <td>4.38</td>\n",
       "      <td>10.23</td>\n",
       "      <td>14.44</td>\n",
       "      <td>19.58</td>\n",
       "      <td>28.77</td>\n",
       "      <td>36.71</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Res152</th>\n",
       "      <td>4.98</td>\n",
       "      <td>10.28</td>\n",
       "      <td>13.89</td>\n",
       "      <td>18.38</td>\n",
       "      <td>26.20</td>\n",
       "      <td>35.61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Den201</th>\n",
       "      <td>5.47</td>\n",
       "      <td>11.82</td>\n",
       "      <td>16.14</td>\n",
       "      <td>20.84</td>\n",
       "      <td>30.47</td>\n",
       "      <td>38.18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Res18</th>\n",
       "      <td>5.53</td>\n",
       "      <td>11.32</td>\n",
       "      <td>14.50</td>\n",
       "      <td>19.31</td>\n",
       "      <td>28.06</td>\n",
       "      <td>35.61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Den169</th>\n",
       "      <td>5.69</td>\n",
       "      <td>12.25</td>\n",
       "      <td>15.59</td>\n",
       "      <td>19.09</td>\n",
       "      <td>28.67</td>\n",
       "      <td>37.53</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Den121</th>\n",
       "      <td>5.80</td>\n",
       "      <td>12.31</td>\n",
       "      <td>16.47</td>\n",
       "      <td>21.39</td>\n",
       "      <td>29.92</td>\n",
       "      <td>38.89</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          R@1    R@5   R@10   R@20   R@50  R@100\n",
       "alexnet  3.67   8.53  11.71  14.99  22.59  30.63\n",
       "vgg16    3.77   7.88  12.04  16.90  24.02  32.39\n",
       "Res50    4.38  10.23  14.44  19.58  28.77  36.71\n",
       "Res152   4.98  10.28  13.89  18.38  26.20  35.61\n",
       "Den201   5.47  11.82  16.14  20.84  30.47  38.18\n",
       "Res18    5.53  11.32  14.50  19.31  28.06  35.61\n",
       "Den169   5.69  12.25  15.59  19.09  28.67  37.53\n",
       "Den121   5.80  12.31  16.47  21.39  29.92  38.89"
      ]
     },
     "execution_count": 698,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TT=(array(z1).T[xs+[49,99],:]/float(N))\n",
    "TT = TT.T\n",
    "import pandas as pd\n",
    "df=pd.DataFrame(around(100*TT,2),index=legend_values,columns=['R@'+str(p+1) for p in (xs+[49,99])])\n",
    "df=df.sort_values('R@1')\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 699,
   "metadata": {},
   "outputs": [],
   "source": [
    "if False:\n",
    "  with open(\"my_table1.tex\", \"w\") as f:\n",
    "      f.write('\\\\documentclass{article}\\n\\\n",
    "      \\n\\\\usepackage{booktabs}\\n\\\n",
    "          \\\\begin{document}\\n')\n",
    "      f.write(df.to_latex())\n",
    "      f.write('\\\\end{document}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 700,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/amir/anaconda2/envs/universe/lib/python2.7/site-packages/ipykernel/__main__.py:8: MatplotlibDeprecationWarning: The find function was deprecated in version 2.2.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "percentage @1,5,10,20\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 3.06049822,  5.65836299,  8.14946619, 11.49466192])"
      ]
     },
     "execution_count": 700,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# involve face distance as well.\n",
    "face_generic_dists_path = os.path.join(outputDir,'faces_generic_dists.pkl') \n",
    "aa = pickle.load(open(face_generic_dists_path))\n",
    "# calculate the stuff for the faces.\n",
    "# exclude faces where images did not include any faces.\n",
    "selection_ = diag(aa < 100)\n",
    "aa1=aa[selection_]\n",
    "D_true=find(selection_)\n",
    "NN = len(D_true)\n",
    "D_true = D_true.reshape(NN,1)\n",
    "D_sorted = aa1.argsort(1)\n",
    "zz=cumsum(sum(D_sorted==D_true,0))\n",
    "print 'percentage @1,5,10,20'\n",
    "100*zz[[1,5,10,20]]/float(NN) # array([ 2.95373665,  5.72953737,  7.61565836, 11.31672598])\n",
    "# same for specific face features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 703,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And again, this time without faces either!\n",
    "# Let's do this again, this time remove all the near duplicates - with a threshold of .15\n",
    "zs = []\n",
    "#sel = logical_and(~sel_face,sel_dup)\n",
    "all_dups = is_dup_right | is_dup_left | face_dups | (cross_dists <= .15) | (cross_face_dists <= .4)\n",
    "sel_no_faces = (~is_dup_right & ~is_dup_left &  ~sel_face)\n",
    "#sel = ~all_dups | sel_no_faces\n",
    "sel = sel_no_faces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 704,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1622"
      ]
     },
     "execution_count": 704,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(sel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 705,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('number of selected images excluding faces and duplicates :', 1622)\n",
      "resnet18\n",
      "resnet50\n",
      "vgg16\n",
      "densenet201\n",
      "densenet121\n",
      "resnet152\n",
      "densenet169\n",
      "alexnet\n"
     ]
    }
   ],
   "source": [
    "print('number of selected images excluding faces and duplicates :',sum(sel_no_faces))\n",
    "for networkName,networkFun in networks.items():\n",
    "    print networkName\n",
    "    curOutPath = os.path.join(outputDir,networkName+'.pkl')\n",
    "    dists_out_path = curOutPath+'.dist'\n",
    "    a = pickle.load(open(dists_out_path))\n",
    "    G = array(a['G'])\n",
    "    k = 'D_cosine'    \n",
    "    for k in ['D_cosine']:\n",
    "        D = a[k]\n",
    "        D = D[sel]\n",
    "        D = D[:,sel]\n",
    "        D_sorted=D.argsort(axis=1)\n",
    "        #N=float(len(D))\n",
    "        N=len(D)\n",
    "        D_true = array(range(N)).reshape(N,1)\n",
    "        d=((D_sorted==D_true).sum(0)).astype(float)\n",
    "        #plot(arange(0,1,1./N), cumsum(d)/sum(d))#,xlabel='index')#,ylabel=)\n",
    "        # plot the recall at different points.    \n",
    "        zz=cumsum(sum(D_sorted==D_true,0))\n",
    "        zs.append((networkName,k,zz))    \n",
    "if False:\n",
    "    N = float(N)\n",
    "    print 'recall @ 0,5,10,100:',100*zz[[0,4,9,99]]/N\n",
    "    z=nonzero(D_sorted==D_true)[1]\n",
    "    aa=hist(z[z<=inf],100,normed=True,cumulative=True,histtype='step',linewidth=2)\n",
    "    xlabel('no images');\n",
    "    ylabel('$p(hit)$');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "no faces: sel_obj = (~is_dup_right & ~is_dup_left &  ~sel_face) \n",
    "no dups: sel_d = ~is_dup_right &~ is_dup_left &~ (cross_dists <= .15)  &~ face_dups &~ (cross_face_dists <= .4) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "query_data\n",
    "⮡no_faces\n",
    "   ⮡random   \n",
    "    ⮡human_query_paths  \n",
    "    ⮡human_query_targets\n",
    "    \n",
    "    ⮡all_sels\n",
    "    ⮡all_sels_f\n",
    "  ⮡sort_D\n",
    "    ⮡human_query_paths \n",
    "    ⮡human_query_targets\n",
    "    ⮡all_sels\n",
    "    ⮡all_sels_f\n",
    "⮡no_dups\n",
    "    ⮡random\n",
    "      ⮡...\n",
    "    ⮡sort_D\n",
    "      ⮡...\n",
    "    ⮡sort_F\n",
    "      ⮡...\n",
    "    ⮡sort_F_generic\n",
    "      ⮡...      "
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:universe]",
   "language": "python",
   "name": "conda-env-universe-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "274px",
    "width": "382px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}