Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

Crie um codigo em python para ir na base evolucoes e buscar na coluna descricao temas…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-3-5-sonnet-20241022’s answer.
  1. User

    Crie um codigo em python para ir na base evolucoes e buscar na coluna descricao temas que remetem que o paciente foi a óbito e retorne o valor do atendi_codigo de cada um. use um modelo de hygging face que ajude a encontrar. Ou seja, usando termos como óbito, falec, mort e outros

  2. Gemini Assistant

    Claro! Com certeza. Para resolver este problema, vamos usar uma abordagem em duas etapas, que é muito eficiente para este tipo de tarefa:

    1. Pré-filtragem com Palavras-chave: Primeiro, faremos uma busca rápida no banco de dados por textos que contenham palavras-chave óbvias (como óbito, falec, morte, etc.). Isso reduzirá drasticamente o número de registros que precisamos analisar com o modelo de IA, tornando o processo muito mais rápido.
    2. Validação com Modelo Zero-Shot da Hugging Face: Em seguida, usaremos um modelo de "Classificação Zero-Shot" nos textos pré-filtrados. Esse tipo de modelo é excelente porque podemos dar a ele um texto e uma lista de "rótulos" (como "paciente foi a óbito" vs. "discussão sobre risco de morte"), e ele nos dirá qual rótulo melhor descreve o texto, sem precisar de treinamento prévio. Isso nos ajuda a eliminar falsos positivos (por exemplo, diferenciar "constatado óbito" de "paciente com medo da morte").

    Vamos ao código.

    Passo 1: Instalar as bibliotecas necessárias

    Primeiro, você precisa instalar as bibliotecas que vamos usar. Abra seu terminal ou prompt de comando e execute:

    pip install pandas torch transformers sentencepiece
    # Se você for se conectar a um banco de dados real, instale o driver correspondente, ex:
    # pip install psycopg2-binary # para PostgreSQL
    # pip install mysql-connector-python # para MySQL
    

    Passo 2: O Código Python

    Abaixo está o código completo. Ele primeiro simula uma base de dados com pandas para que o exemplo seja executável, mas também inclui seções comentadas mostrando como conectar a um banco de dados real (como SQLite ou PostgreSQL).

    import pandas as pd
    import re
    from transformers import pipeline
    
    # --- Bloco 1: Simulação de Dados (Substitua pela sua conexão ao banco de dados) ---
    
    # Criando um DataFrame de exemplo para simular a base "evolucoes"
    # Em um cenário real, você se conectaria ao seu banco de dados aqui.
    dados = {
        'atendi_codigo': [101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
        'descricao': [
            'Paciente evolui com melhora clínica, segue em observação.',
            'Às 14:30, foi constatado o óbito do paciente. Realizados procedimentos pós-morte.',
            'Familiares informados sobre o falecimento e orientados.',
            'Paciente discute com a equipe sobre seu medo da morte e prognóstico.',
            'Evolução estável. Sem intercorrências. Nega risco de óbito.',
            'Após parada cardiorrespiratória não reversível, paciente veio a óbito.',
            'Histórico familiar de morte súbita por infarto.',
            'Declarado o falecimento do paciente às 09:00 pela equipe médica.',
            'Paciente está bem, orientado e conversando. Sem queixas.',
            'O paciente faleceu em casa, segundo informações da família.'
        ]
    }
    df_evolucoes = pd.DataFrame(dados)
    
    print("--- Base de dados de exemplo ---")
    print(df_evolucoes)
    print("-" * 30)
    
    # --- FIM DO BLOCO DE SIMULAÇÃO ---
    # Se você tem um banco de dados real (ex: PostgreSQL, SQLite), use o código abaixo:
    # import sqlite3
    # conn = sqlite3.connect('seu_banco.db')
    # query = "SELECT atendi_codigo, descricao FROM evolucoes;"
    # df_evolucoes = pd.read_sql_query(query, conn)
    # conn.close()
    
    
    # --- Bloco 2: Pré-filtragem por Palavras-Chave ---
    
    def pre_filtrar_candidatos(df: pd.DataFrame) -> pd.DataFrame:
        """
        Filtra o DataFrame em busca de textos que contenham palavras-chave
        relacionadas a óbito.
        """
        print("\n--- Etapa 1: Pré-filtrando por palavras-chave ---")
        
        # Lista de palavras-chave (incluindo variações sem acento)
        palavras_chave = ['óbito', 'obito', 'falec', 'morte', 'morto', 'morta', 'falecido', 'falecida']
        
        # Cria uma expressão regular (regex) que busca qualquer uma das palavras-chave
        # O 'pipe' | funciona como um "OU". re.IGNORECASE ignora maiúsculas/minúsculas.
        regex_pattern = '|'.join(palavras_chave)
        
        # Filtra a coluna 'descricao' usando a regex
        candidatos_df = df[df['descricao'].str.contains(regex_pattern, case=False, na=False, regex=True)].copy()
        
        print(f"Encontrados {len(candidatos_df)} registros candidatos para análise com IA.")
        print(candidatos_df)
        return candidatos_df
    
    
    # --- Bloco 3: Análise com Hugging Face (Zero-Shot Classification) ---
    
    def analisar_com_modelo_hf(df_candidatos: pd.DataFrame, limiar_confianca: float = 0.90) -> list:
        """
        Usa um modelo de Zero-Shot para validar se o texto realmente confirma o óbito.
        """
        print("\n--- Etapa 2: Validando com o modelo da Hugging Face ---")
        print("Carregando o modelo... (isso pode demorar e baixar arquivos na primeira vez)")
    
        # Modelo recomendado para tarefas de classificação em múltiplos idiomas
        # 'facebook/bart-large-mnli' é um clássico, mas 'MoritzLaurer/mDeBERTa-v3-base-mnli-xnli' é mais moderno
        modelo_zero_shot = "MoritzLaurer/mDeBERTa-v3-base-mnli-xnli"
        classifier = pipeline("zero-shot-classification", model=modelo_zero_shot)
        
        # Rótulos que vamos usar para classificar o texto.
        # O modelo vai nos dizer qual desses rótulos melhor descreve a descrição.
        rotulos_candidatos = [
            "confirmação de óbito do paciente",
            "discussão sobre risco ou cuidados paliativos",
            "menção geral não relacionada ao paciente"
        ]
        
        codigos_obito_confirmado = []
        
        for index, row in df_candidatos.iterrows():
            descricao_texto = row['descricao']
            atendi_codigo = row['atendi_codigo']
            
            print(f"\nAnalisando Atendimento Cód: {atendi_codigo}...")
            
            # Realiza a classificação
            resultado = classifier(descricao_texto, rotulos_candidatos, multi_label=False)
            
            # Pega o rótulo com a maior pontuação
            rotulo_principal = resultado['labels'][0]
            score_principal = resultado['scores'][0]
            
            print(f"Texto: '{descricao_texto[:80]}...'")
            print(f"Rótulo principal: '{rotulo_principal}' (Confiança: {score_principal:.2%})")
            
            # Verifica se o rótulo principal é o que queremos e se a confiança é alta
            if rotulo_principal == "confirmação de óbito do paciente" and score_principal >= limiar_confianca:
                print(f"✅ CONFIRMADO: O texto indica óbito. Adicionando código {atendi_codigo}.")
                codigos_obito_confirmado.append(atendi_codigo)
            else:
                print(f"❌ DESCARTADO: O texto não parece confirmar o óbito diretamente ou a confiança é baixa.")
                
        return codigos_obito_confirmado
    
    
    # --- Bloco 4: Execução do fluxo completo ---
    
    # 1. Filtra os candidatos
    df_candidatos = pre_filtrar_candidatos(df_evolucoes)
    
    # 2. Analisa os candidatos com o modelo de IA
    if not df_candidatos.empty:
        atendimentos_obito = analisar_com_modelo_hf(df_candidatos, limiar_confianca=0.90)
    
        # 3. Exibe o resultado final
        print("\n\n--- RESULTADO FINAL ---")
        if atendimentos_obito:
            print("Os seguintes atendi_codigo foram identificados como registros de óbito:")
            print(atendimentos_obito)
        else:
            print("Nenhum registro de óbito foi confirmado com alta confiança.")
    else:
        print("\nNenhum registro candidato encontrado. Encerrando.")
    
    

    Como o código funciona e por que ele é eficaz

    1. Simulação de Dados: O DataFrame criado no início serve para que você possa rodar o código imediatamente e ver como ele funciona. Ele contém casos claros de óbito, casos que são "falsos positivos" (mencionam a palavra "morte", mas em outro contexto) e casos normais. Lembre-se de substituir essa parte pela conexão real ao seu banco de dados.

    2. pre_filtrar_candidatos:

      • Define uma lista de termos (palavras_chave) que indicam uma possível morte.
      • Usa a função str.contains() do pandas com uma expressão regular (regex). O | (pipe) significa "OU", então ele procura por óbito OU falec OU morte, etc.
      • case=False garante que ele encontre "Óbito" e "óbito".
      • Isso cria um DataFrame muito menor, contendo apenas os registros que valem a pena ser analisados pelo modelo de IA, economizando muito tempo de processamento.
    3. analisar_com_modelo_hf:

      • Carregamento do Modelo: Ele usa a função pipeline da biblioteca transformers, que é a maneira mais fácil de usar modelos pré-treinados. Na primeira vez que você rodar, ele fará o download do modelo (pode levar alguns minutos e ocupar alguns GBs).
      • Rótulos (rotulos_candidatos): Esta é a parte mais importante da técnica "Zero-Shot". Nós damos ao modelo as categorias que nos interessam. Ele vai ler a descricao e decidir qual das nossas frases descreve melhor o texto.
      • Limiar de Confiança (limiar_confianca): Definimos um "piso" de confiança (ex: 90% ou 0.90). Se o modelo classificar um texto como "confirmação de óbito do paciente", mas com apenas 60% de certeza, nós o ignoramos para evitar erros. Você pode ajustar esse valor para ser mais ou menos rigoroso.
      • Lógica de Decisão: O código verifica se o rótulo com a maior pontuação é exatamente o que procuramos ("confirmação de óbito do paciente") E se a pontuação está acima do nosso limiar. Se ambas as condições forem verdadeiras, o atendi_codigo é salvo.

    Essa abordagem híbrida é poderosa, pois combina a velocidade da busca por palavras-chave com a inteligência contextual de um modelo de linguagem avançado para obter resultados precisos e eficientes.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.