AudioCraft provides the code and models for MusicGen, a simple and controllable model for music generation. MusicGen is a single stage auto-regressive Transformer model trained over a 32kHz EnCodec tokenizer with 4 codebooks sampled at 50 Hz. Unlike existing methods like MusicLM, MusicGen doesn't require a self-supervised semantic representation, and it generates all 4 codebooks in one pass. By introducing a small delay between the codebooks, we show we can predict them in parallel, thus having only 50 auto-regressive steps per second of audio. Check out our sample page or test the available demo!
We use 20K hours of licensed music to train MusicGen. Specifically, we rely on an internal dataset of 10K high-quality music tracks, and on the ShutterStock and Pond5 music data.
See the model card.
Please follow the AudioCraft installation instructions from the README.
AudioCraft requires a GPU with at least 16 GB of memory for running inference with the medium-sized models (~1.5B parameters).
We offer a number of way to interact with MusicGen:
- A demo is also available on the
facebook/MusicGenHugging Face Space (huge thanks to all the HF team for their support). - You can run the extended demo on a Colab: colab notebook
- You can use the gradio demo locally by running
python -m demos.musicgen_app --share. - You can play with MusicGen by running the jupyter notebook at
demos/musicgen_demo.ipynblocally (if you have a GPU). - Finally, checkout @camenduru Colab page which is regularly updated with contributions from @camenduru and the community.
We provide a simple API and 10 pre-trained models. The pre trained models are:
facebook/musicgen-small: 300M model, text to music only - 🤗 Hubfacebook/musicgen-medium: 1.5B model, text to music only - 🤗 Hubfacebook/musicgen-melody: 1.5B model, text to music and text+melody to music - 🤗 Hubfacebook/musicgen-large: 3.3B model, text to music only - 🤗 Hubfacebook/musicgen-melody-large: 3.3B model, text to music and text+melody to music - 🤗 Hubfacebook/musicgen-stereo-*: All the previous models fine tuned for stereo generation - small, medium, large, melody, melody large.
We observe the best trade-off between quality and compute with the facebook/musicgen-medium or facebook/musicgen-melody model.
In order to use MusicGen locally you must have a GPU. We recommend 16GB of memory, but smaller
GPUs will be able to generate short sequences, or longer sequences with the facebook/musicgen-small model.
See after a quick example for using the API.
import torchaudio
from audiocraft.models import MusicGen
from audiocraft.data.audio import audio_write
model = MusicGen.get_pretrained('facebook/musicgen-melody')
model.set_generation_params(duration=8) # generate 8 seconds.
wav = model.generate_unconditional(4) # generates 4 unconditional audio samples
descriptions = ['happy rock', 'energetic EDM', 'sad jazz']
wav = model.generate(descriptions) # generates 3 samples.
melody, sr = torchaudio.load('./assets/bach.mp3')
# generates using the melody from the given audio and the provided descriptions.
wav = model.generate_with_chroma(descriptions, melody[None].expand(3, -1, -1), sr)
for idx, one_wav in enumerate(wav):
# Will save under {idx}.wav, with loudness normalization at -14 db LUFS.
audio_write(f'{idx}', one_wav.cpu(), model.sample_rate, strategy="loudness", loudness_compressor=True)MusicGen is available in the 🤗 Transformers library from version 4.31.0 onwards, requiring minimal dependencies and additional packages. Steps to get started:
- First install the 🤗 Transformers library from main:
pip install git+https://github.com/huggingface/transformers.git- Run the following Python code to generate text-conditional audio samples:
from transformers import AutoProcessor, MusicgenForConditionalGeneration
processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
inputs = processor(
text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
padding=True,
return_tensors="pt",
)
audio_values = model.generate(**inputs, max_new_tokens=256)- Listen to the audio samples either in an ipynb notebook:
from IPython.display import Audio
sampling_rate = model.config.audio_encoder.sampling_rate
Audio(audio_values[0].numpy(), rate=sampling_rate)Or save them as a .wav file using a third-party library, e.g. scipy:
import scipy
sampling_rate = model.config.audio_encoder.sampling_rate
scipy.io.wavfile.write("musicgen_out.wav", rate=sampling_rate, data=audio_values[0, 0].numpy())For more details on using the MusicGen model for inference using the 🤗 Transformers library, refer to the MusicGen docs or the hands-on Google Colab.
The MusicGenSolver implements MusicGen's training pipeline. It defines an autoregressive language modeling task over multiple streams of discrete tokens extracted from a pre-trained EnCodec model (see EnCodec documentation for more details on how to train such model).
Note that we do NOT provide any of the datasets used for training MusicGen. We provide a dummy dataset containing just a few examples for illustrative purposes.
Please read first the TRAINING documentation, in particular the Environment Setup section.
Warning: As of version 1.1.0, a few breaking changes were introduced. Check the CHANGELOG.md file for more information. You might need to retrain some of your models.
We provide configurations to reproduce the released models and our research. MusicGen solvers configuration are available in config/solver/musicgen, in particular:
- MusicGen base model for text-to-music:
solver=musicgen/musicgen_base_32khz - MusicGen model with chromagram-conditioning support:
solver=musicgen/musicgen_melody_32khz
We provide 3 different scales, e.g. model/lm/model_scale=small (300M), or medium (1.5B), and large (3.3B).
Please find some example grids to train MusicGen at audiocraft/grids/musicgen.
# text-to-music
dora grid musicgen.musicgen_base_32khz --dry_run --init
# melody-guided music generation
dora grid musicgen.musicgen_melody_base_32khz --dry_run --init
# Remove the `--dry_run --init` flags to actually schedule the jobs once everything is setup.MusicGen's underlying dataset is an AudioDataset augmented with music-specific metadata.
The MusicGen dataset implementation expects the metadata to be available as .json files
at the same location as the audio files. Learn more in the datasets section.
We support a number of audio tokenizers: either pretrained EnCodec models, DAC, or your own models.
The tokenizer is controlled with the setting compression_model_checkpoint.
For instance,
# Using the 32kHz EnCodec trained on music
dora run solver=musicgen/debug \
compression_model_checkpoint=//pretrained/facebook/encodec_32khz \
transformer_lm.n_q=4 transformer_lm.card=2048
# Using DAC
dora run solver=musicgen/debug \
compression_model_checkpoint=//pretrained/dac_44khz \
transformer_lm.n_q=9 transformer_lm.card=1024 \
'codebooks_pattern.delay.delays=[0,1,2,3,4,5,6,7,8]'
# Using your own model after export (see ENCODEC.md)
dora run solver=musicgen/debug \
compression_model_checkpoint=//pretrained//checkpoints/my_audio_lm/compression_state_dict.bin \
transformer_lm.n_q=... transformer_lm.card=...
# Using your own model from its training checkpoint.
dora run solver=musicgen/debug \
compression_model_checkpoint=//sig/SIG \ # where SIG is the Dora signature of the EnCodec XP.
transformer_lm.n_q=... transformer_lm.card=...Warning: you are responsible for setting the proper value for transformer_lm.n_q and transformer_lm.card (cardinality of the codebooks). You also have to update the codebook_pattern to match n_q as shown in the example for using DAC. .
Use the option interleave_stereo_codebooks.use set to True to activate stereo training along with channels=2. Left and right channels will be
encoded separately by the compression model, then their codebook will be interleaved, e.g. order of codebook is
[1_L, 1_R, 2_L, 2_R, ...]. You will also need to update the delays for the codebook patterns to match the number of codebooks, and the n_q value passed to the transformer LM:
dora run solver=musicgen/debug \
compression_model_checkpoint=//pretrained/facebook/encodec_32khz \
channels=2 interleave_stereo_codebooks.use=True \
transformer_lm.n_q=8 transformer_lm.card=2048 \
codebooks_pattern.delay.delays='[0, 0, 1, 1, 2, 2, 3, 3]'
You can initialize your model to one of the pretrained models by using the continue_from argument, in particular
# Using pretrained MusicGen model.
dora run solver=musicgen/musicgen_base_32khz model/lm/model_scale=medium continue_from=//pretrained/facebook/musicgen-medium conditioner=text2music
# Using another model you already trained with a Dora signature SIG.
dora run solver=musicgen/musicgen_base_32khz model/lm/model_scale=medium continue_from=//sig/SIG conditioner=text2music
# Or providing manually a path
dora run solver=musicgen/musicgen_base_32khz model/lm/model_scale=medium continue_from=/checkpoints/my_other_xp/checkpoint.thWarning: You are responsible for selecting the other parameters accordingly, in a way that make it compatible
with the model you are fine tuning. Configuration is NOT automatically inherited from the model you continue from. In particular make sure to select the proper conditioner and model/lm/model_scale.
Warning: We currently do not support fine tuning a model with slightly different layers. If you decide
to change some parts, like the conditioning or some other parts of the model, you are responsible for manually crafting a checkpoint file from which we can safely run load_state_dict.
If you decide to do so, make sure your checkpoint is saved with torch.save and contains a dict
{'best_state': {'model': model_state_dict_here}}. Directly give the path to continue_from without a //pretrained/ prefix.
You will not be able to continue_from a mono model with stereo training, as the shape of the embeddings and output linears
would not match. You can use the following snippet to prepare a proper finetuning checkpoint.
from pathlib import Path
import torch
# Download the pretrained model, e.g. from
# https://huggingface.co/facebook/musicgen-melody/blob/main/state_dict.bin
model_name = 'musicgen-melody'
root = Path.home() / 'checkpoints'
# You are responsible for downloading the following checkpoint in the proper location
input_state_dict_path = root / model_name / 'state_dict.bin'
state = torch.load(input_state_dict_path, 'cpu')
bs = state['best_state']
# there is a slight different in format between training checkpoints and exported public checkpoints.
# If you want to use your own mono models from one of your training checkpont, following the instructions
# for exporting a model explained later on this page.
assert 'model' not in bs, 'The following code is for using an exported pretrained model'
nbs = dict(bs)
for k in range(8):
# We will just copy mono embeddings and linears twice, once for left and right channels.
nbs[f'linears.{k}.weight'] = bs[f'linears.{k//2}.weight']
nbs[f'emb.{k}.weight'] = bs[f'emb.{k//2}.weight']
torch.save({'best_state': {'model': nbs}}, root / f'stereo_finetune_{model_name}.th')Now, you can use $HOME/checkpoints/stereo_finetune_musicgen-melody.th as a continue_from target (without a //pretrained prefix!).
It is possible to precompute the EnCodec tokens and other metadata. An example of generating and using this cache provided in the musicgen.musicgen_base_cached_32khz grid.
By default, evaluation stage is also computing the cross-entropy and the perplexity over the evaluation dataset. Indeed the objective metrics used for evaluation can be costly to run or require some extra dependencies. Please refer to the metrics documentation for more details on the requirements for each metric.
We provide an off-the-shelf configuration to enable running the objective metrics for audio generation in config/solver/musicgen/evaluation/objective_eval.
One can then activate evaluation the following way:
# using the configuration
dora run solver=musicgen/debug solver/musicgen/evaluation=objective_eval
# specifying each of the fields, e.g. to activate KL computation
dora run solver=musicgen/debug evaluate.metrics.kld=trueSee an example evaluation grid.
The generation stage allows to generate samples conditionally and/or unconditionally and to perform
audio continuation (from a prompt). We currently support greedy sampling (argmax), sampling
from softmax with a given temperature, top-K and top-P (nucleus) sampling. The number of samples
generated and the batch size used are controlled by the dataset.generate configuration
while the other generation parameters are defined in generate.lm.
# control sampling parameters
dora run solver=musicgen/debug generate.lm.gen_duration=10 generate.lm.use_sampling=true generate.lm.top_k=15Note that generation happens automatically every 25 epochs. You can easily access and
compare samples between models (as long as they are trained) on the same dataset using the
MOS tool. For that first pip install Flask gunicorn. Then
gunicorn -w 4 -b 127.0.0.1:8895 -t 120 'scripts.mos:app' --access-logfile -
And access the tool at https://127.0.0.1:8895.
Once you have launched some experiments, you can easily get access to the Solver with the latest trained model using the following snippet.
from audiocraft.solvers.musicgen import MusicGenSolver
solver = MusicGenSolver.get_eval_solver_from_sig('SIG', device='cpu', batch_size=8)
solver.model
solver.dataloadersWe do not support currently loading a model from the Hugging Face implementation or exporting to it.
If you want to export your model in a way that is compatible with audiocraft.models.MusicGen
API, you can run:
from audiocraft.utils import export
from audiocraft import train
xp = train.main.get_xp_from_sig('SIG_OF_LM')
export.export_lm(xp.folder / 'checkpoint.th', '/checkpoints/my_audio_lm/state_dict.bin')
# You also need to bundle the EnCodec model you used !!
## Case 1) you trained your own
xp_encodec = train.main.get_xp_from_sig('SIG_OF_ENCODEC')
export.export_encodec(xp_encodec.folder / 'checkpoint.th', '/checkpoints/my_audio_lm/compression_state_dict.bin')
## Case 2) you used a pretrained model. Give the name you used without the //pretrained/ prefix.
## This will actually not dump the actual model, simply a pointer to the right model to download.
export.export_pretrained_compression_model('facebook/encodec_32khz', '/checkpoints/my_audio_lm/compression_state_dict.bin')Now you can load your custom model with:
import audiocraft.models
musicgen = audiocraft.models.MusicGen.get_pretrained('/checkpoints/my_audio_lm/')Learn more about AudioCraft training pipelines in the dedicated section.
@FurkanGozukara made a complete tutorial for AudioCraft/MusicGen on Windows
Check @camenduru tutorial on YouTube.
Check out @FurkanGozukara tutorial.
The two are mutually exclusive (because FSDP does autocast on its own). You can use autocast up to 1.5B (medium), if you have enough RAM on your GPU. FSDP makes everything more complex but will free up some memory for the actual activations by sharding the optimizer state.
@inproceedings{copet2023simple,
title={Simple and Controllable Music Generation},
author={Jade Copet and Felix Kreuk and Itai Gat and Tal Remez and David Kant and Gabriel Synnaeve and Yossi Adi and Alexandre Défossez},
booktitle={Thirty-seventh Conference on Neural Information Processing Systems},
year={2023},
}
See license information in the model card.