Add initial Dockerfile, FastAPI application, and requirements

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", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,141 @@
+from fastapi import FastAPI, UploadFile, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import pandas as pd
+import numpy as np
+from sklearn.naive_bayes import CategoricalNB
+from sklearn.preprocessing import LabelEncoder
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import confusion_matrix
+import json
+import io
+from typing import Dict, List, Optional
+from pydantic import BaseModel
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+model = None
+feature_encoders: Dict[str, LabelEncoder] = {}
+target_encoder: Optional[LabelEncoder] = None
+
+class TrainOptions(BaseModel):
+    target_column: str
+    feature_columns: List[str]
+
+class PredictionFeatures(BaseModel):
+    features: Dict[str, str]
+
+@app.get("/api/health")
+async def health_check():
+    return {"status": "healthy"}
+
+@app.post("/api/upload")
+async def upload_csv(file: UploadFile):
+    if not file.filename.endswith('.csv'):
+        raise HTTPException(status_code=400, detail="Only CSV files are allowed")
+    
+    try:
+        contents = await file.read()
+        df = pd.read_csv(io.StringIO(contents.decode()))
+        
+        columns = df.columns.tolist()
+        column_types = {col: str(df[col].dtype) for col in columns}
+        
+        unique_values = {col: df[col].unique().tolist() for col in columns}
+        
+        for col, values in unique_values.items():
+            unique_values[col] = [v.item() if isinstance(v, np.generic) else v for v in values]
+        
+        return {
+            "message": "File uploaded successfully",
+            "columns": columns,
+            "column_types": column_types,
+            "unique_values": unique_values,
+            "row_count": len(df)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/train")
+async def train_model(file: UploadFile, options: str = Form(...)):
+    global model, feature_encoders, target_encoder
+    
+    try:
+        train_options = json.loads(options)
+        target_column = train_options["target_column"]
+        feature_columns = train_options["feature_columns"]
+        
+        contents = await file.read()
+        df = pd.read_csv(io.StringIO(contents.decode()))
+        
+        X = pd.DataFrame()
+        feature_encoders = {}
+        for column in feature_columns:
+            encoder = LabelEncoder()
+            X[column] = encoder.fit_transform(df[column])
+            feature_encoders[column] = encoder
+        
+        target_encoder = LabelEncoder()
+        y = target_encoder.fit_transform(df[target_column])
+        
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=42
+        )
+        
+        model = CategoricalNB()
+        model.fit(X_train, y_train)
+        
+        accuracy = float(model.score(X_test, y_test))
+        
+        return {
+            "message": "Model trained successfully",
+            "accuracy": accuracy,
+            "target_classes": target_encoder.classes_.tolist()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/predict")
+async def predict(features: PredictionFeatures):
+    global model, feature_encoders, target_encoder
+    
+    if model is None:
+        raise HTTPException(status_code=400, detail="Model not trained yet")
+    
+    try:
+        encoded_features = {}
+        for column, value in features.features.items():
+            if column in feature_encoders:
+                encoded_features[column] = feature_encoders[column].transform([value])[0]
+        
+        X = pd.DataFrame([encoded_features])
+        
+        prediction = model.predict(X)
+        prediction_proba = model.predict_proba(X)
+        
+        predicted_class = target_encoder.inverse_transform(prediction)[0]
+        
+        class_probabilities = {
+            target_encoder.inverse_transform([i])[0]: float(prob) 
+            for i, prob in enumerate(prediction_proba[0])
+        }
+        
+        return {
+            "prediction": predicted_class,
+            "probabilities": class_probabilities
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+python-multipart
+pandas
+scikit-learn
+numpy
+matplotlib
+gunicorn