Add caching to the GUI

gui/app.py

@@ -8,6 +8,7 @@ import altair as alt
 sys.path.append(os.path.abspath(os.path.join(os.getcwd(), '..')))
 from src.utils.bulk_loading import bulk_load_raw_resume_files
 from src.utils.file_reader import extract_text_from_file
+from src.utils.model_loader import get_applicant_matrix, get_applicant_vectorizer, get_bert_model, get_faiss_index, get_recruiter_vectorizer
 from pipelines.core.applicant import run_tfidf_pipeline as applicant_tfidf, run_bert_pipeline as applicant_bert
 from pipelines.core.recruiter import rank_with_tfidf as recruiter_tfidf, rank_with_bert as recruiter_bert
 
@@ -71,7 +72,7 @@ if app_mode == "Applicant":
 
     if resume_file:
         st.success(f"✅ Successfully uploaded `{resume_file.name}`")
-        if st.button("Find Top Job Matches", type="primary", use_container_width=True):
+        if st.button("Find Top Job Matches", type="primary", width='stretch'):
             
             with st.spinner(f"Analyzing resume with {model_choice}..."):
                 
@@ -84,9 +85,20 @@ if app_mode == "Applicant":
                     raw_resume_text = extract_text_from_file(tmp_file_path)
 
                     if model_choice == "BERT":
-                        matches, message = applicant_bert(raw_resume_text, top_k=top_k)
+                        bert_model = get_bert_model()
+                        faiss_index = get_faiss_index()
+                        matches, message = applicant_bert(raw_resume_text,
+                                                          model=bert_model,
+                                                          job_index=faiss_index,
+                                                          top_k=top_k,)
+                        
                     else:
-                        matches, message = applicant_tfidf(raw_resume_text, top_k=top_k)
+                        applicant_vectorizer = get_applicant_vectorizer()
+                        applicant_matrix = get_applicant_matrix()
+                        matches, message = applicant_tfidf(raw_resume_text,
+                                                           vectorizer=applicant_vectorizer,
+                                                           job_matrix=applicant_matrix,
+                                                           top_k=top_k)
 
                     if not matches:
                         st.warning("⚠️ No suitable job matches found.")
@@ -139,7 +151,7 @@ if app_mode == "Recruiter":
 
     if job_desc_file and resume_files:
         st.success(f"✅ Successfully uploaded job description `{job_desc_file.name}` and {len(resume_files)} resumes.")
-        if st.button("Rank Resumes", type="primary", use_container_width=True):
+        if st.button("Rank Resumes", type="primary", width='stretch'):
             
             with st.spinner(f"Ranking {len(resume_files)} resumes with {model_choice}..."):
                 
@@ -166,9 +178,17 @@ if app_mode == "Recruiter":
 
                     # 3. Call the appropriate model's pipeline based on the model choice (default to TF-IDF)
                     if model_choice == "BERT":
-                        ranked_resumes, message = recruiter_bert(raw_job_text, raw_resume_texts, top_k=top_k)
+                        bert_model = get_bert_model()
+                        ranked_resumes, message = recruiter_bert(raw_job_text,
+                                                                 raw_resume_texts,
+                                                                 model=bert_model,
+                                                                 top_k=top_k)
                     else:
-                        ranked_resumes, message = recruiter_tfidf(raw_job_text, raw_resume_texts, top_k=top_k)
+                        vectorizer = get_recruiter_vectorizer()
+                        ranked_resumes, message = recruiter_tfidf(raw_job_text,
+                                                                  raw_resume_texts,
+                                                                  vectorizer=vectorizer,
+                                                                  top_k=top_k)
 
                     # 4. Display results
                     if not ranked_resumes:
@@ -187,7 +207,7 @@ if app_mode == "Recruiter":
                                                 min_value=0,
                                                 max_value=1,),
                                            },
-                                            use_container_width=True,
+                                            width='stretch',
                                             hide_index=True,
                         )
 

pipelines/core/applicant.py

@@ -13,7 +13,9 @@ def load_job_titles(job_csv_path: str):
         raise ValueError("Job CSV must contain a 'title' column.")
     return df
 
-def run_tfidf_pipeline(raw_resume: str,
+def run_tfidf_pipeline(raw_resume: str, *,
+                       vectorizer=None,
+                       job_matrix=None,
                        local_vectorizer_path=None,
                        local_matrix_path=None,
                        repo_id="Om-Shandilya/resume-matcher-tfidf",
@@ -25,6 +27,8 @@ def run_tfidf_pipeline(raw_resume: str,
     
     Args:
         raw_resume (str): Raw text of the resume.
+        vectorizer (TfidfVectorizer, optional): Preloaded TF-IDF vectorizer.
+        job_matrix (scipy.sparse matrix, optional): Preloaded TF-IDF job matrix
         local_vectorizer_path (str, optional): Local path to TF-IDF vectorizer.
         local_matrix_path (str, optional): Local path to TF-IDF matrix.
         repo_id (str): Hugging Face repo ID for vectorizer/matrix.
@@ -38,8 +42,11 @@ def run_tfidf_pipeline(raw_resume: str,
     """
     cleaned_resume = clean_text(raw_resume)
 
-    vectorizer = load_tfidf_vectorizer(local_vectorizer_path, repo_id, vectorizer_filename)
-    job_matrix = load_tfidf_matrix(local_matrix_path, repo_id, matrix_filename)
+    if vectorizer is None:
+        vectorizer = load_tfidf_vectorizer(local_vectorizer_path, repo_id, vectorizer_filename)
+    
+    if job_matrix is None:
+        job_matrix = load_tfidf_matrix(local_matrix_path, repo_id, matrix_filename)
 
     resume_vector = vectorizer.transform([cleaned_resume])
     sim_matrix = compute_similarity_matrix(resume_vector, job_matrix)
@@ -68,10 +75,12 @@ def run_tfidf_pipeline(raw_resume: str,
             print(f"[{job_idx}] {job_df.iloc[job_idx]['title']} → {score:0.6f}")
         print("==============================================")
 
-    return [(job_df.iloc[j]['title'], score) for j, score in matches[0]],message
+    return [(job_df.iloc[j]['title'], score) for j, score in matches[0]], message
 
 
-def run_bert_pipeline(raw_resume: str,
+def run_bert_pipeline(raw_resume: str, *,
+                      model=None,
+                      job_index=None,
                       local_bert_path=None,
                       local_index_path=None,
                       repo_id="Om-Shandilya/resume-matcher-bert",
@@ -82,6 +91,8 @@ def run_bert_pipeline(raw_resume: str,
     
     Args:
         raw_resume (str): Raw text of the resume.
+        model (SentenceTransformer, optional): Preloaded BERT model.
+        job_index (faiss.Index, optional): Preloaded FAISS index.
         local_bert_path (str, optional): Local path to BERT model. 
         local_index_path (str, optional): Local path to FAISS index.
         repo_id (str): Hugging Face repo ID for model/index.
@@ -92,8 +103,11 @@ def run_bert_pipeline(raw_resume: str,
     Returns:
         List[Tuple[str, float]]: List of (job_title, score) for top_k matches.
     """
-    model = load_bert_model(local_bert_path=local_bert_path, repo_id=repo_id)
-    job_index = load_faiss_index(local_index_path, repo_id, index_filename)
+    if model is None:
+        model = load_bert_model(local_bert_path=local_bert_path, repo_id=repo_id)
+    
+    if job_index is None:
+        job_index = load_faiss_index(local_index_path, repo_id, index_filename)
 
     cleaned_resume = clean_text_for_bert(raw_resume)
     resume_embedding = model.encode([cleaned_resume], normalize_embeddings=True)

pipelines/core/recruiter.py

@@ -6,17 +6,32 @@ from src.processing.text_cleaning import clean_text, clean_text_for_bert
 
 
 def rank_with_tfidf(raw_job_text, raw_resume_texts, *,
+                    vectorizer=None,
                     local_vectorizer_path=None,
                     repo_id="Om-Shandilya/resume-matcher-tfidf",
                     filename="recruiter/combined_vectorizer.pkl",
                     top_k=None,
                     debug=False):
-    """Rank resumes using TF-IDF similarity."""
-    vectorizer = load_tfidf_vectorizer(
-        local_vectorizer_path=local_vectorizer_path,
-        repo_id=repo_id,
-        filename=filename
-    )
+    """Rank resumes using TF-IDF similarity.
+    
+    Args:
+        raw_job_text (str): Raw text of the job description.
+        raw_resume_texts (dict): Dictionary of resume filenames and their raw texts.
+        vectorizer (TfidfVectorizer, optional): Preloaded TF-IDF vectorizer.
+        local_vectorizer_path (str, optional): Local path to TF-IDF vectorizer.
+        repo_id (str): Hugging Face repo ID for vectorizer.
+        filename (str): Filename of the vectorizer in the repo.
+        top_k (int, optional): Number of top matches to return. If None, return all.
+        debug (bool, optional): Print raw similarity scores for both and cleaned resume.
+    
+    Returns:
+        List[Tuple[str, float]]: List of (resume_filename, score) for top_k matches. and message.
+    """
+
+    if vectorizer is None:
+        vectorizer = load_tfidf_vectorizer(local_vectorizer_path=local_vectorizer_path,
+                                       repo_id=repo_id,
+                                       filename=filename)
 
     cleaned_job_text = clean_text(raw_job_text)
     job_vector = vectorizer.transform([cleaned_job_text])
@@ -56,12 +71,28 @@ def rank_with_tfidf(raw_job_text, raw_resume_texts, *,
 
 
 def rank_with_bert(raw_job_text, raw_resume_texts, *,
+                   model=None,
                    local_bert_path=None,
                    repo_id="Om-Shandilya/resume-matcher-bert",
                    top_k=None,
                    debug=False):
-    """Rank resumes using BERT embeddings."""
-    model = load_bert_model(local_bert_path=local_bert_path, repo_id=repo_id)
+    """Rank resumes using BERT embeddings.
+    
+    Args:
+        raw_job_text (str): Raw text of the job description.
+        raw_resume_texts (dict): Dictionary of resume filenames and their raw text.
+        model (SentenceTransformer, optional): Preloaded BERT model.
+        local_bert_path (str, optional): Local path to BERT model.
+        repo_id (str): Hugging Face repo ID for model.
+        top_k (int, optional): Maximum number of matches to show. If None, show all.
+        debug (bool, optional): Print raw similarity scores.
+
+    Returns:
+        List[Tuple[str, float]]: List of (resume_filename, score) for top_k matches. and message.
+    """
+
+    if model is None:
+        model = load_bert_model(local_bert_path=local_bert_path, repo_id=repo_id)
 
     cleaned_job_text = clean_text_for_bert(raw_job_text)
     job_embedding = model.encode([cleaned_job_text], normalize_embeddings=True)

src/feature_engg/bert_embedding_data.py

@@ -7,11 +7,10 @@ import torch
 from faiss import read_index
 from typing import Optional
 from sentence_transformers import SentenceTransformer, models
-from transformers import AutoTokenizer, AutoModel
 from huggingface_hub import hf_hub_download
 
 
-def get_bert_model(model_name: str,
+def create_bert_model(model_name: str,
                    device: str = None):
     """
     Loads a BERT-based sentence transformer model for embeddings.
@@ -84,7 +83,7 @@ def bert_embed_text(df: pd.DataFrame,
         df[text_column] = df[text_column].fillna("")
 
     if model is None:
-        model = get_bert_model()
+        model = create_bert_model()
 
     embeddings = model.encode(
         df[text_column].tolist(),

src/utils/model_loader.py

@@ -0,0 +1,44 @@
+import streamlit as st
+from src.feature_engg.bert_embedding_data import load_bert_model
+from src.feature_engg.tfidf_vectorizing_data import load_tfidf_vectorizer, load_tfidf_matrix
+from src.feature_engg.bert_embedding_data import load_faiss_index
+
+# Usinf streamlit's caching mechanism to load models and artifacts only once
+@st.cache_resource
+def get_bert_model():
+    """Loads and caches the BERT model."""
+
+    return load_bert_model(local_bert_path=None,
+                           repo_id="Om-Shandilya/resume-matcher-bert")
+
+@st.cache_resource
+def get_faiss_index():
+    """Loads and caches the FAISS index for the applicant view."""
+
+    return load_faiss_index(local_index_path=None,
+                            repo_id="Om-Shandilya/resume-matcher-bert", 
+                            filename="applicant/jobs.faiss")
+
+@st.cache_resource
+def get_applicant_vectorizer():
+    """Loads and caches the TF-IDF vectorizer for the applicant view."""
+    
+    return load_tfidf_vectorizer(local_vectorizer_path=None,
+                                 repo_id="Om-Shandilya/resume-matcher-tfidf", 
+                                 filename="applicant/job_vectorizer.pkl")
+@st.cache_resource
+def get_applicant_matrix():
+    """Loads and caches the TF-IDF matrix for the applicant view."""
+
+    return load_tfidf_matrix(local_matrix_path=None,
+                             repo_id="Om-Shandilya/resume-matcher-tfidf", 
+                             filename="applicant/job_matrix.npz")
+    
+
+@st.cache_resource
+def get_recruiter_vectorizer():
+    """Loads and caches the TF-IDF vectorizer for the recruiter view."""
+
+    return load_tfidf_vectorizer(local_vectorizer_path=None,
+                                 repo_id="Om-Shandilya/resume-matcher-tfidf", 
+                                 filename="recruiter/combined_vectorizer.pkl")