Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,42 @@
+# Ignore Python cache
+__pycache__/
+*.py[cod]
+*.so
+
+# Ignore Jupyter notebooks (if not used)
+*.ipynb
+.ipynb_checkpoints/
+
+# Ignore logs and temp files
+*.log
+*.tmp
+*.DS_Store
+
+# Ignore version control and dev files
+.git/
+.github/
+.vscode/
+*.env
+.env*
+.gitignore
+
+# MLflow & DVC metadata (keep only if you need them at runtime)
+.mlflow/
+.dvc/
+.dvcignore
+
+# CI/CD config files
+tox.ini
+pytest.ini
+setup.cfg
+setup.py
+requirements-dev.txt
+
+# Ignore Docker build context bloat
+*.tar
+*.zip
+*.gz
+*.egg-info/
+
+# Ignore Hugging Face cache
+~/.cache/huggingface/

.gitignore

@@ -0,0 +1 @@
+model/

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11.11-slim-bookworm
+
+RUN apt-get update && apt-get upgrade -y
+
+COPY . /app
+
+WORKDIR /app
+
+RUN pip install -r requirements.txt
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:model_inference:inference_api", "--host", "0.0.0.0", "--port", "7860"]

main/helper.py

@@ -0,0 +1,34 @@
+# Helper functions for the model inference api
+import yaml
+import joblib
+from pathlib import Path
+
+# load yaml files to get model meta data.
+try:
+    with open(Path("model/registered_model_meta.yaml"), 'r') as f:
+        model_metadata = yaml.safe_load(f)
+except:
+    raise FileNotFoundError("Failed to load file having model metadata")
+
+
+def load_model():
+    """ Loads ML model from location path and returns the model. """
+    try:
+        with open(Path("serve_api/model/python_model.pkl"), "rb") as f:
+            model = joblib.load(f)
+        return model
+    
+    except:
+        raise FileNotFoundError("Failed to load model")
+
+
+def get_model_registry():
+    """ Fetches the model registry name and returns it. """
+    model_registry = model_metadata['model_name']
+    return model_registry
+
+
+def get_model_version():
+    """ Fetches the model version and returns it. """
+    model_version = model_metadata['model_version']
+    return model_version

main/model_inference.py

@@ -0,0 +1,69 @@
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from main.validate_schema import UserInput, APIResponse
+from datetime import datetime
+from main.helper import *
+import uuid, time
+
+model = load_model()
+
+# Initializing fastapi
+inference_api = FastAPI()
+
+@inference_api.post('/api', response_model=APIResponse)
+def api(payload: UserInput):
+    timestamp = datetime.now().astimezone().isoformat()
+    request_id = str(uuid.uuid4())
+    
+    start_time = time.perf_counter()
+    tweet = payload.comment
+    model_response = model.predict(tweet)
+
+    label = int(model_response["class_label"][0])
+    probability_scores = model_response["class_probability_scores"]
+    proba_class0 = float(probability_scores[0][0])
+    proba_class1 = float(probability_scores[0][1])
+
+    end_time = time.perf_counter()
+
+    if proba_class1 > 0.70:
+        toxic_level = "strong"
+    elif proba_class1 > 0.54:
+        toxic_level = "high"
+    elif proba_class1 > 0.46:
+        toxic_level = "light"
+    else:
+        toxic_level = "none"
+
+
+    response = {
+        "response": {
+            "class_label": label,
+            "confidence": round(abs(proba_class0 - proba_class1), 4),
+            "toxic_level": toxic_level,
+            "pred_scores": {
+                "0": round(proba_class0, 4),
+                "1": round(proba_class1, 4)
+            },
+        },
+        "metadata": {
+            "request_id": request_id,
+            "timestamp": timestamp,
+            "response_time": f"{round((end_time - start_time), 4)} sec",
+            "input": {
+                "num_tokens": int(len(tweet.split())),
+                "num_characters": int(len([i for i in tweet])),
+                "language": "en (iso 639-1code)",
+            },
+            "model": type(model.model).__name__,
+            "model_version": get_model_version(),
+            "vectorizer": type(model.vectorizer).__name__,
+            "model_registry": f"Mlflow {get_model_registry()}",
+            "type": "production",
+            "streamable": False,
+            "api_version": "v-1.0",
+            "developer": "Subinoy Bera"
+        }
+    }
+
+    return JSONResponse(status_code=200, content=response)

main/validate_schema.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, Field
+from typing import Annotated, Dict
+
+
+class UserInput(BaseModel):
+    comment: Annotated[str, Field(..., description="User tweet or comment to be classified")]
+
+
+class ResponseData(BaseModel):
+    class_label: int
+    confidence: float
+    toxic_level: str
+    pred_scores: Dict[int, float]
+
+class MetaData(BaseModel):
+    request_id: str
+    timestamp: str
+    response_time: str
+    input: Dict[str, int]
+    model: str
+    version: int
+    vectorizer: str
+    type: str
+    loader_module: str
+    streamable: bool
+    api_version: str
+    developer: str
+
+
+class APIResponse(BaseModel):
+    response: ResponseData
+    metadata: MetaData

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.116.1
+uvicorn==0.35.0
+joblib==1.5.1
+PyYAML==6.0.2