Vowpal Wabbit 1. Preparing dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gzip\n",
    "import random\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "from sklearn.model_selection import StratifiedShuffleSplit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df = pd.read_csv('..\\\\input\\\\mlboot_test.tsv', index_col=0)\n",
    "train_df = pd.read_csv('..\\\\input\\\\mlboot_train_answers.tsv', delimiter='\\t', index_col=0)\n",
    "train_index = train_df.index\n",
    "\n",
    "# Разметить таргет для vw\n",
    "train_df[train_df['target']==0] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cuid</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>888b238b4d14c03173baa375a739f6bc</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ac4b8244f3ae82df511b002257473c11</th>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: []\n",
       "Index: [888b238b4d14c03173baa375a739f6bc, ac4b8244f3ae82df511b002257473c11]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cuid</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>dc28aafafcfa71c0bbfa2a5724af6061</th>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>a4e12f1cbce08d16f3bb0672cef5193c</th>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  target\n",
       "cuid                                    \n",
       "dc28aafafcfa71c0bbfa2a5724af6061      -1\n",
       "a4e12f1cbce08d16f3bb0672cef5193c      -1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Создание датасета\n",
    "\n",
    "Подготовка датасета формата Vowpal Wabbit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def c_parse(counter_row):\n",
    "    \"\"\"Парсинг строк counter1,2,3 для использования в создании признаков файла vw.\n",
    "    \n",
    "    Input:\n",
    "    1. counter_row = '{\"809001\":2,\"848545\":2,\"565828\":1,\"490363\":1}'\n",
    "    2. counter_row = '{}'\n",
    "    \n",
    "    Output:\n",
    "    1. c_edit_row = '809001:2 848545:2 565828:1 490363:1', vals = [2, 2, 1, 1]\n",
    "    2. c_edit_row = '', vals = []\n",
    "    \"\"\"\n",
    "    c_edit_row = counter_row[1:-1].replace('\"','').replace(',','.0 ')\n",
    "    if c_edit_row:\n",
    "        c_edit_row += '.0'\n",
    "#         vals = [int(x[:-2]) for y in c_edit_row.split(' ') for x in y.split(':')[1]]\n",
    "        vals = [int(x.split(':')[1][:-2]) for x in c_edit_row.split(' ')]\n",
    "        return c_edit_row + ' ', vals\n",
    "    return '', []\n",
    "\n",
    "\n",
    "def c_parse2(counter_row):\n",
    "    \"\"\"Парсинг строк counter1,2,3 для использования в создании признаков файла vw.\n",
    "    \n",
    "    Функция аналогична c_parse(), но использует преобразование к dict.\n",
    "    Обрабатыват данные дольше (примерно в полтора раза).\n",
    "    \n",
    "    \"\"\"\n",
    "    d = json.loads(counter_row)\n",
    "    if d:\n",
    "        c_edit_row = ' '.join([token + ':' + str(val) + '.0' for token,val in d.items()]) + ' '\n",
    "        \n",
    "        return c_edit_row, d.values()\n",
    "#         return c_edit_row, list(d.values())\n",
    "    return '', []\n",
    "\n",
    "\n",
    "def cat_f(cat_row, val=0):\n",
    "    \"\"\"Категориальная числовая фича, увеличенная на 1\"\"\"\n",
    "    return str(int(cat_row)+val) + '.0'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Создание дополнительных признаков\n",
    "\n",
    "Дополнительные признаки из токенов (count, sum и проч)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numc(c_vals):\n",
    "    \"\"\"Количество.\"\"\"\n",
    "    return str(len(c_vals)) + '.0'\n",
    "\n",
    "\n",
    "def sumc(c_vals):\n",
    "    \"\"\"Сумма.\"\"\"\n",
    "    return str(sum(c_vals)) + '.0'\n",
    "\n",
    "\n",
    "def meanc(c_vals):\n",
    "    \"\"\"Среднее.\"\"\"\n",
    "    if c_vals:\n",
    "        return str(np.round(np.mean(c_vals),1))\n",
    "    return '0.0'\n",
    "\n",
    "\n",
    "def minc(c_vals):\n",
    "    \"\"\"Минимальное.\"\"\"\n",
    "    if c_vals:\n",
    "        return str(min(c_vals)) + '.0'\n",
    "    return '0.0'\n",
    "\n",
    "\n",
    "def maxc(c_vals):\n",
    "    \"\"\"Максимальное.\"\"\"\n",
    "    if c_vals:\n",
    "        return str(max(c_vals)) + '.0'\n",
    "    return '0.0'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Создание строки формата VW\n",
    "Формат строки:\n",
    "- признак -1 или 1\n",
    "- |c catf:value (прибавить единицу)\n",
    "- |f token:value (counter first)\n",
    "- |s token:value (counter second)\n",
    "- |t token:value (counter third)\n",
    "- |d diff:value (тоже на всякий случай прибавить единицу)\n",
    "\n",
    "Дополнительные признаки, что можно сделать:\n",
    "- Количество токенов для каждого counter: |n nucf:value nucs:value nuct:value\n",
    "- Сумма посещений токенов (сумма values): |p sucf:value sucs:value suct:value\n",
    "- Среднее посещений токенов: |a mecf:value mecs:value mect:value\n",
    "- Минимальное посещение токенов: |b micf:value mics:value mict:value\n",
    "- Максимальное посещение токенов: |m macf:value macs:value mact:value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_vw(label, tags, cat_feature, counter1, counter2, counter3, day):\n",
    "    \n",
    "    c1, c1_val = c_parse(counter1)\n",
    "    c2, c2_val = c_parse(counter2)\n",
    "    c3, c3_val = c_parse(counter3)\n",
    "    \n",
    "    f, s, t = \"\", \"\", \"\"\n",
    "    if c1:\n",
    "        f = f\"|f {c1}\"\n",
    "    if c2:\n",
    "        s = f\"|s {c2}\"\n",
    "    if c3:\n",
    "        t = f\"|t {c3}\"\n",
    "    \n",
    "    if not isinstance(tags, list):\n",
    "        tags = [tags]\n",
    "#     tag = [\"'\" + t for t in tags[:-1]] + [tags[-1]]\n",
    "    tag = f\"{'_'.join(tags)}\"\n",
    "    \n",
    "    return f\"{label} {tag}\" + \\\n",
    "        f\"|c catf:{cat_f(cat_feature, 1)} \" + f + s + t + \\\n",
    "        f\"|d diff:{cat_f(day)} \" + \\\n",
    "        f\"|n nucf:{numc(c1_val)} nucs:{numc(c2_val)} nuct:{numc(c3_val)} \" + \\\n",
    "        f\"|p sucf:{sumc(c1_val)} sucs:{sumc(c2_val)} suct:{sumc(c3_val)} \" + \\\n",
    "        f\"|a mecf:{meanc(c1_val)} mecs:{meanc(c2_val)} mect:{meanc(c3_val)} \" + \\\n",
    "        f\"|b micf:{minc(c1_val)} mics:{minc(c2_val)} mict:{minc(c3_val)} \" + \\\n",
    "        f\"|m macf:{maxc(c1_val)} macs:{maxc(c2_val)} mact:{maxc(c3_val)}\" + \\\n",
    "        \"\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Создание файлов для VW\n",
    "##### Проверка функций создания строк для VW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 day39_5_00000d2994b6df9239901389031acaac|c catf:6.0 |f 809001:2.0 848545:2.0 565828:1.0 490363:1.0 |s 85789:1.0 238490:1.0 32285:1.0 103987:1.0 16507:2.0 6477:1.0 92797:2.0 |d diff:39.0 |n nucf:4.0 nucs:7.0 nuct:0.0 |p sucf:6.0 sucs:9.0 suct:0.0 |a mecf:1.5 mecs:1.3 mect:0.0 |b micf:1.0 mics:1.0 mict:0.0 |m macf:2.0 macs:2.0 mact:0.0\\n'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with gzip.open('..\\\\input\\\\mlboot_data.tsv.gz', 'rt') as f:\n",
    "    for row in f:\n",
    "        break\n",
    "\n",
    "cuid, cat_feature, counter1, counter2, counter3, day = row.split()\n",
    "label = 1\n",
    "tags = [f'day{day}', cat_feature, cuid]\n",
    "to_vw(label, tags, cat_feature, counter1, counter2, counter3, day)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "19528597it [44:45, 7272.67it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 44min 45s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "niter = 0\n",
    "input_gzip = '..\\\\input\\\\mlboot_data.tsv.gz'\n",
    "\n",
    "output_dataset = '..\\\\vw\\\\dataset.vw'\n",
    "output_dataset_cuid = '..\\\\vw\\\\dataset_cuid.vw'\n",
    "\n",
    "output_test = '..\\\\vw\\\\dataset_test.vw'\n",
    "output_test_cuid = '..\\\\vw\\\\dataset_cuid_test.vw'\n",
    "\n",
    "with gzip.open(input_gzip, 'rt') as input_data, \\\n",
    "    open(output_dataset, 'w') as dataset, open(output_dataset_cuid, 'w') as dataset_cuid, \\\n",
    "    open(output_test, 'w') as test, open(output_test_cuid, 'w') as test_cuid:\n",
    "\n",
    "    for row in tqdm(input_data):\n",
    "        cuid, cat_feature, counter1, counter2, counter3, day = row.split()\n",
    "        tags = [f'day{day}', cat_feature, cuid]\n",
    "        \n",
    "        if cuid in train_index:\n",
    "            label = train_df['target'][cuid]\n",
    "            output_row = to_vw(label, tags, cat_feature, counter1, counter2, counter3, day)\n",
    "            dataset.write(output_row)\n",
    "            \n",
    "            # Записать cuid\n",
    "            dataset_cuid.write(f'{cuid}\\t{cat_feature}\\t{day}\\n')\n",
    "        else:\n",
    "            label = '1'\n",
    "            output_row = to_vw(label, tags, cat_feature, counter1, counter2, counter3, day)\n",
    "            test.write(output_row)\n",
    "            \n",
    "            # Записать cuid\n",
    "            test_cuid.write(f'{cuid}\\t{cat_feature}\\t{day}\\n')\n",
    "\n",
    "#         niter += 1\n",
    "        \n",
    "#         if niter > 1000:\n",
    "#             break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Разделить выборку на train / valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cuid</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>dc28aafafcfa71c0bbfa2a5724af6061</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>a4e12f1cbce08d16f3bb0672cef5193c</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                               cuid  target\n",
       "0  dc28aafafcfa71c0bbfa2a5724af6061       0\n",
       "1  a4e12f1cbce08d16f3bb0672cef5193c       0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df = pd.read_csv('..\\\\input\\\\mlboot_train_answers.tsv', delimiter='\\t')\n",
    "train_df.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Индексы разделения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TRAIN: [134680 141806 199462 ... 287909 267837 309817] TEST: [ 49559 232377  91810 ... 263939 311760 367063]\n"
     ]
    }
   ],
   "source": [
    "sss = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=17)\n",
    "\n",
    "for train_index, valid_index in sss.split(train_df, train_df['target']):\n",
    "    print(\"TRAIN:\", train_index, \"TEST:\", valid_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cuid</th>\n",
       "      <th>target</th>\n",
       "      <th>train</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cuid</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>dc28aafafcfa71c0bbfa2a5724af6061</th>\n",
       "      <td>dc28aafafcfa71c0bbfa2a5724af6061</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>a4e12f1cbce08d16f3bb0672cef5193c</th>\n",
       "      <td>a4e12f1cbce08d16f3bb0672cef5193c</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                              cuid  target  \\\n",
       "cuid                                                                         \n",
       "dc28aafafcfa71c0bbfa2a5724af6061  dc28aafafcfa71c0bbfa2a5724af6061       0   \n",
       "a4e12f1cbce08d16f3bb0672cef5193c  a4e12f1cbce08d16f3bb0672cef5193c       0   \n",
       "\n",
       "                                  train  \n",
       "cuid                                     \n",
       "dc28aafafcfa71c0bbfa2a5724af6061      1  \n",
       "a4e12f1cbce08d16f3bb0672cef5193c      1  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df['train'] = 0\n",
    "\n",
    "train_df.loc[train_index, 'train'] = 1\n",
    "\n",
    "train_df.index = train_df['cuid']\n",
    "train_df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "12874345it [08:17, 25873.31it/s]\n"
     ]
    }
   ],
   "source": [
    "dataset_file = '..\\\\vw\\\\dataset.vw'\n",
    "train_file = '..\\\\vw\\\\dataset_train.vw'\n",
    "valid_file = '..\\\\vw\\\\dataset_valid.vw'\n",
    "\n",
    "n_iter = 0\n",
    "with open(dataset_file, 'r') as d_file, open(train_file, 'w') as t_file, open(valid_file, 'w') as v_file:\n",
    "    for row in tqdm(d_file):\n",
    "        cuid = row.split('|')[0].split()[1].split('_')[-1]\n",
    "            \n",
    "        if train_df['train'][cuid] == 1:\n",
    "            t_file.write(row)\n",
    "        else:\n",
    "            v_file.write(row)\n",
    "        \n",
    "#         n_iter += 1\n",
    "#         if n_iter > 100000:\n",
    "#             break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Перемешать данные (WARNING - High Memory Usage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shuffle_data(input_file, output_file):\n",
    "    \n",
    "    lines = open(input_file).readlines()\n",
    "    random.shuffle(lines)\n",
    "    open(output_file, 'w').writelines(lines)\n",
    "    \n",
    "    print(f'Data shuffle completed: {input_file}. Saved to {output_file}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shuffle_data2(input_file, output_file):\n",
    "    \"\"\"Работает в два раза медленнее!\"\"\"\n",
    "    with open(input_file,'r') as source:\n",
    "        data = [(random.random(), line) for line in source]\n",
    "    data.sort()\n",
    "    \n",
    "    with open(output_file,'w') as target:\n",
    "        for _, line in data:\n",
    "            target.write( line )\n",
    "    \n",
    "    print(f'Data shuffle completed: {input_file}. Saved to {output_file}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data shuffle completed: ..\\vw\\dataset.vw. Saved to ..\\vw\\dataset_shuffled.vw\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Исходный датасет\n",
    "shuffle_data('..\\\\vw\\\\dataset.vw', '..\\\\vw\\\\dataset_shuffled.vw')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data shuffle completed: ..\\vw\\dataset_train.vw. Saved to ..\\vw\\dataset_train_shuffled.vw\n",
      "Data shuffle completed: ..\\vw\\dataset_valid.vw. Saved to ..\\vw\\dataset_valid_shuffled.vw\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# train\n",
    "shuffle_data('..\\\\vw\\\\dataset_train.vw', '..\\\\vw\\\\dataset_train_shuffled.vw')\n",
    "\n",
    "# valid\n",
    "shuffle_data('..\\\\vw\\\\dataset_valid.vw', '..\\\\vw\\\\dataset_valid_shuffled.vw')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}