Delete semantic_search

semantic_search/README.md

@@ -1,62 +0,0 @@
-# Semantic Search Codebase
-
-## Overview
-CLaMP 2 is a state-of-the-art multimodal music information retrieval system designed to work with 101 languages. This codebase includes scripts for evaluating model performance, performing semantic searches, and calculating similarity metrics based on CLaMP2-extracted **nomarlized** feature vectors from music or text data. Below is a description of the scripts contained in the `semantic_search/` folder.
-
-## Repository Structure
-The `semantic_search/` folder contains the following scripts:
-
-### 1. `clamp2_score.py`
-This script calculates the cosine similarity between the average feature vectors extracted from two sets of `.npy` files, serving as a measure of similarity between the reference and test datasets.
-
-It can be used to validate the semantic similarity between generated music and ground truth, providing an objective metric. Through empirical observation, we found that this metric aligns well with subjective judgments made by individuals with professional music expertise.
-
-**Usage:**
-```bash
-python clamp2_score.py <reference_folder> <test_folder>
-```
-- `reference_folder`: Path to the folder containing reference `.npy` files.
-- `test_folder`: Path to the folder containing test `.npy` files.
-
-**Functionality:**
-- Loads all `.npy` files from the specified folders.
-- Computes the average feature vector for each folder.
-- Calculates the cosine similarity between the two averaged vectors.
-- Outputs the similarity score rounded to four decimal places.
-
-### 2. `semantic_search.py`
-This script performs semantic search by calculating the cosine similarity between a query feature and a set of features stored in `.npy` files.
-
-**Usage:**
-```bash
-python semantic_search.py <query_file> <features_folder> [--top_k TOP_K]
-```
-- `query_file`: Path to the query feature file (e.g., `ballad.npy`).
-- `features_folder`: Path to the folder containing feature files for comparison.
-- `--top_k`: (Optional) Number of top similar items to display. Defaults to 10 if not specified.
-
-**Functionality:**
-- Loads a query feature from the specified file.
-- Loads feature vectors from the given folder.
-- Computes cosine similarity between the query feature and each loaded feature vector.
-- Displays the top K most similar features along with their similarity scores.
-
-### 3. `semantic_search_metrics.py`
-This script calculates evaluation metrics for semantic search by comparing query features to reference features.
-
-**Usage:**
-```bash
-python semantic_search_metrics.py <query_folder> <reference_folder>
-```
-- `query_folder`: Path to the folder containing query features (in `.npy` format).
-- `reference_folder`: Path to the folder containing reference features (in `.npy` format).
-
-**Functionality:**
-- Loads query features from the specified folder.
-- Loads reference features from the given folder.
-- Computes the following metrics based on cosine similarity:
-  - **Mean Reciprocal Rank (MRR)**
-  - **Hit@1**
-  - **Hit@10**
-  - **Hit@100**
-- Outputs the calculated metrics to the console.

semantic_search/clamp2_score.py

@@ -1,57 +0,0 @@
-import os
-import numpy as np
-import argparse
-
-def load_npy_files(folder_path):
-    """
-    Load all .npy files from a specified folder and return a list of numpy arrays.
-    """
-    npy_list = []
-    for file_name in os.listdir(folder_path):
-        if file_name.endswith('.npy'):
-            file_path = os.path.join(folder_path, file_name)
-            np_array = np.load(file_path)[0]
-            npy_list.append(np_array)
-    return npy_list
-
-def average_npy(npy_list):
-    """
-    Compute the average of a list of numpy arrays.
-    """
-    return np.mean(npy_list, axis=0)
-
-def cosine_similarity(vec1, vec2):
-    """
-    Compute cosine similarity between two numpy arrays.
-    """
-    dot_product = np.dot(vec1, vec2)
-    
-    norm_vec1 = np.linalg.norm(vec1)
-    norm_vec2 = np.linalg.norm(vec2)
-    
-    cosine_sim = dot_product / (norm_vec1 * norm_vec2)
-    
-    return cosine_sim
-
-if __name__ == '__main__':
-    # Set up argument parsing for input folders
-    parser = argparse.ArgumentParser(description="Calculate cosine similarity between average feature vectors.")
-    parser.add_argument('reference', type=str, help='Path to the reference folder containing .npy files.')
-    parser.add_argument('test', type=str, help='Path to the test folder containing .npy files.')
-    args = parser.parse_args()
-
-    reference = args.reference
-    test = args.test
-    # Load .npy files
-    ref_npy = load_npy_files(reference)
-    test_npy = load_npy_files(test) 
-    
-    # Compute the average of each list of numpy arrays
-    avg_ref = average_npy(ref_npy)
-    avg_test = average_npy(test_npy)
-
-    # Compute the cosine similarity between the two averaged numpy arrays
-    similarity = cosine_similarity(avg_ref, avg_test)
-
-    # Output the cosine similarity rounded to four decimal places
-    print(f"Cosine similarity between '{reference}' and '{test}': {similarity:.4f}")

semantic_search/semantic_search.py

@@ -1,51 +0,0 @@
-import os
-import torch
-import numpy as np
-import argparse
-
-def get_info(folder_path):
-    """
-    Load all .npy files from a specified folder and return a dictionary of features.
-    """
-    files = sorted(os.listdir(folder_path))
-    features = {}
-    
-    for file in files:
-        if file.endswith(".npy"):
-            key = file.split(".")[0]
-            features[key] = np.load(os.path.join(folder_path, file))[0]
-    
-    return features
-
-def main(query_file, features_folder, top_k=10):
-    # Load query feature from the specified file
-    query_feature = np.load(query_file)[0]  # Load directly from the query file
-    query_tensor = torch.tensor(query_feature).unsqueeze(dim=0)
-
-    # Load key features from the specified folder
-    key_features = get_info(features_folder)
-
-    # Prepare tensor for key features
-    key_feats_tensor = torch.tensor(np.array([key_features[k] for k in key_features.keys()]))
-
-    # Calculate cosine similarity
-    similarities = torch.cosine_similarity(query_tensor, key_feats_tensor)
-    ranked_indices = torch.argsort(similarities, descending=True)
-
-    # Get the keys for the features
-    keys = list(key_features.keys())
-    
-    print(f"Top {top_k} similar items:")
-    for i in range(top_k):
-        print(keys[ranked_indices[i]], similarities[ranked_indices[i]].item())
-
-if __name__ == '__main__':
-    # Set up argument parsing for input paths
-    parser = argparse.ArgumentParser(description="Find top similar features based on cosine similarity.")
-    parser.add_argument('query_file', type=str, help='Path to the query feature file (e.g., ballad.npy).')
-    parser.add_argument('features_folder', type=str, help='Path to the folder containing feature files for comparison.')
-    parser.add_argument('--top_k', type=int, default=10, help='Number of top similar items to display (default: 10).')
-    args = parser.parse_args()
-
-    # Execute the main functionality
-    main(args.query_file, args.features_folder, args.top_k)

semantic_search/semantic_search_metrics.py

@@ -1,78 +0,0 @@
-import os
-import torch
-import numpy as np
-import argparse
-
-def get_features(path):
-    """
-    Load and return feature data from .npy files in the given directory.
-    Each feature is stored in a dictionary with the filename (without extension) as the key.
-    """
-    files = sorted(os.listdir(path))
-    features = {}
-    
-    for file in files:
-        if file.endswith(".npy"):
-            key = file.split(".")[0]
-            features[key] = np.load(os.path.join(path, file))[0]
-    
-    return features
-
-def calculate_metrics(query_features, reference_features):
-    """
-    Calculate MRR, Hit@1, Hit@10, and Hit@100 metrics based on the similarity 
-    between query and reference features.
-    """
-    common_keys = set(query_features.keys()) & set(reference_features.keys())
-    mrr, hit_1, hit_10, hit_100 = 0, 0, 0, 0
-
-    for idx, key in enumerate(common_keys):
-        # Convert query feature to tensor and add batch dimension
-        query_feat = torch.tensor(query_features[key]).unsqueeze(dim=0)
-        
-        # Collect all reference features for common keys
-        ref_feats = torch.tensor(np.array([reference_features[k] for k in common_keys]))
-
-        # Compute cosine similarity between the query and all reference features
-        similarities = torch.cosine_similarity(query_feat, ref_feats)
-
-        # Create a list of (similarity, index) pairs
-        indexed_sims = list(enumerate(similarities.tolist()))
-
-        # Sort by similarity in descending order, with idx-based tie-breaking
-        sorted_indices = sorted(indexed_sims, key=lambda x: (x[1], x[0] == idx), reverse=True)
-
-        # Extract the sorted rank list
-        ranks = [x[0] for x in sorted_indices]
-
-        # Calculate MRR
-        mrr += 1 / (ranks.index(idx) + 1)
-
-        # Calculate Hit@1, Hit@10, Hit@100
-        if idx in ranks[:100]:
-            hit_100 += 1
-            if idx in ranks[:10]:
-                hit_10 += 1
-                if idx in ranks[:1]:
-                    hit_1 += 1
-
-    # Compute the final metrics
-    total_keys = len(common_keys)
-    print(f"MRR: {round(mrr / total_keys, 4)}")
-    print(f"Hit@1: {round(hit_1 / total_keys, 4)}")
-    print(f"Hit@10: {round(hit_10 / total_keys, 4)}")
-    print(f"Hit@100: {round(hit_100 / total_keys, 4)}")
-
-if __name__ == '__main__':
-    # Set up argument parsing for input directories
-    parser = argparse.ArgumentParser(description="Calculate similarity metrics between query and reference features.")
-    parser.add_argument('query_folder', type=str, help='Path to the folder containing query features (.npy files).')
-    parser.add_argument('reference_folder', type=str, help='Path to the folder containing reference features (.npy files).')
-    args = parser.parse_args()
-
-    # Load features from the specified folders
-    query_features = get_features(args.query_folder)
-    reference_features = get_features(args.reference_folder)
-
-    # Calculate and print the metrics
-    calculate_metrics(query_features, reference_features)