app.py

import gradio as gr
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
from transformers import MarianMTModel, MarianTokenizer
from diffusers import StableDiffusionPipeline, DiffusionPipeline
import torch
import numpy as np
import imageio
from PIL import Image
from modelscope.pipelines import pipeline as ms_pipeline
from modelscope.outputs import OutputKeys

class MultiModalServices:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.image_generator = None
        self.video_generator = None
        self.translator = None
        self.sentiment_analyzer = None

    def load_image_generator(self):
        if self.image_generator is None:
            model_id = "CompVis/stable-diffusion-v1-4"
            self.image_generator = StableDiffusionPipeline.from_pretrained(
                model_id,
                torch_dtype=torch.float32
            ).to(self.device)
        return self.image_generator

    def load_video_generator(self):
        if self.video_generator is None:
            self.video_generator = ms_pipeline(
                'text-to-video-synthesis',
                'damo/text-to-video-synthesis'
            )
        return self.video_generator

    def generate_image(self, prompt, num_images=1):
        try:
            generator = self.load_image_generator()
            images = generator(
                prompt,
                num_images_per_prompt=num_images,
                guidance_scale=7.5
            ).images
            return images[0] if num_images == 1 else images
        except Exception as e:
            return f"Erro na geração de imagem: {str(e)}"

    def generate_video(self, prompt, duration=3):
        try:
            generator = self.load_video_generator()
            output = generator({'text': prompt})
            return output[OutputKeys.OUTPUT_VIDEO]
        except Exception as e:
            return f"Erro na geração de vídeo: {str(e)}"

    def translate(self, text, src_lang, tgt_lang):
        if self.translator is None:
            model_name = f'Helsinki-NLP/opus-mt-{src_lang}-{tgt_lang}'
            self.translator = pipeline('translation', model=model_name)
        try:
            result = self.translator(text)[0]['translation_text']
            return result
        except Exception as e:
            return f"Erro na tradução: {str(e)}"

    def analyze_sentiment(self, text):
        if self.sentiment_analyzer is None:
            self.sentiment_analyzer = pipeline(
                'sentiment-analysis',
                model='nlptown/bert-base-multilingual-uncased-sentiment'
            )
        try:
            result = self.sentiment_analyzer(text)[0]
            return f"Sentimento: {result['label']}, Confiança: {result['score']:.2f}"
        except Exception as e:
            return f"Erro na análise: {str(e)}"

# Instância global dos serviços
services = MultiModalServices()

# Interface Gradio
with gr.Blocks(title="Serviços de IA Multimodal") as demo:
    gr.Markdown("""
    # 🎨 Hub de Serviços de IA Multimodal
    
    Esta aplicação oferece serviços de geração de imagem, vídeo e processamento de texto.
    """)
    
    # 1. Geração de Imagem
    with gr.Tab("Geração de Imagem"):
        gr.Markdown("### Gerador de Imagens com Stable Diffusion")
        with gr.Row():
            img_prompt = gr.Textbox(
                label="Descrição da imagem",
                placeholder="Descreva a imagem que deseja gerar...",
                lines=3
            )
            img_output = gr.Image(label="Imagem Gerada")
        with gr.Row():
            img_num = gr.Slider(
                minimum=1,
                maximum=4,
                value=1,
                step=1,
                label="Número de imagens"
            )
        img_button = gr.Button("Gerar Imagem")
        img_button.click(
            services.generate_image,
            inputs=[img_prompt, img_num],
            outputs=img_output
        )
    
    # 2. Geração de Vídeo
    with gr.Tab("Geração de Vídeo"):
        gr.Markdown("### Gerador de Vídeos")
        with gr.Row():
            vid_prompt = gr.Textbox(
                label="Descrição do vídeo",
                placeholder="Descreva o vídeo que deseja gerar...",
                lines=3
            )
            vid_output = gr.Video(label="Vídeo Gerado")
        with gr.Row():
            vid_duration = gr.Slider(
                minimum=1,
                maximum=10,
                value=3,
                step=1,
                label="Duração (segundos)"
            )
        vid_button = gr.Button("Gerar Vídeo")
        vid_button.click(
            services.generate_video,
            inputs=[vid_prompt, vid_duration],
            outputs=vid_output
        )
    
    # 3. Tradução
    with gr.Tab("Tradutor"):
        gr.Markdown("### Tradutor Multilíngue")
        with gr.Row():
            trans_input = gr.Textbox(
                label="Texto para traduzir",
                placeholder="Digite o texto aqui...",
                lines=3
            )
            trans_output = gr.Textbox(
                label="Tradução",
                lines=3
            )
        with gr.Row():
            src_lang = gr.Dropdown(
                choices=["en", "pt", "es", "fr", "de"],
                value="en",
                label="Idioma de origem"
            )
            tgt_lang = gr.Dropdown(
                choices=["pt", "en", "es", "fr", "de"],
                value="pt",
                label="Idioma de destino"
            )
        trans_button = gr.Button("Traduzir")
        trans_button.click(
            services.translate,
            inputs=[trans_input, src_lang, tgt_lang],
            outputs=trans_output
        )
    
    # 4. Análise de Sentimentos
    with gr.Tab("Análise de Sentimentos"):
        gr.Markdown("### Análise de Sentimentos Multilíngue")
        with gr.Row():
            sent_input = gr.Textbox(
                label="Texto para análise",
                placeholder="Digite o texto para analisar o sentimento...",
                lines=3
            )
            sent_output = gr.Textbox(
                label="Resultado da análise",
                lines=2
            )
        sent_button = gr.Button("Analisar Sentimento")
        sent_button.click(
            services.analyze_sentiment,
            inputs=sent_input,
            outputs=sent_output
        )

    gr.Markdown("""
    ### Notas:
    - A geração de imagens e vídeos requer GPU para melhor performance
    - Os modelos são carregados sob demanda para economizar memória
    - Primeira execução pode ser mais lenta devido ao download dos modelos
    - Todos os modelos são open source
    """)

if __name__ == "__main__":
    demo.launch()