Upload folder using huggingface_hub

e88186124ec611f1/dataset/sample_submission.csv

@@ -1,6 +1,3 @@
-Index,demand
-0,0.090767774072159
-1,0.0898848048932868
-2,0.0070368435076525
-3,0.0790872273785951
-4,0.0546359836658569
+version https://git-lfs.github.com/spec/v1
+oid sha256:512c0d62e334d2ca8e4e49f7b7bbcce7abbf681388fb81fe2a18e5f8599fb4ac
+size 117

gridlock_solution.ipynb

@@ -1,448 +1,3 @@
-{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
-  "colab": {
-   "provenance": []
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Gridlock Hackathon 2.0 — Traffic Demand Prediction\n",
-    "\n",
-    "**Approach:** LightGBM + XGBoost ensemble with temporal lag features.\n",
-    "\n",
-    "**Key features:**\n",
-    "- Geohash → lat/lon\n",
-    "- Cyclical time encoding (sin/cos of hour)\n",
-    "- **Lag feature:** same geohash + same timestamp from previous day (day 48)\n",
-    "- Per-geohash aggregations: mean, std, median, max demand\n",
-    "- Per-geohash per-hour mean demand\n",
-    "- Neighbourhood (geo3-prefix) demand aggregations\n",
-    "- Temperature (imputed via geohash+hour mean where missing)\n",
-    "- Road features: RoadType, NumberofLanes, LargeVehicles, Landmarks, Weather\n",
-    "\n",
-    "**Evaluation:** `score = max(0, 100 * R2(actual, predicted))`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Install dependencies (Colab)\n",
-    "!pip install pygeohash lightgbm xgboost -q"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import pygeohash as pgh\n",
-    "from lightgbm import LGBMRegressor\n",
-    "from xgboost import XGBRegressor\n",
-    "from sklearn.metrics import r2_score\n",
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')\n",
-    "\n",
-    "print('Libraries loaded.')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Load Data\n",
-    "\n",
-    "Upload `train.csv` and `test.csv` to Colab or mount Google Drive."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Option A: upload files manually\n",
-    "# from google.colab import files\n",
-    "# uploaded = files.upload()  # upload train.csv and test.csv\n",
-    "\n",
-    "# Option B: mount Drive\n",
-    "# from google.colab import drive\n",
-    "# drive.mount('/content/drive')\n",
-    "# DATA_PATH = '/content/drive/MyDrive/gridlock/'\n",
-    "\n",
-    "# Option C: local paths (if running locally)\n",
-    "DATA_PATH = 'e88186124ec611f1/dataset/'\n",
-    "\n",
-    "train = pd.read_csv(DATA_PATH + 'train.csv')\n",
-    "test  = pd.read_csv(DATA_PATH + 'test.csv')\n",
-    "\n",
-    "print(f'Train: {train.shape}, Test: {test.shape}')\n",
-    "print('Train days:', sorted(train.day.unique()))\n",
-    "print('Test days:', sorted(test.day.unique()))\n",
-    "train.head()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Feature Engineering"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def parse_timestamp(df):\n",
-    "    df = df.copy()\n",
-    "    df['hour']   = df['timestamp'].map(lambda x: int(x.split(':')[0]))\n",
-    "    df['minute'] = df['timestamp'].map(lambda x: int(x.split(':')[1]))\n",
-    "    df['time_min'] = df['day'] * 24 * 60 + df['hour'] * 60 + df['minute']\n",
-    "    # Cyclical daily time\n",
-    "    t = (df['hour'] * 60 + df['minute']) / (24 * 60) * 2 * np.pi\n",
-    "    df['time_sin'] = np.sin(t)\n",
-    "    df['time_cos'] = np.cos(t)\n",
-    "    # Cyclical day\n",
-    "    d = df['day'] / 7 * 2 * np.pi\n",
-    "    df['day_sin'] = np.sin(d)\n",
-    "    df['day_cos'] = np.cos(d)\n",
-    "    return df\n",
-    "\n",
-    "\n",
-    "def decode_geohash(df):\n",
-    "    df = df.copy()\n",
-    "    decoded  = df['geohash'].map(pgh.decode)\n",
-    "    df['lat'] = decoded.map(lambda x: x[0])\n",
-    "    df['lon'] = decoded.map(lambda x: x[1])\n",
-    "    df['geo3'] = df['geohash'].str[:3]\n",
-    "    df['geo4'] = df['geohash'].str[:4]\n",
-    "    return df\n",
-    "\n",
-    "\n",
-    "def encode_categoricals(df):\n",
-    "    df = df.copy()\n",
-    "    df['RoadType_enc']     = df['RoadType'].map({'Residential': 0, 'Street': 1, 'Highway': 2}).fillna(-1)\n",
-    "    df['LargeVehicles_enc'] = (df['LargeVehicles'] == 'Allowed').astype(float)\n",
-    "    df['Landmarks_enc']    = (df['Landmarks'] == 'Yes').astype(float)\n",
-    "    df['Weather_enc']      = df['Weather'].map({'Sunny': 0, 'Rainy': 1, 'Foggy': 2, 'Snowy': 3}).fillna(-1)\n",
-    "    return df\n",
-    "\n",
-    "\n",
-    "train = parse_timestamp(train)\n",
-    "train = decode_geohash(train)\n",
-    "train = encode_categoricals(train)\n",
-    "\n",
-    "test = parse_timestamp(test)\n",
-    "test = decode_geohash(test)\n",
-    "test = encode_categoricals(test)\n",
-    "\n",
-    "print('Basic features done.')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ── Temperature imputation ────────────────────────────────────────────────────\n",
-    "# Use geohash+hour mean from training data\n",
-    "geo_hour_temp = (train.dropna(subset=['Temperature'])\n",
-    "                 .groupby(['geohash', 'hour'])['Temperature']\n",
-    "                 .mean().reset_index()\n",
-    "                 .rename(columns={'Temperature': 'temp_impute'}))\n",
-    "\n",
-    "day_temp_mean = train.groupby('day')['Temperature'].mean()\n",
-    "\n",
-    "def impute_temp(df):\n",
-    "    df = df.merge(geo_hour_temp, on=['geohash', 'hour'], how='left')\n",
-    "    df['Temperature'] = df['Temperature'].fillna(df['temp_impute'])\n",
-    "    df['Temperature'] = df['Temperature'].fillna(day_temp_mean.mean())\n",
-    "    df = df.drop(columns=['temp_impute'])\n",
-    "    return df\n",
-    "\n",
-    "train = impute_temp(train)\n",
-    "test  = impute_temp(test)\n",
-    "print(f'Temp NaN remaining - train: {train.Temperature.isna().sum()}, test: {test.Temperature.isna().sum()}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ── Lag feature: same geohash + same timestamp, 1 day earlier ────────────────\n",
-    "train48 = (train[train['day'] == 48][['geohash', 'timestamp', 'demand']]\n",
-    "           .rename(columns={'demand': 'demand_lag1d'}))\n",
-    "\n",
-    "train = train.merge(train48, on=['geohash', 'timestamp'], how='left')\n",
-    "test  = test.merge(train48, on=['geohash', 'timestamp'], how='left')\n",
-    "\n",
-    "print(f'Lag1d coverage - train: {train.demand_lag1d.notna().sum()}/{len(train)}, '\n",
-    "      f'test: {test.demand_lag1d.notna().sum()}/{len(test)}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ── Aggregation features (from all train data) ───────────────────────────────\n",
-    "\n",
-    "# geohash statistics\n",
-    "geo_stats = (train.groupby('geohash')['demand']\n",
-    "             .agg(['mean','std','median','max']).reset_index()\n",
-    "             .rename(columns={'mean':'geo_mean','std':'geo_std',\n",
-    "                              'median':'geo_median','max':'geo_max'}))\n",
-    "geo_stats['geo_std'] = geo_stats['geo_std'].fillna(0)\n",
-    "\n",
-    "# geohash + hour mean\n",
-    "geo_hour_demand = (train.groupby(['geohash','hour'])['demand']\n",
-    "                   .mean().reset_index()\n",
-    "                   .rename(columns={'demand':'geo_hour_mean'}))\n",
-    "\n",
-    "# geohash + exact timestamp mean (captures recurring patterns)\n",
-    "geo_ts_mean = (train.groupby(['geohash','timestamp'])['demand']\n",
-    "               .mean().reset_index()\n",
-    "               .rename(columns={'demand':'geo_ts_mean'}))\n",
-    "\n",
-    "# geo3 neighbourhood + hour mean\n",
-    "geo3_hour = (train.groupby(['geo3','hour'])['demand']\n",
-    "             .mean().reset_index()\n",
-    "             .rename(columns={'demand':'geo3_hour_mean'}))\n",
-    "\n",
-    "# geo3 overall mean\n",
-    "geo3_mean = (train.groupby('geo3')['demand']\n",
-    "             .mean().reset_index()\n",
-    "             .rename(columns={'demand':'geo3_mean'}))\n",
-    "\n",
-    "# Hour-of-day global mean (captures daily rhythm)\n",
-    "hour_mean = (train.groupby('hour')['demand']\n",
-    "             .mean().reset_index()\n",
-    "             .rename(columns={'demand':'hour_global_mean'}))\n",
-    "\n",
-    "def apply_aggs(df):\n",
-    "    df = df.merge(geo_stats, on='geohash', how='left')\n",
-    "    df = df.merge(geo_hour_demand, on=['geohash','hour'], how='left')\n",
-    "    df = df.merge(geo_ts_mean, on=['geohash','timestamp'], how='left')\n",
-    "    df = df.merge(geo3_hour, on=['geo3','hour'], how='left')\n",
-    "    df = df.merge(geo3_mean, on='geo3', how='left')\n",
-    "    df = df.merge(hour_mean, on='hour', how='left')\n",
-    "    # Impute missing lag1d using geo_ts_mean\n",
-    "    df['demand_lag1d'] = df['demand_lag1d'].fillna(df['geo_ts_mean'])\n",
-    "    return df\n",
-    "\n",
-    "train = apply_aggs(train)\n",
-    "test  = apply_aggs(test)\n",
-    "\n",
-    "print('Aggregation features done.')\n",
-    "print(f'Train features: {train.shape[1]}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Model Training"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "FEATURES = [\n",
-    "    'lat', 'lon',\n",
-    "    'hour', 'minute', 'day',\n",
-    "    'time_sin', 'time_cos', 'day_sin', 'day_cos',\n",
-    "    'RoadType_enc', 'NumberofLanes', 'LargeVehicles_enc', 'Landmarks_enc',\n",
-    "    'Temperature', 'Weather_enc',\n",
-    "    'demand_lag1d',\n",
-    "    'geo_mean', 'geo_std', 'geo_median', 'geo_max',\n",
-    "    'geo_hour_mean', 'geo_ts_mean', 'geo3_hour_mean', 'geo3_mean',\n",
-    "    'hour_global_mean',\n",
-    "]\n",
-    "\n",
-    "X = train[FEATURES].fillna(-1)\n",
-    "y = train['demand']\n",
-    "X_test = test[FEATURES].fillna(-1)\n",
-    "\n",
-    "# Cross-val: train on day48, validate on day49\n",
-    "mask49 = train['day'] == 49\n",
-    "X_tr, y_tr = X[~mask49], y[~mask49]\n",
-    "X_va, y_va = X[mask49],  y[mask49]\n",
-    "\n",
-    "print(f'CV split — train: {X_tr.shape}, val: {X_va.shape}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ── LightGBM ──────────────────────────────────────────────────────────────────\n",
-    "lgbm_params = dict(\n",
-    "    n_estimators=5000,\n",
-    "    learning_rate=0.015,\n",
-    "    num_leaves=255,\n",
-    "    min_child_samples=15,\n",
-    "    subsample=0.8, subsample_freq=1,\n",
-    "    colsample_bytree=0.8,\n",
-    "    reg_alpha=0.05, reg_lambda=0.1,\n",
-    "    random_state=42, verbose=-1, n_jobs=-1,\n",
-    ")\n",
-    "\n",
-    "lgbm_cv = LGBMRegressor(**lgbm_params)\n",
-    "lgbm_cv.fit(X_tr, y_tr)\n",
-    "lgbm_cv_pred = lgbm_cv.predict(X_va)\n",
-    "lgbm_r2 = r2_score(y_va, lgbm_cv_pred)\n",
-    "print(f'LightGBM CV R2: {lgbm_r2:.4f}  score: {max(0,100*lgbm_r2):.2f}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ── XGBoost ───────────────────────────────────────────────────────────────────\n",
-    "xgb_params = dict(\n",
-    "    n_estimators=5000,\n",
-    "    learning_rate=0.015,\n",
-    "    max_depth=8,\n",
-    "    subsample=0.8,\n",
-    "    colsample_bytree=0.8,\n",
-    "    reg_alpha=0.05, reg_lambda=0.1,\n",
-    "    random_state=42, verbosity=0, n_jobs=-1,\n",
-    "    tree_method='hist',\n",
-    ")\n",
-    "\n",
-    "xgb_cv = XGBRegressor(**xgb_params)\n",
-    "xgb_cv.fit(X_tr, y_tr)\n",
-    "xgb_cv_pred = xgb_cv.predict(X_va)\n",
-    "xgb_r2 = r2_score(y_va, xgb_cv_pred)\n",
-    "print(f'XGBoost CV R2: {xgb_r2:.4f}  score: {max(0,100*xgb_r2):.2f}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ── Ensemble: find best blend weight ─────────────────────────────────────────\n",
-    "best_w, best_r2 = 0, -999\n",
-    "for w in np.arange(0, 1.05, 0.05):\n",
-    "    blend = w * lgbm_cv_pred + (1 - w) * xgb_cv_pred\n",
-    "    r2 = r2_score(y_va, blend)\n",
-    "    if r2 > best_r2:\n",
-    "        best_r2, best_w = r2, w\n",
-    "\n",
-    "print(f'Best blend: {best_w:.2f} * LightGBM + {1-best_w:.2f} * XGBoost')\n",
-    "print(f'Ensemble CV R2: {best_r2:.4f}  score: {max(0,100*best_r2):.2f}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ── Train final models on ALL data ────────────────────────────────────────────\n",
-    "print('Training final LightGBM...')\n",
-    "lgbm_final = LGBMRegressor(**lgbm_params)\n",
-    "lgbm_final.fit(X, y)\n",
-    "\n",
-    "print('Training final XGBoost...')\n",
-    "xgb_final = XGBRegressor(**xgb_params)\n",
-    "xgb_final.fit(X, y)\n",
-    "\n",
-    "# Blend predictions\n",
-    "lgbm_test_pred = lgbm_final.predict(X_test)\n",
-    "xgb_test_pred  = xgb_final.predict(X_test)\n",
-    "final_preds = np.clip(\n",
-    "    best_w * lgbm_test_pred + (1 - best_w) * xgb_test_pred,\n",
-    "    0, None\n",
-    ")\n",
-    "\n",
-    "print('Done.')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Generate Submission"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "submission = pd.DataFrame({'Index': test['Index'], 'demand': final_preds})\n",
-    "submission.to_csv('submission.csv', index=False)\n",
-    "print(f'Saved submission.csv  shape: {submission.shape}')\n",
-    "submission.head(10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Download from Colab\n",
-    "# from google.colab import files\n",
-    "# files.download('submission.csv')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Feature Importance"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "fi = pd.Series(lgbm_final.feature_importances_, index=FEATURES).sort_values(ascending=True)\n",
-    "fig, ax = plt.subplots(figsize=(8, 8))\n",
-    "fi.plot.barh(ax=ax)\n",
-    "ax.set_title('LightGBM Feature Importances')\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  }
- ]
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:76de0010cf7e8b8130c2bdb26ef3d56ff10af4691be83f027bbe78de8d6a87d7
+size 15595

solve.py

@@ -2,6 +2,7 @@ import numpy as np
 import pandas as pd
 import pygeohash as pgh
 from lightgbm import LGBMRegressor
+from xgboost import XGBRegressor
 from sklearn.metrics import r2_score
 import warnings
 warnings.filterwarnings('ignore')
@@ -12,16 +13,14 @@ print("Loading data...")
 train = pd.read_csv(f'{DATA}/train.csv')
 test  = pd.read_csv(f'{DATA}/test.csv')
 
+# ── Parse / encode ────────────────────────────────────────────────────────────
 def parse_ts(df):
     df = df.copy()
-    df['hour'] = df['timestamp'].map(lambda x: int(x.split(':')[0]))
+    df['hour']   = df['timestamp'].map(lambda x: int(x.split(':')[0]))
     df['minute'] = df['timestamp'].map(lambda x: int(x.split(':')[1]))
-    df['time_min'] = df['day'] * 24 * 60 + df['hour'] * 60 + df['minute']
-    mins_in_day = 24 * 60
-    t = (df['hour'] * 60 + df['minute']) / mins_in_day * 2 * np.pi
+    t = (df['hour'] * 60 + df['minute']) / (24 * 60) * 2 * np.pi
     df['time_sin'] = np.sin(t)
     df['time_cos'] = np.cos(t)
-    # day of week proxy (cyclical)
     d = df['day'] / 7 * 2 * np.pi
     df['day_sin'] = np.sin(d)
     df['day_cos'] = np.cos(d)
@@ -29,131 +28,207 @@ def parse_ts(df):
 
 def decode_geo(df):
     df = df.copy()
-    decoded = df['geohash'].map(lambda x: pgh.decode(x))
+    decoded  = df['geohash'].map(pgh.decode)
     df['lat'] = decoded.map(lambda x: x[0])
     df['lon'] = decoded.map(lambda x: x[1])
-    # geohash prefix for neighbor grouping
-    df['geo4'] = df['geohash'].str[:4]
     df['geo3'] = df['geohash'].str[:3]
     return df
 
 def encode_cats(df):
     df = df.copy()
-    road_map = {'Residential': 0, 'Street': 1, 'Highway': 2}
-    df['RoadType_enc'] = df['RoadType'].map(road_map).fillna(-1)
+    df['RoadType_enc']      = df['RoadType'].map({'Residential': 0, 'Street': 1, 'Highway': 2}).fillna(-1)
     df['LargeVehicles_enc'] = (df['LargeVehicles'] == 'Allowed').astype(float)
-    df['Landmarks_enc'] = (df['Landmarks'] == 'Yes').astype(float)
-    weather_map = {'Sunny': 0, 'Rainy': 1, 'Foggy': 2, 'Snowy': 3}
-    df['Weather_enc'] = df['Weather'].map(weather_map).fillna(-1)
+    df['Landmarks_enc']     = (df['Landmarks'] == 'Yes').astype(float)
+    df['Weather_enc']       = df['Weather'].map({'Sunny': 0, 'Rainy': 1, 'Foggy': 2, 'Snowy': 3}).fillna(-1)
     return df
 
-print("Parsing features...")
-train = parse_ts(train)
-train = decode_geo(train)
-train = encode_cats(train)
-test  = parse_ts(test)
-test  = decode_geo(test)
-test  = encode_cats(test)
-
-# ── Lag features ──────────────────────────────────────────────────────────────
-train48 = train[train['day'] == 48][['geohash', 'timestamp', 'demand']].rename(
-    columns={'demand': 'demand_lag1d'})
-
-# Same geohash+timestamp, 1 day earlier
-train = train.merge(train48, on=['geohash', 'timestamp'], how='left')
-test  = test.merge(train48,  on=['geohash', 'timestamp'], how='left')
-
-# ── Static geohash aggregations (from ALL train) ─────────────────────────────
-geo_stats = (train.groupby('geohash')['demand']
-             .agg(['mean', 'std', 'median', 'max'])
-             .reset_index()
-             .rename(columns={'mean':'geo_mean', 'std':'geo_std',
-                              'median':'geo_median', 'max':'geo_max'}))
-train = train.merge(geo_stats, on='geohash', how='left')
-test  = test.merge(geo_stats, on='geohash', how='left')
-
-# geohash + hour bucket mean
-geo_hour = (train.groupby(['geohash', 'hour'])['demand']
-            .mean().reset_index().rename(columns={'demand': 'geo_hour_mean'}))
-train = train.merge(geo_hour, on=['geohash', 'hour'], how='left')
-test  = test.merge(geo_hour, on=['geohash', 'hour'], how='left')
-
-# geohash + timestamp exact mean (over train days)
-geo_ts_mean = (train.groupby(['geohash', 'timestamp'])['demand']
-               .mean().reset_index().rename(columns={'demand': 'geo_ts_mean'}))
-train = train.merge(geo_ts_mean, on=['geohash', 'timestamp'], how='left')
-test  = test.merge(geo_ts_mean, on=['geohash', 'timestamp'], how='left')
-
-# geo3 (neighbourhood) hour mean
-geo3_hour = (train.groupby(['geo3', 'hour'])['demand']
-             .mean().reset_index().rename(columns={'demand': 'geo3_hour_mean'}))
-train = train.merge(geo3_hour, on=['geo3', 'hour'], how='left')
-test  = test.merge(geo3_hour, on=['geo3', 'hour'], how='left')
-
-# Impute missing lag1d using geo_ts_mean as proxy
-train['demand_lag1d'] = train['demand_lag1d'].fillna(train['geo_ts_mean'])
-test['demand_lag1d']  = test['demand_lag1d'].fillna(test['geo_ts_mean'])
-
-# geo std fill
-train['geo_std'] = train['geo_std'].fillna(0)
-test['geo_std']  = test['geo_std'].fillna(0)
+train = parse_ts(train); train = decode_geo(train); train = encode_cats(train)
+test  = parse_ts(test);  test  = decode_geo(test);  test  = encode_cats(test)
+
+# ── Neighbor cache ────────────────────────────────────────────────────────────
+print("Building neighbor cache...")
+all_geohashes = list(set(train['geohash']) | set(test['geohash']))
+neighbor_cache = {}
+for gh in all_geohashes:
+    t = pgh.get_adjacent(gh, 'top');    b = pgh.get_adjacent(gh, 'bottom')
+    l = pgh.get_adjacent(gh, 'left');   r = pgh.get_adjacent(gh, 'right')
+    tl = pgh.get_adjacent(t, 'left');   tr = pgh.get_adjacent(t, 'right')
+    bl = pgh.get_adjacent(b, 'left');   br = pgh.get_adjacent(b, 'right')
+    neighbor_cache[gh] = [t, b, l, r, tl, tr, bl, br]
+
+def ts_offset(ts, delta_min):
+    h, m = int(ts.split(':')[0]), int(ts.split(':')[1])
+    total = (h * 60 + m + delta_min) % (24 * 60)
+    return f"{total // 60}:{total % 60}"
+
+# ── Core feature builder (given a reference day's lookup dict) ───────────────
+def build_features(df, ref_df):
+    """
+    df      : dataframe to featurize
+    ref_df  : training subset used to compute all statistics (no leakage)
+    """
+    df = df.copy()
+
+    # Lag lookup from ref_df (day 48 in CV, all train for final)
+    lag_lookup = dict(zip(zip(ref_df['geohash'], ref_df['timestamp']), ref_df['demand']))
+
+    # Rolling lags: T, T-15, T-30, T-45, T-60
+    for delta in [0, 15, 30, 45, 60]:
+        col = 'lag1d' if delta == 0 else f'lag1d_m{delta}'
+        if delta == 0:
+            df[col] = [lag_lookup.get((gh, ts), np.nan)
+                       for gh, ts in zip(df['geohash'], df['timestamp'])]
+        else:
+            df[col] = [lag_lookup.get((gh, ts_offset(ts, -delta)), np.nan)
+                       for gh, ts in zip(df['geohash'], df['timestamp'])]
+
+    # Neighbor mean at same timestamp from ref_df
+    df['neighbor_mean'] = [
+        np.nanmean([lag_lookup.get((n, ts), np.nan)
+                    for n in neighbor_cache.get(gh, [])]) or np.nan
+        for gh, ts in zip(df['geohash'], df['timestamp'])
+    ]
+
+    # Aggregations from ref_df
+    geo_stats = (ref_df.groupby('geohash')['demand']
+                 .agg(['mean','std','median','max']).reset_index()
+                 .rename(columns={'mean':'geo_mean','std':'geo_std',
+                                  'median':'geo_median','max':'geo_max'}))
+    geo_stats['geo_std'] = geo_stats['geo_std'].fillna(0)
+    geo_hour = (ref_df.groupby(['geohash','hour'])['demand']
+                .mean().reset_index().rename(columns={'demand':'geo_hour_mean'}))
+    geo_ts   = (ref_df.groupby(['geohash','timestamp'])['demand']
+                .mean().reset_index().rename(columns={'demand':'geo_ts_mean'}))
+    geo3_h   = (ref_df.groupby(['geo3','hour'])['demand']
+                .mean().reset_index().rename(columns={'demand':'geo3_hour_mean'}))
+    geo3_m   = (ref_df.groupby('geo3')['demand']
+                .mean().reset_index().rename(columns={'demand':'geo3_mean'}))
+    hr_mean  = (ref_df.groupby('hour')['demand']
+                .mean().reset_index().rename(columns={'demand':'hour_global_mean'}))
+    # Day-49 early hours baseline (if available in ref_df)
+    day49_early = ref_df[ref_df['day'] == 49] if 'day' in ref_df.columns else ref_df.iloc[0:0]
+    if len(day49_early):
+        d49_base = (day49_early.groupby('geohash')['demand']
+                    .mean().reset_index().rename(columns={'demand':'geo_d49_mean'}))
+    else:
+        d49_base = pd.DataFrame({'geohash': [], 'geo_d49_mean': []})
+
+    df = df.merge(geo_stats, on='geohash', how='left')
+    df = df.merge(geo_hour,  on=['geohash','hour'], how='left')
+    df = df.merge(geo_ts,    on=['geohash','timestamp'], how='left')
+    df = df.merge(geo3_h,    on=['geo3','hour'], how='left')
+    df = df.merge(geo3_m,    on='geo3', how='left')
+    df = df.merge(hr_mean,   on='hour', how='left')
+    df = df.merge(d49_base,  on='geohash', how='left')
+
+    # Daily ratio: day49_morning / day48_morning per geohash
+    # Signals if today is busier/quieter than yesterday overall
+    day48_am = (ref_df[ref_df['day'] == 48][ref_df['hour'] < 4] if len(ref_df[ref_df['day'] == 48]) else ref_df.iloc[0:0])
+    day49_am = (day49_early[day49_early['hour'] < 4] if len(day49_early) else pd.DataFrame())
+
+    if len(day48_am) and len(day49_am):
+        d48_am_mean = day48_am.groupby('geohash')['demand'].mean().rename('d48_am')
+        d49_am_mean = day49_am.groupby('geohash')['demand'].mean().rename('d49_am')
+        ratio_df = pd.concat([d48_am_mean, d49_am_mean], axis=1).reset_index()
+        ratio_df['daily_ratio'] = ratio_df['d49_am'] / ratio_df['d48_am'].replace(0, np.nan)
+        ratio_df = ratio_df[['geohash', 'daily_ratio']]
+        df = df.merge(ratio_df, on='geohash', how='left')
+    else:
+        df['daily_ratio'] = np.nan
+
+    # Impute missing lags with fallback chain
+    fallback = df['neighbor_mean'].fillna(df['geo_ts_mean']).fillna(df['geo_hour_mean'])
+    for col in ['lag1d','lag1d_m15','lag1d_m30','lag1d_m45','lag1d_m60']:
+        df[col] = df[col].fillna(fallback)
+
+    return df
 
 FEATURES = [
-    'lat', 'lon',
-    'hour', 'minute', 'day',
+    'lat', 'lon', 'hour', 'minute', 'day',
     'time_sin', 'time_cos', 'day_sin', 'day_cos',
     'RoadType_enc', 'NumberofLanes', 'LargeVehicles_enc', 'Landmarks_enc',
     'Temperature', 'Weather_enc',
-    'demand_lag1d',
+    'lag1d', 'lag1d_m15', 'lag1d_m30', 'lag1d_m45', 'lag1d_m60',
+    'neighbor_mean',
     'geo_mean', 'geo_std', 'geo_median', 'geo_max',
-    'geo_hour_mean', 'geo_ts_mean', 'geo3_hour_mean',
+    'geo_hour_mean', 'geo_ts_mean', 'geo3_hour_mean', 'geo3_mean',
+    'hour_global_mean', 'geo_d49_mean', 'daily_ratio',
 ]
 
-X_train = train[FEATURES].fillna(-1)
-y_train = train['demand']
-X_test  = test[FEATURES].fillna(-1)
-
-print(f"Train: {X_train.shape}, Test: {X_test.shape}")
-
-# ── CV: train on day48, validate on day49 ────────────────────────────────────
-mask49 = train['day'] == 49
-X_cv_tr, y_cv_tr = X_train[~mask49], y_train[~mask49]
-X_cv_va, y_cv_va = X_train[mask49],  y_train[mask49]
-
-PARAMS = dict(
-    n_estimators=3000,
-    learning_rate=0.02,
-    num_leaves=255,
-    max_depth=-1,
-    min_child_samples=15,
-    subsample=0.8,
-    subsample_freq=1,
-    colsample_bytree=0.8,
-    reg_alpha=0.05,
-    reg_lambda=0.1,
-    random_state=42,
-    verbose=-1,
-    n_jobs=-1,
+LGBM_PARAMS = dict(
+    n_estimators=3000, learning_rate=0.02, num_leaves=255,
+    min_child_samples=15, subsample=0.8, subsample_freq=1,
+    colsample_bytree=0.8, reg_alpha=0.05, reg_lambda=0.1,
+    random_state=42, verbose=-1, n_jobs=-1,
+)
+XGB_PARAMS = dict(
+    n_estimators=3000, learning_rate=0.02, max_depth=8,
+    subsample=0.8, colsample_bytree=0.8,
+    reg_alpha=0.05, reg_lambda=0.1,
+    random_state=42, verbosity=0, n_jobs=-1, tree_method='hist',
 )
 
-print("\nCV training (day48->day49)...")
-m_cv = LGBMRegressor(**PARAMS)
-m_cv.fit(X_cv_tr, y_cv_tr,
-         eval_set=[(X_cv_va, y_cv_va)])
-cv_pred = m_cv.predict(X_cv_va)
-cv_r2 = r2_score(y_cv_va, cv_pred)
-print(f"CV R2: {cv_r2:.4f}  |  competition score: {max(0, 100*cv_r2):.2f}")
-
-print("\nFull training on all data...")
-model = LGBMRegressor(**PARAMS)
-model.fit(X_train, y_train)
+# ── Proper CV: ref = day48 only ───────────────────────────────────────────────
+print("\nBuilding CV features (ref=day48 only)...")
+train48 = train[train['day'] == 48]
+train49 = train[train['day'] == 49]
+
+tr_cv = build_features(train48, train48)   # train on day48, featurized vs day48
+va_cv = build_features(train49, train48)   # val on day49, but stats from day48 only
+
+X_tr = tr_cv[FEATURES].fillna(-1);  y_tr = train48['demand'].values
+X_va = va_cv[FEATURES].fillna(-1);  y_va = train49['demand'].values
+
+print(f"CV — train: {X_tr.shape}  val: {X_va.shape}")
+
+print("\nTraining LGBM CV...")
+lgbm_cv = LGBMRegressor(**LGBM_PARAMS)
+lgbm_cv.fit(X_tr, y_tr)
+lp = lgbm_cv.predict(X_va)
+lgbm_r2 = r2_score(y_va, lp)
+print(f"LGBM CV R2: {lgbm_r2:.4f}  score: {max(0, 100*lgbm_r2):.2f}")
+
+print("\nTraining XGB CV...")
+xgb_cv = XGBRegressor(**XGB_PARAMS)
+xgb_cv.fit(X_tr, y_tr)
+xp = xgb_cv.predict(X_va)
+xgb_r2 = r2_score(y_va, xp)
+print(f"XGB CV R2:  {xgb_r2:.4f}  score: {max(0, 100*xgb_r2):.2f}")
+
+best_w, best_r2 = 0, -999
+for w in np.arange(0, 1.05, 0.05):
+    r2 = r2_score(y_va, w * lp + (1 - w) * xp)
+    if r2 > best_r2:
+        best_r2, best_w = r2, w
+print(f"\nBest blend {best_w:.2f}*LGBM + {1-best_w:.2f}*XGB: R2={best_r2:.4f}  score={max(0, 100*best_r2):.2f}")
+
+# ── Final model: ref = ALL train ──────────────────────────────────────────────
+print("\nBuilding final features (ref=all train)...")
+train_full = build_features(train, train)
+test_full  = build_features(test,  train)
+
+X_all  = train_full[FEATURES].fillna(-1)
+y_all  = train['demand'].values
+X_test = test_full[FEATURES].fillna(-1)
+
+print("Training final LGBM...")
+lgbm_f = LGBMRegressor(**LGBM_PARAMS)
+lgbm_f.fit(X_all, y_all)
+
+print("Training final XGB...")
+xgb_f = XGBRegressor(**XGB_PARAMS)
+xgb_f.fit(X_all, y_all)
+
+preds = np.clip(
+    best_w * lgbm_f.predict(X_test) + (1 - best_w) * xgb_f.predict(X_test),
+    0, None
+)
 
-preds = np.clip(model.predict(X_test), 0, None)
 submission = pd.DataFrame({'Index': test['Index'], 'demand': preds})
 submission.to_csv('submission.csv', index=False)
-print(f"Saved submission.csv  ({len(submission)} rows)")
+print(f"\nSaved submission.csv  ({len(submission)} rows)")
 print(submission.head())
 
-fi = pd.Series(model.feature_importances_, index=FEATURES).sort_values(ascending=False)
+fi = pd.Series(lgbm_f.feature_importances_, index=FEATURES).sort_values(ascending=False)
 print("\nTop feature importances:")
 print(fi.head(15))

traffic-management-travel-demand-forecast (1).ipynb

@@ -1,1085 +1,3 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Introduction\n",
-    "This notebook is a submission to **Grab AI For Sea Challenge - Traffic Management**, to forecast travel demand based on historical Grab bookings. \n",
-    "Challenge website: https://www.aiforsea.com/traffic-management\n",
-    "\n",
-    "There are **four parts** in this notebook:\n",
-    "* **Data cleaning & preprocessing**\n",
-    "* **Model selection: Random Forest vs. XGBoost**\n",
-    "* **Define a function to predict demands of T+1, ..., T+5 using known data till T**\n",
-    "* **Predict demands of T+1, ..., T+5 using test data.** \n",
-    "\n",
-    "The test dataset can start from any time period after the timeframe of the training dataset. My model will use features from the test dataset ending at timestamp T and predict T+1 to T+5 for all the geohashes which appeared in the training dataset. \n",
-    "\n",
-    "Each time interval in this challenge is 15 minutes.\n",
-    "\n",
-    "**For evaluators**: please uncomment the code in Part 4 and fill in the link of test dataset. The code will produce a CSV file containing the demand forecasts for T+1 to T+5 for all the geohashes from the training set. Please run all codes in this notebook to avoid any errors. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
-    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['training.csv']\n"
-     ]
-    }
-   ],
-   "source": [
-    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
-    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
-    "# For example, here's several helpful packages to load in \n",
-    "\n",
-    "import numpy as np # linear algebra\n",
-    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
-    "\n",
-    "# Input data files are available in the \"../input/\" directory.\n",
-    "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
-    "\n",
-    "import os\n",
-    "print(os.listdir(\"../input\"))\n",
-    "\n",
-    "# Any results you write to the current directory are saved as output."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Part 1 - Data Cleaning & Preprocessing"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Take a look at training set:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
-    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>geohash6</th>\n",
-       "      <th>day</th>\n",
-       "      <th>timestamp</th>\n",
-       "      <th>demand</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>qp03wc</td>\n",
-       "      <td>18</td>\n",
-       "      <td>20:0</td>\n",
-       "      <td>0.020072</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>qp03pn</td>\n",
-       "      <td>10</td>\n",
-       "      <td>14:30</td>\n",
-       "      <td>0.024721</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>qp09sw</td>\n",
-       "      <td>9</td>\n",
-       "      <td>6:15</td>\n",
-       "      <td>0.102821</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>qp0991</td>\n",
-       "      <td>32</td>\n",
-       "      <td>5:0</td>\n",
-       "      <td>0.088755</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>qp090q</td>\n",
-       "      <td>15</td>\n",
-       "      <td>4:0</td>\n",
-       "      <td>0.074468</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "  geohash6  day timestamp    demand\n",
-       "0   qp03wc   18      20:0  0.020072\n",
-       "1   qp03pn   10     14:30  0.024721\n",
-       "2   qp09sw    9      6:15  0.102821\n",
-       "3   qp0991   32       5:0  0.088755\n",
-       "4   qp090q   15       4:0  0.074468"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import seaborn as sns\n",
-    "\n",
-    "df_train = pd.read_csv('../input/training.csv')\n",
-    "df_train.head()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Size of training data:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(4206321, 4)"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_train.shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1329 unique locations in the data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1329"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(df_train.geohash6.unique())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Convert timestamp into hours and mininutes:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>geohash6</th>\n",
-       "      <th>day</th>\n",
-       "      <th>timestamp</th>\n",
-       "      <th>demand</th>\n",
-       "      <th>hours</th>\n",
-       "      <th>mins</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>qp03wc</td>\n",
-       "      <td>18</td>\n",
-       "      <td>20:0</td>\n",
-       "      <td>0.020072</td>\n",
-       "      <td>20</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>qp03pn</td>\n",
-       "      <td>10</td>\n",
-       "      <td>14:30</td>\n",
-       "      <td>0.024721</td>\n",
-       "      <td>14</td>\n",
-       "      <td>30</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>qp09sw</td>\n",
-       "      <td>9</td>\n",
-       "      <td>6:15</td>\n",
-       "      <td>0.102821</td>\n",
-       "      <td>6</td>\n",
-       "      <td>15</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>qp0991</td>\n",
-       "      <td>32</td>\n",
-       "      <td>5:0</td>\n",
-       "      <td>0.088755</td>\n",
-       "      <td>5</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>qp090q</td>\n",
-       "      <td>15</td>\n",
-       "      <td>4:0</td>\n",
-       "      <td>0.074468</td>\n",
-       "      <td>4</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "  geohash6  day timestamp    demand  hours  mins\n",
-       "0   qp03wc   18      20:0  0.020072     20     0\n",
-       "1   qp03pn   10     14:30  0.024721     14    30\n",
-       "2   qp09sw    9      6:15  0.102821      6    15\n",
-       "3   qp0991   32       5:0  0.088755      5     0\n",
-       "4   qp090q   15       4:0  0.074468      4     0"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_train['hours'] = df_train['timestamp'].map(lambda x: int(x.split(':')[0]))\n",
-    "df_train['mins'] = df_train['timestamp'].map(lambda x: int(x.split(':')[1]))\n",
-    "df_train.head()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Convert day, hours, mins into a single feature **\"time\"**:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>geohash6</th>\n",
-       "      <th>day</th>\n",
-       "      <th>timestamp</th>\n",
-       "      <th>demand</th>\n",
-       "      <th>hours</th>\n",
-       "      <th>mins</th>\n",
-       "      <th>time</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>qp03wc</td>\n",
-       "      <td>18</td>\n",
-       "      <td>20:0</td>\n",
-       "      <td>0.020072</td>\n",
-       "      <td>20</td>\n",
-       "      <td>0</td>\n",
-       "      <td>25680</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>qp03pn</td>\n",
-       "      <td>10</td>\n",
-       "      <td>14:30</td>\n",
-       "      <td>0.024721</td>\n",
-       "      <td>14</td>\n",
-       "      <td>30</td>\n",
-       "      <td>13830</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>qp09sw</td>\n",
-       "      <td>9</td>\n",
-       "      <td>6:15</td>\n",
-       "      <td>0.102821</td>\n",
-       "      <td>6</td>\n",
-       "      <td>15</td>\n",
-       "      <td>11895</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>qp0991</td>\n",
-       "      <td>32</td>\n",
-       "      <td>5:0</td>\n",
-       "      <td>0.088755</td>\n",
-       "      <td>5</td>\n",
-       "      <td>0</td>\n",
-       "      <td>44940</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>qp090q</td>\n",
-       "      <td>15</td>\n",
-       "      <td>4:0</td>\n",
-       "      <td>0.074468</td>\n",
-       "      <td>4</td>\n",
-       "      <td>0</td>\n",
-       "      <td>20400</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "  geohash6  day timestamp    demand  hours  mins   time\n",
-       "0   qp03wc   18      20:0  0.020072     20     0  25680\n",
-       "1   qp03pn   10     14:30  0.024721     14    30  13830\n",
-       "2   qp09sw    9      6:15  0.102821      6    15  11895\n",
-       "3   qp0991   32       5:0  0.088755      5     0  44940\n",
-       "4   qp090q   15       4:0  0.074468      4     0  20400"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_train['time'] = 24*60*(df_train['day']-1) + 60*df_train['hours'] + df_train['mins']\n",
-    "df_train.head()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Convert geohash6 into latitude and longtitude:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>geohash6</th>\n",
-       "      <th>day</th>\n",
-       "      <th>timestamp</th>\n",
-       "      <th>demand</th>\n",
-       "      <th>hours</th>\n",
-       "      <th>mins</th>\n",
-       "      <th>time</th>\n",
-       "      <th>Latitude</th>\n",
-       "      <th>Longitude</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>qp02zd</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.022396</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-5.479431</td>\n",
-       "      <td>90.686646</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>qp02zu</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.001831</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-5.468445</td>\n",
-       "      <td>90.697632</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>qp02zt</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.001112</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-5.462952</td>\n",
-       "      <td>90.686646</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>qp02zv</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.006886</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-5.462952</td>\n",
-       "      <td>90.697632</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>qp08bj</td>\n",
-       "      <td>1</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.066376</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-5.462952</td>\n",
-       "      <td>90.708618</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "  geohash6  day timestamp    demand    ...      mins  time  Latitude  Longitude\n",
-       "0   qp02zd    1       0:0  0.022396    ...         0     0 -5.479431  90.686646\n",
-       "1   qp02zu    1       0:0  0.001831    ...         0     0 -5.468445  90.697632\n",
-       "2   qp02zt    1       0:0  0.001112    ...         0     0 -5.462952  90.686646\n",
-       "3   qp02zv    1       0:0  0.006886    ...         0     0 -5.462952  90.697632\n",
-       "4   qp08bj    1       0:0  0.066376    ...         0     0 -5.462952  90.708618\n",
-       "\n",
-       "[5 rows x 9 columns]"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import Geohash\n",
-    "df_train['Latitude'] = df_train.geohash6.map(lambda x: float(Geohash.decode_exactly(x)[0]))\n",
-    "df_train['Longitude'] = df_train.geohash6.map(lambda x: float(Geohash.decode_exactly(x)[1]))\n",
-    "df_train = df_train.sort_values(by=['time','Latitude','Longitude'], ascending=True)\n",
-    "df_train = df_train.reset_index().drop('index',axis=1)\n",
-    "df_train.head()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Not all locations appear in all time slots"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>demand</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>geohash6</th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>qp02yc</th>\n",
-       "      <td>577</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02yf</th>\n",
-       "      <td>89</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02yu</th>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02yv</th>\n",
-       "      <td>7</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02yy</th>\n",
-       "      <td>106</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02yz</th>\n",
-       "      <td>879</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02z1</th>\n",
-       "      <td>1153</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02z3</th>\n",
-       "      <td>567</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02z4</th>\n",
-       "      <td>448</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>qp02z5</th>\n",
-       "      <td>1491</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "          demand\n",
-       "geohash6        \n",
-       "qp02yc       577\n",
-       "qp02yf        89\n",
-       "qp02yu         2\n",
-       "qp02yv         7\n",
-       "qp02yy       106\n",
-       "qp02yz       879\n",
-       "qp02z1      1153\n",
-       "qp02z3       567\n",
-       "qp02z4       448\n",
-       "qp02z5      1491"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_train[['geohash6','demand']].groupby('geohash6').count().head(10)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As the training set is a huge dataset with more than 4 million data, I will only use the last 14 days' data, out of which the last five timestamps are used for testing purpose and the rest is for training purpose."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "max_day = df_train.day.max()\n",
-    "max_time = df_train.time.max()\n",
-    "train_start = df_train[df_train.day==61-13].index[0]\n",
-    "test_start = df_train[df_train.time==max_time-15*4].index[0]\n",
-    "\n",
-    "Xtrain = df_train[['time', 'Latitude','Longitude']].iloc[train_start:test_start,:]\n",
-    "Xtest = df_train[['time', 'Latitude','Longitude']].iloc[test_start:,:]\n",
-    "\n",
-    "ytrain = df_train.demand.iloc[train_start:test_start]\n",
-    "ytest = df_train.demand.iloc[test_start:]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "((990189, 3), (2640, 3), (990189,), (2640,))"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Xtrain.shape, Xtest.shape, ytrain.shape, ytest.shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Part 2 - Model Selection"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Part 2.1 - RandomForestRegressor"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "RMSE: 0.03347819383369924\n"
-     ]
-    }
-   ],
-   "source": [
-    "from sklearn.ensemble import RandomForestRegressor\n",
-    "from sklearn.metrics import mean_squared_error\n",
-    "\n",
-    "model = RandomForestRegressor(n_estimators=30, max_depth=40)\n",
-    "model.fit(Xtrain, ytrain)\n",
-    "ytest_pred = model.predict(Xtest)\n",
-    "rmse = np.sqrt(mean_squared_error(ytest, ytest_pred))\n",
-    "print('RMSE:',rmse)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Part 2.2 - XGBRegressor"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.6/site-packages/xgboost/core.py:587: FutureWarning: Series.base is deprecated and will be removed in a future version\n",
-      "  if getattr(data, 'base', None) is not None and \\\n",
-      "/opt/conda/lib/python3.6/site-packages/xgboost/core.py:588: FutureWarning: Series.base is deprecated and will be removed in a future version\n",
-      "  data.base is not None and isinstance(data, np.ndarray) \\\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "RMSE: 0.032064894772248616\n"
-     ]
-    }
-   ],
-   "source": [
-    "from xgboost import XGBRegressor\n",
-    "\n",
-    "model = XGBRegressor(n_estimators=500, learning_rate=0.05, max_depth=35)\n",
-    "model.fit(Xtrain, ytrain)\n",
-    "ytest_pred = model.predict(Xtest)\n",
-    "rmse = np.sqrt(mean_squared_error(ytest, ytest_pred))\n",
-    "print('RMSE:',rmse)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### From above output, XGBRegressor produces a smaller RMSE than RandomForestRegressor. Hence XGBRegressor will be used. \n",
-    "#### All the hyperparameters above have been refined.[](http://)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Define a function to convert time into day, hour, minute and timestamp:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def convert_time(time):\n",
-    "    day = int(time/(24*60)) + 1\n",
-    "    hour = int((time-(day-1)*24*60)/60)\n",
-    "    minute = time-(day-1)*24*60-hour*60\n",
-    "    timestamp = ':'.join((str(hour),str(minute)))\n",
-    "    return (day, hour, minute, timestamp)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Part 3 - Define a function to predict demands of T+1, ..., T+5 using known data till T "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def predict5ts(link, n_estimators=500, learning_rate=0.05, max_depth=35):\n",
-    "    df = pd.read_csv(link)\n",
-    "    df['hours'] = df['timestamp'].map(lambda x: int(x.split(':')[0]))\n",
-    "    df['mins'] = df['timestamp'].map(lambda x: int(x.split(':')[1]))\n",
-    "    df['time'] = 24*60*(df['day']-1) + 60*df['hours'] + df['mins']\n",
-    "    \n",
-    "    import Geohash\n",
-    "    df['Latitude'] = df.geohash6.map(lambda x: float(Geohash.decode_exactly(x)[0]))\n",
-    "    df['Longitude'] = df.geohash6.map(lambda x: float(Geohash.decode_exactly(x)[1]))\n",
-    "\n",
-    "    df = df.sort_values(by=['time','Latitude','Longitude'], ascending=True)\n",
-    "    df = df.reset_index().drop('index',axis=1)\n",
-    "    \n",
-    "    X = df[['time', 'Latitude','Longitude']]\n",
-    "    y = df.demand\n",
-    "    \n",
-    "    from xgboost import XGBRegressor\n",
-    "    model = XGBRegressor(n_estimators=n_estimators, learning_rate=learning_rate, max_depth=max_depth)\n",
-    "    model.fit(X, y)\n",
-    "    \n",
-    "    T = df.time.max()\n",
-    "    T1 = T+15\n",
-    "    T2 = T+15*2\n",
-    "    T3 = T+15*3\n",
-    "    T4 = T+15*4\n",
-    "    T5 = T+15*5\n",
-    "    \n",
-    "    geohashes = df_train.geohash6.unique()\n",
-    "    geohashes2 = []\n",
-    "    latitudes = []\n",
-    "    longitudes = []\n",
-    "    times = []\n",
-    "    days = []\n",
-    "    timestamps = []\n",
-    "\n",
-    "    for t in (T1,T2,T3,T4,T5):\n",
-    "        for gh in geohashes:\n",
-    "            geohashes2.append(gh)\n",
-    "            latitudes.append(float(Geohash.decode_exactly(gh)[0]))\n",
-    "            longitudes.append(float(Geohash.decode_exactly(gh)[1]))\n",
-    "            times.append(t)\n",
-    "            days.append(convert_time(t)[0])\n",
-    "            timestamps.append(convert_time(t)[-1])\n",
-    "\n",
-    "    df_pred = pd.DataFrame({'geohash6': geohashes2, 'day': days, 'timestamp': timestamps,\n",
-    "                        'time': times, 'Latitude': latitudes, 'Longitude': longitudes})\n",
-    "    Xtest = df_pred[['time', 'Latitude','Longitude']]\n",
-    "    ypred = model.predict(Xtest)\n",
-    "\n",
-    "    df_pred['demand'] = ypred\n",
-    "    output = df_pred[['geohash6', 'day', 'timestamp', 'demand']]\n",
-    "    output.to_csv('output.csv', index=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Check if the above function works by testing a small portion of data from the training set."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.6/site-packages/xgboost/core.py:587: FutureWarning: Series.base is deprecated and will be removed in a future version\n",
-      "  if getattr(data, 'base', None) is not None and \\\n",
-      "/opt/conda/lib/python3.6/site-packages/xgboost/core.py:588: FutureWarning: Series.base is deprecated and will be removed in a future version\n",
-      "  data.base is not None and isinstance(data, np.ndarray) \\\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(6645, 4)\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>geohash6</th>\n",
-       "      <th>day</th>\n",
-       "      <th>timestamp</th>\n",
-       "      <th>demand</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>qp02zd</td>\n",
-       "      <td>62</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.014072</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>qp02zu</td>\n",
-       "      <td>62</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.039789</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>qp02zt</td>\n",
-       "      <td>62</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.137830</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>qp02zv</td>\n",
-       "      <td>62</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.042405</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>qp08bj</td>\n",
-       "      <td>62</td>\n",
-       "      <td>0:0</td>\n",
-       "      <td>0.054124</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "  geohash6  day timestamp    demand\n",
-       "0   qp02zd   62       0:0  0.014072\n",
-       "1   qp02zu   62       0:0  0.039789\n",
-       "2   qp02zt   62       0:0  0.137830\n",
-       "3   qp02zv   62       0:0  0.042405\n",
-       "4   qp08bj   62       0:0  0.054124"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_trial = df_train[['geohash6','day','timestamp','demand']].iloc[-20000:,:]\n",
-    "df_trial.to_csv('df_trial.csv', index=False)\n",
-    "\n",
-    "trial_link = 'df_trial.csv'\n",
-    "predict5ts(link=trial_link)\n",
-    "\n",
-    "output = pd.read_csv('output.csv')\n",
-    "print(output.shape)\n",
-    "output.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "os.remove(\"df_trial.csv\")\n",
-    "os.remove(\"output.csv\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Part 4 - Predict demands of T+1, ..., T+5 using test data\n",
-    "* Please uncomment below code and enter the link of test data.\n",
-    "* Below code will produce an output file **output.csv** which is the demand forecast of T+1,...,T+5 for all the geo-locations, where T is the last time stamp in the test data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#test_link = '...'\n",
-    "#predict5ts(link=test_link)"
-   ]
-  }
- ],
- "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.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c261e5da02bf183147144454ea16d21eeb96273b6b53f8772334587c5c6672c
+size 31277