huggingface space main commit

.gitignore

@@ -0,0 +1 @@
+__pycache__/

about.md

@@ -0,0 +1,12 @@
+### About the Classifier
+The classifier is a [convolutional neural network](https://en.wikipedia.org/wiki/Convolutional_neural_network) trained on over 10,000 hours of Carnatic audio sourced from this incredible [YouTube collection](https://ramanarunachalam.github.io/Music/Carnatic/carnatic.html).
+### Key Features:
+- Can identify **150 ragas**
+- Does not require any information about the **shruthi (tonic pitch)** of the recording.
+- **Compatible** with male/female vocal or instrumental recordings.
+
+### Interpreting the Classifier:
+We can gain an intuitive sense for what the classifier has learned. Here is a [t-SNE](https://en.wikipedia.org/wiki/T-distributed_stochastic_neighbor_embedding) projection of the hidden activations averaged per ragam. Each point is a ragam, and relative distances between the points indicate the degree to which the classifier thinks the ragas are similar. Each ragam is color coded by the [melakartha chakra](https://en.wikipedia.org/wiki/Melakarta#Chakras) it belongs to. We observe that the classifier has learned to a representation that roughly corresponds to these chakras! 
+
+
+

app.py

@@ -0,0 +1,57 @@
+import os
+from inference import Evaluator
+import argparse
+from utils.YParams import YParams
+import torch
+import gradio as gr
+
+def read_markdown_file(path):
+    with open(path, 'r', encoding='utf-8') as file:
+        return file.read()
+
+
+if __name__ == '__main__':
+
+    #parse args
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--yaml_config", default='config.yaml', type=str)
+    parser.add_argument("--config", default='resnet_0.7', type=str)
+
+    args = parser.parse_args()
+    params = YParams(os.path.abspath(args.yaml_config), args.config)
+
+    #GPU stuff
+    try:
+        params.device = torch.device(torch.cuda.current_device())
+    except:
+        params.device = "cpu"
+    
+    #checkpoint stuff
+    expDir = "ckpts/resnet_0.7/150classes_alldata_cliplength30"
+    params['checkpoint_path'] = os.path.join(expDir, 'training_checkpoints/ckpt.tar')
+    params['best_checkpoint_path'] = os.path.join(expDir, 'training_checkpoints/best_ckpt.tar')
+
+    evaluator = Evaluator(params)
+
+    with gr.Blocks() as demo:
+        with gr.Tab("Classifier"):
+            gr.Interface(
+            title="Carnatic Raga Classifier",
+            description="**Welcome!** This is a deep-learning based raga classifier. Simply upload or record an audio clip to test it out. \n",
+            article = "**Get in Touch:** Feel free to reach out to [me](https://sanjeevraja.com/) via email (sanjeevr AT berkeley DOT edu) with any questions or feedback! ",
+            fn=evaluator.inference,
+            inputs=[
+                gr.Slider(minimum = 1, maximum = 150, value = 5, label = "Number of displayed ragas", info = "Choose number of top predictions to display"), 
+                gr.Audio()
+                ],
+            outputs="label",
+            allow_flagging = False
+            )
+            
+        with gr.Tab("About"):
+            gr.Markdown(read_markdown_file('about.md'))
+            gr.Image('site/tsne.jpeg', height = 800, width=800)
+
+    demo.launch()
+
+

ckpts/resnet_0.7/150classes_alldata_cliplength30/training_checkpoints/best_ckpt.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09844cbcfc6c98af632671ca14dd4878fe6656811cdb77097a847c8b324362ca
+size 66309523

config.yaml

@@ -0,0 +1,130 @@
+default: &DEFAULT
+
+  #data
+  exp_dir: carnatic/ckpts
+  metadata_labeled_path: labeled_small_wav_metadata.json
+  metadata_unlabeled_path: unlabeled_data/unlabeled_mp3_metadata.json
+  num_files_per_raga_path: metadata_small.json
+  num_classes: 150
+  use_frac: 1
+  use_unlabeled_data: !!bool False
+  labeled_data_dir: labeled_data_small
+  clip_length: 30
+  sample_rate: 8000
+  normalize: !!bool True
+
+  #training
+  batch_size: 16
+  num_data_workers: 16
+  n_epochs: 100
+  lr: 0.001
+  class_imbalance_weights: !!bool False
+  patience: 10
+  train_frac: 0.8
+  
+  #model
+  model: 'base'
+  n_input: 2 #stereo
+  stride: 16
+  n_channel: 32
+  max_pool_every: 1
+  
+  #logging
+  save_checkpoint: !!bool False
+  wandb_api_key: f7892f37dd96b5f1da5c85a410300bb661f3c4de
+  log_to_wandb: !!bool False
+  
+
+default_0.7: &DEFAULT_0.7
+
+  <<: *DEFAULT
+  metadata_labeled_path: labeled_0.7_wav_metadata.json
+  num_files_per_raga_path: metadata_0.7.json
+  labeled_data_dir: labeled_data_0.7
+
+default_0.9: &DEFAULT_0.9
+
+  <<: *DEFAULT
+  metadata_labeled_path: labeled_0.9_wav_metadata.json
+  num_files_per_raga_path: metadata_0.9.json
+  labeled_data_dir: labeled_data_0.9
+  train_frac: 0.85
+  num_classes: 200
+
+  
+resnet: &RESNET
+
+  <<: *DEFAULT
+  model: 'resnet'
+  n_blocks: 5 #for resnet
+  n_channel: 128
+
+resnet_0.7: &RESNET_0.7
+
+  <<: *DEFAULT_0.7
+  model: 'resnet'
+  n_blocks: 10 #for resnet
+  n_channel: 300
+  num_classes: 150
+
+resnet_0.9: &RESNET_0.9
+
+  <<: *DEFAULT_0.9
+  model: 'resnet'
+  n_blocks: 10 #for resnet
+  n_channel: 350
+  max_pool_every: 1 #downsample every other res block
+
+
+wav2vec_0.7: &WAV2VEC_0.7
+  <<: *DEFAULT_0.7
+
+  model: 'wav2vec'
+  n_input: 1 #mono
+
+  #transformer parameters (this config leads to around 29M params)
+  extractor_mode: "layer_norm"
+  extractor_conv_layer_config: None #harcoded for now, fix this at some point
+  extractor_conv_bias: !!bool True
+  encoder_embed_dim: 512
+  encoder_projection_dropout: 0
+  encoder_pos_conv_kernel: 3
+  encoder_pos_conv_groups: 32
+  encoder_num_layers: 12
+  encoder_num_heads: 16
+  encoder_attention_dropout: 0
+  encoder_ff_interm_features: 1024
+  encoder_ff_interm_dropout: 0
+  encoder_dropout: 0
+  encoder_layer_norm_first: !!bool True
+  encoder_layer_drop: 0
+
+
+wav2vec_0.9: &WAV2VEC_0.9
+  <<: *DEFAULT_0.9
+
+  model: 'wav2vec'
+  n_input: 1 #mono
+
+  #transformer parameters (this config leads to around 29M params)
+  extractor_mode: "layer_norm"
+  extractor_conv_layer_config: None #harcoded for now, fix this at some point
+  extractor_conv_bias: !!bool True
+  encoder_embed_dim: 512
+  encoder_projection_dropout: 0
+  encoder_pos_conv_kernel: 3
+  encoder_pos_conv_groups: 32
+  encoder_num_layers: 12
+  encoder_num_heads: 16
+  encoder_attention_dropout: 0
+  encoder_ff_interm_features: 1024
+  encoder_ff_interm_dropout: 0
+  encoder_dropout: 0
+  encoder_layer_norm_first: !!bool True
+  encoder_layer_drop: 0
+
+
+
+
+
+  

data/dataloader.py

@@ -0,0 +1,143 @@
+import logging
+import glob
+from multiprocessing.sharedctypes import Value
+import torch
+import random
+import numpy as np
+from torch.utils.data import Dataset
+import torchaudio
+import json
+import os
+from math import floor
+import sys
+import time
+import copy
+import math
+import logging
+
+
+np.random.seed(123)
+random.seed(123)
+#load used subset of metadata
+def extract_data(params):
+    with open(params.metadata_labeled_path) as f:
+        metadata_labeled = json.load(f)
+        
+    if params.use_unlabeled_data:
+        with open(params.metadata_unlabeled_path) as f:
+            metadata_unlabeled = json.load(f)
+        n_unlabeled_samples = len(metadata_unlabeled)
+    
+    #shuffle data and removed unused files
+    random.shuffle(metadata_labeled)
+    keep = math.ceil(params.use_frac*len(metadata_labeled))
+    metadata_labeled = metadata_labeled[0:keep]
+
+    #construct raga label lookup table.
+    raga2label = get_raga2label(params)
+
+    #remove ragas unused ragas from metadata dictionary
+    metadata_labeled_final = remove_unused_ragas(metadata_labeled, raga2label)
+
+    return metadata_labeled_final, raga2label
+
+def get_raga2label(params):
+    with open(params.num_files_per_raga_path) as f:
+        num_files_per_raga = json.load(f)
+    raga2label = {}
+    for i, raga in enumerate(num_files_per_raga.keys()):
+        raga2label[raga] = i #assign every raga to a unique number from 0 to self.num_classes
+        if i == params.num_classes-1:
+          break
+    return raga2label
+
+def remove_unused_ragas(metadata_labeled, raga2label):
+    temp = copy.deepcopy(metadata_labeled)
+    for i, entry in enumerate(metadata_labeled):
+      raga = entry['filename'].split("/")[0]
+      if raga not in raga2label.keys(): #this raga is not in the top self.params.num_classes ragas
+        temp.remove(entry)
+    
+    return temp
+
+class RagaDataset(Dataset):
+  def __init__(self, params, metadata_labeled, raga2label):
+    self.params = params
+    self.metadata_labeled = metadata_labeled
+    self.raga2label = raga2label
+    self.n_labeled_samples = len(self.metadata_labeled)
+    self.transform_dict = {}
+    self.count=0
+
+    if params.local_rank ==0:
+      print("Begin training using ", self.__len__(), " audio samples of ", self.params.clip_length, " seconds each.")
+      print("Total number of ragas specified: ", self.params.num_classes)
+    
+        
+  def construct_label(self, raga, label_smoothing=False):
+    #construct one hot encoding vector for raga
+    raga_index = self.raga2label[raga]
+    label = torch.zeros((self.params.num_classes,), dtype = torch.float32)
+    label[raga_index] = 1
+    return label 
+
+  def normalize(self, audio):
+
+    return (audio - torch.mean(audio, dim=1, keepdim=True))/(torch.std(audio, dim=1, keepdim=True) + 1e-5)
+
+  def pad_audio(self, audio):
+    pad = (0, self.params.sample_rate*self.params.clip_length - audio.shape[1])
+    return torch.nn.functional.pad(audio, pad = pad, value=0)
+
+  def __len__(self):
+    return len(self.metadata_labeled)
+    
+
+  def __getitem__(self, idx):
+    #get metadata
+    file_info = self.metadata_labeled[idx]
+
+    #sample offset uniformly
+    rng = max(0,file_info['duration'] - self.params.clip_length)
+    if rng == 0:
+      rng = file_info['duration']
+
+    seconds_offset = np.random.randint(floor(rng))
+
+    #open audio file
+    audio_clip, sample_rate = torchaudio.load(filepath = os.path.join(self.params.labeled_data_dir, file_info['filename']), \
+                                 frame_offset = seconds_offset * file_info['sample_rate'], \
+                                num_frames=self.params.clip_length*file_info['sample_rate'], normalize=True)
+    
+    
+    if audio_clip.shape[0] !=2:
+      audio_clip = audio_clip.repeat(2, 1)
+    
+    #keep stereo
+    #audio_clip = audio_clip.mean(dim=0, keepdim=True)
+    #add transform to dictionary          
+    if sample_rate not in self.transform_dict.keys():
+      self.transform_dict[sample_rate] = torchaudio.transforms.Resample(orig_freq = sample_rate, new_freq = self.params.sample_rate)
+    
+    #load cached transform
+    resample = self.transform_dict[sample_rate]
+    audio_clip = resample(audio_clip)
+
+    if self.params.normalize:
+      audio_clip = self.normalize(audio_clip)
+
+    if audio_clip.size()[1] < self.params.sample_rate*self.params.clip_length:
+      #pad audio with zeros if it's not long enough
+      audio_clip = self.pad_audio(audio_clip)
+
+    
+    raga = file_info['filename'].split("/")[0]
+    
+    #construct label
+    label = self.construct_label(raga)
+
+    assert not torch.any(torch.isnan(audio_clip))
+    assert not torch.any(torch.isnan(label))
+    assert audio_clip.shape[1] == self.params.sample_rate*self.params.clip_length
+    return audio_clip, label
+   

inference.py

@@ -0,0 +1,117 @@
+import logging
+from utils import logging_utils
+logging_utils.config_logger()
+import torch
+import random
+import numpy as np
+from data.dataloader import extract_data
+import torchaudio
+from models.RagaNet import BaseRagaClassifier, ResNetRagaClassifier, Wav2VecTransformer, count_parameters
+from collections import OrderedDict
+
+np.random.seed(123)
+random.seed(123)
+
+
+class Evaluator():
+
+    def __init__(self, params):
+        self.params = params
+        self.device = self.params.device
+        #get raga to label mapping
+        _, self.raga2label = extract_data(self.params)
+        self.raga_list = list(self.raga2label.keys())
+        self.label_list = list(self.raga2label.values())
+
+        #initialize model
+        if params.model == 'base':
+            self.model = BaseRagaClassifier(params).to(self.device)
+        elif params.model == 'resnet':
+            self.model = ResNetRagaClassifier(params).to(self.device)
+        elif params.model == 'wav2vec':
+            self.model = Wav2VecTransformer(params).to(self.device)
+        else:
+            logging.error("Model must be either 'base', 'resnet', or 'wav2vec'")
+        
+        #load best model
+        logging.info("Loading checkpoint %s"%params.best_checkpoint_path)
+        self.restore_checkpoint('ckpts/resnet_0.7/150classes_alldata_cliplength30/training_checkpoints/best_ckpt.tar')#params.best_checkpoint_path)
+        self.model.eval()
+
+
+    def normalize(self, audio):
+        return (audio - torch.mean(audio, dim=1, keepdim=True))/(torch.std(audio, dim=1, keepdim=True) + 1e-5)
+
+    def pad_audio(self, audio):
+        pad = (0, self.params.sample_rate*self.params.clip_length - audio.shape[1])
+        return torch.nn.functional.pad(audio, pad = pad, value=0)
+
+    def inference(self, k, audio):
+        #open audio file
+        sample_rate, audio_clip = audio
+
+        #repeat mono channel to get stereo if necessary
+        if len(audio_clip.shape) == 1:
+            audio_clip = torch.tensor(audio_clip).unsqueeze(0).repeat(2,1).to(torch.float32)
+        else:
+            audio_clip = torch.tensor(audio_clip).T.to(torch.float32)
+        
+        #resample audio clip
+        resample = torchaudio.transforms.Resample(orig_freq = sample_rate, new_freq = self.params.sample_rate)
+        audio_clip = resample(audio_clip)
+
+        #normalize the audio clip
+        if self.params.normalize:
+            audio_clip = self.normalize(audio_clip)
+
+        #pad audio with zeros if it's not long enough
+        if audio_clip.size()[1] < self.params.sample_rate*self.params.clip_length:
+            audio_clip = self.pad_audio(audio_clip)
+        
+        assert not torch.any(torch.isnan(audio_clip))
+        audio_clip = audio_clip.to(self.device)
+
+        with torch.no_grad():
+            length = audio_clip.shape[1]
+            train_length = self.params.sample_rate*self.params.clip_length
+
+            pred_probs = torch.zeros((self.params.num_classes,)).to(self.device)
+
+            #loop over clip_length segments and perform inference
+            num_clips = int(np.floor(length/train_length))
+            for i in range(num_clips):
+                
+                clip = audio_clip[:, i*train_length:(i+1)*train_length].unsqueeze(0)
+        
+                #perform forward pass through model
+                pred_distribution = self.model(clip).reshape(-1, self.params.num_classes)
+                pred_probs +=  1 / num_clips * (torch.exp(pred_distribution)/torch.exp(pred_distribution).sum(axis = 1, keepdim=True))[0]
+
+                
+        pred_probs, labels = pred_probs.sort(descending=True)
+        pred_probs_topk = pred_probs[:k]
+        pred_ragas_topk = [self.raga_list[self.label_list.index(label)] for label in labels[:k]]
+        d = dict(zip(pred_ragas_topk, pred_probs_topk)) 
+        return {k: v.item() for k, v in d.items()}
+
+    def restore_checkpoint(self, checkpoint_path):
+        checkpoint = torch.load(checkpoint_path, map_location=self.device)
+        try:
+            self.model.load_state_dict(checkpoint['model_state'])
+        except:
+            #loading DDP checkpoint into non-DDP model
+            new_state_dict = OrderedDict()
+            for k, v in checkpoint['model_state'].items():
+                name = k[7:] # remove `module.`
+                new_state_dict[name] = v
+            # load params
+            self.model.load_state_dict(new_state_dict)
+            
+        self.iters = checkpoint['iters']
+        self.startEpoch = checkpoint['epoch']
+
+
+   
+    
+    
+    

metadata_0.7.json

@@ -0,0 +1,530 @@
+{
+    "Mohanam": 1085,
+    "Sankarabharanam": 1084,
+    "Panthuvarali": 1036,
+    "Kalyani": 1032,
+    "Bhairavi": 1032,
+    "Hamsadhwani": 1005,
+    "Sindhubhairavi": 985,
+    "Kambhoji": 958,
+    "Thodi": 936,
+    "Khamas": 926,
+    "Poorvikalyani": 920,
+    "Madhyamavathi": 914,
+    "Kapi": 907,
+    "Karaharapriya": 881,
+    "Hindolam": 868,
+    "Anandabhairavi": 847,
+    "Saveri": 801,
+    "Nata": 788,
+    "Shanmukapriya": 779,
+    "Reethigowla": 743,
+    "Begada": 732,
+    "Behag": 714,
+    "Abheri": 692,
+    "Arabhi": 691,
+    "Bilahari": 651,
+    "Atana": 648,
+    "Kaanada": 613,
+    "Sri": 601,
+    "Varali": 577,
+    "Sahana": 572,
+    "Yamunakalyani": 560,
+    "Suruti": 544,
+    "Mayamalavagowla": 539,
+    "Yadukulakambhoji": 536,
+    "Mukhari": 493,
+    "Sriranjani": 477,
+    "Abhogi": 464,
+    "Natakurinji": 463,
+    "Harikambhoji": 458,
+    "Vasantha": 447,
+    "Dhanyasi": 442,
+    "Neelambari": 434,
+    "Keeravani": 421,
+    "Kedaragowla": 413,
+    "Chenchurutti": 392,
+    "Sowrashtram": 387,
+    "Hamsanandi": 378,
+    "Shuddhadhanyasi": 366,
+    "Sama": 351,
+    "Brindavanasaranga": 340,
+    "Shuddhasaveri": 331,
+    "Hamirkalyani": 323,
+    "Devagandhari": 322,
+    "Gowla": 313,
+    "Charukesi": 310,
+    "Darbar": 306,
+    "Revathi": 302,
+    "Saranga": 299,
+    "Simhendramadhyamam": 290,
+    "Dwijavanthi": 283,
+    "Kunthalavarali": 269,
+    "Jonpuri": 269,
+    "Bahudhari": 269,
+    "Huseni": 267,
+    "Ranjani": 263,
+    "Maand": 259,
+    "Nalinakanthi": 257,
+    "Asaveri": 257,
+    "Kedaram": 253,
+    "Hamsanadam": 252,
+    "Kurinji": 250,
+    "Kadanakuthuhalam": 236,
+    "Desh": 234,
+    "Bowli": 232,
+    "Amrithavarshini": 232,
+    "Saramathi": 232,
+    "Punnagavarali": 231,
+    "Mohanakalyani": 231,
+    "Subhapanthuvarali": 224,
+    "Nadanamakriya": 223,
+    "Lathangi": 222,
+    "Gambheeranata": 219,
+    "Darbarikaanada": 218,
+    "Malayamarutham": 208,
+    "Chakravakam": 204,
+    "Bageshree": 201,
+    "Ahiri": 200,
+    "Saraswathi": 200,
+    "Kannada": 197,
+    "Manirangu": 196,
+    "Kalyanavasantham": 195,
+    "Jaganmohini": 192,
+    "Andolika": 190,
+    "Poornachandrika": 184,
+    "Devamanohari": 183,
+    "Lalitha": 179,
+    "Gowrimanohari": 178,
+    "Valaji": 171,
+    "Vachaspathi": 171,
+    "Dharmavathi": 168,
+    "Paras": 161,
+    "Varamu": 159,
+    "Janaranjani": 159,
+    "Hemavathi": 154,
+    "Ravichandrika": 150,
+    "Nayaki": 143,
+    "Navarasakannada": 143,
+    "Gowlipanthu": 126,
+    "Madhuvanthi": 124,
+    "Manji": 124,
+    "Thilang": 124,
+    "Kapinarayani": 122,
+    "Kamalamanohari": 121,
+    "Ahirbhairavi": 119,
+    "Revagupthi": 118,
+    "Jayanthashree": 117,
+    "Chandrajyothi": 117,
+    "Nagaswaravali": 116,
+    "Kannadagowla": 116,
+    "Bindumalini": 112,
+    "Durga": 111,
+    "Vagadheeswari": 110,
+    "Karnaranjani": 106,
+    "Nasikabhushani": 106,
+    "Dhenuka": 103,
+    "Malavi": 102,
+    "Natabhairavi": 101,
+    "Ganamoorthi": 99,
+    "Vegavahini": 97,
+    "Sarasangi": 94,
+    "Saraswathimanohari": 93,
+    "Ramapriya": 87,
+    "Rudrapriya": 87,
+    "Chittaranjani": 86,
+    "Mandari": 86,
+    "Malahari": 81,
+    "Shuddhabangala": 80,
+    "Sunadhavinodhini": 79,
+    "Salagabhairavi": 75,
+    "Chinthamani": 74,
+    "Devamruthavarshini": 73,
+    "Brindavani": 72,
+    "Balahamsa": 70,
+    "Mishrayaman": 70,
+    "Vakulabharanam": 70,
+    "Bhavapriya": 70,
+    "Vijayashree": 69,
+    "Bhoopalam": 69,
+    "Dhanashree": 68,
+    "Jayamanohari": 67,
+    "Peeloo": 66,
+    "Shivaranjani": 66,
+    "Rasikapriya": 63,
+    "Vasanthabhairavi": 63,
+    "Rishabhapriya": 62,
+    "Garudadhwani": 61,
+    "Natakapriya": 61,
+    "Chalanata": 60,
+    "Ratipatipriya": 60,
+    "Gowdamalhar": 58,
+    "Navaroj": 58,
+    "Karnatakakapi": 58,
+    "Kumudakriya": 58,
+    "Bangala": 54,
+    "Chenchukambhoji": 54,
+    "Shuddhasarang": 53,
+    "Kalavathi": 53,
+    "Bhairavam": 53,
+    "Narayanagowla": 52,
+    "Shuddhaseemanthini": 52,
+    "Hamsavinodhini": 49,
+    "Manoranjani": 49,
+    "Chayatharangini": 49,
+    "Kiranavali": 49,
+    "Amrithavahini": 49,
+    "Devagandharam": 48,
+    "Jayanthasena": 47,
+    "Ramamanohari": 47,
+    "Mishramaand": 47,
+    "Nagagandhari": 47,
+    "Kanthamani": 46,
+    "Neethimathi": 46,
+    "Lalithapanchamam": 45,
+    "Vijayanagari": 45,
+    "Devakriya": 45,
+    "Rageshree": 45,
+    "Suryakantam": 45,
+    "Chandrakowns": 45,
+    "Vasanthi": 45,
+    "Pushpalatika": 44,
+    "Umabharanam": 44,
+    "Kanakangi": 43,
+    "Sindhuramakriya": 42,
+    "Gangeyabhushani": 41,
+    "Poornashadjam": 41,
+    "Tharangini": 39,
+    "Lavangi": 39,
+    "Karnatakabehag": 38,
+    "Sucharithra": 38,
+    "Neelamani": 38,
+    "Hindolavasantham": 37,
+    "Margahindolam": 37,
+    "Mishrashivaranjani": 36,
+    "Patdeep": 36,
+    "Jyothiswaroopini": 35,
+    "Phalamanjari": 35,
+    "Urmika": 35,
+    "Yaman": 35,
+    "Vanaspathi": 35,
+    "Veeravasantham": 35,
+    "Gamanashrama": 34,
+    "Kokilavarali": 33,
+    "Pahadi": 33,
+    "Kalanidhi": 33,
+    "Sindhukannada": 32,
+    "Narayani": 32,
+    "Manjari": 31,
+    "Hindusthanigandhari": 29,
+    "Bhavani": 29,
+    "Purvi": 29,
+    "Prathapavarali": 29,
+    "Vallabhi": 28,
+    "Karnatakashuddhasaveri": 27,
+    "Megharanjani": 27,
+    "Isamanohari": 27,
+    "Soorya": 27,
+    "Pasupathipriya": 26,
+    "Gambheeravani": 26,
+    "Simhavahini": 26,
+    "Madhavamanohari": 26,
+    "Niroshta": 26,
+    "Varunapriya": 26,
+    "Manavathi": 26,
+    "Naganandhini": 25,
+    "Ghanta": 25,
+    "Shivashakti": 25,
+    "Kaikavasi": 24,
+    "Kokilapriya": 24,
+    "Mishrapahadi": 24,
+    "Saindhavi": 24,
+    "Jingala": 24,
+    "Kosalam": 24,
+    "Kalgada": 23,
+    "Sumanesaranjani": 23,
+    "Bhushavali": 23,
+    "Narireethigowla": 22,
+    "Rasali": 22,
+    "Vivardhini": 22,
+    "Jankaradhvani": 22,
+    "Sarangatharangini": 21,
+    "Paadi": 21,
+    "Gowri": 21,
+    "Bhujangini": 21,
+    "Gurjari": 21,
+    "Suposhini": 21,
+    "Udhayaravichandrika": 20,
+    "Rathnangi": 20,
+    "Deepali": 20,
+    "Ragavardhani": 20,
+    "Supradeepam": 19,
+    "Mangalakaishiki": 19,
+    "Kannadabangala": 19,
+    "Shadhvidhamargini": 19,
+    "Kokiladhwani": 18,
+    "Mahathi": 18,
+    "Janasammodhini": 17,
+    "Takka": 17,
+    "Vasanthavarali": 17,
+    "Thanarupi": 17,
+    "Amrithabehag": 17,
+    "Rupavathi": 16,
+    "Ganavaridhi": 16,
+    "Natanarayani": 15,
+    "Jog": 15,
+    "Manorama": 15,
+    "Swarabhushani": 15,
+    "Gopikavasantham": 15,
+    "Shuddhadesi": 14,
+    "Mararanjani": 14,
+    "Deshakshi": 14,
+    "Gundakriya": 14,
+    "Gayakapriya": 14,
+    "Chithrambari": 14,
+    "Maruvabehag": 14,
+    "Ramkali": 13,
+    "Shulini": 13,
+    "Desiyathodi": 13,
+    "Vandanadharini": 13,
+    "Malavashree": 13,
+    "Deepakam": 12,
+    "Kokilaravam": 12,
+    "Vijayasaraswathi": 12,
+    "Mishraharikambhoji": 12,
+    "Maruvadhanyasi": 12,
+    "Mohanangi": 12,
+    "Hatakambari": 12,
+    "Yagapriya": 12,
+    "Suvarnangi": 12,
+    "Samanta": 12,
+    "Basantbahar": 12,
+    "Mishrapeeloo": 11,
+    "Raghupriya": 11,
+    "Pavani": 11,
+    "Navanitham": 11,
+    "Sindhumandari": 11,
+    "Buddhamanohari": 11,
+    "Shuddhavasantha": 10,
+    "Bhanumathi": 10,
+    "Andhali": 10,
+    "Jalarnavam": 10,
+    "Puriyadhanashree": 10,
+    "Gavambodhi": 10,
+    "Vamsavathi": 10,
+    "Sarangamalhar": 10,
+    "Dhavalambari": 10,
+    "Gowrivelaavali": 9,
+    "Namanarayani": 9,
+    "Shyamakalyani": 9,
+    "Bhoopali": 9,
+    "Vishnupriya": 8,
+    "Jyothi": 8,
+    "Gopikathilakam": 8,
+    "Chayanata": 8,
+    "Shruthiranjani": 8,
+    "Santhanamanjari": 8,
+    "Ardhradesi": 8,
+    "Sumukham": 8,
+    "Madhukowns": 8,
+    "Dhivyamani": 8,
+    "Shivakambhoji": 7,
+    "Devaranji": 7,
+    "Chayagowla": 7,
+    "Narthaki": 7,
+    "Rasamanjari": 7,
+    "Vardhani": 7,
+    "Dhurvanki": 7,
+    "Phenadyuthi": 7,
+    "Gavathi": 7,
+    "Poornalalitha": 7,
+    "Kunthalam": 7,
+    "Poorvakamodari": 7,
+    "Mahuri": 7,
+    "Chandrika": 7,
+    "Rohini": 7,
+    "Mishrakhamaj": 7,
+    "Salagam": 7,
+    "Sarvashree": 7,
+    "Bhooshavathi": 7,
+    "Shreemani": 6,
+    "Sumanapriya": 6,
+    "Sushama": 6,
+    "Latantapriya": 6,
+    "Gurjarithodi": 6,
+    "Guharanjani": 6,
+    "Namadesi": 6,
+    "Kunjari": 6,
+    "Maargadesi": 6,
+    "Ragapanjaram": 6,
+    "Harinarayani": 6,
+    "Ravikriya": 6,
+    "Gopriya": 5,
+    "Chayaranjani": 5,
+    "Hamsadeepika": 5,
+    "Nadavarangini": 5,
+    "Hamsalatha": 5,
+    "Shuddhavalaji": 5,
+    "Bhogachayanata": 5,
+    "Phalaranjani": 5,
+    "Bhogavasantha": 5,
+    "Senavathi": 5,
+    "Thandavam": 5,
+    "Swaravali": 5,
+    "Geethapriya": 5,
+    "Jayanarayani": 5,
+    "Vishwambhari": 5,
+    "Nagavarali": 5,
+    "Karthyayani": 5,
+    "Sharavathi": 5,
+    "Ganasamavarali": 5,
+    "Jaganmohinam": 5,
+    "Shyamalangi": 5,
+    "Nagavalli": 5,
+    "Bhinnashadjam": 5,
+    "Suraranjani": 5,
+    "Nabhomani": 4,
+    "Maruva": 4,
+    "Komalangi": 4,
+    "Dhavalangam": 4,
+    "Shivapriya": 4,
+    "Bhavabharanam": 4,
+    "Nagabhushani": 4,
+    "Swarasammodhini": 4,
+    "Gomedhikapriya": 4,
+    "Dhatuvardhani": 4,
+    "Hamsakalyani": 4,
+    "Samakadambari": 4,
+    "Sauvira": 4,
+    "Thanukeerthi": 4,
+    "Ragachoodaamani": 4,
+    "Rasikaranjani": 3,
+    "Moharanjani": 3,
+    "Hamsabhramari": 3,
+    "Dundubi": 3,
+    "Miyanmalhar": 3,
+    "Murali": 3,
+    "Shekharachandrikaa": 3,
+    "Madhulika": 3,
+    "Krisnaveni": 3,
+    "Nagadhwani": 3,
+    "Dakshayani": 3,
+    "Kalasaveri": 3,
+    "Sthavarajam": 3,
+    "Mishrajog": 3,
+    "Srothaswani": 3,
+    "Sowrasenaa": 3,
+    "Samudrapriya": 3,
+    "Bhuvanagaandhaari": 3,
+    "Hamsanantini": 3,
+    "Bhanuchandrika": 3,
+    "Balachandrika": 3,
+    "Shuddhamukhari": 3,
+    "Viswapriya": 3,
+    "Gangatharangini": 3,
+    "Sharadapriya": 3,
+    "Chathurangini": 3,
+    "Venkatadri": 3,
+    "Narayanadri": 3,
+    "Puriyakalyan": 3,
+    "Hindusthanitodi": 3,
+    "Dayavathi": 3,
+    "Kokila": 3,
+    "Madhyamaravali": 3,
+    "Vivahapriya": 3,
+    "Vijayavasantha": 3,
+    "Kuvalayabharanam": 3,
+    "Swararanjani": 3,
+    "Mishrabilahari": 3,
+    "Salanganata": 3,
+    "Malavapanchamam": 3,
+    "Siddhasena": 3,
+    "Jalavarali": 3,
+    "Haricharan": 3,
+    "Karnatakahindolam": 3,
+    "Senagrani": 3,
+    "Nadhabrahma": 3,
+    "Poorvagowla": 3,
+    "Veenadhaari": 3,
+    "Geyahejjajji": 3,
+    "Tarani": 3,
+    "Navarathnavilaasam": 3,
+    "Bhanudhanyasi": 3,
+    "Kolahalam": 3,
+    "Panchamam": 2,
+    "Bhoopalapanchamam": 2,
+    "Rasavinodhini": 2,
+    "Seshadri": 2,
+    "Tarakagowla": 2,
+    "Poornapanchamam": 2,
+    "Kesari": 2,
+    "Shailadeshakshi": 2,
+    "Jujahuli": 2,
+    "Churnikavinodhini": 2,
+    "Rukmambari": 2,
+    "Kalakanti": 2,
+    "Omkaari": 2,
+    "Hindoladarbar": 2,
+    "Mukthidayini": 2,
+    "Hradini": 2,
+    "Velaavali": 2,
+    "Kowshikadhwani": 2,
+    "Hamsavahini": 2,
+    "Srikara": 2,
+    "Mishramanolayam": 2,
+    "Bhanupriya": 2,
+    "Manolayam": 2,
+    "Mukundamalini": 2,
+    "Siddhi": 2,
+    "Ramakriya": 2,
+    "Suranandini": 2,
+    "Chandrapriya": 2,
+    "Shuddhasaranga": 2,
+    "Bhatiyaar": 2,
+    "Malava": 2,
+    "Kusumakaram": 2,
+    "Kannadamaruva": 2,
+    "Sowgandhini": 2,
+    "Shuddhathodi": 2,
+    "Thivravahini": 1,
+    "Savithri": 1,
+    "Shreekaanti": 1,
+    "Kumarapriya": 1,
+    "Sugunabhooshani": 1,
+    "Kalyanakesari": 1,
+    "Nagabharanam": 1,
+    "Jadathari": 1,
+    "Guhamanohari": 1,
+    "Agnikopa": 1,
+    "Pranavapriya": 1,
+    "Karpoorabharani": 1,
+    "Rojakadambari": 1,
+    "Shuddhakambhoji": 1,
+    "Hindhusthanibehag": 1,
+    "Jnanachinthamani": 1,
+    "Chandrahasitham": 1,
+    "Triveni": 1,
+    "Dravidakalavati": 1,
+    "Kumbhini": 1,
+    "Vasukari": 1,
+    "Vitapi": 1,
+    "Saranganata": 1,
+    "Visharada": 1,
+    "Vinodhini": 1,
+    "Sarasaanana": 1,
+    "Shuddhalalitha": 1,
+    "Rishipriya": 1,
+    "Dhipaka": 1,
+    "Shuddhasalavi": 1,
+    "Sutradhari": 1,
+    "Natabharanam": 1,
+    "Mishrabhairavi": 1,
+    "Priyadarshani": 1,
+    "Hamsagamini": 1,
+    "Shyamalam": 1,
+    "Jeevanthika": 1,
+    "Alankari": 1,
+    "Jayashuddhamaalavi": 1,
+    "Mechabowli": 1,
+    "Garudapriya": 1
+}

models/RagaNet.py

@@ -0,0 +1,164 @@
+import torch.nn as nn
+import torch.nn.functional as F
+from torchaudio.models import wav2vec2_model
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+#basic conv block
+def conv_block(n_input, n_output, stride=1, kernel_size=80):
+    layers = []
+    if stride ==1:
+        layers.append(nn.Conv1d(n_input, n_output, kernel_size=kernel_size, stride=stride, padding='same')) #Conv
+    else:
+        layers.append(nn.Conv1d(n_input, n_output, kernel_size=kernel_size, stride=stride)) #Conv
+    layers.append(nn.BatchNorm1d(n_output))
+    layers.append(nn.ReLU())
+    return nn.Sequential(*layers)
+
+#basic 2-conv residual block
+class ResidualBlock(nn.Module):
+    def __init__(self, n_channels, kernel_size):
+        super().__init__()
+       
+        self.conv_block1 = conv_block(n_channels, n_channels, stride = 1, kernel_size=kernel_size)
+        self.conv_block2 = conv_block(n_channels, n_channels, stride= 1, kernel_size=3)
+    
+    def forward(self, x):
+        
+        identity = x
+        x = self.conv_block1(x)
+        x = self.conv_block2(x)
+        x = x + identity
+        return x
+
+    
+class ResNetRagaClassifier(nn.Module):
+    def __init__(self, params):
+        super().__init__()
+        n_input = params.n_input
+        n_channel = params.n_channel
+        stride = params.stride
+        self.n_blocks = params.n_blocks
+        self.conv_first = conv_block(n_input, n_channel, stride=stride, kernel_size = 80)
+        self.max_pool_every = params.max_pool_every
+
+        self.res_blocks = nn.ModuleList() #Residual Blocks
+        for i in range(self.n_blocks):
+            self.res_blocks.append(ResidualBlock(n_channel, kernel_size=3))
+        
+        #linear classification head
+        self.fc1 = nn.Linear(n_channel, params.num_classes)
+        
+                                    
+    def forward(self, x):
+        #initial conv
+        x = self.conv_first(x)
+
+        #residual blocks
+        for i, block in enumerate(self.res_blocks):
+            x = block(x)
+            if i % self.max_pool_every == 0:
+                x = F.max_pool1d(x, 2)
+        
+        #classification head
+        x = F.avg_pool1d(x, x.shape[-1])
+        x = x.permute(0, 2, 1)
+        x = self.fc1(x)
+        x = F.log_softmax(x, dim=-1)
+        
+        return x
+
+
+class BaseRagaClassifier(nn.Module):
+    def __init__(self, params):
+        super().__init__()
+        n_input = params.n_input
+        n_channel = params.n_channel
+        stride = params.stride
+        self.conv_blocks = []
+        
+        self.conv_block1 = conv_block(n_input, n_channel, stride=stride, kernel_size=80)
+        self.conv_block2 = conv_block(n_channel, n_channel, stride=1, kernel_size=3)
+        self.conv_block3 = conv_block(n_channel, 2*n_channel, stride=1, kernel_size=3)
+        self.conv_block4 = conv_block(2*n_channel, 2*n_channel, stride=1, kernel_size=3)
+        self.fc1 = nn.Linear(2 * n_channel, params.num_classes)
+
+    def forward(self, x):
+        x = self.conv_block1(x)
+        x = F.max_pool1d(x, 4)
+        x = self.conv_block2(x)
+        x = F.max_pool1d(x, 4)
+        x = self.conv_block3(x)
+        x = F.max_pool1d(x, 4)
+        x = self.conv_block4(x)
+        x = F.avg_pool1d(x, x.shape[-1])
+        x = x.permute(0, 2, 1)
+        x = self.fc1(x)
+        x = F.log_softmax(x, dim=-1)
+        return x
+
+
+class Wav2VecTransformer(nn.Module):
+    def __init__(self, params):
+        super().__init__()
+        self.params = params
+        self.extractor_mode = params.extractor_mode
+        self.extractor_conv_layer_config = params.extractor_conv_layer_config
+        self.extractor_conv_bias = params.extractor_conv_bias
+        self.encoder_embed_dim = params.encoder_embed_dim
+        self.encoder_projection_dropout = params.encoder_projection_dropout
+        self.encoder_pos_conv_kernel = params.encoder_pos_conv_kernel
+        self.encoder_pos_conv_groups = params.encoder_pos_conv_groups
+        self.encoder_num_layers  = params.encoder_num_layers
+        self.encoder_num_heads = params.encoder_num_heads
+        self.encoder_attention_dropout = params.encoder_attention_dropout
+        self.encoder_ff_interm_features =  params.encoder_ff_interm_features
+        self.encoder_ff_interm_dropout = params.encoder_ff_interm_dropout
+        self.encoder_dropout = params.encoder_dropout
+        self.encoder_layer_norm_first = params.encoder_layer_norm_first
+        self.encoder_layer_drop = params.encoder_layer_drop
+        self.aux_num_out = params.num_classes
+
+        self.extractor_conv_layer_config = [
+                                            (32, 80, 16),
+                                            (64, 5, 4),
+                                            (128, 5, 4),
+                                            (256, 5, 4),
+                                            (512, 3, 2),
+                                            (512, 2, 2),
+                                            (512, 2, 2),
+                                            ]
+        self.encoder = wav2vec2_model(self.extractor_mode, \
+                        self.extractor_conv_layer_config, \
+                        self.extractor_conv_bias, \
+                        self.encoder_embed_dim, \
+                        self.encoder_projection_dropout,\
+                        self.encoder_pos_conv_kernel,\
+                        self.encoder_pos_conv_groups,\
+                        self.encoder_num_layers,
+                        self.encoder_num_heads,
+                        self.encoder_attention_dropout,
+                        self.encoder_ff_interm_features,
+                        self.encoder_ff_interm_dropout,
+                        self.encoder_dropout,\
+                        self.encoder_layer_norm_first,\
+                        self.encoder_layer_drop,
+                        aux_num_out = None)
+        
+        self.audio_length = params.sample_rate*params.clip_length
+        self.classification_head = nn.Linear(int(self.audio_length/(16*4*4*4*2*2*2))*params.encoder_embed_dim, params.num_classes)
+
+    def forward(self, x):
+        x = self.encoder(x)[0]
+        x = x.reshape(x.shape[0], -1) # flatten
+        x = self.classification_head(x)
+        x = F.log_softmax(x, dim=-1)
+        return x
+
+        
+
+
+
+
+

requirements.txt

@@ -0,0 +1,3 @@
+torch
+torchaudio
+numpy

utils/YParams.py

@@ -0,0 +1,47 @@
+from ruamel.yaml import YAML
+import logging
+
+class YParams():
+  """ Yaml file parser """
+  def __init__(self, yaml_filename, config_name, print_params=False):
+    self._yaml_filename = yaml_filename
+    self._config_name = config_name
+    self.params = {}
+
+    if print_params:
+      print("------------------ Configuration ------------------")
+
+    with open(yaml_filename) as _file:
+
+      for key, val in YAML().load(_file)[config_name].items():
+        if print_params: print(key, val)
+        if val =='None': val = None
+
+        self.params[key] = val
+        self.__setattr__(key, val)
+
+    if print_params:
+      print("---------------------------------------------------")
+
+  def __getitem__(self, key):
+    return self.params[key]
+
+  def __setitem__(self, key, val):
+    self.params[key] = val
+    self.__setattr__(key, val)
+
+  def __contains__(self, key):
+    return (key in self.params)
+
+  def update_params(self, config):
+    for key, val in config.items():
+      self.params[key] = val
+      self.__setattr__(key, val)
+
+  def log(self):
+    logging.info("------------------ Configuration ------------------")
+    logging.info("Configuration file: "+str(self._yaml_filename))
+    logging.info("Configuration name: "+str(self._config_name))
+    for key, val in self.params.items():
+        logging.info(str(key) + ' ' + str(val))
+    logging.info("---------------------------------------------------")

utils/logging_utils.py

@@ -0,0 +1,32 @@
+import os
+import logging
+
+_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+
+def config_logger(log_level=logging.INFO):
+  logging.basicConfig(format=_format, level=log_level)
+
+def log_to_file(logger_name=None, log_level=logging.INFO, log_filename='tensorflow.log'):
+
+  if not os.path.exists(os.path.dirname(log_filename)):
+    os.makedirs(os.path.dirname(log_filename))
+
+  if logger_name is not None:
+    log = logging.getLogger(logger_name)
+  else:
+    log = logging.getLogger()
+
+  fh = logging.FileHandler(log_filename)
+  fh.setLevel(log_level)
+  fh.setFormatter(logging.Formatter(_format))
+  log.addHandler(fh)
+
+def log_versions():
+  import torch
+  import subprocess
+
+  logging.info('--------------- Versions ---------------')
+  logging.info('git branch: ' + str(subprocess.check_output(['git', 'branch']).strip()))
+  logging.info('git hash: ' + str(subprocess.check_output(['git', 'rev-parse', 'HEAD']).strip()))
+  logging.info('Torch: ' + str(torch.__version__))
+  logging.info('----------------------------------------')