Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.ipynb filter=lfs diff=lfs merge=lfs -text

e88186124ec611f1/dataset/sample_submission.csv

@@ -0,0 +1,6 @@
+Index,demand
+0,0.090767774072159
+1,0.0898848048932868
+2,0.0070368435076525
+3,0.0790872273785951
+4,0.0546359836658569

gridlock_solution.ipynb

@@ -0,0 +1,448 @@
+{
+ "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()"
+   ]
+  }
+ ]
+}

instructions/instructions.md

@@ -0,0 +1,95 @@
+# Gridlock Hackathon 2.0
+
+**Platform:** Flipkart  
+**Status:** LIVE  
+**Duration:** May 26, 2026, 10:00 PM IST (Asia/Kolkata) – Jun 07, 2026, 11:59 PM IST (Asia/Kolkata)
+
+---
+
+## Problem: Traffic Demand Prediction
+
+**Max score:** 100
+
+### Background
+
+Cities worldwide are increasingly turning to AI-powered solutions to tackle traffic congestion. This problem disrupts the smooth flow of transportation and poses a significant barrier to economic growth. To address this challenge effectively, the first step is to understand travel demand and patterns within urban areas comprehensively. By harnessing the power of AI, cities and regions aim to gather critical insights into transportation dynamics. This will enable them to implement data-driven strategies and solutions to alleviate traffic congestion and promote more efficient mobility. Ultimately, this endeavor will foster economic development and prosperity.
+
+### Task
+
+Design a system that helps us provide valuable insights into passenger travel patterns, booking behavior, and trip cancellations, which can be used for various analyses and predict demand in the travel industry.
+
+---
+
+## Dataset
+
+### Files
+
+| File | Shape |
+|------|-------|
+| `train.csv` | 77299 × 11 |
+| `test.csv` | 41778 × 10 |
+| `sample_submission.csv` | 5 × 2 |
+
+### Variable Descriptions
+
+| Column | Description |
+|--------|-------------|
+| `Index` | Unique identification of datapoint |
+| `geohash` | Geographic information regarding a place |
+| `day` | Day when the information is recorded |
+| `timestamp` | Timestamp of the record inserted in the system |
+| `RoadType` | Type of road in the nearby location |
+| `NumberofLanes` | Number of roads/lanes present in the location |
+| `LargeVehicles` | Whether large vehicles are permitted on the specific roads/lanes |
+| `Landmarks` | Whether there are any landmarks near the location |
+| `Temperature` | Temperature of the place |
+| `Weather` | Weather of the place |
+| `demand` | **TARGET** — Demand of traffic at the timestamp (train only) |
+
+---
+
+## Evaluation Metric
+
+```python
+score = max(0, 100 * metrics.r2_score(actual, predicted))
+```
+
+- Higher R² → higher score
+- Score clamped to minimum 0 (negative R² counts as 0)
+- Perfect predictions → score of 100
+
+---
+
+## Submission Requirements
+
+- **Prediction file format:** CSV only
+- **Submission size:** 41778 rows × 2 columns
+- **Required columns:**
+  - `Index` — correct index values as per the test file
+  - `demand` — predicted demand values
+- Column names must match `sample_submission.csv` exactly
+
+---
+
+## How to Submit
+
+1. Download dataset from the problem page
+2. Solve the problem in your local environment
+3. Save predictions in a `.csv` file
+4. Upload prediction file via **Upload Prediction File → Choose File → Submit & Evaluate**
+5. Upload source code via **Upload Source Files** (zip or tar archive containing):
+   - Text file explaining your approach
+   - Details about feature engineering
+   - Tools used
+   - Relevant source files (`.ipynb` + any presentation file)
+6. Add instructions/comments in the **Your Answer** section
+7. Click **Submit**
+
+---
+
+## Key Notes
+
+- **Dataset origin:** Based on the Grab AI for SEA – Traffic Management challenge (public Kaggle dataset). Original Grab data used `geohash6` + `day` + `timestamp` + `demand`.
+- **Scoring:** R² is computed between actual and predicted `demand` on the test set server-side.
+- **Leaderboard:** Live scoring visible on the Leaderboard tab.
+- **Source upload:** Required alongside prediction CSV — judges review approach + feature engineering.

solve.py

@@ -0,0 +1,159 @@
+import numpy as np
+import pandas as pd
+import pygeohash as pgh
+from lightgbm import LGBMRegressor
+from sklearn.metrics import r2_score
+import warnings
+warnings.filterwarnings('ignore')
+
+DATA = 'e88186124ec611f1/dataset'
+
+print("Loading data...")
+train = pd.read_csv(f'{DATA}/train.csv')
+test  = pd.read_csv(f'{DATA}/test.csv')
+
+def parse_ts(df):
+    df = df.copy()
+    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
+    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)
+    return df
+
+def decode_geo(df):
+    df = df.copy()
+    decoded = df['geohash'].map(lambda x: pgh.decode(x))
+    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['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)
+    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)
+
+FEATURES = [
+    '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',
+    'geo_mean', 'geo_std', 'geo_median', 'geo_max',
+    'geo_hour_mean', 'geo_ts_mean', 'geo3_hour_mean',
+]
+
+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,
+)
+
+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)
+
+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(submission.head())
+
+fi = pd.Series(model.feature_importances_, index=FEATURES).sort_values(ascending=False)
+print("\nTop feature importances:")
+print(fi.head(15))

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

@@ -0,0 +1,1085 @@
+{
+ "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
+}