DEV Community: Edinson Mauricio Mendoza

Clasificador de imágenes con una red neuronal convolucional (CNN)

Edinson Mauricio Mendoza — Thu, 02 May 2024 02:37:00 +0000

Hola amigos, hoy les traigo este tutorial de como podemos crear un clasificador de imágenes implementado una red neural convolucional conocida como CNN del inglés Convolutional Neural Network.

Una red neuronal convolucional es un tipo de red neuronal artificial diseñada específicamente para procesar datos con estructura de cuadrícula, como imágenes. Utiliza capas de convolución para detectar patrones y características en los datos de entrada, seguidas de capas de agrupación que reducen la dimensionalidad. Las CNN son ampliamente utilizadas en tareas de visión por computadora, como reconocimiento de imágenes y clasificación, debido a su capacidad para aprender características jerárquicas y invariantes a la traslación.

Para lograr esto usaremos como lenguaje principal Python, y otras librerías como:

La implementación completa la puedes encontrar en mi cuenta de GitHub en el siguiente repositorio:

https://github.com/emmendoza2794/basic-image-classifier

Este proyecto se encuentra dividido en 3 partes:

La interfaz gráfica realizada con Streamlit
El predictor de imágenes a partir de un modelo ya entrenado
El entrenador de un nuevo modelo a partir de nuevas imágenes

1. Interfaz gráfica

Para este proyecto tenemos 2 secciones, una en donde probamos nuestros modelos ya entrenados y otra en donde entrenamos un nuevo modelo.

Interfaz de prueba de modelos:

Interfaz de entrenamiento de nuevo modelo:

Nuestro código en Python seria este:

import streamlit as st  

from src.predictor import Predictor  
from src.train import Train  
from src.utils import Utils  

if 'prediction_result' not in st.session_state:  
    st.session_state.prediction_result = None  

if 'classes_list' not in st.session_state:  
    st.session_state.classes_list = None  

if 'train_result' not in st.session_state:  
    st.session_state.train_result = None  


def predict_image():  
    if st.session_state.image_file is None:  
        st.error("No image file")  
        return  

  st.session_state.prediction_result = Predictor().predict(  
        name_model=st.session_state.model,  
        image=st.session_state.image_file  
    )  


def get_classes():  
    if st.session_state.classes_list is not None:  
        classes = Predictor().load_classes(  
            name_model=st.session_state.model  
        )  

        st.session_state.classes_list = ', '.join(classes)  

    else:  
        st.session_state.classes_list = "There are no models to test, download the test models"  

def train_model():  

    st.session_state.train_result = Train().train_model(  
        epochs=st.session_state.epochs,  
        model_name=st.session_state.model_name  
    )  


st.set_page_config(  
    page_title="Basic Image Classifier",  
    page_icon="👋",  
    layout="wide",  
)  

st.header('Test model', divider='rainbow')  

col1, col2, col3 = st.columns([0.3, 0.5, 0.2])  

with col1:  
    with st.container(border=True):  
        st.subheader("Image Classifier")  

        st.selectbox(  
            label='Select model',  
            key="model",  
            options=Predictor().load_list_models()  
        )  

        get_classes()  

        st.markdown(f'**Classes:** {st.session_state.classes_list}')  

        st.file_uploader(  
            label="image file",  
            key="image_file",  
            type=['jpg', 'jpeg', 'png', 'bmp', 'gif', 'webp']  
        )  

        st.button(  
            label="Predict category",  
            type="primary",  
            on_click=predict_image,  
            use_container_width=True,  
        )  

    with st.container(border=True):  
        st.write("download example models for testing")  
        st.button(  
            label="Download models",  
            type="primary",  
            on_click=Utils().download_models,  
            use_container_width=True,  
        )  

with col2:  
    with st.container(border=True, height=600):  
        st.subheader("Image preview")  

        if st.session_state.image_file is not None:  
            st.image(  
                image=st.session_state.image_file  
            )  

with col3:  
    with st.container(border=True, height=600):  
        st.subheader("Prediction result")  

        if st.session_state.prediction_result is not None:  

            data_result = st.session_state.prediction_result  
            first_result = next(iter(data_result.items()))  

            st.subheader(f":green[{first_result[0]} {round(first_result[1], 2)}%]")  
            st.write(data_result)  


st.header('Train model', divider='rainbow')  


col4, col5 = st.columns([0.3, 0.7])  

with col4:  
    with st.container(border=True):  
        st.subheader("Configuration")  

        st.markdown('''  
 :red[**Important:** to train the model with your own data or another dataset, first copy the images separated by        folders into the root folder "image_files". For example:]   
        ''')  

        st.image("assets/image_files.png")  

        st.text_input(  
            label="Model name",  
            value="model_test",  
            key="model_name"  
  )  

        st.slider(  
            label="Epochs",  
            min_value=10,  
            max_value=100,  
            value=40,  
            key="epochs",  
            step=1  
  )  

        st.markdown("*At least 40 epochs are recommended to have an accuracy > 80%*")  

        st.button(  
            label="Train model",  
            type="primary",  
            on_click=train_model,  
            use_container_width=True,  
        )  


with col5:  
    with st.container(border=True, height=600):  
        st.subheader("Training result")  

        if st.session_state.train_result is not None:  
            st.write(st.session_state.train_result)

2. Predictor de imágenes a partir de un modelo entrenado

En esta parte usamos Pytorch para cargar el modelo y transformar la imagen a predecir de tal manera que nuestro modelo pueda usarla.

Para esto primero debemos cargar un modelo ya entrenado, en la interfaz tenemos un botón para descargar estos modelos de prueba, estos modelos se descargan en la carpeta raíz “models”, por cada modelo abran 2 archivos, uno con las clases posibles que el modelo puede predecir que será un archivo .json y otro con el formato .pth que es un archivo que contiene los parámetros entrenados del modelo.

La clase principal en donde definimos nuestro modelo es la siguiente:

from torch import nn  
import torch.nn.functional as F  


class Net(nn.Module):  
    def __init__(self, num_classes: int):  
        super().__init__()  
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)  
        self.pool = nn.MaxPool2d(2, 2)  
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)  
        self.dropout = nn.Dropout(0.5)  
        self.fc1 = nn.Linear(64 * 64 * 64, 128)  
        self.fc2 = nn.Linear(128, num_classes)  

    def forward(self, x):  
        x = self.pool(F.relu(self.conv1(x)))  
        x = self.pool(F.relu(self.conv2(x)))  
        x = x.view(-1, 64 * 64 * 64)  
        x = F.relu(self.fc1(x))  
        x = self.dropout(x)  
        x = self.fc2(x)  
        return F.log_softmax(x, dim=1)

Esta clase es la misma que usamos para entrenar como para hacer las predicciones, es como la estructura que sigue nuestro modelo cuando entrena y cuando va a realizar una predicción.

Ahora bien, para realizar la predicción tenemos que instanciar nuestro modelo y cargarle el archivo .pth con los parámetros del modelo entrenado, esto lo hacemos con el siguiente código:

import json  
import os  

import streamlit as st  
import torch  
from PIL import Image  
from torchvision import transforms  
import torch.nn.functional as F  
from src.model import Net  


@st.cache_resource  
def load_model(num_classes: int):  
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  
    net = Net(num_classes=num_classes)  
    net.to(device=device)  

    return net  


class Predictor:  

    def __init__(self):  
        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  


    def load_list_models(self):  
        list_models = []  
        for file_name in os.listdir('models'):  
            if file_name.endswith(".pth"):  
                list_models.append(file_name)  

        return list_models  


    def load_classes(self, name_model):  

        name_model = name_model.replace(".pth", "")  

        with open(f"models/classes_{name_model}.json", "r") as file:  
            classes = json.load(file)  
        return classes  

    def predict(self, name_model, image):  

        if image is None:  
            print("No image file")  
            return  

  image = Image.open(image)  

        transform = transforms.Compose([  
            transforms.Resize((256, 256)),  
            transforms.RandomHorizontalFlip(p=0.5),  
            transforms.RandomVerticalFlip(p=0.5),  
            transforms.RandomRotation(degrees=15),  
            transforms.ToTensor(),  
            transforms.Normalize((0.5,), (0.5,))  
        ])  

        image = transform(image)  
        image = image.unsqueeze(0)  

        image = image.to(device=self.device)  

        classes = self.load_classes(name_model=name_model)  

        model = load_model(num_classes=len(classes))  

        model.load_state_dict(torch.load(f"models/{name_model}"))  

        model.eval()  

        with torch.no_grad():  
            output = model(image)  
            probabilities = F.softmax(output, dim=1)  
            percentage = probabilities * 100  

  values = percentage[0].tolist()  

        results = dict(zip(classes, values))  
        results = dict(sorted(results.items(), key=lambda item: item[1], reverse=True))  

        return results

Básicamente, lo que hacemos es en la función predict, recibimos la imagen y le aplicamos unas transformaciones para que sea compatible con nuestro modelo, luego cargamos el modelo que tenemos seleccionado en la interfaz, cargamos las clases posibles que puede predecir el modelo y finalmente retornamos los resultados de la predicción.

2. Entrenar un modelo nuevo desde cero

Para poder entrenar un nuevo modelo desde cero primero debemos tener las imágenes separadas en carpetas y que estas carpetas sean las clases, podemos encontrar muchos datasets con imágenes ya clasificadas en páginas como https://www.kaggle.com/

Una vez tengamos nuestras imágenes, debemos copiarlas a la carpeta que está en la raíz del proyecto llamada “images_files”, por ejemplo:

Antes de cargar las imágenes a nuestro modelo tenemos una función que busca y elimina archivos corruptos, esto es importante porque si hay archivos dañados nuestro modelo no podrá entrenarse, el código que hace eso es el siguiente:

def clean_corrupt_images(self, root_dir: str):  
    for subdir, dirs, files in os.walk(root_dir):  
        for file in files:  
            file_path = os.path.join(subdir, file)  
            try:  
                with Image.open(file_path) as img:  
                    img.verify()  
            except (IOError, SyntaxError):  
                print(f'corrupt image: {file_path}')  
                os.remove(file_path)

Ahora si tenemos todo listo para empezar nuestro entrenamiento, desde la interfaz podemos darle un nombre al nuevo modelo y la cantidad de épocas que queremos que nuestro modelo se entrene, nuestro código para el entrenamiento es el siguiente:

import json  
import streamlit as st  
from src.model import Net  
from src.utils import Utils  
import torch  
from torchvision.transforms import transforms  
from torchvision.datasets import ImageFolder  
from torch.utils.data import DataLoader, random_split  
import torch.nn as nn  
import torch.optim as optim  


class Train:  
    def __init__(self):  
        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  

    def _evaluate_model(self, model, data_loader):  
        model.eval()  
        correct = 0  
  total = 0  
  with torch.no_grad():  
            for data in data_loader:  
                images, labels = data[0].to(self.device), data[1].to(self.device)  
                outputs = model(images)  
                _, predicted = torch.max(outputs.data, 1)  
                total += labels.size(0)  
                correct += (predicted == labels).sum().item()  
        accuracy = 100 * correct / total  
        return accuracy  

    def train_model(self, epochs: int, model_name: str):  
        transform = transforms.Compose([  
            transforms.Resize((256, 256)),  
            transforms.RandomHorizontalFlip(p=0.5),  
            transforms.RandomVerticalFlip(p=0.5),  
            transforms.RandomRotation(degrees=15),  
            transforms.ToTensor(),  
            transforms.Normalize((0.5,), (0.5,))  
        ])  

        Utils().clean_corrupt_images(root_dir="images_files")  

        data_files = ImageFolder(root="images_files", transform=transform)  

        classes = data_files.classes  

        with open(f'models/classes_{model_name}.json', 'w') as file:  
            file.write(json.dumps(classes, indent=4))  

        train_size = int(0.85 * len(data_files))  
        test_size = len(data_files) - train_size  
        train_set, test_set = random_split(data_files, [train_size, test_size])  

        train_loader = DataLoader(train_set, batch_size=32, shuffle=True, num_workers=2)  
        test_loader = DataLoader(test_set, batch_size=32, shuffle=True, num_workers=2)  

        model = Net(num_classes=len(classes))  
        model.to(device=self.device)  

        criterion = nn.CrossEntropyLoss()  
        optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)  

        train_result = []  

        progress_bar = st.progress(0, "Initializing training...")  

        for epoch in range(epochs):  

            model.train()  
            running_loss = 0.0  
  for i, data in enumerate(train_loader, 0):  
                inputs, labels = data[0].to(self.device), data[1].to(self.device)  

                optimizer.zero_grad()  

                outputs = model(inputs)  
                loss = criterion(outputs, labels)  
                loss.backward()  
                optimizer.step()  

                running_loss += loss.item()  

            accuracy = self._evaluate_model(model, test_loader)  

            info = f'Epoch {epoch + 1} -> Loss: {round(running_loss / len(train_loader), 2)} - Accuracy: {round(accuracy, 2)}%'  

  print(info)  

            percentage = (epoch + 1) / epochs  

  progress_bar.progress(percentage, info)  

            train_result.append({  
                'epoch': epoch + 1,  
                'loss': running_loss / len(train_loader),  
                'accuracy': accuracy  
            })  

        print('Finished Training')  

        progress_bar.empty()  

        torch.save(model.state_dict(), f'models/{model_name}.pth')  

        return train_result

En nuestra función tran_model seguimos los siguientes pasos:

Definir las transformaciones que le vamos a hacer a nuestro dataset de imágenes, que son las mismas transformaciones que usamos para la predicción
Luego limpiamos los archivos corruptos
Usamos los nombres de las carpetas para definir las clases posibles del modelo y lo guardamos como json
Definimos los DataLoaders de prueba y entrenamiento, usamos un 85% para entrenamiento y un 15% para pruebas
Definimos nuestra función de perdida para el entrenamiento del modelo y el optimizador que se utilizara para ajustar los parámetros del modelo durante el entrenamiento
Finalmente, empezamos a entrenar nuestro modelo con la cantidad de épocas que definimos en la interfaz, durante el entrenamiento, al finalizar cada época evaluamos nuestro modelo, esto con el fin de poder visualizar como avanza el entrenamiento en cada ciclo, cuando termina guardamos los parámetros del entrenamiento en un archivo .pth para luego usarlo en la vista de pruebas de nuestros modelos

Conclusiones

Gracias a las CNN podemos entrenar modelos para la clasificación de imágenes de una manera muy rápida y efectiva, logrando en nuestro caso una predicción de las del 85% sin importar el tamaño de nuestra imagen ni otros factores que gracias a los transformers de Pytorch podemos obviar, esto hace que tengamos muchos escenarios en donde podamos implementar este tipo de tecnologías.

Muchas gracias por leer mi post, hasta la próxima.

Creando Subtítulos Automáticos para Vídeos con Python, Faster-Whisper, FFmpeg, Streamlit, Pillow

Edinson Mauricio Mendoza — Mon, 29 Apr 2024 03:40:08 +0000

Hola amigos, hoy les traigo un tutorial de como generar subtítulos de manera automática a tus videos con python, sé que existen muchos programas que actualmente ya hacen esto, pero siento es importante aprender a hacer este tipo de cosas casi desde cero, esto hace que aumente nuestra creatividad y conocimiento y hace que pensemos en un mundo de posibilidades y aplicaciones.

Para lograr esto usaremos como lenguaje principal Python, y otras librerías como:

Faster-whisper (https://github.com/SYSTRAN/faster-whisper)
Streamlit (https://streamlit.io/)
Pillow (https://python-pillow.org/)
FFmpeg (https://ffmpeg.org/)

La implementación completa la puedes encontrar en mi cuenta de GitHub en el siguiente repositorio:

https://github.com/emmendoza2794/automatic-subs-GUI

Este proyecto se encuentra dividido en 4 partes:

La interfaz gráfica realizada con Streamlit
La generación de los subtítulos a partir del audio del video lo hacemos con Fast-Whisper
La creación de las imágenes con fondo transparente con el texto de los subtítulos y las configuraciones que realizaremos con Pillow
Composición final del vídeo original con los subtítulos en el tiempo correcto será con FFmpeg

1. Interfaz gráfica

Para este proyecto usaremos una interfaz gráfica sencilla en donde podremos configurar el estilo y posición de los subtítulos, podremos ver una vista previa de como quedaran y una vista del resultado final.

Sera algo como esto:

Nuestro código en Python seria este:

import os
import shutil
import subprocess

import streamlit as st

if 'text_preview_path' not in st.session_state:
    st.session_state.text_preview_path = None

if 'final_video' not in st.session_state:
    st.session_state.final_video = None


def generate_video_subs():
    ...


def generate_text_preview():
    ...


st.set_page_config(
    page_title="Automatic Subs GUI",
    page_icon="👋",
    layout="wide",
    initial_sidebar_state="expanded",
)

st.markdown(
    unsafe_allow_html=True,
    body="""
    <style>
           img {
               max-height: 700px;         
           }
           .block-container {
                padding-top: 2rem;
           }
           video {
               max-height:700px;
           }
    </style>
    """
)

st.header('Automatic Subtitle Generator', divider='rainbow')

col1, col2, col3 = st.columns([0.25, 0.375, 0.375])

with col1:
    with st.container(border=True):
        st.subheader("Video file")

        st.file_uploader(
            label="Video file",
            key="video_file",
            label_visibility="collapsed",
            type=['mp4']
        )

        if st.session_state.video_file is not None:
            with open(f'temp/video.mp4', 'wb') as f:
                f.write(st.session_state.video_file.getvalue())

    with st.container(border=True):
        st.subheader("Subtitle settings")

        st.selectbox(
            label='Font',
            key="font",
            options=Utils().list_fonts()
        )

        st.slider(
            label="Font size",
            min_value=30,
            max_value=90,
            value=70,
            key="font_size",
            step=1
        )

        col_color_1, col_color_2 = st.columns([0.5, 0.5])

        with col_color_1:
            st.color_picker(
                label="Text color",
                key="color_text",
                value="#ffffff"
            )

        with col_color_2:
            st.color_picker(
                label="Border color",
                key="color_border",
                value="#000"
            )

        st.radio(
            label="Text position",
            key="text_position",
            index=2,
            options=["Top", "Center", "Bottom"],
            horizontal=True,
        )

        st.radio(
            label="Subtitle length",
            key="subtitle_length",
            index=0,
            options=["Automatic", "Custom"],
            horizontal=True,
        )

        st.slider(
            label="Minimum characters",
            min_value=10,
            max_value=150,
            value=70,
            key="min_chars",
            step=1,
            disabled=st.session_state.subtitle_length == "Automatic"
        )

    st.button(
        label="Generate video",
        type="primary",
        on_click=generate_video_subs,
        use_container_width=True,
    )

with col2:
    with st.container(border=True):
        st.subheader("Subtitle preview")

        generate_text_preview()

        if st.session_state.text_preview_path is not None:
            st.image(st.session_state.text_preview_path)

with col3:
    with st.container(border=True):
        st.subheader("Final video")

        if st.session_state.final_video is not None:
            st.video(st.session_state.final_video)

            with open(st.session_state.final_video, "rb") as file:
                st.download_button(
                    type="primary",
                    label="Download video",
                    data=file,
                    file_name="final_video.mp4",
                    mime="video/mp4"
                )

2. Generacion de subtitulos a partir del audio del video

Aquí es donde usamos la librria Faster-Whisper, esta librería es una reimplementación del modelo Whisper de OpenAI utilizando CTranslate2, promete ser hasta 4 veces más rápida que openai/whisper para lograr la misma precisión y utilizar menos memoria.

Básicamente, debemos pasarle el audio del video y automáticamente reconocerá el idioma y nos devolverá el texto del audio con sus tiempos en la línea del tiempo del video.

Para esto primero debemos extraer el audio del video, esto es muy simple con FFmpeg(esta no es una librería de python, debes tenerlo instalado en tu pc https://ffmpeg.org/download.html), que lo podemos usar desde Python muy fácilmente.

Código para extraer el audio de un video con Python y FFmpeg:

import subprocess  

ffmpeg_command = [  
    "ffmpeg",  
    "-loglevel", "warning",  
    "-i", "temp/video.mp4",  
    "temp/audio.mp3",  
    "-y"  
]  

subprocess.run(ffmpeg_command)

Ya con el audio del video podemos ahora si usar Faster-Whisper.

IMPORTANTE: todo el código me estoy mostrando hace parte del repositorio que puedes ver en Github, en cualquier momento puedes revisarlo o clonarlo para entender mejor su funcionamiento

Esto lo hacemos con el siguiente código:

from faster_whisper import WhisperModel
import streamlit as st


@st.cache_resource
def load_model():
    return WhisperModel(
        model_size_or_path="large-v3",
        device="cuda",
        compute_type="float16"
    )


class GenerateSubtitles:

    def __init__(self):
        self.model = None

    def generate_automatic(self):

        model = load_model()

        segments, info = model.transcribe(
            audio="temp/audio.mp3",
            beam_size=5,
        )

        data_segments = []

        for segment in segments:
            data_segments.append({
                'start': segment.start,
                'end': segment.end,
                'text': segment.text
            })

        return data_segments

    def generate_custom(self, len_segment: int):

        model = load_model()

        segments, info = model.transcribe(
            audio="temp/audio.mp3",
            beam_size=5,
            word_timestamps=True
        )

        data_words = []

        for segment in segments:
            for word in segment.words:
                data_words.append({
                    "start": word.start,
                    "end": word.end,
                    "word": word.word
                })

        text = ""
        pos_start = 0

        data_word_expanded = []

        for index, data in enumerate(data_words):

            if text == "":
                pos_start = data["start"]

            text += data["word"]

            if len(text) >= len_segment or index == len(data_words) - 1:
                data_word_expanded.append({
                    'start': pos_start,
                    'end': data["end"],
                    'text': text.strip()
                })

                text = ""

        return data_word_expanded

Como puedes ver, tenemos 2 funciones, una que retorna los subtitulos tal como nos lo da la librería de Faster-Whisper y otra función en donde le pasamos el parámetro len_segment para que nos devuelva una longitud personalizada de cada segmento del subtitulo.

3. Creación de las imágenes .png con los subtitulos y las configuraciones

Para poder tener una mejor personalización a la hora de crear los subtítulos opté por crear temporalmente una imagen por cada subtitulo, así puedo usar cualquier fuente, cambiar colores, tamaños, etc… Para esto use la librería de Python Pillow.

Este es el código:

import os
import subprocess

from PIL import Image, ImageDraw, ImageFont


class GenerateImages:

    def __init__(self):
        self.draw = None

    def _wrap_text(self, text, font, max_width):

        lines = []
        words = text.split(" ")
        temp_line = ""
        for word in words:
            if self.draw.textbbox((0, 0), temp_line + word, font=font)[2] <= max_width:
                temp_line += " " + word if temp_line else word
            else:
                lines.append(temp_line)
                temp_line = word
        lines.append(temp_line)

        return "\n".join(lines)

    def dimensions_video(self):
        ffmpeg_command = [
            'ffmpeg',
            '-loglevel', 'warning',
            '-i', 'temp/video.mp4',
            '-ss', '00:00:3',
            '-vframes', '1',
            'temp/video_preview.jpg',
            '-y'
        ]

        subprocess.run(ffmpeg_command)

        img = Image.open("temp/video_preview.jpg")

        width, height = img.size

        return width, height

    def multi_line_img(
            self,
            text: str,
            font: str,
            font_size: int,
            text_color: str,
            border_color: str,
            text_position: str,
            name: str,
            width: int,
            height: int,
    ):

        image = Image.new("RGBA", (width, height), (255, 255, 255, 0))
        self.draw = ImageDraw.Draw(image)

        margin = height * 0.05

        font = ImageFont.truetype(f"assets/fonts/{font}.ttf", font_size)

        lines_text = self._wrap_text(text, font, width - 2 * margin)

        text_box = self.draw.textbbox(
            xy=(0, 0),
            text=lines_text,
            font=font,
            spacing=int(font_size / 10),
            align="center",
            stroke_width=int(font_size / 15)

        )

        if text_position == "Top":
            position_x = height * 0.1

        if text_position == "Center":
            position_x = (height - (text_box[3] * 1.5)) // 2

        if text_position == "Bottom":
            position_x = (height * 0.8) - (text_box[3] // 2)

        self.draw.multiline_text(
            xy=((width-text_box[2]) // 2, position_x),
            text=lines_text,
            font=font,
            fill=text_color,
            spacing=int(font_size / 10),
            align="center",
            stroke_fill=border_color,
            stroke_width=int(font_size / 15)
        )

        name = f"temp/subs/{name}.png"

        image.save(name)

        return name

    def preview_text(
            self,
            uploaded_video: bool,
            text: str,
            font: str,
            font_size: int,
            text_color: str,
            border_color: str,
            text_position: str,
    ):

        if uploaded_video and os.path.exists('temp/video.mp4'):
            width, height = self.dimensions_video()
            image = Image.open("temp/video_preview.jpg")

        else:
            width = 1920
            height = 1080
            image = Image.new("RGB", (width, height), (234, 234, 234))

        margin = width * 0.05

        self.draw = ImageDraw.Draw(image)

        font = ImageFont.truetype(f"assets/fonts/{font}.ttf", font_size)

        lines_text = self._wrap_text(text, font, width - 2 * margin)

        text_box = self.draw.textbbox(
            xy=(0, 0),
            text=lines_text,
            font=font,
            spacing=int(font_size / 10),
            align="center",
            stroke_width=int(font_size / 15)

        )

        if text_position == "Top":
            position_x = height * 0.1

        if text_position == "Center":
            position_x = (height - (text_box[3] * 1.5)) // 2

        if text_position == "Bottom":
            position_x = (height * 0.8) - (text_box[3] // 2)

        self.draw.multiline_text(
            xy=((width - text_box[2]) // 2, position_x),
            text=lines_text,
            font=font,
            fill=text_color,
            spacing=int(font_size / 10),
            align="center",
            stroke_fill=border_color,
            stroke_width=int(font_size / 15)
        )

        image.save("temp/text_preview.jpg")

Con el código anterior vemos que creamos un preview de como quedaría el texto en el video, para esto obtenemos el tamaño del video actual y trabamos todo en base a ese tamaño, tenemos la función multi_line_img que genera la imagen temporal del subtitulo que le pasemos.

4. Composición final del video original con los subtítulos

Ahora bien, ya tenemos los subtitulos con los tiempos en donde deben ir y tenemos las imágenes .png con esos subtitulos, solo nos falta superponer estas imágenes a lo largo del video original en el tiempo indicado, esto lo logramos con el siguiente código:

import subprocess

LOGLEVEL = "warning"


class GenerateVideo:

    def generate(self, subtitles: list):

        video_final = [
            "ffmpeg",
            "-loglevel", LOGLEVEL,
            "-i", "temp/video.mp4",
            '-y'
        ]

        overlays = []

        for index, subtitle in enumerate(subtitles):
            if index == 0:
                overlays.append(
                    f"[0:v][1:v]"
                    f"overlay=0:0:enable='between(t,{subtitle['start']},{subtitle['end']})'"
                    f"[v1]"
                )
            else:
                overlays.append(
                    f"[v{index}][{index + 1}:v]"
                    f"overlay=0:0:enable='between(t,{subtitle['start']},{subtitle['end']})'"
                    f"[v{index + 1}]"
                )

            video_final.extend(["-i", subtitle["img_path"]])

        video_final += [
            "-filter_complex",
            ";".join(overlays),
            "-map", "0:a",
            '-c:a', 'copy',
            "-map",
            f"[v{len(subtitles)}]",
            "output/final_video.mp4",
            "-y"
        ]

        subprocess.run(video_final)

        return True
import subprocess

LOGLEVEL = "warning"


class GenerateVideo:

    def generate(self, subtitles: list):

        video_final = [
            "ffmpeg",
            "-loglevel", LOGLEVEL,
            "-i", "temp/video.mp4",
            '-y'
        ]

        overlays = []

        for index, subtitle in enumerate(subtitles):
            if index == 0:
                overlays.append(
                    f"[0:v][1:v]"
                    f"overlay=0:0:enable='between(t,{subtitle['start']},{subtitle['end']})'"
                    f"[v1]"
                )
            else:
                overlays.append(
                    f"[v{index}][{index + 1}:v]"
                    f"overlay=0:0:enable='between(t,{subtitle['start']},{subtitle['end']})'"
                    f"[v{index + 1}]"
                )

            video_final.extend(["-i", subtitle["img_path"]])

        video_final += [
            "-filter_complex",
            ";".join(overlays),
            "-map", "0:a",
            '-c:a', 'copy',
            "-map",
            f"[v{len(subtitles)}]",
            "output/final_video.mp4",
            "-y"
        ]

        subprocess.run(video_final)

        return True

Aquí usamos totalmente FFmpeg que con su filtro overlay superpone cada una de las imágenes en el tiempo que le indiquemos.

Conclusiones

Sabemos que esta es una implementación sencilla pero es gratificante entender como esto tiene un sin fin de aplicaciones y mas ahora con el boom que hay de la IA, podríamos por ejemplo automatizar videos, realizar transcripciones de videos de manera automática, editar videos de manera masiva, en fin tenemos infinitas posibilidades.

Muchas gracias por leer mi post, hasta la próxima.