En introduksjon til Deepfakes med bare én kildevideo

Introduksjon til Deepfakes

Deepfakes er AI-genererte syntetiske videoer av enhver person eller kjendis som etterligner den faktiske personen og får dem til å handle eller si noe de opprinnelig aldri gjorde. Prosessen med å lage deepfakes er teknisk kompleks og krever generelt en enorm mengde data som deretter mates til et nevralt nettverk for å trene og generere den syntetiske videoen.

Effekten av Deepfakes

Deepfakes og AI-avatarer kan ha varierende innvirkning avhengig av hvordan den brukes. Selv om de negative effektene av deepfake kan være skummelt og skremmende å forestille seg, kan det også være nyttig under andre omstendigheter og brukstilfeller.

Fordeler med Deepfakes-

• Deepfakes kan brukes som en form for kunst for å bringe mennesker fra fortiden tilbake til livet. For eksempel kan et maleri av Mona Lisa brukes til å generere et syntetisk bilde av å snakke Mona Lisa som en form for kunst.
• Deepfake-teknologi kan brukes til å lage AI-avatarer i treningsvideoer. Startups som London-baserte Synthesia har fått mer oppmerksomhet fra næringslivet under COVID-pandemien siden nedstengninger og helseproblemer har gjort videoopptak med ekte mennesker mye vanskeligere å gjennomføre.
• Deepfakes kan brukes til å lage personlige avatarer for å prøve klær eller nye frisyrer før du prøver dem på ekte.

Deepfakes kan også brukes i identitetsbeskyttelse og anonymisering på forskjellige felt som undersøkende nyhetsrapportering, finans, etc.

Ulemper med Deepfakes-

• Deepfakes kan brukes til å spre falske nyheter med omformede videoer av kjendiser.
• Deepfakes kan også misbrukes til å lage feilinformasjonskampanjer på sosiale medier som kan endre opinionen og føre til negative konsekvenser.

Opprette Deepfakes

Mens deepfakes kan brukes eller misbrukes på flere måter, blir det enklere å lage dem med flere fremskritt innen AI for hver dag som går.

Vi kan nå lage en deepfake med bare 1 liten kildevideo av personen. Ja, det er nå lett mulig med de siste fremskrittene innen nevrale nettverk. Les for å vite mer!

La oss dele opp løsningen i to deler –

• Stemmekloning
• Video leppesynkronisering

Voice Cloning-delen av Deepfakes

SV2TTS er et rammeverk for dyp læring som kan trenes til å kvantifisere og representere lyd som tall og parametere basert på bare noen få sekunder med lyd av stemmen til en person. Denne numeriske avbildningen av stemmeeksemplet kan brukes til å veilede og trene en tekst-til-tale-modell for å generere ny lyd med nøyaktig samme stemme med alle tekstdata som input. Ved å bruke den ekstraherte lyden fra eksempelkildevideoen kan en stemmeklone enkelt lages med SV2TTS.

Figur: SV2TTS Arbeidsflyt

SV2TTS arbeidsflyt

• Speaker Encoder mottar lyden til målpersonen ekstrahert fra kildevideoen og sender den kodede utgangen med innbygging til synthesizeren.
• Synthesizeren blir trent på mållyd og par med teksttranskripsjoner og syntetiserer inngangen
• Den nevrale vokoderen konverterer spektrogrammene generert av synthesizer-inms

Wav2lip er et leppesynkroniserings-GAN som tar et lydeksempel og et videoeksempel av samme lengde av en person som snakker som input og synkroniserer leppen til personen til inngangslyden. Dermed produserer den en syntetisk video av samme person som snakker inngangslyden i stedet for den faktiske lyden i den originale prøvevideoen.

Figur: Wav2Lip Workflow

Workflow for videoleppesynkronisering

• Generatoren bruker en identitetskoder, talekoder og ansiktsdekoder for å generere rammene til videoen
• Diskriminatoren straffer generatoren for unøyaktigheter i generering under opplæringsprosessen
• Generator-diskriminator-kampen resulterer i den endelige utgangsvideoen med høyest mulig nøyaktighet

Eksempel på syntetisk video

Her er en syntetisk video jeg laget av Barack Obama som snakker med oss! Tekstutskriften som ble brukt til å lage stemmeklonelyden lyder – «Hei folkens, dette er Barack Obama. Som du kan se, er ikke dette en ekte video. Skaperen min, Suvojit, genererte denne syntetiske videoen med Generative Adversarial Networks...."

Dypdykking i trinnene og koden til SV2TTS

La oss ta et dypdykk i trinnene og koden bak SV2TTS og Wav2Lip.

kilde Video

Velg kildevideoen – videoen kan være av hvilken som helst lengde og bør kun ha målkarakteren som snakker i front med så få pauser som mulig. Merk at den endelige syntetiske videoen som genereres vil ha samme størrelse som inngangsvideoen, slik at du kan beskjære videoen etter behov.

Lydutvinning

Trekk ut lyden fra kildevideoen. Denne lyden vil fungere som treningsdata for SV2TTS for å generere stemmeklonen.

Importer biblioteker

For SV2TTS, importer de nødvendige bibliotekene i en notatbok.

# importerer alle nødvendige biblioteker

import OS fra os.path import eksisterer, join, basename, splitext import sys fra IPython.display import display, Audio, clear_output fra IPython.utils import io import ipywidgets som widgets import numpy som np fra dl_colab_notebooks.audio import record_audio, upload_audio fra synthesizer .inference import Synthesizer fra koder import slutning som koder fra vocoder import slutning som vokoder fra pathlib import Path

sys.path.append(navn_på_prosjekt)

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

# klon repo rekursivt og installer avhengigheter

hvis ikke eksisterer (navn_på_proj): # klon og installer !git clone -q --rekursiv {git_repo_url} # installer avhengigheter !cd {name_of_proj}

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

# load pretrained model encoder.load_model(project_name / Path("encoder/saved_models/pretrained.pt")) # create synthesizer object synthesizer = Synthesizer(project_name / Path("synthesizer/saved_models/pretrained/pretrained.pt")) # load modell til vocoder vocoder.load_model(project_name / Path("vocoder/saved_models/pretrained/pretrained.pt"))

Last opp lyd og datainnbygging

Still inn samplingsfrekvensen, koderinnbygginger og muligheten til å laste opp eller ta opp lyden. I dette tilfellet,

# velg passende samplingsfrekvens

SAMPLE_RATE = 22050

# opprette alternativ for å laste opp eller ta opp lyd, skriv inn lydvarighet rec_upl = "Upld (.mp3 eller .wav)" #@param ["Recrd", "Upld (.mp3 or .wav)"] record_seconds = 600#@param { type:"nummer", min:1, maks:10, trinn:1} innebygging = Ingen

# compute embeddings def _compute_embedding(audio): display(Audio(audio, rate=SAMPLE_RATE, autoplay=True)) global embedding embedding = Ingen embedding = encoder.embed_utterance(encoder.preprocess_wav(audio, SAMPLE_RATE))

#funksjon for å ta opp din egen stemme og datainnbygging def _record_audio(b): clear_output() audio = record_audio(record_seconds, sample_rate=SAMPLE_RATE) _compute_embedding(audio)

#funksjon for opplasting av lyd og datainnbygging 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="Record Your Voice") button.on_click(_record_audio) display(button) else: #button = widgets.Button(description="Last opp stemmefil") # button.on_click(_upload_audio) _upload_audio("")

# tekst for stemmeklonen å lese opp i den syntetisk genererte lyden

text = "Hei folkens, dette er Barack Obama. Som dere kan se, er dette ikke en ekte video. Skaperen min, Suvojit genererte denne syntetiske videoen med Generative Adversarial Networks. Lik og del denne videoen, og send melding til Suvojit hvis du vil vite mer detaljer. Hei" #@param {type:"string"} def synthesize(embed, text): print("Synthesizing new audio...") # synthesize the spectrograms specs = synthesizer.synthesize_spectrograms([text],

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

 # generer utgangsbølgeform generert_wav = np.pad(generert_wav, (0, synthesizer.sample_rate), mode="constant") clear_output() display(Audio(generated_wav, rate=synthesizer.sample_rate, autoplay=True))

#last ned: https://github.com/Rudrabha/Wav2Lip#training-on-datasets-other-than-lrs2 !git-klone https://github.com/Rudrabha/Wav2Lip.git

# kopier sjekkpunkter fra Google Drive til øktlagring

!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 requirements.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 fra google.colab importfiler lastet opp = 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" fra google.colab importfiler

# last ned stemmen generert i tidligere trinn til session storage files.download('/content/Wav2Lip/results/result_voice.mp4') fra IPython.display import HTML fra base64 import b64encode

# read binær av lydfilen mp4 = open('/content/Wav2Lip/results/result_voice.mp4','rb').read() data_url = "data:video/mp4;base64," + b64encode(mp4). decode() HTML(f"""

""")

%cd sample_data/ fra google.colab importfiler lastet opp = files.upload() %cd ..

# still inn argumentene for sjekkpunkt- og inngangsfiler og generer leppesynkroniseringsvideoen

!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')

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