Initial commit

Dockerfile

@@ -0,0 +1,20 @@
+# Use official Python image as a base image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the entire app folder into the container
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Command to run the FastAPI app using Uvicorn
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,8 @@
+---
+title: Embedding Restapi
+emoji: 😻
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+---

main.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI, HTTPException
+from services.sms_service import predict_label, compute_cosine_similarity, compute_embeddings
+from schemas.input_schemas import CosineSimilarityInput, MessageInput, EmbeddingInput
+
+app = FastAPI()
+
+# 🚀 1️⃣ Homepage Endpoint
+@app.get("/")
+async def home():
+    return {"message": "Welcome to SMS Classification API"}
+
+# 🔢 2️⃣ Cosine Similarity Endpoint
+@app.post("/cosine_similarity")
+async def get_cosine_similarity(input_data: CosineSimilarityInput):
+    try:
+        return await compute_cosine_similarity(input_data.text1, input_data.text2)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error computing similarity: {str(e)}")
+
+# 📩 3️⃣ SMS Classification Endpoint
+@app.post("/predict_label")
+async def classify_message(input_data: MessageInput):
+    try:
+        return await predict_label(input_data.message)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error predicting label: {str(e)}")
+
+# 📊 4️⃣ Text Embedding Endpoint
+@app.post("/compute_embeddings")
+async def get_embeddings(input_data: EmbeddingInput):
+    try:
+        return await compute_embeddings(input_data.message)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error computing embeddings: {str(e)}")

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+sentence-transformers
+scikit-learn
+pandas
+numpy
+openpyxl  # Needed for reading Excel files
+gradio

schemas/input_schemas.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel
+from typing import List
+
+# Request schema for computing cosine similarity
+class CosineSimilarityInput(BaseModel):
+    text1: str
+    text2: str
+
+# Request schema for SMS classification
+class MessageInput(BaseModel):
+    message: str
+
+# Request schema for computing embeddings
+class EmbeddingInput(BaseModel):
+    message: str
+
+# Response schema for cosine similarity
+class CosineSimilarityResponse(BaseModel):
+    cosine_similarity: float
+
+# Response schema for embeddings
+class EmbeddingResponse(BaseModel):
+    embeddings: List[List[float]]

services/sms_service.py

@@ -0,0 +1,58 @@
+import pickle
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from sklearn.feature_extraction.text import TfidfVectorizer
+from fastapi import HTTPException
+from schemas.input_schemas import CosineSimilarityResponse, EmbeddingResponse
+
+# Load the trained model and vectorizer
+def load_model():
+    model_path = "models/sms_classifier_model.pkl"
+    vectorizer_path = "models/tfidf_vectorizer.pkl"
+
+    try:
+        with open(model_path, 'rb') as f:
+            classifier = pickle.load(f)
+
+        with open(vectorizer_path, 'rb') as f:
+            vectorizer = pickle.load(f)
+
+        return classifier, vectorizer
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error loading model: {str(e)}")
+
+async def predict_label(message: str):
+    try:
+        classifier, vectorizer = load_model()
+        # Vectorize the input message
+        message_vec = vectorizer.transform([message])
+
+        # Predict the label
+        label = classifier.predict(message_vec)[0]
+        return {"label": label}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error predicting label: {str(e)}")
+
+async def compute_cosine_similarity(text1: str, text2: str):
+    try:
+        classifier, vectorizer = load_model()
+
+        # Vectorize the input texts
+        vec1 = vectorizer.transform([text1]).toarray()
+        vec2 = vectorizer.transform([text2]).toarray()
+
+        # Compute cosine similarity
+        cosine_sim = np.dot(vec1, vec2.T) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
+        return CosineSimilarityResponse(cosine_similarity=cosine_sim[0][0])
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error computing similarity: {str(e)}")
+
+async def compute_embeddings(message: str):
+    try:
+        classifier, vectorizer = load_model()
+
+        # Vectorize the input message
+        embedding = vectorizer.transform([message]).toarray().tolist()
+        return EmbeddingResponse(embeddings=embedding)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error computing embeddings: {str(e)}")

services/train_model.py

@@ -0,0 +1,42 @@
+import pandas as pd
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+import pickle
+import os
+
+# Load the dataset
+file_path = "data/sms_process_data_main.xlsx"
+df = pd.read_excel(file_path)
+
+# Prepare the features and labels
+X = df['MessageText']  # SMS messages
+y = df['label']        # Labels: 'Transaction' or 'Offer'
+
+# Split the data into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize the TF-IDF Vectorizer
+vectorizer = TfidfVectorizer(max_features=5000)
+
+# Fit the vectorizer on the training data and transform the training data
+X_train_vec = vectorizer.fit_transform(X_train)
+
+# Initialize and train the logistic regression model
+classifier = LogisticRegression()
+classifier.fit(X_train_vec, y_train)
+
+# Save the trained model and vectorizer
+models_dir = "models"
+if not os.path.exists(models_dir):
+    os.makedirs(models_dir)
+
+# Save the classifier model
+with open(os.path.join(models_dir, 'sms_classifier_model.pkl'), 'wb') as model_file:
+    pickle.dump(classifier, model_file)
+
+# Save the vectorizer
+with open(os.path.join(models_dir, 'tfidf_vectorizer.pkl'), 'wb') as vectorizer_file:
+    pickle.dump(vectorizer, vectorizer_file)
+
+print("Model and vectorizer saved successfully!")