Add DAPT finetuned BERT functionalities to the app pipeline

.gitignore

@@ -211,8 +211,8 @@ Resume.csv
 job_descriptions.csv
 understanding_data.ipynb
 data/processed/*.csv
+data/processed/*.txt
 data/raw/*/*csv
 data/saved_plots/
-test_vectorization.py
 models/
 tests/

pipelines/app_pipeline.py

@@ -1,9 +1,11 @@
 import argparse
 import os
 import pandas as pd
-from src.feature_engg.vectorizing_data import load_vectorizer, load_vector_data, vectorize_text
+import faiss
+from sentence_transformers import SentenceTransformer
+from src.feature_engg.tfidf_vectorizing_data import load_vectorizer, load_vector_data
 from src.processing.text_cleaning import clean_text
-from src.matching.matching_engine import compute_similarity_matrix, top_n_matches
+from src.matching.matching_engine import compute_similarity_matrix, top_n_tfidf_matches, top_n_bert_matches
 from src.utils.file_reader import extract_text_from_file
 
 
@@ -14,41 +16,86 @@ def load_job_titles(job_csv_path: str):
     return df
 
 
-def main(args):
-    try:
-        # Step 1: Load and clean resume text (supports .pdf, .docx, .txt)
-        if not os.path.exists(args.resume_path):
-            raise FileNotFoundError(f"Resume file not found: {args.resume_path}")
-        raw_resume = extract_text_from_file(args.resume_path)
-        cleaned_resume = clean_text(raw_resume)
+def run_tfidf_pipeline(args, raw_resume: str):
+
+    # Step 2: Clean resume text
+    cleaned_resume = clean_text(raw_resume)
+
+    # Step 3: Load vectorizer and job matrix
+    vectorizer = load_vectorizer(args.vectorizer_path)
+    job_matrix = load_vector_data(args.job_matrix_path)
+
+    # Step 4: Vectorize cleaned resume text
+    resume_vector = vectorizer.transform([cleaned_resume])
+
+    # Step 5: Compute similarity
+    sim_matrix = compute_similarity_matrix(resume_vector, job_matrix)
+
+    # Step 6: Load job titles
+    job_df = load_job_titles(args.job_title_csv)
+
+    # Step 7: Get top-N job matches
+    matches = top_n_tfidf_matches(sim_matrix, top_n=args.top_k, job_df=job_df)
+
+    print(f"\n🎯 Top {args.top_k} Job Matches for the Resume (TF-IDF):")
+    for job_idx, score in matches[0]:
+        print(f"🔹 {job_df.iloc[job_idx]['title']} (score: {score:0.4f})")
+
+    # Optional debug
+    if args.debug:
+        print("\n======= DEBUG MODE =======")
+        print("\n📄 Cleaned Resume Preview:\n", cleaned_resume[:1000])
+        print("\n--- Raw TF-IDF Similarity Scores (Top-K) ---")
+        for job_idx, score in matches[0]:
+            print(f"[{job_idx}] {job_df.iloc[job_idx]['title']} → {score:0.6f}")
+        print("============================")
 
 
-        # Step 2: Load vectorizer and job matrix
-        vectorizer = load_vectorizer(args.vectorizer_path)
-        job_matrix = load_vector_data(args.job_matrix_path)
+def run_bert_pipeline(args, raw_resume: str):
+    # Step 2: Load SentenceTransformer model
+    model = SentenceTransformer(args.bert_model_path)
 
-        # Step 3: Vectorize cleaned resume text
-        resume_vector = vectorizer.transform([cleaned_resume])  # single row sparse matrix
+    # Step 3: Load FAISS job index
+    job_index = faiss.read_index(args.bert_faiss_index)
 
-        # Step 4: Compute similarity
-        sim_matrix = compute_similarity_matrix(resume_vector, job_matrix)
+    # Step 4: Encode resume into embedding
+    resume_embedding = model.encode([raw_resume], normalize_embeddings=True)
 
-        # Step 5: Load job titles for display
-        job_df = load_job_titles(args.job_title_csv)
+    # Step 5: Search deeply in FAISS index in order to eliminate duplicate job titles
+    # Search across all job embeddings in FAISS
+    n_jobs = job_index.ntotal
+    D, I = job_index.search(resume_embedding, n_jobs)
 
-        # Step 6: Get top-N job matches
-        matches = top_n_matches(sim_matrix, top_n=args.top_k, job_df=job_df)
+    # Step 6: Load job titles
+    job_df = load_job_titles(args.job_title_csv)
 
-        print(f"\n🎯 Top {args.top_k} Job Matches for the Resume:")
-        for job_idx, score in matches[0]:  # 0 because it's the only resume
-            print(f"🔹 {job_df.iloc[job_idx]['title']} (score: {score:0.4f})")
+    print(f"\n🎯 Top {args.top_k} Job Matches for the Resume (BERT):")
+    matches = top_n_bert_matches(I, D, job_df, top_n=args.top_k)
 
-        # Optional debug output
-        if args.debug:
-            print("\n===== DEBUG MODE =====")
-            print("\n📄 Cleaned Resume Preview:\n", cleaned_resume[:1000])
-            print("\n📊 Raw Similarity Scores:\n", sim_matrix)
-            print("=======================")
+    for idx, score in matches:
+        print(f"🔹 {job_df.iloc[idx]['title']} (score: {score:0.4f})")
+
+    # Optional debug
+    if args.debug:
+        print("\n======= DEBUG MODE =======")
+        print("\n--- Raw BERT/FAISS Similarity Scores (Top-K) ---")
+        for idx, score in matches:
+            print(f"🔹 {job_df.iloc[idx]['title']} (score: {score})")
+        print("============================")
+
+
+def main(args):
+    try:
+        # Step 1: Load raw resume text
+        if not os.path.exists(args.resume_path):
+            raise FileNotFoundError(f"Resume file not found: {args.resume_path}")
+        raw_resume = extract_text_from_file(args.resume_path)
+
+        # Run chosen pipeline
+        if args.model == "bert":
+            run_bert_pipeline(args, raw_resume)
+        else:
+            run_tfidf_pipeline(args, raw_resume)
 
     except Exception as e:
         print(f"❌ Error: {str(e)}")
@@ -57,11 +104,26 @@ def main(args):
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Match a resume to top relevant job titles")
     parser.add_argument('--resume_path', type=str, required=True, help="Path to resume file")
-    parser.add_argument('--vectorizer_path', type=str, default='models/app_tfidf/job_tfidf_vectorizer.pkl')
-    parser.add_argument('--job_matrix_path', type=str, default='models/app_tfidf/job_tfidf_matrix.npz')
+    parser.add_argument('--model', type=str, choices=['tfidf', 'bert'], default='tfidf',
+                        help="Which model pipeline to use: 'tfidf' or 'bert'")
+
+
+    # TF-IDF arguments
+    parser.add_argument('--vectorizer_path', type=str, default='models/tfidf/app_tfidf/job_tfidf_vectorizer.pkl')
+    parser.add_argument('--job_matrix_path', type=str, default='models/tfidf/app_tfidf/job_tfidf_matrix.npz')
+
+    # BERT arguments
+    parser.add_argument('--bert_model_path', type=str, default='models/bert/dapt_minilm_sentence_transformer',
+                        help="Path to fine-tuned SentenceTransformer model")
+    parser.add_argument('--bert_faiss_index', type=str, default='models/bert/app_bert/jobs_bert_embeddings.faiss',
+                        help="Path to FAISS index of job embeddings")
+
+    # Shared arguments
     parser.add_argument('--job_title_csv', type=str, default='data/app_data/job_titles.csv')
-    parser.add_argument('--top_k', type=int, default=5, help="Number of top job matches to return")
-    parser.add_argument('--debug', action='store_true', help="Print cleaned resume and raw matches")
+    parser.add_argument('--top_k', type=int, default=5,
+                        help="Number of top job matches to return")
+    parser.add_argument('--debug', action='store_true',
+                        help="Print raw similarity scores and cleaned resume for tfidf pipeline")
 
     args = parser.parse_args()
     main(args)

pipelines/recruiter_pipeline.py

@@ -65,7 +65,7 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Recruiter Pipeline: Rank resumes for a given job description")
     parser.add_argument('--job_desc_path', type=str, required=True, help="Path to job description file")
     parser.add_argument('--resume_dir', type=str, required=True, help="Directory containing applicant resumes")
-    parser.add_argument('--vectorizer_path', type=str, default='models/recruiter_tfidf/combined_tfidf_vectorizer.pkl')
+    parser.add_argument('--vectorizer_path', type=str, default='models/tfidf/recruiter_tfidf/combined_tfidf_vectorizer.pkl')
     parser.add_argument('--top_k', type=int, default=10, help="Number of top resumes to return")
     parser.add_argument('--debug', action='store_true', help="Print cleaned job/resume text and raw matches")
 

src/feature_engg/bert_embedding_data.py

@@ -0,0 +1,137 @@
+import os
+import numpy as np
+import pandas as pd
+import torch
+from typing import Optional
+from sentence_transformers import SentenceTransformer, models
+import faiss
+
+
+def get_bert_model(model_name: str = "all-MiniLM-L6-v2",
+                   device: str = None):
+    """
+    Loads a BERT-based sentence transformer model for embeddings.
+
+    Args:
+        model_name (str): HuggingFace model name. Default is "all-MiniLM-L6-v2".
+        device (str, optional): "cuda", "cpu", or None (auto-detect).
+
+    Returns:
+        SentenceTransformer: Loaded model ready for encoding.
+    """
+    device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+    return SentenceTransformer(model_name, device=device)
+
+
+def save_bert_embeddings(embeddings: np.ndarray,
+                         path: str):
+    """
+    Save dense BERT embeddings as a FAISS index file (.faiss).
+    """
+
+    if not path.endswith('.faiss'):
+        path += '.faiss'
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    embedding_dimension = embeddings.shape[1]
+    index = faiss.IndexFlatIP(embedding_dimension)  # Inner Product (cosine if normalized)
+    index.add(embeddings)
+
+    faiss.write_index(index, path)
+    print(f"✅ BERT embeddings saved to FAISS index: [{path}] "
+          f"with {index.ntotal} vectors, dim={embedding_dimension}")
+
+
+def save_bert_model(vectorizer: SentenceTransformer,
+                    path: str):
+    """Save the full SentenceTransformer model to disk."""
+
+    os.makedirs(path, exist_ok=True)
+    vectorizer.save(path)
+    print(f"✅ BERT model saved to: [{path}]")
+
+
+def bert_embed_text(df: pd.DataFrame,
+                   text_column: str,
+                   label: str,
+                   model: Optional[SentenceTransformer] = None,
+                   save_path: Optional[str] = None,
+                   save_model_file: bool = False):
+    """
+    Encodes text from a DataFrame into dense BERT embeddings.
+
+    To save the embeddings and model, ensure 'save_path' is provided along with a valid 'label'.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing the text to be encoded.
+        text_column (str): Column with text to be encoded.
+        label (str): Label prefix for saved files (e.g., 'resumes', 'jobs').
+        model (SentenceTransformer, optional): Preloaded model.
+        save_path (str, optional): Directory to save outputs.
+        save_model_file (bool): If True, also saves the model reference.
+
+    Returns:
+        tuple: (embeddings ndarray, model) 
+    """
+
+    if df[text_column].isnull().any():
+        print(f"\n⚠️ Found missing values in column '{text_column}', replacing with empty string.")
+        df[text_column] = df[text_column].fillna("")
+
+    if model is None:
+        model = get_bert_model()
+
+    embeddings = model.encode(
+        df[text_column].tolist(),
+        convert_to_numpy=True,
+        show_progress_bar=True,
+        normalize_embeddings=True   # normalizing as it is good for cosine similarity.
+    )
+
+    if save_path and label:
+        save_bert_embeddings(embeddings, os.path.join(save_path, f"{label}_bert_embeddings.faiss"))
+        if save_model_file:
+            save_bert_model(model, os.path.join(save_path, f"{label}_bert_model"))
+
+    return embeddings, model
+
+
+def load_bert_embeddings(path: str):
+    """
+    Load a FAISS index file (.faiss) from disk.
+    """
+    if not path.endswith('.faiss'):
+        path += '.faiss'
+    return faiss.read_index(path)
+
+
+def load_bert_model(path: str):
+    """Load a saved SentenceTransformer model."""
+
+    return SentenceTransformer(path)
+
+
+def convert_hf_model_to_st(hf_model_path: str,
+                           st_model_path: str):
+    """
+    Converts a HuggingFace model to a SentenceTransformer model.
+
+    Needed as fine-tuning was performed using HuggingFace's Transformers library.
+
+    Args:
+        hf_model_path (str): Path to the HuggingFace model.
+        st_model_path (str): Path to save the SentenceTransformer model.
+    
+    Returns:
+        None: Saves the SentenceTransformer model to the specified path.
+    """
+    # Build SentenceTransformer from HF model
+    word_embedding_model = models.Transformer(hf_model_path)
+    pooling_model = models.Pooling(word_embedding_model.get_word_embedding_dimension())
+    st_model = SentenceTransformer(modules=[word_embedding_model, pooling_model])
+
+    # Save to the provided path
+    os.makedirs(st_model_path, exist_ok=True)
+    st_model.save(st_model_path)
+    print(f"✅ Converted HuggingFace model [{hf_model_path}] "
+          f"to SentenceTransformer at [{st_model_path}]")

src/feature_engg/{vectorizing_data.py → tfidf_vectorizing_data.py}

@@ -29,16 +29,16 @@ def get_combined_tfidf_vectorizer(max_features: int = 40000,
     return TfidfVectorizer(
            stop_words="english",
            lowercase=True,
-           max_features=max_features,      # Balanced for resumes + jobs
+           max_features=max_features,       # Balanced for resumes + jobs
            ngram_range=ngram_range,
            min_df=5,
            max_df=0.85,
-           sublinear_tf=True,       # Smooth term frequency scaling
+           sublinear_tf=True,               # Smooth term frequency scaling
            norm="l2"         
 )
 
 def save_vectorizer(vectorizer: TfidfVectorizer, 
-                    path: str = 'models/dev_tfidf/tfidf_vectorizer.pkl'):
+                    path: str = 'models/tfidf/dev_tfidf/tfidf_vectorizer.pkl'):
     
     """
     Saves a TfidfVectorizer object to a given path. Appends .pkl if missing.
@@ -64,9 +64,9 @@ def save_vector_data(matrix: csr_matrix, path: str):
     print(f"✅ TF-IDF matrix saved to: [{path}]")
 
 
-def vectorize_text(df: pd.DataFrame, 
+def tfidf_vectorize_text(df: pd.DataFrame, 
                    text_column: str, 
-                   label: str,  # e.g., 'resumes' or 'jobs'
+                   label: str,
                    vectorizer: Optional[TfidfVectorizer] = None,
                    fit_vectorizer: bool = False, 
                    save_path: Optional[str] = None,

src/fine_tuning/domain_adaptive_bert.py

@@ -0,0 +1,194 @@
+from pathlib import Path
+from datasets import Dataset
+import argparse
+from sklearn.model_selection import train_test_split
+from transformers import (AutoTokenizer,
+                          AutoModelForMaskedLM,
+                          DataCollatorForLanguageModeling,
+                          Trainer,
+                          TrainingArguments,
+                          EarlyStoppingCallback)
+
+
+
+def run_dapt(corpus_path: str,
+             model_name: str = "sentence-transformers/all-MiniLM-L6-v2",
+             output_dir: str = "models/bert/dapt_minilm",
+             num_train_epochs: int = 3,
+             per_device_train_batch_size: int = 32,
+             learning_rate: float = 5e-5,
+             warmup_steps: int = 0,
+             save_total_limit: int = 2,
+             logging_steps: int = 100,
+             max_seq_length: int = 256,
+             val_split: float = 0.1,
+             early_stopping_patience: int = 2,
+             early_stopping_threshold: float = 0.01,
+             save_best_only: bool = True):
+    """
+    Runs Domain-Adaptive Pretraining (DAPT) on a given text corpus.
+
+    Args:
+        corpus_path (str): Path to the text corpus file.
+        model_name (str): Name of the pre-trained BERT model to use. default: "sentence-transformers/all-MiniLM-L6-v2".
+        output_dir (str): Directory to save the trained model. default: "models/bert/dapt_minilm".
+        num_train_epochs (int): Number of training epochs. default: 3.
+        per_device_train_batch_size (int): Batch size for training. default: 32.
+        learning_rate (float): Learning rate for training. default: 5e-5.
+        warmup_steps (int): Number of warmup steps for training. default: 0.
+        save_total_limit (int): Number of checkpoints to save. default: 2.
+        logging_steps (int): Number of steps to log. default: 100.
+        max_seq_length (int): Maximum sequence length for input. default: 256.
+        val_split (float): Fraction of the data to use for validation. default: 0.1.
+        early_stopping_patience (int): Number of epochs to wait for improvement before early stopping. default: 2.
+        early_stopping_threshold (float): Threshold for early stopping improvement. default: 0.01.
+        save_best_only (bool): Whether to save only the best model. default: True.
+
+    Returns:
+        output_dir (str): Path to the trained model directory.
+    """
+
+    # Load dataset from text file bypassing any future caching errors.
+    with open(corpus_path, encoding="utf-8") as f:
+        lines = [l.strip() for l in f if l.strip()]
+
+    if val_split > 0:
+        # Train/validation split
+        train_texts, val_texts = train_test_split(lines, test_size=val_split, random_state=42)
+        dataset = Dataset.from_dict({"text": train_texts})
+        val_dataset = Dataset.from_dict({"text": val_texts})
+    else:
+        # Use full data for training
+        dataset = Dataset.from_dict({"text": lines})
+        val_dataset = None
+
+    # Tokenizer & model
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForMaskedLM.from_pretrained(model_name)
+
+    # Tokenization function
+    def tokenize_fn(batch):
+        return tokenizer(
+            batch["text"],
+            truncation=True,
+            padding="max_length",
+            max_length=max_seq_length,
+        )
+
+    tokenized_train = dataset.map(tokenize_fn, batched=True, remove_columns=["text"])
+    tokenized_val = val_dataset.map(tokenize_fn, batched=True, remove_columns=["text"]) if val_dataset else None
+
+    # Data collator with dynamic masking
+    data_collator = DataCollatorForLanguageModeling(
+        tokenizer=tokenizer,
+        mlm=True,
+        mlm_probability=0.15,
+    )
+
+    # Base training arguments
+    training_args = {
+        "output_dir": output_dir,
+        "overwrite_output_dir": True,
+        "num_train_epochs": num_train_epochs,
+        "per_device_train_batch_size": per_device_train_batch_size,
+        "save_total_limit": save_total_limit,
+        "prediction_loss_only": True,
+        "logging_steps": logging_steps,
+        "learning_rate": learning_rate,
+        "warmup_steps": warmup_steps,
+        "save_strategy": "epoch",
+        "report_to": "none",
+    }
+
+    # Add validation-related args only if val_split > 0
+    if val_dataset:
+        training_args.update({
+            "eval_strategy": "epoch",
+            "load_best_model_at_end": save_best_only,
+            "metric_for_best_model": "eval_loss",
+            "greater_is_better": False,
+        })
+
+
+    training_args = TrainingArguments(**training_args)
+
+    # Callbacks
+    callbacks = []
+    if val_dataset and early_stopping_patience > 0:
+        callbacks.append(
+            EarlyStoppingCallback(
+                early_stopping_patience=early_stopping_patience,
+                early_stopping_threshold=early_stopping_threshold,
+            )
+        )
+
+    # Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_train,
+        eval_dataset=tokenized_val if val_dataset else None,
+        tokenizer=tokenizer,
+        data_collator=data_collator,
+        callbacks=callbacks if val_dataset else None,
+    )
+
+    # Train
+    print("🚀 Starting Domain-Adaptive Pretraining (DAPT)...")
+    trainer.train()
+    trainer.save_model(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+    print(f"✅ DAPT finished! Model saved at: {output_dir}")
+    return output_dir
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Domain-Adaptive Pretraining (DAPT) for BERT/SBERT")
+
+    parser.add_argument("--model_name", type=str, default="sentence-transformers/all-MiniLM-L6-v2",
+                        help="Pretrained model name or path to load")
+    parser.add_argument("--corpus_path", type=str, default="data/processed/domain_corpus.txt",
+                        help="Path to plain text corpus for DAPT")
+    parser.add_argument("--output_dir", type=str, default="models/dapt_bert",
+                        help="Directory to save the fine-tuned model")
+    parser.add_argument("--epochs", type=int, default=3,
+                        help="Number of training epochs")
+    parser.add_argument("--batch_size", type=int, default=32,
+                        help="Training batch size per device")
+    parser.add_argument("--learning_rate", type=float, default=5e-5,
+                        help="Learning rate for AdamW optimizer")
+    parser.add_argument("--warmup_steps", type=int, default=0,
+                        help="Number of warmup steps for LR scheduler")
+    parser.add_argument("--max_seq_length", type=int, default=256,
+                        help="Maximum sequence length for inputs")
+    parser.add_argument("--val_split", type=float, default=0.1,
+                        help="Fraction of data to use for validation (set 0 for no validation)")
+    parser.add_argument("--early_stopping_patience", type=int, default=2,
+                        help="Number of evals with no improvement before stopping (ignored if val_split=0)")
+    parser.add_argument("--early_stopping_threshold", type=float, default=0.01,
+                        help="Minimum improvement in eval loss to be considered progress (ignored if val_split=0)")
+    parser.add_argument("--save_best_only", action="store_true",
+                        help="Save only the best checkpoint (ignored if val_split=0)")
+
+    args = parser.parse_args()
+    Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+
+    run_dapt(
+        model_name=args.model_name,
+        corpus_path=args.corpus_path,
+        output_dir=args.output_dir,
+        num_train_epochs=args.epochs,
+        per_device_train_batch_size=args.batch_size,
+        learning_rate=args.learning_rate,
+        warmup_steps=args.warmup_steps,
+        max_seq_length=args.max_seq_length,
+        val_split=args.val_split,
+        early_stopping_patience=args.early_stopping_patience,
+        early_stopping_threshold=args.early_stopping_threshold,
+        save_best_only=args.save_best_only,
+    )
+
+
+if __name__ == "__main__":
+    main()

src/matching/matching_engine.py

@@ -1,6 +1,6 @@
 import numpy as np
 from sklearn.metrics.pairwise import cosine_similarity
-from src.feature_engg.vectorizing_data import load_vector_data
+from src.feature_engg.tfidf_vectorizing_data import load_vector_data
 
 def compute_similarity_matrix(X_resumes, X_jobs ):
     """
@@ -9,7 +9,7 @@ def compute_similarity_matrix(X_resumes, X_jobs ):
     """
     return cosine_similarity(X_resumes, X_jobs)
 
-def top_n_matches(similarity_matrix: np.ndarray, 
+def top_n_tfidf_matches(similarity_matrix: np.ndarray, 
                   top_n: int = 5,
                   job_df = None):
     """
@@ -36,6 +36,34 @@ def top_n_matches(similarity_matrix: np.ndarray,
         results[i] = ranked
     return results
 
+def top_n_bert_matches(indices, distances, job_df, top_n=5):
+    """
+    Deduplicate FAISS results by job title and return top-N unique matches.
+    Searches across all jobs if provided.
+
+    Args:
+        indices (np.ndarray): Indices of nearest neighbors from FAISS (shape: [1, k]).
+        distances (np.ndarray): Distances/similarities from FAISS (shape: [1, k]).
+        job_df (pd.DataFrame): DataFrame containing job titles.
+        top_n (int): Number of unique top matches to return.
+
+    Returns:
+        List[Tuple[int, float]]: List of (job_idx, score) for top-N unique titles.
+    """
+    seen_titles = set()
+    ranked = []
+
+    for idx, score in zip(indices[0], distances[0]):
+        title = job_df.iloc[idx]['title']
+        if title not in seen_titles:
+            ranked.append((idx, float(score)))
+            seen_titles.add(title)
+        if len(ranked) == top_n:
+            break
+
+    return ranked
+
+
 if __name__ == "__main__":
     # Define paths
     resume_vec_path = "models/dev_tfidf/resumes_tfidf_matrix.npz"
@@ -56,7 +84,7 @@ if __name__ == "__main__":
     # print(f"Min score: {np.min(all_scores):0.4f}, \nMax score: {np.max(all_scores):0.4f}, \nMean score: {np.mean(all_scores):0.4f}, \nMedian score: {np.median(all_scores):0.4f}")
 
     # Get top 5 matches per resume
-    matches = top_n_matches(similarity_matrix, top_n=5)
+    matches = top_n_tfidf_matches(similarity_matrix, top_n=5)
 
     # Display example output (i.e. top_n job matches for first 5 resumes)
     for resume_idx, top_jobs in list(matches.items())[:5]: