Added post processing

.gitignore

@@ -1,3 +1,5 @@
 venv**
 __pycache__/
-*.pyc
+*.pyc
+.env
+.DS_Store

app.py

@@ -7,8 +7,12 @@ from sklearn.metrics.pairwise import cosine_similarity
 import os
 import re
 from datetime import datetime
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
 
-# Official PO Definitions (your complete version)
 OFFICIAL_PO_DEFINITIONS = {
     "PO1": "Apply the knowledge of mathematics, science, engineering fundamentals, and an engineering specialization to the solution of complex engineering problems",
     "PO2": "Identify, formulate, review research literature, and analyze complex engineering problems reaching substantiated conclusions using first principles of mathematics, natural sciences, and engineering sciences",
@@ -23,7 +27,7 @@ OFFICIAL_PO_DEFINITIONS = {
     "PO11": "Demonstrate knowledge and understanding of the engineering and management principles and apply these to one's own work, as a member and leader in a team, to manage projects and in multidisciplinary environments"
 }
 
-# Bloom's Taxonomy Definitions
+
 BLOOM_LEVEL_DEFINITIONS = {
     "Remember": "Recall facts, terms, basic concepts, and answers without necessarily understanding",
     "Understand": "Demonstrate understanding of facts and ideas by organizing, comparing, translating, interpreting",
@@ -33,7 +37,7 @@ BLOOM_LEVEL_DEFINITIONS = {
     "Create": "Compile information together in a different way by combining elements in new patterns or proposing alternative solutions"
 }
 
-# PO Keywords (your complete version)
+
 PO_KEYWORDS = {
     "PO1": [
         "knowledge", "mathematics", "math", "science", "computing", "engineering", 
@@ -212,12 +216,34 @@ PO_KEYWORDS = {
     ]
 }
 
+
 class FineTunedCOPOMapper:
     def __init__(self):
-        hf_token = os.environ.get("HF_TOKEN")
-        print("Loading model from Hugging Face...")
-        self.model = SentenceTransformer("MakPr016/co-po-bloom-model", token=hf_token)
-        print("Model loaded successfully! (88.1% accuracy)")
+        print("Loading model...")
+        
+        try:
+            self.model = SentenceTransformer(
+                "MakPr016/co-po-bloom-model",
+                local_files_only=True,
+                trust_remote_code=False
+            )
+            print("Model loaded from cache (Offline mode)")
+        except Exception as e:
+            print(f"Offline mode failed: {str(e)}")
+            print("Attempting online load...")
+            try:
+                hf_token = os.environ.get("HF_TOKEN")
+                if not hf_token:
+                    raise ValueError("HF_TOKEN not set")
+                self.model = SentenceTransformer(
+                    "MakPr016/co-po-bloom-model",
+                    token=hf_token
+                )
+                print("Model loaded from HuggingFace (Online mode)")
+            except Exception as e2:
+                print(f"Online mode also failed: {str(e2)}")
+                raise
+        
         self.po_embeddings = {}
         self.bloom_embeddings = {}
         self._precompute_embeddings()
@@ -257,8 +283,54 @@ class FineTunedCOPOMapper:
         else:
             return min(1.0, matched_count / len(keywords) * 3.0)
     
+    def _apply_constraints(self, results, co_text):
+        po_scores = {r['po_id']: r['score'] for r in results}
+        
+        po_hierarchy = ['PO1', 'PO2', 'PO3', 'PO4']
+        for i in range(len(po_hierarchy) - 1):
+            current_po = po_hierarchy[i]
+            next_po = po_hierarchy[i + 1]
+            if po_scores[current_po] < po_scores[next_po]:
+                po_scores[next_po] = po_scores[current_po]
+        
+        po7_keywords = [
+            "sustainability", "environmental", "resource efficiency", "renewable",
+            "pollution", "waste", "climate", "conservation", "eco", "green",
+            "carbon", "lifecycle", "circular economy", "biodiversity"
+        ]
+        co_lower = co_text.lower()
+        po7_keyword_matches = sum(1 for keyword in po7_keywords if keyword in co_lower)
+        
+        if po7_keyword_matches >= 3:
+            po_scores['PO7'] = 0.8
+        elif po7_keyword_matches == 2:
+            po_scores['PO7'] = 0.7
+        elif po7_keyword_matches == 1:
+            po_scores['PO7'] = 0.6
+        else:
+            po_scores['PO7'] = 0.4
+        
+        po11_keywords = [
+            "project", "management", "plan", "budget", "schedule", "resource",
+            "timeline", "milestone", "risk", "team", "coordinate", "execute"
+        ]
+        po11_keyword_matches = sum(1 for keyword in po11_keywords if keyword in co_lower)
+        
+        if po11_keyword_matches >= 3:
+            po_scores['PO11'] = 0.8
+        elif po11_keyword_matches == 2:
+            po_scores['PO11'] = 0.7
+        elif po11_keyword_matches == 1:
+            po_scores['PO11'] = 0.6
+        else:
+            po_scores['PO11'] = 0.4
+        
+        for result in results:
+            result['score'] = round(po_scores[result['po_id']], 3)
+        
+        return sorted(results, key=lambda x: x['score'], reverse=True)    
+    
     def predict_bloom_level(self, co_text):
-        """Predict Bloom's taxonomy level"""
         co_embedding = self.model.encode([co_text])[0]
         bloom_scores = {}
         for level, bloom_embedding in self.bloom_embeddings.items():
@@ -296,7 +368,8 @@ class FineTunedCOPOMapper:
                 'confidence': confidence,
                 'method': 'semantic_only'
             })
-        return sorted(results, key=lambda x: x['score'], reverse=True)
+        results = self._apply_constraints(results, co_text)
+        return results
     
     def map_co_to_pos_hybrid(self, co_text):
         co_embedding = self.model.encode([co_text])[0]
@@ -304,7 +377,6 @@ class FineTunedCOPOMapper:
         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)
-            # 80:20 ratio (semantic:keywords)
             final_score = (0.80 * semantic_score) + (0.20 * keyword_score)
             if final_score > 0.7:
                 strength, confidence = 3, "high"
@@ -324,27 +396,34 @@ class FineTunedCOPOMapper:
                 'confidence': confidence,
                 'method': 'hybrid'
             })
-        return sorted(results, key=lambda x: x['score'], reverse=True)
+        results = self._apply_constraints(results, co_text)
+        return results
+
 
 app = FastAPI(title="CO-PO Mapping API", version="3.0.0 (with Bloom's)")
 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
     include_bloom: bool = True
 
+
 class BatchCORequest(BaseModel):
     co_texts: List[str]
     include_bloom: bool = True
     max_cos: int = 50
 
+
 class POMapping(BaseModel):
     po_id: str
     score: float
@@ -355,12 +434,14 @@ class POMapping(BaseModel):
     confidence: str
     method: str
 
+
 class BloomPrediction(BaseModel):
     predicted_level: str
     confidence: float
     all_scores: Dict[str, float]
     description: str
 
+
 class MappingResponse(BaseModel):
     co_text: str
     total_pos: int
@@ -368,11 +449,13 @@ class MappingResponse(BaseModel):
     mappings: List[POMapping]
     bloom_prediction: Optional[BloomPrediction] = None
 
+
 class BatchMappingResponse(BaseModel):
     total_cos: int
     method: str
     results: List[Dict[str, Any]]
 
+
 @app.get("/")
 async def root():
     return {
@@ -382,10 +465,12 @@ async def root():
         "features": ["PO Mapping", "Bloom's Taxonomy", "Semantic + Hybrid modes"]
     }
 
+
 @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():
@@ -400,6 +485,7 @@ async def map_semantic(request: CORequest):
         bloom_prediction=BloomPrediction(**bloom) if bloom else None
     )
 
+
 @app.post("/map/hybrid", response_model=MappingResponse)
 async def map_hybrid(request: CORequest):
     if not request.co_text or not request.co_text.strip():
@@ -414,6 +500,7 @@ async def map_hybrid(request: CORequest):
         bloom_prediction=BloomPrediction(**bloom) if bloom else None
     )
 
+
 @app.post("/map/batch/semantic", response_model=BatchMappingResponse)
 async def map_batch_semantic(request: BatchCORequest):
     if not request.co_texts or len(request.co_texts) == 0:
@@ -437,6 +524,7 @@ async def map_batch_semantic(request: BatchCORequest):
     
     return BatchMappingResponse(total_cos=len(results), method="semantic_only", results=results)
 
+
 @app.post("/map/batch/hybrid", response_model=BatchMappingResponse)
 async def map_batch_hybrid(request: BatchCORequest):
     if not request.co_texts or len(request.co_texts) == 0: