Deploy ML app with LFS

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app/ app/
+COPY models/ models/
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,10 +1,106 @@
 ---
-title: Ml Deploy App
-emoji: 🔥
-colorFrom: indigo
-colorTo: green
+title: Iris Classification
+emoji: 🌺
+colorFrom: green
+colorTo: purple
 sdk: docker
-pinned: false
+app_port: 8000
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# FastAPI ML Deployment Tutorial
+
+This repository demonstrates how to serve and deploy a Machine Learning application using FastAPI and Docker. We use the classic Iris dataset to keep the ML part simple and focus on the deployment mechanics.
+
+## Project Structure
+
+```
+.
+├── app/
+│   ├── __init__.py
+│   ├── main.py          # FastAPI application
+│   └── model.py         # Model loading and prediction logic
+├── model_training/
+│   └── train.py         # Script to train and save the model
+├── models/              # Directory to store the saved model artifact
+├── requirements.txt     # Python dependencies
+├── Dockerfile           # Container definition
+└── README.md            # This tutorial
+```
+
+## Prerequisites
+
+- Python 3.9+
+- Docker (optional, for containerization)
+
+## Step 1: Setup Environment
+
+1.  Clone the repository:
+    ```bash
+    git clone <repository-url>
+    cd ml-deploy-app
+    ```
+
+2.  Create a virtual environment:
+    ```bash
+    python -m venv venv
+    source venv/bin/activate  # On Windows: venv\Scripts\activate
+    ```
+
+3.  Install dependencies:
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+## Step 2: Train the Model
+
+Run the training script to generate the model artifact (`models/iris_model.joblib`):
+
+```bash
+python model_training/train.py
+```
+
+You should see output indicating the model was saved successfully.
+
+## Step 3: Run the API Locally
+
+Start the FastAPI server using Uvicorn:
+
+```bash
+uvicorn app.main:app --reload
+```
+
+The API will be available at `http://127.0.0.1:8000`.
+
+### Interactive Documentation
+
+Visit `http://127.0.0.1:8000/docs` to see the Swagger UI. You can test the `/predict` endpoint directly from the browser.
+
+**Example Request Body:**
+
+```json
+{
+  "sepal_length": 5.1,
+  "sepal_width": 3.5,
+  "petal_length": 1.4,
+  "petal_width": 0.2
+}
+```
+
+## Step 4: Run with Docker
+
+1.  Build the Docker image:
+    ```bash
+    docker build -t iris-app .
+    ```
+
+2.  Run the container:
+    ```bash
+    docker run -p 8000:8000 iris-app
+    ```
+
+The API will be accessible at `http://127.0.0.1:8000` (and `http://127.0.0.1:8000/docs`).
+
+## Next Steps
+
+- **Hugging Face Spaces**: You can deploy this easily to Hugging Face Spaces by adding a `README.md` with YAML metadata and pushing the code.
+- **Cloud Deployment**: This Docker container can be deployed to AWS ECS, Google Cloud Run, or Azure Container Apps.

app/main.py

@@ -0,0 +1,23 @@
+from fastapi import FastAPI, HTTPException
+from app.model import IrisModel, IrisInput, IrisPrediction
+
+app = FastAPI(title="Iris Classification API", version="1.0.0")
+
+# Initialize model
+model = IrisModel()
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to the Iris Classification API"}
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy"}
+
+@app.post("/predict", response_model=IrisPrediction)
+def predict_iris(input_data: IrisInput):
+    try:
+        prediction = model.predict(input_data)
+        return prediction
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/model.py

@@ -0,0 +1,44 @@
+import joblib
+import os
+from pydantic import BaseModel
+from typing import List
+
+class IrisInput(BaseModel):
+    sepal_length: float
+    sepal_width: float
+    petal_length: float
+    petal_width: float
+
+class IrisPrediction(BaseModel):
+    class_name: str
+    class_id: int
+
+class IrisModel:
+    def __init__(self):
+        self.model = None
+        self.class_names = ["setosa", "versicolor", "virginica"]
+        self.load_model()
+
+    def load_model(self):
+        model_path = os.path.join("models", "iris_model.joblib")
+        if os.path.exists(model_path):
+            self.model = joblib.load(model_path)
+        else:
+            raise FileNotFoundError(f"Model not found at {model_path}. Please train the model first.")
+
+    def predict(self, input_data: IrisInput) -> IrisPrediction:
+        if not self.model:
+            self.load_model()
+        
+        data = [[
+            input_data.sepal_length,
+            input_data.sepal_width,
+            input_data.petal_length,
+            input_data.petal_width
+        ]]
+        
+        prediction = self.model.predict(data)[0]
+        return IrisPrediction(
+            class_name=self.class_names[prediction],
+            class_id=int(prediction)
+        )

model_training/train.py

@@ -0,0 +1,26 @@
+import os
+import joblib
+import pandas as pd
+from sklearn.datasets import load_iris
+from sklearn.ensemble import RandomForestClassifier
+
+# Set up directories
+MODEL_DIR = "models"
+os.makedirs(MODEL_DIR, exist_ok=True)
+MODEL_PATH = os.path.join(MODEL_DIR, "iris_model.joblib")
+
+def train_model():
+    print("Loading Iris dataset...")
+    iris = load_iris()
+    X, y = iris.data, iris.target
+
+    print("Training Random Forest Classifier...")
+    clf = RandomForestClassifier(n_estimators=100, random_state=42)
+    clf.fit(X, y)
+
+    print(f"Saving model to {MODEL_PATH}...")
+    joblib.dump(clf, MODEL_PATH)
+    print("Model saved successfully!")
+
+if __name__ == "__main__":
+    train_model()

models/iris_model.joblib

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

requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.109.0
+uvicorn==0.27.0
+scikit-learn==1.4.0
+joblib==1.3.2
+pandas==2.2.0
+numpy==1.26.3
+pydantic==2.6.0