add MSC nbs and cli cmds

21 files changed, 2821 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e41e7c36..5c9865b1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,8 @@
 #site/public/*.html
 notebooks/_local_*
 site/datasets/final/*.csv
+site/datasets/verified/*.csv
+
 # Project specific
 
 webpack-stats.dev.json
diff --git a/megapixels/cli_msc.py b/megapixels/cli_msc.py
new file mode 100644
index 00000000..d690b292
--- /dev/null
+++ b/megapixels/cli_msc.py
@@ -0,0 +1,36 @@
+# --------------------------------------------------------
+# MSC Project
+# --------------------------------------------------------
+
+import click
+
+from app.settings import app_cfg as cfg
+from app.utils import logger_utils
+from app.models.click_factory import ClickSimple
+
+# click cli factory
+cc = ClickSimple.create(cfg.DIR_COMMANDS_MSC)
+
+# --------------------------------------------------------
+# CLI
+# --------------------------------------------------------
+@click.group(cls=cc, chain=False)
+@click.option('-v', '--verbose', 'verbosity', count=True, default=4, 
+  show_default=True,
+  help='Verbosity: -v DEBUG, -vv INFO, -vvv WARN, -vvvv ERROR, -vvvvv CRITICAL')
+@click.pass_context
+def cli(ctx, **kwargs):
+  """\033[1m\033[94mMegaPixels: FAISS Data Scripts\033[0m                                                
+  """
+  ctx.opts = {}
+  # init logger
+  logger_utils.Logger.create(verbosity=kwargs['verbosity'])
+
+
+
+# --------------------------------------------------------
+# Entrypoint
+# --------------------------------------------------------
+if __name__ == '__main__':
+    cli()
+
diff --git a/megapixels/commands/msc/append_embassies.py b/megapixels/commands/msc/append_embassies.py
new file mode 100644
index 00000000..2e659344
--- /dev/null
+++ b/megapixels/commands/msc/append_embassies.py
@@ -0,0 +1,126 @@
+from glob import glob
+import os
+from os.path import join
+from pathlib import Path
+
+import click
+
+from app.settings import types
+from app.utils import click_utils
+from app.settings import app_cfg as cfg
+from app.utils import logger_utils
+
+import pandas as pd
+from PIL import Image, ImageOps, ImageFilter
+from app.utils import file_utils, im_utils
+
+
+log = logger_utils.Logger.getLogger()
+
+@click.command()
+@click.option('-i', '--input', 'opt_fp_in', required=True,
+  help='Input directory')
+@click.option('-o', '--output', 'opt_fp_out', required=True,
+  help='Output file')
+@click.option('--slice', 'opt_slice', type=(int, int), default=(None, None),
+  help='Slice list of files')
+@click.option('--api_key', 'opt_api_key', envvar='FLICKR_API_KEY_1')
+@click.option('--api_secret', 'opt_api_secret', envvar='FLICKR_API_SECRET_1')
+@click.option('-d', '--delay', 'opt_delay', default=None, type=float,
+  help='Delay between API calls to prevent rate-limiting')
+@click.pass_context
+def cli(ctx, opt_fp_in, opt_fp_out, opt_slice, opt_api_key, opt_api_secret, 
+  opt_delay):
+  """Fetches Flickr API for embassy. Saves to JSON"""
+  
+  from tqdm import tqdm
+  from glob import glob
+  import time
+  import json
+  import os, sys
+  from random import randint
+  import urllib.request
+  import flickr_api  # pip install flickr_api
+  from flickr_api.flickrerrors import FlickrAPIError
+  from requests.compat import urljoin, quote_plus
+
+  
+  # -------------------------------------------------
+  # process  
+  
+  if not opt_api_key or not opt_api_secret:
+    log.error('source ../env/flickr.env vars for Flickr API and try again')
+    return
+
+  # check how many flickr keys
+  api_keys = []
+  api_secrets = []
+  for i in range(1,10):
+    try:
+      var_name_key = f'FLICKR_API_KEY_{i}'
+      var_name_secret = f'FLICKR_API_SECRET_{i}'
+      if os.environ[var_name_key] and os.environ[var_name_secret]:
+        api_keys.append(os.environ[var_name_key])
+        api_secrets.append(os.environ[var_name_secret])
+    except Exception as e:
+      pass
+
+  log.info(f'Shuffling between: {len(api_keys)} api keys')
+
+  # read in CSV
+  # | username, ... |
+  df_records = pd.read_csv(opt_fp_in)
+  log.info(f'Dedpuplicating {len(df_records)}')
+  df_records = df_records.drop_duplicates(subset='url', keep="last")
+  log.info(f'Dedpuplicated {len(df_records)}')
+  records = df_records.to_dict('records')
+  
+  if opt_slice:
+    records = records[opt_slice[0]:opt_slice[1]]
+  
+  log.info('Processing: {:,} items'.format(len(records)))
+
+  identities = []
+  
+  for record in tqdm(records):
+    if record.get('nsid', None):
+      continue
+    try:
+      # shuffle the api keys to avoid rate limiting
+      rand_int = randint(0,len(api_keys)-1)
+      api_key = api_keys[rand_int]
+      api_secret = api_secrets[rand_int]
+      """
+      { "user": { "id": "46768316@N07", 
+      "username": { "_content": "U.S. Embassy Tirana Art Contest" } }, "stat": "ok" }
+      """
+      
+      # https://www.flickr.com/services/rest/
+      # ?method=flickr.urls.lookupUser&api_key=xxx&url=[encoded url]&format=json&nojsoncallback=1
+      url = record['url']
+      url_encoded = quote_plus(url)
+      flickr_url = 'https://api.flickr.com/services/rest/?method=flickr.urls.lookupUser'
+      flickr_url += f'&api_key={api_key}'
+      flickr_url += f'&url={url_encoded}'
+      flickr_url += '&format=json'
+      flickr_url += '&nojsoncallback=1'
+      log.debug(f'{flickr_url}')
+      with urllib.request.urlopen(flickr_url) as url:
+        data = json.loads(url.read().decode())
+
+      if data['stat'] =='fail':
+        error_msg = data["message"]
+        log.error(f'Failed. Message: {error_msg}, url: {flickr_url}')
+        raise Exception(error_msg)
+      elif data['stat'] =='ok':
+        user_data = data.get('user')
+        record['nsid'] = user_data.get('id')
+        record['username'] = user_data.get('username').get('_content')
+      
+    except Exception as e:
+      log.error(f'Exception: {e}, url: {flickr_url}')
+    
+
+    # write data
+    df_records = pd.DataFrame.from_dict(records)
+    df_records.to_csv(opt_fp_out)
diff --git a/megapixels/commands/msc/append_embassy_profile.py b/megapixels/commands/msc/append_embassy_profile.py
new file mode 100644
index 00000000..7d301f06
--- /dev/null
+++ b/megapixels/commands/msc/append_embassy_profile.py
@@ -0,0 +1,150 @@
+from glob import glob
+import os
+from os.path import join
+from pathlib import Path
+
+import click
+
+from app.settings import types
+from app.utils import click_utils
+from app.settings import app_cfg as cfg
+from app.utils import logger_utils
+
+import pandas as pd
+from PIL import Image, ImageOps, ImageFilter
+from app.utils import file_utils, im_utils
+
+
+log = logger_utils.Logger.getLogger()
+
+@click.command()
+@click.option('-i', '--input', 'opt_fp_in', required=True,
+  help='Input directory')
+@click.option('-o', '--output', 'opt_fp_out', required=True,
+  help='Output file')
+@click.option('--slice', 'opt_slice', type=(int, int), default=(None, None),
+  help='Slice list of files')
+@click.option('--api_key', 'opt_api_key', envvar='FLICKR_API_KEY_1')
+@click.option('--api_secret', 'opt_api_secret', envvar='FLICKR_API_SECRET_1')
+@click.option('-d', '--delay', 'opt_delay', default=None, type=float,
+  help='Delay between API calls to prevent rate-limiting')
+@click.pass_context
+def cli(ctx, opt_fp_in, opt_fp_out, opt_slice, opt_api_key, opt_api_secret, 
+  opt_delay):
+  """Fetches Flickr API for embassy. Saves to JSON"""
+  
+  from tqdm import tqdm
+  from glob import glob
+  import time
+  import json
+  import os, sys
+  from random import randint
+  import urllib.request
+  import flickr_api  # pip install flickr_api
+  from flickr_api.flickrerrors import FlickrAPIError
+  from requests.compat import urljoin, quote_plus
+
+  
+  # -------------------------------------------------
+  # process  
+  
+  if not opt_api_key or not opt_api_secret:
+    log.error('source ../env/flickr.env vars for Flickr API and try again')
+    return
+
+  # check how many flickr keys
+  api_keys = []
+  api_secrets = []
+  for i in range(1,20):
+    try:
+      var_name_key = f'FLICKR_API_KEY_{i}'
+      var_name_secret = f'FLICKR_API_SECRET_{i}'
+      if os.environ[var_name_key] and os.environ[var_name_secret]:
+        api_keys.append(os.environ[var_name_key])
+        api_secrets.append(os.environ[var_name_secret])
+    except Exception as e:
+      pass
+
+  log.info(f'Shuffling between: {len(api_keys)} api keys')
+
+  # read in CSV
+  # | username, ... |
+  df_records = pd.read_csv(opt_fp_in)
+  log.info(f'Dedpuplicating {len(df_records)}')
+  df_records = df_records.drop_duplicates(subset='url', keep="last")
+  log.info(f'Dedpuplicated {len(df_records)}')
+  records = df_records.to_dict('records')
+  
+  if opt_slice:
+    records = records[opt_slice[0]:opt_slice[1]]
+  
+  log.info('Processing: {:,} items'.format(len(records)))
+
+  identities = []
+  
+  for record in tqdm(records):
+    if not record.get('nsid', None):
+      log.warn(f'No NSID for {record["url"]}')
+      continue
+    try:
+      # shuffle the api keys to avoid rate limiting
+      error_msg = ''
+      rand_int = randint(0,len(api_keys)-1)
+      api_key = api_keys[rand_int]
+      api_secret = api_secrets[rand_int]
+      
+      nsid = record['nsid']
+      nsid_encoded = urllib.parse.quote_plus(nsid)
+      flickr_url = 'https://flickr.com/services/rest/?method=flickr.profile.getProfile'
+      flickr_url += f'&api_key={api_key}'
+      flickr_url += f'&user_id={nsid_encoded}'
+      flickr_url += '&format=json'
+      flickr_url += '&nojsoncallback=1'
+
+      with urllib.request.urlopen(flickr_url) as url:
+        data = json.loads(url.read().decode())
+
+      if data['stat'] =='fail':
+        error_msg = data["message"]
+        raise Exception(error_msg)
+      elif data['stat'] =='ok':
+        profile = data.get('profile')
+        # append data
+        tags = ['join_date', 'occupation', 'hometown', 'first_name', 'last_name']
+        tags += ['profile_description', 'city', 'country', 'twitter', 'facebook', 'instagram']
+        for tag in tags:
+          record.setdefault(tag, profile.get(tag))
+      
+    except Exception as e:
+      log.error(f'Exception: {e}, message: {error_msg}, url: {flickr_url}')
+    
+
+  # write data
+  df_records = pd.DataFrame.from_dict(records)
+  df_records.to_csv(opt_fp_out, index=False)
+
+
+"""
+{
+  "profile": {
+    "id": "129819216@N03",
+    "nsid": "129819216@N03",
+    "join_date": "1417769829",
+    "occupation": "",
+    "hometown": "",
+    "showcase_set": "72157680742231281",
+    "showcase_set_title": "Profile Showcase",
+    "first_name": "Ambasciata",
+    "last_name": "d'Italia a Praga",
+    "profile_description": "",
+    "city": "",
+    "country": "",
+    "facebook": "",
+    "twitter": "",
+    "tumblr": "",
+    "instagram": "",
+    "pinterest": ""
+  },
+  "stat": "ok"
+}
+"""
\ No newline at end of file
diff --git a/megapixels/commands/msc/basic.py b/megapixels/commands/msc/basic.py
new file mode 100644
index 00000000..2e952896
--- /dev/null
+++ b/megapixels/commands/msc/basic.py
@@ -0,0 +1,30 @@
+import click
+
+from app.settings import types
+from app.models.dataset import Dataset
+from app.utils import click_utils
+from app.settings import app_cfg as cfg
+from app.utils.logger_utils import Logger
+
+log = Logger.getLogger()
+
+@click.command()
+@click.pass_context
+def cli(ctx, ):
+  """_template_"""
+  
+  import sys
+  from glob import glob
+  from os.path import join
+  from pathlib import Path
+  import time
+
+  import pandas as pd
+  import cv2 as cv
+  from tqdm import tqdm
+  
+  from app.utils import file_utils, im_utils
+  from app.models.data_store import DataStore
+
+  log = Logger.getLogger()
+  log.info('template works')
diff --git a/megapixels/commands/msc/cross_reference.py b/megapixels/commands/msc/cross_reference.py
new file mode 100644
index 00000000..d4457945
--- /dev/null
+++ b/megapixels/commands/msc/cross_reference.py
@@ -0,0 +1,78 @@
+from os.path import join
+
+import click
+
+from app.utils.logger_utils import Logger
+
+log = Logger.getLogger()
+
+# source file for Embassy NSIDs
+fp_in_embassies = '/data_store/datasets/msc/embassies/embassies_on_flickr_ext.csv'
+
+# list of datasets to cross reference
+dataset_keys = ['pipa', 'megaface', 'helen', 'ibm_dif', 'adience', 'who_goes_there']
+fp_dataset_base = '/data_store/datasets/people/'
+fp_datasets = {}
+for dk in dataset_keys:
+  fp_datasets[dk] = join(fp_dataset_base, dk, f'research/{dk}_flickr_meta.csv')
+
+
+# output file
+fp_out = '/data_store/datasets/msc/embassies/embassies_scores.csv'
+
+@click.command()
+@click.option('-i', '--input', 'opt_fp_in', required=True, default=fp_in_embassies,
+  help='Input file for embassies')
+@click.option('-o', '--output', 'opt_fp_out', required=True, default=fp_out,
+  help='Output file')
+@click.option('--slice', 'opt_slice', type=(int, int), default=(None, None),
+  help='Slice list of files')
+@click.option('-f', '--force', 'opt_force', is_flag=True,
+  help='Force overwrite')
+@click.pass_context
+def cli(ctx, opt_fp_in, opt_fp_out, opt_slice, opt_force):
+  """Cross reference"""
+  
+  import sys
+  from os.path import join
+  from glob import glob
+  from pathlib import Path
+  import time
+
+  import pandas as pd
+  from tqdm import tqdm
+
+  log = Logger.getLogger()
+  log.info('Cross reference embassy list')
+
+  df_embassies = pd.read_csv(opt_fp_in)
+  df_embassies.fillna('', inplace=True)
+  embassy_nsids = list(df_embassies['nsid'])
+
+  match_items = []
+  for dataset_key, fp_dataset in fp_datasets.items():
+    df_dataset = pd.read_csv(fp_dataset)
+    nsids = list(df_dataset['nsid'])
+    for nsid in nsids:
+      if nsid in embassy_nsids:
+        # add to matches, and count
+        count = df_dataset[df_dataset['nsid'] == nsid]['count'].values[0]
+        first_name = df_embassies[df_embassies['nsid'] == nsid]['first_name'].values[0]
+        last_name = df_embassies[df_embassies['nsid'] == nsid]['last_name'].values[0]
+        path_alias = df_embassies[df_embassies['nsid'] == nsid]['path_alias'].values[0]
+        log.debug(f'{first_name} {last_name}, {path_alias} count: {count}, in {dataset_key}')
+        match_obj = {
+          'count': count,
+          'path_alias': path_alias,
+          'name': f'{first_name} {last_name}',
+          'dataset_key': dataset_key,
+          'nsid': nsid
+        }
+        match_items.append(match_obj)
+
+  df = pd.DataFrame.from_dict(match_items)
+  df.to_csv(opt_fp_out, index=False)
+  
+  total = df['count'].sum()
+  
+  log.debug(f'Found {total} embassy photos')
\ No newline at end of file
diff --git a/megapixels/commands/msc/embassy_flickr_api_data_to_csv.py b/megapixels/commands/msc/embassy_flickr_api_data_to_csv.py
new file mode 100644
index 00000000..1a0b6a91
--- /dev/null
+++ b/megapixels/commands/msc/embassy_flickr_api_data_to_csv.py
@@ -0,0 +1,120 @@
+"""
+Converts directory of JSON API output files to CSV format
+"""
+
+from glob import glob
+import os
+from os.path import join
+from pathlib import Path
+
+import click
+
+from app.settings import types
+from app.utils import click_utils
+from app.settings import app_cfg as cfg
+from app.utils import logger_utils
+
+import pandas as pd
+from PIL import Image, ImageOps, ImageFilter
+from app.utils import file_utils, im_utils
+
+data_types = ['nsid_url', 'nsid_profile']
+
+log = logger_utils.Logger.getLogger()
+
+@click.command()
+@click.option('-i', '--input', 'opt_fp_in', required=True,
+  help='Input directory')
+@click.option('-o', '--output', 'opt_fp_out', required=True,
+  help='Output file')
+@click.option('--slice', 'opt_slice', type=(int, int), default=(None, None),
+  help='Slice list of files')
+@click.option('-q', '--query', 'opt_query', required=True, type=click.Choice(data_types),
+  help='Flickr API data type')
+@click.option('-f', '--force', 'opt_force', is_flag=True,
+  help='Force overwrite')
+@click.pass_context
+def cli(ctx, opt_fp_in, opt_fp_out, opt_slice, opt_force, opt_query):
+  """Fetches Flickr API for user info. Saves to JSON"""
+  
+  from tqdm import tqdm
+  from glob import glob
+  import json
+
+  
+  # -------------------------------------------------
+  # process  
+  if Path(opt_fp_out).is_file() and not opt_force:
+    log.error('File exists. Use "--force" to overwrite it')
+    return
+
+  fp_files = glob(join(opt_fp_in, '*.json'))
+  fp_files = [f for f in fp_files if 'error' not in f]
+  if opt_slice:
+    fp_files = fp_files[opt_slice[0]:opt_slice[1]]
+
+  log.debug(f'Found {len(fp_files)} files')
+  items = []
+  """
+  {
+    "stat": "ok",
+    "user": {
+      "id": "95216244@N04",
+      "username": {
+        "_content": "AfghanistanWien"
+      }
+    }
+  }
+  """
+  """
+    {
+    "profile": {
+      "city": "Oslo",
+      "country": "Norway",
+      "facebook": "",
+      "first_name": "US Embassy",
+      "hometown": "Oslo",
+      "id": "133886098@N05",
+      "instagram": "",
+      "join_date": "1436521589",
+      "last_name": "Oslo",
+      "nsid": "133886098@N05",
+      "occupation": "",
+      "pinterest": "",
+      "profile_description": "This is the official Flickr profile of the U.S. Embassy in Oslo, Norway. Contact us: osloirc@state.gov.",
+      "showcase_set": "72157677372281094",
+      "showcase_set_title": "Profile Showcase",
+      "tumblr": "",
+      "twitter": "",
+      "website": "http://norway.usembassy.gov/index.html"
+    },
+    "stat": "ok"
+  }
+  """
+  # Convert to |nsid|username|
+  for fp_file in tqdm(fp_files):
+    metadata = file_utils.load_json(fp_file)
+
+    if opt_query == 'nsid_url':
+      path_alias = Path(fp_file).stem
+      metadata = metadata.get('user')
+      nsid = metadata.get('id')
+      username = metadata.get('username').get('_content')
+      url = f'https://www.flickr.com/photos/{path_alias}'
+      obj = {
+        'nsid': nsid,
+        'username': username,
+        'url': url,
+        'path_alias': path_alias,
+        'filename': f'{path_alias}.json'
+        }
+    elif opt_query == 'nsid_profile':
+      obj = metadata.get('profile')
+
+    items.append(obj)
+
+
+  # conver to DataFrame
+  df = pd.DataFrame.from_dict(items)
+  df.to_csv(opt_fp_out, index=False)
+  log.info(f'Wrote {len(df)} to {opt_fp_out}')
\ No newline at end of file
diff --git a/megapixels/commands/msc/flickr_list_to_csv.py b/megapixels/commands/msc/flickr_list_to_csv.py
new file mode 100644
index 00000000..f107db60
--- /dev/null
+++ b/megapixels/commands/msc/flickr_list_to_csv.py
@@ -0,0 +1,48 @@
+import click
+
+from app.utils.logger_utils import Logger
+
+log = Logger.getLogger()
+
+fp_in = '/data_store/datasets/msc/embassies/embassy-list.txt'
+fp_out = '/data_store/datasets/msc/embassies/embassies_on_flickr.csv'
+
+@click.command()
+@click.option('-i', '--input', 'opt_fp_in', required=True, default=fp_in,
+  help='Input directory')
+@click.option('-o', '--output', 'opt_fp_out', required=True, default=fp_out,
+  help='Output file')
+@click.pass_context
+def cli(ctx, opt_fp_in, opt_fp_out):
+  """Convert embassy list to CSV"""
+  
+  import sys
+  from glob import glob
+  from os.path import join
+  from pathlib import Path
+  import time
+
+  import pandas as pd
+  from tqdm import tqdm
+
+  from app.utils import file_utils
+
+  log = Logger.getLogger()
+  log.info('converting flickr list to CSV')
+  
+  items = []
+
+  embassies = file_utils.load_text(opt_fp_in)
+
+  for embassy in tqdm(embassies):
+    splits = embassy.split(' ')
+    url = splits[0].strip()
+    title = ' '.join(splits[1:]).strip()
+    username = Path(url).stem
+    items.append({'title': title, 'url': url, 'username': username})
+
+  df = pd.DataFrame.from_dict(items)
+  df.to_csv(opt_fp_out, index=False)
+  log.debug(f'Wrote {len(df)} lines')
+
+
diff --git a/megapixels/commands/msc/plot_countries.py b/megapixels/commands/msc/plot_countries.py
new file mode 100644
index 00000000..9df7dcd5
--- /dev/null
+++ b/megapixels/commands/msc/plot_countries.py
@@ -0,0 +1,31 @@
+import click
+
+from app.settings import types
+from app.models.dataset import Dataset
+from app.utils import click_utils
+from app.settings import app_cfg as cfg
+from app.utils.logger_utils import Logger
+
+log = Logger.getLogger()
+
+@click.command()
+@click.pass_context
+def cli(ctx, ):
+  """Plot countries"""
+  
+  import sys
+  from glob import glob
+  from os.path import join
+  from pathlib import Path
+  import time
+
+  import pandas as pd
+  import cv2 as cv
+  from tqdm import tqdm
+  import matplotlib.pyplot as plt
+  
+  from app.utils import file_utils, im_utils
+  from app.models.data_store import DataStore
+
+  log = Logger.getLogger()
+  log.info('Plot country data')
diff --git a/megapixels/commands/msc/summarize.py b/megapixels/commands/msc/summarize.py
new file mode 100644
index 00000000..d5d251db
--- /dev/null
+++ b/megapixels/commands/msc/summarize.py
@@ -0,0 +1,67 @@
+import click
+
+from app.settings import types
+from app.models.dataset import Dataset
+from app.utils import click_utils
+from app.settings import app_cfg as cfg
+from app.utils.logger_utils import Logger
+
+log = Logger.getLogger()
+
+@click.command()
+@click.option('-i', '--input', 'opt_fp_in', required=True)
+@click.option('-o', '--output', 'opt_fp_out', required=True)
+@click.pass_context
+def cli(ctx, opt_fp_in, opt_fp_out):
+  """_template_"""
+  
+  import sys
+  from glob import glob
+  from os.path import join
+  from pathlib import Path
+  import time
+  from pprint import pprint
+
+  import pandas as pd
+  from tqdm import tqdm
+  
+  from app.utils import file_utils
+
+  log = Logger.getLogger()
+
+  dataset_names = ['helen', 'megaface', 'adience', 'pipa', 'lfpw', 'duke_mtmc', 'brainwash', 'msceleb', 'uccs']
+  
+  df = pd.DataFrame()
+  fp_out = opt_fp_out.replace('.csv', '_citations.csv')
+  for dataset_name in dataset_names:
+    fp_csv = join(opt_fp_in, f'{dataset_name}.csv')
+    _df = pd.read_csv(fp_csv)
+    _df = _df[_df.lat != 0]
+    print(dataset_name, len(_df))
+    df = df.append(_df, ignore_index=True)
+
+  df.to_csv(opt_fp_out, index=False)
+
+  # create country summary
+  fp_out = opt_fp_out.replace('.csv', '_countries.csv')
+  country_groups = df.groupby('country')
+  summary = []
+  for group_name, group in country_groups:
+    summary.append({'country': group_name, 'citations': len(group)})
+  df_summary = pd.DataFrame.from_dict(summary)
+  df_summary.sort_values(by='citations', ascending=False, inplace=True)
+  df_summary.to_csv(fp_out, index=False)
+  pprint(df_summary)
+
+  # summary sector
+  summary = []
+  fp_out = opt_fp_out.replace('.csv', '_sector.csv')
+  groups = df.groupby('loc_type')
+  for group_name, group in groups:
+    summary.append({'type': group_name, 'citations': len(group)})
+  df_types = pd.DataFrame.from_dict(summary)
+  df_types.sort_values(by='citations', ascending=False, inplace=True)
+  df_types.to_csv(fp_out, index=False)
+  pprint(df_types)
+
+
diff --git a/megapixels/notebooks/datasets/adience/flickr_metadata_cleanup.ipynb b/megapixels/notebooks/datasets/adience/flickr_metadata_cleanup.ipynb
new file mode 100644
index 00000000..69aaced4
--- /dev/null
+++ b/megapixels/notebooks/datasets/adience/flickr_metadata_cleanup.ipynb
@@ -0,0 +1,169 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Adience Flickr Metadata Cleanup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "import pandas as pd\n",
+    "\n",
+    "import sys\n",
+    "sys.path.append('/work/megapixels_dev/megapixels')\n",
+    "from app.utils import file_utils"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in_files = '/data_store_hdd/datasets/people/adience/research/adience_flickr_api_queries.csv'\n",
+    "fp_in_nsid_urls = '/data_store_hdd/datasets/people/adience/research/adience_flickr_nsid_url.csv'\n",
+    "fp_in_nsid_profiles = '/data_store_hdd/datasets/people/adience/research/adience_flickr_nsid_profile.csv'\n",
+    "fp_out = '/data_store_hdd/datasets/people/adience/research/adience_flickr_meta.csv'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create metadata csv output\n",
+    "\n",
+    "|nsid|path_alias|count|"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# files\n",
+    "df_files = pd.read_csv(fp_in_files)\n",
+    "df_files.fillna('', inplace=True)\n",
+    "files = df_files.to_dict('records')\n",
+    "\n",
+    "# nsid urls\n",
+    "df_urls = pd.read_csv(fp_in_nsid_urls)\n",
+    "df_urls.fillna('', inplace=True)\n",
+    "urls = df_urls.to_dict('records')\n",
+    "\n",
+    "# nsid profiles\n",
+    "df_profiles = pd.read_csv(fp_in_nsid_profiles)\n",
+    "df_profiles.fillna('', inplace=True)\n",
+    "profiles = df_profiles.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create nsid lookup table\n",
+    "alias_lookup = {}\n",
+    "for url_meta in urls:\n",
+    "  alias_lookup[url_meta['nsid']] = str(Path(url_meta['url']).stem)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nsid_groups = df_files.groupby('nsid')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Skipping: 10693681@N00\n",
+      "Skipping: 10743505@N04\n",
+      "Skipping: 113728563@N05\n",
+      "Skipping: 7648211@N03\n"
+     ]
+    }
+   ],
+   "source": [
+    "items = []\n",
+    "for nsid, nsid_group in nsid_groups:\n",
+    "  if nsid not in alias_lookup.keys():\n",
+    "    print(f'Skipping: {nsid}')\n",
+    "    continue\n",
+    "  path_alias = alias_lookup[nsid]\n",
+    "  obj = {'nsid': nsid, 'path_alias': path_alias, 'count': len(nsid_group)}\n",
+    "  items.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_out = pd.DataFrame.from_dict(items)\n",
+    "df_out.to_csv(fp_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/adience/prepare_flickr_api.ipynb b/megapixels/notebooks/datasets/adience/prepare_flickr_api.ipynb
new file mode 100644
index 00000000..a35c3b24
--- /dev/null
+++ b/megapixels/notebooks/datasets/adience/prepare_flickr_api.ipynb
@@ -0,0 +1,188 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Prepare Flickr API Batch CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob, iglob\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create CSV for API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "| filepath | query | count |\n",
+    "|:---|:---|:---|\n",
+    "| 12234 | 12234@123| 10 |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in_dir = '/data_store/datasets/people/adience/dataset/'\n",
+    "fp_out_queries = '/data_store/datasets/people/adience/research/adience_flickr_api_queries.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9\n"
+     ]
+    }
+   ],
+   "source": [
+    "fp_files = glob(join(fp_in_dir, '*.txt'))\n",
+    "print(len(fp_files))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_images = pd.DataFrame()\n",
+    "for fp_file in fp_files:\n",
+    "  df = pd.read_csv(fp_file, delimiter='\\t')\n",
+    "  if 'user_id' in df.keys():\n",
+    "    df = df[['user_id', 'original_image']]\n",
+    "    df_images = dfs.append(df, ignore_index=True)  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_images.drop_duplicates(inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = df_images.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for image in images:\n",
+    "  image['photo_id'] = image['original_image'].split('_')[0]\n",
+    "  image['filename'] = f'{image[\"photo_id\"]}.json'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_images = pd.DataFrame.from_dict(images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_images.drop(columns=['original_image'], inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "10804\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(df_images))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_images.to_csv(fp_out_queries, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/cofw/prepare_flickr_api.ipynb b/megapixels/notebooks/datasets/cofw/prepare_flickr_api.ipynb
new file mode 100644
index 00000000..1d5f2e3b
--- /dev/null
+++ b/megapixels/notebooks/datasets/cofw/prepare_flickr_api.ipynb
@@ -0,0 +1,208 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# COFW Prepare Flickr API"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob, iglob\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "\n",
+    "from PIL import Image, ImageDraw\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.io as sio\n",
+    "import h5py\n",
+    "import numpy as np\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create CSV for API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "| photo_id |\n",
+    "|:---|\n",
+    "| 12234 |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in_test = '/data_store/datasets/people/cofw/downloads/COFW_test_color.mat'\n",
+    "fp_in_train = '/data_store/datasets/people/cofw/downloads/COFW_train_color.mat'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# mat_train = sio.loadmat(fp_in_train)\n",
+    "# mat_test = sio.loadmat(fp_in_test)\n",
+    "\n",
+    "# with h5py.File(fp_in_test, 'r') as f:\n",
+    "#   mat_test = f.read()\n",
+    "  \n",
+    "arrays = {}\n",
+    "fp_h5 = h5py.File(fp_in_test)\n",
+    "for k, v in fp_h5.items():\n",
+    "  arrays[k] = np.array(v)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import hdf5storage\n",
+    "mat = hdf5storage.loadmat(fp_in_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['IsT', 'bboxesT', 'phisT'])"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mat.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(87,)\n",
+      "[ 65.09143518 157.72547642  93.2417092  126.6292435   77.20259958\n",
+      "  77.20259958 142.66835311 142.66835311  73.92931191 149.54225723\n",
+      "  95.86033934 126.95657227  86.04047631  86.69513385 141.03170928\n",
+      " 141.03170928  86.69513385 141.68636681  98.15164071 123.68328459\n",
+      " 106.98951744 107.64417498  96.84232564 133.50314762 110.91746265\n",
+      " 111.57212019 113.20876403 113.86342156 117.79136677  13.45532209\n",
+      "  11.16402071  18.69258237  15.41929469  12.47333578  16.401281\n",
+      "   8.54539057  11.49134948  27.53045909  26.87580156  30.80374677\n",
+      "  30.80374677  23.60251388  32.11306184  22.62052758  31.13107554\n",
+      "  27.85778786  26.87580156  64.19128107  66.80991121  63.8639523\n",
+      "  67.46456875  84.1583359   84.81299343  80.88504822  84.81299343\n",
+      "  86.77696604  92.34155509 113.94525375   0.           1.\n",
+      "   0.           0.           0.           0.           0.\n",
+      "   0.           0.           0.           0.           0.\n",
+      "   0.           0.           0.           0.           0.\n",
+      "   0.           0.           0.           0.           0.\n",
+      "   1.           0.           0.           0.           0.\n",
+      "   0.           1.        ]\n",
+      "[ 55.  -1. 113. 125.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(mat['phisT'][0].shape)\n",
+    "print(mat['phisT'][0])\n",
+    "print(mat['bboxesT'][0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f38151979b0>"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "im = mat['IsT'][0][0]\n",
+    "plt.imshow(im)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/helen/prepare_flickr_api.ipynb b/megapixels/notebooks/datasets/helen/prepare_flickr_api.ipynb
new file mode 100644
index 00000000..311d3462
--- /dev/null
+++ b/megapixels/notebooks/datasets/helen/prepare_flickr_api.ipynb
@@ -0,0 +1,162 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# HELEN Prepare Flickr API"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob, iglob\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "\n",
+    "import h5py\n",
+    "from scipy import misc\n",
+    "from io import BytesIO\n",
+    "from base64 import b64decode\n",
+    "\n",
+    "from PIL import Image, ImageDraw\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.io as sio\n",
+    "import h5py\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import sys\n",
+    "sys.path.append('/work/megapixels_dev/megapixels/')\n",
+    "from app.utils import file_utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in = '/data_store/datasets/people/helen/research/flickr_photo_ids.txt'\n",
+    "fp_out = '/data_store/datasets/people/helen/research/helen_flickr_meta.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "photo_id_list = file_utils.load_text(fp_in)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "items = [{'photo_id': x.split('_')[0]} for x in photo_id_list]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame.from_dict(items)\n",
+    "df.to_csv(fp_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load Flickr API Dump\n",
+    "\n",
+    "- and create Flickr meta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_api_dump = '/data_store/datasets/people/helen/research/helen_flickr_api_dump.csv'\n",
+    "df = pd.read_csv(fp_api_dump)\n",
+    "#records = df.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "groups = df.groupby('nsid')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = []\n",
+    "for nsid, group in groups:\n",
+    "  obj = {\n",
+    "    'nsid': nsid,\n",
+    "    'count': len(group)\n",
+    "  }\n",
+    "  results.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.DataFrame.from_dict(results).to_csv(fp_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/ibm_dif/prepare_flickr_api.ipynb b/megapixels/notebooks/datasets/ibm_dif/prepare_flickr_api.ipynb
new file mode 100644
index 00000000..ff41e799
--- /dev/null
+++ b/megapixels/notebooks/datasets/ibm_dif/prepare_flickr_api.ipynb
@@ -0,0 +1,243 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Prepare Flickr API Batch CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob, iglob\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create CSV for API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "| photo_id |\n",
+    "|:---|\n",
+    "| 12234 |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# flickr api data\n",
+    "fp_in_flickr_meta = '/data_store_hdd/datasets/people/ibm_dif/research/flickr_api_query_dump.csv'\n",
+    "# ibm count data\n",
+    "fp_in_ibm_meta = '/data_store_hdd/datasets/people/ibm_dif/research/ibm_dif_metadata.csv'\n",
+    "# output\n",
+    "fp_out = '/data_store_hdd/datasets/people/ibm_dif/research/ibm_dif_metadata.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load ibm data and create count lookup with photoid\n",
+    "df_ibm_meta = pd.read_csv(fp_in_ibm_meta)\n",
+    "ibm_meta_records = df_ibm_meta.to_dict('records')\n",
+    "count_lookup = {}\n",
+    "for ibm_meta_record in ibm_meta_records:\n",
+    "  photo_id = int(Path(ibm_meta_record['url']).stem.split('_')[0])\n",
+    "  count_lookup[photo_id] = ibm_meta_record['count']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "100438"
+      ]
+     },
+     "execution_count": 69,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(count_lookup)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_flickr_meta = pd.read_csv(fp_in_flickr_meta, dtype={'count': int, 'username': str, 'sha256': str}).fillna('')\n",
+    "flickr_meta_records = df_flickr_meta.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error: invalid literal for int() with base 10: '', {'country': '', 'description': 'Haircut Next...', 'lat': '', 'lon': '', 'nsid': '', 'owner_location': '', 'path_alias': '', 'photo_id': '', 'place': '', 'place_id': '', 'posted': '', 'realname': '', 'taken': '', 'username': '', 'woeid': ''}\n",
+      "Error: invalid literal for int() with base 10: '', {'country': '', 'description': '', 'lat': '86085317@N00', 'lon': 'New York', 'nsid': 'anonymousthomas', 'owner_location': '4975598', 'path_alias': '', 'photo_id': '', 'place': '1108685469', 'place_id': 'Thomas', 'posted': '2005-02-18 00:11:09', 'realname': 'anonymousthomas', 'taken': '', 'username': '', 'woeid': ''}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load flickr data\n",
+    "for flickr_meta_record in flickr_meta_records:\n",
+    "  try:\n",
+    "    nsid = flickr_meta_record['nsid']\n",
+    "    photo_id = int(flickr_meta_record['photo_id'])\n",
+    "    count = count_lookup[photo_id]\n",
+    "  except Exception as e:\n",
+    "    print(f'Error: {e}, {flickr_meta_record}')\n",
+    "    continue\n",
+    "  obj = {\n",
+    "    'photo_id': photo_id,\n",
+    "    'nsid': nsid,\n",
+    "    'count': count \n",
+    "  }\n",
+    "  results.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_out = pd.DataFrame.from_dict(results)\n",
+    "df_out.to_csv(fp_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create meta count file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_flickr_api_dump = '/data_store_hdd/datasets/people/ibm_dif/research/flickr_api_query_dump.csv'\n",
+    "fp_out_meta = '/data_store_hdd/datasets/people/ibm_dif/research/ibm_dif_flickr_meta.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/adam/anaconda3/envs/megapixels/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3020: DtypeWarning: Columns (2,3,10) have mixed types. Specify dtype option on import or set low_memory=False.\n",
+      "  interactivity=interactivity, compiler=compiler, result=result)\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(fp_flickr_api_dump)\n",
+    "groups = df.groupby('nsid')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = []\n",
+    "for nsid, group in groups:\n",
+    "  obj = {\n",
+    "    'nsid': nsid,\n",
+    "    'count': len(group)\n",
+    "  }\n",
+    "  results.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.DataFrame.from_dict(results).to_csv(fp_out_meta, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/megaface/megaface_prepare_flickr_api.ipynb b/megapixels/notebooks/datasets/megaface/megaface_prepare_flickr_api.ipynb
new file mode 100644
index 00000000..48133228
--- /dev/null
+++ b/megapixels/notebooks/datasets/megaface/megaface_prepare_flickr_api.ipynb
@@ -0,0 +1,315 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Prepare Flickr API Batch CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob, iglob\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create CSV for API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "| filepath | query |\n",
+    "|:---|:---|\n",
+    "| 12234 | 12234@123|"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in_dir_ids = '/data_store_ssd_perrier/datasets/people/megaface/downloads/MegafaceIdentities_VGG_META/'\n",
+    "fp_out_queries = '/data_store_hdd/datasets/people/megaface/research/megaface_flickr_api_queries.csv'\n",
+    "fp_out_queries_full = '/data_store_hdd/datasets/people/megaface/research/megaface_flickr_api_queries_full.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nsid_paths = glob(join(fp_in_dir_ids, '*'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1ab58c3dd0934591b0ea3f2da77003f5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(IntProgress(value=0, max=672057), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "items = []\n",
+    "for nsid_path in tqdm(nsid_paths):\n",
+    "  nsid_full = Path(nsid_path).name\n",
+    "  nsid = nsid_full.split('_')[0]\n",
+    "  json_files = glob(join(fp_in_dir_ids, nsid_path, '*.json'))\n",
+    "  for json_file in json_files:\n",
+    "    nsid_id_json = file_utils.load_json(json_file)\n",
+    "    full_image_url = nsid_id_json.get('full_img_url')\n",
+    "    obj = {'nsid': nsid, 'nsid_full': nsid_full, 'full_image_url': full_image_url}\n",
+    "    items.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame.from_dict(items)\n",
+    "df.to_csv(fp_out_queries_full, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "count_lookup = {}\n",
+    "for item in items:\n",
+    "  nsid = item['nsid']\n",
+    "  if not nsid in count_lookup.keys():\n",
+    "    count_lookup[nsid] = 0\n",
+    "  count_lookup[nsid] += 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Combine MegaFace Flickr API Meta for User/NSID"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in_dir = '/media/adam/ah8tb/data_store/datasets/people/megaface/research/flickr_api_dump'\n",
+    "fp_files = glob(join(fp_in_dir, '*.json'))\n",
+    "fp_files_err = [f for f in fp_files if '.txt' in f]\n",
+    "fp_files = [f for f in fp_files if '.txt' not in f]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "46906\n",
+      "0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(fp_files))\n",
+    "print(len(fp_files_err))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# combine files into single CSV"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```\n",
+    "{\n",
+    "  \"stat\": \"ok\",\n",
+    "  \"user\": {\n",
+    "    \"nsid\": \"7122726@N03\",\n",
+    "    \"url\": \"https://www.flickr.com/people/tdbsca/\"\n",
+    "  }\n",
+    "}\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c304096902584115be0c1a86accf2f69",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(IntProgress(value=0, max=46906), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "meta_records = []\n",
+    "for fp_file in tqdm(fp_files):\n",
+    "  data = file_utils.load_json(fp_file)\n",
+    "  user = data.get('user')\n",
+    "  nsid = user.get('nsid')\n",
+    "  path_alias = Path(user.get('url')).stem\n",
+    "  count = count_lookup.get(nsid)\n",
+    "  obj = {'path_alias': path_alias, 'nsid': nsid, 'count': count}\n",
+    "  meta_records.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "46906\n"
+     ]
+    }
+   ],
+   "source": [
+    "df_meta_records = pd.DataFrame.from_dict(meta_records)\n",
+    "print(len(df_meta_records))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_meta_records.drop_duplicates(subset='nsid', keep='last', inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "46906\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(df_meta_records))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_out_combined = '/data_store_hdd/datasets/people/megaface/research/megaface_flickr_meta_count.csv'\n",
+    "df_meta_records.to_csv(fp_out_combined, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4627187\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(df_meta_records['count'].sum())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/msc/fix_embassies.ipynb b/megapixels/notebooks/datasets/msc/fix_embassies.ipynb
new file mode 100644
index 00000000..a48bbc48
--- /dev/null
+++ b/megapixels/notebooks/datasets/msc/fix_embassies.ipynb
@@ -0,0 +1,215 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fix MSC Embassy CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The dotenv extension is already loaded. To reload it, use:\n",
+      "  %reload_ext dotenv\n"
+     ]
+    }
+   ],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "%load_ext dotenv\n",
+    "#%dotenv /work/megapixels_dev/env/flickr.env\n",
+    "\n",
+    "import sys, os\n",
+    "from os.path import join\n",
+    "from glob import glob, iglob\n",
+    "from pathlib import Path\n",
+    "from random import randint\n",
+    "import urllib\n",
+    "\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in = '/data_store/datasets/msc/embassies/embassies_on_flickr.csv'\n",
+    "fp_in_metadata = '/data_store/datasets/msc/embassies/embassy_meta_nsid.csv'\n",
+    "fp_out = '/data_store/datasets/msc/embassies/embassies_on_flickr_ext.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_embassies = pd.read_csv(fp_in)\n",
+    "df_embassies.fillna('', inplace=True)\n",
+    "embassy_records = df_embassies.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_meta = pd.read_csv(fp_in_metadata)\n",
+    "df_meta.fillna('', inplace=True)\n",
+    "meta_records = df_meta.to_dict('records')\n",
+    "meta_records_nsid = {}\n",
+    "for meta_record in meta_records:\n",
+    "  meta_records_nsid[meta_record['nsid']] = meta_record"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for embassy_record in embassy_records:\n",
+    "  nsid = embassy_record.get('nsid')\n",
+    "  if nsid:\n",
+    "    meta = meta_records_nsid.get(nsid)\n",
+    "    if meta:\n",
+    "      embassy_record['first_name'] = meta['first_name']\n",
+    "      embassy_record['last_name'] = meta['last_name']\n",
+    "      embassy_record['occupation'] = meta['occupation']\n",
+    "      embassy_record['city'] = meta['city']\n",
+    "      embassy_record['country'] = meta['country']\n",
+    "      embassy_record['email'] = meta['email']\n",
+    "      embassy_record['facebook'] = meta['facebook']\n",
+    "      embassy_record['instagram'] = meta['instagram']\n",
+    "      embassy_record['join_date'] = meta['join_date']\n",
+    "      embassy_record['twitter'] = meta['twitter']\n",
+    "      embassy_record['profile_description'] = meta['profile_description']\n",
+    "      embassy_record['website'] = meta['website']\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_embassies_ext = pd.DataFrame.from_dict(embassy_records)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_embassies_ext.to_csv(fp_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fix country"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in = '/data_store/datasets/msc/embassies/embassies_on_flickr.csv'\n",
+    "fp_in_ext = '/data_store/datasets/msc/embassies/embassies_on_flickr_ext.csv'\n",
+    "fp_out = '/data_store/datasets/msc/embassies/embassies_on_flickr_ext_02.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_embassies = pd.read_csv(fp_in)\n",
+    "df_embassies.fillna('', inplace=True)\n",
+    "embassy_records = df_embassies.to_dict('records')\n",
+    "\n",
+    "df_embassies_ext = pd.read_csv(fp_in_ext)\n",
+    "df_embassies_ext.fillna('', inplace=True)\n",
+    "embassy_records_ext = df_embassies_ext.to_dict('records')\n",
+    "\n",
+    "embassy_records_nsid = {}\n",
+    "for embassy_record in embassy_records:\n",
+    "  embassy_records_nsid[embassy_record['nsid']] = embassy_record"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# df_embassies_copy.loc[(df_embassies['nsid'] == '124109311@N07').idxmax(),'country']\n",
+    "# df_embassies_copy.at[df_embassies_copy['nsid'] == '124109311@N07'] = 'Test'\n",
+    "# df_embassies_copy.loc[(df_embassies['nsid'] == '124109311@N07').idxmax(),'country']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Get country from the original unextended file\n",
+    "for embassy_record_ext in embassy_records_ext:\n",
+    "  nsid = embassy_record_ext['nsid']\n",
+    "  if embassy_records_nsid.get(nsid):\n",
+    "    country = embassy_records_nsid.get(nsid).get('country')\n",
+    "    if country:\n",
+    "      #embassy_record_ext.setdefault('country', )\n",
+    "      country_ext = embassy_record_ext['country']\n",
+    "      if country_ext != country:\n",
+    "        print(f'set ext: {country_ext} to {country}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/munich_security_conference/html2csv.ipynb b/megapixels/notebooks/datasets/msc/html2csv.ipynb
index aa819214..aa819214 100644
--- a/megapixels/notebooks/datasets/munich_security_conference/html2csv.ipynb
+++ b/megapixels/notebooks/datasets/msc/html2csv.ipynb
diff --git a/megapixels/notebooks/datasets/pipa/pipa_flickr_metadata_cleanup.ipynb b/megapixels/notebooks/datasets/pipa/pipa_flickr_metadata_cleanup.ipynb
new file mode 100644
index 00000000..8746a740
--- /dev/null
+++ b/megapixels/notebooks/datasets/pipa/pipa_flickr_metadata_cleanup.ipynb
@@ -0,0 +1,145 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PIPA Flickr Metadata Cleanup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "import pandas as pd\n",
+    "\n",
+    "import sys\n",
+    "sys.path.append('/work/megapixels_dev/megapixels')\n",
+    "from app.utils import file_utils"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in = '/data_store/datasets/people/pipa/research/pipa_flickr_metadata_ext.csv'\n",
+    "fp_out = '/data_store/datasets/people/pipa/research/pipa_flickr_metadata_test.csv'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create metadata csv output\n",
+    "\n",
+    "|nsid|path_alias|count|"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_flickr_meta = pd.read_csv(fp_in)\n",
+    "df_flickr_meta.fillna('', inplace=True)\n",
+    "flickr_metas = df_flickr_meta.to_dict('records')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create nsid lookup table\n",
+    "nsid_lookup = {}\n",
+    "alias_lookup = {}\n",
+    "for flickr_meta in flickr_metas:\n",
+    "  nsid = flickr_meta['nsid']\n",
+    "  nsid_lookup[nsid] = flickr_meta\n",
+    "  alias_lookup[nsid] = flickr_meta['path_alias']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nsid_groups = df_flickr_meta.groupby('nsid')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "items = []\n",
+    "for nsid, nsid_group in nsid_groups:\n",
+    "  path_alias = alias_lookup[nsid]\n",
+    "  obj = {'nsid': nsid, 'path_alias': path_alias, 'count': len(nsid_group)}\n",
+    "  items.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_out = pd.DataFrame.from_dict(items)\n",
+    "df_out.to_csv(fp_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/sdr/sdr_instagram.ipynb b/megapixels/notebooks/datasets/sdr/sdr_instagram.ipynb
new file mode 100644
index 00000000..f10a7032
--- /dev/null
+++ b/megapixels/notebooks/datasets/sdr/sdr_instagram.ipynb
@@ -0,0 +1,265 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Social Relationship Domain\n",
+    "\n",
+    "- examine Instagram URLs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "import math\n",
+    "from glob import glob\n",
+    "from random import randint\n",
+    "import json\n",
+    "from pprint import pprint\n",
+    "\n",
+    "import cv2 as cv\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from PIL import Image, ImageDraw\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.io\n",
+    "from pathlib import Path\n",
+    "from sklearn import preprocessing\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "\n",
+    "import sys\n",
+    "sys.path.append('/work/megapixels_dev/megapixels/')\n",
+    "from app.settings import app_cfg as cfg\n",
+    "from app.utils import file_utils, im_utils\n",
+    "from app.models.bbox import BBox"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_dir = '/data_store/datasets/people/social_relation_pipa/dataset/'\n",
+    "fp_anno_info = '/data_store/datasets/people/social_relation_pipa/dataset/annotation_image_info.json'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def media_id_to_code(media_id):\n",
+    "  alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'\n",
+    "  short_code = ''\n",
+    "  while media_id > 0:\n",
+    "    remainder = media_id % 64\n",
+    "    media_id = (media_id-remainder)//64\n",
+    "    short_code = alphabet[remainder] + short_code\n",
+    "  return short_code\n",
+    "\n",
+    "def code_to_media_id(short_code):\n",
+    "  alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'\n",
+    "  media_id = 0;\n",
+    "  for letter in short_code:\n",
+    "    media_id = (media_id*64) + alphabet.index(letter)\n",
+    "  return media_id"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load JSON to CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "23995\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(fp_anno_info, 'r') as fp:\n",
+    "  annos_data = json.load(fp)\n",
+    "print(len(data))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['instagram', 'bing-doctor', 'yfcc100m', 'flickr', 'coco_val2014', 'coco_train2014', 'Flickr', 'Bing', 'visual_genome']\n"
+     ]
+    }
+   ],
+   "source": [
+    "annos_ig = []\n",
+    "sources = []\n",
+    "for anno_data in annos_data:\n",
+    "  src = anno_data['source']\n",
+    "  if src not in sources:\n",
+    "    sources.append(src)\n",
+    "  if anno_data['source'] == 'instagram':\n",
+    "    annos_ig.append(anno_data)\n",
+    "print(sources)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Instagram: 42\n",
+      "bing: 74\n",
+      "flickr: 2079\n",
+      "yfcc100m: 4340\n",
+      "Bing: 170\n",
+      "VG: 4218\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f'Instagram: {sum(1 for anno_data in annos_data if anno_data[\"source\"] == \"instagram\")}')\n",
+    "print(f'bing: {sum(1 for anno_data in annos_data if anno_data[\"source\"] == \"bing-doctor\")}')\n",
+    "print(f'flickr: {sum(1 for anno_data in annos_data if anno_data[\"source\"] == \"flickr\")}')\n",
+    "print(f'yfcc100m: {sum(1 for anno_data in annos_data if anno_data[\"source\"] == \"yfcc100m\")}')\n",
+    "print(f'Bing: {sum(1 for anno_data in annos_data if anno_data[\"source\"] == \"Bing\")}')\n",
+    "print(f'VG: {sum(1 for anno_data in annos_data if anno_data[\"source\"] == \"visual_genome\")}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'imgH': 640, 'source': 'instagram', 'bbox': [[62, 266, 325, 639], [224, 219, 564, 636]], 'source_id': '527824347898327040', 'imgW': 640, 'id': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(annos_ig[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "https://instagram.com/p/dTNXKoSDAA\n",
+      "https://instagram.com/p/dTXS1qSIAA\n",
+      "https://instagram.com/p/dT5EOOyCAA\n",
+      "https://instagram.com/p/dT8Sp_yDAB\n",
+      "https://instagram.com/p/dT9JCAQhAA\n",
+      "https://instagram.com/p/dT_SgSSCAA\n",
+      "https://instagram.com/p/dUA4XdCCAA\n",
+      "https://instagram.com/p/dUCxd_SFAA\n",
+      "https://instagram.com/p/dUHNmxSCAA\n",
+      "https://instagram.com/p/dUSSRTQkAB\n",
+      "https://instagram.com/p/dUXnSJwjAE\n",
+      "https://instagram.com/p/dUXw23AhAB\n",
+      "https://instagram.com/p/dUY0EAQkAA\n",
+      "https://instagram.com/p/dUZQeMAhAB\n",
+      "https://instagram.com/p/dUcEquSCAA\n",
+      "https://instagram.com/p/dUcI0tAjAB\n",
+      "https://instagram.com/p/dUcgMcAjAA\n",
+      "https://instagram.com/p/dUdzB6AkAC\n",
+      "https://instagram.com/p/dUhFAgiCAA\n",
+      "https://instagram.com/p/dVA5PJCGAA\n",
+      "https://instagram.com/p/dVA_qoAjAA\n",
+      "https://instagram.com/p/dVDQq4CCAA\n",
+      "https://instagram.com/p/dVSYfGQmAA\n",
+      "https://instagram.com/p/dVXL1JiHAA\n",
+      "https://instagram.com/p/dVXuiqyEAA\n",
+      "https://instagram.com/p/dVezqxiFAA\n",
+      "https://instagram.com/p/dVfFhNyCAB\n",
+      "https://instagram.com/p/dVkZddAgAA\n",
+      "https://instagram.com/p/dVk0IqCAAA\n",
+      "https://instagram.com/p/dVlXCpiEAB\n",
+      "https://instagram.com/p/dVlZVoCEAB\n",
+      "https://instagram.com/p/dV0hRtSGAA\n",
+      "https://instagram.com/p/dV2HchSFAA\n",
+      "https://instagram.com/p/dV2SrliIAC\n",
+      "https://instagram.com/p/dV25bbSGAA\n",
+      "https://instagram.com/p/dV3umuCGAA\n",
+      "https://instagram.com/p/dV8XH4SGAA\n",
+      "https://instagram.com/p/dWjs8FwnAA\n",
+      "https://instagram.com/p/dWkMfZyEAA\n",
+      "https://instagram.com/p/dWzrJniBAB\n",
+      "https://instagram.com/p/dW30c4yDAA\n",
+      "https://instagram.com/p/dW4bG2iHAB\n"
+     ]
+    }
+   ],
+   "source": [
+    "for anno_ig in annos_ig:\n",
+    "  media_code = media_id_to_code(int(anno_ig['source_id']))\n",
+    "  url = f'https://instagram.com/p/{media_code}'\n",
+    "  print(url)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/who_goes_there/prepare_flickr_api.ipynb b/megapixels/notebooks/datasets/who_goes_there/prepare_flickr_api.ipynb
new file mode 100644
index 00000000..c2ec5c84
--- /dev/null
+++ b/megapixels/notebooks/datasets/who_goes_there/prepare_flickr_api.ipynb
@@ -0,0 +1,223 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Who Goes There Prepare Flickr API"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from glob import glob, iglob\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm_notebook as tqdm\n",
+    "\n",
+    "import h5py\n",
+    "from scipy import misc\n",
+    "from io import BytesIO\n",
+    "from base64 import b64decode\n",
+    "\n",
+    "from PIL import Image, ImageDraw\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.io as sio\n",
+    "import h5py\n",
+    "import numpy as np\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_in = '/data_store/datasets/people/who_goes_there/downloads/whogoesthere_dataset.hdf5'\n",
+    "fp_out = '/data_store/datasets/people/who_goes_there/research/wgt_flickr_meta_base.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "keys_all = ['accuracy', 'admin1', 'admin2', 'age', 'capture_device', 'city', \n",
+    "  'content_length', 'country_code', 'date_taken', 'date_uploaded', \n",
+    "  'description', 'face', 'face_bounds', 'face_key', 'face_landmarks_f', \n",
+    "  'face_landmarks_o', 'gender', 'im_download_url', 'im_extension_original', \n",
+    "  'im_farm_id', 'im_id', 'im_page_url', 'im_secret', 'im_secret_original', \n",
+    "  'im_server_id', 'index', 'latitude', 'license_name', 'license_url', 'longitude', \n",
+    "  'machine_tags', 'title', 'user_nickname', 'user_nsid', 'user_tags']\n",
+    "\n",
+    "keys_keep = ['accuracy', 'admin1', 'admin2', 'age', 'capture_device', 'city', \n",
+    "  'content_length', 'country_code', 'date_taken', 'date_uploaded', \n",
+    "  'description', 'face', 'face_bounds', 'face_key', 'face_landmarks_f', \n",
+    "  'face_landmarks_o', 'gender', 'im_download_url', 'im_extension_original', \n",
+    "  'im_farm_id', 'im_id', 'im_page_url', 'im_secret', 'im_secret_original', \n",
+    "  'im_server_id', 'index', 'latitude', 'license_name', 'license_url', 'longitude', \n",
+    "  'machine_tags', 'title', 'user_nickname', 'user_nsid', 'user_tags']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<KeysViewHDF5 ['accuracy', 'admin1', 'admin2', 'age', 'capture_device', 'city', 'content_length', 'country_code', 'date_taken', 'date_uploaded', 'description', 'face', 'face_bounds', 'face_key', 'face_landmarks_f', 'face_landmarks_o', 'gender', 'im_download_url', 'im_extension_original', 'im_farm_id', 'im_id', 'im_page_url', 'im_secret', 'im_secret_original', 'im_server_id', 'index', 'latitude', 'license_name', 'license_url', 'longitude', 'machine_tags', 'title', 'user_nickname', 'user_nsid', 'user_tags']>\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "35deca016b57430bbfc84a2f3eefde51",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(IntProgress(value=0, max=2106478), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = []\n",
+    "with h5py.File(fp_in, 'r') as fp:\n",
+    "    print(fp.keys())\n",
+    "    print('')\n",
+    "    nsids = fp.get('user_nsid')\n",
+    "    for i, nsid in tqdm(enumerate(nsids), total=len(nsids)):\n",
+    "      obj = {\n",
+    "        'nsid': nsid.decode(),\n",
+    "        'photo_id': fp.get(\"im_id\")[i],\n",
+    "        'url': fp.get(\"im_download_url\")[i].decode(),\n",
+    "        'nickname': fp.get(\"user_nickname\")[0].decode()\n",
+    "      }\n",
+    "      results.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame.from_dict(results)\n",
+    "df.to_csv(fp_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_flickr_meta_ext = '/data_store/datasets/people/who_goes_there/research/wgt_flickr_queries.csv'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Convert Flickr Queries data to final meta file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_flickr_meta = '/data_store/datasets/people/who_goes_there/research/wgt_flickr_queries.csv'\n",
+    "fp_meta_out = '/data_store/datasets/people/who_goes_there/research/who_goes_there_flickr_meta.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_flickr_meta = pd.read_csv(fp_flickr_meta)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "groups = df_flickr_meta.groupby('nsid')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = []\n",
+    "for nsid, group in groups:\n",
+    "  obj = {\n",
+    "    'nsid': nsid,\n",
+    "    'count': len(group)\n",
+    "  }\n",
+    "  results.append(obj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.DataFrame.from_dict(results).to_csv(fp_meta_out, index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "megapixels",
+   "language": "python",
+   "name": "megapixels"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}