ss

app.py

@@ -34,6 +34,95 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
+# --- Global Device and Model Loading Section ---
+
+# Initialize session state keys for all models, their loading status/errors, and app data
+keys_to_initialize = {
+    'embedding_model': None, 'embedding_model_error': None,
+    'cross_encoder': None, 'cross_encoder_error': None,
+    'qwen3_1_7b_tokenizer': None, 'qwen3_1_7b_tokenizer_error': None,
+    'qwen3_1_7b_model': None, 'qwen3_1_7b_model_error': None,
+    'results': [], 'resume_texts': [], 'file_names': [], 'current_job_description': ""
+    # Add any other app-specific session state keys here if needed
+}
+for key, default_value in keys_to_initialize.items():
+    if key not in st.session_state:
+        st.session_state[key] = default_value
+
+# Load Embedding Model (BAAI/bge-large-en-v1.5)
+if st.session_state.embedding_model is None and st.session_state.embedding_model_error is None:
+    print("[Global Init] Attempting to load Embedding Model (BAAI/bge-large-en-v1.5) with device_map='auto'...")
+    try:
+        st.session_state.embedding_model = SentenceTransformer(
+            'BAAI/bge-large-en-v1.5', 
+            device_map="auto"
+        )
+        print(f"[Global Init] Embedding Model (BAAI/bge-large-en-v1.5) LOADED with device_map='auto'.")
+    except Exception as e:
+        if "device_map" in str(e).lower() and "unexpected keyword argument" in str(e).lower():
+            print("⚠️ [Global Init] device_map='auto' not supported for SentenceTransformer. Falling back to default device handling.")
+            try:
+                st.session_state.embedding_model = SentenceTransformer('BAAI/bge-large-en-v1.5')
+                print(f"[Global Init] Embedding Model (BAAI/bge-large-en-v1.5) LOADED (fallback device handling).")
+            except Exception as e_fallback:
+                error_msg = f"Failed to load Embedding Model (fallback): {str(e_fallback)}"
+                print(f"❌ [Global Init] {error_msg}")
+                st.session_state.embedding_model_error = error_msg
+        else:
+            error_msg = f"Failed to load Embedding Model: {str(e)}"
+            print(f"❌ [Global Init] {error_msg}")
+            st.session_state.embedding_model_error = error_msg
+
+# Load Cross-Encoder Model (ms-marco-MiniLM-L6-v2)
+if st.session_state.cross_encoder is None and st.session_state.cross_encoder_error is None:
+    print("[Global Init] Attempting to load Cross-Encoder Model (ms-marco-MiniLM-L6-v2) with device_map='auto'...")
+    try:
+        st.session_state.cross_encoder = CrossEncoder(
+            'cross-encoder/ms-marco-MiniLM-L6-v2', 
+            device_map="auto"
+        )
+        print(f"[Global Init] Cross-Encoder Model (ms-marco-MiniLM-L6-v2) LOADED with device_map='auto'.")
+    except Exception as e:
+        if "device_map" in str(e).lower() and "unexpected keyword argument" in str(e).lower():
+            print("⚠️ [Global Init] device_map='auto' not supported for CrossEncoder. Falling back to default device handling.")
+            try:
+                st.session_state.cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L6-v2')
+                print(f"[Global Init] Cross-Encoder Model (ms-marco-MiniLM-L6-v2) LOADED (fallback device handling).")
+            except Exception as e_fallback:
+                error_msg = f"Failed to load Cross-Encoder Model (fallback): {str(e_fallback)}"
+                print(f"❌ [Global Init] {error_msg}")
+                st.session_state.cross_encoder_error = error_msg
+        else:
+            error_msg = f"Failed to load Cross-Encoder Model: {str(e)}"
+            print(f"❌ [Global Init] {error_msg}")
+            st.session_state.cross_encoder_error = error_msg
+
+# Load Qwen3-1.7B Tokenizer
+if st.session_state.qwen3_1_7b_tokenizer is None and st.session_state.qwen3_1_7b_tokenizer_error is None:
+    print("[Global Init] Loading Qwen3-1.7B Tokenizer...")
+    try:
+        st.session_state.qwen3_1_7b_tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-1.7B")
+        print("[Global Init] Qwen3-1.7B Tokenizer Loaded.")
+    except Exception as e:
+        error_msg = f"Failed to load Qwen3-1.7B Tokenizer: {str(e)}"
+        print(f"❌ [Global Init] {error_msg}")
+        st.session_state.qwen3_1_7b_tokenizer_error = error_msg
+
+# Load Qwen3-1.7B Model
+if st.session_state.qwen3_1_7b_model is None and st.session_state.qwen3_1_7b_model_error is None:
+    print("[Global Init] Loading Qwen3-1.7B Model...")
+    try:
+        st.session_state.qwen3_1_7b_model = AutoModelForCausalLM.from_pretrained(
+            "Qwen/Qwen3-1.7B", torch_dtype="auto", device_map="auto"
+        )
+        print("[Global Init] Qwen3-1.7B Model Loaded.")
+    except Exception as e:
+        error_msg = f"Failed to load Qwen3-1.7B Model: {str(e)}"
+        print(f"❌ [Global Init] {error_msg}")
+        st.session_state.qwen3_1_7b_model_error = error_msg
+
+# --- End of Global Model Loading Section ---
+
 # Sidebar configuration
 with st.sidebar:
     st.title("⚙️ Configuration")
@@ -63,478 +152,40 @@ with st.sidebar:
     st.markdown("### 📈 Scoring Formula")
     st.markdown("**Final Score = Cross-Encoder (0-1) + BM25 (0.1-0.2) + Intent (0-0.3)**")
 
-# Initialize session state
-if 'embedding_model' not in st.session_state:
-    st.session_state.embedding_model = None
-if 'cross_encoder' not in st.session_state:
-    st.session_state.cross_encoder = None
-if 'results' not in st.session_state:
-    st.session_state.results = []
-if 'resume_texts' not in st.session_state:
-    st.session_state.resume_texts = []
-if 'file_names' not in st.session_state:
-    st.session_state.file_names = []
-if 'current_job_description' not in st.session_state:
-    st.session_state.current_job_description = ""
-if 'qwen3_1_7b_tokenizer' not in st.session_state:
-    print("[Init] Loading Qwen3-1.7B Tokenizer...")
-    st.session_state.qwen3_1_7b_tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-1.7B")
-    print("[Init] Qwen3-1.7B Tokenizer Loaded.")
-if 'qwen3_1_7b_model' not in st.session_state:
-    print("[Init] Loading Qwen3-1.7B Model...")
-    st.session_state.qwen3_1_7b_model = AutoModelForCausalLM.from_pretrained(
-        "Qwen/Qwen3-1.7B", torch_dtype="auto", device_map="auto"
-    )
-    print("[Init] Qwen3-1.7B Model Loaded.")
-
-@st.cache_resource
-def load_embedding_model():
-    """Load and cache the BGE embedding model"""
-    print("[Cache] Attempting to load Embedding Model (BAAI/bge-large-en-v1.5)...")
-    try:
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"[Cache] Using device: {device} for embedding model")
-        with st.spinner("🔄 Loading BAAI/bge-large-en-v1.5 model..."):
-            model = SentenceTransformer('BAAI/bge-large-en-v1.5', device=device)
-            st.success("✅ Embedding model loaded successfully!")
-            print("[Cache] Embedding Model (BAAI/bge-large-en-v1.5) LOADED.")
-            return model
-    except Exception as e:
-        st.error(f"❌ Error loading embedding model: {str(e)}")
-        return None
-
-@st.cache_resource
-def load_cross_encoder():
-    """Load and cache the Cross-Encoder model"""
-    print("[Cache] Attempting to load Cross-Encoder Model (ms-marco-MiniLM-L6-v2)...")
-    try:
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"[Cache] Using device: {device} for cross-encoder model")
-        with st.spinner("🔄 Loading Cross-Encoder ms-marco-MiniLM-L6-v2..."):
-            from sentence_transformers import CrossEncoder
-            model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L6-v2', device=device)
-            st.success("✅ Cross-Encoder model loaded successfully!")
-            print("[Cache] Cross-Encoder Model (ms-marco-MiniLM-L6-v2) LOADED.")
-            return model
-    except Exception as e:
-        st.error(f"❌ Error loading Cross-Encoder model: {str(e)}")
-        return None
-
-def generate_qwen3_response(prompt, tokenizer, model, max_new_tokens=200):
-    messages = [{"role": "user", "content": prompt}]
-    text = tokenizer.apply_chat_template(
-        messages,
-        tokenize=False,
-        add_generation_prompt=True,
-        enable_thinking=True
-    )
-    model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
-    generated_ids = model.generate(
-        **model_inputs,
-        max_new_tokens=max_new_tokens
-    )
-    output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
-    response = tokenizer.decode(output_ids, skip_special_tokens=True).strip("\n")
-    return response
-
-class ResumeScreener:
-    def __init__(self):
-        print("[ResumeScreener] Initializing...")
-        st.text("Initializing Screener: Loading embedding model...")
-        self.embedding_model = load_embedding_model()
-        st.text("Initializing Screener: Loading cross-encoder model...")
-        self.cross_encoder = load_cross_encoder()
-        print("[ResumeScreener] Initialized.")
-        st.text("Screener Ready.")
-    
-    def extract_text_from_file(self, file_path, file_type):
-        """Extract text from various file types"""
-        try:
-            if file_type == "pdf":
-                with open(file_path, 'rb') as file:
-                    with pdfplumber.open(file) as pdf:
-                        text = ""
-                        for page in pdf.pages:
-                            text += page.extract_text() or ""
-                        
-                        if not text.strip():
-                            # Fallback to PyPDF2
-                            file.seek(0)
-                            reader = PyPDF2.PdfReader(file)
-                            text = ""
-                            for page in reader.pages:
-                                text += page.extract_text() or ""
-                        return text
-                        
-            elif file_type == "docx":
-                doc = Document(file_path)
-                return " ".join([paragraph.text for paragraph in doc.paragraphs])
-                
-            elif file_type == "txt":
-                with open(file_path, 'r', encoding='utf-8') as file:
-                    return file.read()
-                    
-            elif file_type == "csv":
-                with open(file_path, 'r', encoding='utf-8') as file:
-                    csv_reader = csv.reader(file)
-                    return " ".join([" ".join(row) for row in csv_reader])
-                    
-        except Exception as e:
-            st.error(f"Error extracting text from {file_path}: {str(e)}")
-            return ""
-    
-    def get_embedding(self, text):
-        """Generate embedding for text using BGE model"""
-        if self.embedding_model is None:
-            st.error("No embedding model loaded!")
-            return np.zeros(1024)  # BGE-large dimension
-            
-        try:
-            # BGE models recommend adding instruction for retrieval
-            # For queries (job description)
-            if len(text) < 500:  # Assuming shorter texts are queries
-                text = "Represent this sentence for searching relevant passages: " + text
-            
-            # Truncate text to avoid memory issues
-            text = text[:8192] if text else ""
-            
-            # Generate embedding
-            embedding = self.embedding_model.encode(text, 
-                                                  convert_to_numpy=True,
-                                                  normalize_embeddings=True)
-            return embedding
-                    
-        except Exception as e:
-            st.error(f"Error generating embedding: {str(e)}")
-            return np.zeros(1024)  # BGE-large dimension
-    
-    def calculate_bm25_scores(self, resume_texts, job_description):
-        """Calculate BM25 scores for keyword matching"""
-        try:
-            job_tokens = word_tokenize(job_description.lower())
-            corpus = [word_tokenize(text.lower()) for text in resume_texts if text and text.strip()]
-            
-            if not corpus:
-                return [0.0] * len(resume_texts)
-                
-            bm25 = BM25Okapi(corpus)
-            scores = bm25.get_scores(job_tokens)
-            return scores.tolist()
-            
-        except Exception as e:
-            st.error(f"Error calculating BM25 scores: {str(e)}")
-            return [0.0] * len(resume_texts)
-    
-    def advanced_pipeline_ranking(self, resume_texts, job_description):
-        """Advanced pipeline: FAISS recall -> Cross-encoder -> BM25 -> LLM intent -> Final ranking"""
-        print("[Pipeline] Advanced Pipeline Ranking started.")
-        if not resume_texts:
-            return []
-        st.info("🔍 Stage 1: FAISS Recall - Finding top candidates...")
-        print("[Pipeline] Calling faiss_recall.")
-        top_50_indices = self.faiss_recall(resume_texts, job_description, top_k=50)
-        print(f"[Pipeline] faiss_recall returned {len(top_50_indices)} indices.")
-
-        st.info("🎯 Stage 2: Cross-Encoder Re-ranking - Selecting top candidates...")
-        print("[Pipeline] Calling cross_encoder_rerank.")
-        top_20_results = self.cross_encoder_rerank(resume_texts, job_description, top_50_indices, top_k=20)
-        print(f"[Pipeline] cross_encoder_rerank returned {len(top_20_results)} results.")
-
-        st.info("🔤 Stage 3: BM25 Keyword Matching...")
-        print("[Pipeline] Calling add_bm25_scores.")
-        top_20_with_bm25 = self.add_bm25_scores(resume_texts, job_description, top_20_results)
-        print(f"[Pipeline] add_bm25_scores processed.")
-
-        st.info("🤖 Stage 4: LLM Intent Analysis (Qwen3-1.7B)...")
-        print("[Pipeline] Calling add_intent_scores.")
-        top_20_with_intent = self.add_intent_scores(resume_texts, job_description, top_20_with_bm25)
-        print(f"[Pipeline] add_intent_scores processed.")
-
-        st.info("🏆 Stage 5: Final Combined Ranking...")
-        print("[Pipeline] Calling calculate_final_scores.")
-        final_results = self.calculate_final_scores(top_20_with_intent)
-        print(f"[Pipeline] calculate_final_scores returned {len(final_results)} results.")
-        print("[Pipeline] Advanced Pipeline Ranking finished.")
-        return final_results[:5]  # Return top 5
-    
-    def faiss_recall(self, resume_texts, job_description, top_k=50):
-        """Stage 1: Use FAISS for initial recall to find top 50 resumes"""
-        print("[faiss_recall] Method started.")
-        st.text("FAISS Recall: Embedding job description...")
-        job_embedding = self.get_embedding(job_description)
-        print("[faiss_recall] Job description embedded.")
-        st.text(f"FAISS Recall: Embedding {len(resume_texts)} resumes...")
-        resume_embeddings = []
-        progress_bar = st.progress(0)
-        
-        for i, text in enumerate(resume_texts):
-            if text:
-                embedding = self.embedding_model.encode(text[:8192], 
-                                                      convert_to_numpy=True,
-                                                      normalize_embeddings=True)
-                resume_embeddings.append(embedding)
-            else:
-                resume_embeddings.append(np.zeros(1024))
-            progress_bar.progress((i + 1) / len(resume_texts))
-            if i % 10 == 0: # Print progress every 10 resumes
-                print(f"[faiss_recall] Embedded resume {i+1}/{len(resume_texts)}")
-        
-        progress_bar.empty()
-        print("[faiss_recall] All resumes embedded.")
-        st.text("FAISS Recall: Building FAISS index...")
-        resume_embeddings = np.array(resume_embeddings).astype('float32')
-        dimension = resume_embeddings.shape[1]
-        index = faiss.IndexFlatIP(dimension)  # Inner product for cosine similarity
-        index.add(resume_embeddings)
-        print("[faiss_recall] FAISS index built.")
-        st.text("FAISS Recall: Searching index...")
-        job_embedding = job_embedding.reshape(1, -1).astype('float32')
-        scores, indices = index.search(job_embedding, min(top_k, len(resume_texts)))
-        print("[faiss_recall] FAISS search complete.")
-        return indices[0].tolist()
-    
-    def cross_encoder_rerank(self, resume_texts, job_description, top_50_indices, top_k=20):
-        """Stage 2: Use Cross-Encoder to re-rank top 50 and select top 20"""
-        print("[cross_encoder_rerank] Method started.")
-        try:
-            if not self.cross_encoder:
-                st.error("Cross-encoder not loaded!")
-                return [(idx, 0.0) for idx in top_50_indices[:top_k]]
-            
-            # Prepare pairs for cross-encoder
-            pairs = []
-            valid_indices = []
-            
-            for idx in top_50_indices:
-                if idx < len(resume_texts) and resume_texts[idx]:
-                    # Truncate texts for cross-encoder
-                    job_snippet = job_description[:512]
-                    resume_snippet = resume_texts[idx][:512]
-                    pairs.append([job_snippet, resume_snippet])
-                    valid_indices.append(idx)
-            
-            if not pairs:
-                return [(idx, 0.0) for idx in top_50_indices[:top_k]]
-            
-            st.text(f"Cross-Encoder: Preparing {len(pairs)} pairs for re-ranking...")
-            print(f"[cross_encoder_rerank] Prepared {len(pairs)} pairs.")
-            # Get cross-encoder scores
-            progress_bar = st.progress(0)
-            scores = []
-            
-            # Process in batches to avoid memory issues
-            batch_size = 8
-            for i in range(0, len(pairs), batch_size):
-                batch = pairs[i:i+batch_size]
-                batch_scores = self.cross_encoder.predict(batch)
-                scores.extend(batch_scores)
-                progress_bar.progress(min(1.0, (i + batch_size) / len(pairs)))
-                print(f"[cross_encoder_rerank] Processed batch {i//batch_size + 1}")
-            
-            progress_bar.empty()
-            print("[cross_encoder_rerank] All pairs scored.")
-            st.text("Cross-Encoder: Re-ranking complete.")
-            
-            # Combine indices with scores and sort
-            indexed_scores = list(zip(valid_indices, scores))
-            indexed_scores.sort(key=lambda x: x[1], reverse=True)
-            
-            return indexed_scores[:top_k]
-            
-        except Exception as e:
-            st.error(f"Error in cross-encoder re-ranking: {str(e)}")
-            return [(idx, 0.0) for idx in top_50_indices[:top_k]]
-    
-    def add_bm25_scores(self, resume_texts, job_description, top_20_results):
-        """Stage 3: Add BM25 scores to top 20 resumes"""
-        print("[add_bm25_scores] Method started.")
-        st.text("BM25: Calculating keyword scores...")
-        try:
-            # Get texts for top 20
-            top_20_texts = [resume_texts[idx] for idx, _ in top_20_results]
-            
-            # Calculate BM25 scores
-            bm25_scores = self.calculate_bm25_scores(top_20_texts, job_description)
-            
-            # Normalize BM25 scores to 0.1-0.2 range
-            if bm25_scores and max(bm25_scores) > 0:
-                max_bm25 = max(bm25_scores)
-                min_bm25 = min(bm25_scores)
-                if max_bm25 > min_bm25:
-                    normalized_bm25 = [
-                        0.1 + 0.1 * (score - min_bm25) / (max_bm25 - min_bm25) 
-                        for score in bm25_scores
-                    ]
-                else:
-                    normalized_bm25 = [0.15] * len(bm25_scores)
-            else:
-                normalized_bm25 = [0.15] * len(top_20_results)
-            
-            # Combine with existing results
-            results_with_bm25 = []
-            for i, (idx, cross_score) in enumerate(top_20_results):
-                bm25_score = normalized_bm25[i] if i < len(normalized_bm25) else 0.15
-                results_with_bm25.append((idx, cross_score, bm25_score))
-            
-            print("[add_bm25_scores] BM25 scores calculated and normalized.")
-            st.text("BM25: Keyword scores added.")
-            return results_with_bm25
-            
-        except Exception as e:
-            st.error(f"Error adding BM25 scores: {str(e)}")
-            return [(idx, cross_score, 0.15) for idx, cross_score in top_20_results]
-    
-    def add_intent_scores(self, resume_texts, job_description, top_20_with_bm25):
-        """Stage 4: Add LLM intent analysis scores"""
-        print("[add_intent_scores] Method started.")
-        st.text(f"LLM Intent: Analyzing intent for {len(top_20_with_bm25)} candidates (Qwen3-1.7B)...")
-        results_with_intent = []
-        progress_bar = st.progress(0)
-        
-        for i, (idx, cross_score, bm25_score) in enumerate(top_20_with_bm25):
-            intent_score = self.analyze_intent(resume_texts[idx], job_description)
-            results_with_intent.append((idx, cross_score, bm25_score, intent_score))
-            progress_bar.progress((i + 1) / len(top_20_with_bm25))
-            print(f"[add_intent_scores] Intent analyzed for candidate {i+1}")
-        
-        progress_bar.empty()
-        print("[add_intent_scores] All intents analyzed.")
-        st.text("LLM Intent: Analysis complete.")
-        return results_with_intent
-    
-    def analyze_intent(self, resume_text, job_description):
-        """Analyze candidate's intent using Qwen3-1.7B LLM with thinking enabled."""
-        print(f"[analyze_intent] Analyzing intent for one resume (Qwen3-1.7B)...")
-        st.text("LLM Intent: Analyzing intent (Qwen3-1.7B)...")
-        try:
-            resume_snippet = resume_text[:15000]
-            job_snippet = job_description[:5000]
-            
-            prompt = f"""You are given a job description and a candidate's resume.\nAnalyze the candidate's resume in detail against the job description to determine if they are genuinely seeking this specific job, or if their profile is a more general fit or perhaps a mismatch.\nProvide a step-by-step thought process for your decision.\nFinally, clearly answer: \"Is the candidate likely seeking THIS SPECIFIC job? Respond with 'Yes', 'Maybe', or 'No' and give a brief justification based on your thought process.\"\n\nJob Description:\n{job_snippet}\n\nCandidate Resume:\n{resume_snippet}\n\nResponse format:\n<think>\n[Your detailed step-by-step thought process comparing resume to JD, noting specific alignments or mismatches that indicate intent. Be thorough.]\n</think>\nIntent: [Yes/Maybe/No]\nReason: [Brief justification based on your thought process]"""
-            
-            response_text = generate_qwen3_response(
-                prompt,
-                st.session_state.qwen3_1_7b_tokenizer,
-                st.session_state.qwen3_1_7b_model,
-                max_new_tokens=20000
-            )
-            print(f"[analyze_intent] Qwen3-1.7B full response (first 100 chars): {response_text[:100]}...")
-
-            thinking_content = "No detailed thought process extracted."
-            intent_decision_part = response_text
-
-            think_start_tag = "<think>"
-            think_end_tag = "</think>"
-            
-            start_index = response_text.find(think_start_tag)
-            end_index = response_text.rfind(think_end_tag)
-
-            if start_index != -1 and end_index != -1 and start_index < end_index:
-                thinking_content = response_text[start_index + len(think_start_tag):end_index].strip()
-                intent_decision_part = response_text[end_index + len(think_end_tag):].strip()
-                print(f"[analyze_intent] Thinking content extracted (first 50 chars): {thinking_content[:50]}...")
-            else:
-                print("[analyze_intent] <think> block not found or malformed in response.")
-
-            response_lower = intent_decision_part.lower()
-            intent_score = 0.1
-            if 'intent: yes' in response_lower or 'intent:yes' in response_lower:
-                intent_score = 0.3
-            elif 'intent: no' in response_lower or 'intent:no' in response_lower:
-                intent_score = 0.0
-            
-            print(f"[analyze_intent] Parsed Intent: {intent_score}, Decision part: {intent_decision_part[:100]}...")
-            return intent_score
-
-        except Exception as e:
-            st.warning(f"Error analyzing intent with Qwen3-1.7B: {str(e)}")
-            print(f"[analyze_intent] EXCEPTION: {str(e)}")
-            return 0.1
-    
-    def calculate_final_scores(self, results_with_all_scores):
-        """Stage 5: Calculate final combined scores"""
-        print("[calculate_final_scores] Method started.")
-        st.text("Final Ranking: Calculating combined scores...")
-        try:
-            final_results = []
-            
-            for idx, cross_score, bm25_score, intent_score in results_with_all_scores:
-                # Normalize cross-encoder score to 0-1 range
-                normalized_cross = max(0, min(1, cross_score))
-                
-                # Final Score = Cross-Encoder (0-1) + BM25 (0.1-0.2) + Intent (0-0.3)
-                final_score = normalized_cross + bm25_score + intent_score
-                
-                final_results.append({
-                    'index': idx,
-                    'cross_encoder_score': normalized_cross,
-                    'bm25_score': bm25_score,
-                    'intent_score': intent_score,
-                    'final_score': final_score
-                })
-            
-            # Sort by final score
-            final_results.sort(key=lambda x: x['final_score'], reverse=True)
-            
-            print("[calculate_final_scores] Final scores calculated and sorted.")
-            st.text("Final Ranking: Complete.")
-            return final_results
-            
-        except Exception as e:
-            st.error(f"Error calculating final scores: {str(e)}")
-            return []
-    
-    def extract_skills(self, text, job_description):
-        """Extract skills from resume based on job description"""
-        if not text:
-            return []
-            
-        # Common tech skills
-        common_skills = [
-            "python", "java", "javascript", "react", "angular", "vue", "node.js", 
-            "express", "django", "flask", "spring", "sql", "nosql", "html", "css",
-            "aws", "azure", "gcp", "docker", "kubernetes", "jenkins", "git", "github",
-            "agile", "scrum", "jira", "ci/cd", "devops", "microservices", "rest", "api",
-            "machine learning", "deep learning", "data science", "artificial intelligence", 
-            "tensorflow", "pytorch", "keras", "scikit-learn", "pandas", "numpy", 
-            "matplotlib", "seaborn", "jupyter", "r", "sas", "spss", "tableau", "powerbi",
-            "excel", "mysql", "postgresql", "mongodb", "redis", "elasticsearch", 
-            "kafka", "rabbitmq", "spark", "hadoop", "hive", "airflow", "linux", "unix"
-        ]
-        
-        # Extract potential skills from job description
-        job_words = set(word.lower() for word in word_tokenize(job_description) if len(word) > 2)
-        
-        # Find matching skills
-        found_skills = []
-        text_lower = text.lower()
-        
-        # Check common skills that appear in both resume and job description
-        for skill in common_skills:
-            if skill in text_lower and any(skill in job_word for job_word in job_words):
-                found_skills.append(skill)
-        
-        # Check for skills mentioned in job description
-        for word in job_words:
-            if len(word) > 3 and word in text_lower and word not in found_skills:
-                # Basic filter to avoid common words
-                if word not in ['with', 'have', 'that', 'this', 'from', 'what', 'when', 'where']:
-                    found_skills.append(word)
-        
-        return list(set(found_skills))[:15]  # Return top 15 unique skills
-
-def create_download_link(df, filename="resume_screening_results.csv"):
-    """Create download link for results"""
-    csv = df.to_csv(index=False)
-    b64 = base64.b64encode(csv.encode()).decode()
-    return f'<a href="data:file/csv;base64,{b64}" download="{filename}" class="download-btn">📥 Download Results CSV</a>'
-
-# Main App Interface
-st.title("🎯 AI-Powered Resume Screener")
-st.markdown("*Find the perfect candidates using BAAI/bge-large-en-v1.5 embeddings and Qwen3-1.7B for intent analysis*")
+# Display Model Loading Status from Global Init
+st.subheader("🤖 Model Loading Status")
+col1, col2 = st.columns(2)
+with col1:
+    if st.session_state.get('embedding_model_error'):
+        st.error(f"Embedding Model: {st.session_state.embedding_model_error}")
+    elif st.session_state.get('embedding_model'):
+        st.success("✅ Embedding Model (BAAI/bge-large-en-v1.5) loaded.")
+    else:
+        st.warning("⏳ Embedding Model loading or not found (check console).")
+
+    if st.session_state.get('cross_encoder_error'):
+        st.error(f"Cross-Encoder Model: {st.session_state.cross_encoder_error}")
+    elif st.session_state.get('cross_encoder'):
+        st.success("✅ Cross-Encoder Model (ms-marco-MiniLM-L6-v2) loaded.")
+    else:
+        st.warning("⏳ Cross-Encoder Model loading or not found (check console).")
+with col2:
+    if st.session_state.get('qwen3_1_7b_tokenizer_error'):
+        st.error(f"Qwen3-1.7B Tokenizer: {st.session_state.qwen3_1_7b_tokenizer_error}")
+    elif st.session_state.get('qwen3_1_7b_tokenizer'):
+        st.success("✅ Qwen3-1.7B Tokenizer loaded.")
+    else:
+        st.warning("⏳ Qwen3-1.7B Tokenizer loading or not found (check console).")
+
+    if st.session_state.get('qwen3_1_7b_model_error'):
+        st.error(f"Qwen3-1.7B Model: {st.session_state.qwen3_1_7b_model_error}")
+    elif st.session_state.get('qwen3_1_7b_model'):
+        st.success("✅ Qwen3-1.7B Model loaded.")
+    else:
+        st.warning("⏳ Qwen3-1.7B Model loading or not found (check console).")
 st.markdown("---")
 
-# Initialize screener
+# Initialize screener (after global model loading attempts)
 screener = ResumeScreener()
 
 # Job Description Input
@@ -725,7 +376,11 @@ col1, col2 = st.columns([1, 1])
 
 with col1:
     if st.button("🚀 Advanced Pipeline Analysis", 
-                 disabled=not (job_description and st.session_state.resume_texts),
+                 disabled=not (job_description and st.session_state.resume_texts and 
+                              st.session_state.get('embedding_model') and
+                              st.session_state.get('cross_encoder') and
+                              st.session_state.get('qwen3_1_7b_model') and
+                              st.session_state.get('qwen3_1_7b_tokenizer')),
                  type="primary",
                  help="Run the complete 5-stage advanced pipeline"):
         print("--- Advanced Pipeline Analysis Button Clicked ---")

requirements.txt

@@ -14,6 +14,5 @@ huggingface-hub==0.30.0
 bitsandbytes==0.44.1
 accelerate==0.27.2
 datasets==2.18.0
-sentence-transformers==2.6.1
-plotly==5.18.0
+sentence-transformers==2.7.0
 einops