{"id":44179066,"url":"https://github.com/magcil/deepaudio-x","last_synced_at":"2026-04-20T13:13:37.147Z","repository":{"id":325083386,"uuid":"1059944603","full_name":"magcil/deepaudio-x","owner":"magcil","description":"A python library to train Deep Neural Networks on various audio tasks using Self-Supervised backbones.","archived":false,"fork":false,"pushed_at":"2026-04-02T13:28:11.000Z","size":7659,"stargazers_count":12,"open_issues_count":1,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-04-02T19:50:40.869Z","etag":null,"topics":["audio-classificaton","audio-embedding","audio-foundational-models","audio-processing","deep-learning","feature-extraction","pretrained-model","python","pytorch","self-supervised-learning","speech-processing","transformer"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/magcil.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-09-19T07:02:11.000Z","updated_at":"2026-04-02T13:20:59.000Z","dependencies_parsed_at":"2026-04-02T09:02:44.675Z","dependency_job_id":null,"html_url":"https://github.com/magcil/deepaudio-x","commit_stats":null,"previous_names":["magcil/deepaudio-x"],"tags_count":20,"template":false,"template_full_name":null,"purl":"pkg:github/magcil/deepaudio-x","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/magcil%2Fdeepaudio-x","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/magcil%2Fdeepaudio-x/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/magcil%2Fdeepaudio-x/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/magcil%2Fdeepaudio-x/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/magcil","download_url":"https://codeload.github.com/magcil/deepaudio-x/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/magcil%2Fdeepaudio-x/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32048545,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-20T11:35:06.609Z","status":"ssl_error","status_checked_at":"2026-04-20T11:34:48.899Z","response_time":94,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["audio-classificaton","audio-embedding","audio-foundational-models","audio-processing","deep-learning","feature-extraction","pretrained-model","python","pytorch","self-supervised-learning","speech-processing","transformer"],"created_at":"2026-02-09T14:04:42.836Z","updated_at":"2026-04-20T13:13:37.139Z","avatar_url":"https://github.com/magcil.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# DeepAudioX\n\n[![docs-dev](https://img.shields.io/badge/docs--dev-latest-blue)](https://deepaudio-x.readthedocs.io/en/latest/)\n[![PyPI version](https://img.shields.io/pypi/v/deepaudio-x.svg?cacheSeconds=10\u0026v=1)](https://pypi.org/project/deepaudio-x/)\n[![Python versions](https://img.shields.io/pypi/pyversions/deepaudio-x.svg?cacheSeconds=300)](https://pypi.org/project/deepaudio-x/)\n[![License](https://img.shields.io/github/license/magcil/deepaudio-x.svg)](https://github.com/magcil/deepaudio-x/blob/main/LICENSE)\n[![Run Tests](https://github.com/magcil/deepaudio-x/actions/workflows/tests.yml/badge.svg)](https://github.com/magcil/deepaudio-x/actions/workflows/tests.yml)\n[![Publish to PyPI](https://github.com/magcil/deepaudio-x/actions/workflows/publish.yml/badge.svg)](https://github.com/magcil/deepaudio-x/actions/workflows/publish.yml)\n\n\n\u003cp align=\"left\"\u003e\n  \u003cimg src=\"docs/source/_static/DeepAudioX_whitebg.png\" style=\"width: 60%\" alt=\"DeepAudio-X logo\"\u003e\n\u003c/p\u003e\n\n\nDeepAudioX is a PyTorch-based library that provides **simple, flexible pipelines for audio classification** using **pretrained audio foundation models** as feature extractors.\n\nIt is designed to let users train, evaluate, and run inference on **custom audio datasets** with only a few lines of code, while still allowing advanced customization when needed.\n\n## Key Features\n\n- 🔊 **Pretrained audio backbones** for feature extraction  \n- 🧠 **Modular pooling strategies** (e.g. GAP, SimPool, EfficientProbing)\n- 🧩 **Custom classifier heads** for downstream audio classification\n- 🚀 **High-level training, evaluation, and inference APIs**\n- 🔁 Fully **PyTorch-native** and extensible\n- 📦 Clean integration with existing PyTorch workflows\n\n---\n\n## Installation\n\nFor PyPI installs, we recommend creating a virtual environment with a supported Python version first.\n\n### Virtual Environment\n\nDeepAudioX supports Python 3.11, 3.12, and 3.13. You can create a virtual environment using `uv` or Miniconda and then install DeepAudioX from PyPI.\n\n**Option A: uv (recommended)**\n\nInstall `uv` following the official guide (see: [Astral uv installation docs](https://docs.astral.sh/uv/getting-started/installation/)), then create a virtual environment:\n\n```bash\nuv venv --python 3.12 .venv\nsource .venv/bin/activate\nuv pip install deepaudio-x\n```\n\n**Option B: Miniconda**\n\n```bash\nconda create -n deepaudiox python=3.12\nconda activate deepaudiox\npip install deepaudio-x\n```\n\n### Install From Source\n\nClone the repo and use `uv sync` to install dependencies from `pyproject.toml`:\n\n```bash\ngit clone git@github.com:magcil/deepaudio-x.git\ncd deepaudio-x\nuv sync\n```\n---\n\n## Quick Start\n\n### Creating an Audio Classification Dataset\n\nDeepAudioX provides flexible dataset creation methods for audio classification tasks. Here are the main approaches:\n\n#### Method 1: From Directory Structure\n\nIf your audio files are organized in subdirectories where each subdirectory name is a class label:\n\n```\ndata/\n├── speech/\n│   ├── audio1.wav\n│   ├── audio2.wav\n│   └── ...\n├── music/\n│   ├── audio3.wav\n│   ├── audio4.wav\n│   └── ...\n└── noise/\n    ├── audio5.wav\n    └── ...\n```\n\nYou can load the dataset as follows:\n\n```python\nfrom deepaudiox import audio_classification_dataset_from_dir\nfrom deepaudiox import get_class_mapping_from_dir\n\n# Define a class mapping\nclass_mapping = get_class_mapping_from_dir(root_dir=\"path/to/data\")\n\ndataset = audio_classification_dataset_from_dir(\n    root_dir=\"path/to/data\",\n    sample_rate=16_000,  # sampling rate in Hz\n    class_mapping=class_mapping\n)\n```\n\n#### Method 2: From Custom File-to-Class Mapping\n\nIf your audio files aren't organized in subdirectories, or you need custom mappings, you can create a dictionary mapping file paths to class labels:\n\n```python\nfrom deepaudiox import audio_classification_dataset_from_dictionary\n\n# Create a file-to-class mapping\nfile_to_class_mapping = {\n    \"path/to/audio1.wav\": \"speech\",\n    \"path/to/audio2.wav\": \"speech\",\n    \"path/to/audio3.wav\": \"music\",\n    # ... more mappings\n}\n\n# Create a class-to-id mapping\nclass_mapping = {\"speech\": 0, \"music\": 1, \"noise\": 2}\n\n# Initialize the dataset\ndataset = audio_classification_dataset_from_dictionary(\n    file_to_class_mapping=file_to_class_mapping,\n    sample_rate=16_000,\n    class_mapping=class_mapping\n)\n```\n\n#### Audio Segmentation\n\nTo split long audio files into fixed-duration segments, use the `segment_duration` parameter:\n\n```python\n# Create dataset with 2-second audio segments\ndataset = audio_classification_dataset_from_dir(\n    root_dir=\"path/to/data\",\n    sample_rate=16_000,\n    segment_duration=2.0,  # Duration in seconds\n    class_mapping=class_mapping\n)\n```\n\nWhen `segment_duration` is specified, each audio file is divided into non-overlapping segments of the given duration. Each segment is treated as an independent sample in the dataset, with the same class label as the original audio file. The `segment_idx` field in the dataset output indicates which segment a sample corresponds to.\n\n**Example**: A 10-second audio file with `segment_duration=2.0` will produce 5 separate samples, each 2 seconds long, all with the same class label.\n\nBoth methods return an `AudioClassificationDataset` object that can be used with PyTorch's DataLoader for training and evaluation.\n\n#### Dataset Output Format\n\nEach item returned by the dataset is a dictionary containing:\n\n```python\n{\n    \"path\": str,                # File path of the audio\n    \"y_true\": int,              # Integer class ID\n    \"class_name\": str,          # String class label\n    \"segment_idx\": int,         # Segment index (for segmented audio)\n    \"feature\": np.ndarray       # Audio waveform as numpy array\n}\n```\n\nExample usage:\n\n```python\nfrom torch.utils.data import DataLoader\n\ndataloader = DataLoader(dataset, batch_size=32)\n\nfor batch in dataloader:\n    paths = batch[\"path\"]           # File paths\n    class_ids = batch[\"y_true\"]     # Shape: (batch_size,)\n    class_names = batch[\"class_name\"]  # Class names\n    segment_indices = batch[\"segment_idx\"]  # Segment indices\n    waveforms = batch[\"feature\"]    # Shape: (batch_size, num_samples)\n```\n\n## Create an Audio Classifier with Pretrained Backbone\n\nDeepAudioX simplifies the creation of audio classifiers by combining pretrained audio backbones with custom classifier heads. Here's how to build and configure a classifier:\n\n### Basic Setup\n\n```python\nfrom deepaudiox import AudioClassifier\n\n# Initialize classifier with pretrained BEATs backbone\nclassifier = AudioClassifier(\n    num_classes=10,              # Number of output classes\n    backbone=\"beats\",            # Pretrained backbone (e.g., \"beats\")\n    sample_rate=16_000,          # Audio sample rate\n    pretrained=True,             # Use pretrained weights\n    freeze_backbone=True         # Freeze backbone for fine-tuning\n)\n```\n\n**Note**: When `pretrained=True`, the BEATs model will be automatically downloaded and cached in your OS-specific cache directory (e.g., `~/.cache` on Linux). The library does not contain pretrained model files (`.pt` files), keeping the repository lightweight. Subsequent uses will load the model from the cache.\n\n### Available Backbones\n\n- **BEATs** (`\"beats\"`): BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)\n- **PaSST** (`\"passt\"`): Efficient Training of Audio Transformers with Patchout (https://arxiv.org/abs/2110.05069)\n- **MobileNet (0.5x, AudioSet)** (`\"mobilenet_05_as\"`): MobileNetV3 audio backbone pretrained on AudioSet\n- **MobileNet (1.0x, AudioSet)** (`\"mobilenet_10_as\"`): MobileNetV3 audio backbone pretrained on AudioSet\n- **MobileNet (4.0x, AudioSet)** (`\"mobilenet_40_as\"`): MobileNetV3 audio backbone pretrained on AudioSet\n  Width multipliers (`0.5x`, `1.0x`, `4.0x`) scale convolution channel sizes. Reference: https://arxiv.org/abs/2211.04772\n\n### Key Parameters\n\n- `num_classes`: Number of output classification classes\n- `sample_rate`: Audio sampling rate (Hz) - must match your dataset\n- `pretrained`: Whether to use pretrained weights (recommended)\n- `freeze_backbone`: Freeze backbone parameters during training (reduces parameters to fine-tune)\n\n### Optional: Custom Pooling Strategies\n\nYou can customize the pooling strategy used to aggregate audio features:\n\n```python\n\nclassifier = AudioClassifier(\n    num_classes=10,\n    backbone=\"beats\",\n    sample_rate=16_000,\n    pretrained=True,\n    freeze_backbone=True,\n    pooling=\"gap\"\n)\n```\n\n**Supported pooling names**: `\"gap\"`, `\"simpool\"`, `\"ep\"`\n\n### Backbone-Only Usage\n\nIf you only need the pretrained backbone (for feature extraction or custom heads), you can instantiate it directly with `Backbone`:\n\n```python\nfrom deepaudiox import Backbone\n\nbackbone = Backbone(\n    backbone=\"beats\",\n    pretrained=True,\n    freeze_backbone=True,\n    pooling=\"gap\",\n    sample_rate=16_000\n)\n```\n\nYou can access both the raw backbone output and the pooled embeddings:\n\n```python\nimport torch\n\nwaveforms = torch.randn(2, 5 * 16_000)  # (batch, samples)\n\nfeatures = backbone.forward(waveforms)  # raw backbone features: (B, N, D) for Transformer or (B, D, H, W) for CNN\nembeddings = backbone.forward_with_pooling(waveforms)  # pooled embeddings\n```\n\n### Input and Output Expectations\n\n- Inputs to backbones and classifiers are mono waveforms shaped `(B, T)` where `T` depends on sample rate and duration.\n- `AudioClassifier` outputs logits shaped `(B, num_classes)`.\n- `Backbone.forward(...)` returns either `(B, N, D)` for Transformer backbones or `(B, D, H, W)` for CNN backbones.\n- `Backbone.forward_with_pooling(...)` returns pooled embeddings shaped `(B, D)`.\n\nAvailable pooling strategies include:\n- **GAP**: Simple average pooling\n- **SimPool**: As presented in \"Keep It SimPool: Who Said Supervised Transformers Suffer from Attention Deficit?\" (https://arxiv.org/pdf/2309.06891)\n- **EP**: As presented in \"Attention, Please! Revisiting Attentive Probing Through the Lens of Efficiency\"(https://arxiv.org/abs/2506.10178)\n\nNormally, attentive pooling methods like ep and simpool will perform better than the Global Average Pooling (GAP).\n\nThe classifier is now ready for training or inference.\n\n## Training\n\nTrain your audio classifier with a few lines of code using the built-in `Trainer` class:\n\n#### Minimal Example (Recommended)\n\n```python\nfrom deepaudiox import Trainer\n\n# Initialize trainer with defaults\ntrainer = Trainer(\n    train_dset=train_dataset,\n    model=classifier,\n    validation_dset=val_dataset,  # Optional\n    batch_size=32,\n    epochs=100,\n    num_workers=4,\n    patience=20,\n    device=\"cuda\",  # \"cuda\", \"mps\" (Apple Silicon), or \"cpu\"\n)\n\n# Start training\ntrainer.train()\n```\n\nBy default, the trainer uses:\n- **Optimizer**: Adam with learning rate `1e-3`\n- **Scheduler**: ReduceLROnPlateau with patience `10`\n\n#### Advanced: Custom Optimizer and Scheduler\n\nFor more control, you can provide custom optimizer and learning rate scheduler:\n\n```python\nfrom torch.optim import Adam\nfrom torch.optim.lr_scheduler import CosineAnnealingLR\nfrom deepaudiox import Trainer\n\noptimizer = Adam(classifier.parameters(), lr=1e-2)\nlr_scheduler = CosineAnnealingLR(optimizer=optimizer, T_max=100, eta_min=1e-6)\n\ntrainer = Trainer(\n    train_dset=train_dataset,\n    model=classifier,\n    validation_dset=val_dataset,\n    optimizer=optimizer,\n    lr_scheduler=lr_scheduler,\n    batch_size=32,\n    epochs=100,\n    num_workers=4,\n    patience=20,\n    path_to_checkpoint=\"checkpoint.pt\"\n)\n\ntrainer.train()\n```\n\n\u003e **Note:** The checkpoint saved at `path_to_checkpoint` contains both the model weights and the architecture config (backbone, pooling, num_classes, etc.). You can restore the full model in one line:\n\u003e ```python\n\u003e from deepaudiox import AudioClassifier\n\u003e model = AudioClassifier.from_checkpoint(\"checkpoint.pt\")\n\u003e print(model.config)  # {\"backbone\": \"beats\", \"pooling\": \"gap\", ...}\n\u003e ```\n\n### Trainer Parameters\n\n- `train_dset`: Training dataset (AudioClassificationDataset)\n- `model`: Audio classifier model to train\n- `validation_dset`: Optional validation dataset for monitoring (if None, will split from train_dset)\n- `optimizer`: Optional custom PyTorch optimizer (default: Adam with lr=1e-3)\n- `lr_scheduler`: Optional custom learning rate scheduler (default: ReduceLROnPlateau with patience=10)\n- `batch_size`: Number of samples per batch (default: 16)\n- `epochs`: Maximum number of training epochs (default: 100)\n- `patience`: Number of epochs with no improvement before early stopping (default: 15)\n- `num_workers`: Number of workers for data loading (default: 4)\n- `path_to_checkpoint`: Path to save the best model checkpoint (default: \"checkpoint.pt\")\n- `device`: Device to use for training — `\"cuda\"`, `\"mps\"` (Apple Silicon GPU), or `\"cpu\"` (default: `\"cuda\"`)\n- `device_index`: GPU index to use when `device=\"cuda\"` and multiple GPUs are available (optional)\n\n### Features\n\n- **Automatic Checkpointing**: Saves the best model based on validation loss\n- **Early Stopping**: Stops training when validation loss plateaus\n- **Progress Tracking**: Displays training progress with loss metrics\n- **Device Selection**: Supports `\"cuda\"`, `\"mps\"` (Apple Silicon), and `\"cpu\"` via the `device` parameter\n\n## Evaluate\n\nEvaluate your trained classifier on a test dataset using the `Evaluator` class:\n\n```python\nfrom deepaudiox import AudioClassifier, Evaluator\n\n# Load model with architecture and weights restored from checkpoint\nclassifier = AudioClassifier.from_checkpoint(\"checkpoint.pt\")\n\n# Initialize evaluator\nevaluator = Evaluator(\n    test_dset=test_dataset,\n    model=classifier,\n    class_mapping=class_mapping,\n    batch_size=32,\n    num_workers=4,\n    device=\"cuda\",  # \"cuda\", \"mps\" (Apple Silicon), or \"cpu\"\n)\n\n\n# Run evaluation\nevaluator.evaluate()\n\n# Access evaluation results\ny_true = evaluator.state.y_true       # True labels\ny_pred = evaluator.state.y_pred       # Predicted labels\nposteriors = evaluator.state.posteriors  # Prediction probabilities\n```\n\n### Evaluator Parameters\n\n- `test_dset`: Test dataset (AudioClassificationDataset)\n- `model`: Trained audio classifier model\n- `class_mapping`: Dictionary mapping class names to IDs\n- `batch_size`: Number of samples per batch (default: 16)\n- `num_workers`: Number of workers for data loading (default: 4)\n- `device`: Device to use for evaluation — `\"cuda\"`, `\"mps\"` (Apple Silicon GPU), or `\"cpu\"` (default: `\"cuda\"`)\n- `device_index`: GPU index to use when `device=\"cuda\"` and multiple GPUs are available (optional)\n\n### Evaluation Results\n\nThe evaluator stores predictions in its state:\n- `y_true`: Ground truth labels as NumPy array\n- `y_pred`: Predicted class IDs as NumPy array\n- `posteriors`: Class probability distributions as NumPy array\n\nYou can use these results to compute metrics like accuracy, precision, recall, F1-score, etc.:\n\n```python\nfrom sklearn.metrics import accuracy_score, classification_report\n\naccuracy = accuracy_score(evaluator.state.y_true, evaluator.state.y_pred)\nprint(f\"Accuracy: {accuracy:.4f}\")\nprint(classification_report(evaluator.state.y_true, evaluator.state.y_pred))\n```\n\n---\n\n## Running Inference\n\nThe `BaseAudioClassifier` exposes two convenience methods for inference on raw waveforms or audio files.\n\nBoth methods return a dictionary with:\n- `final_label`: Predicted class label (string).\n- `final_posterior`: Posterior probability for the predicted class.\n- `segment_labels`: List of per-segment labels (only when `segment_duration` is used and the audio is longer than that duration).\n- `segment_posteriors`: List of per-segment posteriors aligned with `segment_labels` (only when `segment_duration` is used and the audio is longer than that duration).\n\nThe `segment_duration` argument (in seconds) enables segment-level inference. If provided and the audio is longer than the segment length, the waveform is split into equal segments, each segment is classified, and the final label is chosen by majority vote (ties are resolved by higher mean posterior for the class).\n\n### `inference_on_waveform`\n\nUse this when you already have a waveform tensor or NumPy array.\n\n```python\nimport torch\nfrom deepaudiox import AudioClassifier\n\nclassifier = AudioClassifier(\n    backbone=\"beats\",\n    num_classes=2,\n    sample_rate=16_000,\n    pretrained=True,\n)\n\nclass_mapping = {\"dog\": 0, \"cat\": 1}\nwaveform = torch.randn(5 * 16_000)  # 5 seconds of mono audio\n\nprediction = classifier.inference_on_waveform(\n    waveform,\n    sample_rate=16_000,\n    class_mapping=class_mapping,\n    segment_duration=1.0,  # Optional: segment-level inference with majority vote\n)\n\nprint(prediction)\n```\n\n### `inference_on_file`\n\nUse this when you want the model to load audio directly from disk.\n\n```python\nfrom deepaudiox import AudioClassifier\n\nclassifier = AudioClassifier(\n    backbone=\"beats\",\n    num_classes=2,\n    sample_rate=16_000,\n    pretrained=True,\n)\n\nclass_mapping = {\"dog\": 0, \"cat\": 1}\n\nprediction = classifier.inference_on_file(\n    \"data/example.wav\",\n    sample_rate=16_000,\n    class_mapping=class_mapping,\n    segment_duration=2.0,  # Optional\n)\n\nprint(prediction)\n```\n\n---\n\n\n## Customization\n\nAdvanced users can:\n\n- **Plug in custom backbones** - Implement your own audio feature extractors\n- **Implement new pooling layers** - Create custom aggregation strategies for sequence features\n- **Define custom classifier heads** - Design specialized classification architectures\n- **Override training loops** - Customize the training process while keeping the pipeline structure\n\nThe library is designed to scale from quick experiments to research and production use.\n\n---\n\n\n## Attribution\n\nThis project is developed at MagCIL and is created and primarily maintained by:\n\n- Christos Nikou ([@ChrisNick92](https://github.com/ChrisNick92))\n- Stefanos Vlachos ([@stefanos-vlachos](https://github.com/stefanos-vlachos))\n- Ellie Vakalaki ([@ellievak](https://github.com/ellievak))\n\n---\n\n## Citation\n\nIf you use this library in academic work, please cite:\n\n```bibtex\n@software{DeepAudioX,\n  author = {Nikou, Christos and Vlachos, Stefanos and Vakalaki, Ellie and Giannakopoulos, Theodoros},\n  title = {DeepAudioX: A PyTorch-based audio classification framework},\n  year = {2026},\n  url = {https://github.com/magcil/deepaudio-x}\n}\n```\n\n---\n\n## Contributing\n\nContributions are welcome! Please refer to [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to set up the development environment, run tests, and submit changes.\n\n---\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmagcil%2Fdeepaudio-x","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmagcil%2Fdeepaudio-x","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmagcil%2Fdeepaudio-x/lists"}