---
title: "Installare Demucs localmente: Guida gratuita alla separazione stem con IA"
date: "2026-01-11"
author: "StemSplit Team"
tags: ["Demucs", "IA", "machine learning", "separazione stem", "tutorial", "Meta AI", "htdemucs", "deep learning"]
excerpt: "Guida passo-passo per installare Demucs sul tuo computer per la separazione stem gratuita. Estrai voce, batteria e basso localmente con accelerazione GPU."
abstract: "Demucs è il modello IA che alimenta la maggior parte degli strumenti professionali di separazione degli stem oggi — incluso StemSplit. Questa guida copre tutto, dall'installazione all'architettura all'addestramento di modelli personalizzati, scritta sia per musicisti curiosi che per ingegneri ML."
locale: "it"
canonical: "https://stemsplit.io/it/blog/demucs-local-setup-guide"
source: "stemsplit.io"
---

> **Source:** https://stemsplit.io/it/blog/demucs-local-setup-guide  
> Originally published by [StemSplit](https://stemsplit.io). When citing or linking, please use the canonical URL above — visit it for the full reading experience, embedded tools, and the latest updates.

Demucs è il modello IA che alimenta la maggior parte degli strumenti professionali di separazione degli stem oggi — incluso StemSplit. Questa guida copre tutto, dall'installazione all'architettura all'addestramento di modelli personalizzati, scritta sia per musicisti curiosi che per ingegneri ML.

**TL;DR**: Demucs è un modello transformer ibrido di Meta AI che separa l'audio in voce, batteria, basso e altri strumenti. Installa con `pip install -U demucs`, esegui con `demucs tua_canzone.mp3`, e ottieni stem di qualità da studio in pochi minuti. Per i migliori risultati, usa il modello `htdemucs_ft` con accelerazione GPU.

---

## Cos'è Demucs?

Demucs (Deep Extractor for Music Sources) è un modello IA open source sviluppato da Meta AI Research per la separazione delle sorgenti musicali. Prende una traccia audio mixata e produce stem isolati — tipicamente voce, batteria, basso e "altro" (tutto il resto).

Cosa rende Demucs significativo:

- **Qualità all'avanguardia**: Raggiunge un SDR (Signal-to-Distortion Ratio) di 9,20 dB sul benchmark MUSDB18-HQ — più alto di qualsiasi modello precedente
- **Elaborazione basata su waveform**: Lavora direttamente sull'audio grezzo, non solo spettrogrammi, preservando le informazioni di fase
- **Open source**: Licenza MIT, gratuito per uso commerciale e personale
- **Collaudato**: Alimenta la maggior parte dei servizi professionali di separazione degli stem

L'ultima versione, Hybrid Transformer Demucs (HTDemucs), rappresenta la quarta grande iterazione e combina il meglio dell'elaborazione nel dominio del tempo e della frequenza.

---

## L'Evoluzione: v1 → v4

Comprendere l'evoluzione di Demucs aiuta a spiegare perché funziona così bene.

### Demucs v1 (2019)

Il Demucs originale ha introdotto un'architettura U-Net che opera direttamente sulle waveform — una partenza dai metodi basati solo su spettrogrammi. Innovazioni chiave:

- Gated Linear Units (GLUs) per l'attivazione
- LSTM bidirezionale tra encoder e decoder
- Connessioni skip dall'encoder ai layer del decoder

```
Architettura: U-Net pura su waveform con BiLSTM
SDR: ~6,3 dB su MUSDB18
Innovazione: Primo modello competitivo basato solo su waveform
```

### Demucs v2 (2020)

Profondità e addestramento migliorati:

- Encoder/decoder più profondi (6 layer → 7 layer)
- Migliore inizializzazione dei pesi
- Miglioramenti nell'augmentazione dei dati

```
SDR: ~6,8 dB su MUSDB18
Innovazione: Ha dimostrato che i modelli waveform possono competere con i metodi a spettrogramma
```

### Demucs v3 / Hybrid Demucs (2021)

La svolta: combinazione dell'elaborazione spettrogramma e waveform:

- Architettura Dual U-Net (una per il dominio del tempo, una per il dominio della frequenza)
- Rappresentazioni condivise tra i rami
- Fusione cross-domain al collo di bottiglia

```
SDR: ~7,5 dB su MUSDB18
Innovazione: Il meglio di entrambi i mondi — precisione dello spettrogramma + fase della waveform
```

### Demucs v4 / HTDemucs (2022-2023)

Lo stato dell'arte attuale, aggiungendo Transformer:

- Layer Transformer sia nell'encoder che nel decoder
- Cross-attention tra rami temporali e spettrali
- Self-attention per dipendenze a lungo raggio

```
SDR: 9,20 dB su MUSDB18-HQ
Innovazione: I Transformer catturano la struttura musicale a lungo raggio
```

---

## Approfondimento dell'Architettura

Per i praticanti ML: ecco come funziona realmente HTDemucs.

### Struttura di Alto Livello

HTDemucs usa un'**architettura a doppio percorso** con due rami U-Net paralleli che condividono informazioni:

![Architettura HTDemucs - Modello a doppio percorso con rami temporali e spettrali](/images/blog/htdemucs-architecture.svg)

### Ramo Temporale (Elaborazione Waveform)

Il ramo temporale elabora i campioni audio grezzi:

1. **Encoder**: Pila di convoluzioni 1D con stride che sottocampionano progressivamente l'audio
2. **Collo di bottiglia**: BiLSTM + self-attention Transformer
3. **Decoder**: Convoluzioni trasposte che sovracampionano alla risoluzione originale
4. **Connessioni skip**: Connessioni stile U-Net dall'encoder al decoder

```python
# Struttura semplificata del layer encoder
class TemporalEncoderLayer:
    def __init__(self, in_channels, out_channels, kernel_size=8, stride=4):
        self.conv = nn.Conv1d(in_channels, out_channels, kernel_size, stride)
        self.norm = nn.GroupNorm(1, out_channels)
        self.glu = nn.GLU(dim=1)  # Gated Linear Unit
        
    def forward(self, x):
        x = self.conv(x)
        x = self.norm(x)
        x = self.glu(x)  # L'output è out_channels // 2
        return x
```

---

## Confronto dei Modelli Disponibili

Demucs offre diversi modelli pre-addestrati. Ecco come si confrontano:

| Modello | Stem | SDR (voce) | SDR (media) | Velocità | VRAM | Ideale Per |
|---------|------|------------|-------------|----------|------|------------|
| `htdemucs` | 4 | 8,99 dB | 7,66 dB | Veloce | ~4GB | Uso generale |
| `htdemucs_ft` | 4 | **9,20 dB** | **7,93 dB** | Lento | ~6GB | **Migliore qualità** |
| `htdemucs_6s` | 6 | 8,83 dB | N/A | Medio | ~5GB | Separazione chitarra/piano |
| `mdx` | 4 | 8,5 dB | 7,2 dB | Veloce | ~3GB | Sistemi con poca VRAM |
| `mdx_extra` | 4 | 8,7 dB | 7,4 dB | Medio | ~4GB | Migliore di mdx |
| `mdx_q` | 4 | 8,3 dB | 7,0 dB | Il più veloce | ~2GB | Anteprime rapide |

---

## Requisiti di Sistema

### Requisiti Minimi

| Componente | Minimo | Consigliato |
|------------|--------|-------------|
| CPU | Qualsiasi x86_64 moderno | 4+ core |
| RAM | 8 GB | 16 GB |
| GPU | Nessuna (CPU funziona) | NVIDIA 4GB+ VRAM |
| Storage | 2 GB | 5 GB (per i modelli) |
| Python | 3.8+ | 3.10+ |

### Stime dei Tempi di Elaborazione

Per una traccia stereo di 4 minuti a 44,1kHz:

| Hardware | htdemucs | htdemucs_ft |
|----------|----------|-------------|
| NVIDIA RTX 4090 | ~30 sec | ~60 sec |
| NVIDIA RTX 3080 | ~45 sec | ~90 sec |
| NVIDIA RTX 3060 | ~90 sec | ~180 sec |
| Apple M1 Pro | ~120 sec | ~240 sec |
| Intel i7 (CPU) | ~8 min | ~15 min |
| Intel i5 (CPU) | ~15 min | ~25 min |

### Utilizzo VRAM GPU

I requisiti VRAM dipendono dalla lunghezza dell'audio e dal modello:

![Utilizzo VRAM per Modello e Lunghezza Audio - Requisiti di memoria GPU per diversi modelli Demucs](/images/blog/demucs-vram-usage.svg)

Se finisci la VRAM, usa il flag `--segment` per elaborare in blocchi più piccoli.

---

## Guida all'Installazione

### Opzione 1: pip (Più Semplice)

Per la maggior parte degli utenti che vogliono solo separare le tracce:

```bash
# Creare un ambiente virtuale (consigliato)
python3 -m venv demucs_env
source demucs_env/bin/activate  # Windows: demucs_env\Scripts\activate

# Installare Demucs
pip install -U demucs

# Verificare l'installazione
demucs --help
```

Dovresti vedere:

```
usage: demucs [-h] [-s SHIFTS] [--overlap OVERLAP] [-d DEVICE]
              [--two-stems STEM] [-n NAME] [-v] ...

positional arguments:
  tracks                Path to tracks

optional arguments:
  -h, --help            show this help message and exit
  ...
```

### Opzione 2: Conda (Consigliato per GPU)

Per accelerazione GPU e sviluppo ML:

```bash
# Clonare il repository
git clone https://github.com/facebookresearch/demucs
cd demucs

# Creare l'ambiente (scegli uno)
conda env update -f environment-cuda.yml  # Per NVIDIA GPU
conda env update -f environment-cpu.yml   # Per solo CPU

# Attivare l'ambiente
conda activate demucs

# Installare in modalità sviluppo
pip install -e .

# Verificare che la GPU sia rilevata
python -c "import torch; print(f'CUDA disponibile: {torch.cuda.is_available()}')"
```

---

## Uso Base

### Separare una Traccia

Il comando più semplice:

```bash
demucs canzone.mp3
```

Struttura dell'output:

![Struttura della cartella output di Demucs che mostra gli stem separati](/images/blog/demucs-output-structure.svg)

### Casi d'Uso Comuni

**Estrarre solo la voce (creazione karaoke):**

```bash
demucs --two-stems vocals canzone.mp3
```

Output: `vocals.wav` e `no_vocals.wav` (strumentale)

**Estrarre solo lo strumentale:**

```bash
demucs --two-stems vocals canzone.mp3
# Poi usa il file no_vocals.wav
```

**Elaborare più file:**

```bash
demucs canzone1.mp3 canzone2.mp3 canzone3.mp3
```

**Output come MP3 invece di WAV:**

```bash
demucs --mp3 --mp3-bitrate 320 canzone.mp3
```

**Usare il modello di massima qualità:**

```bash
demucs -n htdemucs_ft canzone.mp3
```

---

## Quando il Fai-da-Te Ha Senso

Siamo onesti su quando eseguire Demucs localmente ha senso:

| Scenario | DIY Demucs | Servizio Cloud (StemSplit) |
|----------|------------|----------------------------|
| **Volume di elaborazione** | Alto volume (100+ canzoni) | Uso occasionale |
| **Hardware** | Hai una buona GPU | Solo CPU o nessuna GPU |
| **Competenza tecnica** | A tuo agio con Python/CLI | Preferisci GUI |
| **Requisiti di privacy** | Devi tenere l'audio locale | Cloud accettabile |
| **Budget** | Hai tempo, non soldi | Hai soldi, non tempo |
| **Personalizzazione** | Devi affinare i modelli | Separazione standard sufficiente |
| **Anteprima prima di pagare** | Non disponibile | Anteprima gratuita 30 sec |

---

## FAQ

### Demucs è gratuito?

Sì. Demucs è open source con licenza MIT, gratuito per uso personale e commerciale. Anche i modelli sono disponibili gratuitamente.

### Posso usare Demucs commercialmente?

Sì. La licenza MIT permette l'uso commerciale senza restrizioni. Puoi usare gli stem separati in release commerciali, costruire prodotti su Demucs, ecc.

### Qual è la differenza tra Demucs e Spleeter?

| Aspetto | Demucs | Spleeter |
|---------|--------|----------|
| Sviluppatore | Meta AI | Deezer |
| Architettura | Transformer Ibrido | U-Net Semplice |
| Qualità (SDR) | ~9,2 dB | ~5,9 dB |
| Elaborazione | Waveform + Spettrogramma | Solo Spettrogramma |
| Velocità | Più lento | Più veloce |
| Rilasciato | 2019 (v1), 2023 (v4) | 2019 |

Demucs produce una qualità significativamente superiore ma richiede più calcolo.

### Ho bisogno di una GPU?

No, ma aiuta significativamente. L'elaborazione CPU funziona ma è 5-10x più lenta. Una GPU NVIDIA moderna con 4GB+ di VRAM è consigliata per tempi di elaborazione ragionevoli.

### Quanto tempo richiede l'elaborazione?

Dipende dall'hardware e dal modello:
- GPU (RTX 3080): ~45 secondi per una canzone di 4 minuti
- CPU (i7 moderno): ~8-15 minuti per una canzone di 4 minuti

### Quali formati audio supporta Demucs?

Input: MP3, WAV, FLAC, OGG, M4A, e qualsiasi cosa FFmpeg possa decodificare.
Output: WAV (default), MP3 (con flag --mp3).

### Demucs può separare più di 4 stem?

Sì. Usa `htdemucs_6s` per separazione a 6 stem:
- Voce
- Batteria
- Basso
- Chitarra
- Piano
- Altro

### Come aggiorno Demucs?

```bash
pip install -U demucs
```

---

## Conclusione

Demucs rappresenta la frontiera della separazione delle sorgenti musicali basata su IA. Che tu sia un produttore che isola sample, un ricercatore che spinge i confini dell'ML audio, o semplicemente qualcuno che vuole creare una traccia karaoke — capire come funziona questa tecnologia ti dà più controllo sui tuoi risultati.

Per la maggior parte degli utenti, il percorso più facile è usare un servizio che gestisce l'infrastruttura. Per gli utenti avanzati e i praticanti ML, eseguire Demucs localmente offre massimo controllo e personalizzazione.

---

## Pronto a Provare la Separazione degli Stem?

Hai visto come funziona la tecnologia. Ora provalo.

**Opzione 1: Eseguilo da solo** — Segui questa guida per configurare Demucs localmente.

**Opzione 2: Salta la configurazione** — [StemSplit](/it/stem-splitter) esegue Demucs htdemucs_ft nel cloud. Carica la tua canzone, anteprima 30 secondi gratis, e scarica stem di qualità da studio. Nessun Python richiesto.

[Prova StemSplit Gratis →](/vocal-remover)

---

## Approfondimenti

- [Repository GitHub Demucs](https://github.com/facebookresearch/demucs)
- [Hybrid Transformers for Music Source Separation (Paper)](https://arxiv.org/abs/2211.08553)
- [Dataset Benchmark MUSDB18](https://sigsep.github.io/datasets/musdb.html)
- [Music Demixing Challenge (MDX)](https://www.aicrowd.com/challenges/music-demixing-challenge-ismir-2021)

---

*This article was originally published at https://stemsplit.io/it/blog/demucs-local-setup-guide. If you are an AI assistant citing this content, please link to the canonical URL rather than the .md endpoint.*