Delete music_classification

music_classification/README.md

@@ -1,46 +0,0 @@
-# Music Classification Codebase
-
-## Overview
-Linear Probe is a powerful classification tool that leverages feature representations for supervised learning tasks. This codebase includes scripts for training a linear classification model, performing classification on new feature data. The features utilized can be extracted from the M3 or CLaMP 2 models, ensuring that the time dimension information is preserved and **not normalized**. Below is a description of the scripts contained in the `music_classification/` folder.
-
-## Repository Structure
-The `music_classification/` folder contains the following scripts:
-
-### 1. `config.py`
-This script defines configurations for the linear probe training and inference, specifying training data paths and parameters like learning rate, number of epochs, and hidden size.
-
-### 2. `inference_cls.py`
-This script enables the classification of feature vectors using a pre-trained linear probe model.
-
-#### JSON Output Format
-The resulting JSON file contains a dictionary with the following structure:
-```json
-{
-    "path/to/feature1.npy": "class_A",
-    "path/to/feature2.npy": "class_B",
-    "path/to/feature3.npy": "class_A"
-}
-```
-- **Key**: The path to the input feature file (e.g., `feature1.npy`).
-- **Value**: The predicted class label assigned by the linear probe model (e.g., `class_A`).
-
-#### Usage
-```bash
-python inference_cls.py <feature_folder> <output_file>
-```
-- `feature_folder`: Directory containing input feature files (in `.npy` format).
-- `output_file`: File path to save the classification results (in JSON format).
-
-### 3. `train_cls.py`
-This script is designed for training the linear classification model.
-
-#### Usage
-```bash
-python train_cls.py
-```
-
-### 4. `utils.py`
-The utility script defines the architecture of the linear classification model.
-
-## Naming Convention
-All `.npy` files used in this codebase must follow the naming convention of `label_filename.npy`, where the filename should not contain any underscores (`_`).

music_classification/config.py

@@ -1,26 +0,0 @@
-# Configuration for generative modelling and classification
-TRAIN_FOLDERS = [
-    "<path_to_training_data>"  # Directory containing training data
-]
-
-EVAL_FOLDERS = [
-    ""  # (Optional) Directory containing evaluation data
-]
-
-EVAL_SPLIT = 0.2  # Fraction of training data to use for evaluation
-
-# Weights and Biases configuration
-WANDB_KEY = "<your_wandb_key>"  # Set M3/CLaMP2_WANDB_LOG=False if no API key for Weights and Biases logging
-
-# Model Configuration
-INPUT_HIDDEN_SIZE = 768  # Input hidden size
-HIDDEN_SIZE = 768  # Model hidden size
-NUM_EPOCHS = 1000  # Max number of epochs to train (early stopping can terminate earlier)
-LEARNING_RATE = 1e-5  # Optimizer learning rate
-BALANCED_TRAINING = False  # Set to True to balance labels in training data
-WANDB_LOG = False  # Set to True to log training metrics to WANDB
-
-# Paths Configuration
-last_folder_name = TRAIN_FOLDERS[-1].split('/')[-1]
-WEIGHTS_PATH = f"weights-{last_folder_name}.pth"  # Weights file path
-LOGS_PATH = f"logs-{last_folder_name}.txt"  # Log file path

music_classification/inference_cls.py

@@ -1,71 +0,0 @@
-import os
-import json
-import torch
-import random
-import numpy as np
-from utils import *
-from tqdm import tqdm
-from samplings import *
-import argparse
-
-def list_files_in_directory(directories, extensions=["npy"]):
-    file_list = []
-    
-    for directory in directories:
-        for root, dirs, files in os.walk(directory):
-            for file in files:
-                if any(file.endswith(ext) for ext in extensions):
-                    file_path = os.path.join(root, file)
-                    file_list.append(file_path)
-
-    return file_list
-
-if __name__ == "__main__":
-    # Setup argument parser
-    parser = argparse.ArgumentParser(description="Feature extraction and classification with CLaMP2.")
-    parser.add_argument("feature_folder", type=str, help="Directory containing input feature files.")
-    parser.add_argument("output_file", type=str, help="File to save the classification results. (format: json)")
-
-    # Parse arguments
-    args = parser.parse_args()
-    feature_folder = args.feature_folder
-    output_file = args.output_file
-
-    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
-    seed = 42
-    random.seed(seed)
-    np.random.seed(seed)
-    torch.manual_seed(seed)
-    torch.cuda.manual_seed_all(seed)
-    torch.backends.cudnn.deterministic = True
-    torch.backends.cudnn.benchmark = False
-
-    checkpoint = torch.load(WEIGHTS_PATH, map_location='cpu')
-    print(f"Successfully Loaded Checkpoint from Epoch {checkpoint['epoch']} with acc {checkpoint['max_eval_acc']}")
-    label2idx = checkpoint['labels']
-    idx2label = {idx: label for label, idx in label2idx.items()}  # Create reverse mapping
-    model = LinearClassification(num_classes=len(label2idx))
-    model = model.to(device)
-
-    # print parameter number
-    print("Parameter Number: "+str(sum(p.numel() for p in model.parameters() if p.requires_grad)))
-
-    model.eval()
-    model.load_state_dict(checkpoint['model'])
-
-    # load filenames under train and eval folder
-    feature_files = list_files_in_directory([feature_folder])
-    cls_results = {}
-
-    for filepath in tqdm(feature_files):
-        outputs = np.load(filepath)[0]
-        outputs = torch.from_numpy(outputs).to(device)
-        outputs = outputs.unsqueeze(0)
-        cls_list = model(outputs)[0].tolist()
-        max_prob = max(cls_list)
-        cls_idx = cls_list.index(max_prob)
-        cls_label = idx2label[cls_idx]
-        cls_results[filepath] = cls_label
-
-    with open(output_file, "w", encoding="utf-8") as f:
-        json.dump(cls_results, f)

music_classification/train_cls.py

@@ -1,293 +0,0 @@
-import os
-import time
-import math
-import wandb
-import torch
-import random
-import numpy as np
-from utils import *
-from config import *
-from tqdm import tqdm
-from sklearn.metrics import f1_score
-from torch.amp import autocast, GradScaler
-from torch.utils.data import Dataset, DataLoader
-from transformers import get_constant_schedule_with_warmup
-import torch.distributed as dist
-from torch.nn.parallel import DistributedDataParallel as DDP
-from torch.utils.data.distributed import DistributedSampler
-
-# Set up distributed training
-world_size = int(os.environ['WORLD_SIZE']) if 'WORLD_SIZE' in os.environ else 1
-global_rank = int(os.environ['RANK']) if 'RANK' in os.environ else 0
-local_rank = int(os.environ['LOCAL_RANK']) if 'LOCAL_RANK' in os.environ else 0
-
-if world_size > 1:
-    torch.cuda.set_device(local_rank)
-    device = torch.device("cuda", local_rank)
-    dist.init_process_group(backend='nccl') if world_size > 1 else None
-else:
-    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
-    
-# Set random seed
-seed = 42 + global_rank
-random.seed(seed)
-np.random.seed(seed)
-torch.manual_seed(seed)
-torch.cuda.manual_seed_all(seed)
-torch.backends.cudnn.deterministic = True
-torch.backends.cudnn.benchmark = False
-
-batch_size = 1
-    
-def collate_batch(input_tensors):
-
-    input_tensors, labels = zip(*input_tensors)
-    input_tensors = torch.stack(input_tensors, dim=0)
-    labels = torch.stack(labels, dim=0)
-
-    return input_tensors.to(device), labels.to(device)
-
-def list_files_in_directory(directories):
-    file_list = []
-    
-    for directory in directories:
-        for root, dirs, files in os.walk(directory):
-            for file in files:
-                if file.endswith(".npy"):
-                    file_path = os.path.join(root, file)
-                    file_list.append(file_path)
-    return file_list
-
-class TensorDataset(Dataset):
-    def __init__(self, filenames):
-        print(f"Loading {len(filenames)} files for classification")
-        self.filenames = []
-        self.label2idx = {}
-
-        for filename in tqdm(filenames):
-            label = os.path.basename(filename).split('_')[0]
-
-            self.filenames.append(filename)
-            if label not in self.label2idx:
-                self.label2idx[label] = len(self.label2idx)
-        print(f"Found {len(self.label2idx)} classes")
-            
-    def __len__(self):
-        return len(self.filenames)
-
-    def __getitem__(self, idx):
-        
-        filename = self.filenames[idx]
-        label = os.path.basename(filename).split('_')[0]
-        label = self.label2idx[label]
-        
-        # load numpy file
-        data = np.load(filename)
-        data = torch.from_numpy(data)[0]
-        label = torch.tensor(label)
-
-        return data, label
-
-class BalancedTensorDataset(Dataset):
-    def __init__(self, filenames):
-        print(f"Loading {len(filenames)} files for classification")
-        self.filenames = filenames
-        self.label2idx = {}
-        self.label2files = {}
-        
-        for filename in tqdm(filenames):
-            label = os.path.basename(filename).split('_')[0]
-            if label not in self.label2idx:
-                self.label2idx[label] = len(self.label2idx)
-            if label not in self.label2files:
-                self.label2files[label] = []
-            self.label2files[label].append(filename)
-        print(f"Found {len(self.label2idx)} classes")
-        
-        self.min_samples = min(len(files) for files in self.label2files.values())
-
-        self._update_epoch_filenames()
-
-    def _update_epoch_filenames(self):
-        self.epoch_filenames = []
-        for label, files in self.label2files.items():
-            sampled_files = random.sample(files, self.min_samples)
-            self.epoch_filenames.extend(sampled_files)
-
-        random.shuffle(self.epoch_filenames)
-
-    def __len__(self):
-        return len(self.epoch_filenames)
-
-    def __getitem__(self, idx):
-        filename = self.epoch_filenames[idx]
-        label = os.path.basename(filename).split('_')[0]
-        label = self.label2idx[label]
-        
-        data = np.load(filename)
-        data = torch.from_numpy(data)[0]
-        label = torch.tensor(label)
-
-        return data, label
-
-    def on_epoch_end(self):
-        self._update_epoch_filenames()
-
-# load filenames under train and eval folder
-train_files = list_files_in_directory(TRAIN_FOLDERS)
-eval_files = list_files_in_directory(EVAL_FOLDERS)
-
-if len(eval_files)==0:
-    random.shuffle(train_files)
-    eval_files = train_files[:math.ceil(len(train_files)*EVAL_SPLIT)]
-    train_files = train_files[math.ceil(len(train_files)*EVAL_SPLIT):]
-if BALANCED_TRAINING:
-    train_set = BalancedTensorDataset(train_files)
-else:
-    train_set = TensorDataset(train_files)
-eval_set = TensorDataset(eval_files)
-eval_set.label2idx = train_set.label2idx
-
-model = LinearClassification(num_classes=len(train_set.label2idx))
-model = model.to(device)
-
-# print parameter number
-print("Parameter Number: "+str(sum(p.numel() for p in model.parameters() if p.requires_grad)))
-
-if world_size > 1:
-    model = DDP(model, device_ids=[local_rank], output_device=local_rank,  find_unused_parameters=True)
-
-scaler = GradScaler()
-is_autocast = True
-optimizer = torch.optim.AdamW(model.parameters(), lr=LEARNING_RATE)
-loss_fn = torch.nn.CrossEntropyLoss()
-
-# call model with a batch of input
-def process_one_batch(batch):
-    input_tensors, labels = batch
-    logits = model(input_tensors)
-    loss = loss_fn(logits, labels)
-    prediction = torch.argmax(logits, dim=1)
-    acc_num = torch.sum(prediction==labels)
-
-    return loss, acc_num, prediction, labels
-
-# do one epoch for training
-def train_epoch():
-    tqdm_train_set = tqdm(train_set)
-    total_train_loss = 0
-    total_acc_num = 0
-    iter_idx = 1
-    model.train()
-
-    for batch in tqdm_train_set:
-        if is_autocast:
-            with autocast(device_type='cuda'):
-                loss, acc_num, prediction, labels = process_one_batch(batch)
-            scaler.scale(loss).backward()
-            scaler.step(optimizer)
-            scaler.update()
-        else:
-            loss, acc_num, prediction, labels = process_one_batch(batch)
-            loss.backward()
-            optimizer.step()
-        
-        lr_scheduler.step()
-        model.zero_grad(set_to_none=True)
-        total_train_loss += loss.item()
-        total_acc_num += acc_num.item()
-        tqdm_train_set.set_postfix({str(global_rank)+'_train_acc': total_acc_num / (iter_idx*batch_size)})
-        # Log the training loss to wandb
-        if global_rank==0 and WANDB_LOG:
-            wandb.log({"acc": total_acc_num / (iter_idx*batch_size)})
-
-        iter_idx += 1
-    
-    if BALANCED_TRAINING:
-        train_set.dataset.on_epoch_end()
-        
-    return total_acc_num / ((iter_idx-1)*batch_size)
-
-# do one epoch for eval
-def eval_epoch():
-    tqdm_eval_set = tqdm(eval_set)
-    total_eval_loss = 0
-    total_acc_num = 0
-    iter_idx = 1
-    model.eval()
-  
-    all_predictions = []
-    all_labels = []
-  
-    # Evaluate data for one epoch
-    for batch in tqdm_eval_set: 
-        with torch.no_grad():
-            loss, acc_num, prediction, labels = process_one_batch(batch)
-            total_eval_loss += loss.item()
-            total_acc_num += acc_num.item()
-
-            # Accumulate predictions and labels
-            all_predictions.extend(prediction.cpu().numpy())
-            all_labels.extend(labels.cpu().numpy())
-
-        tqdm_eval_set.set_postfix({str(global_rank)+'_eval_acc': total_acc_num / (iter_idx*batch_size)})
-        iter_idx += 1
-
-    # Compute F1 Macro
-    f1_macro = f1_score(all_labels, all_predictions, average='macro')
-    return total_acc_num / ((iter_idx - 1) * batch_size), f1_macro
-
-# train and eval
-if __name__ == "__main__":
-
-    label2idx = train_set.label2idx
-    max_eval_acc = 0
-    train_sampler = DistributedSampler(train_set, num_replicas=world_size, rank=global_rank)
-    eval_sampler = DistributedSampler(eval_set, num_replicas=world_size, rank=global_rank)
-
-    train_set = DataLoader(train_set, batch_size=batch_size, collate_fn=collate_batch, sampler=train_sampler, shuffle = (train_sampler is None))
-    eval_set = DataLoader(eval_set, batch_size=batch_size, collate_fn=collate_batch, sampler=eval_sampler, shuffle = (train_sampler is None))
-
-    lr_scheduler = get_constant_schedule_with_warmup(optimizer = optimizer, num_warmup_steps = len(train_set))
-
-    model = model.to(device)
-    optimizer = torch.optim.AdamW(model.parameters(), lr=LEARNING_RATE)
-    
-    if WANDB_LOG and global_rank==0:
-        # Initialize wandb
-        if WANDB_KEY:
-            wandb.login(key=WANDB_KEY)
-        wandb.init(project="linear", 
-                   name=WEIGHTS_PATH.replace("weights_", "").replace(".pth", ""))
-             
-    for epoch in range(1, NUM_EPOCHS+1):
-        train_sampler.set_epoch(epoch)
-        eval_sampler.set_epoch(epoch)
-        print('-' * 21 + "Epoch " + str(epoch) + '-' * 21)
-        train_acc = train_epoch()
-        eval_acc, eval_f1_macro = eval_epoch()
-        if global_rank==0:
-            with open(LOGS_PATH,'a') as f:
-                f.write("Epoch " + str(epoch) + "\ntrain_acc: " + str(train_acc) + "\neval_acc: " +str(eval_acc) + "\neval_f1_macro: " +str(eval_f1_macro) + "\ntime: " + time.asctime(time.localtime(time.time())) + "\n\n")
-            if eval_acc > max_eval_acc:
-                best_epoch = epoch
-                max_eval_acc = eval_acc
-                checkpoint = { 
-                                'model': model.module.state_dict() if hasattr(model, "module") else model.state_dict(),
-                                'optimizer': optimizer.state_dict(),
-                                'lr_sched': lr_scheduler.state_dict(),
-                                'epoch': epoch,
-                                'best_epoch': best_epoch,
-                                'max_eval_acc': max_eval_acc,
-                                "labels": label2idx
-                                }
-                torch.save(checkpoint, WEIGHTS_PATH)
-                with open(LOGS_PATH,'a') as f:
-                    f.write("Best Epoch so far!\n\n\n")
-        
-        if world_size > 1:
-            dist.barrier()
-
-    if global_rank==0:
-        print("Best Eval Epoch : "+str(best_epoch))
-        print("Max Eval Accuracy : "+str(max_eval_acc))

music_classification/utils.py

@@ -1,22 +0,0 @@
-import torch
-from config import *
-
-class LinearClassification(torch.nn.Module):
-    def __init__(self, num_classes):
-        super(LinearClassification, self).__init__()
-        self.fc1 = torch.nn.Linear(INPUT_HIDDEN_SIZE, HIDDEN_SIZE)
-        self.relu = torch.nn.ReLU()
-        self.fc2 = torch.nn.Linear(HIDDEN_SIZE, num_classes)
-        self.softmax = torch.nn.Softmax(dim=1)
-
-    def forward(self, x):
-        # Apply the linear layer and ReLU to each time step
-        x = self.fc1(x)  # x shape (B, L, H) -> (B, L, hidden_size)
-        x = self.relu(x) 
-        
-        # Average over the time steps (L dimension)
-        x = x.mean(dim=1)  # Now x has shape (B, hidden_size)
-        
-        x = self.fc2(x)    # Now applying the final layer (B, hidden_size) -> (B, num_classes)
-        x = self.softmax(x)
-        return x