Update app.py

app.py

@@ -37,13 +37,8 @@ logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
-# Model configuration
-MODEL_CHOICES = {
-    "TinyLlama (Fastest)": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
-    "Phi-2 (Balanced)": "microsoft/phi-2",
-    "DeepSeek-V3 (Most Powerful)": "deepseek-ai/DeepSeek-V3"
-}
-DEFAULT_MODEL = "TinyLlama (Fastest)"
+# Model configuration - Only DeepSeek
+MODEL_NAME = "deepseek-ai/DeepSeek-V3"
 
 # Initialize Hugging Face API
 if HF_TOKEN:
@@ -61,11 +56,11 @@ class ModelLoader:
         self.loaded = False
         self.loading = False
         self.error = None
-        self.current_model = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
     
-    def load_model(self, model_name: str, progress: gr.Progress = None) -> Tuple[Optional[AutoModelForCausalLM], Optional[AutoTokenizer]]:
+    def load_model(self, progress: gr.Progress = None) -> Tuple[Optional[AutoModelForCausalLM], Optional[AutoTokenizer]]:
         """Lazy load the model with progress feedback"""
-        if self.loaded and self.current_model == model_name:
+        if self.loaded:
             return self.model, self.tokenizer
             
         self.loading = True
@@ -85,48 +80,48 @@ class ModelLoader:
             # Load with optimized settings
             model_kwargs = {
                 "trust_remote_code": True,
-                "torch_dtype": torch.float16,
-                "device_map": "auto",
+                "torch_dtype": torch.float16 if self.device == "cuda" else torch.float32,
+                "device_map": "auto" if self.device == "cuda" else None,
                 "low_cpu_mem_usage": True
             }
             
-            if "TinyLlama" in model_name:
-                model_kwargs["attn_implementation"] = "flash_attention_2"
+            # Add quantization config for low-memory devices
+            if self.device == "cpu":
+                model_kwargs["load_in_8bit"] = True
             
             if progress:
                 progress(0.3, desc="Loading tokenizer...")
             self.tokenizer = AutoTokenizer.from_pretrained(
-                MODEL_CHOICES[model_name],
+                MODEL_NAME,
                 trust_remote_code=True
             )
             
             if progress:
                 progress(0.6, desc="Loading model...")
             self.model = AutoModelForCausalLM.from_pretrained(
-                MODEL_CHOICES[model_name],
+                MODEL_NAME,
                 **model_kwargs
-            )
+            ).to(self.device)
             
             # Verify model responsiveness
             if progress:
                 progress(0.8, desc="Verifying model...")
-            test_input = self.tokenizer("Test", return_tensors="pt").to(self.model.device)
+            test_input = self.tokenizer("Test", return_tensors="pt").to(self.device)
             _ = self.model.generate(**test_input, max_new_tokens=1)
             
             self.model.eval()  # Disable dropout
             if progress:
                 progress(0.9, desc="Finalizing...")
             self.loaded = True
-            self.current_model = model_name
             return self.model, self.tokenizer
             
         except torch.cuda.OutOfMemoryError:
-            self.error = "Out of GPU memory. Try a smaller model."
+            self.error = "Out of GPU memory. Try using CPU instead."
             logging.error(self.error)
             return None, None
         except Exception as e:
-            self.error = str(e)
-            logging.error(f"Model loading error: {str(e)}")
+            self.error = f"Model loading error: {str(e)}"
+            logging.error(self.error)
             return None, None
         finally:
             self.loading = False
@@ -298,30 +293,36 @@ class TranscriptParser:
         }
     
     def _extract_student_info(self, text: str):
-        """Extract student personal information"""
-        header_match = re.search(
-            r"(\d{7}) - ([\w\s,]+)\s*\|\s*Cohort \w+\s*\|\s*Un-weighted GPA ([\d.]+)\s*\|\s*Comm Serv Hours (\d+)",
-            text
+        """Enhanced student info extraction with more robust regex"""
+        # Unified pattern that handles variations in transcript formats
+        header_pattern = (
+            r"(?:Student\s*[:]?\s*|Name\s*[:]?\s*)?"
+            r"(\d{7})\s*[-]?\s*([\w\s,]+?)\s*"
+            r"(?:\||Cohort\s*\w+\s*\||Un-weighted\s*GPA\s*([\d.]+)\s*\||Comm\s*Serv\s*Hours\s*(\d+))?"
         )
+        
+        header_match = re.search(header_pattern, text, re.IGNORECASE)
         if header_match:
             self.student_data = {
-                "id": header_match.group(1),
-                "name": header_match.group(2).strip(),
-                "unweighted_gpa": float(header_match.group(3)),
-                "community_service_hours": int(header_match.group(4))
+                "id": header_match.group(1) if header_match.group(1) else "Unknown",
+                "name": header_match.group(2).strip() if header_match.group(2) else "Unknown",
+                "unweighted_gpa": float(header_match.group(3)) if header_match.group(3) else 0.0,
+                "community_service_hours": int(header_match.group(4)) if header_match.group(4) else 0
             }
         
-        # Extract additional info
-        grade_match = re.search(
-            r"Current Grade: (\d+)\s*\|\s*YOG (\d{4})\s*\|\s*Weighted GPA ([\d.]+)\s*\|\s*Total Credits Earned ([\d.]+)",
-            text
+        # More flexible grade info pattern
+        grade_pattern = (
+            r"(?:Grade|Level)\s*[:]?\s*(\d+)\s*"
+            r"(?:\||YOG\s*[:]?\s*(\d{4})\s*\||Weighted\s*GPA\s*([\d.]+)\s*\||Total\s*Credits\s*Earned\s*([\d.]+))?"
         )
+        
+        grade_match = re.search(grade_pattern, text, re.IGNORECASE)
         if grade_match:
             self.student_data.update({
-                "current_grade": grade_match.group(1),
-                "graduation_year": grade_match.group(2),
-                "weighted_gpa": float(grade_match.group(3)),
-                "total_credits": float(grade_match.group(4))
+                "current_grade": grade_match.group(1) if grade_match.group(1) else "Unknown",
+                "graduation_year": grade_match.group(2) if grade_match.group(2) else "Unknown",
+                "weighted_gpa": float(grade_match.group(3)) if grade_match.group(3) else 0.0,
+                "total_credits": float(grade_match.group(4)) if grade_match.group(4) else 0.0
             })
     
     def _extract_requirements(self, text: str):
@@ -401,7 +402,7 @@ async def parse_transcript_async(file_obj, progress=gr.Progress()):
 
 def parse_transcript_with_ai(text: str, progress=gr.Progress()) -> Dict:
     """Use AI model to parse transcript text with progress feedback"""
-    model, tokenizer = model_loader.load_model(model_loader.current_model or DEFAULT_MODEL, progress)
+    model, tokenizer = model_loader.load_model(progress)
     if model is None or tokenizer is None:
         raise gr.Error(f"Model failed to load. {model_loader.error or 'Please try loading a model first.'}")
     
@@ -472,7 +473,7 @@ def parse_transcript_with_ai_fallback(text: str, progress=gr.Progress()) -> Dict
             progress(0.1, desc="Processing transcript with AI...")
         
         # Tokenize and generate response
-        inputs = model_loader.tokenizer(prompt, return_tensors="pt").to(model_loader.model.device)
+        inputs = model_loader.tokenizer(prompt, return_tensors="pt").to(model_loader.device)
         if progress:
             progress(0.4)
         
@@ -502,7 +503,7 @@ def parse_transcript_with_ai_fallback(text: str, progress=gr.Progress()) -> Dict
         return validate_parsed_data(parsed_data)
     
     except torch.cuda.OutOfMemoryError:
-        raise gr.Error("The model ran out of memory. Try with a smaller transcript or use a smaller model.")
+        raise gr.Error("The model ran out of memory. Try with a smaller transcript.")
     except Exception as e:
         logging.error(f"AI parsing error: {str(e)}")
         raise gr.Error(f"Error processing transcript: {str(e)}")
@@ -1306,12 +1307,6 @@ def create_interface():
             background-color: #fff3e0;
             color: #e65100;
         }
-        .model-selection {
-            margin-bottom: 20px;
-            padding: 15px;
-            background: #f8f9fa;
-            border-radius: 8px;
-        }
         """
         
         gr.Markdown("""
@@ -1320,20 +1315,6 @@ def create_interface():
         Complete each step to get customized learning recommendations.
         """)
         
-        # Model selection section
-        with gr.Group(elem_classes="model-selection"):
-            model_selector = gr.Dropdown(
-                choices=list(MODEL_CHOICES.keys()),
-                value=DEFAULT_MODEL,
-                label="Select AI Model",
-                interactive=True
-            )
-            load_model_btn = gr.Button("Load Selected Model", variant="secondary")
-            model_status = gr.HTML(
-                value="<div class='model-loading'>Model not loaded yet. Please select and load a model.</div>",
-                visible=True
-            )
-        
         # Progress tracker
         with gr.Row():
             with gr.Column(scale=1):
@@ -1353,8 +1334,8 @@ def create_interface():
         # Navigation message
         nav_message = gr.HTML(elem_classes="nav-message", visible=False)
         
-        # Main tabs
-        with gr.Tabs() as tabs:
+        # Main tabs (hidden since we're using the button navigation)
+        with gr.Tabs(visible=False) as tabs:
             # ===== TAB 1: Transcript Upload =====
             with gr.Tab("Transcript Upload", id=0) as tab1:
                 with gr.Row():
@@ -1765,22 +1746,10 @@ def create_interface():
             outputs=[tabs, nav_message]
         )
         
-        # Model loading functions
-        def load_selected_model(model_name, progress=gr.Progress()):
-            try:
-                model_loader.load_model(model_name, progress)
-                if model_loader.loaded:
-                    return gr.update(value=f"<div class='alert-box'>{model_name} loaded successfully!</div>", visible=True)
-                else:
-                    return gr.update(value=f"<div class='nav-message'>Failed to load model: {model_loader.error}</div>", visible=True)
-            except Exception as e:
-                logging.error(f"Model loading error: {str(e)}")
-                return gr.update(value=f"<div class='nav-message'>Error: {str(e)}</div>", visible=True)
-        
-        load_model_btn.click(
-            fn=load_selected_model,
-            inputs=model_selector,
-            outputs=model_status
+        # Load DeepSeek model automatically
+        app.load(
+            fn=lambda: model_loader.load_model(),
+            outputs=[]
         )
     
     return app