diff --git a/.github/workflows/CD.yml b/.github/workflows/CD.yml new file mode 100644 index 0000000..21e5239 --- /dev/null +++ b/.github/workflows/CD.yml @@ -0,0 +1,62 @@ +name: CD + +on: + push: + branches: + - main + - clavrat/proto-crepe + tags: + - '*.*.*' # Adjust this pattern to match your tag format + +jobs: + build_and_release: + name: Build and Upload Release + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v3 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.12' + + - name: Install Poetry + run: | + pip install poetry + + - name: Build the package + run: | + poetry build + + - name: Create Release + id: create_release + uses: actions/create-release@v1.0.0 + env: + GITHUB_TOKEN: ${{ secrets.PAT_TOKEN }} + with: + tag_name: ${{ github.ref }} + release_name: Release ${{ github.ref }} + draft: false + prerelease: false + + - name: Get Name of Artifact + run: | + ARTIFACT_PATHNAME=$(ls dist/*.whl | head -n 1) + ARTIFACT_NAME=$(basename $ARTIFACT_PATHNAME) + echo "ARTIFACT_PATHNAME=${ARTIFACT_PATHNAME}" >> $GITHUB_ENV + echo "ARTIFACT_NAME=${ARTIFACT_NAME}" >> $GITHUB_ENV + + - name: Upload Whl to Release Assets + id: upload-release-asset + uses: actions/upload-release-asset@v1.0.2 + env: + GITHUB_TOKEN: ${{ secrets.PAT_TOKEN }} + with: + upload_url: ${{ steps.create_release.outputs.upload_url }} + asset_path: ${{ env.ARTIFACT_PATHNAME }} + asset_name: ${{ env.ARTIFACT_NAME }} + asset_content_type: application/x-wheel+zip + + \ No newline at end of file diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 0000000..bb4aa2a --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,28 @@ +name: CI + +on: [push, pull_request] + +jobs: + linter: + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v3 + + - name: Lint with flake8 + run: | + pip install flake8 + flake8 ./crepe --count --select=E9,F63,F7,F82 --show-source --statistics +# flake8 ./crepe --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + + + doc_coverage: + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v3 + + - name: Check documentation coverage with pydocstyle + run: | + pip install pydocstyle + pydocstyle ./crepe diff --git a/.gitignore b/.gitignore index 82f9275..eaeb781 100644 --- a/.gitignore +++ b/.gitignore @@ -160,3 +160,6 @@ cython_debug/ # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ +dataset/* +wandb/* +.prompts/* \ No newline at end of file diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 261eeb9..0000000 --- a/LICENSE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/README.md b/README.md index 2dc6323..3fa40cf 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,76 @@ -# TorchCrepe -Implementation of the crepe pitch extractor in PyTorch +
+ Banner +
+ +

+ Interactive Demo + • + Video + • + Python API +

+ +
+ + License + + Python Versions + + CI + +
+ +

The Torch-CREPE project re-develop the CREPE pitch estimation model in PyTorch, empowering its optimization and adaptation for real-time voice pitch detection tasks. By re-developping this deep learning-based system, we unlock new research possibilities for music signal processing and audio analysis applications.

+ +## How it Works + +The **PyTorch CREPE** implementation utilizes the **Torch** and **Torchaudio** library to process and analyze audio signals. The project's core functionality is based on the CREPE model, which estimates fundamental frequencies from audio data. + +The way this model achieve this is by doing a classification of 20ms audio chunks on 350 classes representing the audio range in cents of the observed fundamental frequency. + +## Features + +- **Real-time pitch detection:** Processing done in realtime using the given script. +- **Optimized for instrument and voices:** Trained on instruments and voices for maximum usescases focuses. +- **Deep learning-based**: system with full PyTorch implementation +- **Fast Integration** with Torchaudio library +- **Trainable on Consumer GPU** (complete train done on an RTX-3080) + +## Run app locally + +To run the PyTorch CREPE demo locally, you can use the following Python code: + +```py +import torchaudio +from crepe.model import crepe +from crepe.utils import load_test_file + +crepe = crepe(model_capacity="tiny", device='cpu') + +audio, sr = load_test_file() + +time, frequency, confidence, activation = crepe.predict( + audio=audio, + sr = sr +) +``` + +## Python API + +For a detailed documentation of the PyTorch CREPE implementation, including the API and usage guidelines, please refer to [this link]. + +## Train + +The model is still in my training queue so only the 'tiny' version of **Crepe** has been trained yet. + +## Datasets + +[MIR-1K](http://mirlab.org/dataset/public/MIR-1K.zip) + +## Contributing + +This project is an open-source project, and contributions are always welcome. If you would like to contribute to the project, you can do so by submitting a pull request or by creating an issue on the project's GitHub page. + +## License + +This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details. diff --git a/TorchCREPE_banner.png b/TorchCREPE_banner.png new file mode 100644 index 0000000..0a1b107 Binary files /dev/null and b/TorchCREPE_banner.png differ diff --git a/crepe/crepe-tiny.pth b/crepe/crepe-tiny.pth new file mode 100644 index 0000000..98a6a39 Binary files /dev/null and b/crepe/crepe-tiny.pth differ diff --git a/crepe/dataset.py b/crepe/dataset.py new file mode 100644 index 0000000..1855a71 --- /dev/null +++ b/crepe/dataset.py @@ -0,0 +1,332 @@ +"""This file contains various dataloader for training and processing audio data and labels.""" + +from torch.utils.data import Dataset +import os +import torch +import torchaudio +import glob +import json +from torch.utils.data import Dataset, ConcatDataset +from concurrent.futures import ThreadPoolExecutor, as_completed + + +class MIR1KDataset(Dataset): + """ + MIR-1K Dataset. + + Args: + Dataset (Dataset): from torch.utils.data import Dataset + """ + + def __init__(self, root_dir): + """ + Create an instance of the MIR-1K dataset. + + This class loads and prepares the data from the MIR-1K dataset, + which consists of audio files with corresponding pitch labels. + + Attributes: + root_dir (str): The root directory containing the MIR-1K dataset. + + Methods: + __init__: Initializes the dataset by loading the audio files and pitch labels. + __len__: Returns the total number of samples in the dataset. + __getitem__: Loads a single sample from the dataset, consisting of an audio file + and its corresponding pitch label. + """ + self.root_dir = root_dir + # self.labels = [f.replace('.wav', '.txt') for f in self.files] + self.files = sorted(glob.glob(os.path.join( + self.root_dir+"/Wavfile", f"*.wav"))) + self.labels = sorted(glob.glob(os.path.join( + self.root_dir+"/PitchLabel", f"*.pv"))) + + def __len__(self): + """ + Retrieve the total number of samples in the dataset. + + Returns: + int: The total number of samples in the dataset. + """ + return len(self.files) + + def __getitem__(self, idx): + """ + Retrieve a single sample from the dataset. + + Args: + idx (int): The index of the sample to retrieve. + + Returns: + tuple: A tuple containing the audio file and its corresponding pitch label, + where the audio is a tensor representing the audio waveform, and the + pitch label is a tensor containing the pitch values for each frame. + + Note: + The returned audio tensor has shape (1, num_frames), where num_frames is the + number of frames in the original audio file. The returned pitch label tensor has + shape (num_frames,), containing one pitch value per frame. + """ + audio_path = os.path.abspath(self.files[idx]) + label_path = self.labels[idx] + + audio, sr = torchaudio.load(audio_path) + + with open(label_path, 'r') as f: + labels = [float(line.strip()) for line in f.readlines()] + + labels = torch.tensor(labels) + + return audio[1, :], labels + + +class Back10Dataset(Dataset): + """ + Bach10 Dataset. + + Args: + Dataset (Dataset): from torch.utils.data import Dataset + """ + + def __init__(self, root_dir): + """ + Create an instance of the Bach10 dataset. + + This class loads and prepares the data from the Bach10 dataset, + which consists of audio files with corresponding pitch labels. + + Attributes: + root_dir (str): The root directory containing the Bach10 dataset. + + Methods: + __init__: Initializes the dataset by loading the audio files and pitch labels. + __len__: Returns the total number of samples in the dataset. + __getitem__: Loads a single sample from the dataset, consisting of an audio file + and its corresponding pitch label. + """ + self.root_dir = root_dir + self.files_violin = sorted(glob.glob(os.path.join( + self.root_dir, f"*/*violin.wav"), recursive=True)) + self.files_clarinet = sorted(glob.glob(os.path.join( + self.root_dir, f"*/*clarinet.wav"), recursive=True)) + self.files_saxophone = sorted(glob.glob(os.path.join( + self.root_dir, f"*/*saxophone.wav"), recursive=True)) + self.files_bassoon = sorted(glob.glob(os.path.join( + self.root_dir, f"*/*bassoon.wav"), recursive=True)) + self.dataset_orga = {} + + idx = 0 + for path in self.files_violin: + self.dataset_orga[idx] = {} + self.dataset_orga[idx]["type"] = "violin" + self.dataset_orga[idx]["number"] = 1 + self.dataset_orga[idx]["audio_path"] = path + self.dataset_orga[idx]["label_path"] = path.replace( + '-violin.wav', '.txt') + idx += 1 + + for path in self.files_clarinet: + self.dataset_orga[idx] = {} + self.dataset_orga[idx]["type"] = "clarinet" + self.dataset_orga[idx]["number"] = 2 + self.dataset_orga[idx]["audio_path"] = path + self.dataset_orga[idx]["label_path"] = path.replace( + '-clarinet.wav', '.txt') + idx += 1 + + for path in self.files_saxophone: + self.dataset_orga[idx] = {} + self.dataset_orga[idx]["type"] = "saxophone" + self.dataset_orga[idx]["number"] = 3 + self.dataset_orga[idx]["audio_path"] = path + self.dataset_orga[idx]["label_path"] = path.replace( + '-saxophone.wav', '.txt') + idx += 1 + + for path in self.files_bassoon: + self.dataset_orga[idx] = {} + self.dataset_orga[idx]["type"] = "bassoon" + self.dataset_orga[idx]["number"] = 4 + self.dataset_orga[idx]["audio_path"] = path + self.dataset_orga[idx]["label_path"] = path.replace( + '-bassoon.wav', '.txt') + idx += 1 + + self.len = idx + + self.labels = sorted(glob.glob(os.path.join( + self.root_dir, f"*/*.txt"), recursive=True)) + + def _load_data(self, file_path, instrument_number): + data = [] + with open(file_path, 'r') as file: + for line in file: + if line.strip(): # Ignore empty lines + # Parse the line + parts = line.strip().split() + # time_audio = int(parts[0]) + # time_midi = int(parts[1]) + midi_pitch = int(parts[2]) + channel = int(parts[3]) + + if channel == instrument_number: + # Convert MIDI pitch to fundamental frequency + frequency = 440 * 2**((midi_pitch - 69) / 12) + data.append(frequency) + return data + + def __len__(self): + """ + Retrieve the total number of samples in the dataset. + + Returns: + int: The total number of samples in the dataset. + """ + return self.len + + def __getitem__(self, idx): + """ + Retrieve a single sample from the dataset. + + Args: + idx (int): The index of the sample to retrieve. + + Returns: + tuple: A tuple containing the audio file and its corresponding pitch label, + where the audio is a tensor representing the audio waveform, and the + pitch label is a tensor containing the pitch values for each frame. + (audio, label) + + Note: + The returned audio tensor has shape (1, num_frames), where num_frames is the + number of frames in the original audio file. The returned pitch label tensor has + shape (num_frames,), containing one pitch value per frame. + """ + instr_type = self.dataset_orga[idx]['number'] + audio_path = self.dataset_orga[idx]['audio_path'] + label_path = self.dataset_orga[idx]['label_path'] + + audio, sr = torchaudio.load(audio_path) + label = self._load_data(label_path, instr_type) + label = torch.tensor(label) + audio = torch.mean(audio, dim=0) + + return audio, label + + +class NSynthDataset(Dataset): + """ + Nsynth Dataset. + + Args: + Dataset (Dataset): from torch.utils.data import Dataset + """ + + def __init__(self, root_dir, n_samples=1): + """ + Create an instance of the NSynth dataset. + + This class loads and prepares the data from the NSynth dataset, + which consists of audio files with corresponding pitch labels. + + Attributes: + root_dir (str): The root directory containing the NSynth dataset. + + Methods: + __init__: Initializes the dataset by loading the audio files and pitch labels. + __len__: Returns the total number of samples in the dataset. + __getitem__: Loads a single sample from the dataset, consisting of an audio file + and its corresponding pitch label. + """ + self.root_dir = root_dir + self.n_samples = n_samples + + # Load file paths + self.files = sorted(glob.glob(os.path.join( + root_dir, "*/*/*.wav"), recursive=True)) + self.infos = sorted(glob.glob(os.path.join( + root_dir, "*/*.json"), recursive=True)) + + # Precompute a mapping from filenames to their paths + self.filename_to_path = {os.path.splitext(os.path.basename(f))[ + 0]: f for f in self.files} + + # Load all metadata + self.data = self._load_metadata() + + # Create a mapping from filenames to their data for fast access + self.file_to_data = {filename: self.data.get( + filename, {}) for filename in self.data} + + def _load_metadata(self): + data = {} + for json_file in self.infos: + with open(json_file, 'r') as f: + data.update(json.load(f)) + return data + + def __len__(self): + """ + Retrieve the total number of samples in the dataset. + + Returns: + int: The total number of samples in the dataset. + """ + return len(self.files) // self.n_samples + + def _load_audio_and_pitch(self, filename): + audio_path = self.filename_to_path[filename] + audio, sr = torchaudio.load(audio_path) + audio = torch.mean(audio, dim=0) # Convert to mono + + # Retrieve MIDI pitch and calculate frequency + midi_pitch = self.file_to_data.get(filename, {}).get( + "pitch", 69) # Default to 69 if not found + pitch = 440 * 2 ** ((midi_pitch - 69) / 12) + pitch = torch.ones([audio.shape[0] // 40]) * pitch + + return audio, pitch + + def __getitem__(self, idx): + """ + Retrieve a single sample from the dataset. + + Args: + idx (int): The index of the sample to retrieve. + + Returns: + tuple: A tuple containing the audio file and its corresponding pitch label, + where the audio is a tensor representing the audio waveform, and the + pitch label is a tensor containing the pitch values for each frame. + (audio, label) + + Note: + The returned audio tensor has shape (1, num_frames), where num_frames is the + number of frames in the original audio file. The returned pitch label tensor has + shape (num_frames,), containing one pitch value per frame. + """ + start_idx = idx * self.n_samples + end_idx = start_idx + self.n_samples + + # Ensure we don't go out of bounds + if end_idx > len(self.files): + raise IndexError( + "Index out of bounds for the requested group of samples.") + + audio_list = [] + pitch_list = [] + + filenames = list(self.data.keys())[start_idx:end_idx] + + with ThreadPoolExecutor() as executor: + future_to_filename = {executor.submit( + self._load_audio_and_pitch, filename): filename for filename in filenames} + for future in as_completed(future_to_filename): + audio, pitch = future.result() + audio_list.append(audio) + pitch_list.append(pitch) + + audio = torch.cat(audio_list) + pitch = torch.cat(pitch_list) + + return audio, pitch diff --git a/crepe/model.py b/crepe/model.py new file mode 100644 index 0000000..bd8328e --- /dev/null +++ b/crepe/model.py @@ -0,0 +1,242 @@ +"""This file contains the Crepe model and its block.""" + +import torch +import os +import torchaudio +import torch.nn as nn + +from crepe.utils import get_frame, activation_to_frequency + + +class ConvBlock(nn.Module): + """ + Convolutional block model. + + Args: + nn.Module (nn.Module): import torch.nn as nn + """ + + def __init__(self, out_channels, kernel_width, stride, in_channels): + """ + Convolutional block with one or more convolutional layers. + + Args: + out_channels (int): The number of output channels. + kernel_width (int): The width of the convolutional kernel. + stride (tuple, int): The stride for each dimension. + in_channels (int): The number of input channels. + + Attributes: + layer (nn.Sequential): A sequential container holding the block's layers. + + Methods: + forward(x): Passes an input tensor `x` through the block. + """ + super(ConvBlock, self).__init__() + + # Calculate padding for the height dimension (kernel width) + pad_top = (kernel_width - 1) // 2 + pad_bottom = (kernel_width - 1) - pad_top + + # Define the block using nn.Sequential + self.layer = nn.Sequential( + # Add padding to the input + nn.ZeroPad2d((0, 0, pad_top, pad_bottom)), + nn.Conv2d( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=(kernel_width, 1), + stride=stride + ), # Apply 2D convolution + nn.ReLU(), # Apply ReLU activation + nn.BatchNorm2d(out_channels), # Apply batch normalization + nn.MaxPool2d(kernel_size=(2, 1)), # Apply max pooling + nn.Dropout(p=0.25) # Apply dropout for regularization + ) + + def forward(self, x): + """ + Pass an input tensor `x` through the network. + + Args: + x (torch.Tensor): The input tensor to pass through the network. + + Returns: + torch.Tensor: The output of the network. + """ + return self.layer(x) + + +class Crepe(nn.Module): + """ + Crepe model. + + Args: + nn.Module (nn.Module): import torch.nn as nn + """ + + def __init__(self, model_capacity="full", device='cpu'): + """ + CREPE model for pitch estimation. + + Args: + model_capacity (str): The capacity of the network ('tiny', 'small', 'medium', 'large', or 'full'). + device (str): The device to run the model on ('cpu', 'gpu', 'mps'). + + Attributes: + model_capacity (str): The capacity of the network. + convolutional_blocks (nn.Sequential): A sequential container holding the convolutional blocks. + linear (nn.Linear): A linear layer for final mapping. + + Methods: + forward(x): Passes an input tensor `x` through the network. + get_activation(audio, sr, center=True, step_size=10, batch_size=128): + Computes the activation stack for a given audio signal and sampling rate. + predict(audio, sr, center=True, step_size=10, batch_size=128): + Predicts pitch class labels from an input audio signal. + + Note: + The model's capacity determines its size and complexity. + """ + super(Crepe, self).__init__() + + # Define a multiplier for the network's capacity based on the selected model size + self.model_capacity = model_capacity + capacity_multiplier = { + 'tiny': 4, 'small': 8, 'medium': 16, 'large': 24, 'full': 32 + }[model_capacity] + + # Define the number of filters for each layer, scaled by the capacity multiplier + filters = [n * capacity_multiplier for n in [32, 4, 4, 4, 8, 16]] + # Include the input channel size as the first element + filters = [1] + filters + + # Define the kernel widths and strides for each layer + widths = [512, 64, 64, 64, 64, 64] + strides = [(4, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1)] + + # Create a list of layers for the Sequential container + layers = [] + for i in range(len(filters) - 1): + layers.append(ConvBlock( + out_channels=filters[i + 1], + kernel_width=widths[i], + stride=strides[i], + in_channels=filters[i] + )) + + # Add all layers to the Sequential container + self.convolutional_blocks = nn.Sequential(*layers) + + # Define the final linear layer to map the output to 360 classes (e.g., pitch classes) + self.linear = nn.Linear(64 * capacity_multiplier, 360) + + # load model + self.device = device + self.load_weight(model_capacity) + + # Set the model to evaluation mode by default + self.eval() + + def load_weight(self, model_capacity): + """ + Load the weights for a given model capacity. + + Args: + model_capacity (str): The capacity of the network ('tiny', 'small', 'medium', 'large', or 'full'). + + Note: + The model's capacity determines its size and complexity. + """ + package_dir = os.path.dirname(os.path.realpath(__file__)) + filename = "crepe-{}.pth".format(model_capacity) + try: + self.load_state_dict(torch.load(os.path.join( + package_dir, filename), map_location=torch.device(self.device), weights_only=True)) + except: + print(f"{filename} Not found.") + + def forward(self, x): + """ + Pass an input tensor `x` through the network. + + Args: + x (torch.Tensor): The input tensor to pass through the network. + + Returns: + torch.Tensor: The output of the network. + """ + x = x.view(x.shape[0], 1, -1, 1) + + # Pass the input through each convolutional block sequentially + x = self.convolutional_blocks(x) + + # Reorder dimensions and flatten before passing to the linear layer + x = x.permute(0, 3, 2, 1) + x = x.reshape(x.shape[0], -1) + + # Apply the final linear layer and sigmoid activation + x = self.linear(x) + x = torch.sigmoid(x) + + return x + + def get_activation(self, audio, sr, center=True, step_size=10, batch_size=128): + """ + Compute the activation stack for a given audio signal and sampling rate. + + Args: + audio (torch.Tensor): The input audio tensor. + sr (int): The sampling rate of the audio signal. + center (bool): Whether to center the frames around each other. Defaults to True. + step_size (int): The number of samples per frame. Defaults to 10. + batch_size (int): The batch size for computing activations. + + Returns: + torch.Tensor: The activation stack. + """ + # resample to 16kHz if needed + if sr != 16000: + rs = torchaudio.transforms.Resample(sr, 16000) + audio = rs(audio) + + # make mono if needed + if len(audio.shape) == 2: + if audio.shape[0] == 1: + audio = audio[0] + else: + audio = audio.mean(dim=0) + + frames = get_frame(audio, step_size, center) + activation_stack = [] + device = self.linear.weight.device + + for i in range(0, len(frames), batch_size): + f = frames[i:min(i+batch_size, len(frames))] + f = f.to(device) + act = self.forward(f) + activation_stack.append(act.cpu()) + activation = torch.cat(activation_stack, dim=0) + + return activation + + def predict(self, audio, sr, center=True, step_size=10, batch_size=128): + """ + Predict pitch class labels from an input audio signal. + + Args: + audio (torch.Tensor): The input audio tensor. + sr (int): The sampling rate of the audio signal. + center (bool): Whether to center the frames around each other. Defaults to True. + step_size (int): The number of samples per frame. Defaults to 10. + batch_size (int): The batch size for computing activations. + + Returns: + tuple: A tuple containing the time, frequency, confidence, and activation stack. + """ + activation = self.get_activation( + audio, sr, batch_size=batch_size, step_size=step_size) + frequency = activation_to_frequency(activation) + confidence = activation.max(dim=1)[0] + time = torch.arange(confidence.shape[0]) * step_size / 1000.0 + return time, frequency, confidence, activation diff --git a/crepe/utils.py b/crepe/utils.py new file mode 100644 index 0000000..240d1d2 --- /dev/null +++ b/crepe/utils.py @@ -0,0 +1,165 @@ +"""This file contains various functions for processing and converting audio data and labels.""" + +import torch +import torch.nn as nn +import subprocess +import torchaudio +import os + + +def get_frame(audio, step_size, center): + """ + Extract audio frames from a given audio signal. + + Args: + audio (Tensor): The input audio signal. + step_size (float): The time step size in milliseconds. Audio will be divided into + 1024-sample frames with this hop length. + center (bool): If True, pads the audio to have equal number of samples on both sides. + + Returns: + Tensor: A tensor containing the extracted audio frames, standardized to have zero mean and unit standard deviation. + """ + if center: + audio = nn.functional.pad(audio, pad=(512, 512)) + # make 1024-sample frames of the audio with hop length of 10 milliseconds + hop_length = int(16000 * step_size / 1000) + n_frames = 1 + (len(audio) - 1024) // hop_length + frames = torch.as_strided(audio, size=( + 1024, n_frames), stride=(1, hop_length)) + frames = frames.transpose(0, 1).clone() + + mean = torch.mean(frames, dim=1, keepdim=True) + # Adding epsilon to prevent division by zero + std = torch.std(frames, dim=1, keepdim=True) + 1e-8 + + frames -= mean + frames /= std + return frames + + +def to_local_average_cents(salience, center=None): + """ + Compute the weighted average cents near the argmax bin of a salience vector. + + Args: + salience (Tensor): A 1D or 2D tensor representing the salience values. + center (int, optional): The index around which to compute the weighted average. Defaults to None. + + Returns: + Tensor: The weighted average cents near the argmax bin. + + Notes: + This function assumes that the input salience values are normalized such that their sum equals 1. + """ + if not hasattr(to_local_average_cents, 'cents_mapping'): + # The bin number-to-cents mapping + to_local_average_cents.cents_mapping = ( + torch.linspace(0, + 1200 * torch.log2(torch.tensor(3951.066/10)), + 360, dtype=salience.dtype, + device=salience.device) + 1200 * torch.log2(torch.tensor(32.70/10))) + + if salience.ndim == 1: + if center is None: + center = int(torch.argmax(salience)) + start = max(0, center - 4) + end = min(len(salience), center + 5) + salience_segment = salience[start:end] + mapping_segment = to_local_average_cents.cents_mapping[start:end] + product_sum = torch.sum(salience_segment * mapping_segment) + weight_sum = torch.sum(salience_segment) + return product_sum / weight_sum + elif salience.ndim == 2: + return torch.stack([to_local_average_cents(salience[i, :]) for i in range(salience.shape[0])]) + + +def activation_to_frequency(activations): + """ + Convert activations to a corresponding frequency value. + + Args: + activations (tensor): The input activations to convert. + + Returns: + tensor: A tensor representing the frequency values. + """ + cents = to_local_average_cents(activations) + frequency = 10 * 2 ** (cents / 1200) + frequency[torch.isnan(frequency)] = 0 + frequency = torch.where(frequency < 32.71, torch.tensor( + 1e-7, device=frequency.device), frequency) + return frequency + + +def frequency_to_activation(frequencies, num_bins=360): + """ + Convert a tensor of frequencies to a binary activation map. + + Args: + frequencies (torch.Tensor): The input frequencies. + num_bins (int, optional): The number of bins in the activation map. Defaults to 360. + + Returns: + torch.Tensor: A binary activation map where each row corresponds to the frequency in the corresponding + row of `frequencies`. + """ + # Convert frequency to cents + cents = 1200 * torch.log2(frequencies / 10) + + # Create the cents-to-bin mapping if it doesn't already exist + if not hasattr(frequency_to_activation, 'cents_mapping'): + frequency_to_activation.cents_mapping = ( + torch.linspace(0, + 1200 * torch.log2(torch.tensor(3951.066/10)), + num_bins, dtype=frequencies.dtype, + device=frequencies.device) + 1200 * torch.log2(torch.tensor(32.70/10))) + + # Initialize activation map with zeros; expects batch input for frequencies + activations = torch.zeros( + frequencies.shape[0], num_bins, dtype=frequencies.dtype, device=frequencies.device) + + # Find the closest bin to the calculated cents value for each frequency in the batch + for i in range(frequencies.shape[0]): + closest_bin = torch.argmin( + torch.abs(frequency_to_activation.cents_mapping - cents[i])) + activations[i, closest_bin] = 1.0 + + return activations + + +def load_test_file(filename: str, mono: bool = False, normalize: bool = False): + """ + Load a test audio file from a remote server into a PyTorch Audio tensor. + + Args: + filename (str): The name of the audio file to download. + mono (bool, optional): If True, load the audio in monaural format. Defaults to False. + normalize (bool, optional): If True, normalize the audio signal. Defaults to False. + + Returns: + Tuple[Tensor, int]: A tuple containing the loaded audio tensor and its sample rate. + If an error occurs during download or loading, returns (None, None). + """ + # Construct the URL for the file on your server + url = f"https://openfileserver.chloelavrat.com/testfiles/audio/{filename}" + + # Create a temporary directory to store the downloaded files + temp_dir = "/tmp" # You can change this to any other directory you like + + # Construct the full path where the downloaded file will be saved + filepath = os.path.join(temp_dir, filename) + + try: + # Use subprocess to run wget and download the file + subprocess.check_call( + ["wget", "-P", temp_dir, url, "--no-check-certificate", "-q"]) + + # Load the audio file into a PyTorch Audio tensor + audio, sr = torchaudio.load(filepath, normalize=normalize) + + return audio, sr + + except subprocess.CalledProcessError as e: + print(f"Failed to download {filename}: {e}") + return None diff --git a/notebooks/dataset.ipynb b/notebooks/dataset.ipynb new file mode 100644 index 0000000..caa4a10 --- /dev/null +++ b/notebooks/dataset.ipynb @@ -0,0 +1,261 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# fix relative import\n", + "import os, sys\n", + "dir2 = os.path.abspath('')\n", + "dir1 = os.path.dirname(dir2)\n", + "if not dir1 in sys.path: sys.path.append(dir1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "audio backend list: ['soundfile']\n" + ] + } + ], + "source": [ + "# import libs + list audio backend\n", + "from tqdm import tqdm\n", + "import torch\n", + "import torchaudio\n", + "from concurrent.futures import ThreadPoolExecutor, as_completed\n", + "print(f\"audio backend list: {str(torchaudio.list_audio_backends())}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# dataset scan function with multithreading\n", + "def dataset_scan(data, desc, max_workers=4):\n", + " error = False\n", + " \n", + " def process_item(i):\n", + " try:\n", + " audio = data[i][0].shape\n", + " label = data[i][1].shape\n", + " except Exception as e:\n", + " return (i, data.files[i], str(e))\n", + " return None\n", + " \n", + " with ThreadPoolExecutor(max_workers=max_workers) as executor:\n", + " futures = {executor.submit(process_item, i): i for i in range(len(data))}\n", + " \n", + " for future in tqdm(as_completed(futures), total=len(data), desc=desc):\n", + " result = future.result()\n", + " if result is not None:\n", + " error = True\n", + " i, file, exception = result\n", + " print(f\"Error id: {i} file: {file} - Exception: {exception}\")\n", + " \n", + " return error" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "** mir_1k **\n", + "lenght of dataset: 1000\n", + "random sample id: 850\n", + "id_850 audio size: torch.Size([147969])\n", + "id_850 label size: torch.Size([461])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test mir_1k: 100%|██████████| 1000/1000 [00:01<00:00, 854.41it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset analyzed and ready to be used\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Import: MIR-1K\n", + "from crepe.dataset import MIR1KDataset\n", + "mir_1k = MIR1KDataset(root_dir=os.path.join(dir1, \"dataset/MIR-1K\"))\n", + "\n", + "# Test: MIR-1K\n", + "print(\"** mir_1k **\")\n", + "print(f\"lenght of dataset: {len(mir_1k)}\")\n", + "idx = int(torch.randint(0, int(len(mir_1k)), (1,)))\n", + "print(f\"random sample id: {int(idx)}\")\n", + "print(f\"id_{idx} audio size: {mir_1k[idx][0].shape}\")\n", + "print(f\"id_{idx} label size: {mir_1k[idx][1].shape}\")\n", + "\n", + "error = dataset_scan(mir_1k, \"test mir_1k\")\n", + "\n", + "if not error:\n", + " print(\"Dataset analyzed and ready to be used\")\n", + "if error:\n", + " print(\"it seams that your dataset is not well formated.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "** back10 **\n", + "lenght of dataset: 30\n", + "random sample id: 23\n", + "id_23 audio size: torch.Size([1837433])\n", + "id_23 label size: torch.Size([65])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test back10: 100%|██████████| 30/30 [00:00<00:00, 347.92it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset analyzed and ready to be used\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Import: Bach-10\n", + "from crepe.dataset import Back10Dataset\n", + "back10 = Back10Dataset(root_dir=os.path.join(dir1, \"dataset/Bach10\"))\n", + "\n", + "# Test: MIR-1K\n", + "print(\"** back10 **\")\n", + "print(f\"lenght of dataset: {len(back10)}\")\n", + "idx = int(torch.randint(0, int(len(back10)), (1,)))\n", + "print(f\"random sample id: {int(idx)}\")\n", + "print(f\"id_{idx} audio size: {back10[idx][0].shape}\")\n", + "print(f\"id_{idx} label size: {back10[idx][1].shape}\")\n", + "\n", + "error = dataset_scan(back10, \"test back10\")\n", + "\n", + "if not error:\n", + " print(\"Dataset analyzed and ready to be used\")\n", + "if error:\n", + " print(\"it seams that your dataset is not well formated.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "** nsynth **\n", + "lenght of dataset: 10062\n", + "random sample id: 5275\n", + "id_5275 audio size: torch.Size([1920000])\n", + "id_5275 label size: torch.Size([48000])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test nsynth: 0%| | 16/10062 [00:00<03:22, 49.70it/s] \n" + ] + } + ], + "source": [ + "# Import: Nsynth\n", + "from crepe.dataset import NSynthDataset\n", + "nsynth = NSynthDataset(root_dir=os.path.join(dir1, \"dataset/Nsynth-mixed\"), n_samples=30)\n", + "\n", + "# Test: MIR-1K\n", + "print(\"** nsynth **\")\n", + "print(f\"lenght of dataset: {len(nsynth)}\")\n", + "idx = int(torch.randint(0, int(len(nsynth)), (1,)))\n", + "print(f\"random sample id: {int(idx)}\")\n", + "print(f\"id_{idx} audio size: {nsynth[idx][0].shape}\")\n", + "print(f\"id_{idx} label size: {nsynth[idx][1].shape}\")\n", + "\n", + "error = dataset_scan(nsynth, \"test nsynth\")\n", + "\n", + "if not error:\n", + " print(\"Dataset analyzed and ready to be used\")\n", + "if error:\n", + " print(\"it seams that your dataset is not well formated.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/model.ipynb b/notebooks/model.ipynb new file mode 100644 index 0000000..bfd683e --- /dev/null +++ b/notebooks/model.ipynb @@ -0,0 +1,303 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# fix relative import\n", + "import os, sys\n", + "dir2 = os.path.abspath('')\n", + "dir1 = os.path.dirname(dir2)\n", + "if not dir1 in sys.path: sys.path.append(dir1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "** convBlock **\n", + "layers: \n", + "ConvBlock(\n", + " (layer): Sequential(\n", + " (0): ZeroPad2d((0, 0, 1, 2))\n", + " (1): Conv2d(3, 6, kernel_size=(4, 1), stride=(2, 2))\n", + " (2): ReLU()\n", + " (3): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (4): MaxPool2d(kernel_size=(2, 1), stride=(2, 1), padding=0, dilation=1, ceil_mode=False)\n", + " (5): Dropout(p=0.25, inplace=False)\n", + " )\n", + ")\n", + "verification: True\n" + ] + } + ], + "source": [ + "# ConvBlock\n", + "from crepe.model import ConvBlock\n", + "convBlock = ConvBlock(\n", + " in_channels=3, # Number of input channels\n", + " out_channels=6, # Number of output channels\n", + " kernel_width=4, # Width of the convolution kernel\n", + " stride=2 # Stride of the convolution\n", + ")\n", + "expected = \"\"\"ConvBlock(\n", + " (layer): Sequential(\n", + " (0): ZeroPad2d((0, 0, 1, 2))\n", + " (1): Conv2d(3, 6, kernel_size=(4, 1), stride=(2, 2))\n", + " (2): ReLU()\n", + " (3): BatchNorm2d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (4): MaxPool2d(kernel_size=(2, 1), stride=(2, 1), padding=0, dilation=1, ceil_mode=False)\n", + " (5): Dropout(p=0.25, inplace=False)\n", + " )\n", + ")\"\"\"\n", + "print(\"** convBlock **\")\n", + "print(\"layers: \")\n", + "print(str(convBlock))\n", + "print(f\"verification: {(str(convBlock)==expected)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crepe device: mps\n", + "crepe model_capacity: tiny\n" + ] + } + ], + "source": [ + "# Import crepe\n", + "from crepe.model import Crepe\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available(\n", + ") else 'mps' if torch.backends.mps.is_available() else 'cpu')\n", + "\n", + "crepe = Crepe(model_capacity='tiny', device=device)\n", + "\n", + "print(f\"crepe device: \", crepe.device)\n", + "print(f\"crepe model_capacity: \", crepe.model_capacity)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/chloelavrat/Documents/GitHub/TorchCrepe/dataset/MIR-1K/Wavfile/amy_10_04.wav\n", + "audio test\n", + "load audio MIR 1K id_136\n", + "sr: 16000 Hz\n", + "audio shape: torch.Size([101889])\n", + "\n", + "Process..\n", + "activation Shape: torch.Size([637, 360])\n", + "confidence Shape: torch.Size([637])\n", + "frequency Shape: torch.Size([637])\n", + "time Shape: torch.Size([637])\n" + ] + } + ], + "source": [ + "# load fake audio to crepe (randn)\n", + "from crepe.dataset import MIR1KDataset\n", + "mir_1k = MIR1KDataset(root_dir=os.path.join(dir1, \"dataset/MIR-1K\"))\n", + "\n", + "sr = 16000\n", + "idx = 136#int(torch.randint(0, int(len(mir_1k)), (1,)))\n", + "audio = mir_1k[idx][0]\n", + "labels = mir_1k[idx][1]\n", + "\n", + "print(mir_1k.files[136])\n", + "\n", + "audio = (audio - torch.mean(audio) ) / (torch.max(audio))\n", + "print(\"audio test\")\n", + "print(f\"load audio MIR 1K id_{idx}\")\n", + "print(f\"sr: {sr} Hz\")\n", + "print(f\"audio shape: {audio.shape}\")\n", + "\n", + "time, frequency, confidence, activation = crepe.predict(\n", + " audio=audio,\n", + " sr = sr\n", + ")\n", + "print(\"\\nProcess..\")\n", + "print(f\"activation Shape: {activation.shape}\")\n", + "print(f\"confidence Shape: {frequency.shape}\")\n", + "print(f\"frequency Shape: {frequency.shape}\")\n", + "print(f\"time Shape: {frequency.shape}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "salience = activation.flip(1)\n", + "salience_transposed = salience.transpose(0, 1) # Transpose the axes\n", + "plt.figure(figsize=(10, 6)) # Adjust the figure size\n", + "plt.imshow(salience_transposed.detach().numpy(), cmap='inferno', aspect='auto')\n", + "plt.colorbar(label='Activation') # Add a color bar for reference\n", + "plt.title('Salience Map')\n", + "plt.xlabel('Sample Index') # Adjusted based on transposition\n", + "plt.ylabel('Feature Dimension') # Adjusted based on transposition\n", + "plt.ylim(350, 300) # Set the y-axis range from 350 to 250\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Assuming frequency and labels are PyTorch tensors\n", + "frequency_np = frequency.detach().numpy()\n", + "\n", + "# Interpolate labels to match the size of frequency\n", + "labels_resized = torch.nn.functional.interpolate(\n", + " labels.unsqueeze(0).unsqueeze(0), # Add batch and channel dimensions\n", + " size=frequency.shape[0], # Target size\n", + " mode='linear', align_corners=True # Linear interpolation\n", + ").squeeze(0).squeeze(0) # Remove the added dimensions\n", + "\n", + "labels_np = labels_resized.detach().numpy()\n", + "\n", + "# Create the plot with two y-axes\n", + "fig, ax1 = plt.subplots(figsize=(10, 4))\n", + "\n", + "# Plot frequency on the primary y-axis\n", + "ax1.plot(frequency_np, color='b', label='Frequency')\n", + "ax1.set_xlabel('Time')\n", + "ax1.set_ylabel('Frequency (Hz)', color='b')\n", + "ax1.tick_params(axis='y', labelcolor='b')\n", + "\n", + "# Create a secondary y-axis\n", + "ax1.plot(labels_np, color='r', label='Labels (Interpolated)')\n", + "ax1.set_ylabel('Labels', color='r')\n", + "ax1.tick_params(axis='y', labelcolor='r')\n", + "\n", + "# Add legends for clarity\n", + "ax1.legend(loc='upper left')\n", + "ax1.legend(loc='upper right')\n", + "\n", + "# Show the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": " is not a generic class", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[8], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# Download and load a built-in dataset\u001b[39;00m\n\u001b[1;32m 4\u001b[0m dataset \u001b[38;5;241m=\u001b[39m torchaudio\u001b[38;5;241m.\u001b[39mdatasets\u001b[38;5;241m.\u001b[39mSPEECHCOMMANDS\n\u001b[0;32m----> 5\u001b[0m data, sampling_rate \u001b[38;5;241m=\u001b[39m \u001b[43mdataset\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(data\u001b[38;5;241m.\u001b[39mshape)\n\u001b[1;32m 8\u001b[0m time, frequency, confidence, activation \u001b[38;5;241m=\u001b[39m crepe\u001b[38;5;241m.\u001b[39mpredict(\n\u001b[1;32m 9\u001b[0m audio\u001b[38;5;241m=\u001b[39maudio,\n\u001b[1;32m 10\u001b[0m sr \u001b[38;5;241m=\u001b[39m sr\n\u001b[1;32m 11\u001b[0m )\n", + "File \u001b[0;32m/opt/homebrew/Cellar/python@3.12/3.12.4/Frameworks/Python.framework/Versions/3.12/lib/python3.12/typing.py:398\u001b[0m, in \u001b[0;36m_tp_cache..decorator..inner\u001b[0;34m(*args, **kwds)\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m 397\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m \u001b[38;5;66;03m# All real errors (not unhashable args) are raised below.\u001b[39;00m\n\u001b[0;32m--> 398\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/homebrew/Cellar/python@3.12/3.12.4/Frameworks/Python.framework/Versions/3.12/lib/python3.12/typing.py:1101\u001b[0m, in \u001b[0;36m_generic_class_getitem\u001b[0;34m(cls, params)\u001b[0m\n\u001b[1;32m 1099\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m prepare \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1100\u001b[0m params \u001b[38;5;241m=\u001b[39m prepare(\u001b[38;5;28mcls\u001b[39m, params)\n\u001b[0;32m-> 1101\u001b[0m \u001b[43m_check_generic\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__parameters__\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1103\u001b[0m new_args \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 1104\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m param, new_arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m__parameters__, params):\n", + "File \u001b[0;32m~/Documents/GitHub/TorchCrepe/.venv/lib/python3.12/site-packages/typing_extensions.py:2922\u001b[0m, in \u001b[0;36m_check_generic\u001b[0;34m(cls, parameters, elen)\u001b[0m\n\u001b[1;32m 2917\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Check correct count for parameters of a generic cls (internal helper).\u001b[39;00m\n\u001b[1;32m 2918\u001b[0m \n\u001b[1;32m 2919\u001b[0m \u001b[38;5;124;03mThis gives a nice error message in case of count mismatch.\u001b[39;00m\n\u001b[1;32m 2920\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 2921\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m elen:\n\u001b[0;32m-> 2922\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is not a generic class\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 2923\u001b[0m alen \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(parameters)\n\u001b[1;32m 2924\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m alen \u001b[38;5;241m!=\u001b[39m elen:\n", + "\u001b[0;31mTypeError\u001b[0m: is not a generic class" + ] + } + ], + "source": [ + "import torchaudio\n", + "\n", + "# Download and load a built-in dataset\n", + "dataset = torchaudio.datasets.SPEECHCOMMANDS\n", + "data, sampling_rate = dataset[0]\n", + "print(data.shape)\n", + "\n", + "time, frequency, confidence, activation = crepe.predict(\n", + " audio=audio,\n", + " sr = sr\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/train.ipynb b/notebooks/train.ipynb new file mode 100644 index 0000000..40c1400 --- /dev/null +++ b/notebooks/train.ipynb @@ -0,0 +1,145 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# fix relative import\n", + "import os, sys, torch\n", + "dir2 = os.path.abspath('')\n", + "dir1 = os.path.dirname(dir2)\n", + "if not dir1 in sys.path: sys.path.append(dir1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crepe device: mps\n", + "crepe model_capacity: tiny\n" + ] + } + ], + "source": [ + "# Import crepe\n", + "from crepe.model import Crepe\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available(\n", + ") else 'mps' if torch.backends.mps.is_available() else 'cpu')\n", + "\n", + "crepe = Crepe(model_capacity='tiny', device=device)\n", + "\n", + "print(f\"crepe device: \", crepe.device)\n", + "print(f\"crepe model_capacity: \", crepe.model_capacity)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "random sample id: 359\n", + "id_359 audio size: torch.Size([176641])\n", + "id_359 label size: torch.Size([551])\n" + ] + } + ], + "source": [ + "# Import: MIR-1K (selection of one sample)\n", + "from crepe.dataset import MIR1KDataset\n", + "mir_1k = MIR1KDataset(root_dir=os.path.join(dir1, \"dataset/MIR-1K\"))\n", + "\n", + "sr = 16000\n", + "idx = int(torch.randint(0, int(len(mir_1k)), (1,)))\n", + "print(f\"random sample id: {int(idx)}\")\n", + "print(f\"id_{idx} audio size: {mir_1k[idx][0].shape}\")\n", + "print(f\"id_{idx} label size: {mir_1k[idx][1].shape}\")\n", + "audio = mir_1k[idx][0]\n", + "labels = mir_1k[idx][1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "labels_activations shape: torch.Size([1105, 360])\n", + "model_activations shape: torch.Size([1105, 360])\n" + ] + } + ], + "source": [ + "# train step test\n", + "from train import epoch_step\n", + "labels_activations, model_activations = epoch_step(crepe, audio, labels, sr, device)\n", + "\n", + "print(f\"labels_activations shape: {labels_activations.shape}\")\n", + "print(f\"model_activations shape: {model_activations.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss is 0.694\n" + ] + } + ], + "source": [ + "# test loss\n", + "import torch.nn as nn\n", + "criteron = nn.BCELoss()\n", + "loss = criteron(model_activations, labels_activations)\n", + "print(f\"loss is {float(loss):.3f}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/usecrepe.ipynb b/notebooks/usecrepe.ipynb new file mode 100644 index 0000000..2cc72cc --- /dev/null +++ b/notebooks/usecrepe.ipynb @@ -0,0 +1,141 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CREPE: How to use" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# fix relative import\n", + "import os, sys\n", + "dir2 = os.path.abspath('')\n", + "dir1 = os.path.dirname(dir2)\n", + "if not dir1 in sys.path: sys.path.append(dir1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crepe device: mps\n", + "crepe model_capacity: tiny\n" + ] + } + ], + "source": [ + "# Import crepe\n", + "import torch\n", + "from crepe.model import Crepe\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available(\n", + ") else 'mps' if torch.backends.mps.is_available() else 'cpu')\n", + "\n", + "crepe = Crepe(model_capacity='tiny', device=device)\n", + "\n", + "print(f\"crepe device: \", crepe.device)\n", + "print(f\"crepe model_capacity: \", crepe.model_capacity)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Process..\n", + "activation Shape: torch.Size([637, 360])\n", + "confidence Shape: torch.Size([637])\n", + "frequency Shape: torch.Size([637])\n", + "time Shape: torch.Size([637])\n" + ] + } + ], + "source": [ + "# Import test file\n", + "from crepe.utils import load_test_file\n", + "\n", + "audio, sr = load_test_file(\"amy_10_04.wav\", mono=True, normalize=True)\n", + "\n", + "time, frequency, confidence, activation = crepe.predict(\n", + " audio=audio,\n", + " sr = sr\n", + ")\n", + "print(\"\\nProcess..\")\n", + "print(f\"activation Shape: {activation.shape}\")\n", + "print(f\"confidence Shape: {frequency.shape}\")\n", + "print(f\"frequency Shape: {frequency.shape}\")\n", + "print(f\"time Shape: {frequency.shape}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot results\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "salience = activation.flip(1)\n", + "salience_transposed = salience.transpose(0, 1) # Transpose the axes\n", + "plt.figure(figsize=(10, 6)) # Adjust the figure size\n", + "plt.imshow(salience_transposed.detach().numpy(), cmap='inferno', aspect='auto')\n", + "plt.colorbar(label='Activation') # Add a color bar for reference\n", + "plt.title('Salience Map')\n", + "plt.xlabel('Sample Index') # Adjusted based on transposition\n", + "plt.ylabel('Feature Dimension') # Adjusted based on transposition\n", + "plt.ylim(350, 300) # Set the y-axis range from 350 to 250\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/utils.ipynb b/notebooks/utils.ipynb new file mode 100644 index 0000000..4ab74a4 --- /dev/null +++ b/notebooks/utils.ipynb @@ -0,0 +1,135 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Utils" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# fix relative import\n", + "import os, sys\n", + "dir2 = os.path.abspath('')\n", + "dir1 = os.path.dirname(dir2)\n", + "if not dir1 in sys.path: sys.path.append(dir1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from crepe.utils import activation_to_frequency, frequency_to_activation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 8000])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sr = 16000\n", + "test_freq = torch.arange(0., float(sr//2), 1).unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# \n", + "activation = frequency_to_activation(test_freq[0,:])\n", + "freq_out = activation_to_frequency(activation)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot \n", + "import matplotlib.pyplot as plt\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(2, 1) # Create two subplots, one above the other\n", + "\n", + "%matplotlib inline\n", + "plt.figure(figsize=(10, 4)) # Adjust the figure size\n", + "\n", + "# First plot on the first set of axes\n", + "ax1.plot(test_freq[0, :], color='b')\n", + "ax1.set_ylabel('Test Frequency')\n", + "ax1.set_xlabel('X-Axis for Test Frequency')\n", + "\n", + "# Second plot on the second set of axes\n", + "ax2.plot(freq_out, color='r')\n", + "ax2.set_ylabel('Frequency Out')\n", + "ax2.set_xlabel('X-Axis for Frequency Out')\n", + "\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..55da211 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,28 @@ +[tool.poetry] +name = "CrepeTorch" +version = "1.0.0" +description = "**CrepeTorch** is a fundamental frequency detector on audio." +authors = ["Chloé Lavrat "] +license = "Copyright (c) Chloé Lavrat 2024" +readme = "README.md" +packages = [{include = "crepe"}] + +[tool.poetry.dependencies] +python = "^3.12" +pytest = "^6.2" +torch = "^2.4" +torchaudio = "^2.4" +PySoundFile = "^0.9" +tqdm = "^4.66.4" + + +[tool.poetry.dev-dependencies] +pytest = "^6.2.5" # Example development dependency + +[tool.poetry.urls] +homepage = "chloelavrat.com" +repository = "https://github.com/chloelavrat/TorchCrepe" + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3a8b8fe --- /dev/null +++ b/requirements.txt @@ -0,0 +1,108 @@ +aiofiles==24.1.0 +aiohappyeyeballs==2.4.0 +aiohttp==3.10.5 +aiosignal==1.3.1 +altair==5.3.0 +appnope==0.1.4 +asttokens==2.4.1 +attrs==23.2.0 +audioread==3.0.1 +blinker==1.8.2 +cachetools==5.4.0 +certifi==2024.7.4 +cffi==1.16.0 +charset-normalizer==3.3.2 +click==8.1.7 +comm==0.2.2 +contourpy==1.2.1 +cycler==0.12.1 +debugpy==1.8.2 +decorator==5.1.1 +docker-pycreds==0.4.0 +executing==2.0.1 +filelock==3.15.4 +fonttools==4.53.1 +frozenlist==1.4.1 +fsspec==2024.6.1 +gitdb==4.0.11 +GitPython==3.1.43 +hmmlearn==0.3.2 +idna==3.7 +ipykernel==6.29.5 +ipython==8.26.0 +jedi==0.19.1 +Jinja2==3.1.4 +joblib==1.4.2 +jsonschema==4.23.0 +jsonschema-specifications==2023.12.1 +jupyter_client==8.6.2 +jupyter_core==5.7.2 +kiwisolver==1.4.5 +lazy_loader==0.4 +librosa==0.10.2.post1 +llvmlite==0.43.0 +markdown-it-py==3.0.0 +MarkupSafe==2.1.5 +matplotlib==3.9.1 +matplotlib-inline==0.1.7 +mdurl==0.1.2 +mpmath==1.3.0 +msgpack==1.0.8 +multidict==6.0.5 +nest-asyncio==1.6.0 +networkx==3.3 +numba==0.60.0 +numpy==2.0.1 +packaging==24.1 +pandas==2.2.2 +parso==0.8.4 +pexpect==4.9.0 +pillow==10.4.0 +platformdirs==4.2.2 +pooch==1.8.2 +prompt_toolkit==3.0.47 +protobuf==5.27.2 +psutil==6.0.0 +ptyprocess==0.7.0 +pure_eval==0.2.3 +pyarrow==17.0.0 +pycparser==2.22 +pydeck==0.9.1 +Pygments==2.18.0 +pyparsing==3.1.2 +PySoundFile==0.9.0.post1 +python-dateutil==2.9.0.post0 +pytz==2024.1 +PyYAML==6.0.1 +pyzmq==26.0.3 +referencing==0.35.1 +requests==2.32.3 +rich==13.7.1 +rpds-py==0.19.1 +scikit-learn==1.5.1 +scipy==1.14.0 +sentry-sdk==2.11.0 +setproctitle==1.3.3 +setuptools==71.1.0 +six==1.16.0 +smmap==5.0.1 +soundfile==0.12.1 +soxr==0.4.0 +stack-data==0.6.3 +streamlit==1.37.0 +sympy==1.13.1 +tenacity==8.5.0 +threadpoolctl==3.5.0 +toml==0.10.2 +toolz==0.12.1 +torch==2.4.0 +torchaudio==2.4.0 +tornado==6.4.1 +tqdm==4.66.4 +traitlets==5.14.3 +typing_extensions==4.12.2 +tzdata==2024.1 +urllib3==2.2.2 +wandb==0.17.5 +wcwidth==0.2.13 +yarl==1.9.4 diff --git a/scripts/package_change_version.sh b/scripts/package_change_version.sh new file mode 100644 index 0000000..94ce90a --- /dev/null +++ b/scripts/package_change_version.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +# Define the new version number as an argument +NEW_VERSION="$1" + +# Check if a version number was provided +if [ -z "$NEW_VERSION" ]; then + echo "Usage: $0 " + exit 1 +fi + +# Path to the pyproject.toml file +PYPROJECT_FILE="pyproject.toml" + +# Use sed to replace the version number in the pyproject.toml file +sed -i.bak "s/^version = \".*\"/version = \"$NEW_VERSION\"/" "$PYPROJECT_FILE" + +# Print a success message +echo "Version updated to $NEW_VERSION in $PYPROJECT_FILE" + +# Optional: Remove backup file created by sed +rm "${PYPROJECT_FILE}.bak" diff --git a/scripts/package_generate_doc.sh b/scripts/package_generate_doc.sh new file mode 100644 index 0000000..b1783a0 --- /dev/null +++ b/scripts/package_generate_doc.sh @@ -0,0 +1,53 @@ +#!/bin/bash + +SUCCESS='\033[0;32m' +RESET='\033[0m' + +# Function to print messages in green +print_success() { + echo -e "${SUCCESS}$1${RESET}" +} + +# Function to activate the Python virtual environment +activate_venv() { + print_success "Activating Python virtual environment..." + source .venv/bin/activate > /dev/null +} + +# Function to check if a Python package is installed +check_package() { + if ! python -c "import $1" 2>/dev/null; then + echo "Error: $1 package is missing." + exit 1 + fi +} + +# Function to upgrade pip +upgrade_pip() { + print_success "Upgrading pip to the latest version..." + pip install --upgrade pip > /dev/null +} + +# Function to install a Python package +install_package() { + local package=$1 + print_success "Installing ${package} package..." + pip install "$package" > /dev/null +} + +# Function to generate API documentation using lazydocs +generate_docs() { + print_success "Creating API documentation with lazydocs..." + lazydocs \ + --output-path="./docs/api-docs" \ + --overview-file="README.md" \ + --src-base-url="https://github.com/" \ + APOLLO_LIBRARY > /dev/null +} + +# Main script execution +activate_venv +check_package "pip" +upgrade_pip +install_package "lazydocs" +generate_docs diff --git a/scripts/virtualenv_activate.sh b/scripts/virtualenv_activate.sh new file mode 100644 index 0000000..28ee5d4 --- /dev/null +++ b/scripts/virtualenv_activate.sh @@ -0,0 +1,2 @@ +#!/bin/bash +source .venv/bin/activate diff --git a/scripts/virtualenv_create.sh b/scripts/virtualenv_create.sh new file mode 100644 index 0000000..8c6d3de --- /dev/null +++ b/scripts/virtualenv_create.sh @@ -0,0 +1,41 @@ +#!/bin/bash + +# Define color codes +SUCCESS='\033[0;32m' +RESET='\033[0m' # Reset color + +# Function to create a virtual environment +create_virtual_env() { + echo -e "${SUCCESS}Setting up virtual environment...${RESET}" + python3 -m venv .venv > /dev/null +} + +# Function to activate the virtual environment +activate_virtual_env() { + echo -e "${SUCCESS}Activating virtual environment...${RESET}" + source .venv/bin/activate > /dev/null +} + +# Function to upgrade pip +upgrade_pip() { + echo -e "${SUCCESS}Upgrading pip...${RESET}" + pip install --upgrade pip > /dev/null +} + +# Function to install dependencies +install_dependencies() { + echo -e "${SUCCESS}Installing dependencies from requirements file...${RESET}" + pip install -r requirements.txt +} + +# Function to display completion message +display_completion() { + echo -e "${SUCCESS}Setup complete!${RESET}" +} + +# Main script execution +create_virtual_env +activate_virtual_env +upgrade_pip +install_dependencies +display_completion \ No newline at end of file diff --git a/train.py b/train.py new file mode 100644 index 0000000..e92e0bb --- /dev/null +++ b/train.py @@ -0,0 +1,210 @@ +"""This file the code necessary to train the Crepe model.""" + +import torch +import torch.nn as nn +from tqdm import tqdm +import torch.nn.functional as F +from crepe.utils import frequency_to_activation +from crepe.model import Crepe + + +def epoch_step(model, audio, labels, sr, device): + """ + Compute model and label activations for a given batch. + + Args: + model: The Crepe model to use. + audio: A tensor of audio data. + labels: A tensor of label data. + sr: The sample rate of the audio data. + device: The device (CPU or GPU) to move the tensors to. + + Returns: + A tuple containing the label activations and the model activations. + """ + # send tensor to device + audio = audio.to(device) + labels = labels.to(device) + + # compute label activations + labels_activations = frequency_to_activation(labels[0, :]) + + # compute model activations + model_activations = model.get_activation(audio, sr).to(device) + + labels_activations = F.interpolate(labels_activations.unsqueeze(0).unsqueeze(0), size=( + model_activations.shape[0], labels_activations.shape[1]), mode='bilinear', align_corners=False).squeeze(0).squeeze(0) + + # return activations + return labels_activations, model_activations + + +def train_epoch(model, optimizer, dataloader, sr, device): + """ + Train the Crepe model for one epoch. + + Args: + model: The Crepe model to train. + optimizer: The optimizer to use. + dataloader: A DataLoader containing the training data. + sr: The sample rate of the audio data. + device: The device (CPU or GPU) to move the tensors to. + + Returns: + The average loss over all batches in this epoch. + """ + model.train() # Set the model to training mode + running_loss = 0.0 + + criterion = nn.BCELoss() # Initialize the loss function + + for i, (audio, labels) in enumerate(tqdm(dataloader)): + audio, labels = audio.to(device), labels.to( + device) # Move data to the correct device + + optimizer.zero_grad() # Zero the gradients + + # Forward pass + labels_activations, model_activations = epoch_step( + model=model, + audio=audio, + labels=labels, + sr=sr, + device=device + ) + + # Compute the loss + loss = criterion(model_activations, labels_activations) + running_loss += loss.item() * audio.size(0) + + # Backward pass and optimization + loss.backward() + optimizer.step() + + return running_loss / len(dataloader.dataset) + + +def validate_epoch(model, dataloader, sr, device): + """ + Validate the Crepe model for one epoch. + + Args: + model: The Crepe model to validate. + dataloader: A DataLoader containing the validation data. + sr: The sample rate of the audio data. + device: The device (CPU or GPU) to move the tensors to. + + Returns: + The average loss over all batches in this epoch. + """ + model.eval() # Set the model to evaluation mode + running_loss = 0.0 + criterion = nn.BCELoss() # Initialize the loss function + + with torch.no_grad(): # Disable gradient calculation + for i, (audio, labels) in enumerate(tqdm(dataloader)): + audio, labels = audio.to(device), labels.to( + device) # Move data to the correct device + + # Forward pass + labels_activations, model_activations = epoch_step( + model=model, + audio=audio, + labels=labels, + sr=sr, + device=device + ) + + # Compute the loss + loss = criterion(model_activations, labels_activations) + running_loss += loss.item() * audio.size(0) + + return running_loss / len(dataloader.dataset) + + +if __name__ == "__main__": + from crepe.dataset import MIR1KDataset, Back10Dataset, NSynthDataset + from torch.utils.data import DataLoader, random_split, ConcatDataset + + model_capacity = 'small' + learning_rate = 0.0002 + num_epoch = 50000 + num_batches_per_epoch = 8 + sr = 16000 + max_epochs_without_improvement = 32 + + device = torch.device('cuda' if torch.cuda.is_available( + ) else 'mps' if torch.backends.mps.is_available() else 'cpu') + + model = Crepe(model_capacity=model_capacity).to(device) + + # dataset + mir_1k = MIR1KDataset(root_dir="./dataset/MIR-1K") + back10 = Back10Dataset(root_dir="./dataset/Bach10") +# nsynth = NSynthDataset(root_dir="./dataset/Nsynth-mixed", n_samples=30) + dataset = ConcatDataset([back10, mir_1k]) + + # set train, validation dataset sizes + train_size = int(0.8 * len(dataset)) + val_size = len(dataset) - train_size + train_dataset, val_dataset = random_split(dataset, [train_size, val_size]) + + train_loader = DataLoader( + train_dataset, + shuffle=True, + num_workers=4, + pin_memory=True + ) + val_loader = DataLoader( + val_dataset, + shuffle=False, + num_workers=4, + pin_memory=True + ) + + # set optimizer + optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) + + best_val_loss = float('inf') + epochs_without_improvement = 0 + accumulation_steps = 4 + + for epoch in range(1, num_epoch + 1): + train_loss = 0.0 + for _ in range(num_batches_per_epoch): + tmp_loss = train_epoch( + model, + optimizer, + train_loader, + sr, + device + ) + train_loss += tmp_loss + # compute train loss + train_loss /= num_batches_per_epoch + + # validation step + val_loss = validate_epoch( + model, + val_loader, + sr, + device + ) + + print(f'Epoch {epoch}, Train Loss: { + train_loss:.4f}, Val Loss: {val_loss:.4f}') + + if val_loss < best_val_loss: + best_val_loss = val_loss + torch.save(model.state_dict(), + f'crepe/crepe_{model_capacity}_best.pth') + epochs_without_improvement = 0 + else: + epochs_without_improvement += 1 + + if epochs_without_improvement >= max_epochs_without_improvement: + print("Stopping early due to no improvement in validation loss.") + break + + # save model + torch.save(model.state_dict(), f'crepe/crepe_{model_capacity}_final.pth')