Eine Einführung in Deepfakes mit nur einem Quellvideo

Einführung in Deepfakes

Deepfakes sind KI-generierte synthetische Videos einer Person oder Berühmtheit, die sich als die tatsächliche Person ausgeben und sie dazu bringen, etwas zu tun oder zu sagen, was sie ursprünglich nie getan haben. Der Prozess der Erstellung von Deepfakes ist technisch komplex und erfordert im Allgemeinen eine große Datenmenge, die dann einem neuronalen Netzwerk zugeführt wird, um das synthetische Video zu trainieren und zu generieren.

Auswirkungen von Deepfakes

Deepfakes und KI-Avatare können je nach Verwendungszweck unterschiedliche Auswirkungen haben. Während die negativen Auswirkungen von Deepfake beängstigend und beängstigend sein können, kann es auch unter anderen Umständen und Anwendungsfällen nützlich sein.

Vorteile von Deepfakes:

• Deepfakes können als Kunstform eingesetzt werden, um Menschen aus der Vergangenheit wieder zum Leben zu erwecken. Beispielsweise kann ein Gemälde der Mona Lisa verwendet werden, um ein synthetisches Bild der sprechenden Mona Lisa als Kunstform zu erzeugen.
• Mithilfe der Deepfake-Technologie können KI-Avatare in Schulungsvideos erstellt werden. Start-ups wie das in London ansässige Unternehmen Synthesia haben während der COVID-Pandemie mehr Aufmerksamkeit in der Unternehmenswelt erhalten, da Lockdowns und Gesundheitsbedenken die Durchführung von Videodrehs mit echten Menschen erheblich erschwert haben.
• Mithilfe von Deepfakes können persönliche Avatare erstellt werden, mit denen man Kleidung oder neue Frisuren anprobieren kann, bevor man sie in der Realität ausprobiert.

Deepfakes können auch zum Identitätsschutz und zur Anonymisierung in verschiedenen Bereichen wie investigativer Berichterstattung, Finanzen usw. eingesetzt werden.

Nachteile von Deepfakes-

• Deepfakes können genutzt werden, um Fake News mit manipulierten Videos von Prominenten zu verbreiten.
• Deepfakes können auch dazu missbraucht werden, Fehlinformationskampagnen in sozialen Medien zu erstellen, die die öffentliche Meinung verändern und negative Konsequenzen haben können.

Deepfakes erstellen

Während Deepfakes auf vielfältige Weise verwendet oder missbraucht werden können, wird ihre Erstellung mit jedem Tag, der vergeht, mit den Fortschritten in der KI einfacher.

Wir können jetzt ein Deepfake mit nur einem kleinen Quellvideo der Person erstellen. Ja, das ist mit den neuesten Fortschritten bei neuronalen Netzen jetzt problemlos möglich. Lesen Sie, um mehr zu erfahren!

Teilen wir die Lösung in zwei Teile auf:

• Klonen von Stimmen
• Video-Lippensynchronisation

Voice Cloning ist Teil von Deepfakes

SV2TTS ist ein Framework für Deep Learning, das darauf trainiert werden kann, Audiodaten in Form von Zahlen und Parametern zu quantifizieren und darzustellen, basierend auf nur wenigen Sekunden Audiodaten der Stimme einer Person. Diese numerische Darstellung des Sprachbeispiels kann verwendet werden, um ein Text-zu-Sprache-Modell anzuleiten und zu trainieren, um mit beliebigen Textdaten als Eingabe neue Audiodaten mit genau derselben Stimme zu generieren. Daher kann mithilfe des extrahierten Audios aus dem Beispielquellvideo ganz einfach ein Sprachklon mit SV2TTS erstellt werden.

Abbildung: SV2TTS-Workflow

SV2TTS-Workflow

• Der Speaker Encoder empfängt das aus dem Quellvideo extrahierte Audio der Zielperson und übergibt die codierte Ausgabe mit Einbettungen an den Synthesizer.
• Der Synthesizer wird auf Zielaudio und Texttranskriptpaare trainiert und synthetisiert die Eingabe
• Der neuronale Vocoder wandelt die vom Synthesizer erzeugten Spektrogramme um

Wav2lip ist ein lippensynchronisierendes GAN, das ein Audiobeispiel und ein Videobeispiel gleicher Länge einer sprechenden Person als Eingabe verwendet und die Lippe der Person mit dem Eingangsaudio synchronisiert. Dadurch wird ein synthetisches Video der gleichen Person erzeugt, die den eingegebenen Ton spricht, anstelle des tatsächlichen Tons im ursprünglichen Beispielvideo.

Abbildung: Wav2Lip-Workflow

Video-Lippensynchronisierungs-Workflow

• Der Generator verwendet einen Identitäts-Encoder, einen Sprach-Encoder und einen Gesichts-Decoder, um die Frames des Videos zu generieren
• Der Diskriminator bestraft den Generator für Ungenauigkeiten bei der Erzeugung während des Trainingsprozesses
• Das Gerangel zwischen Generator und Diskriminator führt zu einem endgültigen Ausgabevideo mit der höchstmöglichen Genauigkeit

Beispiel für ein synthetisches Video

Hier ist ein synthetisches Video, das ich erstellt habe, in dem Barack Obama mit uns spricht! Das Texttranskript, das zur Erstellung des Voice-Clone-Audios verwendet wurde, lautet: „Hey Leute, das ist Barack Obama. Wie Sie sehen, handelt es sich hierbei nicht um ein echtes Video. Mein Schöpfer Suvojit hat dieses synthetische Video mit Generative Adversarial Networks erstellt…“

Tauchen Sie tief in die Schritte und den Code von SV2TTS ein

Lassen Sie uns einen tiefen Einblick in die Schritte und den Code hinter SV2TTS und Wav2Lip werfen.

Quelle Video

Wählen Sie das Quellvideo – das Video kann beliebig lang sein und sollte im Vordergrund nur den Zielcharakter mit möglichst wenigen Pausen enthalten. Beachten Sie, dass das endgültig generierte synthetische Video dieselbe Größe wie das Eingabevideo hat, sodass Sie das Video je nach Bedarf zuschneiden können.

Audioextraktion

Extrahieren Sie den Ton aus dem Quellvideo. Dieses Audio dient SV2TTS als Trainingsdaten zur Generierung des Sprachklons.

Bibliotheken importieren

Importieren Sie für SV2TTS die erforderlichen Bibliotheken in ein Notebook.

# Importieren aller notwendigen Bibliotheken

Betriebssystem importieren
aus os.path import existiert, Join, Basisname, Splitext
Importsystem
aus IPython.display import display, Audio, clear_output
aus IPython.utils import io
ipywidgets als Widgets importieren
numpy als np importieren
aus dl_colab_notebooks.audio import record_audio, upload_audio
aus synthesizer.inference Synthesizer importieren
aus der Encoder-Importinferenz als Encoder
aus der Vocoder-Importinferenz als Vocoder
aus pathlib import Path

sys.path.append(name_of_proj)

#URL von svt2tts
git_repo_url = 'https://github.com/CorentinJ/Real-Time-Voice-Cloning.git'
name_of_proj = splitext(basename(git_repo_url))[0]

# Repo rekursiv klonen und Abhängigkeiten installieren

falls nicht vorhanden (name_of_proj): # klonen und installieren !git clone -q --recursive {git_repo_url} # Abhängigkeiten installieren !cd {name_of_proj}

 !pip install -q -r Anforderungen.txt !pip install -q gdown !apt-get install -qq libportaudio2 !pip install -q https://github.com/tugstugi/dl-colab-notebooks/archive/colab_utils.zip

# vorab trainiertes Modell laden Encoder.load_model(project_name / Path("encoder/saved_models/pretrained.pt")) # Synthesizer-Objekt erstellen synthesizer = Synthesizer(project_name / Path("synthesizer/saved_models/pretrained/pretrained.pt")) # laden Modell zum Vocoder vocoder.load_model(Projektname / Pfad("vocoder/saved_models/pretrained/pretrained.pt"))

Laden Sie Audio- und Compute-Einbettungen hoch

Legen Sie die Abtastrate, die Encoder-Einbettungen und die Option zum Hochladen oder Aufzeichnen des Audios fest. In diesem Fall,

# Wählen Sie die entsprechende Abtastrate

SAMPLE_RATE = 22050

# Option zum Hochladen oder Aufzeichnen von Audio erstellen, Audiodauer eingeben
rec_upl = "Upld (.mp3 oder .wav)" #@param ["Recrd", "Upld (.mp3 oder .wav)"]
record_seconds = 600#@param {type:"number", min:1, max:10, step:1}
Einbettung = Keine

# Einbettungen berechnen
def _compute_embedding(audio): display(Audio(audio, rate=SAMPLE_RATE, autoplay=True)) globale Einbettung Einbettung = Keine Einbettung = Encoder.embed_utterance(encoder.preprocess_wav(audio, SAMPLE_RATE))

#Funktion zum Aufzeichnen Ihrer eigenen Stimme und Berechnen von Einbettungen
def _record_audio(b): clear_output() audio = record_audio(record_seconds, sample_rate=SAMPLE_RATE) _compute_embedding(audio)

#Funktion zum Hochladen von Audio und Berechnen von Einbettungen
def _upload_audio(b): clear_output() audio = upload_audio(sample_rate=SAMPLE_RATE) _compute_embedding(audio)

if record_or_upload == "Record": button = widgets.Button(description="Nehmen Sie Ihre Stimme auf") button.on_click(_record_audio) display(button)
sonst: #button = widgets.Button(description="Sprachdatei hochladen") #button.on_click(_upload_audio) _upload_audio("")

# Text für den Sprachklon zum Vorlesen im synthetisch generierten Audio

text = „Hey Leute, das ist Barack Obama. Wie Sie sehen können, ist dies kein echtes Video. Mein Schöpfer Suvojit hat dieses synthetische Video mit Generative Adversarial Networks erstellt. Liken und teilen Sie dieses Video und senden Sie eine Nachricht an Suvojit, wenn Sie mehr wissen möchten Details. Tschüss" #@param {type:"string"}
def synthesize(embed, text): print("Synthesizing new audio...") # synthetisieren Sie die Spektrogramme specs = synthesizer.synthesize_spectrograms([text],

) generic_wav = vocoder.infer_waveform(specs[0])

 # Ausgabewellenform generieren generic_wav = np.pad(generated_wav, (0, synthesizer.sample_rate), mode="constant") clear_output() display(Audio(generated_wav, rate=synthesizer.sample_rate, autoplay=True))

#Download:  https://github.com/Rudrabha/Wav2Lip#training-on-datasets-other-than-lrs2
!git-Klon https://github.com/Rudrabha/Wav2Lip.git

# Prüfpunkte von Google Drive in den Sitzungsspeicher kopieren

!cp -ri "/content/gdrive/MyDrive/Files/Wav2lip/wav2lip_gan.pth" /content/Wav2Lip/checkpoints/
!cp -ri "/content/gdrive/MyDrive/Files/Wav2lip/wav2lip.pth" /content/Wav2Lip/checkpoints/
!cd Wav2Lip && pip install -r Anforderungen.txt
!wget "https://www.adrianbulat.com/downloads/python-fan/s3fd-619a316812.pth" -O "Wav2Lip/face_detection/detection/sfd/s3fd.pth"

%cd sample_data/
%rm input_audio.wav
%rm input_video.mp4
aus google.colab-Importdateien
hochgeladen = files.upload()
%CD ..

!cd Wav2Lip && python inference.py --checkpoint_path checkpoints/wav2lip_gan.pth --face "/content/sample_data/input_video.mp4" --audio "/content/sample_data/input_audio.wav"
aus google.colab-Importdateien

# Laden Sie die in den vorherigen Schritten generierte Stimme in den Sitzungsspeicher herunter
files.download('/content/Wav2Lip/results/result_voice.mp4') von IPython.display HTML importieren
aus Base64 b64encode importieren

# Binärdatei der Audiodatei lesen
mp4 = open('/content/Wav2Lip/results/result_voice.mp4','rb').read()
data_url = "data:video/mp4;base64," + b64encode(mp4).decode()
HTML(f"""

„““)

%cd sample_data/
aus google.colab-Importdateien
hochgeladen = files.upload()
%CD ..

# Legen Sie die Argumente für Prüfpunkt und Eingabedateien fest und generieren Sie das Lippensynchronisationsvideo

!cd Wav2Lip && python inference.py --checkpoint_path checkpoints/wav2lip_gan.pth --face "/content/sample_data/input_video.mp4" --audio "/content/sample_data/input_audio.wav"

files.download('/content/Wav2Lip/results/result_voice.mp4')

Quelle: https://www.analyticsvidhya.com/blog/2021/10/an-introduction-to-deepfakes-with-only-one-source-video/