Upload 10 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
+flights_database.db filter=lfs diff=lfs merge=lfs -text

Dockerfile.txt

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Requirements install karein
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Saara code copy karein
+COPY . .
+
+# PERMISSION FIX: Hugging Face user ko permissions dena
+RUN chmod -R 777 /app
+
+# Port 7860 Hugging Face ke liye standard hai
+EXPOSE 7860
+
+CMD ["uvicorn", "api.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,13 +1,18 @@
----
-title: Flightt
-emoji: 📊
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.8.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+   pip install -r requirements.txt
+
+
+
+   python src/etl.py
+
+
+
+   python src/train.py
+
+   mlflow ui
+
+
+
+   uvicorn api.main:app --reload
+
+ 
+

docker-compose.yml

@@ -0,0 +1,9 @@
+version: '3.8'
+services:
+  api:
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      - DATABASE_URL=sqlite:///data/flights_database.db
+    

etl.py

@@ -0,0 +1,44 @@
+import pandas as pd
+from sqlalchemy import create_engine
+import os
+
+def run_etl():
+    
+    file_path = "data/T_ONTIME_REPORTING_20260228_131510/flights.csv"
+    
+    
+    db_engine = create_engine('sqlite:///data/flights_database.db')
+    
+    print("ETL Process now start...")
+
+    
+    try:
+        df = pd.read_csv(file_path, low_memory=False)
+        print(f"Data Loaded successfuly,: {df.shape[0]} rows find it.")
+    except FileNotFoundError:
+        print(f"Error: file not found: {file_path}")
+        return
+
+    
+    df = df.dropna(subset=['ARR_DELAY', 'DEP_DELAY'])
+    
+    if 'CANCELLED' in df.columns:
+        df = df[df['CANCELLED'] == 0]
+    
+    df['is_delayed'] = (df['ARR_DELAY'] > 15).astype(int)
+    
+    print("Cleaning aur Labeling completed,")
+
+    if not os.path.exists('data'):
+        os.makedirs('data')
+
+    sample_size = min(10000, len(df))
+    sample_df = df.sample(n=sample_size) 
+    
+    sample_df.to_sql('cleaned_flights', con=db_engine, if_exists='replace', index=False)
+    
+    print(f"Data saved to SQL Database,")
+    print(f"Database Location: data/flights_database.db")
+
+if __name__ == "__main__":
+    run_etl()

flight_model.joblib

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

flights_database.db

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

label_encoder.joblib

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

main.py

@@ -0,0 +1,83 @@
+import os
+import joblib
+import pandas as pd
+import logging
+from fastapi import FastAPI
+from pydantic import BaseModel
+from datetime import datetime
+
+# LOGGING: Console par log karein taake Docker ya cloud environments mein logs asani se milain
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+app = FastAPI(title="Flight Delay Prediction API")
+
+# --- PATH SETUP (DOCKER FRIENDLY) ---
+# BASE_DIR ko aik level up le kar jana hai (api folder se bahar)
+# Example: /app/api/main.py -> /app/
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODEL_PATH = os.path.join(BASE_DIR, 'models', 'flight_model.joblib')
+
+logging.info(f"Looking for model at: {MODEL_PATH}")
+
+try:
+    # Model load logic
+    model = joblib.load(MODEL_PATH)
+    logging.info("Model successfully loaded.")
+except Exception as e:
+    logging.error(f"Model load karne mein masla: {e}")
+    model = None 
+
+# --- DATA SCHEMA ---
+class FlightData(BaseModel):
+    MONTH: int
+    DAY_OF_WEEK: int
+    DISTANCE: float
+    CRS_DEP_TIME: int
+    OP_UNIQUE_CARRIER: str
+    ORIGIN: str
+    DEST: str
+
+# --- ENDPOINTS ---
+@app.get("/")
+def home():
+    return {"message": "Flight Delay Prediction API is Running!"}
+
+@app.post("/predict")
+def predict(data: FlightData):
+    if model is None:
+        logging.error("Prediction failed: Model is not loaded.")
+        return {"error": "Model not loaded on server. Check path and logs."}
+
+    logging.info(f"Prediction requested for: {data.dict()}")
+
+    try:
+        # Convert incoming Pydantic model to DataFrame
+        input_df = pd.DataFrame([data.dict()])
+        
+        # Categorical columns ko numeric mein badalne ke liye hash use ho raha hai
+        for col in ['OP_UNIQUE_CARRIER', 'ORIGIN', 'DEST']:
+            input_df[col] = input_df[col].apply(lambda x: abs(hash(str(x))) % 1000)
+
+        # Make Prediction
+        prediction = model.predict(input_df)[0]
+        probability = model.predict_proba(input_df)[0][1]
+
+        result = {
+            "delay_probability": round(float(probability), 2),
+            "prediction": "Delayed" if prediction == 1 else "On Time"
+        }
+        
+        logging.info(f"Prediction successful: {result}")
+        return result
+
+    except Exception as e:
+        logging.error(f"Prediction error: {str(e)}")
+        return {"error": "There is an issue with the prediction process", "details": str(e)}
+
+if __name__ == "__main__":
+    import uvicorn
+    # Docker/External access ke liye 0.0.0.0 zaroori hai
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,9 @@
+pandas
+numpy
+scikit-learn
+xgboost
+fastapi
+uvicorn
+mlflow
+joblib
+sqlalchemy

train.py

@@ -0,0 +1,84 @@
+import pandas as pd
+import sqlite3
+from sqlalchemy import create_engine
+from xgboost import XGBClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, roc_auc_score
+from sklearn.preprocessing import LabelEncoder
+import mlflow
+import mlflow.sklearn
+import joblib
+import os
+
+mlflow.set_tracking_uri("sqlite:///mlflow.db")
+
+def train_model():
+    print("Model Training started")
+    
+    db_path = 'sqlite:///data/flights_database.db'
+    engine = create_engine(db_path)
+    
+    try:
+        df = pd.read_sql('SELECT * FROM cleaned_flights', engine)
+    except Exception as e:
+        print(f"Error: Database data not found. Check it,: {e}")
+        return
+
+    features = ['MONTH', 'DAY_OF_WEEK', 'DISTANCE', 'CRS_DEP_TIME', 'OP_UNIQUE_CARRIER', 'ORIGIN', 'DEST']
+    X = df[features].copy()
+    y = df['is_delayed']
+
+    encoders = {}
+    for col in ['OP_UNIQUE_CARRIER', 'ORIGIN', 'DEST']:
+        le = LabelEncoder()
+        X[col] = le.fit_transform(X[col])
+        encoders[col] = le 
+    
+    
+    os.makedirs('models', exist_ok=True)
+    joblib.dump(encoders, 'models/label_encoders.joblib')
+    print("All Label Encoders saved to models/label_encoders.joblib")
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    mlflow.set_experiment("Flight_Delay_Prediction")
+    
+    with mlflow.start_run():
+        print("XGBoost Model train")
+        
+        params = {
+            "n_estimators": 100, 
+            "max_depth": 5, 
+            "learning_rate": 0.1,
+            "use_label_encoder": False,
+            "eval_metric": "logloss"
+        }
+        
+        model = XGBClassifier(**params)
+        model.fit(X_train, y_train)
+
+        
+        y_pred = model.predict(X_test)
+        y_proba = model.predict_proba(X_test)[:, 1]
+
+        
+        acc = accuracy_score(y_test, y_pred)
+        auc = roc_auc_score(y_test, y_proba)
+
+        print(f"Accuracy: {acc:.2f}")
+        print(f"ROC-AUC: {auc:.2f}")
+
+        
+        mlflow.log_params(params)
+        mlflow.log_metric("accuracy", acc)
+        mlflow.log_metric("roc_auc", auc)
+        
+        
+        mlflow.sklearn.log_model(model, "model")
+
+        
+        joblib.dump(model, 'models/flight_model.joblib')
+        print("Model saved: models/flight_model.joblib")
+
+if __name__ == "__main__":
+    train_model()