1
resposta

Sistema Especialista Diagnóstico Respiratório

Para construir esse sistema em Python, utilizaremos um mecanismo de Encadeamento Progressivo (Forward Chaining). Esse método parte dos fatos conhecidos e aplica as regras sucessivamente para derivar novas conclusões até que nenhum novo diagnóstico possa ser feito.

class BaseDeConhecimento:
    def __init__(self):
        # Usamos um set (conjunto) para garantir que fatos sejam únicos
        self.fatos = set()
        # Regras: lista de tuplas (condições, conclusão)
        self.regras = []

    def adicionar_fato(self, fato):
        self.fatos.add(fato.lower())

    def adicionar_regra(self, condicoes, conclusao):
        """
        condicoes: lista de strings que devem ser verdadeiras.
        conclusao: string que se torna fato se as condições forem atendidas.
        """
        self.regras.append({
            'condicoes': [c.lower() for c in condicoes],
            'conclusao': conclusao.lower()
        })

class SistemaEspecialista:
    def __init__(self, base_conhecimento):
        self.bc = base_conhecimento

    def inferir(self):
        print("--- Iniciando Processo de Inferência ---")
        novos_fatos = True
        diagnosticos_finais = []

        while novos_fatos:
            novos_fatos = False
            for regra in self.bc.regras:
                condicoes = regra['condicoes']
                conclusao = regra['conclusao']

                # Verifica se todas as condições da regra estão nos fatos conhecidos
                if all(c in self.bc.fatos for c in condicoes) and conclusao not in self.bc.fatos:
                    print(f"Raciocínio: Como o paciente tem {', '.join(condicoes)}, infere-se: {conclusao}")
                    self.bc.adicionar_fato(conclusao)
                    diagnosticos_finais.append(conclusao)
                    novos_fatos = True # Uma nova conclusão pode ativar outras regras
        
        return diagnosticos_finais

# --- Teste do Sistema ---

# 1. Instanciar a Base de Conhecimento
minha_bc = BaseDeConhecimento()

# 2. Definir as Regras (Lógica Proposicional)
minha_bc.adicionar_regra(["febre alta", "tosse"], "infecção respiratória")
minha_bc.adicionar_regra(["infecção respiratória", "dificuldade para respirar"], "pneumonia")
minha_bc.adicionar_regra(["tosse", "espirros"], "resfriado comum")

# 3. Inserir Fatos (Sintomas do Paciente)
sintomas = ["febre alta", "tosse", "dificuldade para respirar"]
for s in sintomas:
    minha_bc.adicionar_fato(s)

# 4. Executar o Mecanismo de Inferência
motor = SistemaEspecialista(minha_bc)
resultados = motor.inferir()

print("\n--- Diagnóstico Final ---")
if resultados:
    print(f"Conclusões encontradas: {', '.join(resultados).upper()}")
else:
    print("Nenhum diagnóstico conclusivo com os fatos fornecidos.")

Explicação do FuncionamentoO diagrama abaixo ilustra como a lógica de encadeamento progressivo funciona no sistema que acabamos de criar, onde os fatos iniciais "gatilham" as regras em cascata:Lógica Proposicional: O sistema utiliza a operação de implicação ($P \land Q \rightarrow R$). Por exemplo: Se Febre Alta AND Tosse, então Infecção.Encadeamento Progressivo: O loop while novos_fatos garante que o sistema seja "inteligente" o suficiente para entender que uma conclusão (como "infecção respiratória") pode servir de sintoma para uma condição mais grave (como "pneumonia").Explicação do Raciocínio: O método de inferência imprime cada passo do pensamento lógico, o que é fundamental em sistemas médicos para que o doutor possa validar a decisão da IA.

1 resposta

Oi, Tiago! Como vai?

Agradeço por compartilhar seu código com a comunidade Alura.

Gostei de como você estruturou a BaseDeConhecimento com set() para evitar fatos duplicados e do while no inferir() para permitir o encadeamento progressivo, onde uma conclusão vira novo fato e pode ativar outras regras.

Uma dica interessante para o futuro é adicionar um controle de regras já aplicadas (evita repetição e deixa o motor mais previsível), usando set. Veja este exemplo:


regras_aplicadas = set()

for i, regra in enumerate(self.bc.regras):
    condicoes = regra["condicoes"]
    conclusao = regra["conclusao"]

    if all(c in self.bc.fatos for c in condicoes) and conclusao not in self.bc.fatos:
        if i not in regras_aplicadas:
            regras_aplicadas.add(i)
            self.bc.adicionar_fato(conclusao)

Esse código registra o índice da regra aplicada em regras_aplicadas e evita que a mesma regra seja executada mais de uma vez no processo.

Alura Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!