Come fare face swap e cambiare viso in un video con l’intelligenza artificiale: guida reale su Linux

Negli ultimi mesi l’intelligenza artificiale è diventata una specie di martello universale: qualunque problema hai, qualcuno ti dice che l’AI lo risolve. Editing video, generazione immagini, voce sintetica, animazioni facciali. Tutto sembra magico finché non provi davvero a usarlo su una macchina reale, con hardware normale e tempo limitato. Lì finisce la favola e inizia il lavoro vero.

Il face swap è uno di quei campi dove l’intelligenza artificiale fa davvero impressione… almeno nei video promozionali. Volti perfettamente sovrapposti, espressioni naturali, rotazioni credibili, qualità cinematografica. Poi apri il terminale, installi un modello, e ti ritrovi con una faccia che sembra incollata male su un cartonato. La teoria è elegante, la pratica è una guerra continua con dipendenze, modelli incompatibili e risultati che cambiano completamente in base a dettagli minuscoli.

Apri il terminale, segui una guida, installi un modello, e ti ritrovi con un volto che sembra incollato con lo scotch su un corpo in movimento, che si deforma non appena la testa ruota di qualche grado. Il salto tra il trailer promozionale e il risultato reale è abissale. Le demo su YouTube mostrano perfezione assoluta, ma nei fatti, usare questi strumenti su un sistema normale — senza una GPU da 12 GB o un server dedicato — diventa un esercizio di ingegneria, debug e sopportazione.

È per questo che ho deciso di addentrarmi davvero nel mondo del face swapping: non per fare un semplice test da amatoriale, ma per capire cosa è realisticamente ottenibile in condizioni di utilizzo comuni. Senza cloud, senza Docker magici, senza stranezze preconfigurate. Solo un sistema Linux pulito, una CPU normale, e tanta voglia di capire. Il risultato? Un viaggio di un pomeriggio intero tra errori, dipendenze mancanti, modelli che non funzionano e sorprese inaspettate. E, alla fine, un risultato che, se non perfetto, è comunque accettabile. In quest’articolo vi racconto com’è andata davvero, senza filtri né semplificazioni: il resoconto pratico di chi ha provato a usare FaceFusion, uno dei tool più promettenti, direttamente dal fronte.

Cos’è FaceFusion e perché l’ho provato

FaceFusion non è l’unico tool di face swap open source, ma è sicuramente uno di quelli più discussi negli ultimi tempi. Dopo aver sperimentato con iRoop, un altro noto progetto che però mostrava limiti evidenti – specialmente in termini di qualità da vicino e gestione della rotazione della testa – ho cominciato a sentire parlare in continuazione di FaceFusion come di una soluzione più matura, modulare e potente. Non solo permette di sostituire un volto, ma offre un controllo dettagliato sui parametri, supporta diversi modelli di face swapping e addirittura include strumenti per il miglioramento del volto modificato, come face enhancer e expression restorer.

L’idea alla base di FaceFusion è quella di fornire una piattaforma modulare, dove ogni fase del processo — dal rilevamento del volto all’incorporamento nel video finale — può essere configurata e ottimizzata. A differenza di strumenti più semplicistici che si limitano a far girare un modello in background, qui hai il pieno controllo su quale modello usare, come selezionare i volti target, come gestire espressioni e pose. È quasi come essere uno sviluppatore di effetti speciali, con la differenza che lo fai sul tuo laptop di tutti i giorni.

Ma questo livello di controllo ha un costo: complessità. Configurare FaceFusion da zero richiede tempo, conoscenza tecnica e molta pazienza. Non c’è magia né automazione totale. Piuttosto, è un’esperienza che ti porta dentro il motore: puoi ottimizzare ogni singolo frame, cambiare modello in base al tipo di movimento, bilanciare qualità e prestazioni. E nonostante la promessa di superiorità rispetto ad altri strumenti, il risultato non è garantito. Tutto dipende da come lo usi, da quali modelli scegli e da quanto sei disposto a lavorare a mano.

Installazione — primo problema: Python

Il primo ostacolo che ho incontrato con FaceFusion è stato puramente tecnico: la versione di Python. Il progetto richiede esplicitamente Python 3.11, niente di più, niente di meno. E se sul tuo sistema c’è installata la versione 3.10 o 3.12, ti ritrovi subito con un muro di errori. Nel mio caso, stavo con la 3.10 e, provando a eseguire lo script d’installazione, ricevevo un errore legato alla dipendenza scipy==1.17.1, che semplicemente non esiste per Python 3.10 — solo per 3.11 in su. Niente panico, ma il messaggio è chiaro: se vuoi usare FaceFusion, devi essere preciso.

La soluzione, ovvia ma spesso sottovalutata, è installare Python 3.11 separatamente. Su Ubuntu o sistemi Debian-based, questo si fa con un semplice:

sudo apt install python3.11 python3.11-venv python3.11-dev -y

Una volta installato, puoi clonare il repository ufficiale da GitHub e creare un ambiente virtuale dedicato per isolare le dipendenze e non incasinare il tuo sistema. È una pratica fondamentale in qualsiasi progetto Python. Ecco i comandi:

git clone https://github.com/facefusion/facefusion
cd facefusion
python3.11 -m venv .venv
source .venv/bin/activate

A questo punto, sei pronto per procedere all’installazione vera e propria. Ma attenzione: anche qui, c’è un’altra trappola nascosta, detta Conda, che può complicare ulteriormente le cose.

Installazione — secondo problema: conda

Uno degli aspetti che rende FaceFusion potente è anche uno dei suoi punti deboli per gli utenti comuni: la dipendenza da Conda, uno strumento di gestione di ambienti e pacchetti molto usato in ambito scientifico e data science. Il problema? Tanti utenti non lo usano, soprattutto su Linux, preferendo gestire le proprie dipendenze con pip e venv. E quando FaceFusion prova a installare automaticamente Conda, può causare rallentamenti, errori di permessi o conflitti inaspettati.

Fortunatamente, c’è un modo per bypassare questo step: usare l’opzione --skip-conda nel comando di installazione. Questo permette a FaceFusion di procedere con le sue dipendenze usando solo pip, evitando l’installazione di Conda. Il comando corretto diventa:

python install.py --onnxruntime default --skip-conda

Un’ottima notizia per chi, come me, vuole rimanere leggero. Se hai una GPU NVIDIA, anche modesta (tipo con soli 2 GB di VRAM), puoi sostituire default con cuda per sfruttare l’accelerazione hardware. Il modello predefinito viene eseguito con ONNX Runtime, e scegliere la versione CUDA permette di sfruttare la potenza della GPU per rendering più veloci — anche se, con soli 2 GB di VRAM, non aspettarti miracoli. Ma è comunque meglio che affidarsi solo alla CPU.

Primo avvio — la GUI

Dopo aver superato gli scogli dell’installazione, puoi finalmente provare a far girare FaceFusion. Il modo più semplice per testare le funzionalità iniziali è lanciare l’interfaccia grafica, che si attiva con:

python facefusion.py run

Questo comando avvia un server locale e apre automaticamente il browser all’indirizzo http://127.0.0.1:7860. L’interfaccia è pulita, moderna e ben strutturata: puoi caricare facilmente un’immagine sorgente (il volto che vuoi sostituire), un video target (dove far comparire il volto) e selezionare i processori da applicare. Tra questi, face_swapper è automaticamente attivo.

Tutto sembra pronto. Premi invio. Il processo parte. E dopo un po’, ti ritrovi con… un video identico all’originale. Nessuna sostituzione. Nessun cambiamento.

A questo punto, anche i più esperti potrebbero pensare che qualcosa sia rotto. Ma il problema non è il tool: è la configurazione del selettore dei volti. FaceFusion, infatti, di default imposta il Face Selector Mode su reference, il che significa che cerca un volto di riferimento nell’immagine sorgente e confronta ogni volto nel video con quello. Se però non carichi un’immagine di riferimento separata, nessuna corrispondenza avviene. Risultato: silenzio.

La soluzione è molto semplice: cambia Face Selector Mode da reference a many. Così facendo, FaceFusion cerca automaticamente tutti i volti nel video e cerca di sostituirli con l’immagine sorgente, senza necessità di un confronto preciso. Un dettaglio minimo nell’interfaccia, ma decisivo per far funzionare tutto. Una volta impostato correttamente, la sostituzione dei volti inizia a funzionare davvero.

Il vero problema: qualità e rotazione

Ora che il face swap funziona, viene il bello — e il difficile. Il risultato ottenuto con il modello predefinito (inswapper_128) è accettabile, ma solo in certe condizioni. Da lontano, su volti ben illuminati e leggermente frontali, tutto sembra regolare. Ma avvicinando l’immagine, saltano fuori i difetti: bordi visibili, mismatch di tonalità, artefatti intorno al collo o lungo i capelli, texture che non combaciano. E quando la persona nel video gira la testa? È il tracollo totale. Il volto si smembra, si sfuma, esce fuori dal contesto: diventa un effetto da filmato horror a basso budget.

Questi problemi non sono esclusivi di FaceFusion: li ho sperimentati con iRoop e altri strumenti simili. Il motivo sta nei limiti intrinseci dei modelli di face swapping attualmente disponibili. La maggior parte dei modelli è addestrata su volti frontali in condizioni di luce controllate. Quando cambia la posa, l'illuminazione o l’angolo, il modello non sa come generalizzare bene, e così produce risultati approssimativi. È un problema di robustezza.

FaceFusion cerca di affrontare questa sfida con una suite di strumenti più ampia. Ti permette di scegliere diversi modelli, regolare la risoluzione del pixel boost, e soprattutto attivare processori secondari per correggere questi difetti. Ma non basta solo cambiare un parametro: serve un approccio strategico, basato su un’analisi frame per frame dei punti deboli del video target.

Test dei modelli

Dopo aver visto che il modello predefinito non bastava, ho deciso di testare tutti i modelli principali disponibili. Il primo tentativo con hififace_unofficial_256 è stato un fiasco totale: a parte un lieve allargamento del volto, il risultato era perfettamente identico all’input. Il modello sembrava attivo, ma in realtà non faceva assolutamente nulla. Forse richiede input specifici o una configurazione aggiuntiva, ma nella mia prova è risultato inutilizzabile.

Poi ho provato con simswap_unofficial_512. Qui la situazione migliora leggermente: i volti vengono sostituiti, ma i bordi sono ancora evidenti e il colore non si integra bene con il collo. Inoltre, ho notato un errore comune in rete: il nome corretto del modello non è simswap_512, come molte guide erroneamente indicano, ma simswap_unofficial_512. Un dettaglio cruciale, perché con il nome sbagliato lo script non lo riconosce e salta il passo.

Il vero salto qualitativo l’ho ottenuto con ghost_3_256. Questo modello si è rivelato il migliore nella mia configurazione: qualità visiva superiore, bordi più puliti, gestione più coerente delle espressioni. In particolare, gestisce moderatamente bene anche piccole rotazioni della testa, evitando il disastro totale di inswapper. Non è perfetto, ma è il miglior compromesso tra dettaglio e robustezza che ho trovato.

La soluzione per la rotazione: expression_restorer

Un punto di svolta è stato scoprire l’esistenza del processor expression_restorer, un modulo pensato proprio per gestire volti in pose non frontali. Il suo modello più potente è live_portrait, che analizza le pose 3D e applica una deformazione più realistica durante la sostituzione. Attivarlo è semplice: basta aggiungerlo ai processors nella riga di comando.

Ecco un esempio di esecuzione headless con questo processo attivo:

python facefusion.py headless-run \
  --source-paths source.jpg \
  --target-path target.mp4 \
  --output-path output.mp4 \
  --processors face_swapper expression_restorer \
  --face-selector-mode many \
  --face-swapper-model ghost_3_256 \
  --face-swapper-pixel-boost 256x256 \
  --expression-restorer-model live_portrait \
  --expression-restorer-factor 100

Il risultato? Una gestione molto più fluida delle rotazioni. Anche con angolazioni di 30-40 gradi, il volto restituito mantiene un allineamento decente. C’è però un compromesso: la qualità visiva può calare. Il processore expression_restorer tende ad appiattire leggermente i dettagli, e a inserire un po’ di sfocatura. Ma per me, questa riduzione di dettaglio è accettabile se il volto resta dentro il video e non esce dai bordi.

La soluzione definitiva: workflow frame per frame

Per ottenere un risultato professionale, ho capito che serviva un approccio ibrido. Non potevo usare expression_restorer su tutto il video, perché appesantiva e degradava la qualità. Ma non potevo nemmeno fare a meno di lui sui frame chiave. La risposta? Elaborazione frame per frame, con due flussi diversi.

Il primo step è l’estrazione dei frame dal video originale. È fondamentale mantenere audio e cronologia temporale separata:

mkdir frames frames_fixed
ffmpeg -i target.mp4 frames/frame_%04d.png
cp frames/* frames_fixed/

Poi, applichi il face swap con massima qualità solo sui frame “normali” — quelli dove il volto è ben visibile e frontale. Qui usi ghost_3_256 e aggiungi un face enhancer come gfpgan_1.4 per pulire dettagli e pelle:

for f in frames/frame_*.png; do
  name=$(basename $f)
  python facefusion.py headless-run \
    --source-paths source.jpg \
    --target-path $f \
    --output-path frames_fixed/$name \
    --processors face_swapper face_enhancer \
    --face-selector-mode many \
    --face-swapper-model ghost_3_256 \
    --face-swapper-pixel-boost 256x256 \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80
done

Passi poi a intervenire solo sui frame problematici — quelli con testa girata o occlusioni — usando expression_restorer:

for f in frames/frame_0045.png frames/frame_0046.png; do
  name=$(basename $f)
  python facefusion.py headless-run \
    --source-paths source.jpg \
    --target-path $f \
    --output-path frames_fixed/$name \
    --processors face_swapper expression_restorer \
    --face-selector-mode many \
    --face-swapper-model ghost_3_256 \
    --face-swapper-pixel-boost 256x256 \
    --expression-restorer-model live_portrait \
    --expression-restorer-factor 100
done

Se hai frame dove i capelli coprono il volto e nessun modello riesce a fare un buon lavoro, ripristina semplicemente il frame originale:

cp frames/frame_XXXX.png frames_fixed/frame_XXXX.png

Infine, ricomponi il video con FFmpeg, mantenendo l’audio originale:

ffmpeg -framerate 24 -i frames_fixed/frame_%04d.png -c:v libx264 -pix_fmt yuv420p /tmp/output_final.mp4
ffmpeg -i /tmp/output_final.mp4 -i target.mp4 -c copy -map 0:v -map 1:a /tmp/output_final_audio.mp4

Come trovare i frame problematici

Identificare i frame critici è fondamentale in questo workflow. Per farlo, puoi usare ffmpeg per estrarre frame specifici basandoti sul tempo. Esempio: hai un problema a 3,5 secondi in un video a 24 fps? Il frame corrispondente è (3.5 * 24) ≈ 84. Per verificare visivamente, puoi eseguire:

ffmpeg -i target.mp4 -vf "select=eq(n\,83)" -vframes 1 check_frame.png

Questo comando estrae il frame numero 83 e lo salva come immagine. Puoi verificarne i dettagli prima e dopo la modifica. Questo metodo ti permette di intervenire solo dove serve, risparmiando tempo e mantenendo la qualità dove è già buona.

Consigli pratici

La foto sorgente è probabilmente il fattore più importante. Se usi un’immagine di profilo, con capelli che coprono il viso, illuminata male o sfocata, il risultato sarà pessimo, anche con i migliori modelli. La regola d’oro? Scegli una foto frontale, ben illuminata, ad alta risoluzione e con il volto completamente visibile. È la base su cui tutto il sistema si regge.

Un altro consiglio fondamentale: testa sempre prima su pochi frame. Non partire con l’elaborazione di un video da 10 minuti appena inizi. Su CPU, il rendering può richiedere minuti per frame: un video di 10 secondi a 24 fps significa 240 frame, ognuno potenzialmente elaborato in 5-10 secondi. Il totale può superare i 30 minuti. Meglio provare su 5 frame, verificare la qualità, sistemare i parametri e poi andare avanti.

Infine, dimentica la GUI per i lavori seri. Mentre l’interfaccia web è utile per esplorare e fare test rapidi, la modalità headless da riga di comando ti dà il massimo controllo. Vedi gli errori in tempo reale, puoi automatizzare con script shell e personalizzare ogni parametro possibile. È la differenza tra giocare e lavorare davvero.

FaceFusion vs iRoop

Alla fine di questa esperienza, la domanda è: FaceFusion è davvero meglio di iRoop? La risposta è sì, ma con riserva. Non è una rivoluzione, ma un'evoluzione. I problemi fondamentali — gestione della rotazione, artefatti da vicino, robustezza agli angoli non frontali — sono ancora presenti in entrambi gli strumenti. Il salto non è abissale, ma FaceFusion offre strumenti migliori, maggiore modularità e risultati leggermente superiori, soprattutto se sei disposto a lavorare a fondo.

Se cerchi un’esperienza plug-and-play, iRoop è ancora più immediato: si installa in poco tempo, ha meno opzioni e funziona al primo tentativo in molti casi. Ma se vuoi spremere al massimo la qualità e affrontare video complessi con movimenti, allora FaceFusion è la scelta giusta. Richiede più tempo, più conoscenza tecnica e molta pazienza. Ma con un workflow frame per frame, ottimizzato e mirato, puoi ottenere risultati che si avvicinano — forse non raggiungono — al livello professionale.

In sintesi, FaceFusion non è magia. È un’ottima scatola di strumenti per chi sa usarla. E la vera intelligenza artificiale, alla fine, non la trovi nei modelli: la trovi nella testa di chi li sa combinare nel modo giusto.