feat (app): initial app configuration

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "server_cancer_predictor:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -10,3 +10,7 @@ short_description: Breast Cancer Diagnostic - FastAPI
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Breast Cancer Wisconsin (Diagnostic)
+
+See at [DataSci4Health](https://github.com/datasci4health/datasci4health.github.io/tree/master/data/breast-cancer/wisconsin)

breast-cancer-wisconsin_samples.csv

@@ -0,0 +1,5 @@
+diagnosis,radius_mean,texture_mean,symmetry_mean,fractal_dimension_mean
+B,12.47,18.6,0.1925,0.06373
+M,18.94,21.31,0.1582,0.05461
+M,15.46,19.48,0.1931,0.05796
+B,12.4,17.68,0.1811,0.07102

cancer_predictor.py

@@ -0,0 +1,80 @@
+"""
+This module provides the CancerPredictor class for training and predicting breast cancer diagnosis
+using logistic regression. It leverages scikit-learn for model training, evaluation, and prediction,
+and pandas for data manipulation. The predictor expects input features such as radius_mean,
+texture_mean, symmetry_mean, and fractal_dimension_mean, and outputs a diagnosis prediction.
+
+Classes:
+    CancerPredictor: Handles training on a CSV dataset and making predictions
+    based on input features.
+"""
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score
+
+class CancerPredictor:
+    """
+    CancerPredictor is a class for training and making predictions on breast cancer diagnosis
+    using logistic regression.
+    """
+
+    def __init__(self):
+        self.model = LogisticRegression()
+        self.le_diagnosis = LabelEncoder()
+
+    def train(self, csv_train, csv_test):
+        """
+        Trains the logistic regression model using a CSV file containing breast cancer data.
+        The CSV must include columns: 'radius_mean', 'texture_mean', 'symmetry_mean',
+        'fractal_dimension_mean', and 'diagnosis'.
+        Prints the model accuracy after training.
+        """
+        # Load the train data
+        data_train = pd.read_csv(csv_train)
+
+        # Encode categorical variables
+        data_train['diagnosis'] = self.le_diagnosis.fit_transform(data_train['diagnosis'])
+
+        # Split features and target
+        X_train = data_train[
+            ['radius_mean', 'texture_mean', 'symmetry_mean', 'fractal_dimension_mean']]
+        y_train = data_train['diagnosis']
+
+        # Train the model
+        self.model.fit(X_train, y_train)
+
+        # Load the test data
+        data_test = pd.read_csv(csv_test)
+
+        # Encode categorical variables
+        data_test['diagnosis'] = self.le_diagnosis.fit_transform(data_test['diagnosis'])
+
+        # Split features and target
+        X_test = data_test[
+            ['radius_mean', 'texture_mean', 'symmetry_mean', 'fractal_dimension_mean']]
+        y_test = data_test['diagnosis']
+
+        # Evaluate the model
+        y_pred = self.model.predict(X_test)
+        accuracy = accuracy_score(y_test, y_pred)
+        print(f"Model accuracy: {accuracy:.2f}")
+
+    def predict(self, radius_mean, texture_mean, symmetry_mean, fractal_dimension_mean):
+        """
+        Predicts the diagnosis ('M' for malignant or 'B' for benign) based on the provided
+        feature values.
+        Returns the predicted diagnosis as a string.
+        """
+        # Create a DataFrame with the same feature names as the training data
+        input_data = pd.DataFrame(
+            [[radius_mean, texture_mean, symmetry_mean, fractal_dimension_mean]],
+            columns=['radius_mean', 'texture_mean', 'symmetry_mean', 'fractal_dimension_mean'])
+
+        # Make prediction
+        prediction = self.model.predict(input_data)
+
+        # Decode prediction
+        diagnosis = self.le_diagnosis.inverse_transform(prediction)[0]
+
+        return diagnosis

requirements.txt

@@ -0,0 +1,2 @@
+fastapi
+gunicorn

server_cancer_predictor.py

@@ -0,0 +1,66 @@
+"""
+This module provides a FastAPI-based web server for breast cancer prediction and model training.
+It exposes endpoints for training a cancer prediction model asynchronously,
+checking training status, and making predictions based on input features.
+
+Endpoints:
+- POST /train: Starts model training in the background using a provided data file.
+- GET /training_status: Returns the current status of the model training process.
+- GET /predict: Predicts cancer diagnosis based on input features
+                (radius_mean, texture_mean, symmetry_mean, fractal_dimension_mean).
+
+Dependencies:
+- FastAPI for API creation
+- Pydantic for request validation
+- uvicorn for running the server
+- CancerPredictor class for model operations (imported from cancer_predictor.py)
+
+Usage:
+Run this module to start the API server. Use the endpoints to train the model and make predictions.
+"""
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+import uvicorn
+
+# Import the CancerPredictor class
+from cancer_predictor import CancerPredictor
+
+app = FastAPI()
+
+# Create a global instance of CancerPredictor
+predictor = CancerPredictor()
+
+# Global variable to store training status
+training_status = "Not started"
+
+def train_model(train_path: str, test_path: str):
+    global training_status
+    training_status = "In progress"
+    try:
+        predictor.train(train_path, test_path)
+        training_status = "Completed"
+    except Exception as e:
+        training_status = f"Failed: {str(e)}"
+
+@app.post("/train")
+async def train(train_path: str, test_path: str, background_tasks: BackgroundTasks):
+    background_tasks.add_task(train_model, train_path, test_path)
+    return {"message": "Training started in the background"}
+
+@app.get("/training_status")
+async def get_training_status():
+    return {"status": training_status}
+
+@app.get("/predict")
+async def predict(radius_mean: float, texture_mean: float, symmetry_mean: float, fractal_dimension_mean: float):
+    if training_status != "Completed":
+        raise HTTPException(status_code=400, detail="Model not trained yet")
+    try:
+        predicted_diagnosis = predictor.predict(
+            radius_mean, texture_mean, symmetry_mean, fractal_dimension_mean)
+        return {"diagnosis": str(predicted_diagnosis)}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)