Remove all files except .gitattributes, best_ast_model.pth, and AST_README.md

AST_Pipeline.py

@@ -1,397 +0,0 @@
-import os
-import glob
-from networkx import display
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-import librosa
-import librosa.display
-import matplotlib.pyplot as plt
-import random
-import torch
-import wandb
-from torchsummary import summary
-from torch.utils.data.dataset import Dataset
-from torch.utils.data import DataLoader
-from torch.optim.lr_scheduler import ReduceLROnPlateau
-from transformers import ASTForAudioClassification, ASTConfig
-import torch.nn as nn
-from sklearn.model_selection import StratifiedShuffleSplit
-from collections import Counter
-import seaborn as sns
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.metrics import f1_score
-import warnings
-warnings.filterwarnings("ignore")
-
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-print(f"Is GPU available? {torch.cuda.is_available()}")
-print(f"Current device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}")
-
-DATA_SEED = 67
-TRAINING_SEED = 1234
-SR = 22050
-DURATION = 5.0
-N_FFT = 2048
-HOP_LENGTH = 512
-N_MELS = 128
-TOP_DB=20
-TARGET_SNR_DB = 10
-
-random.seed(DATA_SEED)
-np.random.seed(DATA_SEED)
-torch.manual_seed(DATA_SEED)
-torch.cuda.manual_seed(DATA_SEED)
-
-DATA_ROOT = '/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/genres_stems'
-GENRES = [] # Make the list of all genres available
-for genre in os.listdir(path=DATA_ROOT):
-  GENRES.append(genre)
-display(GENRES)
-STEMS = {} # Write here stems file name
-STEM_KEYS = ['drums', 'vocals', 'bass', 'other']
-GENRE_TO_TEST = 'rock'
-SONG_INDEX = 0
-genre_to_id = {genre: i for i, genre in enumerate(GENRES)}
-id_to_genre = {i: genre for i, genre in enumerate(GENRES)}
-
-# Build the dataset in the format {genre: {stem_type: [file_paths]}}
-def build_dataset(root_dir, val_split=0.17, seed=42):
-    train_dataset = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    val_dataset   = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    rows = []
-    for genre in GENRES:
-      genre_path = os.path.join(root_dir, genre)
-      for song in os.listdir(genre_path):
-        rows.append({
-            "label" : genre,
-            "song" : song
-        })
-    df = pd.DataFrame(rows)
-    X = df['song']
-    y = df['label']
-
-    sss = StratifiedShuffleSplit(n_splits=1, test_size=val_split, random_state=seed)
-
-    for train_index, val_index in sss.split(X, y):
-        train_df = df.iloc[train_index].reset_index(drop=True)
-        val_df = df.iloc[val_index].reset_index(drop=True)
-
-    for idx, row in train_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          train_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-
-    for idx, row in val_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          val_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-    return train_dataset, val_dataset
-
-tr, val = build_dataset(DATA_ROOT)
-
-
-
-AST_SR = 16000
-AST_TARGET_FRAMES = 1024
-
-# A custom Dataset class that will handle the loading of audio files, applying random augmentations, and generating the mel spectrograms on-the-fly during training and validation.
-class ASTAudioDataset(Dataset):
-    def __init__(self, data_dict, length, genres, stem_types, noise_files, duration=10.0):
-        self.data_dict = data_dict
-        self.length = length
-        self.genres = genres
-        self.stem_types = stem_types
-        self.noise_files = noise_files
-        self.duration = duration
-        self.sr = AST_SR
-
-    def __len__(self):
-        return self.length
-
-    def __getitem__(self, idx, retries=0):
-        if retries > 10:
-            return self.__getitem__(random.randint(0, self.length - 1), 0)
-
-        genre = random.choice(self.genres) # Choose a random genre for this sample
-        max_start = max(0, 28 - self.duration) # Calculate the maximum start position
-        base_start = random.uniform(0, max_start) 
-        target_len = int(self.sr * self.duration)
-        stems_data = []
-        
-        for stem_type in self.stem_types:
-            if random.random() < 0.15:
-                continue
-            
-            try:
-                path = random.choice(self.data_dict[genre][stem_type])
-                y, _ = librosa.load(path, sr=self.sr, offset=base_start, duration=self.duration)
-                y = librosa.util.fix_length(y, size=target_len)
-                
-                weight = random.uniform(0.4, 1.2)
-                y = y * weight # Apply random gain to the stem
-                
-                if np.sqrt(np.mean(y**2)) > 0.001: 
-                    stems_data.append(y)
-            except:
-                continue
-
-        if not stems_data:
-            return self.__getitem__(idx, retries + 1)
-
-        mix = np.sum(stems_data, axis=0)
-        if np.max(np.abs(mix)) > 0:
-            mix = mix / np.max(np.abs(mix)) # Normalize the mixed audio to prevent clipping
-
-        noise_path = random.choice(self.noise_files)
-        noise_y, _ = librosa.load(noise_path, sr=self.sr, offset=base_start, duration=self.duration)
-        noise_y = librosa.util.fix_length(noise_y, size=target_len)
-
-        # Calculate the power of the signal and noise, then scale the noise to achieve the target SNR
-        p_signal = np.mean(mix**2) + 1e-9
-        p_noise = np.mean(noise_y**2) + 1e-9
-        
-        snr_divisor = random.uniform(2.0, 8.0) 
-        target_noise_power = p_signal / snr_divisor
-        scaling_factor = np.sqrt(target_noise_power / p_noise)
-        final_audio = mix + (scaling_factor * noise_y)
-
-        mel = librosa.feature.melspectrogram(
-            y=final_audio,
-            sr=self.sr,
-            n_mels=128,
-            n_fft=400,       
-            hop_length=160   
-        )
-        
-        mel_db = librosa.power_to_db(mel, ref=np.max)
-        mel_db = (mel_db + 4.26) / 4.56 
-        mel_tensor = torch.tensor(mel_db).float()
-
-        mel_tensor = mel_tensor.T 
-
-        # Pad or truncate to ensure consistent shape (AST expects 1024 frames)
-        if mel_tensor.shape[0] < AST_TARGET_FRAMES:
-            padding_needed = AST_TARGET_FRAMES - mel_tensor.shape[0]
-            mel_tensor = torch.nn.functional.pad(mel_tensor, (0, 0, 0, padding_needed))
-        else:
-            mel_tensor = mel_tensor[:AST_TARGET_FRAMES, :]
-            
-        genre_idx = genre_to_id[genre]
-        return mel_tensor, genre_idx
-noise_files_list = [os.path.join('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/ESC-50-master/audio', f) 
-                    for f in os.listdir('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/ESC-50-master/audio') if f.endswith('.wav')]
-    
-train_ds = ASTAudioDataset(
-    data_dict=tr, 
-    length=1000, 
-    genres=GENRES, 
-    stem_types=STEM_KEYS, 
-    noise_files=noise_files_list
-)
-
-val_ds = ASTAudioDataset(
-    data_dict=val, 
-    length=500, 
-    genres=GENRES, 
-    stem_types=STEM_KEYS, 
-    noise_files=noise_files_list,
-)
-
-train_loader = DataLoader(
-    train_ds, 
-    batch_size=4, 
-    shuffle=True, 
-    num_workers=2,   
-    pin_memory=True  
-)
-
-val_loader = DataLoader(
-    val_ds, 
-    batch_size=4, 
-    shuffle=False, 
-    num_workers=2,
-    pin_memory=True
-)
-
-# Loading pre trained model
-class MusicGenreAST(nn.Module):
-    def __init__(self, num_classes):
-        super(MusicGenreAST, self).__init__()
-        self.ast = ASTForAudioClassification.from_pretrained(
-            "MIT/ast-finetuned-audioset-10-10-0.4593",
-            num_labels=num_classes,
-            ignore_mismatched_sizes=True 
-        )
-
-    def forward(self, x):
-        outputs = self.ast(x)
-        return outputs
-
-#Train loop
-def train_ast(model_instance):
-    num_epochs = 15
-    patience_counter = 0
-    patience_limit = 7 
-    best_score = float('-inf')
-    accumulation_steps = 4 
-    
-    model = model_instance.to(device)
-    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5, weight_decay=0.01) #ADAMW optimizer with weight decay for better generalization
-    scheduler = ReduceLROnPlateau(optimizer=optimizer, mode='max', factor=0.5, patience=2, min_lr=1e-7) # Reduce learning rate when the F1 score plateaus, with a minimum learning rate threshold
-    criterion = nn.CrossEntropyLoss()
-
-    for epoch in range(num_epochs):
-        # Training Phase
-        model.train()
-        tot_train_loss = 0
-        optimizer.zero_grad()
-
-        for i, (mel_spec, genre_id) in enumerate(train_loader):
-            mel_spec, genre_id = mel_spec.to(device), genre_id.to(device)
-            
-            outputs = model(mel_spec).logits
-            loss = criterion(outputs, genre_id)
-            loss = loss / accumulation_steps
-            loss.backward()
-            
-            if (i + 1) % accumulation_steps == 0:
-                optimizer.step()
-                optimizer.zero_grad()
-            
-            tot_train_loss += (loss.item() * accumulation_steps) * mel_spec.size(0)
-            
-        epoch_train_loss = tot_train_loss / len(train_loader.dataset)
-        # Validation Phase
-        model.eval()
-        tot_val_loss = 0
-        genre_pred_tot = []
-        genre_true_tot = []
-        
-        with torch.no_grad():
-            for mel_spec, genre_id in val_loader:
-                mel_spec, genre_id = mel_spec.to(device), genre_id.to(device)
-                
-                outputs = model(mel_spec).logits
-                val_loss = criterion(outputs, genre_id)
-                preds = torch.argmax(outputs, dim=1)
-                
-                genre_true_tot.extend(genre_id.cpu().numpy())
-                genre_pred_tot.extend(preds.cpu().numpy())
-                tot_val_loss += val_loss.item() * mel_spec.size(0)
-        
-        epoch_validate_loss = tot_val_loss / len(val_loader.dataset)
-        genre_score = f1_score(y_true=genre_true_tot, y_pred=genre_pred_tot, average='macro')
-        current_lr = optimizer.param_groups[0]['lr']
-
-        print(f'Epoch {epoch+1}/{num_epochs}')
-        print(f'Train Loss: {epoch_train_loss:.4f} | Val Loss: {epoch_validate_loss:.4f}')
-        print(f'F1 Score: {genre_score:.4f} | LR: {current_lr:.6f}\n')
-
-        wandb.log({
-           "epoch": epoch + 1,
-            "train_loss": epoch_train_loss,
-            "val_loss": epoch_validate_loss,
-            "score": genre_score,
-            "learning_rate": current_lr
-        })
-
-        scheduler.step(genre_score)
-        
-        if genre_score > best_score:
-            best_score = genre_score
-            patience_counter = 0
-            torch.save(model.state_dict(), 'best_ast_model.pth')
-            print(f"New Best Score! Model saved.")
-        else:
-            patience_counter += 1
-        torch.cuda.empty_cache()
-  
-        if patience_counter >= patience_limit:
-            print('----- Early Stopping Triggered -----')
-            break
-
-    wandb.finish()
-
-train_ast(MusicGenreAST(10))
-
-# Prediction dataset for test set
-class ASTTestDataset(Dataset):
-    def __init__(self, test_df):
-        self.data = test_df
-        self.sr = 16000
-        self.duration = 10.0
-        self.target_frames = 1024
-
-    def __len__(self):
-        return len(self.data)
-
-    def __getitem__(self, idx):
-        filename = self.data.iloc[idx]['filename']
-        path = os.path.join('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup', filename)
-        
-        y, _ = librosa.load(path, sr=self.sr, offset=0, duration=self.duration)
-        
-        target_len = int(self.sr * self.duration)
-        y = librosa.util.fix_length(y, size=target_len)
-        
-        if np.max(np.abs(y)) > 0:
-            y = y / np.max(np.abs(y))
-
-        mel = librosa.feature.melspectrogram(
-            y=y,
-            sr=self.sr,
-            n_mels=128,
-            n_fft=400,
-            hop_length=160
-        )
-        
-        mel_db = librosa.power_to_db(mel, ref=np.max)
-        mel_db = (mel_db + 4.26) / 4.56
-        
-        mel_tensor = torch.tensor(mel_db).float().T 
-        
-        current_frames = mel_tensor.shape[0]
-        if current_frames < self.target_frames:
-            padding_needed = self.target_frames - current_frames
-            mel_tensor = torch.nn.functional.pad(mel_tensor, (0, 0, 0, padding_needed))
-        else:
-            mel_tensor = mel_tensor[:self.target_frames, :]
-            
-        return mel_tensor, filename
-test_df = pd.read_csv('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/test.csv')
-
-test_data = ASTTestDataset(test_df)
-
-test_loader = DataLoader(
-    dataset=test_data,
-    batch_size=4, 
-    shuffle=False, 
-    num_workers=2,
-    pin_memory=True if device == 'cuda' else False
-)
-
-# Prediction loop for test set
-def predict(model_instance, model_path):
-    model = model_instance.to(device)
-    model.load_state_dict(torch.load(model_path))
-    model.eval()
-
-    genre_pred = []
-    for mel_specs,_ in test_loader:
-        mel_specs = mel_specs.to(device)
-        if mel_specs.dim() == 4:
-            mel_specs = mel_specs.squeeze(1)
-            
-        with torch.no_grad():
-            outputs = model(mel_specs).logits
-            preds = torch.argmax(outputs, dim=1).cpu().numpy()
-            genre_pred.extend(preds.tolist())
-    final_result = [id_to_genre[g] for g in genre_pred]
-    return final_result
-
-res = predict(MusicGenreAST(10), '/kaggle/input/models/bhavin273/ast-audio-model/pytorch/default/1/best_ast_model.pth')

CRNN_pipeline.py

@@ -1,366 +0,0 @@
-import os
-import glob
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-import librosa
-import librosa.display
-import matplotlib.pyplot as plt
-import random
-import torch
-import wandb
-from torchsummary import summary
-from torch.utils.data.dataset import Dataset
-from torch.utils.data import DataLoader
-from torch.optim.lr_scheduler import ReduceLROnPlateau
-from transformers import ASTForAudioClassification, ASTConfig
-import torch.nn as nn
-from sklearn.model_selection import StratifiedShuffleSplit
-from collections import Counter
-import seaborn as sns
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.metrics import f1_score
-import warnings
-warnings.filterwarnings("ignore")
-
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-print(f"Is GPU available? {torch.cuda.is_available()}")
-print(f"Current device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}")
-
-DATA_SEED = 67
-TRAINING_SEED = 1234
-SR = 22050
-DURATION = 5.0
-N_FFT = 2048
-HOP_LENGTH = 512
-N_MELS = 128
-TOP_DB=20
-TARGET_SNR_DB = 10
-
-random.seed(DATA_SEED)
-np.random.seed(DATA_SEED)
-torch.manual_seed(DATA_SEED)
-torch.cuda.manual_seed(DATA_SEED)
-
-DATA_ROOT = '/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/genres_stems'
-GENRES = [] # Make the list of all genres available
-for genre in os.listdir(path=DATA_ROOT):
-  GENRES.append(genre)
-display(GENRES)
-
-STEMS = {} # Write here stems file name
-STEM_KEYS = ['drums', 'vocals', 'bass', 'other']
-GENRE_TO_TEST = 'rock'
-SONG_INDEX = 0
-genre_to_id = {genre: i for i, genre in enumerate(GENRES)}
-id_to_genre = {i: genre for i, genre in enumerate(GENRES)}
-
-
-# Function to build the dataset by splitting the songs into train and validation sets, and then creating a dictionary with genre as key and stem types as sub-keys containing the list of file paths for each stem type.
-def build_dataset(root_dir, val_split=0.17, seed=42):
-    train_dataset = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    val_dataset   = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    rows = []
-    for genre in GENRES:
-      genre_path = os.path.join(root_dir, genre)
-      for song in os.listdir(genre_path):
-        rows.append({
-            "label" : genre,
-            "song" : song
-        })
-    df = pd.DataFrame(rows)
-    X = df['song']
-    y = df['label']
-
-    sss = StratifiedShuffleSplit(n_splits=1, test_size=val_split, random_state=seed)
-
-    for train_index, val_index in sss.split(X, y):
-        train_df = df.iloc[train_index].reset_index(drop=True)
-        val_df = df.iloc[val_index].reset_index(drop=True)
-
-    for idx, row in train_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          train_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-
-    for idx, row in val_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          val_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-    return train_dataset, val_dataset
-
-tr, val = build_dataset(DATA_ROOT)
-
-# Example of how the dataset is structured
-class audioDataset (Dataset):
-  def __init__ (self, data_dict, length, genres, stem_types, noise_files, sr=SR, duration=DURATION, n_fft=N_FFT, hop_length=HOP_LENGTH, n_mels=N_MELS):
-    self.data_dict = data_dict
-    self.sr = sr
-    self.genres = genres
-    self.stem_types = stem_types
-    self.duration = duration
-    self.n_fft = n_fft
-    self.hop_length = hop_length
-    self.n_mels = n_mels
-    self.noise_files = noise_files
-    self.length = length
-
-  def __len__(self):
-    return self.length
-
-  def __getitem__(self, idx, retries = 0):
-    if retries > 10:
-          idx = random.randint(0, self.length-1)
-          return self.__getitem__(idx, 0)
-    genre = random.choice(self.genres)
-    start_time = random.uniform(0, 24)
-    target_len = int(22050 * 5.0)
-    stems_data = []
-    
-    for stem_type in self.stem_types:
-        path = random.choice(self.data_dict[genre][stem_type])
-        y, _ = librosa.load(path, sr=22050, offset=start_time, duration=self.duration)
-        y = librosa.util.fix_length(y, size=target_len)
-        rms = np.sqrt(np.mean(y**2))
-        if rms < 0.001:
-          return self.__getitem__(idx, retries + 1)
-        stems_data.append(y)
-    mix = np.sum(stems_data, axis=0) / 4.0
-    if np.max(np.abs(mix)) > 0:
-        mix = mix / np.max(np.abs(mix))
-
-    noise_path = random.choice(self.noise_files)
-    noise_y, _ = librosa.load(noise_path, sr=22050, offset=start_time, duration=self.duration)
-    noise_y = librosa.util.fix_length(noise_y, size=target_len)
-
-    p_signal = np.mean(mix**2) + 1e-9
-    p_noise = np.mean(noise_y**2) + 1e-9
-    target_noise_power = p_signal / 10.0
-    scaling_factor = np.sqrt(target_noise_power / p_noise)
-
-    final_audio = mix + (scaling_factor * noise_y)
-
-    mfcc = librosa.feature.mfcc(
-      y=final_audio, 
-      sr=self.sr, 
-      n_mfcc=40, 
-      n_fft=self.n_fft, 
-      hop_length=self.hop_length, 
-      n_mels=self.n_mels
-    )
-
-    mfcc_db = librosa.power_to_db(mfcc, ref=np.max)  
-    return torch.tensor(mfcc_db).float().unsqueeze(0), genre_to_id[genre]  #shape(1, 40, 216)
-  
-noise_files_list = [os.path.join('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/ESC-50-master/audio', f) 
-                    for f in os.listdir('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/ESC-50-master/audio') if f.endswith('.wav')]
-
-train_ds = audioDataset(tr, 1000, GENRES, STEM_KEYS, noise_files_list)
-val_ds = audioDataset(val, 200, GENRES, STEM_KEYS, noise_files_list)
-
-train_loader = DataLoader(dataset=train_ds,
-                          batch_size=32,
-                          shuffle=True,
-                          num_workers=2,
-                          pin_memory=True if device == 'cuda' else False)
-
-val_loader = DataLoader(dataset=val_ds,
-                        batch_size=32,
-                        shuffle=False,
-                        num_workers=2,
-                        pin_memory=True if device == 'cuda' else False)
-
-#Model architecture with 3 convolutional layers followed by a GRU layer and a fully connected layer for genre classification. The convolutional layers extract features from the input MFCCs, while the GRU layer captures temporal dependencies in the features. The final fully connected layer outputs the genre predictions.
-class audioCRNN(nn.Module):
-  def __init__(self):
-    super(audioCRNN, self).__init__()
-    
-    self.conv1 = nn.Sequential(
-        nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
-        nn.BatchNorm2d(32),
-        nn.ReLU(),
-        nn.MaxPool2d(kernel_size=2)
-    )   # Output Shape (32, 32, 20, 108) 
-
-    self.conv2 = nn.Sequential(
-        nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
-        nn.BatchNorm2d(64),
-        nn.ReLU(),
-        nn.MaxPool2d(kernel_size=(2,1))
-    )   # Output Shape (32, 64, 10, 108)
-
-    self.conv3 = nn.Sequential(
-        nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
-        nn.BatchNorm2d(128),
-        nn.ReLU(),
-        nn.MaxPool2d(kernel_size=(2,1))
-    )   # Output Shape (32, 128, 5, 108)
-
-    self.gru = nn.GRU(input_size=128 * 5, hidden_size=128, 
-                          num_layers=2, batch_first=True, 
-                          bidirectional=True, dropout=0.3)    # Ouput size (32, 108, 256)
-
-    self.genre_head = nn.Linear(256, 10)
-
-
-  def forward (self, x):
-    x = self.conv1(x)
-    x = self.conv2(x)
-    x = self.conv3(x)
-    x = x.permute (0, 3, 1, 2)
-    batch, time, channels, mels = x.size()
-    x = x.contiguous().view(batch, time, channels*mels)
-    x, _ = self.gru(x)
-    x = x[:, -1, :]
-
-    return self.genre_head(x)
-
-
-model = audioCRNN().to(device)  # Printing Model Summary
-summary(model, (1, 40, 216))
-
-#The training fn
-def train_epoch (train_batch, audioCRNN, optimizer, criterion):
-  audioCRNN.train()  #Sets model in train Mode
-  mel_freq, genre_id = train_batch
-  mel_freq, genre_id = mel_freq.to(device), genre_id.to(device)
-  optimizer.zero_grad()  #Initializes the gradients to zero
-  genre_output = audioCRNN(mel_freq)
-  genre_loss = criterion(genre_output, genre_id)   
-  genre_loss.backward()   #Back propagation
-  optimizer.step()    #Weights are adjusted
-
-  return genre_loss.item()
-
-#The validation fn
-def validate_epoch (validation_batch, audioCRNN, criterion):
-  audioCRNN.eval()  # Runs Model in evaluation mode
-  mel_freq, genre_id = validation_batch
-  mel_freq, genre_id = mel_freq.to(device), genre_id.to(device)
-  with torch.no_grad():   #Gradients disabled
-    genre_output = audioCRNN(mel_freq)
-    genre_loss = criterion(genre_output, genre_id)
-    genre_pred = torch.softmax(genre_output, dim=1)
-    genre_pred = torch.argmax(genre_pred, dim=1).cpu().numpy() # Gender prediction with softmax followed by argmax
-  return genre_loss.item(), genre_pred
-
-#The training loop
-def train (audioCRNN):
-    num_epochs = 17
-    patience_counter = 0
-    patience_limit = 5
-    best_score = float('-inf')
-    model = audioCRNN.to(device)
-    optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)
-    # scheduler to adjust the optimizer in case the curve flattens
-    scheduler = ReduceLROnPlateau(optimizer=optimizer, mode='max', factor=0.5, patience=2, min_lr=1e-6)
-    criterion = nn.CrossEntropyLoss()
-
-    for epoch in range (num_epochs):
-      tot_train_loss = 0
-      # Training loop
-      for mel_freq, genre_id in train_loader:
-        train_loss = train_epoch((mel_freq, genre_id), model, optimizer, criterion)
-        tot_train_loss += train_loss * mel_freq.size(0)   # Batch mean loss multiplied by batch size for total batch loss
-      epoch_train_loss = tot_train_loss/len(train_loader.dataset)  # Total Train loss per epoch
-      tot_val_loss = 0
-      genre_pred_tot = []
-      genre_true_tot = []
-      # Validation loop
-      for mel_freq, genre_id in val_loader:
-        genre_true_tot.extend(genre_id.cpu().numpy())
-        val_loss, genre_pred = validate_epoch((mel_freq, genre_id), model, criterion)
-        genre_pred_tot.extend(genre_pred)
-        tot_val_loss += val_loss * mel_freq.size(0)
-      epoch_validate_loss = tot_val_loss/len(val_loader.dataset)
-      genre_score = f1_score(y_true=genre_true_tot, y_pred=genre_pred_tot, average='macro') # f1 macro for evaluating the genre score
-      current_lr = optimizer.param_groups[0]['lr']
-  
-
-      print(f'Epoch {epoch+1}/{num_epochs}')
-      print(f'Train Loss : {epoch_train_loss:.4f} | Validation Loss : {epoch_validate_loss:.4f}')
-      print(f'Score : {genre_score:.4f}')
-      print(f'Current learning Rate is : {current_lr:.6f}\n')
-
-      wandb.log({
-        "epoch": epoch + 1,
-        "train_loss": epoch_train_loss,
-        "val_loss": epoch_validate_loss,
-        "score": genre_score,
-        "learning_rate": current_lr
-      })
-
-        
-      scheduler.step(genre_score)
-      if genre_score > best_score:
-        patience_counter = 0
-        best_score = genre_score
-        torch.save(model.state_dict(), 'best_finetuned_model.pth')   # save model
-      else:
-        patience_counter += 1
-  
-      if patience_counter >= patience_limit:
-        print('-----Early Stopping------')
-        break
-    wandb.finish()
-
-train(audioCRNN())
-
-test_df = pd.read_csv('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/test.csv')
-
-class TestDataSet (Dataset):
-    def __init__ (self, test_df):
-        self.data = test_df
-
-    def __len__(self):
-        return len (self.data)
-
-    def __getitem__(self, idx):
-        target_len = int(22050 * 5.0)
-        path = os.path.join('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup', self.data.iloc[idx]['filename'])
-        y, _ = librosa.load(path, sr=22050, offset=0, duration=5.0)
-        y = librosa.util.fix_length(y, size=target_len)
-        if np.max(np.abs(y)) > 0:
-            y = y / np.max(np.abs(y))
-        mfcc = librosa.feature.mfcc(
-                  y=y,
-                  sr=22050,
-                  n_mfcc=40,
-                  n_fft=2048,
-                  hop_length=512,
-                  n_mels=128
-                )
-
-        mfcc_db = librosa.power_to_db(mfcc, ref=np.max)
-        return torch.tensor(mfcc_db).float().unsqueeze(0)
-
-
-test_data = TestDataSet(test_df)
-
-test_loader = DataLoader(dataset=test_data,
-                        batch_size=32,
-                        num_workers=2,
-                        pin_memory=True if device == 'cuda' else False)
-
-genre_pred = []
-def predict (model_name, model_path):
-    model = model_name.to(device)
-    model.load_state_dict(torch.load(model_path))
-
-    model.eval()
-
-    for mfccs in test_loader:
-        mfccs = mfccs.to(device)
-        with torch.no_grad():
-            genre_id = model (mfccs).logits
-            genre_out = torch.softmax(genre_id, dim=1)
-            genre_out = torch.argmax(genre_out, dim=1).cpu().numpy()
-            genre_pred.extend(genre_out.tolist())
-    final_result = [id_to_genre[g] for g in genre_pred]
-    return final_result
-
-res = predict (audioCRNN(), '/kaggle/input/models/bhavin273/crnn-model/pytorch/default/1/best_crnnModel.pth')

Efficient_Net_Pipeline.py

@@ -1,326 +0,0 @@
-import os
-import glob
-from networkx import display
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-import librosa
-import librosa.display
-import matplotlib.pyplot as plt
-import random
-import torch
-import timm
-import wandb
-from torchsummary import summary
-from torch.utils.data.dataset import Dataset
-from torch.utils.data import DataLoader
-from torch.optim.lr_scheduler import ReduceLROnPlateau
-from transformers import ASTForAudioClassification, ASTConfig
-import torch.nn as nn
-from sklearn.model_selection import StratifiedShuffleSplit
-from collections import Counter
-import seaborn as sns
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.metrics import f1_score
-import warnings
-warnings.filterwarnings("ignore")
-
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-print(f"Is GPU available? {torch.cuda.is_available()}")
-print(f"Current device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}")
-
-DATA_SEED = 67
-TRAINING_SEED = 1234
-SR = 22050
-DURATION = 5.0
-N_FFT = 2048
-HOP_LENGTH = 512
-N_MELS = 128
-TOP_DB=20
-TARGET_SNR_DB = 10
-
-random.seed(DATA_SEED)
-np.random.seed(DATA_SEED)
-torch.manual_seed(DATA_SEED)
-torch.cuda.manual_seed(DATA_SEED)
-
-DATA_ROOT = '/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/genres_stems'
-GENRES = [] # Make the list of all genres available
-for genre in os.listdir(path=DATA_ROOT):
-  GENRES.append(genre)
-display(GENRES)
-STEMS = {} # Write here stems file name
-STEM_KEYS = ['drums', 'vocals', 'bass', 'other']
-GENRE_TO_TEST = 'rock'
-SONG_INDEX = 0
-genre_to_id = {genre: i for i, genre in enumerate(GENRES)}
-id_to_genre = {i: genre for i, genre in enumerate(GENRES)}
-
-# Build the dataset in the format {genre: {stem_type: [file_paths]}}
-def build_dataset(root_dir, val_split=0.17, seed=42):
-    train_dataset = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    val_dataset   = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    rows = []
-    for genre in GENRES:
-      genre_path = os.path.join(root_dir, genre)
-      for song in os.listdir(genre_path):
-        rows.append({
-            "label" : genre,
-            "song" : song
-        })
-    df = pd.DataFrame(rows)
-    X = df['song']
-    y = df['label']
-
-    sss = StratifiedShuffleSplit(n_splits=1, test_size=val_split, random_state=seed)
-
-    for train_index, val_index in sss.split(X, y):
-        train_df = df.iloc[train_index].reset_index(drop=True)
-        val_df = df.iloc[val_index].reset_index(drop=True)
-
-    for idx, row in train_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          train_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-
-    for idx, row in val_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          val_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-    return train_dataset, val_dataset
-
-tr, val = build_dataset(DATA_ROOT)
-
-
-
-AST_SR = 16000
-AST_TARGET_FRAMES = 1024
-
-# A custom Dataset class that will handle the loading of audio files, applying random augmentations, and generating the mel spectrograms on-the-fly during training and validation.
-class audioDataset (Dataset):
-  def __init__ (self, data_dict, length, genres, stem_types, noise_files, sr=SR, duration=DURATION, n_fft=N_FFT, hop_length=HOP_LENGTH, n_mels=N_MELS):
-    self.data_dict = data_dict
-    self.sr = sr
-    self.genres = genres
-    self.stem_types = stem_types
-    self.duration = duration
-    self.n_fft = n_fft
-    self.hop_length = hop_length
-    self.n_mels = n_mels
-    self.noise_files = noise_files
-    self.length = length
-  def __len__(self):
-    return self.length
-  def __getitem__(self, idx, retries = 0):
-    if retries > 10:
-          idx = random.randint(0, self.length-1)
-          return self.__getitem__(idx, 0)
-    genre = random.choice(self.genres)
-    start_time = random.uniform(0, 24)
-    target_len = int(22050 * 5.0)
-    stems_data = []
-    for stem_type in self.stem_types:
-        path = random.choice(self.data_dict[genre][stem_type])
-        y, _ = librosa.load(path, sr=22050, offset=start_time, duration=self.duration)
-        y = librosa.util.fix_length(y, size=target_len)
-        rms = np.sqrt(np.mean(y**2))
-        if rms < 0.001:
-          return self.__getitem__(idx, retries + 1)
-        stems_data.append(y)
-    mix = np.sum(stems_data, axis=0) / 4.0
-    if np.max(np.abs(mix)) > 0:
-        mix = mix / np.max(np.abs(mix))
-    noise_path = random.choice(self.noise_files)
-    noise_y, _ = librosa.load(noise_path, sr=22050, offset=start_time, duration=self.duration)
-    noise_y = librosa.util.fix_length(noise_y, size=target_len)
-    p_signal = np.mean(mix**2) + 1e-9
-    p_noise = np.mean(noise_y**2) + 1e-9
-    target_noise_power = p_signal / 10.0
-    scaling_factor = np.sqrt(target_noise_power / p_noise)
-    final_audio = mix + (scaling_factor * noise_y)
-    mfcc = librosa.feature.mfcc(
-      y=final_audio,
-      sr=self.sr,
-      n_fft=self.n_fft,
-      hop_length=self.hop_length,
-      n_mels=self.n_mels
-    )
-    mfcc_db = librosa.power_to_db(mfcc, ref=np.max)
-    return torch.tensor(mfcc_db).float().unsqueeze(0), genre_to_id[genre]  #shape(1, 128, 216)
-
-noise_files_list = [os.path.join('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/ESC-50-master/audio', f) 
-                    for f in os.listdir('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/ESC-50-master/audio') if f.endswith('.wav')]
-    
-train_ds = audioDataset(tr, 1000, GENRES, STEM_KEYS, noise_files_list)
-val_ds = audioDataset(val, 200, GENRES, STEM_KEYS, noise_files_list)
-
-train_loader = DataLoader(dataset=train_ds,
-                          batch_size=32,
-                          shuffle=True,
-                          num_workers=2,
-                          pin_memory=True if device == 'cuda' else False)
-
-val_loader = DataLoader(dataset=val_ds,
-                        batch_size=32,
-                        shuffle=False,
-                        num_workers=2,
-                        pin_memory=True if device == 'cuda' else False)
-
-# Loading pre trained model
-class EfficientNetAudio(nn.Module):
-    def __init__(self, num_classes=10, model_name='efficientnet_b0'):
-        super(EfficientNetAudio, self).__init__()
-        self.model = timm.create_model(
-            model_name, 
-            pretrained=True, 
-            in_chans=1, 
-            num_classes=num_classes
-        )
-
-    def forward(self, x):
-        return self.model(x)
-
-def train_epoch (train_batch, EffNet, optimizer, criterion):
-  EffNet.train()  #Sets model in train Mode
-  mel_freq, genre_id = train_batch
-  mel_freq, genre_id = mel_freq.to(device), genre_id.to(device)
-  optimizer.zero_grad()  #Initializes the gradients to zero
-  genre_output = EffNet(mel_freq)
-  genre_loss = criterion(genre_output, genre_id)
-  genre_loss.backward()   #Back propagation
-  optimizer.step()    #Weights are adjusted
-
-  return genre_loss.item()
-
-def validate_epoch (validation_batch, EffNet, criterion):
-  EffNet.eval()  # Runs Model in evaluation mode
-  mel_freq, genre_id = validation_batch
-  mel_freq, genre_id = mel_freq.to(device), genre_id.to(device)
-  with torch.no_grad():   #Gradients disabled
-    genre_output = EffNet(mel_freq)
-    genre_loss = criterion(genre_output, genre_id)
-    genre_pred = torch.softmax(genre_output, dim=1)
-    genre_pred = torch.argmax(genre_pred, dim=1).cpu().numpy() # Gender prediction with softmax followed by argmax
-  return genre_loss.item(), genre_pred
-
-
-#Train loop
-def train (audioCRNN):
-    num_epochs = 20
-    patience_counter = 0
-    patience_limit = 5
-    best_score = float('-inf')
-    model = audioCRNN.to(device)
-    optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)
-    # scheduler to adjust the optimizer in case the curve flattens
-    scheduler = ReduceLROnPlateau(optimizer=optimizer, mode='max', factor=0.5, patience=2, min_lr=1e-6)
-    criterion = nn.CrossEntropyLoss()
-
-    for epoch in range (num_epochs):
-      tot_train_loss = 0
-      # Training loop
-      for mel_freq, genre_id in train_loader:
-        train_loss = train_epoch((mel_freq, genre_id), model, optimizer, criterion)
-        tot_train_loss += train_loss * mel_freq.size(0)   # Batch mean loss multiplied by batch size for total batch loss
-      epoch_train_loss = tot_train_loss/len(train_loader.dataset)  # Total Train loss per epoch
-      tot_val_loss = 0
-      genre_pred_tot = []
-      genre_true_tot = []
-      # Validation loop
-      for mel_freq, genre_id in val_loader:
-        genre_true_tot.extend(genre_id.cpu().numpy())
-        val_loss, genre_pred = validate_epoch((mel_freq, genre_id), model, criterion)
-        genre_pred_tot.extend(genre_pred)
-        tot_val_loss += val_loss * mel_freq.size(0)
-      epoch_validate_loss = tot_val_loss/len(val_loader.dataset)
-      genre_score = f1_score(y_true=genre_true_tot, y_pred=genre_pred_tot, average='macro') # f1 macro for evaluating the genre score
-      current_lr = optimizer.param_groups[0]['lr']
-
-
-      print(f'Epoch {epoch+1}/{num_epochs}')
-      print(f'Train Loss : {epoch_train_loss:.4f} | Validation Loss : {epoch_validate_loss:.4f}')
-      print(f'Score : {genre_score:.4f}')
-      print(f'Current learning Rate is : {current_lr:.6f}\n')
-
-      wandb.log({
-           "epoch": epoch + 1,
-            "train_loss": epoch_train_loss,
-            "val_loss": epoch_validate_loss,
-            "score": genre_score,
-            "learning_rate": current_lr
-        })
-
-
-      scheduler.step(genre_score)
-      if genre_score > best_score:
-        patience_counter = 0
-        best_score = genre_score
-        torch.save(model.state_dict(), 'best_efficientnet_model.pth')   # save model
-      else:
-        patience_counter += 1
-
-      if patience_counter >= patience_limit:
-        print('-----Early Stopping------')
-        break
-
-train(EfficientNetAudio())
-
-# Prediction dataset for test set
-test_df = pd.read_csv('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup/test.csv')
-
-class TestDataSet (Dataset):
-    def __init__ (self, test_df):
-        self.data = test_df
-
-    def __len__(self):
-        return len (self.data)
-
-    def __getitem__(self, idx):
-        target_len = int(22050 * 5.0)
-        path = os.path.join('/kaggle/input/jan-2026-dl-gen-ai-project/messy_mashup', self.data.iloc[idx]['filename'])
-        y, _ = librosa.load(path, sr=22050, offset=0, duration=5.0)
-        y = librosa.util.fix_length(y, size=target_len)
-        if np.max(np.abs(y)) > 0:
-            y = y / np.max(np.abs(y))
-        mfcc = librosa.feature.mfcc(
-                  y=y,
-                  sr=22050,
-                  n_fft=2048,
-                  hop_length=512,
-                  n_mels=128
-                )
-
-        mfcc_db = librosa.power_to_db(mfcc, ref=np.max)
-        return torch.tensor(mfcc_db).float().unsqueeze(0)
-
-
-test_data = TestDataSet(test_df)
-
-test_loader = DataLoader(dataset=test_data,
-                        batch_size=32,
-                        num_workers=2,
-                        pin_memory=True if device == 'cuda' else False)
-
-# Prediction loop for test set
-genre_pred = []
-def predict (model_name, model_path):
-    model = model_name.to(device)
-    model.load_state_dict(torch.load(model_path))
-
-    model.eval()
-
-    for mfccs in test_loader:
-        mfccs = mfccs.to(device)
-        with torch.no_grad():
-            genre_id = model (mfccs)
-            genre_out = torch.softmax(genre_id, dim=1)
-            genre_out = torch.argmax(genre_out, dim=1).cpu().numpy()
-            genre_pred.extend(genre_out.tolist())
-    final_result = [id_to_genre[g] for g in genre_pred]
-    return final_result
-
-res = predict (EfficientNetAudio(), '/kaggle/input/models/bhavin273/efficientnet-model/pytorch/default/1/best_efficientnet_model.pth')

README.md

@@ -1,247 +0,0 @@
-# Music Genre Classification from Audio
-
-A deep learning project for classifying audio tracks into **10 music genres** using the **messy_mashup** dataset from the Kaggle competition (`jan-2026-dl-gen-ai-project`). Three model architectures are explored: a scratch-built CRNN, a pretrained EfficientNet-B0, and a fine-tuned Audio Spectrogram Transformer (AST) — with AST achieving the best leaderboard score of **0.857**.
-
----
-
-## Table of Contents
-
-- [Project Overview](#project-overview)
-- [Dataset](#dataset)
-- [Project Structure](#project-structure)
-- [Installation](#installation)
-- [Preprocessing Pipeline](#preprocessing-pipeline)
-- [Models](#models)
-  - [Model 1: CRNN (CNN + Bidirectional GRU)](#model-1-crnn-cnn--bidirectional-gru)
-  - [Model 2: Audio Spectrogram Transformer (AST)](#model-2-audio-spectrogram-transformer-ast)
-  - [Model 3: EfficientNet-B0](#model-3-efficientnet-b0)
-- [Training](#training)
-- [Results](#results)
-- [Usage](#usage)
-- [Acknowledgements](#acknowledgements)
-
----
-
-## Project Overview
-
-The goal is to predict the genre of a music track from its raw audio waveform. The audio data consists of separated stems (drums, vocals, bass, other) per song, which are mixed together with environmental noise augmentation to simulate real-world conditions. Three progressively more powerful model architectures are trained and compared.
-
----
-
-## Dataset
-
-| Property | Details |
-|----------|---------|
-| **Name** | messy_mashup |
-| **Genres (10)** | blues, classical, country, disco, hiphop, jazz, metal, pop, reggae, rock |
-| **Stems per song** | `drums`, `vocals`, `bass`, `other` |
-| **Noise source** | ESC-50 environmental sound dataset |
-| **Train/Val split** | 83% / 17% (Stratified Shuffle Split, seed=42) |
-
-### Data Organization
-
-```
-genres_stems/
-├── blues/
-│   ├── song_001/
-│   │   ├── drums.wav
-│   │   ├── vocals.wav
-│   │   ├── bass.wav
-│   │   └── other.wav
-│   └── ...
-├── classical/
-│   └── ...
-└── ...
-```
-
----
-
-## Project Structure
-
-```
-├── dl-23f3002677-notebook-t12026.ipynb   # Main Kaggle notebook (all models + submission)
-├── CRNN_pipeline.py                      # Standalone CRNN model pipeline
-├── AST_Pipeline.py                       # Standalone AST model pipeline
-├── Efficient_Net_Pipeline.py             # Standalone EfficientNet model pipeline
-├── milestone1.py                         # Milestone 1 — EDA & audio preprocessing
-├── milestone_2.py                        # Milestone 2 — Feature extraction & baseline
-├── best_ast_model.pth                    # Saved AST model weights
-├── requirements.txt                      # Python dependencies
-└── README.md
-```
-
-### File Descriptions
-
-| File | Purpose |
-|------|---------|
-| **dl-23f3002677-notebook-t12026.ipynb** | End-to-end notebook: data visualization, dataset building, all 3 model architectures (train + predict), performance comparison, and final submission generation |
-| **milestone1.py** | Data exploration — builds train/val split, detects silence segments in stems |
-| **milestone_2.py** | Feature engineering (tempo, spectral centroid, ZCR, rolloff) + Decision Tree baseline classifier |
-| **CRNN_pipeline.py** | CRNN model definition, dataset, training loop, and prediction |
-| **AST_Pipeline.py** | Audio Spectrogram Transformer pipeline with HuggingFace pretrained model |
-| **Efficient_Net_Pipeline.py** | EfficientNet-B0 pipeline using `timm` pretrained model |
-
----
-
-## Installation
-
-```bash
-pip install -r requirements.txt
-```
-
-### Dependencies
-
-- **numpy** — numerical computation
-- **pandas** — data manipulation
-- **librosa** — audio loading & feature extraction
-- **torch** / **torchaudio** — deep learning framework
-- **torchsummary** — model architecture summaries
-- **transformers** — HuggingFace pretrained AST model
-- **timm** — pretrained EfficientNet-B0
-- **scikit-learn** — stratified splitting, F1 scoring, Decision Tree baseline
-- **matplotlib** / **seaborn** — visualization
-- **wandb** — experiment tracking
-- **soundfile** — audio I/O
-- **tqdm** — progress bars
-
----
-
-## Preprocessing Pipeline
-
-### Audio Mixing
-
-1. **Stem selection**: For each sample, randomly select a genre and load stems (drums, vocals, bass, other) from a random song at a random offset
-2. **Mixing**: Sum all stem waveforms together and peak-normalize the mix
-3. **Noise injection**: Add a random ESC-50 environmental sound clip, scaled to a target SNR
-
-### Feature Extraction
-
-| Model | Feature | Sample Rate | Duration | Output Shape |
-|-------|---------|-------------|----------|-------------|
-| CRNN | 40 MFCCs → power_to_dB | 22,050 Hz | 5s | `(1, 40, 216)` |
-| EfficientNet | 128 MFCCs → power_to_dB | 22,050 Hz | 5s | `(1, 128, 216)` |
-| AST | 128-mel spectrogram → power_to_dB → normalized | 16,000 Hz | 10s | `(1024, 128)` |
-
-### AST-Specific Augmentations
-
-- **Stem dropout**: 15% chance of skipping each stem type
-- **Random gain**: Each stem scaled by a random factor in [0.4, 1.2]
-- **Variable SNR**: Noise scaling divisor randomized between 2.0 and 8.0
-- **Normalization**: `(mel_dB + 4.26) / 4.56`
-
----
-
-## Models
-
-### Model 1: CRNN (CNN + Bidirectional GRU)
-
-A scratch-built architecture combining convolutional feature extraction with recurrent temporal modeling.
-
-```
-Input (1, 40, 216)
-  → Conv2d(1→32) + BatchNorm + ReLU + MaxPool(2×2)      → (32, 20, 108)
-  → Conv2d(32→64) + BatchNorm + ReLU + MaxPool(2×1)     → (64, 10, 108)
-  → Conv2d(64→128) + BatchNorm + ReLU + MaxPool(2×1)    → (128, 5, 108)
-  → Reshape to (108, 640)
-  → Bidirectional GRU (hidden=128, 2 layers, dropout=0.3) → (108, 256)
-  → Last timestep → Linear(256→10)
-```
-
-### Model 2: Audio Spectrogram Transformer (AST)
-
-Fine-tuned from the pretrained [`MIT/ast-finetuned-audioset-10-10-0.4593`](https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593) checkpoint via HuggingFace Transformers. The classification head is replaced with a 10-class output layer.
-
-### Model 3: EfficientNet-B0
-
-Pretrained EfficientNet-B0 loaded via `timm` with `in_chans=1` (single-channel MFCC input) and `num_classes=10`.
-
----
-
-## Training
-
-### Hyperparameters
-
-| Parameter | CRNN | AST | EfficientNet |
-|-----------|------|-----|-------------|
-| **Optimizer** | Adam | AdamW | Adam |
-| **Learning rate** | 1e-3 | 1e-5 | 1e-3 |
-| **Weight decay** | 1e-5 | 0.01 | 1e-5 |
-| **Batch size** | 32 | 4 | 32 |
-| **Max epochs** | 17 | 15 | 20 |
-| **Early stopping patience** | 5 | 7 | 5 |
-| **Gradient accumulation** | — | 4 steps | — |
-| **Scheduler** | ReduceLROnPlateau | ReduceLROnPlateau | ReduceLROnPlateau |
-| **Loss function** | CrossEntropyLoss | CrossEntropyLoss | CrossEntropyLoss |
-| **Train samples** | 1,000 | 1,000 | 1,000 |
-| **Val samples** | 200 | 500 | 200 |
-
-### Experiment Tracking
-
-All training runs are logged to [Weights & Biases (WandB)](https://wandb.ai/) with metrics for train loss, validation loss, F1 score, and learning rate per epoch.
-
----
-
-## Results
-
-| Model | Max F1 (Validation) | Kaggle Leaderboard Score |
-|-------|:-------------------:|:------------------------:|
-| CRNN (scratch) | 0.5800 | 0.33103 |
-| EfficientNet-B0 | 0.5258 | 0.31641 |
-| **Audio Spectrogram Transformer** | **0.8861** | **0.85708** |
-
-The **AST model** significantly outperforms the other two, achieving nearly **0.86 on the leaderboard** — a 2.5× improvement over the CNN-based models. Key factors behind its success:
-
-- **Pretrained on AudioSet**: Large-scale audio pretraining provides strong feature representations
-- **Longer input duration**: 10s vs 5s captures more musical context
-- **Mel spectrogram input**: Richer frequency representation compared to MFCCs
-- **Stronger augmentation**: Stem dropout, variable gain, and variable SNR improve robustness
-
----
-
-## Usage
-
-### Training (in Kaggle notebook)
-
-1. Set up the dataset paths in the notebook
-2. Uncomment the training cell for the desired model:
-   ```python
-   # CRNN
-   train(audioCRNN())
-
-   # AST
-   train_ast(MusicGenreAST(10))
-
-   # EfficientNet
-   train(EfficientNetAudio())
-   ```
-
-### Prediction
-
-```python
-# AST (best model)
-res = predict(MusicGenreAST(10), 'best_ast_model.pth')
-
-# CRNN
-res = predict(audioCRNN(), 'best_crnnModel.pth')
-
-# EfficientNet
-res = predict(EfficientNetAudio(), 'best_efficientnet_model.pth')
-```
-
-### Generating Submission
-
-```python
-submission_df = pd.read_csv('sample_submission.csv')
-submission = pd.DataFrame({"id": submission_df['id'], "genre": res})
-submission.to_csv("submission.csv", index=False)
-```
-
----
-
-## Acknowledgements
-
-- [MIT AST](https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593) — pretrained Audio Spectrogram Transformer
-- [ESC-50](https://github.com/karolpiczak/ESC-50) — environmental sound dataset used for noise augmentation
-- [timm](https://github.com/huggingface/pytorch-image-models) — PyTorch Image Models library
-- [Weights & Biases](https://wandb.ai/) — experiment tracking
-- [librosa](https://librosa.org/) — audio analysis library

milestone1.py

@@ -1,232 +0,0 @@
-# -*- coding: utf-8 -*-
-"""MileStone1.ipynb
-
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/drive/1X-yYuntHy5LGU1wh8QNz1rTO1geAS-qh
-"""
-
-import os
-import glob
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-import librosa
-import librosa.display
-import matplotlib.pyplot as plt
-import random
-import torch
-from sklearn.model_selection import StratifiedShuffleSplit
-from google.colab import drive
-from collections import Counter
-
-import warnings
-warnings.filterwarnings("ignore")
-
-drive.mount('/content/drive')
-
-
-drive_zip = '/content/drive/MyDrive/jan-2026-dl-gen-ai-project.zip'
-local_zip = '/content/data.zip'
-extract_to = '/content/dataset'
-
-if not os.path.exists(extract_to):
-    print("Moving 16 GB from Drive to local SSD...")
-    !rsync -ah --progress "{drive_zip}" "{local_zip}"
-
-    print("Unzipping 25GB... (This will take a few minutes)")
-    !unzip -q "{local_zip}" -d "{extract_to}"
-
-    print("Deleting zip to save space...")
-    os.remove(local_zip)
-    print("Ready! Data is in /content/dataset")
-else:
-    print("Data already exists.")
-
-DATA_SEED = 67
-TRAINING_SEED = 1234
-SR = 22050
-DURATION = 5.0
-N_FFT = 2048
-HOP_LENGTH = 512
-N_MELS = 128
-TOP_DB=20
-TARGET_SNR_DB = 10
-
-random.seed(DATA_SEED)
-np.random.seed(DATA_SEED)
-torch.manual_seed(DATA_SEED)
-torch.cuda.manual_seed(DATA_SEED)
-
-# CONFIGURATION
-DATA_ROOT = '/content/dataset/messy_mashup/genres_stems'
-GENRES = [] # Make the list of all genres available
-for genre in os.listdir(path=DATA_ROOT):
-  GENRES.append(genre)
-display(GENRES)
-STEMS = {} # Write here stems file name
-STEM_KEYS = ['drums', 'vocals', 'bass', 'other']
-GENRE_TO_TEST = 'rock'
-SONG_INDEX = 0
-
-def build_dataset(root_dir, val_split=0.17, seed=42):
-    train_dataset = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    val_dataset   = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    rows = []
-    for genre in GENRES:
-      genre_path = os.path.join(root_dir, genre)
-      for song in os.listdir(genre_path):
-        rows.append({
-            "label" : genre,
-            "song" : song
-        })
-    df = pd.DataFrame(rows)
-    display(song_df.head())
-    X = df['song']
-    y = df['label']
-
-    sss = StratifiedShuffleSplit(n_splits=1, test_size=val_split, random_state=seed)
-
-    for train_index, val_index in sss.split(X, y):
-        train_df = df.iloc[train_index].reset_index(drop=True)
-        val_df = df.iloc[val_index].reset_index(drop=True)
-
-    for idx, row in train_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          train_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-
-    for idx, row in val_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          val_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-
-    print(len(val['jazz']['drums']))
-    return train_dataset, val_dataset
-
-tr, val = build_dataset(DATA_ROOT)
-
-def find_long_silences(dataset_dict, sr=SR, threshold_sec=DURATION, top_db=TOP_DB):
-    """
-    Input:
-        dataset_dict: The dictionary structure {genre: {stem: [paths...]}}
-    Output:
-        df: Pandas DataFrame containing details of all files with silence >= 5s
-    """
-    records = []
-    for genre in GENRES:
-      for key in STEM_KEYS:
-        for file in dataset_dict[genre][key]:
-          silence_type = []
-          total_duration = 0
-          max_silence = 0
-          y, sr = librosa.load(file, sr=sr)
-          intervals = librosa.effects.split(y, top_db=top_db)
-          file_length = len(y) / sr
-
-          if intervals.size == 0:
-              silence_type.append("FULL")
-              max_silence = file_length
-              total_silence_duration = file_length
-          else:
-              # Start
-              start_gap = intervals[0][0] / sr
-              if start_gap > 0:
-                  silence_type.append("START")
-                  max_silence = max(max_silence, start_gap)
-
-              # Middle
-              mid_silence_total = 0
-              for i in range(1, len(intervals)):
-                  gap = (intervals[i][0] - intervals[i-1][1]) / sr
-                  if gap > 0:
-                      if "MIDDLE" not in silence_type: silence_type.append("MIDDLE")
-                      max_silence = max(max_silence, gap)
-                      mid_silence_total += gap
-
-              # End
-              end_gap = (len(y) - intervals[-1][1]) / sr
-              if end_gap > 0:
-                  silence_type.append("END")
-                  max_silence = max(max_silence, end_gap)
-              total_silence_duration = start_gap + mid_silence_total + end_gap
-
-          if max_silence >= threshold_sec:
-             records.append({
-                 "Genre": genre,
-                 "Stem": key,
-                 "Duration": round(total_silence_duration, 2),
-                 "Max_Silence_Sec": round(max_silence, 2),
-                 "Silence_Location": ", ".join(silence_type),
-                 "File_Path": file
-             })
-    #-------------------------------------------------------------------------
-    df = pd.DataFrame(records)
-    return df
-
-
-# --- EXECUTION ---
-# Pass your 'tr' (training) dictionary here.
-# Ensure 'tr' is defined from your previous build_dataset code.
-df_silence = find_long_silences(tr, threshold_sec=DURATION, top_db=TOP_DB)
-
-# --- RESULTS ANALYSIS ---
-
-# ------------------- write your code here -------------------------------
-#-------------------------------------------------------------------------
-# Hint: Create a pivot Table: Count by Genre vs Stem
-
-df_silence[df_silence["Silence_Location"] == 'START'].head()
-
-df_silence[
-    (df_silence['Stem'] == 'drums') &
-    (df_silence['Genre'] == 'jazz') &
-    (df_silence['Max_Silence_Sec'] > 10)
-].shape
-
-stems_audio = []
-path = '/content/dataset/messy_mashup/genres_stems/rock/rock.00000'
-try:
-    for key in STEM_KEYS:
-      y, sr = librosa.load(os.path.join(path, f'{key}.wav'), sr=SR, duration=5.0)
-      stems_audio.append(y)
-    print("Audio loaded successfully.")
-
-except IndexError:
-    print(f"ERROR: Song index {SONG_INDEX} out of range for genre {GENRE_TO_TEST}.")
-except Exception as e:
-    print(f"ERROR: {e}")
-
-# ------------------- write your code here -------------------------------
-
-# Stack them into a numpy array (Shape: 4 x Samples)
-stems_stack = np.asarray(stems_audio)
-print(stems_stack.shape)
-
-# Mix the stems by summing them element-wise
-mix_raw = np.sum(stems_stack, axis=0)
-print(mix_raw.shape)
-
-# Calculate RMS Amplitude MANUALLY
-rms_val = np.sqrt(np.sum(mix_raw**2) / mix_raw.shape[0])
-print(rms_val)
-
-# Peak Normalization (FIXED)
-max_val = np.max(np.abs(mix_raw))   # <-- IMPORTANT CHANGE
-print(max_val)
-
-if max_val > 0:
-    mix_norm = mix_raw / max_val
-else:
-    mix_norm = mix_raw
-
-print(np.max(np.abs(mix_norm)))
-
-# VALIDATION
-assert np.isclose(np.max(np.abs(mix_norm)), 1.0), "Normalization failed."
-

milestone_2.py

@@ -1,258 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Milestone_2.ipynb
-
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/drive/1-r7NZ_PYS1JKGoinWyPplhGkitD7lHuV
-"""
-
-import os
-import glob
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-import librosa
-import librosa.display
-import matplotlib.pyplot as plt
-import random
-import torch
-import soundfile as sf
-from sklearn.model_selection import StratifiedShuffleSplit
-from google.colab import drive
-from collections import Counter
-import matplotlib.pyplot as plt
-import seaborn as sns
-from sklearn.model_selection import train_test_split
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.metrics import f1_score, confusion_matrix, classification_report, ConfusionMatrixDisplay
-import warnings
-warnings.filterwarnings("ignore")
-
-drive.mount('/content/drive')
-
-
-drive_zip = '/content/drive/MyDrive/jan-2026-dl-gen-ai-project.zip'
-local_zip = '/content/data.zip'
-extract_to = '/content/dataset'
-
-if not os.path.exists(extract_to):
-    print("Moving 16 GB from Drive to local SSD...")
-    !rsync -ah --progress "{drive_zip}" "{local_zip}"
-
-    print("Unzipping 25GB... (This will take a few minutes)")
-    !unzip -q "{local_zip}" -d "{extract_to}"
-
-    print("Deleting zip to save space...")
-    os.remove(local_zip)
-    print("Ready! Data is in /content/dataset")
-else:
-    print("Data already exists.")
-
-DATA_SEED = 67
-TRAINING_SEED = 1234
-SR = 22050
-DURATION = 5.0
-N_FFT = 2048
-HOP_LENGTH = 512
-N_MELS = 128
-TOP_DB=20
-TARGET_SNR_DB = 10
-
-random.seed(DATA_SEED)
-np.random.seed(DATA_SEED)
-torch.manual_seed(DATA_SEED)
-torch.cuda.manual_seed(DATA_SEED)
-
-# CONFIGURATION
-DATA_ROOT = '/content/dataset/messy_mashup/genres_stems'
-GENRES = [] # Make the list of all genres available
-for genre in os.listdir(path=DATA_ROOT):
-  GENRES.append(genre)
-display(GENRES)
-STEMS = {} # Write here stems file name
-STEM_KEYS = ['drums', 'vocals', 'bass', 'other']
-GENRE_TO_TEST = 'rock'
-SONG_INDEX = 0
-
-def build_dataset(root_dir, val_split=0.17, seed=42):
-    train_dataset = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    val_dataset   = {g: {s: [] for s in STEM_KEYS} for g in GENRES}
-    rows = []
-    for genre in GENRES:
-      genre_path = os.path.join(root_dir, genre)
-      for song in os.listdir(genre_path):
-        rows.append({
-            "label" : genre,
-            "song" : song
-        })
-    df = pd.DataFrame(rows)
-    X = df['song']
-    y = df['label']
-
-    sss = StratifiedShuffleSplit(n_splits=1, test_size=val_split, random_state=seed)
-
-    for train_index, val_index in sss.split(X, y):
-        train_df = df.iloc[train_index].reset_index(drop=True)
-        val_df = df.iloc[val_index].reset_index(drop=True)
-
-    for idx, row in train_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          train_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-
-    for idx, row in val_df.iterrows():
-        genre = row['label']
-        song = row['song']
-        song_path = os.path.join(root_dir, genre, song)
-        for stem in os.listdir(song_path):
-          val_dataset[genre][stem.replace('.wav', '')].append(os.path.join(song_path, stem))
-    return train_dataset, val_dataset
-
-tr, val = build_dataset(DATA_ROOT)
-
-# Question_1 and Question_2
-duration_arr = []
-for stem in STEM_KEYS:
-  for song in tr['jazz'][stem]:
-    y, sr = librosa.load(path=song)
-    duration = librosa.get_duration(y=y, sr=sr)
-    duration_arr.append(duration)
-display(np.mean(np.array(duration_arr)))
-
-# Question_2
-sr_set=set()
-for genre in GENRES:
-  for stem in STEM_KEYS:
-    for song in tr[genre][stem]:
-      y, sr = librosa.load(path=song)
-      sr_set.add(sr)
-display(list(sr_set))
-
-#Question_3
-counter = 0
-for genre in GENRES:
-  for stem in STEM_KEYS:
-    for song in tr[genre][stem]:
-      if os.path.getsize(song) == 0:
-        counter += 1
-display(counter)
-
-#Question_4
-amplitude_arr = []
-
-for genre in GENRES:
-    for song in tr[genre]['vocals']:
-        y, sr = sf.read(song)
-
-        peak_linear = np.max(np.abs(y))
-
-        if peak_linear > 0:
-            peak_db = librosa.amplitude_to_db(np.array([peak_linear]), ref=1.0)[0]
-            amplitude_arr.append(peak_db)
-
-average_peak_db = np.mean(amplitude_arr)
-print(f"Average Peak Level: {average_peak_db:.2f} dBFS")
-
-#Question_5
-centroids = []
-for stem in STEM_KEYS:
-  for song in tr['blues'][stem]:
-    y, sr = librosa.load(song)
-    sc = librosa.feature.spectral_centroid(y=y, sr=sr)
-    centroids.append(np.mean(sc))
-mean_blues_centroid = np.mean(centroids)
-print(f"Mean Spectral Centroid for Blues: {mean_blues_centroid:.2f} Hz")
-
-#Question_6
-genre_means = {}
-for genre in GENRES:
-    genre_centroids = []
-    for stem in STEM_KEYS:
-        for song_path in tr[genre][stem]:
-            y, sr = librosa.load(song_path)
-            sc = librosa.feature.spectral_centroid(y=y, sr=sr)
-            genre_centroids.append(np.mean(sc))
-
-    genre_means[genre] = np.mean(genre_centroids)
-
-highest_genre = max(genre_means, key=genre_means.get)
-print(f"Genre with highest mean spectral centroid: {highest_genre} ({genre_means[highest_genre]:.2f} Hz)")
-
-#Question_7
-silence_count = 0
-threshold = librosa.db_to_amplitude(-20)
-
-for genre in GENRES:
-    for stem_type in STEM_KEYS:
-        for song_path in tr[genre][stem_type]:
-            y, sr = librosa.load(song_path, duration=0.5)
-            if np.max(np.abs(y)) < threshold:
-                silence_count += 1
-
-print(f"Stems quieter than -20dB in the first 0.5s: {silence_count}")
-
-# --- 1. Setup and Preprocessing ---
-ROOT = '/content/dataset/messy_mashup'
-STEMS_PATH = os.path.join(ROOT, 'genres_stems')
-GENRES = ["blues", "classical", "country", "disco", "hiphop", "jazz", "metal", "pop", "reggae", "rock"]
-
-def extract_features(song_path):
-    # Load 10s at 22050Hz
-    y, sr = librosa.load(os.path.join(song_path, 'other.wav'), sr=22050, duration=10)
-    tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
-    spec_cent = np.mean(librosa.feature.spectral_centroid(y=y, sr=sr))
-    zcr = np.mean(librosa.feature.zero_crossing_rate(y))
-    rolloff = np.mean(librosa.feature.spectral_rolloff(y=y, sr=sr))
-    return [float(tempo), spec_cent, zcr, rolloff]
-
-# --- 2. Data Preparation & Stratified Split ---
-data = []
-for g in GENRES:
-    gp = os.path.join(STEMS_PATH, g)
-    songs = [s for s in os.listdir(gp) if os.path.isdir(os.path.join(gp, s))]
-    for s in songs[:50]: # Sampling 50 for speed; use all for final
-        data.append({'path': os.path.join(gp, s), 'genre': g})
-
-df = pd.DataFrame(data)
-train_df, val_df = train_test_split(df, test_size=0.2, stratify=df['genre'], random_state=42)
-
-# --- 3. Model Training (Decision Tree) ---
-X_train = np.array([extract_features(p) for p in train_df['path']])
-y_train = train_df['genre']
-X_val = np.array([extract_features(p) for p in val_df['path']])
-y_val = val_df['genre']
-
-clf = DecisionTreeClassifier(max_depth=5, random_state=42)
-clf.fit(X_train, y_train)
-
-y_pred = clf.predict(X_val)
-display(f'f1 Score is {f1_score(y_pred=y_pred, y_true=y_val, average='macro'):.2f}')
-
-report_dict = classification_report(y_val, y_pred, output_dict=True)
-df_report = pd.DataFrame(report_dict).transpose()
-plt.figure(figsize=(10, 6))
-sns.heatmap(df_report, annot=True, cmap="YlGnBu", fmt=".2f", linewidths=.5)
-plt.title('Genre Classification Performance')
-plt.show()
-
-display(np.mean(np.array(y_pred==y_val)))
-
-cm = confusion_matrix(y_val, y_pred)
-plt.figure(figsize=(10, 8))
-disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=clf.classes_)
-disp.plot(cmap='Blues', xticks_rotation='vertical', ax=plt.gca())
-plt.title('Confusion Matrix: Predicted vs True Genres')
-plt.show()
-
-true_positives = np.diag(cm)
-tp_per_genre = dict(zip(clf.classes_, true_positives))
-highest_tp_genre = max(tp_per_genre, key=tp_per_genre.get)
-print(f"Genre with the highest True Positives: {highest_tp_genre}")
-
-false_negatives = np.sum(cm, axis=1) - np.diag(cm)
-fn_per_genre = dict(zip(clf.classes_, false_negatives))
-best_genre = min(fn_per_genre, key=fn_per_genre.get)
-print(f"Genre with the lowest False Negatives: {best_genre}")

requirements.txt

@@ -1,14 +0,0 @@
-numpy
-pandas
-tqdm
-librosa
-matplotlib
-seaborn
-torch
-torchaudio
-torchsummary
-transformers
-timm
-scikit-learn
-soundfile
-wandb