Update app.py

app.py

@@ -124,7 +124,8 @@ def load_models():
         )
         
         # Modelos generativos
-        models['text_to_image'] = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5",
+        models['text_to_image'] = StableDiffusionPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5",
             torch_dtype=torch.float16,
             use_safetensors=True,
             safety_checker=None,
@@ -159,12 +160,10 @@ def validate_image_file(file: UploadedFile) -> bool:
 def process_audio_file(audio_file):
     """Processa arquivo de áudio para o formato correto"""
     try:
-        # Criar arquivo temporário para processamento
         with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(audio_file.name)[1]) as tmp_file:
             tmp_file.write(audio_file.read())
             tmp_file_path = tmp_file.name
         
-        # Carregar áudio com librosa
         audio_array, sample_rate = librosa.load(tmp_file_path, sr=16000)
         os.unlink(tmp_file_path)
         
@@ -244,6 +243,151 @@ def display_results(result, model_key):
         st.subheader("🎨 Imagem Gerada")
         st.image(result[0], caption="Imagem gerada a partir do texto")
 
+def get_use_cases():
+    """Retorna os casos de uso para cada modelo"""
+    return {
+        'sentiment_analysis': {
+            'title': "Análise de Sentimento",
+            'description': "Analisa o sentimento (positivo, negativo, neutro) em comentários, avaliações ou postagens de clientes em redes sociais.",
+            'example': "Uma empresa de varejo monitora menções da marca no Twitter/X, identificando feedback negativo para responder proativamente ou destacando comentários positivos em campanhas de marketing.",
+            'benefit': "Melhoria na gestão de reputação online e resposta rápida a crises de imagem.",
+            'demo_input': "A entrega foi super rápida, adorei!",
+            'demo_type': 'text'
+        },
+        'text_classification': {
+            'title': "Classificação de Texto",
+            'description': "Classifica e-mails recebidos como positivos ou negativos para priorizar respostas ou identificar reclamações.",
+            'example': "Um call center categoriza e-mails de clientes, direcionando mensagens negativas para equipes de suporte prioritário.",
+            'benefit': "Otimização do tempo da equipe de atendimento e melhoria na experiência do cliente.",
+            'demo_input': "Estou insatisfeito com o produto",
+            'demo_type': 'text'
+        },
+        'summarization': {
+            'title': "Resumo de Texto",
+            'description': "Gera resumos concisos de documentos longos, como relatórios financeiros ou atas de reuniões.",
+            'example': "Uma consultoria financeira resume relatórios anuais de empresas em poucos parágrafos para facilitar a análise de investidores.",
+            'benefit': "Economia de tempo na leitura de documentos extensos e tomada de decisão mais rápida.",
+            'demo_input': "A empresa XYZ reportou um crescimento de 15% no último trimestre, impulsionado por novas parcerias estratégicas e expansão no mercado asiático. No entanto, desafios logísticos aumentaram os custos operacionais em 5%. A diretoria planeja investir em automação para mitigar esses custos no próximo ano.",
+            'demo_type': 'text'
+        },
+        'question_answering': {
+            'title': "Perguntas e Respostas",
+            'description': "Responde perguntas específicas com base em manuais, FAQs ou documentos internos.",
+            'example': "Um chatbot de suporte técnico responde perguntas como 'Como configurar o produto X?' extraindo respostas diretamente do manual do produto.",
+            'benefit': "Redução do tempo de suporte e maior autonomia para os usuários finais.",
+            'demo_input': {
+                'context': "O produto X tem garantia de 2 anos e pode ser configurado via aplicativo móvel em 5 minutos.",
+                'question': "Qual é o tempo de garantia do produto X?"
+            },
+            'demo_type': 'qa'
+        },
+        'translation': {
+            'title': "Tradução (EN→PT)",
+            'description': "Traduz conteúdo de marketing, manuais ou comunicações de inglês para português.",
+            'example': "Uma empresa de software traduz descrições de produtos para lançar no mercado brasileiro.",
+            'benefit': "Expansão de mercado com conteúdo adaptado e redução de custos com tradutores humanos.",
+            'demo_input': "Our product ensures high performance",
+            'demo_type': 'text'
+        },
+        'ner': {
+            'title': "Reconhecimento de Entidades",
+            'description': "Identifica entidades como nomes de pessoas, organizações e locais em contratos ou documentos legais.",
+            'example': "Um escritório de advocacia extrai automaticamente nomes de partes envolvidas em contratos, agilizando revisões.",
+            'benefit': "Redução de erros manuais e maior eficiência na análise de documentos.",
+            'demo_input': "Microsoft assinou um contrato com a empresa XYZ em Nova York.",
+            'demo_type': 'text'
+        },
+        'text_generation': {
+            'title': "Geração de Texto",
+            'description': "Gera textos criativos para campanhas de marketing, postagens em redes sociais ou roteiros.",
+            'example': "Uma agência de publicidade cria slogans ou descrições de produtos a partir de prompts iniciais.",
+            'benefit': "Aceleração do processo criativo e geração de ideias inovadoras.",
+            'demo_input': "Um futuro onde a tecnologia conecta todos",
+            'demo_type': 'text'
+        },
+        'image_classification': {
+            'title': "Classificação de Imagem",
+            'description': "Identifica defeitos ou classifica produtos em linhas de produção com base em imagens.",
+            'example': "Uma fábrica de eletrônicos classifica imagens de circuitos como 'Defeituoso' ou 'Aprovado' para controle de qualidade.",
+            'benefit': "Redução de erros humanos e aumento da eficiência na inspeção.",
+            'demo_input': None,  # Imagens não podem ser pré-carregadas diretamente no código
+            'demo_type': 'image'
+        },
+        'object_detection': {
+            'title': "Detecção de Objetos",
+            'description': "Detecta objetos como pessoas, veículos ou itens em imagens de câmeras de segurança.",
+            'example': "Um sistema de segurança identifica veículos em um estacionamento para monitoramento automático.",
+            'benefit': "Maior segurança e automação de processos de monitoramento.",
+            'demo_input': None,
+            'demo_type': 'image'
+        },
+        'image_segmentation': {
+            'title': "Segmentação de Imagem",
+            'description': "Segmenta diferentes partes de uma imagem, como órgãos em exames médicos.",
+            'example': "Um hospital segmenta tumores em imagens de ressonância magnética, facilitando diagnósticos.",
+            'benefit': "Apoio a diagnósticos médicos com maior precisão e rapidez.",
+            'demo_input': None,
+            'demo_type': 'image'
+        },
+        'facial_recognition': {
+            'title': "Reconhecimento Facial",
+            'description': "Identifica emoções faciais em vídeos ou fotos de clientes em lojas ou eventos.",
+            'example': "Uma loja de varejo analisa expressões faciais de clientes para avaliar a satisfação durante interações com produtos.",
+            'benefit': "Melhoria na experiência do cliente com base em dados emocionais.",
+            'demo_input': None,
+            'demo_type': 'image'
+        },
+        'speech_to_text': {
+            'title': "Transcrição de Áudio",
+            'description': "Converte gravações de reuniões ou entrevistas em texto para documentação.",
+            'example': "Uma empresa transcreve automaticamente reuniões para criar atas ou resumos.",
+            'benefit': "Economia de tempo na documentação e maior acessibilidade de conteúdo.",
+            'demo_input': None,
+            'demo_type': 'audio'
+        },
+        'audio_classification': {
+            'title': "Classificação de Áudio",
+            'description': "Classifica emoções em chamadas de suporte para avaliar a qualidade do atendimento.",
+            'example': "Um call center analisa chamadas para identificar emoções como 'Frustração' ou 'Satisfação' dos clientes.",
+            'benefit': "Melhoria na formação de equipes e na experiência do cliente.",
+            'demo_input': None,
+            'demo_type': 'audio'
+        },
+        'text_to_image': {
+            'title': "Texto para Imagem",
+            'description': "Gera imagens personalizadas a partir de descrições textuais para campanhas publicitárias ou design de produtos.",
+            'example': "Uma agência de design cria mockups de produtos com base em prompts como 'Um smartphone futurista em um fundo azul neon'.",
+            'benefit': "Redução de custos com designers gráficos e maior agilidade na criação de conteúdo visual.",
+            'demo_input': "Uma paisagem tropical ao pôr do sol",
+            'demo_type': 'text'
+        }
+    }
+
+def handle_use_case_demo(models, use_case_key, use_case):
+    """Executa a demonstração de um caso de uso com entrada pré-definida"""
+    if use_case['demo_input'] is None:
+        st.warning("⚠️ Demonstração não disponível. Este modelo requer upload de imagem ou áudio.")
+        return
+    
+    st.subheader("📊 Demonstração")
+    try:
+        if use_case['demo_type'] == 'text':
+            with st.spinner("Processando demonstração..."):
+                result = models[use_case_key](use_case['demo_input'])
+                display_results(result, use_case_key)
+        elif use_case['demo_type'] == 'qa':
+            with st.spinner("Processando demonstração..."):
+                result = models[use_case_key](
+                    question=use_case['demo_input']['question'],
+                    context=use_case['demo_input']['context']
+                )
+                st.success("🔍 Resposta encontrada:")
+                st.markdown(f"**Resposta:** {result['answer']}")
+                st.markdown(f"**Confiança:** {result['score']:.2%}")
+    except Exception as e:
+        st.error(f"Erro ao executar demonstração: {str(e)}")
+        logging.error(f"Erro na demonstração do caso de uso {use_case_key}: {e}")
+
 def main():
     st.title("🤖 Aplicação de IA Multi-Modal Avançada")
     st.markdown("---")
@@ -256,94 +400,121 @@ def main():
         st.error("Falha crítica ao carregar os modelos. Verifique os logs para mais detalhes.")
         return
     
-    # Sidebar para seleção de modelo
-    st.sidebar.title("⚙️ Configurações")
-    model_categories = {
-        "📝 Processamento de Texto": [
-            ("Análise de Sentimento", "sentiment_analysis"),
-            ("Classificação de Texto", "text_classification"),
-            ("Resumo de Texto", "summarization"),
-            ("Perguntas e Respostas", "question_answering"),
-            ("Tradução (EN→PT)", "translation"),
-            ("Reconhecimento de Entidades", "ner"),
-            ("Geração de Texto", "text_generation")
-        ],
-        "🖼️ Processamento de Imagem": [
-            ("Classificação de Imagem", "image_classification"),
-            ("Detecção de Objetos", "object_detection"),
-            ("Segmentação de Imagem", "image_segmentation"),
-            ("Reconhecimento Facial", "facial_recognition")
-        ],
-        "🎵 Processamento de Áudio": [
-            ("Transcrição de Áudio", "speech_to_text"),
-            ("Classificação de Emoções", "audio_classification")
-        ],
-        "✨ Modelos Generativos": [
-            ("Texto para Imagem", "text_to_image")
-        ]
-    }
-    
-    selected_category = st.sidebar.selectbox(
-        "Categoria",
-        list(model_categories.keys()),
-        index=0
-    )
-    
-    selected_model = st.sidebar.selectbox(
-        "Modelo", 
-        [name for name, key in model_categories[selected_category]],
-        format_func=lambda x: x,
-        index=0
-    )
-    
-    # Obter chave do modelo selecionado
-    model_key = next(key for name, key in model_categories[selected_category] if name == selected_model)
-    
-    # Interface principal
-    st.header(f"{selected_model}")
-    
-    # Accordion para informações do modelo
-    with st.expander("ℹ️ Sobre este modelo"):
-        model_info = {
-            'sentiment_analysis': "Analisa o sentimento expresso em um texto (positivo/negativo/neutro)",
-            'text_classification': "Classifica textos em categorias pré-definidas",
-            'summarization': "Gera um resumo conciso de um texto longo",
-            'question_answering': "Responde perguntas baseadas em um contexto fornecido",
-            'translation': "Traduz texto de inglês para português",
-            'ner': "Identifica e classifica entidades nomeadas (pessoas, lugares, organizações)",
-            'text_generation': "Gera texto criativo continuando a partir de um prompt",
-            'image_classification': "Identifica objetos e cenas em imagens",
-            'object_detection': "Detecta e localiza múltiplos objetos em uma imagem",
-            'image_segmentation': "Segmenta diferentes elementos em uma imagem",
-            'facial_recognition': "Reconhece características faciais e emoções",
-            'speech_to_text': "Transcreve fala em texto",
-            'audio_classification': "Classifica emoções em arquivos de áudio",
-            'text_to_image': "Gera imagens a partir de descrições textuais"
+    # Abas para navegação
+    tab1, tab2 = st.tabs(["Explorar Modelos", "Casos de Uso"])
+    
+    with tab1:
+        # Sidebar para seleção de modelo
+        st.sidebar.title("⚙️ Configurações")
+        model_categories = {
+            "📝 Processamento de Texto": [
+                ("Análise de Sentimento", "sentiment_analysis"),
+                ("Classificação de Texto", "text_classification"),
+                ("Resumo de Texto", "summarization"),
+                ("Perguntas e Respostas", "question_answering"),
+                ("Tradução (EN→PT)", "translation"),
+                ("Reconhecimento de Entidades", "ner"),
+                ("Geração de Texto", "text_generation")
+            ],
+            "🖼️ Processamento de Imagem": [
+                ("Classificação de Imagem", "image_classification"),
+                ("Detecção de Objetos", "object_detection"),
+                ("Segmentação de Imagem", "image_segmentation"),
+                ("Reconhecimento Facial", "facial_recognition")
+            ],
+            "🎵 Processamento de Áudio": [
+                ("Transcrição de Áudio", "speech_to_text"),
+                ("Classificação de Emoções", "audio_classification")
+            ],
+            "✨ Modelos Generativos": [
+                ("Texto para Imagem", "text_to_image")
+            ]
         }
-        st.info(model_info.get(model_key, "Informações detalhadas sobre este modelo."))
-    
-    # Processamento baseado no tipo de modelo
-    try:
-        if model_key in ['sentiment_analysis', 'text_classification', 'summarization', 
-                        'translation', 'text_generation', 'ner']:
-            handle_text_models(models, model_key, selected_model)
         
-        elif model_key == 'question_answering':
-            handle_qa_model(models, model_key)
+        selected_category = st.sidebar.selectbox(
+            "Categoria",
+            list(model_categories.keys()),
+            index=0
+        )
+        
+        selected_model = st.sidebar.selectbox(
+            "Modelo", 
+            [name for name, key in model_categories[selected_category]],
+            format_func=lambda x: x,
+            index=0
+        )
+        
+        # Obter chave do modelo selecionado
+        model_key = next(key for name, key in model_categories[selected_category] if name == selected_model)
+        
+        # Interface principal
+        st.header(f"{selected_model}")
         
-        elif model_key in ['image_classification', 'object_detection', 
-                          'image_segmentation', 'facial_recognition']:
-            handle_image_models(models, model_key, selected_model)
+        # Accordion para informações do modelo
+        with st.expander("ℹ️ Sobre este modelo"):
+            model_info = {
+                'sentiment_analysis': "Analisa o sentimento expresso em um texto (positivo/negativo/neutro).",
+                'text_classification': "Classifica textos em categorias pré-definidas.",
+                'summarization': "Gera um resumo conciso de um texto longo.",
+                'question_answering': "Responde perguntas baseadas em um contexto fornecido.",
+                'translation': "Traduz texto de inglês para português.",
+                'ner': "Identifica e classifica entidades nomeadas (pessoas, lugares, organizações).",
+                'text_generation': "Gera texto criativo continuando a partir de um prompt.",
+                'image_classification': "Identifica objetos e cenas em imagens.",
+                'object_detection': "Detecta e localiza múltiplos objetos em uma imagem.",
+                'image_segmentation': "Segmenta diferentes elementos em uma imagem.",
+                'facial_recognition': "Reconhece características faciais e emoções.",
+                'speech_to_text': "Transcreve fala em texto.",
+                'audio_classification': "Classifica emoções em arquivos de áudio.",
+                'text_to_image': "Gera imagens a partir de descrições textuais."
+            }
+            st.info(model_info.get(model_key, "Informações detalhadas sobre este modelo."))
         
-        elif model_key in ['speech_to_text', 'audio_classification']:
-            handle_audio_models(models, model_key)
+        # Processamento baseado no tipo de modelo
+        try:
+            if model_key in ['sentiment_analysis', 'text_classification', 'summarization', 
+                            'translation', 'text_generation', 'ner']:
+                handle_text_models(models, model_key, selected_model)
+            
+            elif model_key == 'question_answering':
+                handle_qa_model(models, model_key)
+            
+            elif model_key in ['image_classification', 'object_detection', 
+                              'image_segmentation', 'facial_recognition']:
+                handle_image_models(models, model_key, selected_model)
+            
+            elif model_key in ['speech_to_text', 'audio_classification']:
+                handle_audio_models(models, model_key)
+            
+            elif model_key == 'text_to_image':
+                handle_generative_models(models, model_key)
         
-        elif model_key == 'text_to_image':
-            handle_generative_models(models, model_key)
+        except Exception as e:
+            st.error(f"Erro inesperado durante a execução: {str(e)}")
+            logging.exception("Erro durante a execução do modelo")
     
-    except Exception as e:
-        st.error(f"Erro inesperado durante a execução: {str(e)}")
-        logging.exception("Erro durante a execução do modelo")
+    with tab2:
+        st.header("Casos de Uso")
+        st.markdown("Explore casos práticos de aplicação dos modelos para resolver problemas reais.")
+        
+        use_cases = get_use_cases()
+        selected_use_case = st.selectbox(
+            "Selecione um caso de uso",
+            list(use_cases.keys()),
+            format_func=lambda x: use_cases[x]['title']
+        )
+        
+        use_case = use_cases[selected_use_case]
+        
+        st.subheader(use_case['title'])
+        with st.expander("ℹ️ Detalhes do Caso de Uso"):
+            st.markdown(f"**Descrição**: {use_case['description']}")
+            st.markdown(f"**Exemplo Prático**: {use_case['example']}")
+            st.markdown(f"**Benefício**: {use_case['benefit']}")
+        
+        if use_case['demo_input'] is not None:
+            if st.button("🚀 Executar Demonstração", key=f"demo_{selected_use_case}"):
+                handle_use_case_demo(models, selected_use_case, use_case)
 
 def handle_text_models(models, model_key, model_name):
     """Manipula modelos de texto"""
@@ -373,7 +544,7 @@ def handle_text_models(models, model_key, model_name):
                 try:
                     if model_key == 'ner':
                         result = models[model_key](input_text)
-                    elif model_key== 'text_generation':
+                    elif model_key == 'text_generation':
                         result = models[model_key](
                             input_text,
                             max_new_tokens=advanced_params.get('max_length', 100),