message

main.py

@@ -1,40 +1,22 @@
+# app/main.py
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-from sentence_transformers import SentenceTransformer
 import numpy as np
-import pandas as pd
+from linear.services.sms_service import classify_sms, load_trained_model
+from linear.schemas.input_schemas import CosineSimilarityInput, CosineSimilarityOutput
+from linear.schemas.input_schemas import EmbeddingInput, EmbeddingOutput
 
 # Initialize FastAPI
 app = FastAPI()
 
-# Load the sentence transformer model
-try:
-    model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2", trust_remote_code=True)
-    print("✅ Model loaded successfully")
-except Exception as e:
-    raise RuntimeError(f"❌ Failed to load model: {str(e)}")
-
-# Define request schemas
-class CosineSimilarityInput(BaseModel):
-    text1: str
-    text2: str
-
-class MessageInput(BaseModel):
-    message: str
-
-# Load SMS dataset from Excel
-file_path = "sms_process_data_main.xlsx"
-df = pd.read_excel(file_path)
-
-# Precompute embeddings
-transactional_examples = df[df['label'] == 'Transaction']['MessageText'].tolist()
-offer_examples = df[df['label'] == 'Offer']['MessageText'].tolist()
-
-transactional_embeddings = [model.encode(msg, convert_to_tensor=True).cpu().numpy() for msg in transactional_examples]
-offer_embeddings = [model.encode(msg, convert_to_tensor=True).cpu().numpy() for msg in offer_examples]
+# Load the models from the 'models' folder
+model, vectorizer = load_trained_model()
 
 # Function to compute cosine similarity
 def cosine_similarity(vec1, vec2):
+    """
+    Compute cosine similarity between two vectors.
+    """
     norm1 = np.linalg.norm(vec1)
     norm2 = np.linalg.norm(vec2)
     if norm1 == 0 or norm2 == 0:
@@ -44,57 +26,48 @@ def cosine_similarity(vec1, vec2):
 # 🚀 1️⃣ Homepage Endpoint
 @app.get("/")
 async def home():
-    return {"message": "Welcome to Classification of SMS"}
+    return {"message": "Welcome to SMS Classification API"}
+
+# 📩 2️⃣ SMS Classification Endpoint
+class MessageInput(BaseModel):
+    message: str
+
+@app.post("/predict_label/")
+async def classify_sms_endpoint(input_data: MessageInput):
+    """
+    Classify an SMS as either 'Transaction' or 'Offer'.
+    """
+    try:
+        return classify_sms(input_data.message, model, vectorizer)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
 
-# 🔢 2️⃣ Cosine Similarity Endpoint
-@app.post("/cosine_similarity")
+# 🔢 3️⃣ Cosine Similarity Endpoint
+@app.post("/cosine_similarity/", response_model=CosineSimilarityOutput)
 async def compute_similarity(input_data: CosineSimilarityInput):
     """
     Compute cosine similarity between two input texts.
     """
     try:
-        emb1 = model.encode(input_data.text1, convert_to_tensor=True).cpu().numpy()
-        emb2 = model.encode(input_data.text2, convert_to_tensor=True).cpu().numpy()
-        similarity = cosine_similarity(emb1, emb2)
-        return {"cosine_similarity": round(float(similarity), 4)}
+        # Transform the input texts using the TF-IDF vectorizer
+        text1_vectorized = vectorizer.transform([input_data.text1])
+        text2_vectorized = vectorizer.transform([input_data.text2])
+        
+        # Compute the cosine similarity between the two text embeddings
+        similarity = cosine_similarity(text1_vectorized.toarray(), text2_vectorized.toarray())
+        return CosineSimilarityOutput(cosine_similarity=round(float(similarity), 4))
     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):
+# 🧠 4️⃣ Get Embedding of Text Message
+@app.post("/get_embedding/", response_model=EmbeddingOutput)
+async def get_embedding(input_data: EmbeddingInput):
     """
-    Classify an SMS as either 'Transaction' or 'Offer'.
+    Get the embedding (vector representation) of an input text message.
     """
     try:
-        # Validate input
-        text_input = input_data.message.strip()
-        if not text_input:
-            raise HTTPException(status_code=400, detail="Input message cannot be empty")
-
-        # Encode input text
-        input_embedding = model.encode(text_input, convert_to_tensor=True).cpu().numpy()
-
-        # Compute similarity scores
-        transactional_scores = [cosine_similarity(input_embedding, emb) for emb in transactional_embeddings]
-        offer_scores = [cosine_similarity(input_embedding, emb) for emb in offer_embeddings]
-
-        # Get max similarity
-        max_transactional = max(transactional_scores, default=0)
-        max_offer = max(offer_scores, default=0)
-
-        # Determine label and probability
-        if max_transactional > max_offer:
-            label = "Transaction"
-
-        else:
-            label = "Offer"
-
-        return {
-            "label": label
-        }
-
+        # Transform the input text using the TF-IDF vectorizer
+        text_embedding = vectorizer.transform([input_data.message]).toarray().tolist()
+        return EmbeddingOutput(embedding=text_embedding[0])
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
-
-
+        raise HTTPException(status_code=500, detail=f"Error generating embedding: {str(e)}")

models/sms_classifier_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c2b852be29075447f1306196af754cb31984406f591abc7891815e3b7c0e972
+size 21305

models/tfidf_vectorizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cebef878c5c22a6e58d1e80484d053b18402989ba83bbea4ce766ec3ace1bc6
+size 93623

schemas/input_schemas.py

@@ -0,0 +1,19 @@
+# app/schemas/input_schemas.py
+from pydantic import BaseModel
+
+class CosineSimilarityInput(BaseModel):
+    text1: str
+    text2: str
+
+class MessageInput(BaseModel):
+    message: str
+
+
+
+class CosineSimilarityResponse(BaseModel):
+    cosine_similarity: float
+
+
+class EmbeddingResponse(BaseModel):
+    embeddings: list
+

services/sms_service.py

@@ -0,0 +1,59 @@
+# app/services/sms_service.py
+import pickle
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from fastapi import HTTPException
+from linear.schemas.input_schemas import CosineSimilarityResponse
+from linear.schemas.input_schemas import 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,43 @@
+# app/services/train_model.py
+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!")