Sync API from main repo

.gitattributes

@@ -1,35 +0,0 @@
-*.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

Dockerfile

@@ -0,0 +1,17 @@
+# Use a lightweight Python image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the API code and dependencies
+COPY . /app
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the API port
+EXPOSE 8000
+
+# Run the FastAPI server with Uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,14 +0,0 @@
----
-title: Hadt Api
-emoji: 👀
-colorFrom: green
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
-short_description: API for Heart Arrhythmia Detection Tools
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-Dummy change

fast.py

@@ -0,0 +1,55 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from huggingface_hub import hf_hub_download
+
+from utils import load_model_by_type, encoder_from_model
+from preproc import label_decoding
+import pandas as pd
+from io import StringIO
+from pathlib import Path
+
+# Get the absolute path to the package directory
+PACKAGE_ROOT = Path(__file__).parent.parent.parent
+MODEL_DIR = PACKAGE_ROOT / "models"
+
+app = FastAPI()
+
+# Use absolute paths with Path objects
+model_cache = {}
+encoder_cache = {}
+HF_REPO_ID = "your-username/your-model-repo"
+
+app.state.model = None  # Initialize as None, load on first request
+
+@app.get("/")
+def root():
+    return dict(greeting="Hello")
+
+@app.post("/predict")
+async def predict(model_name: str, filepath_csv: UploadFile = File(...)):
+    # Load model if not already loaded
+    model_path = MODEL_DIR / f"{model_name}"
+    encoder_name = encoder_from_model(model_name)
+    encoder_path = MODEL_DIR / encoder_name
+
+    # if model in model_path, load it, otherwise download it from HF
+    if model_name not in model_cache:
+        try:
+            if not model_path.exists():
+                model_path = hf_hub_download(repo_id=model_name, filename=f"{model_name}")
+                encoder_path = hf_hub_download(repo_id=model_name, filename=f"{encoder_name}")
+            model_cache[model_name] = load_model_by_type(model_path)
+            encoder_cache[model_name] = encoder_path
+        except Exception as e:
+            raise HTTPException(status_code=404, detail=f"Model {model_name} not found")
+    model = app.state.model = model_cache[model_name]
+
+    # Read the uploaded CSV file
+    file_content = await filepath_csv.read()
+    X = pd.read_csv(StringIO(file_content.decode('utf-8')), header=None).T
+    y_pred = model.predict_with_pipeline(X)
+    
+    # Decode prediction using absolute path
+    
+    y_pred = label_decoding(value=y_pred[0], path=encoder_cache[model_name])
+    
+    return {"prediction": y_pred}

params.py

@@ -0,0 +1,10 @@
+import os
+
+# GCP Project
+GCP_PROJECT=os.environ.get("GCP_PROJECT")
+
+# Cloud Storage
+GOOGLE_APPLICATION_CREDENTIALS=os.environ.get('GOOGLE_APPLICATION_CREDENTIALS')
+BUCKET_NAME=os.environ.get('BUCKET_NAME')
+BUCKET_NAME_MODELS=os.environ.get('BUCKET_NAME_MODELS')
+LOCAL_REGISTRY_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)))

preproc.py

@@ -0,0 +1,21 @@
+from tslearn.utils import to_time_series_dataset
+from tslearn.preprocessing import TimeSeriesScalerMeanVariance
+import pickle
+
+def preproc_single(X):
+    # to be called in inference/api
+    in_shape = X.shape
+    if X.shape != (1, 180):
+        print('File shape is not (1, 180) but ', in_shape)
+
+    X = to_time_series_dataset(X)
+    X = X.reshape(in_shape[0], -1)
+    scaler = TimeSeriesScalerMeanVariance()
+    X = scaler.fit_transform(X)
+    return X.reshape(in_shape)
+
+def label_decoding(value, path):
+    with open(path, "rb") as f:
+        mapping = pickle.load(f)
+    inverse_mapping = {v: k for k, v in mapping.items()}
+    return inverse_mapping[value]

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+joblib
+huggingface-hub
+pandas==2.2.3
+numpy==1.26.4
+scikit-learn==1.2.2
+tslearn
+pickle
+tensorflow

utils.py

@@ -0,0 +1,40 @@
+from wrappers import LSTMWrapper, XGBWrapper, CNNWrapper
+import joblib
+from tensorflow.keras.models import load_model
+
+
+def load_model_by_type(model_path):
+    if model_path.suffix == '.h5':
+        if 'lstm_multi' in str(model_path):
+            return LSTMWrapper(load_model(model_path))
+        elif 'cnn_multi' in str(model_path):
+            return CNNWrapper(load_model(model_path))
+        else:
+            raise ValueError("Unsupported model type")
+    elif model_path.suffix == '.pkl':
+        return XGBWrapper(joblib.load(model_path))
+    else:
+        raise ValueError("Unsupported model type")
+
+def encoder_from_model(model_name):
+    if model_name == "cnn_multi_model.h5":
+        return "cnn_multi_label_encoding.pkl"
+    elif model_name == "lstm_multi_model.h5":
+        return "lstm_multi_label_encoding.pkl"
+    elif model_name == "pca_xgboost_multi_model.pkl":
+        return "pca_xgboost_multi_label_encoding.pkl"
+    elif model_name == "cnn_binary_model.h5":
+        return "cnn_binary_label_encoding.pkl"
+    elif model_name == "lstm_binary_model.h5":
+        return "lstm_binary_label_encoding.pkl"
+    elif model_name == "pca_xgboost_binary_model.pkl":
+        return "pca_xgboost_binary_label_encoding.pkl"
+    else:
+        raise ValueError("Unsupported model name")
+
+
+if __name__ == "__main__":
+    from pathlib import Path
+    PACKAGE_ROOT = Path(__file__).parent.parent.parent
+    MODEL_PATH = PACKAGE_ROOT / "models" / "lstm_multi_model.h5"
+    load_model_by_type(MODEL_PATH)

wrappers.py

@@ -0,0 +1,51 @@
+import numpy as np
+from preproc import preproc_single
+
+class BaseModelWrapper:
+    def __init__(self, model):
+        self.model = model
+
+    def preprocess(self, data):
+        """Default preprocessing (can be overridden)."""
+        return preproc_single(data)
+
+    def predict(self, data):
+        """Call the model's prediction."""
+        raise NotImplementedError("Subclasses must implement predict()")
+
+    def postprocess(self, prediction):
+        """Default postprocessing (can be overridden)."""
+        return prediction
+
+    def predict_with_pipeline(self, data):
+        """Unified prediction pipeline."""
+        processed_data = self.preprocess(data)
+        raw_prediction = self.predict(processed_data)
+        final_output = self.postprocess(raw_prediction)
+        return final_output
+
+
+class LSTMWrapper(BaseModelWrapper):
+    def preprocess(self, data):
+        # LSTM requires additional dimension expansion
+        data = preproc_single(data)
+        return np.expand_dims(data, axis=1)  # Add time-step dimension
+
+    def predict(self, data):
+        return self.model.predict(data)
+
+    def postprocess(self, prediction):
+        # Assume the output is a probability vector; apply argmax
+        return np.argmax(prediction, axis=1).tolist()
+
+
+class XGBWrapper(BaseModelWrapper):
+    def predict(self, data):
+        return self.model.predict(data).tolist()
+
+class CNNWrapper(BaseModelWrapper):
+    def predict(self, data):
+        return self.model.predict(data)
+    
+    def postprocess(self, prediction):
+        return np.argmax(prediction, axis=1).tolist()