completed

.env

@@ -0,0 +1,14 @@
+# Project name
+PROJECT_NAME="Sentiment Analysis for Lms" 
+# Project version
+PROJECT_VERSION="0.1.0" 
+#mongoDB connection string
+DATABASE_URL=mongodb://localhost:27017 
+# Database name
+DATABASE_NAME="lms-saas" 
+# JWT algorithm
+ALGORITHM="HS256" 
+# Access token expiration time in minutes
+ACCESS_TOKEN_EXPIRE_MINUTES=60 
+# Secret key for JWT
+SECRET_KEY="sdaskiupo9865r392hri97t9trbw86trp97wxwjyt9r876acp9eirba7t9aw"

.gitignore

@@ -0,0 +1,28 @@
+#fastapi gitignore
+
+# Byte-compiled / optimized / DLL files
+/**/__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.pdb
+*.egg-info/
+*.egg
+*.whl
+
+/.venv
+/ai/models/*
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+wheelfile
+.installed.cfg

ai/emotion.py

@@ -0,0 +1,114 @@
+import torch
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+import cv2
+import torchvision.transforms as transforms
+import os
+import numpy as np
+
+class Emotion:
+    def __init__(self, model_path):
+        self.model = AutoModelForImageClassification.from_pretrained(model_path)
+        self.model.eval()
+        self.id2label = self.model.config.id2label
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5]*3, std=[0.5]*3)
+        ])
+        self.face_cascade = cv2.CascadeClassifier(
+            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+        )
+
+    def predict_from_frame(self, frame):
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = self.face_cascade.detectMultiScale(
+            gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)
+        )
+        if len(faces) > 0:
+            x, y, w, h = faces[0]
+            face_roi = frame[y:y+h, x:x+w]
+            img = Image.fromarray(cv2.cvtColor(face_roi, cv2.COLOR_BGR2RGB))
+            input_tensor = self.transform(img).unsqueeze(0)
+            with torch.no_grad():
+                outputs = self.model(input_tensor)
+                predicted_class = torch.argmax(outputs.logits, dim=1).item()
+                label = self.id2label[predicted_class]
+            return label, faces[0]
+        else:
+            return None, None
+
+    def predict_from_frame_bytes(self, frame_bytes):
+        # Convert bytes to numpy array
+        nparr = np.frombuffer(frame_bytes, np.uint8)
+        # Decode image (assuming JPEG/PNG)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        if img is None:
+            raise ValueError("Could not decode image from bytes")
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        faces = self.face_cascade.detectMultiScale(
+            gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)
+        )
+        if len(faces) > 0:
+            x, y, w, h = faces[0]
+            face_roi = img[y:y+h, x:x+w]
+            img = Image.fromarray(cv2.cvtColor(face_roi, cv2.COLOR_BGR2RGB))
+            input_tensor = self.transform(img).unsqueeze(0)
+            with torch.no_grad():
+                outputs = self.model(input_tensor)
+                predicted_class = torch.argmax(outputs.logits, dim=1).item()
+                label = self.id2label[predicted_class]
+            return label, faces[0]
+        else:
+            return None, None
+
+model_path = os.path.join(os.path.dirname(__file__), "models", "emotion")
+emotion_model = Emotion(model_path)
+
+def webcam_demo(emotion_model):
+    cap = cv2.VideoCapture(0)
+    print("Press 'q' to quit")
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        label, face = emotion_model.predict_from_frame(frame)
+        if label:
+            cv2.putText(frame, f"Prediction: {label}", (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+        else:
+            cv2.putText(frame, "Not attending the class", (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+        cv2.imshow("Webcam - Expression Classification", frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    cap.release()
+    cv2.destroyAllWindows()
+
+def analyze_local_video(emotion_model, video_path, output_path):
+    cap = cv2.VideoCapture(video_path)
+    fourcc = cv2.VideoWriter_fourcc(*'XVID')
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        label, face = emotion_model.predict_from_frame(frame)
+        if label:
+            cv2.putText(frame, f"Prediction: {label}", (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+        else:
+            cv2.putText(frame, "Not attending the class", (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+        out.write(frame)
+        cv2.imshow("Video - Expression Classification", frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    cap.release()
+    out.release()
+    cv2.destroyAllWindows()
+
+
+# if __name__ == "__main__":
+#     model_path = os.path.join(os.path.dirname(__file__), "models", "emotion")
+#     emotion_model = Emotion(model_path)
+#     webcam_demo(emotion_model)

ai/sentiment.py

@@ -0,0 +1,27 @@
+import torch
+import os
+from transformers import AutoModelForSequenceClassification, BertTokenizerFast
+
+modal_path = os.path.join(os.path.dirname(__file__), "models", "sentiment")
+tokenizer = BertTokenizerFast.from_pretrained(modal_path)
+model = AutoModelForSequenceClassification.from_pretrained(modal_path, return_dict=True)
+
+
+class Sentiment:
+    def __init__(self):
+        pass
+
+    def predict(self, text: str) -> int:
+        inputs = tokenizer(
+            text, max_length=512, padding=True, truncation=True, return_tensors="pt"
+        )
+        outputs = model(**inputs)
+        probs = torch.nn.functional.softmax(outputs.logits, dim=1)
+        predicted = {
+            "feedback_positive_score": int(probs[0][1].item() * 100),
+            "feedback_negative_score": int(probs[0][2].item() * 100),
+        }
+        return predicted
+
+
+sentiment_model = Sentiment()

app.py

@@ -1,7 +1,87 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from routes.index import router
+import websockets
+from ai.emotion import emotion_model
 
 app = FastAPI()
 
+
 @app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
+def read_root():
+    return {"message": "Hello, FastAPI!"}
+
+
+# To run: uvicorn main:app --reload
+
+
+# pymongo
+
+from pymongo.mongo_client import MongoClient
+
+uri = "mongodb+srv://gowdaman:gowdaman@cluster0.z5dooqf.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0"
+client = MongoClient(uri)
+db = client["ai-saas"]
+emotion = db["emotion"]
+sentiment = db["sentiments"]
+
+
+# emotion detection
+import base64
+import json
+from bson.objectid import ObjectId
+from bson import ObjectId
+
+
+@app.websocket("/emotion")
+async def websocket_emotion(websocket: WebSocket):
+    await websocket.accept()
+    course_id = None
+    try:
+        while True:
+            data = await websocket.receive_text()
+            msg = json.loads(data)
+            image_b64 = msg.get("image")
+            course_id = msg.get("course_id")  # Get the courseId from the message
+            if not image_b64:
+                await websocket.send_text("No image data received")
+                continue
+            image_bytes = base64.b64decode(image_b64)
+            label, face = emotion_model.predict_from_frame_bytes(image_bytes)
+            await websocket.send_text(str(label))
+    except WebSocketDisconnect:
+        # Do not call await websocket.close() here
+        pass
+    finally:
+        print(f"WebSocket connection closed for user with course ID {course_id}")
+        # Convert course_id to ObjectId if it's a string
+        try:
+            course_obj_id = ObjectId(course_id)
+            # course_obj_id = course_id  # fallback if already ObjectId or invalid
+            emotion_data = emotion.find_one({"course_id": course_obj_id})
+            total_len = len(emotion_data['emotion'])
+            print(emotion_data['emotion'].count(0)) # negetive
+            print(emotion_data['emotion'].count(1)) # positive
+            #positive percentage
+            positive_percentage = round((emotion_data['emotion'].count(1)/total_len)*100,2)
+            negative_percentage = round((emotion_data['emotion'].count(0)/total_len)*100,2)
+            print(positive_percentage)
+            print(negative_percentage)
+            sentiment.update_one(
+                {"course_id": course_obj_id},
+                {
+                    "$set": {
+                        "expression_positive_score": positive_percentage,
+                        "expression_negetive_score": negative_percentage,
+                    }
+                },
+            )
+        except Exception:
+            pass
+
+
+app.include_router(router)
+
+# if __name__ == "__main__":
+#     import uvicorn
+
+#     uvicorn.run("main:app", host="0.0.0.0", port=7000, reload=True)

requirements.txt

@@ -1,2 +1,56 @@
 fastapi
 uvicorn[standard]
+annotated-types==0.7.0
+anyio==4.9.0
+certifi==2025.4.26
+charset-normalizer==3.4.1
+click==8.1.8
+dnspython==2.7.0
+filelock==3.18.0
+fsspec==2025.3.2
+h11==0.16.0
+huggingface-hub==0.30.2
+idna==3.10
+Jinja2==3.1.6
+MarkupSafe==3.0.2
+mpmath==1.3.0
+networkx==3.4.2
+numpy==2.2.5
+nvidia-cublas-cu12==12.6.4.1
+nvidia-cuda-cupti-cu12==12.6.80
+nvidia-cuda-nvrtc-cu12==12.6.77
+nvidia-cuda-runtime-cu12==12.6.77
+nvidia-cudnn-cu12==9.5.1.17
+nvidia-cufft-cu12==11.3.0.4
+nvidia-cufile-cu12==1.11.1.6
+nvidia-curand-cu12==10.3.7.77
+nvidia-cusolver-cu12==11.7.1.2
+nvidia-cusparse-cu12==12.5.4.2
+nvidia-cusparselt-cu12==0.6.3
+nvidia-nccl-cu12==2.26.2
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nvtx-cu12==12.6.77
+opencv-python==4.11.0.86
+packaging==25.0
+pillow==11.2.1
+pydantic==2.11.4
+pydantic_core==2.33.2
+pymongo==4.12.1
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.3
+safetensors==0.5.3
+setuptools==80.1.0
+sniffio==1.3.1
+starlette==0.46.2
+sympy==1.14.0
+tokenizers==0.21.1
+torch==2.7.0
+torchvision==0.22.0
+tqdm==4.67.1
+transformers==4.51.3
+triton==3.3.0
+typing-inspection==0.4.0
+typing_extensions==4.13.2
+urllib3==2.4.0
+websockets==15.0.1

routes/feedback.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from ai.sentiment import sentiment_model
+from pydantic import BaseModel
+
+feedback_router = APIRouter(
+    prefix="/feedback",
+    tags=["Feedback"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@feedback_router.get("/")
+async def root():
+    return {"message": "Hello World"}
+
+
+class FeedbackModel(BaseModel):
+    text: str
+
+
+@feedback_router.post("/")
+def get_feedback_setiment(data: FeedbackModel):
+    return sentiment_model.predict(text=data.text)

routes/index.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+from .feedback import feedback_router
+
+router = APIRouter(
+    prefix="/api",
+)
+
+router.include_router(feedback_router)