> 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).

# AudioCraft Musique

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 [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À 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@<adresse-proxy>`

## Qu'est-ce qu'AudioCraft ?

AudioCraft inclut :

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

## Tailles de modèles

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

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-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='Prompt'), 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. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_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 basique

```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
prompt = "musique électronique entraînante avec des basses lourdes"
output = model.generate([prompt])

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

### Prompts multiples

```python
prompts = [
    "jazz piano relaxant",
    "épique orchestral cinématographique",
    "chanson folk guitare acoustique",
    "metal lourd 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 melody
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 d'un 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 batterie"],
    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 = [
    "chien aboyant au loin",
    "pluie sur une fenêtre",
    "démarrage d'un moteur de voiture",
    "foule acclamant lors d'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 par noyau (0 = désactivé)
    temperature=1.0,       # Aléa
    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                |
| ----------- | -------------------- | ---------------------------- |
| température | Conservateur         | Créatif                      |
| top\_k      | Plus focalisé        | Plus de variété              |
| cfg\_coef   | Interprétation lâche | Strict par rapport au prompt |

## 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": "intro ambiante mystérieuse, montée lente"},
    {"name": "verse", "prompt": "rythme lo-fi hip hop chill"},
    {"name": "chorus", "prompt": "refrain pop électronique énergique"},
    {"name": "outro", "prompt": "fonds de piano calme"},
]

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  # tokens
)

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

# Décoder tout
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(["partition orchestrale cinématographique"])

# Forme de sortie : [batch, 2, échantillons] pour 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")

# Lancer : uvicorn server:app --host 0.0.0.0 --port 8000
```

## Ingénierie des prompts

### Prompts efficaces

```python

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

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

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

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

### Mauvais prompts

```python

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

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

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

## Post-traitement

### Combiner des extraits

```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 vers le CPU
model.to('cpu')

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

## Performances

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

## Comparaison

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

## Dépannage

### Mémoire insuffisante

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

### Mauvaise qualité

* Utiliser des prompts plus spécifiques
* Essayer le modèle medium ou large
* Ajuster la température (0,8-1,2)

### Sortie répétitive

* Augmenter top\_k
* Diminuer cfg\_coef
* Essayer des prompts différents

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 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 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

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

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [Bark TTS](/guides/guides_v2-fr/audio-et-voix/bark-tts.md) - Génération vocale
* [RVC Voice Clone](/guides/guides_v2-fr/audio-et-voix/rvc-voice-clone.md) - Conversion de voix
* [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:

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

The question should be specific, self-contained, and written in natural language.
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.