> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/audiocraft-music.md).

# Musique AudioCraft

Générez de la musique et de l'audio avec AudioCraft de Meta sur Clore.ai

Générez de la musique et de l'audio avec AudioCraft de Meta (MusicGen).

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
2. Filtrez par type de GPU, VRAM et prix
3. Choisissez **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<proxy-address>`

## Qu'est-ce qu'AudioCraft ?

AudioCraft comprend :

* **MusicGen** - Génération de texte en musique
* **AudioGen** - Génération d'effets sonores
* **EnCodec** - Compression audio
* **MAGNeT** - Génération plus rapide

## Tailles des modèles

| Modèle  | VRAM  | Qualité             | Vitesse |
| ------- | ----- | ------------------- | ------- |
| petit   | 4 Go  | Bon                 | Rapide  |
| moyen   | 8 Go  | Excellent           | Moyen   |
| grand   | 16 Go | Meilleur            | Lent    |
| mélodie | 8 Go  | Excellent + mélodie | Moyen   |

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Ports :**

```
22/tcp
7860/http
```

**Commande :**

```bash
pip install audiocraft gradio scipy && \
python -c "
import gradio as gr
from audiocraft.models import MusicGen
import scipy.io.wavfile as wav
import tempfile

model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=10)

def generate(prompt, duration):
    model.set_generation_params(duration=duration)
    output = model.generate([prompt])
    audio = output[0].cpu().numpy().T
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        wav.write(f.name, 32000, audio)
        return f.name

demo = gr.Interface(
    fn=generate,
    inputs=[gr.Textbox(label='Invite'), gr.Slider(5, 30, value=10, label='Durée (s)')],
    outputs=gr.Audio(label='Musique générée'),
    title='MusicGen'
)
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Installation

```bash
pip install audiocraft
pip install scipy torchaudio
```

## MusicGen : texte en musique

### Génération de base

```python
from audiocraft.models import MusicGen
import torchaudio

# Charger le modèle
model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)  # secondes

# Générer
"musique de danse électronique entraînante avec des basses puissantes"
output = model.generate([prompt])

# Enregistrer
audio = output[0].cpu()
torchaudio.save("music.wav", audio, sample_rate=32000)
```

### Plusieurs invites

```python
prompts = [
    "jazz piano relaxant",
    "cinématographique orchestral épique",
    "chanson folk à la guitare acoustique",
    "heavy metal agressif"
]

outputs = model.generate(prompts)

for i, output in enumerate(outputs):
    torchaudio.save(f"music_{i}.wav", output.cpu(), sample_rate=32000)
```

### Conditionnement par mélodie

Utilisez une mélodie comme référence :

```python
from audiocraft.models import MusicGen
import torchaudio

# Charger le modèle de mélodie
model = MusicGen.get_pretrained('facebook/musicgen-melody')
model.set_generation_params(duration=15)

# Charger la mélodie de référence
melody, sr = torchaudio.load("reference.wav")
melody = melody.unsqueeze(0).cuda()

# Générer avec la mélodie
output = model.generate_with_chroma(
    ["version piano jazz"],
    melody,
    sr
)

torchaudio.save("jazz_version.wav", output[0].cpu(), sample_rate=32000)
```

### Continuation

Continuer à partir de l'audio existant :

```python

# Charger l'audio à continuer
audio, sr = torchaudio.load("start.wav")
audio = audio.unsqueeze(0).cuda()

# Continuer
output = model.generate_continuation(
    audio,
    prompt_sample_rate=sr,
    descriptions=["plus énergique avec des percussions"],
    progress=True
)

torchaudio.save("continued.wav", output[0].cpu(), sample_rate=32000)
```

## AudioGen : effets sonores

```python
from audiocraft.models import AudioGen

# Charger le modèle
model = AudioGen.get_pretrained('facebook/audiogen-medium')
model.set_generation_params(duration=5)

# Générer des sons
prompts = [
    "aboiements d'un chien au loin",
    "pluie sur une fenêtre",
    "démarrage du moteur d'une voiture",
    "foule applaudissant à un concert"
]

outputs = model.generate(prompts)

for i, output in enumerate(outputs):
    torchaudio.save(f"sound_{i}.wav", output.cpu(), sample_rate=16000)
```

## Paramètres de génération

```python
model.set_generation_params(
    duration=30,           # Durée en secondes
    top_k=250,             # Échantillonnage top-k
    top_p=0.0,             # Échantillonnage nucleus (0 = désactivé)
    temperature=1.0,       # Aléatoire
    cfg_coef=3.0,          # Guidage sans classificateur
    two_step_cfg=False,    # CFG en deux étapes
)
```

### Effets des paramètres

| Paramètre   | Valeur faible         | Valeur élevée                 |
| ----------- | --------------------- | ----------------------------- |
| temperature | Conservateur          | Créatif                       |
| top\_k      | Plus ciblé            | Plus de variété               |
| cfg\_coef   | Interprétation souple | Strictement fidèle à l'invite |

## Traitement par lots

```python
from audiocraft.models import MusicGen
import torchaudio
import os

model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)

prompts = [
    {"name": "intro", "prompt": "introduction ambient mystérieuse, montée lente"},
    {"name": "verse", "prompt": "rythme hip-hop lo-fi relax"},
    {"name": "chorus", "prompt": "refrain pop électronique énergique"},
    {"name": "outro", "prompt": "fondu final calme au piano"},
]

output_dir = "./music_parts"
os.makedirs(output_dir, exist_ok=True)

for item in prompts:
    output = model.generate([item["prompt"]])
    torchaudio.save(
        os.path.join(output_dir, f"{item['name']}.wav"),
        output[0].cpu(),
        sample_rate=32000
    )
    print(f"Généré : {item['name']}")
```

## Génération en streaming

```python
from audiocraft.models import MusicGen
import torch

model = MusicGen.get_pretrained('facebook/musicgen-small')

# Activer le streaming
streamer = model.get_streaming_generator(
    "musique pop entraînante",
    max_gen_len=256  # jetons
)

all_tokens = []
for tokens in streamer:
    all_tokens.append(tokens)
    # Traiter le lot...

# Tout décoder
audio = model.decode(torch.cat(all_tokens, dim=-1))
```

## Génération stéréo

```python
from audiocraft.models import MusicGen

# Charger le modèle stéréo
model = MusicGen.get_pretrained('facebook/musicgen-stereo-medium')
model.set_generation_params(duration=15)

output = model.generate(["bande originale orchestrale cinématographique"])

# Forme de sortie : [batch, 2, samples] pour la stéréo

torchaudio.save("stereo_music.wav", output[0].cpu(), sample_rate=32000)
```

## Serveur API

```python
from fastapi import FastAPI
from fastapi.responses import FileResponse
from audiocraft.models import MusicGen
import torchaudio
import tempfile

app = FastAPI()
model = MusicGen.get_pretrained('facebook/musicgen-medium')

@app.post("/generate")
async def generate_music(prompt: str, duration: int = 10):
    model.set_generation_params(duration=duration)
    output = model.generate([prompt])

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, output[0].cpu(), sample_rate=32000)
        return FileResponse(f.name, media_type="audio/wav")

@app.post("/generate_with_melody")
async def generate_with_melody(prompt: str, melody_path: str, duration: int = 15):
    melody, sr = torchaudio.load(melody_path)

    model_melody = MusicGen.get_pretrained('facebook/musicgen-melody')
    model_melody.set_generation_params(duration=duration)

    output = model_melody.generate_with_chroma([prompt], melody.unsqueeze(0).cuda(), sr)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, output[0].cpu(), sample_rate=32000)
        return FileResponse(f.name, media_type="audio/wav")

# Exécuter : uvicorn server:app --host 0.0.0.0 --port 8000
```

## Ingénierie des invites

### Invites efficaces

```python

# Genre + instruments + ambiance
"jazz entraînant avec saxophone et piano, joyeux et énergique"

# Référence de style
"rythme hip-hop lo-fi, musique d'étude relaxante, crépitement de vinyle"

# Cinématographique
"musique de bande-annonce orchestrale épique, tension croissante, dramatique"

# Éléments spécifiques
"motif de grattement de guitare acoustique, chanson folk, ambiance feu de camp"
```

### Mauvais prompts

```python

# Trop vague
"jolie musique"  # Pas assez spécifique

# Paroles de chanson
"Joyeux anniversaire à toi..."  # Ne fonctionnera pas

# Noms d'artistes
"comme les Beatles"  # Ne comprend pas les artistes
```

## Post-traitement

### Combiner les clips

```python
from pydub import AudioSegment

intro = AudioSegment.from_wav("intro.wav")
verse = AudioSegment.from_wav("verse.wav")
chorus = AudioSegment.from_wav("chorus.wav")

# Fondu enchaîné
song = intro.append(verse, crossfade=1000)
song = song.append(chorus, crossfade=1000)

song.export("full_song.mp3", format="mp3")
```

### Ajouter des effets

```python
from pydub import AudioSegment
from pydub.effects import normalize, compress_dynamic_range

audio = AudioSegment.from_wav("generated.wav")

# Normaliser le volume
audio = normalize(audio)

# Ajouter de la compression
audio = compress_dynamic_range(audio)

# Fondu entrant/sortant
audio = audio.fade_in(2000).fade_out(3000)

audio.export("processed.wav", format="wav")
```

## Optimisation de la mémoire

```python
import torch
from audiocraft.models import MusicGen

# Utiliser un modèle plus petit
model = MusicGen.get_pretrained('facebook/musicgen-small')

# Activer le déchargement sur CPU
model.to('cpu')

# Générer sur le GPU, décharger immédiatement
with torch.cuda.amp.autocast():
    output = model.generate(["invite"])
    output = output.cpu()
    torch.cuda.empty_cache()
```

## Performances

| Modèle  | GPU      | Génération de 30 s |
| ------- | -------- | ------------------ |
| petit   | RTX 3090 | \~10 s             |
| moyen   | RTX 3090 | \~25 s             |
| grand   | RTX 4090 | \~45 s             |
| mélodie | RTX 3090 | \~30s              |

## Comparaison

| Fonctionnalité    | MusicGen  | Stable Audio | Riffusion |
| ----------------- | --------- | ------------ | --------- |
| Qualité           | Excellent | Excellent    | Bon       |
| Durée             | 30 s      | 90 s         | Boucle    |
| Entrée de mélodie | Oui       | Non          | Non       |
| Open source       | Oui       | Non          | Oui       |

## Dépannage

### Mémoire insuffisante

* Utilisez un modèle plus petit (small au lieu de large)
* Réduisez la durée
* Vider le cache : `torch.cuda.empty_cache()`

### Qualité médiocre

* Utilisez des invites plus spécifiques
* Essayez un modèle medium ou large
* Ajustez la température (0,8-1,2)

### Sortie répétitive

* Augmentez top\_k
* Baissez cfg\_coef
* Essayez d'autres invites

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

| GPU        | Tarif horaire | Tarif journalier | Session de 4 heures |
| ---------- | ------------- | ---------------- | ------------------- |
| RTX 3060   | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090   | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090   | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40 Go | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80 Go | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez le **Spot** marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane \~13 % de remise), les autres s'alignent dessus
* Payez avec **CLORE** jetons
* Comparez les prix entre différents fournisseurs

## Étapes suivantes

* [Bark TTS](/guides/guides_v2-fr/audio-et-voix/bark-tts.md) - Génération vocale
* [Clonage vocal RVC](/guides/guides_v2-fr/audio-et-voix/rvc-voice-clone.md) - Conversion vocale
* [Séparation Demucs](/guides/guides_v2-fr/audio-et-voix/demucs-separation.md) - Séparation audio


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/audiocraft-music.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.