ss

app.py

@@ -110,41 +110,330 @@ if st.session_state.qwen3_1_7b_tokenizer is None and st.session_state.qwen3_1_7b
 
 # 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...")
+    print("[Global Init] Loading Qwen3-1.7B Model (attempting with device_map='auto')...")
     try:
         st.session_state.qwen3_1_7b_model = AutoModelForCausalLM.from_pretrained(
-            "Qwen/Qwen3-1.7B", torch_dtype="auto", device_map="auto"
+            "Qwen/Qwen3-1.7B", 
+            torch_dtype="auto", 
+            device_map="auto",
+            trust_remote_code=True # if required by this specific model
         )
-        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
+        print("[Global Init] Qwen3-1.7B Model Loaded with device_map='auto'.")
+    except Exception as e_dev_map:
+        print(f"⚠️ [Global Init] Failed to load Qwen3-1.7B with device_map='auto': {str(e_dev_map)}")
+        print("[Global Init] Retrying Qwen3-1.7B load without device_map (will use default single device)...")
+        try:
+            st.session_state.qwen3_1_7b_model = AutoModelForCausalLM.from_pretrained(
+                "Qwen/Qwen3-1.7B", 
+                torch_dtype="auto", 
+                # No device_map here, let Hugging Face decide or use CUDA if available
+                trust_remote_code=True # if required
+            )
+            print("[Global Init] Qwen3-1.7B Model Loaded (fallback device handling).")
+        except Exception as e_fallback:
+            error_msg = f"Failed to load Qwen3-1.7B Model (fallback): {str(e_fallback)}"
+            print(f"❌ [Global Init] {error_msg}")
+            st.session_state.qwen3_1_7b_model_error = error_msg
 
 # --- End of Global Model Loading Section ---
 
-# Sidebar configuration
+# --- Class Definitions and Helper Functions ---
+
+def generate_qwen3_response(prompt, tokenizer, model, max_new_tokens=200):
+    # ... (implementation of generate_qwen3_response)
+    messages = [{"role": "user", "content": prompt}]
+    text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=True # As per Qwen3-1.7B docs for thinking mode
+    )
+    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: # Ensure this class definition is BEFORE it's instantiated
+    def __init__(self):
+        # ... (init logic as before, referencing st.session_state for models)
+        print("[ResumeScreener] Initializing with references to globally loaded models...")
+        self.embedding_model = st.session_state.get('embedding_model')
+        self.cross_encoder = st.session_state.get('cross_encoder')
+
+        if self.embedding_model:
+            print("[ResumeScreener] Embedding model reference set.")
+        else:
+            print("[ResumeScreener] Embedding model not available (check loading errors).")
+
+        if self.cross_encoder:
+            print("[ResumeScreener] Cross-encoder model reference set.")
+        else:
+            print("[ResumeScreener] Cross-encoder model not available (check loading errors).")
+        
+        print("[ResumeScreener] Initialization complete.")
+
+    # ... (all other methods of ResumeScreener: extract_text_from_file, get_embedding, 
+    #      calculate_bm25_scores, advanced_pipeline_ranking, faiss_recall, cross_encoder_rerank, 
+    #      add_bm25_scores, add_intent_scores, analyze_intent, calculate_final_scores, extract_skills)
+    # Make sure all methods are correctly indented within the class
+
+    def extract_text_from_file(self, file_path, file_type):
+        # ... (implementation)
+        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():
+                            file.seek(0)
+                            reader = PyPDF2.PdfReader(file)
+                            text = ""
+                            for page_num in range(len(reader.pages)):
+                                text += reader.pages[page_num].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):
+        if self.embedding_model is None:
+            st.error("Embedding model is not available!")
+            return np.zeros(1024)
+        try:
+            if len(text) < 500:
+                text = "Represent this sentence for searching relevant passages: " + text
+            text = text[:8192] if text else ""
+            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)
+
+    def calculate_bm25_scores(self, resume_texts, job_description):
+        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):
+        print("[Pipeline] Advanced Pipeline Ranking started.")
+        if not resume_texts:
+            return []
+        st.info("🔍 Stage 1: FAISS Recall - Finding top candidates...")
+        top_50_indices = self.faiss_recall(resume_texts, job_description, top_k=50)
+        st.info("🎯 Stage 2: Cross-Encoder Re-ranking - Selecting top candidates...")
+        top_20_results = self.cross_encoder_rerank(resume_texts, job_description, top_50_indices, top_k=20)
+        st.info("🔤 Stage 3: BM25 Keyword Matching...")
+        top_20_with_bm25 = self.add_bm25_scores(resume_texts, job_description, top_20_results)
+        st.info("🤖 Stage 4: LLM Intent Analysis (Qwen3-1.7B)...")
+        top_20_with_intent = self.add_intent_scores(resume_texts, job_description, top_20_with_bm25)
+        st.info("🏆 Stage 5: Final Combined Ranking...")
+        final_results = self.calculate_final_scores(top_20_with_intent)
+        print("[Pipeline] Advanced Pipeline Ranking finished.")
+        return final_results[:st.session_state.get('top_k', 5)]
+
+    def faiss_recall(self, resume_texts, job_description, top_k=50):
+        print("[faiss_recall] Method started.")
+        st.text("FAISS Recall: Embedding job description...")
+        job_embedding = self.get_embedding(job_description)
+        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))
+        progress_bar.empty()
+        resume_embeddings_np = np.array(resume_embeddings).astype('float32') # Renamed variable
+        if resume_embeddings_np.ndim == 1: # Handle case of single resume
+             resume_embeddings_np = resume_embeddings_np.reshape(1, -1)
+        if resume_embeddings_np.size == 0:
+            print("[faiss_recall] No resume embeddings to add to FAISS index.")
+            return [] # Or handle error appropriately
+
+        dimension = resume_embeddings_np.shape[1]
+        index = faiss.IndexFlatIP(dimension)
+        index.add(resume_embeddings_np)
+        job_embedding_np = job_embedding.reshape(1, -1).astype('float32') # Renamed variable
+        scores, indices = index.search(job_embedding_np, min(top_k, len(resume_texts)))
+        return indices[0].tolist()
+
+    def cross_encoder_rerank(self, resume_texts, job_description, top_50_indices, top_k=20):
+        print("[cross_encoder_rerank] Method started.")
+        if not self.cross_encoder:
+            st.error("Cross-encoder model is not available!")
+            return [(idx, 0.0) for idx in top_50_indices[:top_k]]
+        pairs = []
+        valid_indices = []
+        for idx in top_50_indices:
+            if idx < len(resume_texts) and resume_texts[idx]:
+                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...")
+        scores = []
+        batch_size = 8
+        progress_bar = st.progress(0)
+        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)))
+        progress_bar.empty()
+        indexed_scores = list(zip(valid_indices, scores))
+        indexed_scores.sort(key=lambda x: x[1], reverse=True)
+        return indexed_scores[:top_k]
+
+    def add_bm25_scores(self, resume_texts, job_description, top_20_results):
+        st.text("BM25: Calculating keyword scores...")
+        top_20_texts = [resume_texts[idx] for idx, _ in top_20_results]
+        bm25_scores_raw = self.calculate_bm25_scores(top_20_texts, job_description)
+        if bm25_scores_raw and max(bm25_scores_raw) > 0:
+            max_bm25, min_bm25 = max(bm25_scores_raw), min(bm25_scores_raw)
+            if max_bm25 > min_bm25:
+                normalized_bm25 = [0.1 + 0.1 * (s - min_bm25) / (max_bm25 - min_bm25) for s in bm25_scores_raw]
+            else:
+                normalized_bm25 = [0.15] * len(bm25_scores_raw)
+        else:
+            normalized_bm25 = [0.15] * len(top_20_results)
+        results_with_bm25 = []
+        for i, (idx, cross_score) in enumerate(top_20_results):
+            results_with_bm25.append((idx, cross_score, normalized_bm25[i] if i < len(normalized_bm25) else 0.15))
+        return results_with_bm25
+
+    def add_intent_scores(self, resume_texts, job_description, top_20_with_bm25):
+        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))
+        progress_bar.empty()
+        return results_with_intent
+
+    def analyze_intent(self, resume_text, job_description):
+        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... (rest of prompt)\"\"\" # Ensure f-string is correct
+            # ... (rest of analyze_intent, using st.session_state.qwen3_1_7b_tokenizer and _model)
+            response_text = generate_qwen3_response(
+                prompt,
+                st.session_state.qwen3_1_7b_tokenizer,
+                st.session_state.qwen3_1_7b_model,
+                max_new_tokens=20000
+            )
+            # ... (parsing logic for response_text) ...
+            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()
+            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
+            return intent_score
+        except Exception as e:
+            st.warning(f"Error analyzing intent with Qwen3-1.7B: {str(e)}")
+            return 0.1
+
+    def calculate_final_scores(self, results_with_all_scores):
+        final_results = []
+        for idx, cross_score, bm25_score, intent_score in results_with_all_scores:
+            normalized_cross = max(0, min(1, cross_score))
+            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
+            })
+        final_results.sort(key=lambda x: x['final_score'], reverse=True)
+        return final_results
+
+    def extract_skills(self, text, job_description):
+        # ... (implementation)
+        if not text: return []
+        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"]
+        job_words = set(word.lower() for word in word_tokenize(job_description) if len(word) > 2)
+        found_skills = []
+        text_lower = text.lower()
+        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)
+        for word in job_words:
+            if len(word) > 3 and word in text_lower and word not in found_skills and word not in ['with', 'have', 'that', 'this', 'from', 'what', 'when', 'where']:
+                found_skills.append(word)
+        return list(set(found_skills))[:15]
+
+def create_download_link(df, filename="resume_screening_results.csv"):
+    # ... (implementation)
+    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>'
+
+# --- Sidebar Configuration (Must be after global model loading and class defs if it uses them) ---
 with st.sidebar:
     st.title("⚙️ Configuration")
-    
     # Advanced options
     st.subheader("Advanced Options")
-    top_k = st.selectbox("Number of results to display", [1,2,3,4,5], index=4)
+    # Ensure top_k is in session_state if it's used by advanced_pipeline_ranking before button press
+    if 'top_k' not in st.session_state:
+        st.session_state.top_k = 5 # Default value
+    st.session_state.top_k = st.selectbox("Number of results to display", [1,2,3,4,5], index=st.session_state.top_k-1, key="top_k_selector")
     
     # LLM Settings
     st.subheader("LLM Settings")
-    use_llm_explanations = st.checkbox("Generate AI Explanations", value=True)
-    if use_llm_explanations:
-        hf_token = st.text_input("Hugging Face Token (optional)", type="password", 
-                                help="Enter your HF token for better rate limits")
+    # use_llm_explanations = st.checkbox("Generate AI Explanations", value=True) # This was removed earlier
+    # if use_llm_explanations:
+    #     hf_token = st.text_input("Hugging Face Token (optional)", type="password", 
+    #                             help="Enter your HF token for better rate limits")
     
     st.markdown("---")
     st.markdown("### 🤖 Advanced Pipeline")
     st.markdown("- **Stage 1**: FAISS Recall (Top 50)")
     st.markdown("- **Stage 2**: Cross-Encoder Re-ranking (Top 20)")
     st.markdown("- **Stage 3**: BM25 Keyword Matching")
-    st.markdown("- **Stage 4**: LLM Intent Analysis")
-    st.markdown("- **Final**: Combined Scoring (Top 5)")
+    st.markdown("- **Stage 4**: LLM Intent Analysis (Qwen3-1.7B)")
+    st.markdown("- **Final**: Combined Scoring") # Updated this line
     st.markdown("### 📊 Models Used")
     st.markdown("- **Embedding**: BAAI/bge-large-en-v1.5")
     st.markdown("- **Cross-Encoder**: ms-marco-MiniLM-L6-v2")
@@ -152,7 +441,12 @@ with st.sidebar:
     st.markdown("### 📈 Scoring Formula")
     st.markdown("**Final Score = Cross-Encoder (0-1) + BM25 (0.1-0.2) + Intent (0-0.3)**")
 
-# Display Model Loading Status from Global Init
+# --- Main App Interface (Must be after global model loading and class defs) ---
+st.title("🎯 AI-Powered Resume Screener")
+# ... (Model Loading Status display as before)
+# ...
+st.markdown("*Find the perfect candidates using BAAI/bge-large-en-v1.5 embeddings and Qwen3-1.7B for intent analysis*")
+
 st.subheader("🤖 Model Loading Status")
 col1, col2 = st.columns(2)
 with col1:
@@ -162,7 +456,6 @@ with col1:
         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'):
@@ -176,7 +469,6 @@ with col2:
         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'):
@@ -185,7 +477,7 @@ with col2:
         st.warning("⏳ Qwen3-1.7B Model loading or not found (check console).")
 st.markdown("---")
 
-# Initialize screener (after global model loading attempts)
+# Initialize screener (This line was causing NameError, ensure class is defined above)
 screener = ResumeScreener()
 
 # Job Description Input