{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../../img/ods_stickers.jpg\">\n",
    "## Открытый курс по машинному обучению\n",
    "<center>Автор материала: Michael Kazachok (@miklgr500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center>Другая сторона tensorflow:KMeans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center>Введение"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">  Многие знают <strong>tensorflow</strong>, как одну из лучших библиотек для обучения нейронных сетей, но в последнее время tensorflow довольно сильно вырос. Появились новые <a href='https://www.tensorflow.org/programmers_guide/estimators'>Estimators</a>, которые более удобны, чем старая парадигма, являющаяся фундаментом для новой.</p>\n",
    "<p style=\"text-indent:20px;\">  На сайте <a href = 'https://www.tensorflow.org/'>tensorflow</a> будет хорошая инструкция по установке под определенную операционную ситему и возможностях использование <a href = 'https://ru.wikipedia.org/wiki/GPGPU'>GPGPU</a>.Я не буду грузить данную работу особенностями \"кухни\" tensorflow (поэтому советую почитать хотябы основы в <a href='https://www.tensorflow.org/tutorials/'>официальном тьюториале</a> и посмотреть <a href='https://github.com/aymericdamien/TensorFlow-Examples'>TensorFlow Tutorial and Examples for Beginners with Latest APIs</a>; там же есть примеры, которые помогут в дальнейшем в изучении нейронных сетей), а я пройдусь по уже прошитым в этой либе алгоритмам крастеризации(а их фактически пока только два).</p>\n",
    "<p style=\"text-indent:20px;\">  При этом будет использоваться набор данных с Kaggel для соревнования <a href = 'https://www.kaggle.com/chicago/chicago-taxi-rides-2016'>Chicago Taxi Rides 2016</a>, который использовался в одной из домашек (<span style='color:green'>рекомендую использовать не более двух месяцев</span>).</p>\n",
    "<p style=\"text-indent:20px;\">  Применение простейшего алгоритма кластеризации в tensorflow будет сопроваждаться рассмотрением вопросов изящной визуализации (которую я увидел этим летом на соревнований Kaggle <a href = 'https://www.kaggle.com/c/nyc-taxi-trip-duration'>New York City Taxi Trip</a>), представленой <a href = 'https://www.kaggle.com/drgilermo'>DrGuillermo</a> и <a href = 'https://www.kaggle.com/maheshdadhich'>BuryBuryZymon</a> в их работах <a href = 'https://www.kaggle.com/drgilermo/dynamics-of-new-york-city-animation'>Dynamics of New York city - Animation</a> и <a href = 'https://www.kaggle.com/maheshdadhich/strength-of-visualization-python-visuals-tutorial'>Strength of visualization-python visuals tutorial</a> на соревновании.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\"><i>P.S. На написание данного тьюториала автора сподвигло довольно плохая освещенность возможностей tensorflow для создания уже довольно хорошо всем известных простых алгоритмов машинного обучения, которые для определенных задачах могут быть более эфективны, чем сложные алгоритмы машинного обучения.</i></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## <center>Подключение используемых в работе библиотек и загрузка данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "FIG_SIZE = (12,12)\n",
    "PATH_DATA_JSON = '../../data/column_remapping.json'\n",
    "PATH_DATA_CSV = '../../data/chicago_taxi_trips_2016_*.csv'\n",
    "GIF_PATH = '../../img/animation.gif'\n",
    "KMEANS_GIF_PATH='../../img/kmeans_animation.gif'\n",
    "NUM_CLUSTERS = 5\n",
    "BATCH_SIZE = 5\n",
    "NUM_STEPS = 50\n",
    "LON_CONST = -87.623177\n",
    "LAT_CONST = 41.881832\n",
    "LON_ANI_CENTER = [-87.73, -87.60]\n",
    "LAT_ANI_CENTER = [41.85, 42.00]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from glob import glob\n",
    "\n",
    "import folium\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from IPython.display import HTML\n",
    "from joblib import Parallel, delayed\n",
    "from matplotlib import animation\n",
    "from matplotlib.patches import Ellipse\n",
    "\n",
    "plt.rcParams.update({'figure.max_open_warning': 0})\n",
    "\n",
    "import base64\n",
    "import io\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from dateutil import parser\n",
    "from geopy.geocoders import Nominatim\n",
    "\n",
    "%load_ext watermark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Версии основных библиотек и параметры системы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%watermark -v -m -p numpy,pandas,matplotlib,tensorflow -g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Открываем данные за два первых месяца. Будте внимательны со ссылками на данные."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ядро которое будем использовать \n",
    "#для загруски и преобработки данных за один месяц\n",
    "def preproc_kernel(path):\n",
    "    with open(PATH_DATA_JSON) as json_file:\n",
    "        column_remapping = json.load(json_file)\n",
    "    df = pd.read_csv(path)\n",
    "    # в дальнейшем понадобяться только геоданные\n",
    "    # и время начала поездки\n",
    "    df = df.loc[:, [\n",
    "        'trip_start_timestamp',\n",
    "        'pickup_latitude',\n",
    "        'pickup_longitude',\n",
    "        'dropoff_latitude',\n",
    "        'dropoff_longitude']].dropna()\n",
    "    geo_labels = ['pickup_latitude',\n",
    "                  'pickup_longitude',\n",
    "                  'dropoff_latitude',\n",
    "                  'dropoff_longitude']\n",
    "    for g in geo_labels:\n",
    "        df[g] = df[g].apply(lambda x: float(column_remapping[g].get(str(int(x)))))\n",
    "    return df\n",
    "\n",
    "\n",
    "dataset_files = sorted(glob(PATH_DATA_CSV))\n",
    "# выполняем загрузку данных параллельно\n",
    "# на двух ядрах, каждому по одному файлу\n",
    "dfs = Parallel(n_jobs=2)(delayed(preproc_kernel)(path) for path in dataset_files)\n",
    "# склеиваем данные\n",
    "df = pd.concat(dfs, ignore_index=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center> Визуализация данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Произведем предварительную визуализацию всех гео данных и выявим их границы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# соединяем гео данные для точек посадки и точек высадки\n",
    "longitude = list(df.pickup_longitude)+list(df.dropoff_longitude)\n",
    "print('max_long:'+str(max(longitude)))\n",
    "print('min_long:'+str(min(longitude)))\n",
    "latitude = list(df.pickup_latitude)+list(df.dropoff_latitude)\n",
    "print('max_lat:'+str(max(latitude)))\n",
    "print('min_lat:'+str(min(latitude)))\n",
    "\n",
    "loc_df = pd.DataFrame()\n",
    "loc_df['longitude'] = longitude\n",
    "loc_df['latitude'] = latitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#производим визуализацию объединенных гео данных\n",
    "fig, ax = plt.subplots(1,1, figsize = FIG_SIZE)\n",
    "plt.plot(longitude, \n",
    "         latitude, \n",
    "         '.', \n",
    "         color = 'orangered',\n",
    "         markersize = 1.5, \n",
    "         axes = ax, \n",
    "         figure = fig\n",
    "    )\n",
    "ax.set_axis_off()\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Мало что можно сказать про количество кластеров из графика выше. Но если вывести рапределение по широте и долготе, то картина немного прояснится.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, figsize=FIG_SIZE)\n",
    "\n",
    "sns.distplot(loc_df['longitude'], bins=300, kde=False, ax=ax1)\n",
    "sns.distplot(loc_df['latitude'], bins=300, kde=False, ax=ax2)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Из графиков выше видно, что наибольший трафик приходится практически на центр города. При этом стоит отметить, наличее довольно сильно выделяющегося трафика на долготе -87.90, а по долготе правея центра выделятся три центра с ярко выраженным трафиков.  Таким образом кроме одного основного яровыделяющего по трафику центра есть еще как миниму четыре центра, которые можно выделить в отдельный кластер. В итоге можно выделить пять кластеров, которые имеют ярковыраженый трафик.</p> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "\n",
    "## <center>Kmean в tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Пожалуй это один из самых востребованных алгоритмов кластеризации на на данный момент. Не думаю, что тут стоит излагать теорию (учитывая, что она затрагивалась в <a href='https://habrahabr.ru/company/ods/blog/325654/'>лекции курса</a>), если кто-то хочет почитать что-то еще по данному алгоритму и по кластеризации в целом, то я пожалуй могу посоветовать <a href='http://www.machinelearning.ru/wiki/images/2/28/Voron-ML-Clustering-slides.pdf'>лекции К.В.Воронцова</a>.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# формируем массив с данными в нужном формате\n",
    "# т.е. формируем пары [lon, lat]\n",
    "# Для правильной работы алгоритма\n",
    "# неообходимо омязательно избавиться от\n",
    "# постоянной компаненты\n",
    "data = [[(lon-LON_CONST), (lat-LAT_CONST)] for lon, lat in zip(longitude, latitude)]\n",
    "data = np.array(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">В качестве основы выберем уже прошитый в tensorflow алгоритм <a href='https://www.tensorflow.org/versions/master/api_docs/python/tf/contrib/factorization/KMeans'>KMeans</a>(<a href='https://github.com/tensorflow/tensorflow/blob/r1.4/tensorflow/contrib/factorization/python/ops/clustering_ops.py'>люблю открытый код</a>). Те кто разобрал открытый код, мог заметить, что из большого набора функций вызвать можем только <i>training_graph(self)</i>. Обратите внимание возвращается ли в вашей версии tensorflow данная функция переменную <i>cluster_centers_var</i>(в 1.3 она не возвращается).</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " def KMeans_clustering(num_clusters=NUM_CLUSTERS, flag_print=True):\n",
    "    # создаем placeholder X\n",
    "    # подставляя его вместо каких-то знаений\n",
    "    # мы говорим вычислительному графу\n",
    "    # что эти значения будут предоставлены потом: \n",
    "    # в процессе обучения и/или инициализации\n",
    "    X = tf.placeholder(tf.float32, shape=[None, 2])\n",
    "\n",
    "    # производим построение вычислительного графа для KMeans\n",
    "    kmeans = tf.contrib.factorization.KMeans(\n",
    "        inputs=X,\n",
    "        num_clusters=num_clusters,\n",
    "        initial_clusters=\"kmeans_plus_plus\",\n",
    "        mini_batch_steps_per_iteration=BATCH_SIZE,\n",
    "        random_seed=29,\n",
    "        use_mini_batch=True\n",
    "    )\n",
    "    \n",
    "    (all_scores,cluster_idx, scores,cluster_centers_initialized,\\\n",
    "     cluster_centers_var,init_op,train_op) = kmeans.training_graph()\n",
    "    \n",
    "    # т.к. изначально возвращается tuple\n",
    "    # то берем только первый его член\n",
    "    cluster_idx = cluster_idx[0]\n",
    "    # производим расчет средней дистанции \n",
    "    # точек до своего кластера\n",
    "    avg_distance = tf.reduce_mean(scores)\n",
    "\n",
    "    # создание сессии и инициальзация\n",
    "    init_vars = tf.global_variables_initializer()\n",
    "    sess = tf.Session()\n",
    "    sess.run(init_vars)\n",
    "    sess.run(init_op, feed_dict={X: data})\n",
    "\n",
    "    # пошагово обучаем модель\n",
    "    # получая на каждом шаге\n",
    "    # d:среднюю дистанцию от точки \n",
    "    # до центра своего кластера\n",
    "    #----------------------------\n",
    "    # задаем критерии остановки\n",
    "\n",
    "    for i in range(1,NUM_STEPS+1):\n",
    "        _, d, idx, cl_c = sess.run([train_op, \n",
    "                                    avg_distance,\n",
    "                                    cluster_idx,\n",
    "                                    cluster_centers_var],\n",
    "                                    feed_dict={X: data}\n",
    "                            )\n",
    "        \n",
    "        if (i%10==0)&(flag_print):\n",
    "            print('Step %i, Average Distance %.8f'%(i, d))\n",
    "    sess.close()\n",
    "    return d,idx,cl_c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Визуализируем работу алгоритма, произведя инициализацию всех кластеров в координате [LON_CONST, LAT_CONST], являющеся центром города.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# сделаем анимацию обучения\n",
    "num_clusters = 8\n",
    "\n",
    "# массив для инициализации кластеров\n",
    "# в точке [LON_CONST, LAT_CONST], но \n",
    "# т.к. у нас все данные смещенны на \n",
    "# значение данной координаты,\n",
    "# то инициализацию необходимо провести \n",
    "# в точке [0, 0]\n",
    "init_cl = np.array([[0, 0] for i in range(num_clusters)],\n",
    "                   dtype=np.float32\n",
    "            )\n",
    "X = tf.placeholder(tf.float32, shape=[None, 2])\n",
    "# производим построение вычислительного графа для KMeans\n",
    "kmeans = tf.contrib.factorization.KMeans(\n",
    "    inputs=X,\n",
    "    num_clusters=num_clusters,\n",
    "    initial_clusters=init_cl,\n",
    "    mini_batch_steps_per_iteration=2,\n",
    "    random_seed=29,\n",
    "    use_mini_batch=False\n",
    ")\n",
    "    \n",
    "(all_scores,cluster_idx, scores,cluster_centers_initialized,\\\n",
    "     cluster_centers_var,init_op,train_op) = kmeans.training_graph()\n",
    "# т.к. изначально возвращается tuple\n",
    "# то берем только первый его член\n",
    "cluster_idx = cluster_idx[0]\n",
    "avg_distance = tf.reduce_mean(scores)\n",
    "\n",
    "# создание сессии и инициальзация\n",
    "init_vars = tf.global_variables_initializer()\n",
    "sess = tf.Session()\n",
    "sess.run(init_vars)\n",
    "sess.run(init_op, feed_dict={X: data})\n",
    "fig, ax = plt.subplots(1,1, figsize = FIG_SIZE)\n",
    "# задаем функцию, которую передадим в animation.FuncAnimation\n",
    "# эта функция будет производить просчет полученого графика\n",
    "# на каждом шагу, но так как mini_batch_steps_per_iteration=2\n",
    "# то изменение будут каждые 2 шага, всего шагов будет 10\n",
    "# их мы непосредственно будем задавать в FuncAnimation\n",
    "# в виде массива и FuncAnimation пошагово будет передовать\n",
    "# заданные значения в animate_kmeans\n",
    "def animate_kmeans(step):\n",
    "    _, d, idx, cl_c = sess.run([train_op, \n",
    "                                avg_distance,\n",
    "                                cluster_idx,\n",
    "                                cluster_centers_var],\n",
    "                                feed_dict={X: data}\n",
    "                        )\n",
    "    # для упрощения работы с полученными данными после обучения\n",
    "    # создается DataFrame, который в конце кода будет удален\n",
    "    # данное решение может быть не совсем оптимально\n",
    "    # оно просто упрощает жизнь вашему слуге =)\n",
    "    loc_df['labels'] = idx\n",
    "    cl_df = pd.DataFrame()\n",
    "    cl_df['longitude'] = cl_c[:,0]+LON_CONST\n",
    "    cl_df['latitude'] = cl_c[:,1]+LAT_CONST\n",
    "    cl_df['labels'] = cl_df.index\n",
    "    # обязательно чистим предыдущий график\n",
    "    ax.clear()\n",
    "    ax.set_title('Step: '+str(step))\n",
    "    for l in cl_df['labels']:\n",
    "        ax.plot(loc_df.loc[loc_df['labels'] == l, 'longitude'], \n",
    "                loc_df.loc[loc_df['labels'] == l, 'latitude'], \n",
    "                '.',\n",
    "                markersize = 1.5\n",
    "            )\n",
    "        ax.plot(cl_df.loc[cl_df['labels'] == l, 'longitude'], \n",
    "                cl_df.loc[cl_df['labels'] == l, 'latitude'], \n",
    "                'ro'\n",
    "            )\n",
    "        ax.annotate(s=str(l),\n",
    "                    xy=(cl_df.loc[cl_df['labels'] == l, 'longitude'], \n",
    "                    cl_df.loc[cl_df['labels'] == l, 'latitude'])\n",
    "                )\n",
    "    \n",
    "    ax.set_axis_off()\n",
    "    del cl_df\n",
    "    \n",
    "ani = animation.FuncAnimation(fig,\n",
    "                              animate_kmeans,\n",
    "                              list(range(0, 20)),\n",
    "                              interval=500\n",
    "                    )\n",
    "# производим закрытие отрисованных графиков\n",
    "plt.close()\n",
    "# дириктори сохранения гифки\n",
    "gif_path = KMEANS_GIF_PATH\n",
    "# сохранение гифки\n",
    "ani.save(gif_path,\n",
    "         writer='imagemagick',\n",
    "         fps=1\n",
    "        )\n",
    "# открываем сохраненную гифку и производим ее дешифрование\n",
    "# для дальнейшего URL и подстановки их в HTML\n",
    "video = io.open(gif_path,\n",
    "                'r+b'\n",
    "            ).read()\n",
    "encoded = base64.b64encode(video)\n",
    "# производим отрисовку анимации в notebook\n",
    "HTML(data='''<img src=\"data:image/gif;base64,{0}\"type=\"gif\"/>'''.format(\n",
    "    encoded.decode('ascii')))               "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Видно что обновление происходит каждые 2 шага за счет установки mini_batch_steps_per_iteration=2. Вы можете поиграться с кодом выше! Выставте другую инициализацию(\"kmeans_plus_plus\",\"random\") или поиграйтесь с параметрами для mini_batch, а можно и вовсе изменить количество кластеров!</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Найдем оптимальное число кластеров по методу, который был предложен на лекции,а пока идут вычисления можно заварить чашечку кофе и изучить новый алгоритм =)<p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_cluster = range(1,15,1)\n",
    "avg_distance = []\n",
    "for i in n_cluster:\n",
    "    d,idx,cl_c = KMeans_clustering(num_clusters=i, flag_print=False)\n",
    "    avg_distance.append(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([i for i in n_cluster], avg_distance, color = 'seagreen')\n",
    "plt.xlabel('number of cluster')\n",
    "plt.ylabel('avg_distance')\n",
    "plt.title('Optimal Number Of Cluster')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Из графика видно, что ничего не видно=). Опять гадаем=) Я бы взять 4 кластера, и это довольно неплохо согласуется с предыдущей оценкой, поэтому возмем 5 кластеров(в данном случае лучше взять большее число, т.о. получится более детальная картина трафика).</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_CLUSTERS = 5\n",
    " \n",
    "d,idx,cl_c = KMeans_clustering(num_clusters=NUM_CLUSTERS, flag_print=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Добавим метки кластеров в loc_df, и создадим новый DataFrame с параметрами (широта, долгота и метка кластера для каждого кластера).</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loc_df['labels'] = idx\n",
    "cl_df = pd.DataFrame()\n",
    "cl_df['longitude'] = cl_c[:,0]+LON_CONST\n",
    "cl_df['latitude'] = cl_c[:,1]+LAT_CONST\n",
    "cl_df['labels'] = cl_df.index\n",
    "cl_df.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center> Визуализация полученых кластеров"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1,1, figsize = FIG_SIZE)\n",
    "for l in cl_df['labels']:\n",
    "    plt.plot(loc_df.loc[loc_df['labels'] == l, 'longitude'], \n",
    "             loc_df.loc[loc_df['labels'] == l, 'latitude'], \n",
    "             '.',\n",
    "             markersize = 1.5, \n",
    "             axes = ax, \n",
    "             figure = fig\n",
    "        )\n",
    "    plt.plot(cl_df.loc[cl_df['labels'] == l, 'longitude'], \n",
    "             cl_df.loc[cl_df['labels'] == l, 'latitude'], \n",
    "             'ro', \n",
    "             axes = ax, \n",
    "             figure = fig\n",
    "        )\n",
    "    ax.annotate(s=str(l),\n",
    "                xy=(cl_df.loc[cl_df['labels'] == l, 'longitude'], \n",
    "                    cl_df.loc[cl_df['labels'] == l, 'latitude'])\n",
    "        )\n",
    "           \n",
    "ax.set_axis_off()\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# посмотрим где наши кластеры расположились на карте\n",
    "chikago_map = folium.Map(location=[LAT_CONST, LON_CONST], \n",
    "                zoom_start=10,\n",
    "                tiles='OpenStreetMap'\n",
    "            )\n",
    "# выставляем маркеры на карту Чикаго\n",
    "for lon, lat in zip(cl_df['longitude'], cl_df['latitude']):\n",
    "    folium.Marker(location=[lat, lon]).add_to(chikago_map)\n",
    "chikago_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Можно заметить, что две самых удаленных от скопления мест посадок и высодок центроид кластеров находяться ровно около аэропортов(1,3), одна принадлежит северным жилым зонам Чикаго(2), а две центроиды можно отнести на деловой и культурный части (4,0) Чикаго.</p>\n",
    "<p style=\"text-indent:20px;\">Может показаться странным, что на южные жилые зоны Чикаго нет ярко выраженной центроиды, но если больше узнать об этом городе, то станет понятно, что это не так уж и странно. Южные кварталы Чикаго - это мексиканские и ирландские районы, в которых уровень жизни ниже северной части Чикаго.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center>Визуализация трафика между центрами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Для прогноза трафика между кластерами по часам необходимо: выделить час посадки и выставить метки принадлежности определенному кластеру для мест посадки и высадки.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['pickup_hour'] = df['trip_start_timestamp'].apply(lambda x: parser.parse(x).hour)\n",
    "df['pickup_cluster'] = loc_df.loc[:len(df)-1,'labels'].values\n",
    "df['dropoff_cluster'] = loc_df.loc[len(df):, 'labels'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Начнем делать красоту (т.е. анимацию трафика между кластерами). Тот кто хочет получше разобраться с анимацией в matplotlib можно почитать документацию с <a href='https://matplotlib.org/api/animation_api.html'>официального сайта</a>.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trafic_animation(lon_ani_lim=None, lat_ani_lim=None, strong=6):\n",
    "    # передовая пределы возможно ограничить зону \n",
    "    # изображения анимации\n",
    "    # так же немаловажен параметр strong\n",
    "    # который является маштабирующим коэффициентом\n",
    "    # и влияет на ширину стрелок\n",
    "    if (lon_ani_lim==None)|(lat_ani_lim==None):\n",
    "        lim_cl_df = cl_df\n",
    "    elif (len(lon_ani_lim)!=2)|(len(lat_ani_lim)!=2):\n",
    "        lim_cl_df = cl_df\n",
    "    else:\n",
    "        lim_cl_df = cl_df[\n",
    "            ((cl_df['longitude']>lon_ani_lim[0])&(cl_df['longitude']<lon_ani_lim[1]))&\n",
    "            ((cl_df['latitude']>lat_ani_lim[0])&(cl_df['latitude']<lat_ani_lim[1]))\n",
    "        ]\n",
    "    fig, ax = plt.subplots(1,1, figsize = FIG_SIZE)\n",
    "    \n",
    "    \n",
    "    # функция, которая будет передоваться в animation.FuncAnimation\n",
    "    def animate(hour):\n",
    "        # чистим все что было отрисовано ранее \n",
    "        ax.clear()\n",
    "        # отрисовываем все заново\n",
    "        ax.set_title('Absolute Traffic - Hour' + str(int(hour)) + ':00')\n",
    "        plt.figure(figsize = FIG_SIZE)\n",
    "        # статическая часть, она будет неизменна\n",
    "        # но так как мы чистим все перед этим\n",
    "        # то нам необходимо будет все отрисовать заново\n",
    "        for l in lim_cl_df['labels']:\n",
    "            ax.plot(loc_df.loc[loc_df['labels'] == l, 'longitude'], \n",
    "                     loc_df.loc[loc_df['labels'] == l, 'latitude'], \n",
    "                     '.',\n",
    "                     markersize = 1.5\n",
    "                )\n",
    "            ax.plot(cl_df.loc[cl_df['labels'] == l, 'longitude'], \n",
    "                     cl_df.loc[cl_df['labels'] == l, 'latitude'], \n",
    "                     'ro'\n",
    "                )\n",
    "            ax.annotate(s=str(l),\n",
    "                        xy=(cl_df.loc[cl_df['labels'] == l, 'longitude'], \n",
    "                            cl_df.loc[cl_df['labels'] == l, 'latitude'])\n",
    "                )\n",
    "        # динамическая часть(стрелочки)\n",
    "        # они будут изменяться со временем\n",
    "        for first_label in lim_cl_df['labels']:\n",
    "            for second_label in lim_cl_df['labels']:\n",
    "                # расчитываем количество поездов в данный час\n",
    "                # из первого кластера во второй и из второго в первый\n",
    "                num_of_rides = len(df[(df['pickup_cluster'] == first_label)&\n",
    "                                     (df['dropoff_cluster'] == second_label)&\n",
    "                                     (df['pickup_hour'] == hour)])\n",
    "                # стрелка проводиться как и вектор по двум точкам\n",
    "                # первую задаем начальными координатами\n",
    "                # в качестве второй передаем разность от уже заданной\n",
    "                # до второй точки по обеим осям\n",
    "                dist_x = cl_df.longitude[cl_df['labels'] == first_label].values[0] - \\\n",
    "                        cl_df.longitude[cl_df['labels'] == second_label].values[0]\n",
    "                    \n",
    "                dist_y = cl_df.latitude[cl_df['labels'] == first_label].values[0] - \\\n",
    "                        cl_df.latitude[cl_df['labels'] == second_label].values[0]\n",
    "                # нормировка количества поездок производится по всем поездкам\n",
    "                pct = np.true_divide(num_of_rides, len(df))\n",
    "                # непосредственное создание объекта Arrow\n",
    "                # и его отрисовка\n",
    "                arr = plt.Arrow(cl_df.longitude[cl_df['labels'] == first_label].values, \n",
    "                            cl_df.latitude[cl_df['labels'] == first_label].values,\n",
    "                           -dist_x,\n",
    "                           -dist_y,\n",
    "                           edgecolor='white',\n",
    "                           width=strong*pct\n",
    "                        )\n",
    "                ax.add_patch(arr)\n",
    "                arr.set_facecolor('g')\n",
    "                ax.set_axis_off()\n",
    "    \n",
    "    ani = animation.FuncAnimation(fig,\n",
    "                                 animate,\n",
    "                                 sorted(df['pickup_hour'].unique()),\n",
    "                                 interval=1000\n",
    "                    )\n",
    "    # производим закрытие отрисованных графиков\n",
    "    plt.close()\n",
    "    # дириктори сохранения гифки\n",
    "    gif_path = GIF_PATH\n",
    "    # сохранение гифки\n",
    "    ani.save(gif_path,\n",
    "             writer='imagemagick',\n",
    "             fps=1\n",
    "        )\n",
    "    # открываем сохраненную гифку и производим ее дешифрование\n",
    "    # для дальнейшего URL и подстановки их в HTML\n",
    "    video = io.open(gif_path,\n",
    "                    'r+b'\n",
    "                ).read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return encoded \n",
    "\n",
    "encoded = trafic_animation()\n",
    "# производим отрисовку анимации\n",
    "HTML(data='''<img src=\"data:image/gif;base64,{0}\"type=\"gif\"/>'''.format(\n",
    "    encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# присмотримся к центру города\n",
    "encoded = trafic_animation(lon_ani_lim=LON_ANI_CENTER, \n",
    "                           lat_ani_lim=LAT_ANI_CENTER, \n",
    "                           strong=2\n",
    "                )\n",
    "HTML(data='''<img src=\"data:image/gif;base64,{0}\"type=\"gif\"/>'''.format(\n",
    "    encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Прелесть такого рода визуализации в том, что ее может проинтерпритировать даже ребенок.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## <center> Заключение"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Tensorflow довольно мощное API, которое хорошо подходит не только для обучения нейронных сетей. Хотя стоит отметит скудность документации(по сравнению с sklearn) по некоторым частям библиотеки. Одна из таких частей и была рассмотренна в данном тьюториале. Я так же надеюсь вам понравилась визуализации и вы влюбились в нее так же как и я когда впервые ее увидел. Если такого рода тьюториал вам понравится, то я подумаю о переносе его в виде статьи на хабрахабр и создании цикла такого рода статей.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-indent:20px;\">Спасибо за внимание!</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}