Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+observation.csv filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,23 @@
+# Use an official PyTorch runtime (includes CUDA for GPU)
+FROM pytorch/pytorch:2.4.0-cuda12.1-cudnn8-runtime
+
+# Set environment
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PORT=7860 \
+    HOST=0.0.0.0
+
+# Create working directory
+WORKDIR /app
+
+# Copy files
+COPY . /app
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose port for Hugging Face
+EXPOSE 7860
+
+# Start FastAPI app using Uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,192 @@
+import os
+import re
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader
+from sklearn.preprocessing import LabelEncoder, MinMaxScaler
+from sklearn.metrics import mean_absolute_error
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+# ================= CONFIG =================
+CSV_PATH = "observation.csv"
+SAVE_FULL = "traffic_transformer_model_2.pth"
+INPUT_LEN = 72
+BATCH_SIZE = 128
+DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+CONGESTION_THRESHOLDS = {
+    'LOW': 200,
+    'MEDIUM': 300
+}
+
+# ================= UTILS =================
+def determine_congestion_level(mean_count, thresholds):
+    if mean_count <= thresholds['LOW']:
+        return "Low"
+    elif mean_count <= thresholds['MEDIUM']:
+        return "Medium"
+    else:
+        return "High"
+
+# ================= MODEL =================
+class TransformerForecaster(nn.Module):
+    def __init__(self, input_size, hidden_size=256, num_heads=8, dropout=0.1, seq_len=INPUT_LEN):
+        super().__init__()
+        self.pos_embedding = nn.Parameter(torch.randn(1, seq_len, input_size) * 0.01)
+        self.layer_norm = nn.LayerNorm(input_size)
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=input_size,
+            nhead=num_heads,
+            dim_feedforward=hidden_size,
+            dropout=dropout,
+            batch_first=True,
+            activation='gelu'
+        )
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=3)
+        self.fc = nn.Sequential(
+            nn.Linear(input_size, hidden_size),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_size, 1)
+        )
+
+    def forward(self, x):
+        x = x + self.pos_embedding[:, :x.size(1), :]
+        x = self.layer_norm(x)
+        x = self.transformer(x)
+        x = x[:, -1, :]
+        return self.fc(x).squeeze(-1)
+
+class TrafficDataset(Dataset):
+    def __init__(self, data, input_len=INPUT_LEN, feature_dim=None):
+        self.X, self.y = [], []
+        for i in range(len(data) - input_len):
+            self.X.append(data[i:i + input_len, :feature_dim])
+            self.y.append(data[i + input_len, -1])
+        self.X = torch.tensor(np.array(self.X), dtype=torch.float32)
+        self.y = torch.tensor(np.array(self.y), dtype=torch.float32)
+
+    def __len__(self):
+        return len(self.X)
+
+    def __getitem__(self, idx):
+        return self.X[idx], self.y[idx]
+
+# ================= FASTAPI APP =================
+app = FastAPI(title="Traffic Congestion API", version="1.0")
+
+class InputData(BaseModel):
+    target_place: str
+
+print("🔁 Loading and preparing data...")
+
+try:
+    df = pd.read_csv(CSV_PATH)
+except FileNotFoundError:
+    raise FileNotFoundError(f"File not found at {CSV_PATH}")
+
+# ========== DATA PREPROCESSING ==========
+df = df.drop(columns=["Datetime"], errors="ignore")
+
+def extract_hour(timeslot):
+    if pd.isna(timeslot): return None
+    try:
+        start_time = timeslot.split('-')[0].strip()
+        start_time = re.sub(r'(?i)(AM|PM)', r' \1', start_time).strip().upper()
+        return pd.to_datetime(start_time, format='%I:%M %p').hour
+    except:
+        try:
+            return pd.to_datetime(start_time, format='%H:%M').hour
+        except:
+            return None
+
+df['StartHour'] = df['TimeSlot'].apply(extract_hour)
+df.dropna(subset=['StartHour'], inplace=True)
+df['StartHour'] = df['StartHour'].astype(int)
+
+le_to = LabelEncoder()
+df['To_encoded'] = le_to.fit_transform(df['To'])
+
+df['DayOfYear'] = (df['Month'] - 1) * 30 + df['Day']
+df['Day_sin'] = np.sin(2 * np.pi * df['DayOfYear'] / 365)
+df['Day_cos'] = np.cos(2 * np.pi * df['DayOfYear'] / 365)
+df['Hour_sin'] = np.sin(2 * np.pi * df['StartHour'] / 24)
+df['Hour_cos'] = np.cos(2 * np.pi * df['StartHour'] / 24)
+
+df = df.sort_values(['To', 'Year', 'Month', 'Day', 'StartHour']).reset_index(drop=True)
+
+for lag in [1, 2, 3, 6, 12, 24]:
+    df[f'Lag_{lag}'] = df.groupby('To')['CarCount'].shift(lag)
+
+df['MA_3'] = df.groupby('To')['CarCount'].transform(lambda x: x.rolling(3).mean())
+df['EMA_5'] = df.groupby('To')['CarCount'].transform(lambda x: x.ewm(span=5, adjust=False).mean())
+df['ROLL12_mean'] = df.groupby('To')['CarCount'].transform(lambda x: x.rolling(12).mean())
+df['ROLL12_std'] = df.groupby('To')['CarCount'].transform(lambda x: x.rolling(12).std())
+df['Diff_1'] = df.groupby('To')['CarCount'].diff(1)
+
+df.dropna(inplace=True)
+df.reset_index(drop=True, inplace=True)
+
+feature_cols = [
+    'StartHour', 'Hour_sin', 'Hour_cos', 'Day_sin', 'Day_cos',
+    'To_encoded', 'MA_3', 'EMA_5', 'ROLL12_mean', 'ROLL12_std', 'Diff_1'
+] + [f'Lag_{i}' for i in [1, 2, 3, 6, 12, 24]]
+
+scaler_X = MinMaxScaler()
+df[feature_cols] = scaler_X.fit_transform(df[feature_cols])
+
+scaler_y = MinMaxScaler()
+df['y_scaled'] = scaler_y.fit_transform(df[['CarCount']])
+
+# ========== MODEL LOADING ==========
+try:
+    model_loaded = torch.load(SAVE_FULL, map_location=DEVICE)
+    model_loaded.eval()
+    print(f"✅ Model loaded successfully from {SAVE_FULL}")
+except Exception as e:
+    raise RuntimeError(f"Failed to load model: {e}")
+
+# ================= API ENDPOINT =================
+@app.post("/predict")
+def predict_congestion(data: InputData):
+    target_place = data.target_place.strip()
+    df_target = df[df['To'] == target_place].copy()
+
+    if df_target.empty:
+        raise HTTPException(status_code=404, detail=f"No data found for location: {target_place}")
+
+    values = df_target[feature_cols + ['y_scaled']].values
+    feature_dim = len(feature_cols)
+    train_size = int(len(values) * 0.8)
+    test_data = values[train_size:]
+
+    if len(test_data) < INPUT_LEN + 50:
+        raise HTTPException(status_code=400, detail=f"Not enough data for {target_place}")
+
+    test_dataset = TrafficDataset(test_data, input_len=INPUT_LEN, feature_dim=feature_dim)
+    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+    preds_scaled_all, actuals_scaled_all = [], []
+
+    with torch.no_grad():
+        for X_batch, y_batch in test_loader:
+            X_batch = X_batch.to(DEVICE)
+            y_pred = model_loaded(X_batch).view(-1).cpu().numpy()
+            preds_scaled_all.extend(y_pred)
+            actuals_scaled_all.extend(y_batch.view(-1).cpu().numpy())
+            if len(preds_scaled_all) >= 200:
+                break
+
+    preds_all = scaler_y.inverse_transform(np.array(preds_scaled_all).reshape(-1, 1)).flatten()
+    mean_predicted_car_count = float(np.mean(preds_all[:200]))
+    congestion_level = determine_congestion_level(mean_predicted_car_count, CONGESTION_THRESHOLDS)
+
+    return {
+        "target_place": target_place,
+        "mean_predicted_car_count": round(mean_predicted_car_count, 2),
+        "inferred_congestion_level": congestion_level
+    }
+

observation.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf32a2b56af6bd5f1cc9bfba4636e1dfb1b1c86f8b28b284bc4c53d2fc9b23ce
+size 41704189

traffic_transformer_model_2.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce350fdb9766d1a01bf225497766b4a3d583b9c4ff9065875a7a04481f6e2b4a
+size 172097