File size: 3,503 Bytes
c917b0c
7bcd929
 
ceb986e
7cf322e
ceb986e
26fe3ab
bde67d8
ceb986e
 
 
74c9918
6a1b87b
26fe3ab
7b7e408
26fe3ab
ceb986e
 
6a1b87b
74c9918
ceb986e
 
 
 
 
 
70403dc
 
ceb986e
70403dc
ceb986e
70403dc
 
 
ceb986e
26fe3ab
 
 
 
fa48b3b
26fe3ab
687ec91
 
26fe3ab
687ec91
 
 
 
 
 
 
 
31127be
687ec91
 
 
ceb986e
 
26fe3ab
6c08d2a
b6f0ac0
ceb986e
8b4c2da
687ec91
ceb986e
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import gradio as gr
from transformers import VisionEncoderDecoderModel, ViTImageProcessor, AutoTokenizer
from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler
import torch
import accelerate
from PIL import Image
from diffusers.utils import export_to_video

model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
feature_extractor = ViTImageProcessor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
tokenizer = AutoTokenizer.from_pretrained("nlpconnect/vit-gpt2-image-captioning")

pipe = DiffusionPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b", variant="fp16")
pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)


device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
pipe.to(device)

max_length = 16
num_beams = 4
gen_kwargs = {"max_length": max_length, "num_beams": num_beams}
def image_to_text(image_paths):
    images=[image_paths]
    
    pixel_values = feature_extractor(images=images, return_tensors="pt").pixel_values
    pixel_values = pixel_values.to(device)

    output_ids = model.generate(pixel_values, **gen_kwargs)

    preds = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
    preds = [pred.strip() for pred in preds]
    return preds[0]

def text_to_video(image_paths):
    prompt = image_to_text(image_paths)
    video_frames = pipe(prompt, num_inference_steps=25).frames
    video_path = export_to_video(video_frames)
    return video_path

article = """
## Descripción del proyecto

##### Queremos obtener un vídeo a partir de una imagen que tengamos. Por lo tanto, lo solucionaremos utilizando primero, un modelo de "image captioning" que nos genera un texto a partir de una imagen, y segundo utilizaremos un modelo que genera un video a partir de un texto. De esta manera el cliente en la interfaz deberá de subir como input un archivo de tipo imagen y recibirá como output un archivo de vídeo de unos pocos segundos.

### El primer modelo es el siguiente: https://huggingface.co/nlpconnect/vit-gpt2-image-captioning. Este modelo será el que reciba nuestro input, el cual deberá ser un archivo de tipo imagen. Como output nos da un texto, que será el input del segundo modelo.

### El segundo modelo es el siguiente: https://huggingface.co/damo-vilab/text-to-video-ms-1.7b. Este modelo debe recibir como input un texto, por ello, cuando este modelo reciba el texto del primer modelo generará el vídeo como output que será el output final que se mostrará en la interfaz al cliente que lo esté utilizando. Este modelo sólo puede recibir los inputs en inglés, pero no hay problema ya que el priemr modelo da el outpiut en inglés.

### Un problerma de la aplicación es que necesita bastantes recursos, y debido a los recursos tan limitados que nos ofrece Hugging Face gratuito deberemos esperar bastante tiempo desde que le damos el input hasta que nos de el output, unos 2000 segundos más o menos. Obviando ese detalle esta aplicación es muy útil para obtener un vídeo no muy largo de una imagen.

"""

title = "Proyecto 1: Aplicación de imagen a vídeo utilizando dos modelos de IA"
description = "En este proyecto, utilizando la siguiente interfaz, puedes obtener un vídeo corto a partir de una imagen"

interface = gr.Interface(
    fn=text_to_video, 
    inputs=gr.Image(type="pil"),
    outputs=gr.Video(), 
    title=title,
    description=description,
    article=article,

)

interface.launch(debug=True)