Etablissement : EHTP

Département : génie electrique

Réalisé par : BELMAHI IMANE

ESSELLAK HIBA
BOUASBA MAROUANE
Encadré par : Mr.El AROUSSI MOHAMED
%%capture
%pip install ffmpeg-python imageio-ffmpeg pytube pywhisper setuptools-rust
!pip3 install -U scipy
!pip3 install transformers==4.19.0
!git init .
!git remote add origin https://github.com/AliaksandrSiarohin/first-order-
model
!git pull origin master
!git clone https://github.com/graphemecluster/first-order-model-demo demo

%cd /content/

import IPython.display
import PIL.Image
import cv2
import ffmpeg
import json
import imageio
import io
import ipywidgets
import numpy
import os.path
import requests
import pywhisper
import skimage.transform
import warnings
from base64 import b64encode
from demo import load_checkpoints, make_animation # type: ignore (local f
ile)
from google.colab import files, output
from IPython.display import HTML, Javascript
from shutil import copyfileobj
from skimage import img_as_ubyte
from tempfile import NamedTemporaryFile
from tqdm.auto import tqdm
warnings.filterwarnings("ignore")
os.makedirs("user", exist_ok=True)

Cette cellule Jupyter importe un certain nombre de bibliothèques qui sont utilisées dans le code qui suit.
La première ligne, %cd /content/, change le répertoire courant en "/content/".

Les bibliothèques sont:

IPython.display: Permet l'affichage de médias riches dans les notebooks Jupyter

PIL.Image: Une bibliothèque pour ouvrir, manipuler et enregistrer de nombreux formats de fichiers
d'images différents

cv2: OpenCV est une bibliothèque pour les tâches de vision par ordinateur, elle est principalement
utilisée pour le traitement d'images

ffmpeg: est un outil en ligne de commande pour le traitement multimédia, il peut être utilisé ici pour le
traitement vidéo

json: Une bibliothèque pour travailler avec les données JSON

imageio: une bibliothèque qui fournit une interface facile pour lire et écrire une large gamme de formats
de données d'images, vidéos, scientifiques et volumétriques

io : bibliothèque python intégré pour gérer les opérations IO

ipywidgets: Une bibliothèque pour créer des widgets interactifs dans les notebooks Jupyter

numpy: Une bibliothèque pour travailler avec des tableaux et des matrices de données numériques

os.path : bibliothèque python intégré pour utiliser des fonctions pour interagir avec le système de
fichiers

requests: une bibliothèque pour envoyer des requêtes HTTP

pywhisper: est une bibliothèque Python qui fournit un enveloppe autour du modèle OpenAI Whisper. Ce
modèle est un système de reconnaissance vocale développé par OpenAI qui permet de convertir des
phrases orales en phrases écrites

skimage.transform : une bibliothèque pour le traitement d'images, en particulier pour les

transformations d'images telles que le redimensionnement et la rotation

warnings : bibliothèque python intégré pour gérer les avertissements

La dernière ligne de code crée un répertoire appelé "user" s'il n'existe pas déjà.

selected_image = None
def select_image(filename):
global selected_image
selected_image = resize(PIL.Image.open('demo/images/%s.png' % filename
).convert("RGB"))
input_image_widget.clear_output(wait=True)
with input_image_widget:
display(HTML('Image'))
input_image_widget.remove_class('uploaded')
output.register_callback("notebook.select_image", select_image)

selected_video = None
def select_video(filename):
global selected_video
selected_video = 'demo/videos/%s.mp4' % filename
 input_video_widget.clear_output(wait=True)
with input_video_widget:
display(HTML('Video'))
input_video_widget.remove_class('uploaded')
output.register_callback("notebook.select_video", select_video)

def resize(image, size=(256, 256)):

w, h = image.size
d = min(w, h)
r = ((w - d) // 2, (h - d) // 2, (w + d) // 2, (h + d) // 2)
return image.resize(size, resample=PIL.Image.LANCZOS, box=r)

Ce code définit deux fonctions select_image() et select_video() et une autre fonction resize().

La fonction select_image(filename) prend en paramètre le nom de fichier et ouvre le fichier d'image

correspondant qui se trouve dans demo/images/%s.png en utilisant le module Image de la bibliothèque
PIL, où %s sera remplacé par le nom de fichier passé. Ensuite, il convertit l'image au format RGB et la
transmet à la fonction resize(). Cette fonction resize retourne l'image redimensionnée et l'affecte à une
variable globale selected_image. Ensuite, il efface la sortie de input_image_widget et affiche un
message HTML 'Image' à l'aide de la fonction display de la bibliothèque IPython.

La fonction select_video(filename) est similaire à la fonction précédente, mais elle sélectionne la vidéo à
partir de demo/videos/%s.mp4 et l'affecte à une variable globale selected_video. Il efface également la
sortie de input_video_widget et affiche un message HTML 'Video'.

La fonction resize(image, size=(256, 256)) prend en paramètre l'image et la taille, puis trouve la
dimension la plus petite de l'image en prenant la valeur minimale de la largeur et de la hauteur. Ensuite,
il calcule les quatre coordonnées (coin supérieur gauche, coin supérieur droit, coin inférieur droit, coin
inférieur gauche) nécessaires pour centrer l'image en fonction de la petite dimension. Ensuite, l'image
est redimensionnée à la taille passée (256x256) à l'aide de la méthode image.resize() de PIL et du
réchantillonnage LANCZOS. Cette fonction de redimensionnement est utilisée pour l'image d'entrée afin
qu'elle puisse être cohérente avec la taille d'entrée du modèle.

def upload_image(change):
global selected_image
for name, file_info in upload_input_image_button.value.items():
content = file_info['content']
if content is not None:
selected_image = resize(PIL.Image.open(io.BytesIO(content)).conver
t("RGB"))
input_image_widget.clear_output(wait=True)
with input_image_widget:
display(selected_image)
input_image_widget.add_class('uploaded')
display(Javascript('deselectImages()'))
upload_input_image_button.observe(upload_image, names='value')
import subprocess,os
def remove_audio(video_path):
subprocess.run(['ffmpeg','-y','-i', video_path, '-an', '-
c:v', 'copy', '/content/user/output.mp4'])
subprocess.run(['rm',video_path])
os.rename('/content/user/output.mp4', video_path)

def transcirpt(video_path):
model = pywhisper.load_model("base")
result = model.transcribe(video_path)
with open("transcript.json", "w") as f:
json.dump({'video_path':video_path,'text':result['text']}, f)
Ce code définit deux fonctions upload_image() et transcirpt().
La fonction upload_image(change) est déclenchée lorsqu'un fichier est téléchargé via le bouton
upload_input_image_button. La fonction lit le contenu du fichier téléchargé et le convertit en un objet
BytesIO, afin qu'il puisse être ouvert à l'aide du module Image de PIL. Il convertit ensuite l'image au
format RGB et la transmet à la fonction resize(). Cette fonction resize retourne l'image redimensionnée
et l'affecte à une variable globale selected_image. Ensuite, il efface la sortie de input_image_widget et
affiche l'image redimensionnée. Ensuite, il ajoute une classe appelée uploaded à l'objet
input_image_widget et exécute une fonction javascript deselectImages().

La fonction transcirpt(video_path) prend en paramètre le chemin d'accès de la vidéo, elle utilise la

bibliothèque pywhisper pour charger le modèle nommé "base" puis elle utilise la fonction de
transcription sur la vidéo passée en paramètre et elle récupère le texte comme résultat. Ensuite, elle
écrit un fichier JSON nommé transcript.json avec le nom de la vidéo et son texte de transcription.

La fonction remove_audio(video_path) est une fonction d'aide utilisée pour supprimer l'audio de la
vidéo, elle utilise la bibliothèque ffmpeg en python qui est exécutée avec différentes commandes pour
supprimer l'audio de la vidéo et enregistre la vidéo de sortie dans /content/user/output.mp4. Ensuite, il
supprime la vidéo originale et renomme le fichier output.mp4 en utilisant la commande os.rename pour
qu'il ait le même nom que la vidéo originale. Ainsi, cette fonction permet de supprimer l'audio d'une
vidéo en utilisant ffmpeg et en enregistrant la vidéo sans audio à la place de l'original.

main.layout.display = 'none'
loading.layout.display = ''
filename = model.value + ('' if model.value == 'fashion' else '-
cpk') + '.pth.tar'
if not os.path.isfile(filename):
response = requests.get('https://github.com/graphemecluster/first-
order-model-demo/releases/download/checkpoints/' + filename, stream=True)
with progress_bar:
 with tqdm.wrapattr(response.raw, 'read', total=int(response.he
aders.get('Content-
Length', 0)), unit='B', unit_scale=True, unit_divisor=1024) as raw:
with open(filename, 'wb') as file:
copyfileobj(raw, file)
progress_bar.clear_output()
reader = imageio.get_reader(selected_video, mode='I', format='FFMPEG')
fps = reader.get_meta_data()['fps']
driving_video = []
for frame in reader:
driving_video.append(frame)
generator, kp_detector = load_checkpoints(config_path='config/%s-
256.yaml' % model.value, checkpoint_path=filename)
with progress_bar:
predictions = make_animation(
skimage.transform.resize(numpy.asarray(selected_image), (256,
256)),
[skimage.transform.resize(frame, (256, 256)) for frame in driv
ing_video],
generator,
kp_detector,
relative=relative.value,
adapt_movement_scale=adapt_movement_scale.value
)
progress_bar.clear_output()

Ce code est responsable de charger et d'utiliser un modèle d'apprentissage automatique pré-entraîné et

de générer une animation basée sur une image sélectionnée et une vidéo.

Ce code commence par cacher le layout principal (main.layout.display = 'none') et afficher le layout de
chargement (loading.layout.display = ''). Il construit ensuite le nom du fichier de point de contrôle du
modèle, qui sera au format model.value + ('' if model.value == 'fashion' else '-cpk') + '.pth.tar'.

Ensuite, il vérifie si le fichier de point de contrôle existe sur la machine locale en utilisant
os.path.isfile(filename). S'il n'existe pas, il télécharge le fichier de point de contrôle à partir d'un dépôt
Github en utilisant la bibliothèque python request et le stocke sur la machine locale.

Une fois le fichier de point de contrôle chargé, il lit la vidéo sélectionnée en utilisant la bibliothèque
imageio, puis il charge les modèles generator et kp_detector à l'aide de la fonction load_checkpoints()
en passant le chemin du fichier de config et du fichier de point de contrôle.

Ensuite, il démarre le processus de génération d'animation à l'aide de la fonction make_animation en

passant l'image sélectionnée, les images de la vidéo, les modèles generator, kp_detector et d'autres
paramètres.
Une fois l'animation générée, il efface la sortie de la barre de progression pour signaler que le processus
est terminé.

imageio.mimsave('output.mp4', [img_as_ubyte(frame) for frame in predic

tions], fps=fps)
if selected_video.startswith('user/') or selected_video == 'demo/video
s/0.mp4':
with NamedTemporaryFile(suffix='.mp4') as output:
ffmpeg.output(ffmpeg.input('output.mp4').video, ffmpeg.input(s
elected_video).audio, output.name, c='copy').overwrite_output().run()
with open('output.mp4', 'wb') as result:
copyfileobj(output, result)
with output_widget:
video_widget = ipywidgets.Video.from_file('output.mp4', autoplay=F
alse, loop=False)
video_widget.add_class('video')
video_widget.add_class('video-left')
display(video_widget)
with comparison_widget:
video_widget = ipywidgets.Video.from_file(selected_video, autoplay
=False, loop=False, controls=False)
video_widget.add_class('video')
video_widget.add_class('video-right')
display(video_widget)

Ce code utilise la bibliothèque Imageio pour enregistrer les images générées par le code précédent sous
forme de fichier mp4. Il enregistre le fichier sous le nom "output.mp4" avec le même fps de la vidéo
d'entrée.

Ensuite, il vérifie si la vidéo d'origine est une vidéo téléchargée par l'utilisateur ou une vidéo par défaut
fournie par la démo. Si c'est une vidéo téléchargée par l'utilisateur ou la vidéo par défaut, il crée un
fichier temporaire et utilise ffmpeg pour combiner l'audio de la vidéo d'origine avec la nouvelle vidéo
générée. Ce pas est pour s'assurer que la vidéo de sortie a le même audio que la vidéo d'origine.

Ensuite, il crée un widget vidéo pour la vidéo générée et l'affiche dans le widget de sortie. Il crée
également un widget vidéo pour la vidéo d'origine et l'affiche dans le widget de comparaison. Les vidéos
sont affichées côte à côte avec la vidéo d'origine à droite et la vidéo générée à gauche.

!git clone https://github.com/jnordberg/tortoise-tts.git

%cd tortoise-tts
!pip3 install -r requirements.txt
!python3 setup.py install
Les instructions ci-dessus sont utilisées pour installer un paquet appelé Tortoise TTS, qui est une
bibliothèque de synthèse vocale (TTS) pour Python. Le paquet est basé sur la bibliothèque
OpenSeq2Seq.

La première ligne utilise l'interface en ligne de commande pour télécharger le paquet à partir du dépôt
Github à l'aide de la commande git clone.

La deuxième ligne utilise l'interface en ligne de commande pour changer le répertoire de travail courant
vers le dossier du paquet téléchargé récemment "tortoise-tts"

La troisième ligne utilise le gestionnaire de paquets pip3 pour installer les dépendances du paquet
listées dans le fichier "requirements.txt".

La quatrième ligne exécute le fichier setup.py pour finir le processus d'installation et rendre le paquet
prêt à l'emploi.

Avec ce paquet, vous pourrez créer la parole à partir du texte dans différentes langues, avec plusieurs
voix, accents et vitesse différentes.

# Imports used through the rest of the notebook.

import torch
import torchaudio
import torch.nn as nn
import torch.nn.functional as F

import IPython

from tortoise.api import TextToSpeech

from tortoise.utils.audio import load_audio, load_voice, load_voices

# This will download all the models used by Tortoise from the HuggingFace
hub.
tts = TextToSpeech()

Ce code importe quelques paquets nécessaires pour le fonctionnement de la bibliothèque Tortoise TTS,
y compris Torch et Torchaudio, qui sont utilisés pour les opérations basées sur Pytorch, ainsi que
torch.nn, torch.nn.functional, IPython et la classe TextToSpeech de Tortoise.

Les trois premières lignes importent torch, torchaudio et leurs sous-modules respectifs nn et functional.

Puis, il y a l'import de IPython et la classe TextToSpeech depuis le paquet tortoise

La ligne suivante crée une instance de la classe TextToSpeech. Cette ligne téléchargera tous les modèles
utilisés par Tortoise TTS depuis le hub Hugging Face. Ce processus peut prendre un certain temps, en
fonction de la vitesse de votre connexion internet et du nombre de modèles que vous souhaitez
télécharger.

En utilisant cette classe, vous pouvez générer la parole à partir du texte en spécifiant la langue et la voix.
with open('/content/transcript.json','r') as f:
text=json.load(f)['text']
# Optionally, upload use your own voice by running the next two cells. I r
ecommend
# you upload at least 2 audio clips. They must be a WAV file, 6-
10 seconds long.
CUSTOM_VOICE_NAME = "custom"
import os
from google.colab import files

custom_voice_folder = f"tortoise/voices/{CUSTOM_VOICE_NAME}"
os.makedirs(custom_voice_folder)
for i, file_data in enumerate(files.upload().values()):
with open(os.path.join(custom_voice_folder, f'{i}.wav'), 'wb') as f:
f.write(file_data)

Ce code est utilisé pour générer la parole à partir du texte qui a été transcrit lors de l'étape précédente.

Il commence par ouvrir un fichier "transcript.json" et en lisant le texte transcrit et en stockant dans une
variable "text".

Il crée ensuite une variable CUSTOM_VOICE_NAME qui est une chaîne contenant le nom de la voix
personnalisée que vous souhaitez utiliser.

Il importe la bibliothèque os et l'utilise pour créer un répertoire nommé custom_voice_folder à l'aide du

nom de la voix personnalisée.

Il utilise ensuite la fonction google.colab.files.upload() pour télécharger les fichiers audio de la voix
personnalisée. Et il enregistre les fichiers audio dans le répertoire créé un par un.

La voix personnalisée peut être utilisée pour générer la parole à partir du texte .

Il utilisera la voix que vous avez téléchargée à la place de la voix par défaut fournie par la bibliothèque.

from pytube import YouTube

from IPython.display import Audio, Image, Video
###### choose an url for a youtube video that contains the person in the s
elected image
yt2 = YouTube('https://www.youtube.com/watch?v=80vhQ1fypOU')
audio_stream = yt2.streams.get_by_itag(139)
audio_path=audio_stream.download()
start_time="00:29" # find the start of video where the person is talking w
ithout interruption
ss=int(start_time.split(':')[0]) * 60 + int(start_time.split(':')[1])
t=10 # 10s of content starting from start_time (in this case 07:12)
# Open the input file using ffmpeg
input_audio = ffmpeg.input(audio_path)
# Use ffmpeg to convert the input file to a WAV file
output_audio = ffmpeg.output(input_audio, '/content/user/desired_voice1.wa
v',ss=ss,t=t,ar=22050) # the model of voice synthesis is trained on audios
with a sample rate of 22050 Hz

# Run the conversion

ffmpeg.run(output_audio)
Audio('/content/user/desired_voice1.wav')

Ce code utilise la bibliothèque Pytube pour télécharger une vidéo à partir de YouTube à l'aide de son url.
Et il utilise la bibliothèque ffmpeg pour extraire un segment de l'audio de la vidéo téléchargée, en
fonction du temps de début et de la durée du segment donné.

La première ligne importe la classe YouTube de la bibliothèque Pytube, qui permet d'interagir avec l'API
YouTube et de télécharger des vidéos à partir de celle-ci.

La deuxième ligne importe la bibliothèque IPython.display, qui possède des classes pour afficher
différents types de médias (audio, image et vidéo) dans le notebook Jupyter.

Ensuite, le code spécifie l'url de la vidéo YouTube qui contient la personne dont vous voulez extraire la
parole.

La ligne suivante récupère le flux audio de la vidéo avec itag=139, qui est le flux audio par défaut pour la
vidéo

Le code télécharge ensuite la vidéo dans une variable 'audio_path' et la variable start_time contient le
début de la vidéo où la personne commence à parler

La variable ss contient le temps de début en secondes

Ensuite, il spécifie la durée de l'audio que vous voulez extraire et le stocke dans la variable t

Il utilise la bibliothèque ffmpeg pour ouvrir le fichier audio d'entrée, qui est la vidéo téléchargée, puis il
convertit l'audio d'entrée en un fichier WAV en utilisant la fonction de sortie ffmpeg.

Il spécifie le taux d'échantillonnage de 22050 Hz qui est le même que le taux d'échantillonnage sur
lequel le modèle de synthé de la voix a été entraîné.

La dernière ligne utilise IPython.display.Audio pour lire l'audio extrait dans le notebook.

En gros, ce code télécharge une vidéo à partir d'une url donnée, utilise ffmpeg pour extraire un segment
de l'audio de la vidéo à partir d'un certain temps de début et de durée donnés, et utilise
IPython.display.Audio pour lire l'audio extrait dans le notebook.

!mkdir /content/tortoise-tts/tortoise/voices/custom
!cp /content/user/desired_voice1.wav /content/tortoise-
tts/tortoise/voices/custom/1.wav
Les deux premières lignes de code créent un nouveau dossier "custom" dans le répertoire
"/content/tortoise-tts/tortoise/voices/"

La dernière ligne de code copie le fichier audio extrait, "desired_voice1.wav" dans le nouveau dossier
"custom" créé précédemment.

En somme, ce code crée un nouveau répertoire dans lequel on va stocker les voix personnalisées et y
copie le fichier audio extrait pour utiliser comme une voix personnalisée pour synthèse de la parole par
la suite.

# Generate speech with the custotm voice.

# Pick a "preset mode" to determine quality. Options: {"ultra_fast", "fast
" (default), "standard", "high_quality"}. See docs in api.py
preset = "fast"
CUSTOM_VOICE_NAME = "custom"
voice_samples, conditioning_latents = load_voice(CUSTOM_VOICE_NAME)
gen = tts.tts_with_preset(text, voice_samples=voice_samples, conditioning_
latents=conditioning_latents,
preset=preset)
torchaudio.save(f'generated-
{CUSTOM_VOICE_NAME}.wav', gen.squeeze(0).cpu(), 24000)
IPython.display.Audio(f'generated-{CUSTOM_VOICE_NAME}.wav')

Ce code utilise la librairie "tortoise-tts" pour générer une synthèse de la parole à partir d'un texte et
d'un échantillon de voix personnalisé.

La première ligne définit une variable "preset" qui peut être utilisée pour choisir un préréglage pour la
génération de la synthèse de la parole.

La deuxième ligne définit un nom de voix personnalisée "CUSTOM_VOICE_NAME" qui est utilisée pour
charger des échantillons de voix et des conditionnements latents à partir du fichier wav copié dans le
répertoire précédemment.

La ligne suivante utilise la fonction tts_with_preset() de l'objet tts pour générer la synthèse de la parole
en utilisant les échantillons de voix et les conditionnements latents chargés précédemment ainsi que le
préréglage choisi.

La ligne suivante utilise torchaudio.save() pour enregistrer la synthèse de la parole générée dans un
fichier wav avec un taux d'échantillonnage de 24000 Hz.

La dernière ligne utilise IPython.display.Audio pour lire le fichier wav généré dans le notebook.

En gros, ce code utilise des échantillons de voix et des conditionnements latents personnalisés pour
générer une synthèse de la parole à partir d'un texte donné en utilisant la librairie "tortoise-tts" et
enregistre la synthèse de la parole dans un fichier wav pour être joué dans le notebook.

!mkdir /content/deepfake
!ffmpeg -i "/content/output.mp4" -i "/content/tortoise-tts/generated-
custom.wav" -shortest /content/deepfake/deepfake.mp4

Cette commande utilise FFmpeg pour combiner deux fichiers vidéos en un seul, il prend en entrée le
fichier vidéo "output.mp4" et le fichier audio "generated-custom.wav" et utilise l'option -shortest pour
que la durée de la sortie soit celle du fichier le plus court, avec cette option , il va automatiquement
couper le fichier plus long pour qu'il ait la même durée que le plus court. Il enregistre ensuite la sortie
dans un fichier vidéo mp4 avec le nom deepfake.mp4 dans le dossier "/content/deepfake"

Cette ligne de commande permet de créer un deepfake video qui remplace la voix d'une personne dans
la vidéo originale avec la voix générée précédemment.