2018-06-11-climate-classification-with-neural-nets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Climate classification with neural networks\n",
    "\n",
    "The [Köppen Climate classification](https://en.wikipedia.org/wiki/Köppen_climate_classification) is a widely used climate classification system. It classifies locations around the world as climates like \"Tropical rainforest\" or \"Warm summer continental\".\n",
    "\n",
    "![By Peel, M. C., Finlayson, B. L., and McMahon, T. A.(University of Melbourne)Enhanced, modified, and vectorized by Ali Zifan. - Hydrology and Earth System Sciences: \"Updated world map of the Köppen-Geiger climate classification\" (Supplement)map in PDF (Institute for Veterinary Public Health)Legend explanation, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=47086879](images/2018-06-11-koppen.png)\n",
    "\n",
    "(Image from Wikipedia and [1])\n",
    "\n",
    "One funny thing about the Köppen classification is that it puts Portland, Oregon in the same group as San Francisco and in a very similar group to Los Angeles. I might be wrong,  but Southern California (comfortably walking outside in a t-shirt at 2am) seemed like a pretty different climate than Seattle (not seeing the sun for n months)!\n",
    "\n",
    "I wanted to try classifying climates of locations. In this post, I'll try to classify the climate of continental US weather stations based on the weather they recorded with the help of a neural net. I'll train a neural net on some task that also helps it learn vector representations for each station. Then I'll cluster the vector representations to cluster similar stations into climate classifications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data\n",
    "\n",
    "I used data from the [Global Historical Climatology Network](http://doi.org/10.7289/V5D21VHZ) [2, 3]. I used the subset of weather stations from the U.S. Historical Climatology Network.\n",
    "\n",
    "This gives 2.4G of data containing decades (sometimes over a century!) of daily weather reports from 1,218 stations around the US. It usually gives high temperatures, low temperatures, and precipitation, but also gives information about snow, wind, fog, evaporation rates, volcanic dust, tornados, etc.\n",
    "\n",
    "### Getting the data\n",
    "\n",
    "Wheee, let's download a few GBs of historical weather data. \n",
    "The [readme](ftp://ftp.ncdc.noaa.gov/pub/data/ghcn/daily/readme.txt) is super useful. \n",
    "The `tar` file for the US stations is located at `ftp://ftp.ncdc.noaa.gov/pub/data/ghcn/daily/ghcnd_hcn.tar.gz` (heads up, it uses an underscore, not a hyphen like the readme says!)\n",
    "The other useful file is `ftp://ftp.ncdc.noaa.gov/pub/data/ghcn/daily/ghcnd-stations.txt`, which contains coordinates and station names."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Weather stations\n",
    "\n",
    "If I go through the `.dly` files in `ghcnd_hcn/` folder, and look up the station names in `ghcnd-stations.txt`, I can plot the stations I have daily weather records for using [Basemap](https://github.com/matplotlib/basemap). (See \"Basemap\" below for code and details.)\n",
    "\n",
    "![](images/2018-06-11-stations.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "# helper functions you can skip over :D\n",
    "SAVE = True\n",
    "def maybe_save_plot(filename):\n",
    "    if SAVE:\n",
    "        plt.tight_layout()\n",
    "        plt.savefig('images/' + filename, bbox_inches=\"tight\")\n",
    "\n",
    "def hide_ticks(plot):\n",
    "    plot.axes.get_xaxis().set_visible(False)\n",
    "    plot.axes.get_yaxis().set_visible(False)        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reducing the data\n",
    "\n",
    "[The script I used for processing data is located here](https://github.com/jessstringham/notebooks/blob/master/scripts/process_weather_data.py).\n",
    "\n",
    "There are two issues with the dataset: it's a little large to easily load and manipulate in memory and some records are missing or are labeled as low-quality.\n",
    "I'd love to figure out how to use larger datasets or handle the low-quality data, but I'll save that for another post. \n",
    "Instead, I'll create a small subset I can comfortably load into memory. \n",
    "For each station, I'll sample up to 2000 daily weather reports, including the maximum temperature, minimum temperature, and precipitation.\n",
    "\n",
    "I limit the data in a few ways. I dropped data before 1990 to make the datasets more manageable.\n",
    "I also require all three weather values are not missing and don't have a quality issue.\n",
    "These may introduce bias. If I was doing real science instead of trying to make a pretty graph, I'd justify these decisions better!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading the dataset\n",
    "\n",
    "[See `scripts/process_weather_data.py`](https://github.com/jessstringham/notebooks/blob/master/scripts/process_weather_data.py) for details, but if you ran the command in this folder using `data/weather/data` as the output file, such as:\n",
    "\n",
    "    python scripts/process_weather_data.py [filtered .dly files, see process_weather_data] data/weather/data\n",
    "    \n",
    "then I think this code should work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2417066, 6)\n"
     ]
    }
   ],
   "source": [
    "DATA_PATH = 'data/weather'\n",
    "\n",
    "matrix_file = os.path.join(DATA_PATH, 'data/gsn-2000-TMAX-TMIN-PRCP.npz')\n",
    "\n",
    "# column labels\n",
    "STATION_ID_COL = 0\n",
    "MONTH_COL = 1\n",
    "DAY_COL = 2\n",
    "VAL_COLS_START = 3\n",
    "TMAX_COL = 3\n",
    "TMIN_COL = 4\n",
    "PRCP_COL = 5\n",
    "\n",
    "with np.load(matrix_file) as npz_data:\n",
    "    weather_data = npz_data['data'].astype(np.int32)\n",
    "print(weather_data.shape)\n",
    "\n",
    "# I decided to switch over to using the day of the year instead of two \n",
    "# eh, this isn't perfect (it assumes all months have 31 days), but it helps differentiate \n",
    "# the first of the month vs the last. \n",
    "weather_data_day_of_year_data = 31 * (weather_data[:, MONTH_COL] - 1) + (weather_data[:, DAY_COL] - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To give an idea of how this data looks, here's the number of examples per station, the minimum and maximum temperature.\n",
    "\n",
    "There are a few things I'm overlooking for now: the weather report values are always integers and precipitation is always positive. Precipitation has a larger range and is often 0. I'll end up converting the month and day into the approximate day of the year (e.g., 21 = January 21), which means January 1 and December 31 are considered far apart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1218\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "NUM_STATIONS = np.max(weather_data[:, STATION_ID_COL]) + 1\n",
    "print(NUM_STATIONS)\n",
    "\n",
    "fig, axs = plt.subplots(2, 2, figsize=(9, 9))\n",
    "\n",
    "axs[0][0].hist(weather_data[:, STATION_ID_COL], bins=NUM_STATIONS)\n",
    "axs[0][0].set_title('examples per station')\n",
    "axs[0][1].hist(weather_data[:, MONTH_COL], bins=12)\n",
    "axs[0][1].set_title('examples per month')\n",
    "\n",
    "axs[1][0].hist(weather_data[:, TMIN_COL], bins=range(-400, 400, 20), alpha=0.6, label='min')\n",
    "axs[1][0].hist(weather_data[:, TMAX_COL], bins=range(-400, 400, 20), alpha=0.6, label='max')\n",
    "axs[1][0].legend()\n",
    "axs[1][0].set_title('temperature')\n",
    "axs[1][1].hist(weather_data[:, PRCP_COL], bins=20)\n",
    "axs[1][1].set_title('precipitation')\n",
    "\n",
    "maybe_save_plot('2018-06-11-data')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural network\n",
    "\n",
    "The purpose of the neural network is to learn a good vector representation of the weather station. To do this, I'll set up a task that hopefully encourages the network to learn a good vector representation.\n",
    "\n",
    "The inputs are the *station_id* and *day of the year* (so the month and day, but the year is missing).\n",
    "\n",
    "The network needs to predict the *precipitation*, *high temperature* and *low temperature* for that day. I compare its prediction to an arbitrary year's actual weather and use how poorly it does to tell [TensorFlow](https://www.tensorflow.org) how to update the network parameters.\n",
    "\n",
    "To get the vector representation, I pass the station_id through an [embedding](https://www.tensorflow.org/programmers_guide/embedding) layer.\n",
    "Then I concatenate the day to make a bigger vector. I'll pass the station+day vector through a little neural network that needs to predict the three weather values. The full network looks something like this:\n",
    "\n",
    "![](images/2018-06-11-nn.png)\n",
    "\n",
    "In the image above, the weather data from U.S. Historical Climatology Network gives me the blue and green boxes. I'm using the blue boxes (station_id and day) as input and the green boxes (precipitation, high temperature, low temperature) as output. As I train the model, backpropagation will find better parameters for the orange boxes (the station vector representations and the neural network.) \n",
    "\n",
    "When I'm satisfied, I'll take the vector representation and use an unsupervised classifier on it\n",
    "I don't particularly care about the neural network learns. I'm just using it to learn the vector representations.\n",
    "Once I have the vector representations, I'll use [K-Means clustering](http://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html) to cluster stations that have similar vectors. These clusters will become my climate classification!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "# network parameters\n",
    "BATCH_SIZE = 50\n",
    "EMBEDDING_SIZE = 20\n",
    "HIDDEN_UNITS = 40\n",
    "\n",
    "# and classification parameters. How many climates I want.\n",
    "CLUSTER_NUMBER = 6\n",
    "\n",
    "\n",
    "# Tensorflow and classification logs\n",
    "LOG_PATH = os.path.join(DATA_PATH, 'tf_logs')\n",
    "\n",
    "TENSORFLOW_SUMMARY_FILE = os.path.join(LOG_PATH, 'tf_summary_{}')\n",
    "TENSORFLOW_CHECKPOINT_FILE = os.path.join(LOG_PATH, 'model.cpkt')\n",
    "STATION_CLASSIFICATION_FILE = os.path.join(LOG_PATH, 'station_classification_{run_id}_{step_i}.tsv')\n",
    "\n",
    "# load the stations file that process_weather_data.py saved. \n",
    "# This tells us what the first column's ids map to.\n",
    "with open(os.path.join(DATA_PATH, 'data/stations') )as f:\n",
    "    list_of_stations = [line.strip() for line in f.readlines()]\n",
    "\n",
    "# hiding this code block in blog post"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the network\n",
    "\n",
    "Below I implement the network in TensorFlow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "# set up the batch and input data\n",
    "InputBatch = namedtuple('InputBatch', [\n",
    "    'station_ids',\n",
    "    'month_day',\n",
    "])\n",
    "\n",
    "# let's try out tf.data! set up the dataset and iterator.\n",
    "with tf.variable_scope('data_loading'):\n",
    "    station_id_placeholder = tf.placeholder(tf.int32, (None,), name='station_id_placeholder')\n",
    "    month_day_placeholder = tf.placeholder(tf.float32, (None,), name='month_day_placeholder')  # day of the year\n",
    "    target_placeholder = tf.placeholder(tf.float32, (None, 3), name='target_placeholder')\n",
    "    \n",
    "    dataset = tf.data.Dataset.from_tensor_slices((\n",
    "        InputBatch(\n",
    "            station_ids=station_id_placeholder,\n",
    "            month_day=month_day_placeholder,\n",
    "        ),\n",
    "        target_placeholder # and grab all the weather values\n",
    "    ))\\\n",
    "    .shuffle(buffer_size=10000)\\\n",
    "    .repeat()\\\n",
    "    .batch(BATCH_SIZE)\n",
    "    \n",
    "    iterator = dataset.make_initializable_iterator()\n",
    "    input_batch, targets = iterator.get_next()\n",
    "\n",
    "# Feed the station id through the embedding. This embeddings variable\n",
    "# is the whole point of this network!\n",
    "embeddings = tf.Variable(\n",
    "    tf.random_uniform(\n",
    "        [NUM_STATIONS, EMBEDDING_SIZE], -1.0, 1.0),\n",
    "    dtype=tf.float32,\n",
    "    name='station_embeddings'\n",
    ")\n",
    "\n",
    "embedded_stations = tf.nn.embedding_lookup(embeddings, input_batch.station_ids)\n",
    "\n",
    "# Drop in the month/day data\n",
    "station_and_day = tf.concat([\n",
    "    embedded_stations,\n",
    "    tf.expand_dims(input_batch.month_day, 1),\n",
    "], axis=1)\n",
    "\n",
    "# Now build a little network that can learn to predict the weather\n",
    "dense_layer = tf.contrib.layers.fully_connected(station_and_day, num_outputs=HIDDEN_UNITS)\n",
    "with tf.variable_scope('prediction'):\n",
    "    prediction = tf.contrib.layers.fully_connected(\n",
    "        dense_layer, \n",
    "        num_outputs=3, \n",
    "        activation_fn=None, # don't use an activation on prediction\n",
    "    ) \n",
    "    \n",
    "# Set up loss and optimizer\n",
    "loss_op = tf.losses.mean_squared_error(prediction, targets)\n",
    "tf.summary.scalar('loss', loss_op)\n",
    "train_op = tf.train.AdamOptimizer().minimize(loss_op)\n",
    "\n",
    "# And additional tensorflow fun things\n",
    "merged_summaries = tf.summary.merge_all()\n",
    "init = tf.global_variables_initializer()\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clustering\n",
    "\n",
    "As the model is training, I'll occasionally cluster the stations and save the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_classification(save_location, trained_embeddings):\n",
    "    kmeans = KMeans(n_clusters=CLUSTER_NUMBER, random_state=0).fit(trained_embeddings)\n",
    "\n",
    "    with open(save_location, 'w') as f:\n",
    "        for station, label in zip(stations, kmeans.labels_):\n",
    "            f.write('{}\\t{}\\n'.format(station, label))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I can start training! You can monitor the job through [TensorBoard](https://www.tensorflow.org/programmers_guide/summaries_and_tensorboard). \n",
    "\n",
    "### Deciding when to stop\n",
    "\n",
    "If I had a metric for how good the climate classifications were, I could use the metric to decide when the model is done training. For the purpose of this post (again, pretty pictures), I'll just train the model long enough to run through the dataset a few times. \n",
    "\n",
    "(I have 2.4M weather reports. Since I'm using batch size of 50, it will take around 50K steps will go through the dataset once.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting run 1528762114\n",
      "step: 0 last loss: 18228.15625\n",
      "step: 20000 last loss: 2900.906494140625\n",
      "step: 40000 last loss: 4732.07080078125\n",
      "step: 60000 last loss: 5567.47607421875\n",
      "step: 80000 last loss: 4267.83740234375\n",
      "step: 100000 last loss: 4418.9130859375\n",
      "step: 120000 last loss: 1552.070556640625\n",
      "step: 140000 last loss: 4438.02490234375\n",
      "step: 160000 last loss: 9913.9892578125\n",
      "step: 180000 last loss: 3961.80126953125\n",
      "step: 200000 last loss: 3075.747802734375\n",
      "step: 220000 last loss: 4135.208984375\n",
      "step: 240000 last loss: 3247.721923828125\n",
      "step: 260000 last loss: 2721.795654296875\n",
      "step: 280000 last loss: 4562.06396484375\n",
      "step: 300000 last loss: 3180.221923828125\n",
      "step: 320000 last loss: 3987.0361328125\n",
      "step: 340000 last loss: 3438.39453125\n",
      "step: 360000 last loss: 2264.7490234375\n",
      "step: 380000 last loss: 2647.287841796875\n",
      "step: 400000 last loss: 2951.9794921875\n",
      "step: 420000 last loss: 10272.5322265625\n",
      "step: 440000 last loss: 2140.482666015625\n",
      "step: 460000 last loss: 4016.078857421875\n",
      "step: 480000 last loss: 2924.016357421875\n",
      "step: 500000 last loss: 3251.81005859375\n",
      "step: 520000 last loss: 2416.012939453125\n",
      "step: 540000 last loss: 3573.53759765625\n",
      "step: 560000 last loss: 1960.750244140625\n",
      "step: 580000 last loss: 3008.0576171875\n",
      "step: 600000 last loss: 4468.04833984375\n",
      "step: 620000 last loss: 2047.403564453125\n",
      "step: 640000 last loss: 2752.06787109375\n",
      "step: 660000 last loss: 1762.992919921875\n",
      "step: 680000 last loss: 4159.666015625\n",
      "step: 700000 last loss: 3023.664794921875\n",
      "step: 720000 last loss: 5002.65576171875\n",
      "step: 740000 last loss: 4868.14453125\n",
      "step: 760000 last loss: 2485.292724609375\n",
      "step: 780000 last loss: 4120.93994140625\n",
      "step: 800000 last loss: 2287.0546875\n",
      "step: 820000 last loss: 3997.859130859375\n",
      "step: 840000 last loss: 2466.212646484375\n",
      "step: 860000 last loss: 2791.95263671875\n",
      "step: 880000 last loss: 1766.3455810546875\n",
      "step: 900000 last loss: 3404.13134765625\n",
      "step: 920000 last loss: 3744.648681640625\n",
      "step: 940000 last loss: 2705.738037109375\n",
      "step: 960000 last loss: 6594.17626953125\n",
      "step: 980000 last loss: 2584.0029296875\n"
     ]
    }
   ],
   "source": [
    "MAX_STEPS = 1000000\n",
    "CHECKPOINT_EVERY_N_STEPS = 20000\n",
    "\n",
    "run_id = int(time.time())\n",
    "print('starting run {}'.format(run_id))\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init)   \n",
    "    sess.run(iterator.initializer, {\n",
    "        station_id_placeholder: weather_data[:, STATION_ID_COL],\n",
    "        month_day_placeholder: weather_data_day_of_year_data,\n",
    "        target_placeholder: weather_data[:, VAL_COLS_START:],\n",
    "    })\n",
    "    \n",
    "    writer = tf.summary.FileWriter(TENSORFLOW_SUMMARY_FILE.format(run_id), sess.graph)\n",
    "    \n",
    "    for step_i in range(MAX_STEPS):\n",
    "        summary, loss, _ = sess.run([merged_summaries, loss_op, train_op])\n",
    "        writer.add_summary(summary, global_step=step_i)\n",
    "        if step_i % CHECKPOINT_EVERY_N_STEPS == 0:\n",
    "            print('step: {} last loss: {}'.format(step_i, loss))\n",
    "            saver.save(sess, TENSORFLOW_CHECKPOINT_FILE)\n",
    "            \n",
    "            # extract and save the classification\n",
    "            embedding_values = sess.run(embeddings)\n",
    "            save_classification(\n",
    "                STATION_CLASSIFICATION_FILE.format(run_id=run_id, step_i=step_i),\n",
    "                embedding_values,\n",
    "            )\n",
    "            \n",
    "writer.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Climate!\n",
    "\n",
    "Here's the last saved figure from a run that used 6 classes.\n",
    "\n",
    "![](images/2018-06-11-us.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Starting with a disclaimer: it's really easy to start seeing patterns in noise!\n",
    "\n",
    "That said, I think it's neat that places near each other were assigned to the same group! The neural network didn't know about the latitude or longitude of stations, only random weather reports from those stations.\n",
    "\n",
    "It's also neat that parts of the map look to me like they follow Köppen! The east is split up by latitude into brown, pink, and green. The West coast gets its own and the West gets another.\n",
    "\n",
    "Though Portland and Seattle still share California's climate. It's also probably weird that the humid South and the arid South West all have the same climate. The Yellow climate also looks a little arbitrary. It doesn't pick up mountains."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Etc\n",
    "\n",
    "And that's it! I did a proof of concept of classifying climate with neural nets!\n",
    "Here are a few other things I found during this project.\n",
    "\n",
    "### Year-long predictions by climate\n",
    "\n",
    "The point of this model was to train the embeddings. But the model also learned to predict the weather for each station. For fun, let's check them out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def predict_a_year(station_ids):\n",
    "    '''Given a list of station_ids, predict a year of weather for each of them'''\n",
    "    # shh, just pretend all the months have 31 days\n",
    "    DAY_COUNT = 31 * 12\n",
    "    all_days = np.arange(DAY_COUNT)\n",
    "    \n",
    "    station_values = []\n",
    "    with tf.Session() as sess:\n",
    "        saver.restore(sess, TENSORFLOW_CHECKPOINT_FILE)\n",
    "        \n",
    "        for station_id in station_ids:\n",
    "            station_ids = station_id * np.ones((DAY_COUNT,))\n",
    "            \n",
    "            sample_input_batch = InputBatch(\n",
    "                station_ids=station_ids,\n",
    "                month_day=all_days,\n",
    "            )\n",
    "            \n",
    "            month_day, pred = sess.run(\n",
    "                [input_batch.month_day, prediction],\n",
    "                {input_batch: sample_input_batch}\n",
    "            )\n",
    "            \n",
    "            station_values.append((month_day, pred))\n",
    "            \n",
    "    return station_values\n",
    "\n",
    "# Let's grab all of the stations for each climate. I got these numbers using this script:\n",
    "#\n",
    "#     for class_i in {0..5}; do\n",
    "#         cat tf_logs/station_classification_1528754676_980000.tsv\\\n",
    "#            | awk -F\\t -v class=$class_i '{ if ($2 == class) print NR - 1 }' \\\n",
    "#            | paste -s -d\",\" -;\n",
    "#     done\n",
    "#     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from data/weather/tf_logs/model.cpkt\n",
      "INFO:tensorflow:Restoring parameters from data/weather/tf_logs/model.cpkt\n",
      "INFO:tensorflow:Restoring parameters from data/weather/tf_logs/model.cpkt\n",
      "INFO:tensorflow:Restoring parameters from data/weather/tf_logs/model.cpkt\n",
      "INFO:tensorflow:Restoring parameters from data/weather/tf_logs/model.cpkt\n",
      "INFO:tensorflow:Restoring parameters from data/weather/tf_logs/model.cpkt\n"
     ]
    }
   ],
   "source": [
    "PRED_TMAX_COL = 0\n",
    "PRED_TMIN_COL = 1\n",
    "PRED_PRCP_COL = 2\n",
    "\n",
    "stations_per_climate_to_plot = [\n",
    "    [1,3,42,60,108,111,114,121,125,155,180,181,197,201,280,286,309,310,319,344,346,348,384,386,422,439,495,513,560,601,606,617,664,669,675,676,682,697,704,705,710,716,733,794,796,832,838,895,930,974,981,987,1039,1098,1105,1163,1164,1189,1196],\n",
    "    [7,12,18,23,25,31,33,35,45,47,50,58,61,62,64,71,80,103,115,116,117,118,120,127,128,129,131,135,137,140,149,154,156,161,164,168,171,183,194,210,213,214,230,232,234,238,239,245,247,251,257,258,259,274,283,297,301,302,313,322,328,336,338,341,342,345,349,351,354,355,357,368,369,381,383,389,391,405,408,411,412,413,416,417,418,423,427,431,433,434,436,446,462,463,467,468,470,471,473,478,480,497,498,509,510,511,530,534,537,542,553,562,564,577,579,585,592,598,603,608,610,615,625,627,628,630,631,632,640,648,665,666,667,670,671,678,679,691,700,713,715,721,722,725,746,755,763,778,780,813,816,817,818,821,828,843,846,852,859,863,870,880,912,917,919,920,921,925,927,932,944,947,952,956,958,959,966,973,990,992,997,1002,1004,1014,1016,1018,1024,1027,1028,1030,1031,1047,1051,1054,1055,1057,1062,1065,1087,1096,1106,1111,1116,1121,1125,1126,1142,1146,1150,1158,1159,1160,1168,1182,1191,1193,1197,1202,1214],\n",
    "    [22,159,208,248,252,254,256,268,269,281,290,291,318,320,326,329,358,361,367,379,393,400,402,406,419,430,459,474,475,482,483,484,486,489,492,502,508,519,523,524,528,536,555,558,567,574,581,582,593,599,626,633,634,639,642,645,649,650,657,662,677,684,693,695,701,707,709,714,719,728,729,731,732,741,744,761,765,769,770,787,788,793,800,814,819,830,834,835,836,853,855,857,861,862,864,867,875,884,892,894,900,903,908,913,915,916,918,929,941,943,949,953,965,968,978,982,983,988,994,998,1008,1011,1013,1015,1020,1021,1022,1034,1035,1037,1038,1040,1044,1049,1050,1052,1063,1068,1070,1076,1078,1081,1084,1092,1102,1113,1122,1124,1127,1132,1135,1141,1143,1147,1152,1154,1155,1156,1162,1169,1170,1172,1185,1188,1204,1209,1210,1212,1213],\n",
    "    [0,2,11,15,20,21,27,29,32,34,36,38,40,49,52,56,72,73,79,82,83,84,90,91,94,96,101,102,104,106,132,136,139,142,143,145,148,152,153,162,163,170,172,174,175,177,178,179,186,187,196,198,202,203,204,205,207,209,216,219,221,223,226,227,229,231,235,236,241,242,243,249,250,255,260,263,264,266,270,275,276,277,278,282,284,288,289,292,293,294,295,298,299,305,306,308,312,314,315,317,323,324,325,327,330,332,333,335,337,339,347,352,356,362,363,364,366,374,375,380,385,388,390,392,394,397,398,399,401,403,404,407,409,410,421,424,425,429,435,438,441,447,448,451,452,454,455,456,458,464,465,466,469,472,477,481,485,493,494,496,501,503,504,505,512,515,517,521,522,527,531,533,535,538,540,546,552,556,557,563,568,569,570,573,576,578,580,583,586,587,589,594,595,600,602,604,607,611,612,614,616,620,622,623,635,636,637,641,644,646,651,661,663,668,672,673,674,685,686,688,692,696,698,699,706,708,711,712,718,723,726,727,734,735,737,738,739,743,747,748,751,752,753,757,762,764,766,767,768,772,777,779,781,783,785,791,798,801,802,804,805,810,815,822,826,827,839,841,842,847,851,865,868,873,876,878,879,882,888,889,891,897,898,899,905,907,914,923,924,926,931,933,934,935,940,945,948,951,963,976,977,980,984,989,993,995,996,1006,1007,1029,1032,1033,1041,1042,1043,1056,1059,1061,1067,1074,1079,1080,1088,1091,1094,1095,1097,1099,1100,1101,1107,1110,1115,1130,1131,1133,1134,1140,1144,1149,1157,1166,1179,1180,1183,1184,1190,1195,1199,1200,1203,1208,1211,1216],\n",
    "    [6,8,9,10,13,14,16,17,19,24,26,37,41,43,44,46,48,51,53,54,57,63,65,67,68,69,75,77,78,81,85,86,87,88,89,92,93,97,99,109,110,112,113,122,126,130,133,134,144,147,151,157,165,169,173,176,182,185,189,190,192,193,195,211,212,217,218,224,228,237,240,265,267,272,279,296,303,304,307,311,321,331,340,350,353,359,360,365,373,378,387,396,414,420,426,437,444,453,457,461,476,487,490,500,507,514,520,526,529,532,539,547,549,554,559,561,575,596,597,605,613,619,629,638,654,655,656,659,660,680,681,683,687,690,702,703,717,736,740,742,749,754,756,759,760,771,782,784,795,803,807,812,823,825,829,831,840,848,850,854,858,881,883,885,886,887,896,901,906,910,911,928,936,937,939,946,950,954,957,961,964,967,970,979,985,999,1000,1001,1003,1005,1009,1010,1012,1019,1025,1026,1045,1046,1048,1053,1064,1069,1071,1072,1073,1075,1077,1085,1089,1093,1104,1109,1112,1114,1117,1120,1123,1128,1129,1136,1137,1138,1139,1145,1148,1161,1165,1171,1174,1175,1176,1177,1181,1186,1187,1192,1194,1205,1206,1207,1217],\n",
    "    [4,5,28,30,39,55,59,66,70,74,76,95,98,100,105,107,119,123,124,138,141,146,150,158,160,166,167,184,188,191,199,200,206,215,220,222,225,233,244,246,253,261,262,271,273,285,287,300,316,334,343,370,371,372,376,377,382,395,415,428,432,440,442,443,445,449,450,460,479,488,491,499,506,516,518,525,541,543,544,545,548,550,551,565,566,571,572,584,588,590,591,609,618,621,624,643,647,652,653,658,689,694,720,724,730,745,750,758,773,774,775,776,786,789,790,792,797,799,806,808,809,811,820,824,833,837,844,845,849,856,860,866,869,871,872,874,877,890,893,902,904,909,922,938,942,955,960,962,969,971,972,975,986,991,1017,1023,1036,1058,1060,1066,1082,1083,1086,1090,1103,1108,1118,1119,1151,1153,1167,1173,1178,1198,1201,1215],\n",
    "]\n",
    "climate_predictions = []\n",
    "for climate_stations in stations_per_climate_to_plot:\n",
    "    climate_predictions.append(predict_a_year(climate_stations))\n",
    "    \n",
    "\n",
    "climate_id_to_color = ['red', 'blue', 'orange', 'maroon', 'orchid', 'darkcyan']    \n",
    "    \n",
    "# hiding this code block in blog post"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAADQCAYAAAAK/RswAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xd0VNXax/Hvk0YSWggEAiEh9N5DqCq9iAoiSBGkg4jt2r2W67Vce8cCSG+CiKCAgCCKdEILhN7TCAnpvcx+/zjDfaOXEiDJmbI/a81yZnJmzm9k5swz++wiSik0TdM0TdMciYvZATRN0zRN04qbLnA0TdM0TXM4usDRNE3TNM3h6AJH0zRN0zSHowscTdM0TdMcji5wNE3TNE1zOLrA0TRN02yOiDwkIhuKe9ub2H+6iNQpzufUSpfoeXAcl4icAyYopTaaneV2iMjrQD2l1Eizs2iaZvtERAH1lVKnirj978BCpdS3JRpMK1W6BUczlYi4OcI+NE37X/qzp5lJFzgOSkQWAEHAz9am1udFpIOIbBeRZBE5KCJdC23/u4i8Zf17uoj8LCKVRWSRiKSKyB4RCS60vRKRJ0TkjIgkiMgHIuJS6O/jROSoiCSJyHoRqfW3x04VkZPASet9n4lIpHVfe0XkDuv9fYF/AkOtuQ5a7z8nIj0LPefrIrLQej3Yuo/xInIB+M16/zVfv6ZpRWf9/L0kIkesn/E5IuIpIl1FJEpEXhCRi8Ac6/b3iMgB62dvu4i0KPRcgSKyQkTiReSyiEyz3j9GRLYW2u6ax5zC24rIFutDDlqPGUNFpJKIrLbuI8l6vaZ1+7eBO4Bp1u2nFdpfPev1iiIy3/r48yLyyt/3LSIfWp/7rIj0K9l/Aa1IlFL64qAX4BzQ03o9ALgM3I1R2Pay3vaz/v134BRQF6gIHAFOAD0BN2A+MKfQcytgM+CLUUidwDgdBjDA+lyNrY99Bdj+t8f+an2sl/W+kUBl6/bPABcBT+vfXsdoPr7qa/v7NkCwdR/zgbKA141ev77oi74U/WL9/B0GAq2f423AW0BXIB94Dyhj/ey1Bi4B7QFXYLT18WWstw8Cn1g/q55AF+s+xgBbC+3zesecq21br9DtysADgDdQHvgeWFno779fea6rPYf1WLLK+thg677HF9p3HjDR+nqmADFYu4Doi3kX3YLjPEYCa5VSa5VSFqXUr0AYxhf+FXOUUqeVUinAL8BppdRGpVQ+xgGh9d+e8z2lVKJS6gLwKTDcev8jwDtKqaPWx/4HaFW4Fcf690SlVBaAUmqhUuqyUipfKfURxsGv4W2+5teVUhnWfRTl9WuaVnTTlFKRSqlE4G3+//NvAf6llMqxfvYmAdOVUruUUgVKqXlADtABCAVqAM9ZP6vZSqmtV9nXFdc65lyX9djyg1IqUymVZs17V1EeKyKuwDDgJaVUmlLqHPARMKrQZueVUjOVUgXAPKA6UK0oz6+VHF3gOI9awBBrE3GyiCQDXTA+iFfEFbqedZXb5f72nJGFrp/HOFBd2ddnhfaTCAhGK8rVHouIPGs9pZVifUxFoMpNvcL/VXgfRXn9mqYV3bU+//FKqexCf6sFPPO3z16gdftAjOIg/zb3eV0i4i0i062nl1KBLYCPtXi5kSqAu3V/hfdd+Hh28coVpVSm9erfj5daKdMdwBxb4SFykcACpdTEYnz+QCDCej0Io1n2yr7eVkotKko2a3+b54EeQIRSyiIiSRhF0V+2LSQDo7n5Cv/r7YOSef2a5swCC10v/Pn/++f1yvHg7b8/gYh0BIJExK2IRc61jjk38gxGi3B7pdRFEWkF7Of6x5grEjBOQdXCOHV/Zd/RRdy3ZhLdguPY4oAr8zgsBO4VkT4i4lqoQ2DN23j+56yd9wKBJ4Gl1vu/AV4Skabw3w56Q67zPOUxztvHA24i8hpQ4W+vI7hwJ2bgADBMRNxFJAQYfIOsJfH6Nc2ZTRWRmiLiC7zM/3/+/24m8IiItBdDWRHpLyLlgd1ALPCu9X5PEel8nX1e65jzd4WPfWAcY7KAZGvef91g+/+ynnZaBrwtIuWtp9qfxjimaDZMFziO7R3gFWuT8FCMzr//xCgkIoHnuL33wCpgL0axsQaYBaCU+hGjk+F31ubgw8D1RhWsB9ZhdNw7D2Tz16bo763/vSwi+6zXX8XoEJ0E/BtYfL2gSqlIiv/1a5ozWwxsAM4ApzE6Gf8PpVQYRgfcaRif11MYHXOvFA/3AvWAC0AUxrHqWq56zLmK14F51lNiD2L01/HCaI3ZiXG8KewzYLB1FNTnV3m+xzFajc8AW62vffZ1cmo2QE/0p90SucmJtDRNcxxiwiSi+pij3Sz961XTNE3TNIejCxxN0zRN0xyOPkWlaZqmaZrD0S04mqZpmqY5HJuYB6dKlSoqODjY7BiaphWjvXv3Jiil/MzOoY8vmuZYinpssYkCJzg4mLCwMLNjaJpWjETk/I23Knn6+KJpjqWoxxZ9ikrTNE3TNIejCxxN02yWddbp/SKy2nq7tojsEpFTIrJURDzMzqhpmm3SBY6mabbsSeBoodvvAZ8opephzIo73pRUmqbZPF3gaJpmk6zrhPUHvrXeFqA7sNy6yTxgoDnpNE2zdbrA0TTNVn2Kscq8xXq7MpBcaNXpKCDgag8UkUkiEiYiYfHx8UXeoZ4XTNMch02MotK060nPyWf94YusPBDNrjOJiECtyt7Ur1qehv7lub91AIG+3mbH1IqRiNwDXFJK7RWRrjf7eKXUDGAGQEhIyA2rlpSsPF5bdZjV4bGUcXOhgqc7IcGVeHtgcyp6u990fk3TzKcLHM1mHYlJZcaW06yLuEh2noVAXy8e6hCEqwjnLmdwOCaFtYdj+XzTSQa3rcmjXesRVFkXOg6iM3CfiNwNeAIVMFZ89hERN2srTk0gujh2VtbDlTPxGTwYEkhZD1cSM3L5OTyG5Mw8FowPxTg7pmmaPdEFjmZz9l9I4ovfTvHbsUuUK+PG4LY1ub91TdoE+fzPF01sShbf/H6aJXsi+X5vFINaB/BY93rUqlzWpPRacVBKvQS8BGBtwXlWKfWQiHwPDAa+A0YDq4pjf26uLqyc2hlXl/9/f7WpVYlXVh5mzaFY7mlRozh2o2laKdIFjmZTfj4Yw5Pf7cfH24NnezdgVMdgKnpd+xRB9Ype/HtAM6Z0rcc3f5xmye4LrNgfzcBWAbzQryFVy3uWYnqtFLwAfCcibwH7gVnF9cSFixuAEaFBzN1+ji82neLuZtVxcdGtOJpmT3QnY81mrD0Uy1NLDxBSy5ctz3fjse71r1vcFOZf0ZPX72vKn893Y0ynYFaHx9Dv0z/ZfTaxhFNrJU0p9btS6h7r9TNKqVClVD2l1BClVE5J7dfFRZjarS7H49LYeDSupHajaVoJ0QWOZhPWHb7IE0v20zrQhzlj21GuzK01Llat4Mmr9zRh9eNdqOjtzvi5ezgam1rMaTVncW+LGgT5evPl5lN6hJWm2Rld4Gim2346gceX7KNFzYrMHRdK2VssbgqrX608C8e3x7uMK2Pn7CEmOasYkmrOxs3VhSld63IwKoU/TyaYHUfTtJugCxzNVCfi0pi8YC+1q5RlztjQW265uZoaPl7MHRtKRk4+Y+bsJiUrr9ieW3Meg9oE4F/Bk2mbT5kdRdO0m6ALHM00l1KzGTtnD57urswe067I/W1uRuPqFZg+qi1nEzKYND+MnPyCYt+H5tjKuLky+a467D6byK4zl82Oo2laEekCRzNFRk4+4+btISkzlzlj2lGzUsnNX9OpXhU+HNKSXWcTeWbZQSwW3ZdCuznD2gVRuayHbsXRNDuiCxyt1OUXWHhs8T6Oxqbx5Yg2NAuoWOL7HNAqgBf7NWJ1eCzvrjtW4vvTHIuXhysT7qjDnycTOBiZbHYcTXMoBRZFUkZusT+vLnC0UqWU4l8/RbD5eDxvDGhKt0ZVS23fk++sw8MdazFjyxnmbDtbavvVHMPIDkFU9HLXrTiaVgwKLIqdZy7z6srDtP/PJl5ddbjY96En+tNK1fQtZ1i06wKP3FWXh9rXKtV9iwj/urcpcanZvLH6CP4VPOnXvHqpZtDsV3lPd8Z0CuazTSc5djGVRv4VzI6kaXbFYlHsvZDE6oMxrD18kfi0HDzdXejRqBoDWl113dzbogscrdT8fDCGd385xr0ta/B8n4amZHB1ET4b1pqHvt3Fk0sPULlcGUJr+5qSRbM/YzsH8+2fZ/hy82m+GN7a7DiaZvMsFsX+yCRWh8ey9lAscak5lHFzoXujqvRvUZ3ujari7VEypcgNn1VEPIEtQBnr9suVUv8SkdoY68FUBvYCo5RSuSJSBpgPtAUuA0OVUudKJL1mN3ZbO/iGBvvyweAWpk577+nuyrcPh/DA19uZOD+MH6Z0pF7V8qbl0eyHj7cHIzvWYuaWM/yjZ33q+JUzO5Km2RylFPsjk1ljLWpiU7LxcHOhawM/+reoTo/G1Yp1SpBrKUofnBygu1KqJdAK6CsiHYD3gE+UUvWAJGC8dfvxQJL1/k+s22lO7HR8OhPnh1HT14sZD7fF093V7EhUKuvBvHGhuLu6MHr2Hi6lZpsdSbMTE7rUwd3Vha9/P212FE2zGUopDkYm85+1R+ny3mYGfbWdBTvO07RGRT4d2oq9r/RkxsMhDGgVUCrFDRShBUcZ85OnW2+6Wy8K6A6MsN4/D3gd+BoYYL0OsByYJiKi9DznTikhPYexc/bg5iLMHROKj7eH2ZH+K9DXmzlj2jF0xg7GzNnD0skdKO9Z/HPxaI7Fr3wZhocGsXDneZ7sWb9EpzjQNFumlOJwdCqrD8WwJjyWqKQs3F2FO+r78UzvBvRsUo0KJh5Ti1RGiYgrxmmoesCXwGkgWSmVb90kCrjSQygAiARQSuWLSArGaayEvz3nJGASQFBQ0O29Cs0mZeUWMH5eGJfSslkysQNBlW3vi6B5zYp89VAbxs8L49FF+5g1uh0ebnpwoXZ9k+6sw6Jd55n+xxneHNjM7DiaVmqUUkTEpLLmUCxrwmO5kJiJm4vQpX4VnuxRn95N/KnobRs/FItU4CilCoBWIuID/Ag0ut0dK6VmADMAQkJCdOuOgymwKJ74bj/hUclMH9mW1kGVzI50TV0bVuWdQc15fnk4L64I56MhLRExr4+QZvtq+HjxQJuaLA2L5PHu9ahawdPsSJpWYpRSHLuYxprwWNYciuVsQgauLkLnelV4rFs9ejetZlOt81fc1IkwpVSyiGwGOgI+IuJmbcWpCURbN4sGAoEoEXEDKmJ0NtachFKKN36O4Ncjcbx+bxN6N/U3O9INPRgSSGxyNp9sPEGNil48a9IoL81wncENc4G7gBTrpmOUUgfMyDila12WhUUy888zvNy/iRkRNK3EKKU4EZfOmvAYVh+K5Ux8Bi4CnepWYfKddejd1B/fsrZX1BRWlFFUfkCetbjxAnphdBzeDAzGGEk1GlhlfchP1ts7rH//Tfe/cR5ZuQU8t/wgq8NjmdClNmM61zY7UpE90aMeF1OzmLb5FNV9PEt9nh7tL64MbkgXEXdgq4j8Yv3bc0qp5SZmA6BW5bIMaBXAwp0XmNK1ns0f7DWtKE7GpbHa2lJz6lI6LgId6lRmfJfa9G3qT+VyZcyOWGRFacGpDsyz9sNxAZYppVaLyBHgOxF5C9gPzLJuPwtYICKngERgWAnk1mxQdHIWk+aHcSQ2lRf7NWLynXXMjnRTRIQ3BzQjLjWHV1cepmp5T3o1qWZ2LKd0ncENNuXRrnX5cX80s7ee1a1+mt06HZ9unH4Kj+V4XBoi0L62L6M7NaNvU3/8yttPUVOY2ELjSkhIiAoLCzM7hnYb9pxLZMrCveTkWfhseCu6N7LfwiAzN59hM3ZyIi6NJRM72HT/IVsmInuVUiG38fi/DG5QSr1gPUXVEaOFZxPwolIq5yqPLTyIoe358+dvNcYNTVm4l60nE9j6YncqetlG50pNu5GkjFy+3xvJqgMxRMSkIgLtavnSv0V1+jXzt+l+ZUU9tujhItpt+273BUbM3Em5Mm78OLWTXRc3AN4ebswe046q5T0ZPy+MswkZZkdySkqpAqVUK4w+fqEi0gx4CWOQQzvAF3jhGo+doZQKUUqF+Pn5lWjOqd3qkZaTz4Id50p0P5pWXCwWxcOzd/Oftcdwc3Xh1XuasOPFHix7pCOjOwXbdHFzM3SBo90ypRQfrj/OiysO0aFOZVZN7eIwMwJXKVeGeeNCARgzZzcJ6f/TSKCVEqVUMkafv75KqVhlyAHmAKHmpoNmARXp1tCPWVvPkpmbf+MHaJrJVuyP5lB0Ch8/2JJVUzszvktt/Cs6RlFTmC5wtFuilOK9dceZtvkUw0MDmTOmnc3MfVBcalcpy6zRIcSlZjN+7h795VWKRMTPOi0FhQY3HBOR6tb7BBgIFP8SxLfgse71SMrMY/GuC2ZH0bTryszN54P1x2gZ6MP9rYt/gUtbogsc7aYppXjnl2N888dpHmofxNsDm+Pm6phvpdZBlfhieBsORafw2OL95BdYzI7kLKoDm0UkHNgD/KqUWg0sEpFDwCGgCvCWiRn/q20tXzrU8eXbP8+Sp98jmg2bueWsMZCif2OHn+/LMb+VtBKjlOLN1UeZseUMozvW4q2BzUxdOLM09GpSjTcGNOO3Y5d4ddVhbKFjvqNTSoUrpVorpVoopZoppd6w3t9dKdXcet9IpVT6jZ6rtEy8ow4XU7NZeyjW7CiadlVxqdl888dp+jevTkiwr9lxSpwucLQiU0rx75+PMHvbWcZ2Dub1+5o6/C+AK0Z2qMXUbnVZsjuSL347ZXYczQZ1a1iVOlXKMmvrWV0Eazbpw/XHKbAoXuh724sR2AVd4GhFYrEoXlsVwdzt55jQpTav3dPEaYqbK57t3ZBBbQL4+NcTLAuLNDuOZmNcXISxXWoTHpVC2Pkks+No2l9ExKSwfF8UYzoH2+S6gCVBFzjaDVksildWHWbBzvNMvrMOLzvBudurERHeHdSCO+pX4aUVh/jjRLzZkTQb80CbACp6uTPrz7NmR9G0/1JK8faao/h4uTO1Wz2z45QaXeBo12WxKP754yEW77rAlK51ebFfI6csbq7wcHPhq4fa0LBaeaYs3Mvh6JQbP0hzGt4eboxoH8SGIxeJTMw0O46mAfDbsUtsP32Zp3o2cKrJKHWBo11TgUXxwg/hfLfHWDH5+T4Nnbq4uaK8pztzxrajkrcHY+bs0V9k2l+M7hiMiwhztp0zO4qmkVdg4e21R6njV5YR7YPMjlOqdIGjXVWBRfHc8oN8vzeKJ3vU5+leDXRxU0i1Cp7MG9eOvAILo+fsJikj1+xImo3wr+hJ/xbVWbrnAqnZeWbH0Zzc4l0XOBOfwT/7NcbdQafzuBbnerVakRRYFM9+f5AV+6L5R88G/EMXN1dVr2p5vh0dQlRSFhPmh5GdV2B2JM1GjO9Sm4zcApbt0Z3RNfOkZOXx6cYTdKpbmR6Nq5odp9TpAkf7i/wCC/9YeoAf90fzXJ+GPNmzvtmRbFq7YF8+G9qKfReSePK7/RRY9PBgDVrU9KFdcCXmbDunJ4fUTPPl5lMkZ+U57cAQXeBo/5VXYOHJpQf46WAML/Rt5FS97W9Hv+bVebV/E9ZHxPHGzxF6DhQNMFpxopOz2HAkzuwomhO6cDmTudvOMbhNTZrWqGh2HFPoAkcDjOLmiSX7WRMeyz/vbsSUrnXNjmRXxnWpzcQ7ajNvx3mmbzljdhzNBvRq4k+grxeztuoh41rpe2/dMVxdhGf7NDQ7iml0gaORm2/hscX7+OXwRV7p35hJd+ri5la81K8x97aswbu/HGPVgWiz42gmc3URxnaqzd7zSRyITDY7juZEws4lsuZQLJPvqkO1Co63SnhR6QLHyeXkF/Doon2sj4jjX/c2YcIddcyOZLdcXIQPh7SgfW1fnv3+INtPJZgdSTPZg+0CKV/GTbfiaKXGYlG8ueYo1SqUYdKdzn081wWOE8vJL2DKwn1sPBrHGwOaMrZzbbMj2b0ybq7MeDiE2lXKMnnBXo7GppodSTNRuTJuDG0XyNpDscQkZ5kdR3MCP4fHcDAymef6NMLbw83sOKbSBY6Tys4rYPKCvfx27BJvDWzGwx2DzY7kMCp6uTN3bChly7gxds4e/cXm5EZ3CqbAovhxvz5tqZWs7LwC3l93nKY1KjCodYDZcUynCxwnlJ1XwKQFe/n9eDzvDGrOyA61zI7kcGr4eDF3XDsycvIZM2c3KVl6wrebISKeIrJbRA6KSISI/Nt6f20R2SUip0RkqYh4mJ31RgJ9vWkZ6MP6iItmR9Ec3OxtZ4lOzuLl/o1xcXG+YeF/pwscJ5OVW8DE+WH8eTKe9x9owfBQ55q6uzQ18q/A9FFtOZuQwaT5YeTk64kAb0IO0F0p1RJoBfQVkQ7Ae8AnSql6QBIw3sSMRdanaTXCo1J0a55WYhLSc/hq82l6NalGp7pVzI5jE3SB40Qyc/MZP28PW08l8MHgljzYLtDsSA6vU70qfDikJbvOJvLMsoNY9ESARaIM6dab7taLAroDy633zwMGmhDvpvVp6g/ABt2Ko5WQT349QXZeAS/1a2R2FJuhCxwnkZmbz7i5e9h55jIfP9iSwW1rmh3JaQxoFcCL/RqxOjyWd345anYcuyEiriJyALgE/AqcBpKVUvnWTaKAq3Y0EJFJIhImImHx8fGlE/g66vqVo17VcqyP0JP+acXvRFwaS3ZfYGSHWtTxK2d2HJuhCxwnkJ6Tz5jZe9h9NpFPhrbi/ta6uCltk++sw+iOtZj551lm6yHDRaKUKlBKtQJqAqFAkX+aKqVmKKVClFIhfn5+JZbxZvRt6s/uc4l6YVat2L295ijlyrjxZA+9tE5husBxcGnZeYyZvZu9F5L4bFhrBrTSPevNICK8dm9T+jStxptrjrD2UKzZkeyGUioZ2Ax0BHxE5MrY15qA3QxN6tPUnwKLYuNR3YqjFZ8/TsTzx4l4nuhRn0plbb7PfanSBY4DS83OY/Ts3RyITOaL4a25t2UNsyM5NVcX4bNhrWkTVImnlh5g99lEsyPZLBHxExEf63UvoBdwFKPQGWzdbDSwypyEN69ZQAUCfLz0aSqt2BRYFP9Zc5Ralb0Z1VGPhv07XeA4qJSsPB6etZvwqBSmjWjD3c2rmx1JAzzdXfn24RBqVvJi4vwwTl1KMzuSraoObBaRcGAP8KtSajXwAvC0iJwCKgOzTMx4U0SEXk2qseVkPBk5+Td+gKbdwLKwSI7HpfFi30aUcXM1O47N0QWOA0rJzGPUrF1ExKTw1UNt6NvM3+xIWiGVynowb2wo7q4ujJ69h7jUbLMj2RylVLhSqrVSqoVSqplS6g3r/WeUUqFKqXpKqSFKqRyzs96MPk39yc238McJ8zs+a/YtPSefjzYcp11wJX2MvwZd4DiY5MxcHpq1k2OxaXwzsi29m+o3vi0K9PVm7th2JGXmMmbOHtKy9USAzqBdcCUqebvrSf+02/b176dISM/llf5NENGT+l3NDQscEQkUkc0icsQ6o+iT1vt9ReRXETlp/W8l6/0iIp9bZxoNF5E2Jf0iNENSRi4jZu7iRFw600e1pUfjamZH0q6jWUBFvnqoDSfi0nh00T5y8y1mR9JKmJurCz0bV+O3Y5f0v7d2y6KTs/j2z7MMbFWDloE+ZsexWUVpwckHnlFKNQE6AFNFpAnwIrBJKVUf2GS9DdAPqG+9TAK+LvbU2v+4nJ7D8Jk7ORWfzsyHQ+jWqKrZkbQi6NqwKu8Oas6fJxN4cUU4SumJAB1dn6b+pGXns+PMZbOjaHbqg3XHAHiur57U73puWOAopWKVUvus19MwRjIEAAMwZhKFv84oOgCYb52JdCfGsE7dw7UEJaTnMGLmLs4mZDBrdAh3NbCNeT+0ohkSEsjTvRqwYl80H244bnYcrYR1qV8Fbw9XfZpKuyUHIpNZeSCGCXfUJsDHy+w4Nu2m+uCISDDQGtgFVFNKXZnM4yJw5XxIABBZ6GFXnW3U1mYatVfxaTkMn7GT84kZzB7Tjjvq6+LGHj3evR7DQwP5cvNpFu48b3YcrQR5urvStaEfvx6J00t3aDdFKcXba45QpZwHU7rWMzuOzStygSMi5YAfgKeUUqmF/6aMdvWb+qTa4kyj9uZSajbDZuwgKimLOWNC6VxPL7Bmr0SENwc0o3ujqry26jC/HtFzpTiyPk39iU/LYX9kktlRNDuy7vBF9pxL4pneDSlXxu3GD3ByRSpwRMQdo7hZpJRaYb077sqpJ+t/L1nvjwYKr+JoV7ON2ou41GyGzdhJbEo2c8e2o2PdymZH0m6Tm6sL00a0pnlARR5fso99F/SXn6Pq1qgq7q6iJ/3Tiiwnv4B31x2jYbXyPBiiF0ouiqKMohKMybSOKqU+LvSnnzBmEoW/zij6E/CwdTRVByCl0KksrRhcTDGKm7jUbOaNC6V9HV3cOApvDzdmjWlHtQqeTJgXxtmEDLMjaSWggqc7HetWYd3hi7pjuVYkC3ac5/zlTF7u3xhXFz0svCiK0oLTGRgFdBeRA9bL3cC7QC8ROQn0tN4GWAucAU4BM4FHiz+284pJzmLojB3Ep+Uwf3wo7YJ9zY6kFbMq5cowb2woAKNn7yYh3a7mstOKqF8zfy4kZnI0Vs9mrV1fUkYun286yV0N/LhTDyIpsqKMotqqlBLrjKKtrJe1SqnLSqkeSqn6SqmeSqlE6/ZKKTVVKVVXKdVcKRVW8i/DOUQlZTJ0xg4S03OZPz6UtrV0ceOogquUZdboEC6lZTN+7h4yc/XU/o6mV5NquAisO6wbuLXr+2zTSdJz8nm5f2Ozo9gVPZOxnYhMzGTYjJ2kZOaxcEJ72gRVMjuSVsJaB1Vi2vA2HIpO4ZllB/WpDAdTpVwZ2gX78sthPVxcu7Yz8eks3Hme4aFBNKhW3uw4dkUXOHbgwmWjuEnLzmfRhA565srCLBZw4C/+nk2q8VK/xvxy+CJf/3Ha7DhaMevXzJ+Tl9I5dSnd7CiajXrnl2N4urvyj14NzI5id/QexPEuAAAgAElEQVQ4Mxt3LiGDETN3kplXwKIJ7WkWUNHsSOZRCi4egqg9EL0XYvZD/DEQF/AoZ72UNS7+zaDdBKje0uzUt23CHbUJj07hg/XHaVqjop7I0YH0bVad138+wvqIi9Srquc10f5q++kEfj0Sx/N9G1KlXBmz49gdXeDYsLMJGQyfsZOc/AIWT+hAkxoVzI5kngu7YMMrELXbuO1dGQLaQoO+IAI56ZCbAbnpkJMKh5bDvvnQeiTc8xm42u9bXUR474HmnIxL44kl+/n5sS4EVfY2O5ZWDPwretI6yIdfDscytZsucLT/Z7Eo3l5zlAAfL8Z1rm12HLtkv0d9B3c6Pp3hM3ZSYFEsmdSBRv5OWtxcPg2b/g1HVkE5f7j7Q6jXEyoFG4XNtWQlw9aPYdtnkJEAg+eAh/0WBd4ebswYFcK907YyaUEYKx7thLeH4358RSQQmI8xQ7oCZiilPhOR14GJwJXpz/+plFprTsri0a+ZP/9Ze4zIxEwCfe33PaoVrxX7o4mISeWzYa3wdHc1O45d0n1wbNCpS2kMm7ETi3Li4sZSAJvfgS/bw8mN0PWf8MQ+CJ0IvrWvX9wAePlArzeg/0dwYj0suB8yE0snewkJquzN58NbczwujRd+OOTonY6vtcgvwCeFR3SaF7F49G1qLNW3Tnc21qwyc/P5YP0xWgX6cF/LGmbHsVu6wLExR2JSGTp9J0rBkokdnLPXfMZlWPgA/PEuNBtkFDZdXzD61tysdhNgyFyI2Qdz7oYU+55U+64GfjzbuyE/H4xh1tazZscpMddZ5NfhBFX2pkn1Cvyih4trVjO2nCEuNYdX72mM3OjHnHZNusCxIfsuJDFsxg483FxYOrkD9Z2xuIncA9PvgPPb4b4vYNAMKO9/e8/ZdCA8tBxSomB2H4g/UTxZTfJo17rW0xpH2X4qwew4Je5vi/wCPCYi4SIyW0SuOl+CvS3m26+ZP/suJBOXmm12FM1kcanZTP/jDP2bV9dznd0mXeDYiB2nLzPy211UKuvBsskdqetXzuxIpUsp2DUD5vQDFzeY8Cu0ebj4nr/OXTBmNeRnG0VO1N7ie+5SJiJ8MKQldf3K8diS/UQlZZodqcRcZZHfr4G6QCsgFvjoao+zt8V8+zU3ivj1Efo0lbP7cP1xCiyKF/o2MjuK3dMFjg3YfOwSY+bsJsDHi+8nd3S+joY56fDDBPjlOajXAyb/UTLDu2u0gnHrwbMCzLsXTm0s/n2UknJl3Jg+qi15+RYeWbiX7LwCsyMVu6st8quUilNKFSilLBhLwYSambG41KtannpVy/HLIV3gOLOImBSW74tiTOdgPVKyGOgCx2RrD8UyaUEY9auVY+nkjlSt4Gl2pNKVkwYLBkLECuj+KgxbAl4lOEtz5bowbgP41oHFQyH8+5LbVwmr41eOT4e14nB0Kv/80bE6HV9rkV8RqV5os/uBw6WdraT0a+bPrrOXuazXHnNKShnDwn283PWUAcVEFzgmWr43iscW76NlTR8WT+yAb1kPsyOVrtxMWDwMovfBg/PhzmfBpRTekuWrwdg1ENgBVkyAnV+X/D5LSI/G1XiqZ31W7Itm/o7zZscpTtda5Pd9ETkkIuFAN+AfpqYsRn2b+WNR8OuROLOjaCbYdPQS209f5qmeDajo5W52HIfguBNp2Lj5O87x2qoIutSrwoyH2zr0nCZXlZ8DSx+C89vggW+h8b2lu3/PijDyB6PAWfcipF+CHq/dePi5DXqie30OR6fw5uojNK5egdDa9t8xUSm1FbjaP4bdDwu/libVK1C7SllW7ItmWGiQ2XG0UpRXYOE/vxyljl9ZRrTX//bFRbfgmODr30/z2qoIejauxrejQ5yvuCnIg+/HwOnfYMA0aD7YnBzunjBkHrQdY0wK+NPjUGB/q3a7uAgfD21FkK83jy7aS2xKltmRtFsgIgwPDWT3uUSW740yO45WihbvusCZ+Axevrsx7q76a7m46P+TpUgpxYfrj/PeumPc17IGX49s43wzVFoKYMUkOL7WmJW49Uhz87i4wj2fwp3Pw/4FsGwU5NlfgVDB050ZD7clK7eARxbuIyff8TodO4ORHWrRqW5lnv3+IB//esKh+lVpV5eSlcenG0/QqW5lujeqanYch6ILnFJisSj+/fMRpm0+xbB2gXwytJXzVeoWi9FKErECer1pzEpsC0Sg+8vQ7wM4/gssGGQs9WBn6lUtz0cPtuRgZDL/WhVhdhztFnh7uDF3bChD2tbk800neWrpAYccIaf9vy83nyI5K4+X++tJ/Yqbk33DmqPAonhxRThzt59jXOfavDOoOa4uTvZGVgrWPgsHFhnLLnR+wuxE/6v9JBg821itfM7dkGp/M8v2bVadqd3q8t2eSBbvumB2HO0WeLi58P7gFjzXpyGrDsQwatYuEjNyzY6llYALlzOZu+0cQ9rWpGmNimbHcTi6wClheQUWnvxuP8vConiiez3nnHpbKWMl8LBZ0PkpuOt5sxNdW7NB8ND3kHweZvWGhFNmJ7ppT/dqyF0N/PjXT4fZez7J7DjaLRARpnarxxfDW3MwKoX7v9rGmfh0s2Npxey9dcdwdRGe6d3Q7CgOSRc4JSg7r4ApC/eyOjyWl/o14uneDZ2vuAHY/B/YMQ1CJ0PP121/pFLdbjD6Z8jLhNm9jWHsdsTVRfh8WGuqV/RiysK9XNLT/9ute1vWYMnE9qRl53P/V9vZdeay2ZG0YhJ2LpE1h2J55K66VHO2+c9KiS5wSkhGTj7j5+1h49FLvDmwGZPvqmt2JHP8+RFsed9YdqHvu7Zf3FwR0AbGbzAW+Jx3L5zebHaim1LR2+h0nJadz6OL9pGbbzE7knaL2tbyZeWjnalSzoORs3axYp8eYWXvLBbFm2uOUq1CGSbeWdvsOA5LFzglICUrj1GzdrHj9GU+GtKSUR1qmR3JHDu/hk1vQPMhxkil0pjErzhdmfXYpxYsGgKHfzA70U1p5F+B9we3IOx8Em+tOWJ2HO02BFX2ZsWUzoTU8uXpZQf5RI+wsms/h8dwMDKZ5/o0cr5pQkqRnX3j2L7L6TmMmLmTQ9EpfDmiDQ+0rWl2pNKnFGyfZkyg1/heGPiNMRzbHlWoDmPXQs12sHw87JpudqKbcm/LGky6sw7zd5xnWVik2XG021DR251540IZ3LYmn206yT+WHtDTAdih7LwC3l93nGYBFRjUOsDsOA5Nl47F6GJKNiNn7SIyMZOZD4fQtaGTzWlgKYBTm4zOxCfWQeP74IFZ4GrnbzMvHxi1wrog6POQEQ/dXrab023P92lIREwKr6w8TCP/8rSo6WN2JO0Webi58MHgFtSuUpYP1h8nJjmb6aPaUsnZlnmxY7O3nSU6OYsPh7TExdlG05Yy3YJTTCITM3lw+g5ik7OYNy7UuYqblCj4/V34tAUsHgJRYcbCmUPmgZuDHHjdvYzX03oUbPkAfn7SbmY9dnN14YvhbfArV4ZHFuwlQS/maNeujLD6fHhrDkQlM+jr7ZxNyDA7llYE8Wk5fLX5NL2aVKNj3cpmx3F4usApBqcupTPkmx2kZOWxaGIHOtRxkjduThqseQY+bQ6/vwN+DYwi4OmjpbdwZmlydYP7voA7noV98+D70ZBnHyOUfMt6MH1UWy5n5PLY4n3kF+hOx/buvpY1WDyhPSlZedz/1TZ2n000O5J2A59sPEF2XgEv9WtkdhSn4GDfQKXvSEwqQ6fvIN9i4btJHWgV6CTN/6d/g686wZ5Z0G4iPHkQRv0ITQc6TqvN1YhAj1eh3/twbDUsfACyU8xOVSTNAiryzqDm7DyTyDu/HDM7jlYMQoJ9+fHRTviW9WDkt7tYuT/a7EjaNZyIS+O73RcY2aEWdfzKmR3HKegC5zbsu5DEsBk78HBzYdnkjjSuXsHsSCUvO8VYbmHB/eBWBsath7vfh0rBZicrXe0nG/2LInfBnP6QdtHsREUyqE1NxnQKZtbWs/rL0EHUqlyWFVM60aaWD08tPcCnG/UIK1v09pqjlCvjxpM96psdxWnoAucWbT+dwMhvd1GprAfLJnd0jor85K/wVUfYvxA6PwmP/AlB7c1OZZ7mg2HEUkg8Y8x6fPm02YmK5OX+jQmt7cuLK8KJiLHN1icRCRSRzSJyREQiRORJ6/2+IvKriJy0/reS2VltgY+3B/PHteeBNjX5dONJnl52UI+wsiF/nIjnjxPxPNGjvu4QXop0gXOTLBbFzwdjGDtnDwE+Xnw/uSOBvt5mxypZWUnw4xRYNBjKlIfxG6HXG0bHW2dXrweM+Rly040iJ+aA2YluyN3VhS9HtKGStweTF+wlyTbXOcoHnlFKNQE6AFNFpAnwIrBJKVUf2GS9rWGMsPpwSAue6dWAH/dHM2rWbpIzbfLf1qnkF1h4e80RalX2ZlRHJ50TzSQ3LHBEZLaIXBKRw4Xuu+qvKDF8LiKnRCRcRNqUZPjSFJOcxWcbT3LH+5t5fMl+GlQrz9LJHanq6FNsH1sLX3aA8KVG59rJW6BmW7NT2ZaAtsapOndvmHsPnPnD7EQ35Fe+DF+PbMul1Bye+G4/BRbbOqWhlIpVSu2zXk8DjgIBwABgnnWzecBAcxLaJhHh8R71+WxYKw5cSOb+r7ZzTo+wMtWysChOxKXzUr9GlHGz0/nA7FRRWnDmAn3/dt+1fkX1A+pbL5OAr4snpjly8y38ciiW0bN30/m93/hk4wlqVynL58Nbs3xKR3wduakxM9GY9+W74VC2Ckz8zehc61bG7GS2qUp9GL8efAKNlq6IH81OdEOtAn14a2Az/jyZwAfrj5sd55pEJBhoDewCqimlrizzfhGodo3HTBKRMBEJi4+PL5WctmRAqwAWTWxPcmYu93+1jT3n9AgrM6Tn5PPxr8cJDfalT1N/s+M4nRvOwKaU2mI9wBQ2AOhqvT4P+B14wXr/fGX0cNspIj4iUr3QAcnmKaWIiEll5f5oftwfzeWMXPwrePJ4t3oMCQl0/NNRAEdWGcO/s5Kg60vQ5WnHHhlVXCrUMGY9XjwMvh8LGQkQOtHsVNf1YLtAwqOT+eaP0zQLqMA9LWqYHekvRKQc8APwlFIqtfBitUopJSJXbXpSSs0AZgCEhITYVvNUKWkX7MuPj3Zm7Nw9PDRzFx8MacGAVnrm3NL09e+nSEjPZdboxs650LLJbnWK2Wv9igoACs8HH2W9738KHBGZhNHKQ1BQ0C3GKD6nLqXx04EYfg6P5WxCBm4uQs/G1RgaGsid9f1wdYYZJ9PjYe2zcGQlVG8Jo1aCfzOzU9kXr0rw8EqjwFn7rFHkdH3Rpmc9fu2ephyNTeP55eHUr1qehv7lzY4EgIi4YxQ3i5RSK6x3x1350SQi1YFL5iW0fcFVjBFWkxfu5cnvDnD+ciaPd6+nv2xLQXRyFt/+eZaBrWrQ0lmmD7Extz2H/vV+Rd3gcab/wjodn866wxf5+WAMxy6mIQId61Rm8p116NvMHx9vJ2m1UAoiVsDa54zJ+7q/aoyScnU3O5l9cveCoQuN2Y7/eBcyLsHdH9rselwebi58/VAb7vliK5MWhPHT1C5U9Db3316Mb+BZwFGl1MeF/vQTMBp41/rfVSbEsyuVynqwYHwoL/1wiI9/PcG5yxm8O6gFHm56jElJ+mCdMdfUc331pH5mudUC51q/oqKBwELb1bTeZxOUUoRHpbA+4iLrIy5yOt7ofNc6yId/3duE/s2rO36n4b9Li4M1TxuT1tVoAwO/gqqNzU5l/1zdYMA0KOcHWz8xWnIGzQR323x/Va3gydcj2zBsxk6eWrqfWaPbmb1OTmdgFHBIRK4MTfsnRmGzTETGA+eBB03KZ1fKuLny0YMtqVW5LJ9sPEF0UhbTR7V1nh9xpexAZDIrD8TwWLd6BPjo0aZmudUC51q/on4CHhOR74D2QIrZ/W/yCizsPpvI+oiLbIiI42JqNq4uQvvavjzcMZheTapRwxnfgEpB+DJj8ci8LGPYd4ep9r8wpi0RgZ6vQ9mqsP4lWJQEwxaDp21OCNm2li//urcpr6w8zKcbT/B074amZVFKbQWuVWH1KM0sjkJEeLJnfWpV9ub55eEM+mo7c8a2o1blsmZHcyhKKd5ec4Qq5crwSNe6Zsdxajf8NhORJRgdiquISBTwL679K2otcDdwCsgExpZA5hvKzM1ny4kENkRcZNOxS6Rk5eHp7sKd9f14rmlDujeq6tyTLaXGwOp/GCt+1wyFAV8a60hpJaPjo8ZItJVTYG5/GPkDlLPNxVgfah/EoagUPv/tFE0DKuqRHw5oYOsAavh4MWlBGPd/tZ2ZD7elbS1fs2M5jHWHL7LnXBLvDGpOuTL6B6OZxBam9A4JCVFhYWG39RxJGblsOnaJ9REX+fNkPNl5Fip6udOjcVX6NPXnzvp+eHnYZh+IUqMUHFgE6/4JBbnGsO/2j9hs3xCHc3IjLBsF5arBqBXgW8fsRFeVnVfA0Ok7OB2fwcqpnalX9dZm6RaRvUqpkGKOd9OK4/jiiM4mZDB2zm5iUrL55MFW9G9R3exIdi8nv4BeH2/By92VtU/e4RyDU0xQ1GOLXZWXf56MZ9PRS+QVWPByd8XLw5V8i2Lf+STCzidRYFFUr+jJ0JBA+jT1p11tX9xddUc6AFKi4Kcn4PQmqNXZWBW7sm4+LVX1e8Lon2HREJjVB0YuN0ar2RhPd1e+HtmW+6YZnY5XTe1MeU/d4dzR1K5SlhWPdmbS/DCmLt7HhcRGPHJXHT3C6jYs2HGeC4mZzB8XqosbG2BXBc7+C8ks3xuFp7sLWbkFZOYVIEDj6hV45K469GnqT/OAivoDWphSsHcubHgVlAX6fQDtJoCLLvxMUTPEmPV4wf3GIp3Dl0DtO8xO9T9q+HgxbUQbHvp2F08vO8j0kW3N7nSslQDfsh4snNCe55aH8966Y1xIzOCNAc30D8NbkJSRy+ebTtK1oR93NvAzO46GnRU4U7rW/cscDkopLApdKV9L0nlj5e+zf0DtO41WG2db9dsW+TWA8Rtg4SDj8sAsaHKf2an+R4c6lXmlf2P+/fMRvtx8isf1KsgOydPdlc+GtiLI14svN58mOjmbL0e01q12N+mzTSdJz8nnn3frUai2wq7KdHdXl7+0zoiILm6uxmKB3TONlb+j98I9n8DDP+nixpZUDICxv0CN1vD9aAibbXaiqxrTKZhBrQP4eOMJfjsWZ3YcrYS4uAjP9WnEew80Z9upBIZ8s4OY5CyzY9mN0/HpLNx5nuGhQTSoZhsTZWp2VuBoRZB4Bubda8yiG9QeHt0JIeNseiZdp+Xta8wWXa+XMart9/eMU4o2RET4z6DmNKlegSe/O8BZvXCjQxvaLoi5Y9sRnZTFwC+3cTg6xexIduGdtcfwdHflH730aFRbogscR2EpgB1fwVed4OIhuG8ajFxhLP6o2S4Pbxi2CFqOgN//Y8wmbSkwO9VfeLq78s3IttzVwA8fL33awtHdUd+P5VM64eYiPDh9h265u4HtpxPYeDSOR7vVpUo5vRixLdEFjiNIOAlz+hmTydW+E6buhDajdKuNvXB1N2aQ7vwk7JkJP4yH/ByzU/1FoK8300a0ce75o5xIQ//yrJzamTp+ZZkwL4z5O86ZHckmFVgUb60+SoCPF+M61zY7jvY3usCxZ5YC2PY5fNMF4o/BwG9gxFJjVWvNvogYs0n3fgsifjSGkuekmZ1Kc2JVK3iydFJHujeqymurInhz9REKLLZ1CtVsK/ZFcSQ2lef7NsTTXc8nZmt0gWOvLh2DWb3g11ehbg+YuhtaDdetNvau0+Nw/3Q4v82Y9Tg93uxEmhMrW8aN6aNCGNMpmFlbz/Loor1k5drWKVSzZObm8+GG47QK9OG+lvpHpS3SBY69KciHPz+C6XdA4lljiPGwRVBeT6nvMFoOg+HfQfwJmN0bks6ZnUhzYq4uwuv3NeW1e5qw4Ugcw2buJD7Ntk6hmmHGljPEpebw6j2N9dxrNkoXOPYkLgK+7QGb3oCG/WDqLmg+WLfaOKL6vWD0T5CZCLP7QXKk2Yk0JzeuS22mj2zL8Yup3P/VNk7GOe8p1LjUbKb/cYb+zavrdbxsmC5w7EFBnjGEePpdxpILQ+bBg/NtdsFGrZgEhsKYNZCbYUwImJlodiLNyfVu6s/SSR3JzrMw6OvtbD+VYHakUmexKJ5edoACpXihbyOz42jXoQscWxd7EGZ0M4YQNxlg9LVpOtDsVFpp8W9mLOeQdN7oeJzrHPPQiMhsEbkkIocL3fe6iESLyAHr5W4zMzqrloE+/PhoJ/wrePLw7N0s3xtldqRStfZwLNtOXea1e5oQVNnb7DjadegCx1bl58Bvb8HM7pBxCYYthsGzoGxls5NppS24MwyeDTH74PsxRoue45sL9L3K/Z8opVpZL2tLOZNmFejrzfIpnWhfx5dnvz/Ix7+eQNnYJJUlIa/AwkcbTtCwWnmGhwaZHUe7AV3g2KLofcbpqC0fQPMhxmzEjfqbnUozU+N7jCU3Tm4w1hdz8C8TpdQWQJ+Ts2EVvdyZMyaUIW1r8vmmkzy97CA5+Y49wmpDRBxnEzJ4uncDvUyQHbCrxTYdXk6aUdRs/wLKVYMRy6BBH7NTabai7Rhj2Pjmt4z+V73eMDuRGR4TkYeBMOAZpVTS1TYSkUnAJICgIP1Lu6R4uLnw/uAW1KrszYcbThCdnMWMUW3x8XbMCSGXhUVSo6InPRtXMzuKVgS6BccWFOTDnlnweWvY9hm0GmG02ujiRvu7O5+FdhON98n2aWanKW1fA3WBVkAs8NG1NlRKzVBKhSilQvz8/Eorn1MSER7rXp/PhrXiwIVkBn29nfOXHa+vWExyFltOxjO4bU3demMndIFjJqXg+Dr4uiOseRoq14eJv8GAL8HLx+x0mi0SgX7vQZOBsOFlCF9mdqJSo5SKU0oVKKUswEwg1OxM2v8b0CqAhRPak5iRy/1fbWfv+as2rtmtFfuiUAoGt9Xr+9kLXeCYJeaAser3kqHGkgtDF8HYtRDQ1uxkmq1zcYVBM4x1x1ZOgVMbzU5UKkSkeqGb9wOHr7WtZo7Q2r6smNKJ8p5ujJi5k7WHYs2OVCwsFsWysCg61qmsR07ZEV3glLaUKFgxGWbcZUzc1+8DY8K+xvfoCfu0onMrYxTFVRvD0ochaq/ZiYqViCwBdgANRSRKRMYD74vIIREJB7oB/zA1pHZVdfzKsWJKJ5oFVOTRRfuY/sdpux9htftcIhcSM3mwXU2zo2g3QXcyLi3ZqbDtU9jxpXFqqvNTcMfT4FnR7GSavfKsAA/9YCznsHgIjFsPVeqbnapYKKWGX+XuWaUeRLsllcuVYdGE9jzz/UHe+eUY5xMzeeO+pri52udv6mVhkZQv40bfptVvvLFmM+zz3WZPCvJhz7dGB+I/P4LG98HjYdDr37q40W5f+WowcgWICywYBKmOcUpAs3+e7q58Maw1U7rWZfGuC4yfF0Z6Tr7ZsW5aWnYeaw/Fcm+rGnh56BXD7YkucEqKUnD8F2sH4mfAryFM3AwPzAQfPWxVK0aV68JDyyErERY+AFnJZifSNABcXIQX+jbinUHN2XoqgcFfbyc2JcvsWDdldXgs2XkWHgzRnYvtjS5wSkLMfmsH4mGgLDBsibGmUEAbs5NpjqpGK2NV+YQTsGQ45NnXl4jm2IaHBjF7TDuikrIY+OU2ImJSzI5UZMvCImlQrRwta+oWd3ujC5zilBwJKybBjK5w6Qjc/aF1FuK7dQdireTV6WqMrrqwA36YYJwe1TQbcVcDP75/pCMuIjz4zQ42H7tkdqQbOhmXxv4LyTwYEojoY7jd0QVOcchOhY3/hmkhELESuvwDntgPoRPB1d3sdJozaTbImCfn2GpjbiU7H72iOZbG1SuwcmpngquUZfy8PSzYed7sSNf1/d4o3FyEga0DzI6i3QI9iup2FOTB3rnw+7uQmQAthkL3V3QfG81c7SdD+iX480NjyY/uL5udSNP+q1oFT5ZN7sjjS/bz6srDXLicwUv9GuNiY7MD5xVYWLEvih6Nq1KlXBmz42i3QBc4t+JKB+JfX4PLJ6FWF+j9pu5jo9mO7q9Aehxsed9Ytyp0otmJNO2/ypZxY8aotryx+ggz/zxLZGIWnwxtZVOjlDYfu0RCeq7uXGzH7KvASYmGghyoVPvW+7RYLMZok4x4yE4xTi/lpEJ2snE9O8V62/q3/GwoyLVe8oz/5mZAarSxtMLw76BBX93HRrMtInDPp5B5GdY+B2WrQNP7zU6laf/l5urCv+9rSq3KZXlrzRGGz9zJt6NDbKK1JCUzjw83HKdq+TLc1UCvZWavSqTAEZG+wGeAK/CtUurdYnniPd/C1o+hQgDU6wH1exsdK8uUNwqXzMuQFmv8ck2LhbQ4SL8IaYUu6XFgybv2PlzcjflpPCsaE6m5lwV3b+O2q4fRp8bFHYI6QJuHdR8bzXa5usHg2bDgfqPzu5cv1LnL7FSa9l8iwvgutQnw8eKppfu5/6ttzBnTjnpVy5uWKTuvgInzwzibkMG8saF2OzmhBlLcU2iLiCtwAugFRAF7gOFKqSPXekxISIgKCwu78ZMnnoHTm+HM78YlJ9UoNsr6QcYlsFxl1IhXJSjnD+Wtl3LVoHx1KOdnLWJ8oEyF/y9o3Dx1a4zmWLKSYHY/Y5mQsWugestS2a2I7FVKhZTKzq6jyMcXzVQHIpOZMG8PufkW5oxtR9tavqWeocCimLpoH+siLvLF8Nbc27JGqWfQbqyox5aSKHA6Aq8rpfpYb78EoJR651qPuaUDUEEeRO6CkxsgI+H/C5fyVwqYasbF3fM2Xo2mOYjUGJjVG/JzYPx68K1T4rvUBY52syITMxk1axdZeQWsf+pOfLw9Sm3fFovi5ZWHWLI7ktfuaclR3I0AAAnUSURBVMK4LrVLbd/azSnqsaUkTlEFAJGFbkcB7f++kYhMAiYBBAXdwqgjV3cI7mJcNE27vgo1jCUdZvc2lnQYv8HofKxpNiTQ15svhrfh/q+28eqqCL4Y3rpU9nvhcibvrz/G6vBYHutWTxc3DsK0k4tKqRlKqRClVIifn+7EpWklzq+BsaRDepyxpEN2qtmJNO1/NK9Zkad61ufngzGsOhBdovs6EZfGP5YeoNtHv7MhIo5nejXgmd4NSnSfWukpiQInGig8rq6m9T5N08xWMwQenA9xEbB0pHHKStNszCN31aVNkA+vrYogJev/2rv/2KrqM47j74eWXxNGRV1FoIr1AqKZgsJ0LE4oVfyR4IZm1GyySfYTRNQx2HQuC1miyTaWbcaETGOXaUGgpsz9cApsmOkoiFrLjFJ1FhSsgiLgEOl99sf54kqlP4D2nt5zPq/k5p7zPUf7PLe9D0/O+Z5z2rko5Bh9eLCZ2Q9t4rLF63hs8w5unHgGTy6YxE1lGd2xOEG6o8HZAGTMbISZ9QFmAKu64eeIyLHIlMO0e+C1f8Aj346uQOxhzOx+M2sys/oWY4PN7HEz2xLeT4wzRuk+hQW9WHTNuez+70dUPvWfLv///3ZNA3+q287sSaX8c8Fkbr9qDMWf1nzNpOnyBsfdDwJzgMeAF4GH3X1zV/8cETkO51dA+SLY/Aj8dUFPfKTDA8DUVmMLgdXungFWh3VJqHNOG8QlI0+hqraR5mzX/X2+tGMP9/79Fb48bijzLx/NiSfkbiKz5Fa3zMFx9z+7+0h3L3X3n3XHzxCR4zRxLlw8B2qXwJO/iDuaw7j7OmBXq+FpQGVYrgSuyWlQknMV44ezffd+1r389lH/t81Z5yc19Uy8aw0LVtSxqfFdslnnR4+8wMB+hdxx1ZhuiFh6kvy6k7GIdK3yRdFdvdcsiu4ndcHMuCNqT7G7bw/LO4DitnY87qs0pUcoO7uYkwf0oaq2kUmjO3/VX3PWmb/ieao3vcG4kiL+WPcmyzZuZWC/QvbsP8jPrzuPwTpyk3hqcETSrFevaD7OBzvh0XlRkzP6yrij6pC7u5m1ed7C3ZcASyC6D07OApMu1aewF9MvGMbvnnyNpvf385lOzJNpzjoLVtZRvekNbi0fydyyDHs/PMijz7/JX+p3MLakiOnj9HTwNNA9qEXSrqA3XFcJp42FFd+A15+OO6K2vGVmQwDCe1PM8UgOzBhfQnPWWf7Mtg73zWadhSvrWPHMNuZNyTC3LAPAgL6FzJhQQuWNE5g3ZaSulEoJNTgiAn0HwPXLYdBwqPpKdBl5z7MKOHQObSZQE2MskiMjTj6Bz40YzLINW8m2M9k4m3UWVtex/Jlt3FyWYd4U3c8m7dTgiEjkhJPga9XRw2X/MB3ea4wtFDOrAp4GRpnZNjObBdwFlJvZFmBKWJcUqJhQQuOuD3j61Z1H3J7NOj+sfoGHN25jblmGW8rV3IgaHBFpqagEvroSDnwQPdJh35H/Qelu7l7h7kPcvbe7D3P3+9x9p7uXuXvG3ae4e+urrCShpp57KoP696aq9pNN96Ero5Zt3MpNk8/ilimZGCKUnkgNjogcrvgcuH5pdATnoevgwL64I5KU69e7gC+NHcrfNr/Frn0HPh6PHpBZz9INW5kz6SxuLdf8Gvk/NTgi8kmnfx6uvR/efBYevgGau/52+SJHo2JCCQeas1RviiYbZ7POHTX1VNU28r1LS7ntMjU3cjg1OCJyZGdfDVcvhoYnoGZ2j3ykg6THqFMHMrakiKVhsvGPa+p5aH0j3720lPmXj1JzI5+gBkdE2nbB12HSHVC3DJ64M+5oJOUqxpfQ0LSXy3+1jgfXN/KdL5byAzU30gY1OCLSvku+D+O/CU/9BrZuiDsaSbGrzxvC6FMH0vD2XmZPKmXBVDU30jbdyVhE2mcGV9wd3eF4+Pi4o5EU+1SfQmrmTOSdvQcYWtQ/7nCkh9MRHBHpWK8CKJ0cdxQi9C0sUHMjnaIGR0RERBJHDY6IiIgkjhocERERSRw1OCIiIpI4anBEREQkccy97cfP5ywIs7eB1zu5+8nAO90YTk+TtnwhfTknNd/T3f2UuINQfWmX8k22pObbqdrSIxqco2FmG939wrjjyJW05Qvpyzlt+fZkaftdKN9kS1u+rekUlYiIiCSOGhwRERFJnHxscJbEHUCOpS1fSF/Oacu3J0vb70L5Jlva8j1M3s3BEREREelIPh7BEREREWmXGhwRERFJnLxqcMxsqpm9ZGYNZrYw7ni6gpndb2ZNZlbfYmywmT1uZlvC+4lh3Mzs1yH/OjMbF1/kx8bMhpvZWjP7t5ltNrObw3giczazfmZWa2bPh3x/GsZHmNn6kNcyM+sTxvuG9Yaw/Yw440+LJNYWSFd9SVttAdWXjuRNg2NmBcA9wBXAGKDCzMbEG1WXeACY2mpsIbDa3TPA6rAOUe6Z8PoWcG+OYuxKB4Hb3H0McBEwO/wek5rzh8Bkdz8POB+YamYXAXcDi939LOBdYFbYfxbwbhhfHPaTbpTg2gLpqi9pqy2g+tKuvGlwgAlAg7u/6u4HgKXAtJhjOm7uvg7Y1Wp4GlAZliuBa1qM/94j/wKKzGxIbiLtGu6+3d03heU9wIvAUBKac4h7b1jtHV4OTAZWhPHW+R76HFYAZWZmOQo3rRJZWyBd9SVttQVUXzqSTw3OUGBri/VtYSyJit19e1jeARSH5UR9BuHw6FhgPQnO2cwKzOw5oAl4HHgFeM/dD4ZdWub0cb5h+27gpNxGnDp5/zd2lBL7XTskLbUFVF/ak08NTip5dB1/4q7lN7MBwEpgnru/33Jb0nJ292Z3Px8YRnS0YHTMIYkAyfuuQbpqC6i+tCefGpw3gOEt1oeFsSR669Ch0vDeFMYT8RmYWW+iAvSgu1eH4UTnDODu7wFrgYuJDocXhk0tc/o437B9ELAzx6GmTWL+xjopsd+1tNYWUH05knxqcDYAmTA7vA8wA1gVc0zdZRUwMyzPBGpajN8QZv9fBOxuceg1L4TzvfcBL7r7L1tsSmTOZnaKmRWF5f5AOdHcgLXAtWG31vke+hyuBda47sbZ3dJUWyC537VU1RZQfemQu+fNC7gSeJnoHOPtccfTRTlVAduBj4jOlc4iOie6GtgCPAEMDvsa0dUerwAvABfGHf8x5PsFokPEdcBz4XVlUnMGPgs8G/KtB+4M42cCtUADsBzoG8b7hfWGsP3MuHNIwyuJtSXklZr6krbaEnJQfWnnpUc1iIiISOLk0ykqERERkU5RgyMiIiKJowZHREREEkcNjoiIiCSOGhwRERFJHDU4IiIikjhqcERERCRx/gfW8pbtDdH7fQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1, 2, figsize=(8, 3))\n",
    "\n",
    "_, arbitrary_station = climate_predictions[0][0]\n",
    "\n",
    "axs[0].plot(arbitrary_station[:, PRED_TMAX_COL])\n",
    "axs[0].plot(arbitrary_station[:, PRED_TMIN_COL])\n",
    "axs[0].set_title('temperature')\n",
    "axs[1].plot(arbitrary_station[:, PRED_PRCP_COL])\n",
    "axs[1].set_title('precipitation')\n",
    "\n",
    "maybe_save_plot('2018-06-11-year-temp-single-pred')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predictions by climate\n",
    "\n",
    "It would be cool to see why the model placed each station in each climate. These graphs are pretty cool, but I wouldn't read too much into them!\n",
    "\n",
    "I'll group up weather stations by assigned climate, and ask the model to predict the weather every day of the year. Then for each day, I'll plot the prediction of the median of all stations in that climate. To give an idea of the range of predictions in that climate, and shade in the area between the 5th and 95th percentile of stations. \n",
    "\n",
    "In other words, on June 11, the precipitation chart will show a solid line where the median of the precipitation predictions for all stations. It shows a shaded region between the 5th and 95th percentile of precipitation predictions. (Note it's not following a particular station! It's just looking at all of the predictions for a day)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Temperature\n",
    "\n",
    "It looks like blue (the West) and maroon (northern part of east of the Rockies) have colder winters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x144 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_predictions(climate_predictions, plot_temperature):\n",
    "    fig, axs = plt.subplots(\n",
    "        1,\n",
    "        len(climate_predictions), \n",
    "        figsize=(15, 2), \n",
    "        sharey=True\n",
    "    )\n",
    "    \n",
    "    for climate_i, climate_pred in enumerate(climate_predictions):\n",
    "        x_grid = climate_pred[0][0]\n",
    "        # make a vector of all stations and tranpose so it's day, station, value\n",
    "        climate_preds = np.vstack((\n",
    "            [station_data]\n",
    "            for _, station_data in climate_pred\n",
    "        ))\n",
    "            \n",
    "        central_pred = np.median(climate_preds, axis=0)\n",
    "        \n",
    "        lower_bound = np.percentile(climate_preds, q=5, axis=0)\n",
    "        upper_bound = np.percentile(climate_preds, q=95, axis=0)\n",
    "        \n",
    "        if plot_temperature:\n",
    "            values = [0, 1]\n",
    "        else:\n",
    "            values = [2]\n",
    "            \n",
    "        for value_i in values:\n",
    "            axs[climate_i].fill_between(\n",
    "                x_grid, \n",
    "                lower_bound[:, value_i], \n",
    "                upper_bound[:, value_i], \n",
    "                alpha=0.2, \n",
    "                label='two standard deviations'\n",
    "            )\n",
    "            \n",
    "            axs[climate_i].plot(\n",
    "                x_grid, central_pred[:, value_i]\n",
    "            )\n",
    "            \n",
    "            axs[climate_i].set_title(climate_id_to_color[climate_i])\n",
    "\n",
    "plot_predictions(climate_predictions, plot_temperature=True)\n",
    "maybe_save_plot('2018-06-11-year-temp-predictions')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Precipitation\n",
    "\n",
    "I think the precipitation predictions look a little weird. That said, I approve that the red dots were mostly on the West Coast, and the precipitation predictions show that climate includes a lot of places with very rainy winters. And that blue, the West, includes more dry places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x144 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(climate_predictions, plot_temperature=False)\n",
    "maybe_save_plot('2018-06-11-year-precipitation-predictions')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard Projector\n",
    "\n",
    "TensorBoard has a neat [embedding](https://www.tensorflow.org/programmers_guide/embedding) visualization currently called Projector. If you add column headers to the tsv files the classifier outputs above, you can load them in as labels and kind of get an idea of what KMeans is doing!\n",
    "\n",
    "![](images/2018-06-11-tensorboard.png)\n",
    "\n",
    "\n",
    "### Day of the year\n",
    "\n",
    "This was funny: before I used the day of the year, I used separate values for the month and the year. Here is what the predictions looked like:\n",
    "\n",
    "| | | |\n",
    "|--|--|--|\n",
    "| ![](images/2018-06-11-silly-nn-1.png) | ![](images/2018-06-11-silly-nn-2.png) | ![](images/2018-06-11-silly-nn-3.png) |\n",
    "\n",
    "### Basemap\n",
    "\n",
    "I used Basemap to generate images. Here's some of the [code](https://gist.github.com/jessstringham/319ab3a98d5d35010e1ac870ae2fbff1) I used to generate the maps. \n",
    " \n",
    "### Inspiration\n",
    "\n",
    "My sister told me about the problem with Köppen!\n",
    "\n",
    "The neural network to learn embeddings is a little similar to how [CBOW and Skip-Grams](https://en.wikipedia.org/wiki/Word2vec#CBOW_and_skip_grams) work.\n",
    "\n",
    "### What next? \n",
    "\n",
    "This was a neat proof-of-concept! There are lots of directions one can take this project, but I'm out of time for today. A few off the top of my head are:\n",
    "\n",
    " - Use more data!\n",
    "   - Snow data is often present in the dataset, so I don't even need to deal with missing data.\n",
    " - Try different representations of days, like using an embedding!\n",
    " - Find a better way to choose the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] By Peel, M. C., Finlayson, B. L., and McMahon, T. A.(University of Melbourne)Enhanced, modified, and vectorized by Ali Zifan. - Hydrology and Earth System Sciences: \"Updated world map of the Köppen-Geiger climate classification\" (Supplement)map in PDF (Institute for Veterinary Public Health)Legend explanation, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=47086879\n",
    "\n",
    "[2] Menne, M.J., I. Durre, R.S. Vose, B.E. Gleason, and T.G. Houston, 2012:  An overview \n",
    "of the Global Historical Climatology Network-Daily Database.  Journal of Atmospheric \n",
    "and Oceanic Technology, 29, 897-910, doi:10.1175/JTECH-D-11-00103.1.\n",
    "\n",
    "[3] Menne, M.J., I. Durre, B. Korzeniewski, S. McNeal, K. Thomas, X. Yin, S. Anthony, R. Ray, \n",
    "R.S. Vose, B.E.Gleason, and T.G. Houston, 2012: Global Historical Climatology Network - \n",
    "Daily (GHCN-Daily), Version 3. \n",
    "NOAA National Climatic Data Center. http://doi.org/10.7289/V5D21VHZ 2018/06/09."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}