message

Dockerfile

@@ -1,35 +1,22 @@
-# Use an official Python image as the base image
-FROM python:3.9-slim
-
-# Set environment variables to prevent Python from buffering output
-ENV PYTHONDONTWRITEBYTECODE=1
-ENV PYTHONUNBUFFERED=1
-
-# Install necessary system dependencies
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    libopenblas-dev \
-    liblapack-dev \
-    libglib2.0-0 \
-    libgl1-mesa-glx \
-    libstdc++6 \
-    wget \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create a directory for the app
+FROM python:3.9
+
 WORKDIR /app
+COPY . /app
+
+ENV HF_HOME=/app/.cache
+
+RUN mkdir -p /app/.cache/huggingface/hub && \
+    chmod -R 777 /app/.cache && \
+    chmod -R 777 /app/.cache/huggingface
+
 
-# Copy the requirements file
-COPY requirements.txt /app/
 
-# Install Python dependencies
+RUN pip install --upgrade pip
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy the application code
-COPY . /app/
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
-# Expose the FastAPI application port
-EXPOSE 8000
+EXPOSE 7860
 
-# Command to run the application
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -1,83 +1,51 @@
 from fastapi import FastAPI, HTTPException
-from fastapi.responses import FileResponse
-import pandas as pd
-from sklearn.model_selection import train_test_split
-from sentence_transformers import SentenceTransformer
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import accuracy_score
 from pydantic import BaseModel
+from sentence_transformers import SentenceTransformer
 import numpy as np
-import uvicorn
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
+# Initialize the FastAPI app
 app = FastAPI()
 
-# Load and preprocess dataset
-file_name = r"D:/new/sms_process_data_main.xlsx"
-sheet = "Sheet1"
-df = pd.read_excel(file_name, sheet_name=sheet)
-
-# Split data
-X_train, X_test, y_train, y_test = train_test_split(
-    df['MessageText'], df['label'], test_size=0.2, random_state=42
-)
-
-# Load sentence embedding model
-embedding_model = SentenceTransformer('Alibaba-NLP/gte-base-en-v1.5', trust_remote_code=True)
-
-# Generate embeddings
-X_train_embeddings = embedding_model.encode(X_train.tolist(), convert_to_tensor=True).cpu().numpy()
-X_test_embeddings = embedding_model.encode(X_test.tolist(), convert_to_tensor=True).cpu().numpy()
+# Load the pre-trained SentenceTransformer model from Hugging Face
+#model = SentenceTransformer("//huggingface.co/spaces/Kabila22/Kabilan_embedding_1", trust_remote_code=True)
+model = SentenceTransformer("Alibaba-NLP/gte-base-en-v1.5", trust_remote_code=True)
 
-# Train logistic regression model
-logistic_model = LogisticRegression(max_iter=1000)
-logistic_model.fit(X_train_embeddings, y_train)
+# Define the request body schema
+class TextInput(BaseModel):
+    text: str
 
-# Evaluate model
-y_pred = logistic_model.predict(X_test_embeddings)
-accuracy = accuracy_score(y_test, y_pred)
-logger.info(f"Model trained with accuracy: {accuracy:.4f}")
+# Home route
+@app.get("/")
+async def home():
+    return {"message": "Welcome to embedding SMS API, use /docs to post SMS text and get dimensions"}
+
+# Define the API endpoint
+@app.post("/embed")
+async def generate_embedding(text_input: TextInput):
+    """
+    Generate a 768-dimensional embedding for the input text.
+    Returns the embedding in a structured format with rounded values.
+    """
+    try:
+        # Generate the embedding
+        embedding = model.encode(text_input.text, convert_to_tensor=True).cpu().numpy()
 
-# API Input Model
-class MessageInput(BaseModel):
-    messages: list[str]
+        # Round embedding values to 2 decimal places
+        rounded_embedding = np.round(embedding, decimals=2).tolist()
 
-# Root endpoint
-@app.get("/")
-def read_root():
-    return {"message": "Welcome to the SMS Classification API!"}
+        # Get the number of dimensions
+        dimensions = len(rounded_embedding)
 
-# Predict endpoint
-@app.post("/predict")
-def predict_sms(data: MessageInput):
-    try:
-        # Generate embeddings for new messages
-        new_embeddings = embedding_model.encode(data.messages, convert_to_tensor=True).cpu().numpy()
-        
-        # Predict labels
-        predictions = logistic_model.predict(new_embeddings).tolist()
-        
-        
-        # Prepare the response with embeddings and dimensions
-        response = {
-            "dimensions": new_embeddings.shape[1],  # Number of dimensions in the embeddings
-            "embeddings": new_embeddings.tolist(),   # Convert embeddings to a list
-            "predictions": predictions               # Include predictions
+        # Return structured response
+        return {
+            "dimensions": dimensions,
+            "embeddings": [rounded_embedding]  # Wrap the embedding inside a list
         }
-        return response
-    
     except Exception as e:
-        logger.error(f"Error during prediction: {e}")
+        # Handle any errors
         raise HTTPException(status_code=500, detail=str(e))
 
-# Favicon endpoint (optional)
-@app.get("/favicon.ico")
-def favicon():
-    return FileResponse("path/to/favicon.ico")
-
+# Run the FastAPI app
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)