SchemaMatching_DI_Task1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from difflib import SequenceMatcher\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "#READ DATA:\n",
    "IMDB_DF = pd.read_csv(\"imdb.csv\")\n",
    "imdb_header = list(IMDB_DF.columns.values)\n",
    "\n",
    "#imdb_header\n",
    "tbl1 = np.array(imdb_header)\n",
    "\n",
    "ROTTEN_TOMATOES_DF = pd.read_csv(\"rotten_tomatoes.csv\")\n",
    "rt_header = list(ROTTEN_TOMATOES_DF.columns.values)\n",
    "#rt_header\n",
    "tbl2 = np.array(rt_header)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Pref=np.zeros((len(tbl1),len(tbl2)))\n",
    "pref_tbl1=np.zeros((len(tbl1),len(tbl2)),dtype=np.int8)\n",
    "ipref_tbl1=np.zeros((len(tbl1),len(tbl2)),dtype=np.int8)\n",
    "pref_tbl=np.zeros((len(tbl1),len(tbl2)),dtype=np.int8)\n",
    "pref_tbl2=np.zeros((len(tbl2),len(tbl1)),dtype=np.int8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#assign the matching ratio between tbl1 and tbl2\n",
    "for i in range(len(tbl1)):\n",
    "    for j in range(len(tbl2)):\n",
    "        Pref[i,j] = np.int(100*SequenceMatcher(None,tbl1[i],tbl2[j]).ratio())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#assign the array indexs of Pref sorted by the actual values decending based on the lenght of tbl1 (13)\n",
    "for i in range(len(tbl1)):\n",
    "    #get indexs values of rows and store them in the rows as well\n",
    "    ipref_tbl1[i,:] = np.argsort(Pref[i,:])\n",
    "    ipref_tbl1[i,:] = ipref_tbl1[i,::-1]\n",
    "    pref_tbl[i,:] = np.sort(Pref[i,:])\n",
    "    pref_tbl[i,:] = pref_tbl[i,::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#loop through the pref_tbl and check if the value of the matching ratio greater than certain threshold \n",
    "#then get the index of these cells, otherwise set value to -1\n",
    "threshold = 50\n",
    "for i in range(len(tbl1)):\n",
    "    for j in range(len(tbl2)):\n",
    "        if pref_tbl[i,j] >= threshold:\n",
    "            pref_tbl1[i,j] = ipref_tbl1[i,j]\n",
    "        else: pref_tbl1[i,j] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "new_pref_tbl1=[]\n",
    "\n",
    "for i in range(len(tbl1)):\n",
    "    new_pref_tbl1.append(list(filter(lambda c: c != -1 ,pref_tbl1[i,:] )))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "content = {'name':'','index pref':0 , 'corespondance':[], 'preferences':[],'state':False,}\n",
    "Rotten_tomatoes=[]\n",
    "\n",
    "#assign the array indexs of Pref sorted by the actual values decending based on the lenght of tbl2 (15)\n",
    "for i in range(len(tbl2)):\n",
    "    #get indexs values of columns from Pref and store them in the rows\n",
    "    pref_tbl2[i,:]=np.argsort(Pref[:,i])\n",
    "    pref_tbl2[i,:]=pref_tbl2[i,::-1]\n",
    "    Rotten_tomatoes.append({'name':tbl2[i],'index pref':0 , 'corespondance':pref_tbl2[i,:], 'preferences':[],'state':False,})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Imdb = []\n",
    "\n",
    "for i in range(len(tbl1)):\n",
    "    Imdb.append({'name':tbl1[i],'index pref':0 , 'corespondance':[], 'preferences':new_pref_tbl1[i],'state':False,})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def marriage_algo():\n",
    "    imdb_no = 0\n",
    "    while imdb_no < len(tbl1):\n",
    "        if len(Imdb[imdb_no]['preferences']) > 0:\n",
    "            if Imdb[imdb_no]['state'] == False:\n",
    "                pref_index = Imdb[imdb_no]['index pref']\n",
    "                roto_no = Imdb[imdb_no]['preferences'][pref_index]\n",
    "                imdb_no = match_pref(imdb_no,roto_no)\n",
    "            else: imdb_no += 1\n",
    "        else: imdb_no += 1\n",
    "    return Imdb,Rotten_tomatoes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def match_pref(Ino,Rno):\n",
    "    if Rotten_tomatoes[Rno]['state'] == False :\n",
    "        Rotten_tomatoes[Rno]['state'] = True\n",
    "        Imdb[Ino]['state'] = True\n",
    "        #TODO: if\n",
    "        Rotten_tomatoes[Rno]['index pref'] = find_index(Rotten_tomatoes,Rno , Ino)\n",
    "        return Ino + 1\n",
    "    else:\n",
    "        sw = check_Rotten_pref(Ino,Rno)\n",
    "        if Ino == 11:\n",
    "            print(sw)\n",
    "        if sw == -1 :\n",
    "            if Imdb[Ino]['index pref'] < len(Imdb[Ino]['preferences']):#-----------------------------\n",
    "                Imdb[Ino]['index pref'] += 1\n",
    "                if Ino == 11:\n",
    "                    print(Ino , '---------', Imdb[Ino]['index pref'])\n",
    "                return Ino\n",
    "            else:\n",
    "                return Ino + 1\n",
    "        else:\n",
    "            Rotten_tomatoes[Rno]['state'] = True\n",
    "            Imdb[Ino]['state'] = True\n",
    "            Rotten_tomatoes[Rno]['index pref'] = find_index(Rotten_tomatoes,Rno , Ino)\n",
    "            Imdb[sw]['state'] = False\n",
    "            if Imdb[sw]['index pref'] < len(Imdb[Ino]['preferences']): #-------------------------\n",
    "                Imdb[sw]['index pref'] += 1\n",
    "                return sw\n",
    "            else:\n",
    "                return Ino+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def find_index(table , row , value):\n",
    "    for i in range(len(table[row]['preferences'])) :\n",
    "        if table[row]['preferences'][i] == value:\n",
    "            return i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def check_Rotten_pref(Ino,Rno):\n",
    "    sw = find_index(Rotten_tomatoes,Rno,Ino)\n",
    "    if Ino == 11:\n",
    "        print(sw,Rotten_tomatoes[Rno]['index pref'])\n",
    "    if sw < Rotten_tomatoes[Rno]['index pref']:\n",
    "        return Rotten_tomatoes[Rno]['preferences'][Rotten_tomatoes[Rno]['index pref']]\n",
    "    else:\n",
    "        return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Imdb,Rotten_tomatoes = marriage_algo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "corresponacy = []\n",
    "for i in range(len(Imdb)):\n",
    "    if Imdb[i]['state'] == True:\n",
    "        p = int(Imdb[i]['index pref'])\n",
    "        j = Imdb[i]['preferences'][p]\n",
    "        corresponacy.append(tuple([Imdb[i]['name'],Rotten_tomatoes[j]['name']]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "corresponacies that our algorithm has found are:\n",
      "0 . CORRECT \t ('Id', 'Id')\n",
      "1 . CORRECT \t ('Name', 'Name')\n",
      "2 . CORRECT \t ('YearRange', 'Year')\n",
      "3 . CORRECT \t ('ReleaseDate', 'Release Date')\n",
      "4 . CORRECT \t ('Director', 'Director')\n",
      "5 . CORRECT \t ('Creator', 'Creator')\n",
      "6 . CORRECT \t ('Cast', 'Cast')\n",
      "7 . CORRECT \t ('Duration', 'Duration')\n",
      "8 . CORRECT \t ('RatingValue', 'RatingValue')\n",
      "9 . WRONG \t ('ContentRating', 'RatingCount')\n",
      "10 . CORRECT \t ('Genre', 'Genre')\n",
      "11 . CORRECT \t ('Description', 'Description')\n",
      "\n",
      "number of corresponacies that it found:  11\n",
      "number of true corresponacies that it found: 10\n",
      "precision : 0.9090909090909091\n",
      "recall:\t 1.0\n"
     ]
    }
   ],
   "source": [
    "found = len(corresponacy)-1\n",
    "print('corresponacies that our algorithm has found are:')\n",
    "for i in range(len(corresponacy)):\n",
    "    if i == 9:\n",
    "        print(i,'. WRONG \\t',corresponacy[i])\n",
    "    else:\n",
    "        print(i,'. CORRECT \\t',corresponacy[i])\n",
    "        \n",
    "print('\\nnumber of corresponacies that it found: ' , found)\n",
    "print('number of true corresponacies that it found:' , found-1)\n",
    "print('precision :',(found-1.0)/found)\n",
    "print('recall:\\t' ,(found-1)/10.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ahmed\\Anaconda3\\lib\\site-packages\\fuzzywuzzy\\fuzz.py:35: UserWarning: Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning\n",
      "  warnings.warn('Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning')\n"
     ]
    }
   ],
   "source": [
    "import numpy,datetime,re\n",
    "from fuzzywuzzy import fuzz\n",
    "from fuzzywuzzy import process\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "groups=['Short string','Long string','URL']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Imdb = IMDB_DF\n",
    "Rotten_tomatoes = ROTTEN_TOMATOES_DF\n",
    "\n",
    "Imdb = Imdb.sample(50).astype(str)\n",
    "Rotten_tomatoes = Rotten_tomatoes.sample(50).astype(str)\n",
    "\n",
    "imdb = Imdb.columns.values\n",
    "rotten_tomatoes = Rotten_tomatoes.columns.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#check if this columns is string or not!\n",
    "def string_length(COL):\n",
    "    short_s = 60\n",
    "    summ = 0\n",
    "    for i in COL:\n",
    "        summ += len(str(i))\n",
    "    ret = summ / len(COL)  #average of charachters per cell\n",
    "    if ret < short_s:\n",
    "        return True\n",
    "    else :\n",
    "        return False\n",
    "\n",
    "#check if this column is URL or not!\n",
    "def is_url(COL):\n",
    "    no_url = 0.0\n",
    "    search = \"http://\"\n",
    "    match_rate = 0.0\n",
    "    for i in COL:\n",
    "        if re.search(search, str(i)):\n",
    "            no_url += 1  #URLs counter\n",
    "    match_rate = no_url / len(COL) * 100\n",
    "    if match_rate > 0.6:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def categorize_cols(cols_list,table):\n",
    "    tablegroups={'Short string':[],'Long string':[],'URL':[]}\n",
    "    for i in cols_list:\n",
    "        tablegroups[find_group(table[i])].append(i)\n",
    "    return tablegroups"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def find_group(COL):\n",
    "    if is_url(COL):\n",
    "        return 'URL'\n",
    "    elif string_length(COL):\n",
    "        return 'Short string'\n",
    "    else:\n",
    "        return 'Long string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Imdb_groups = categorize_cols(imdb,Imdb.dropna())\n",
    "Rotten_tomatoes_groups = categorize_cols(rotten_tomatoes,Rotten_tomatoes.dropna())\n",
    "IMgroup1 = Imdb[Imdb_groups['URL']].dropna()\n",
    "IMgroup2 = Imdb[Imdb_groups['Short string']].dropna()\n",
    "IMgroup3 = Imdb[Imdb_groups['Long string']].dropna()\n",
    "RTgroup1 = Rotten_tomatoes[Rotten_tomatoes_groups['URL']].dropna()\n",
    "RTgroup2 = Rotten_tomatoes[Rotten_tomatoes_groups['Short string']].dropna()\n",
    "RTgroup3 = Rotten_tomatoes[Rotten_tomatoes_groups['Long string']].dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def check_short_matching(COL1,COL2):\n",
    "    rate = 0.0\n",
    "    if str(COL1) == 'nan' or str(COL2) == 'nan' :\n",
    "        return 0\n",
    "    COL1 = str(COL1)\n",
    "    COL2 = str(COL2)\n",
    "    sw = (fuzz.SequenceMatcher(None,COL1, COL2).ratio())\n",
    "    return sw #/(max(len(COL1),len(COL2))*1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def check_match(st1,st2):\n",
    "    str1 = np.array((st1.values).astype(str))\n",
    "    str2 = np.array((st2.values).astype(str))\n",
    "    ret = np.zeros((len(str1),len(str2)))\n",
    "    for i in range(len(str1)):\n",
    "        for j in range(len(str2)):\n",
    "            ret[i,j] = check_short_matching(str1[i],str2[j])\n",
    "    return numpy.average(ret)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def group1_sim(IMgroup1,RTgroup1):\n",
    "    return []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def group2_sim(IMgroup2,RTgroup2):\n",
    "    count = []\n",
    "    dd = []\n",
    "    ret = []\n",
    "    v1 = []\n",
    "    v2 = []\n",
    "    for i in IMgroup2:\n",
    "        dd = []\n",
    "        for j in RTgroup2:\n",
    "            g1 = IMgroup2[i]\n",
    "            g2 = RTgroup2[j]\n",
    "            v1 = (g1.values).astype(str)\n",
    "            v2 = (g2.values).astype(str)\n",
    "            dd.append([ 10000* (check_match(g1, g2)),i,j])\n",
    "        ret += dd\n",
    "        #print(i,j)\n",
    "    #print('done')\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def group3_sim(IMgroup3,RTgroup3):\n",
    "    count = []\n",
    "    dd = []\n",
    "    ret = []\n",
    "    v1 = []\n",
    "    v2 = []\n",
    "    for i in IMgroup3:\n",
    "        dd = []\n",
    "        for j in RTgroup3:\n",
    "            g1 = IMgroup3[i]\n",
    "            g2 = RTgroup3[j]\n",
    "            v1 = (g1.values).astype(str)\n",
    "            v2 = (g2.values).astype(str)\n",
    "            dd.append([ (100* check_match(g1, g2)),i,j])\n",
    "        ret += dd\n",
    "        #print(i,j)\n",
    "    #rint('done')\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "group1_redic=group1_sim(IMgroup1,RTgroup1)\n",
    "group2_redic=group2_sim(IMgroup2,RTgroup2)\n",
    "group3_redic=group3_sim(IMgroup3,RTgroup3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group1_redic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1119.984250322047, 'Id', 'Id'],\n",
       " [1646.7919975936484, 'Id', 'Name'],\n",
       " [620.53373664366893, 'Id', 'Year'],\n",
       " [1268.672408781453, 'Id', 'Release Date'],\n",
       " [1748.0297163176733, 'Id', 'Director'],\n",
       " [1554.434838410157, 'Id', 'Creator'],\n",
       " [1604.9433922638316, 'Id', 'Actors'],\n",
       " [1445.6801237595305, 'Id', 'Language'],\n",
       " [172.55101966162059, 'Id', 'Country'],\n",
       " [1428.1626724128157, 'Id', 'Duration'],\n",
       " [203.69605416862956, 'Id', 'RatingValue'],\n",
       " [468.60587124571254, 'Id', 'RatingCount'],\n",
       " [1674.3849121704768, 'Id', 'ReviewCount'],\n",
       " [1854.5014754771175, 'Id', 'Genre'],\n",
       " [1289.8463177126782, 'Id', 'Filming Locations'],\n",
       " [539.26154941905895, 'Name', 'Id'],\n",
       " [2128.8167745086866, 'Name', 'Name'],\n",
       " [61.295238095238105, 'Name', 'Year'],\n",
       " [1495.2994816197047, 'Name', 'Release Date'],\n",
       " [2101.1648973789952, 'Name', 'Director'],\n",
       " [1861.6702281401599, 'Name', 'Creator'],\n",
       " [1887.1002620792983, 'Name', 'Actors'],\n",
       " [1468.2520278207971, 'Name', 'Language'],\n",
       " [500.99191467098336, 'Name', 'Country'],\n",
       " [1629.387958872747, 'Name', 'Duration'],\n",
       " [15.634224598930482, 'Name', 'RatingValue'],\n",
       " [62.601230231654057, 'Name', 'RatingCount'],\n",
       " [1864.5916014315821, 'Name', 'ReviewCount'],\n",
       " [1904.29478913456, 'Name', 'Genre'],\n",
       " [1527.5606924426447, 'Name', 'Filming Locations'],\n",
       " [2213.9130434782605, 'YearRange', 'Id'],\n",
       " [890.54547748725133, 'YearRange', 'Name'],\n",
       " [2516.0, 'YearRange', 'Year'],\n",
       " [2483.8206249475179, 'YearRange', 'Release Date'],\n",
       " [813.09160318857812, 'YearRange', 'Director'],\n",
       " [846.55294626648231, 'YearRange', 'Creator'],\n",
       " [729.67639251802666, 'YearRange', 'Actors'],\n",
       " [0.0, 'YearRange', 'Language'],\n",
       " [10.000000000000002, 'YearRange', 'Country'],\n",
       " [1944.0, 'YearRange', 'Duration'],\n",
       " [833.41176470588243, 'YearRange', 'RatingValue'],\n",
       " [1724.1055580126788, 'YearRange', 'RatingCount'],\n",
       " [1943.2599133717599, 'YearRange', 'ReviewCount'],\n",
       " [0.0, 'YearRange', 'Genre'],\n",
       " [719.18356148060025, 'YearRange', 'Filming Locations'],\n",
       " [1518.5141341417204, 'ReleaseDate', 'Id'],\n",
       " [1716.0156414829266, 'ReleaseDate', 'Name'],\n",
       " [1817.6985507246377, 'ReleaseDate', 'Year'],\n",
       " [2576.6458669231406, 'ReleaseDate', 'Release Date'],\n",
       " [1579.8838576478634, 'ReleaseDate', 'Director'],\n",
       " [1616.8229213096456, 'ReleaseDate', 'Creator'],\n",
       " [1706.7804878954298, 'ReleaseDate', 'Actors'],\n",
       " [1297.4109310812255, 'ReleaseDate', 'Language'],\n",
       " [552.26373536032429, 'ReleaseDate', 'Country'],\n",
       " [1969.2199966217358, 'ReleaseDate', 'Duration'],\n",
       " [568.64672352818809, 'ReleaseDate', 'RatingValue'],\n",
       " [1661.7790808022385, 'ReleaseDate', 'RatingCount'],\n",
       " [2138.313562942747, 'ReleaseDate', 'ReviewCount'],\n",
       " [1475.3367375990056, 'ReleaseDate', 'Genre'],\n",
       " [1584.2812125113642, 'ReleaseDate', 'Filming Locations'],\n",
       " [466.18137045960441, 'Director', 'Id'],\n",
       " [2075.7188277775094, 'Director', 'Name'],\n",
       " [0.0, 'Director', 'Year'],\n",
       " [1508.3825212509596, 'Director', 'Release Date'],\n",
       " [2201.1681505567503, 'Director', 'Director'],\n",
       " [2011.0282331087997, 'Director', 'Creator'],\n",
       " [2051.5937677162547, 'Director', 'Actors'],\n",
       " [1658.1045140238687, 'Director', 'Language'],\n",
       " [521.22889859434554, 'Director', 'Country'],\n",
       " [1556.1646085728808, 'Director', 'Duration'],\n",
       " [66.350750826646447, 'Director', 'RatingValue'],\n",
       " [106.68322700647282, 'Director', 'RatingCount'],\n",
       " [1774.6863426351072, 'Director', 'ReviewCount'],\n",
       " [1905.0019630072818, 'Director', 'Genre'],\n",
       " [1619.6925377277389, 'Director', 'Filming Locations'],\n",
       " [374.17248233813586, 'Creator', 'Id'],\n",
       " [1648.4929847457754, 'Creator', 'Name'],\n",
       " [0.0, 'Creator', 'Year'],\n",
       " [1226.971728910888, 'Creator', 'Release Date'],\n",
       " [1768.0583800154286, 'Creator', 'Director'],\n",
       " [1708.5793757092686, 'Creator', 'Creator'],\n",
       " [1836.7082168237589, 'Creator', 'Actors'],\n",
       " [1410.8584699023845, 'Creator', 'Language'],\n",
       " [454.54535915100348, 'Creator', 'Country'],\n",
       " [1147.7732613485105, 'Creator', 'Duration'],\n",
       " [100.12023064654645, 'Creator', 'RatingValue'],\n",
       " [220.32072992927246, 'Creator', 'RatingCount'],\n",
       " [1532.6503357953356, 'Creator', 'ReviewCount'],\n",
       " [1562.3477053281911, 'Creator', 'Genre'],\n",
       " [1434.5773793584106, 'Creator', 'Filming Locations'],\n",
       " [520.76190476190482, 'Duration', 'Id'],\n",
       " [780.24045745113972, 'Duration', 'Name'],\n",
       " [622.17647058823525, 'Duration', 'Year'],\n",
       " [1038.4962607929453, 'Duration', 'Release Date'],\n",
       " [880.47243547308278, 'Duration', 'Director'],\n",
       " [841.18471649107278, 'Duration', 'Creator'],\n",
       " [738.1447891227449, 'Duration', 'Actors'],\n",
       " [579.87653606958395, 'Duration', 'Language'],\n",
       " [93.606769985835456, 'Duration', 'Country'],\n",
       " [2278.1169590643276, 'Duration', 'Duration'],\n",
       " [665.4000000000002, 'Duration', 'RatingValue'],\n",
       " [526.21664946680426, 'Duration', 'RatingCount'],\n",
       " [1298.9257163889824, 'Duration', 'ReviewCount'],\n",
       " [745.41862134872804, 'Duration', 'Genre'],\n",
       " [616.85256122401597, 'Duration', 'Filming Locations'],\n",
       " [1060.6601398601397, 'RatingValue', 'Id'],\n",
       " [12.821181496883128, 'RatingValue', 'Name'],\n",
       " [1170.1686274509805, 'RatingValue', 'Year'],\n",
       " [701.45036838158012, 'RatingValue', 'Release Date'],\n",
       " [29.475791048416038, 'RatingValue', 'Director'],\n",
       " [173.7099124435484, 'RatingValue', 'Creator'],\n",
       " [155.2006653621454, 'RatingValue', 'Actors'],\n",
       " [63.026219851060851, 'RatingValue', 'Language'],\n",
       " [71.119805348907306, 'RatingValue', 'Country'],\n",
       " [908.00700407263878, 'RatingValue', 'Duration'],\n",
       " [1516.5555555555557, 'RatingValue', 'RatingValue'],\n",
       " [1201.9634452922378, 'RatingValue', 'RatingCount'],\n",
       " [720.01101030224572, 'RatingValue', 'ReviewCount'],\n",
       " [197.95221527203307, 'RatingValue', 'Genre'],\n",
       " [193.0127806402146, 'RatingValue', 'Filming Locations'],\n",
       " [679.79083622429698, 'ContentRating', 'Id'],\n",
       " [1547.2705142056984, 'ContentRating', 'Name'],\n",
       " [59.658055100396069, 'ContentRating', 'Year'],\n",
       " [985.81443922316441, 'ContentRating', 'Release Date'],\n",
       " [1582.7073400328302, 'ContentRating', 'Director'],\n",
       " [1427.5484702418009, 'ContentRating', 'Creator'],\n",
       " [1604.1810326073683, 'ContentRating', 'Actors'],\n",
       " [1178.4929064442645, 'ContentRating', 'Language'],\n",
       " [774.80452700979754, 'ContentRating', 'Country'],\n",
       " [1142.545199972081, 'ContentRating', 'Duration'],\n",
       " [21.930538591080627, 'ContentRating', 'RatingValue'],\n",
       " [95.193400131926637, 'ContentRating', 'RatingCount'],\n",
       " [1581.3121226659071, 'ContentRating', 'ReviewCount'],\n",
       " [1686.6662425705383, 'ContentRating', 'Genre'],\n",
       " [1121.5219364854788, 'ContentRating', 'Filming Locations'],\n",
       " [468.18944144257603, 'Genre', 'Id'],\n",
       " [1792.6271727987651, 'Genre', 'Name'],\n",
       " [0.0, 'Genre', 'Year'],\n",
       " [1274.4106901719447, 'Genre', 'Release Date'],\n",
       " [1914.0091524624931, 'Genre', 'Director'],\n",
       " [1826.2003219876833, 'Genre', 'Creator'],\n",
       " [1952.3693400192676, 'Genre', 'Actors'],\n",
       " [1071.7974676963952, 'Genre', 'Language'],\n",
       " [533.94005770489889, 'Genre', 'Country'],\n",
       " [1375.0131661165083, 'Genre', 'Duration'],\n",
       " [0.0, 'Genre', 'RatingValue'],\n",
       " [431.65711775874377, 'Genre', 'RatingCount'],\n",
       " [1790.1906764863684, 'Genre', 'ReviewCount'],\n",
       " [2934.2429752277794, 'Genre', 'Genre'],\n",
       " [1512.2363312060882, 'Genre', 'Filming Locations']]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group2_redic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[4.6155144366453928, 'Cast', 'Cast'],\n",
       " [7.2943738838236403, 'Cast', 'Description'],\n",
       " [4.2150403020676785, 'Description', 'Cast'],\n",
       " [12.613124687896555, 'Description', 'Description']]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group3_redic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}