pranav6670/detection-classification-of-tabla-taals

This repository is a Python-based audio ML system for detecting and classifying Indian tabla talas from recorded music. The architecture is centered on an offline training pipeline plus a separate real-time inference/visualization app.

1. Core problem domain

The system classifies tabla rhythm patterns into tala classes. The README indicates 10 tala classes, with the dataset stored as many .wav recordings under wavfiles/ and a larger preprocessed corpus under clean/.

2. Data layer

Raw audio lives in wavfiles/; derived/cleaned audio is kept in clean/. These folders are not just assets but part of the pipeline: the project expects preprocessing to transform source recordings into normalized, denoised clips before training or prediction.

3. Preprocessing subsystem

dataops.py is the main data preparation step. The README says it performs downsampling from 44.1 kHz to 16 kHz and applies noise-threshold cleaning using envelope detection. This is the boundary between raw recordings and feature/model inputs.

4. Feature extraction and signal processing

Several modules support audio analysis: hprss.py for harmonic-percussive source separation, Vocalseparation.py for vocal separation, spectograms.py for spectrogram generation, and cfg.py for MFCC-related configuration. These scripts are the signal-processing layer feeding the ML models.

5. Training subsystem

model.py is the main training entry point. It builds the model, creates pickles for faster reuse, and trains either a CNN or an LSTM depending on config.mode. The README mentions myCNN.py as the CNN implementation, so model definitions are split from orchestration.

6. Model artifacts

Trained models are written outside the source tree into models/ (for example conv.model and rec.model), while precomputed dataset artifacts are saved into pickles/. This creates a clear separation between code, training data, and generated artifacts.

7. Inference subsystem

predict.py loads a trained model and runs classification on a sample or CSV-driven input. test.csv and predict.csv appear to be sample input/output files used during evaluation or batch prediction.

8. Real-time application

main.py is the runtime app for live classification and visualization. It ties together audio capture, FFT/time-domain displays, spectrograms, and prediction, so it is the main interactive boundary with the user.

9. Audio capture and live backend

PNstreamsetup.py provides the audio backend for live audio and FFT, while audioBackend.py and recordAudio.py support audio streaming/recording. These modules are the ingestion path for microphone or live input into the runtime app.

10. GUI layer

The UI is built with PyQt5. GUI.py is generated from Qt Designer, with main_1.ui and test.qrc as design/resource sources. mainui.py, guiGO.py, and auvdiovis_Qt.py appear to be glue or experiment files around the GUI/runtime integration.

11. Visualization subsystem

liveSpectogram.py, audiovis_test1.py, and related modules implement plots for raw waveform, FFT, spectrogram, and HPSS-based views. The README explicitly shows these as part of the user-facing live analysis experience.

12. End-to-end data flow

The typical flow is: raw .wav data in wavfiles/ → preprocessing/cleaning in dataops.py → feature extraction/configuration via cfg.py and signal-processing helpers → pickled training data and trained models in pickles/ and models/ → offline prediction via predict.py or live classification via main.py with the PyQt GUI and audio backend.

13. Repo structure implication

This is not a service-oriented or web architecture; it is a desktop/audio-ML application with a strong offline training pipeline and a separate real-time visualization/classification path. The main diagram boundaries should be drawn around data preparation, model training, inference, and live UI/audio capture.