# Musique AudioCraft

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](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/bark-tts) - Génération vocale
* [RVC Voice Clone](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/rvc-voice-clone) - Conversion de voix
* [Séparation Demucs](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/demucs-separation) - Séparation audio