FastAPI Space

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,17 @@
+---
+title: CO-PO Mapping API
+emoji: 🎓
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+---
+
+# CO-PO Mapping API
+
+AI-powered Course Outcome to Program Outcome mapping using fine-tuned sentence transformers.
+
+## Endpoints
+
+- `POST /map/semantic` - Pure semantic AI mapping
+- `POST /map/hybrid` - Hybrid (AI + keywords) mapping

app.py

@@ -0,0 +1,163 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import os
+import re
+
+OFFICIAL_PO_DEFINITIONS = {
+    "PO1": "Apply knowledge of mathematics, natural science, computing, engineering fundamentals and an engineering specialization to solve complex engineering problems",
+    "PO2": "Identify, formulate, review research literature and analyze complex engineering problems reaching substantiated conclusions",
+    "PO3": "Design creative solutions for complex engineering problems and design systems, components or processes to meet identified needs",
+    "PO4": "Conduct investigations of complex engineering problems using research-based knowledge including design of experiments, analysis and interpretation of data",
+    "PO5": "Create, select and apply appropriate techniques, resources and modern engineering IT tools to solve complex engineering problems",
+    "PO6": "Analyze societal, environmental and sustainability aspects while solving complex engineering problems",
+    "PO7": "Apply ethical principles and commit to professional ethics and human values",
+    "PO8": "Function effectively as an individual and as a member or leader in diverse teams",
+    "PO9": "Communicate effectively with the engineering community and society",
+    "PO10": "Apply engineering management principles and economic decision-making to manage projects",
+    "PO11": "Recognize the need for independent lifelong learning and adaptability to emerging technologies"
+}
+
+PO_KEYWORDS = {
+    "PO1": ["knowledge", "mathematics", "math", "science", "computing", "engineering", "fundamental", "theory", "concept", "principle", "algorithm", "data structure", "programming", "software", "hardware", "circuit", "system", "analysis", "understand", "explain", "apply", "technical", "computer"],
+    "PO2": ["identify", "formulate", "analyze", "analysis", "problem", "research", "investigate", "investigation", "examine", "evaluate", "evaluation", "assess", "assessment", "literature", "study", "review", "complex"],
+    "PO3": ["design", "create", "develop", "build", "implement", "implementation", "construct", "architecture", "model", "prototype", "system", "component", "solution", "innovative", "creative", "synthesize"],
+    "PO4": ["experiment", "test", "testing", "measure", "measurement", "data", "analysis", "interpret", "interpretation", "validation", "verify", "verification", "research", "investigation", "empirical", "benchmark", "evaluate"],
+    "PO5": ["tool", "tools", "technology", "software", "framework", "platform", "library", "IDE", "programming", "language", "modern", "technique", "method", "approach", "implement", "application", "use", "utilize"],
+    "PO6": ["society", "social", "environmental", "environment", "sustainability", "sustainable", "impact", "ethical", "responsible", "responsibility", "green", "energy", "carbon", "climate", "eco", "community", "culture", "global"],
+    "PO7": ["ethics", "ethical", "professional", "integrity", "responsibility", "responsible", "conduct", "moral", "morality", "values", "principles", "principle", "honesty", "fairness", "accountability", "code of conduct"],
+    "PO8": ["team", "teams", "collaborate", "collaboration", "cooperative", "cooperation", "group", "leadership", "leader", "member", "members", "teamwork", "collective", "peer", "diverse", "diversity", "multicultural", "together"],
+    "PO9": ["communicate", "communication", "present", "presentation", "document", "documentation", "report", "write", "writing", "speak", "speaking", "explain", "articulate", "technical writing", "stakeholder", "audience"],
+    "PO10": ["project", "projects", "management", "manage", "plan", "planning", "schedule", "scheduling", "resource", "resources", "budget", "cost", "timeline", "milestone", "risk", "decision", "economic", "strategy", "organize", "organization"],
+    "PO11": ["learning", "learn", "adapt", "adapting", "adaptability", "emerging", "new", "continuous", "lifelong", "skill", "skills", "development", "growth", "technology", "technologies", "trend", "trends", "innovation", "self-learn", "update", "evolve", "change"]
+}
+
+class FineTunedCOPOMapper:
+    def __init__(self):
+        hf_token = os.environ.get("HF_TOKEN")
+        print("Loading private model from Hugging Face...")
+        self.model = SentenceTransformer("MakPr016/co-po-finetuned-model", use_auth_token=hf_token)
+        print("Model loaded successfully!")
+        self.po_embeddings = {}
+        self._precompute_po_embeddings()
+    
+    def _precompute_po_embeddings(self):
+        for po_id, po_text in OFFICIAL_PO_DEFINITIONS.items():
+            self.po_embeddings[po_id] = self.model.encode([po_text])[0]
+    
+    def _normalize_text(self, text):
+        text = text.lower()
+        text = re.sub(r'[^\w\s]', ' ', text)
+        return re.sub(r'\s+', ' ', text).strip()
+    
+    def _calculate_keyword_score(self, co_text, po_id):
+        co_normalized = self._normalize_text(co_text)
+        co_words = set(co_normalized.split())
+        keywords = PO_KEYWORDS.get(po_id, [])
+        if not keywords:
+            return 0.0
+        matched_count = 0
+        for keyword in keywords:
+            keyword_normalized = self._normalize_text(keyword)
+            if len(keyword_normalized.split()) == 1:
+                if keyword_normalized in co_words:
+                    matched_count += 1
+            else:
+                if keyword_normalized in co_normalized:
+                    matched_count += 2
+        if matched_count == 0:
+            return 0.0
+        elif matched_count <= 3:
+            return 0.3
+        elif matched_count <= 6:
+            return 0.6
+        else:
+            return min(1.0, matched_count / len(keywords) * 3.0)
+    
+    def map_co_to_pos_semantic(self, co_text):
+        co_embedding = self.model.encode([co_text])[0]
+        results = []
+        for po_id, po_embedding in self.po_embeddings.items():
+            similarity = float(cosine_similarity([co_embedding], [po_embedding])[0][0])
+            if similarity > 0.7:
+                strength, confidence = 3, "high"
+            elif similarity > 0.5:
+                strength, confidence = 2, "medium"
+            elif similarity > 0.3:
+                strength, confidence = 1, "low"
+            else:
+                strength, confidence = 0, "very low"
+            results.append({'po_id': po_id, 'score': round(similarity, 3), 'semantic_score': round(similarity, 3), 'strength': strength, 'po_description': OFFICIAL_PO_DEFINITIONS[po_id], 'confidence': confidence, 'method': 'semantic_only'})
+        return sorted(results, key=lambda x: x['score'], reverse=True)
+    
+    def map_co_to_pos_hybrid(self, co_text):
+        co_embedding = self.model.encode([co_text])[0]
+        results = []
+        for po_id, po_embedding in self.po_embeddings.items():
+            semantic_score = float(cosine_similarity([co_embedding], [po_embedding])[0][0])
+            keyword_score = self._calculate_keyword_score(co_text, po_id)
+            final_score = (0.7 * semantic_score) + (0.3 * keyword_score)
+            if final_score > 0.7:
+                strength, confidence = 3, "high"
+            elif final_score > 0.5:
+                strength, confidence = 2, "medium"
+            elif final_score > 0.3:
+                strength, confidence = 1, "low"
+            else:
+                strength, confidence = 0, "very low"
+            results.append({'po_id': po_id, 'score': round(final_score, 3), 'semantic_score': round(semantic_score, 3), 'keyword_score': round(keyword_score, 3), 'strength': strength, 'po_description': OFFICIAL_PO_DEFINITIONS[po_id], 'confidence': confidence, 'method': 'hybrid'})
+        return sorted(results, key=lambda x: x['score'], reverse=True)
+
+app = FastAPI(title="CO-PO Mapping API", version="2.0.0")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+mapper = None
+
+@app.on_event("startup")
+async def startup():
+    global mapper
+    mapper = FineTunedCOPOMapper()
+
+class CORequest(BaseModel):
+    co_text: str
+
+class POMapping(BaseModel):
+    po_id: str
+    score: float
+    semantic_score: float
+    keyword_score: Optional[float] = None
+    strength: int
+    po_description: str
+    confidence: str
+    method: str
+
+class MappingResponse(BaseModel):
+    co_text: str
+    total_pos: int
+    method: str
+    mappings: List[POMapping]
+
+@app.get("/")
+async def root():
+    return {"message": "CO-PO Mapping API", "version": "2.0.0", "status": "active"}
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "model_loaded": mapper is not None}
+
+@app.post("/map/semantic", response_model=MappingResponse)
+async def map_semantic(request: CORequest):
+    if not request.co_text or not request.co_text.strip():
+        raise HTTPException(400, "CO text cannot be empty")
+    results = mapper.map_co_to_pos_semantic(request.co_text)
+    return MappingResponse(co_text=request.co_text, total_pos=len(results), method="semantic_only", mappings=[POMapping(**r) for r in results])
+
+@app.post("/map/hybrid", response_model=MappingResponse)
+async def map_hybrid(request: CORequest):
+    if not request.co_text or not request.co_text.strip():
+        raise HTTPException(400, "CO text cannot be empty")
+    results = mapper.map_co_to_pos_hybrid(request.co_text)
+    return MappingResponse(co_text=request.co_text, total_pos=len(results), method="hybrid", mappings=[POMapping(**r) for r in results])

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+sentence-transformers==2.2.2
+scikit-learn==1.3.2
+torch==2.1.0
+pydantic==2.5.0