Sistemas Especialistas, Regras e Ontologias

No artigo anterior, construímos a linguagem da inferência. Agora a colocaremos dentro de uma arquitetura que recebe fatos, escolhe regras, produz conclusões e explica o caminho percorrido. Essa arquitetura é o sistema especialista.

Os sistemas especialistas marcaram a aplicação industrial da IA simbólica porque separaram conhecimento de domínio e mecanismo de inferência. O programa MYCIN, desenvolvido em Stanford nos anos 1970, organizava conhecimento médico em regras e mantinha uma trilha das razões usadas em cada recomendação. O valor histórico não autoriza copiar o sistema para decisões clínicas atuais; mostra que explicação, aquisição de conhecimento e incerteza já eram problemas centrais muito antes dos modelos generativos.

1. Anatomia de um sistema especialista

Uma base de conhecimento guarda regras relativamente estáveis sobre o domínio. A memória de trabalho guarda fatos do caso atual. O motor de inferência compara fatos e regras, escolhe uma regra aplicável e atualiza a memória. O módulo de explicação registra quais fatos ativaram cada regra. Uma interface recebe informações e apresenta perguntas ou conclusões.

Separar base e motor permite trocar regras sem reescrever o algoritmo de controle. Também permite perguntar por quê?. Se a conclusão evacuar veio de acionar_alarme, que veio de risco_incendio, que veio de temperatura_alta e fumaca, a trilha é um objeto verificável. Explicável não significa correto: uma trilha perfeita pode expor uma premissa falsa ou uma regra mal formulada. Isso é uma virtude da arquitetura, não um defeito.

O gargalo clássico é a aquisição de conhecimento. Especialistas frequentemente executam julgamentos que não conseguem decompor imediatamente em regras; exceções se acumulam; o vocabulário muda; duas pessoas discordam. A manutenção da base é parte do sistema.

2. Regras de produção

Uma regra de produção tem a forma

Os $a_i$ são antecedentes e $c$ é a conclusão ou ação. Quando todos os antecedentes estão na memória, a regra entra no conjunto de conflito, também chamado de agenda. O ciclo reconhece e age repete quatro passos: casar regras com fatos, formar a agenda, escolher uma regra e dispará-la.

Se várias regras estão prontas, precisamos de resolução de conflito. Uma política pode priorizar regras explicitamente mais importantes, depois as mais específicas, com mais antecedentes, e por fim as ativadas por fatos recentes. A política precisa ser determinística quando a reprodutibilidade importa. Caso contrário, duas execuções sobre os mesmos fatos podem produzir trilhas diferentes.

Uma regra não deve disparar indefinidamente apenas porque sua conclusão já existe. Motores simples marcam a instância como usada; motores completos consideram mudanças nos fatos, remoções e múltiplas substituições de variáveis.

3. Encadeamento para frente e RETE

O encadeamento para frente é dirigido por dados. Começa com fatos observados e dispara regras até não produzir novidade ou até alcançar uma conclusão-alvo. Ele é apropriado quando dados chegam continuamente ou quando queremos descobrir todas as consequências relevantes.

Considere:

Com os dois fatos iniciais, três disparos produzem evacuar. Se a base tiver milhares de regras, testar todas contra todos os fatos em cada ciclo repete comparações. O algoritmo RETE, publicado por Charles Forgy, compila padrões compartilhados em uma rede e preserva resultados parciais. Quando um fato muda, apenas partes afetadas são atualizadas. A economia vem ao custo de memória para guardar esses casamentos.

RETE é uma arquitetura de casamento de padrões, não um substituto para regras bem projetadas. em uma base pequena, uma varredura linear é mais simples e pode ser suficiente. Otimizar cinquenta regras como se fossem cinquenta mil é construir uma autoestrada dentro da garagem.

4. Encadeamento para trás

O encadeamento para trás é dirigido por metas. Para provar evacuar, procura regras que concluam evacuar; encontra $r_3$ e transforma acionar_alarme em submeta. Depois encontra $r_2$, gera risco_incendio, encontra $r_1$ e finalmente pergunta pelos fatos temperatura_alta e fumaca.

Essa direção evita derivar conclusões sem relação com a pergunta. É natural em diagnóstico e consulta, nos quais o sistema pode pedir apenas os dados necessários à hipótese corrente. O risco é repetir submetas, entrar em ciclos e explorar primeiro uma hipótese improvável. Memorização, detecção de ciclos e ordenação de metas controlam o trabalho.

Os dois encadeamentos aplicam as mesmas regras, mas percorrem dependências em sentidos opostos. Para frente pergunta o que estes fatos permitem concluir?; para trás pergunta o que eu precisaria saber para concluir isto?.

5. Incerteza e fatores de certeza

Regras do mundo real raramente são absolutas. O MYCIN usou fatores de certeza, ou CFs, em $[-1,1]$. Valores positivos apoiam uma hipótese, negativos a enfraquecem e zero representa ausência de efeito. CF não é probabilidade; é uma medida operacional de mudança de crença no modelo.

Para duas evidências favoráveis $c_1,c_2\ge0$, a combinação é

Para duas contrárias $c_1,c_2\le0$:

Para sinais opostos:

O caso extremo $c_1=1$ e $c_2=-1$ zera o denominador: duas evidências absolutas e contraditórias revelam uma inconsistência que a fórmula não resolve. Se uma regra tem CF $c_r$ e o antecedente é sustentado por $c_a$, uma propagação simplificada usa $c_a c_r$. As fórmulas são associadas ao modelo de fatores de certeza; não devem ser apresentadas como leis gerais da probabilidade.

Exercícios resolvidos

1. Combine $0{,}6$ e $0{,}4$ a favor da mesma hipótese.

Solução:

$0{,}6+0{,}4(1-0{,}6)=0{,}6+0{,}16=0{,}76$.

2. Combine $0{,}7$ e $-0{,}4$.

Solução:

Os sinais são opostos:

O apoio favorável ainda predomina, mas a evidência contrária reduz o fator combinado de $0{,}7$ para $0{,}5$.

3. Um antecedente tem CF $0{,}8$ e a regra tem CF $0{,}7$. Qual é o apoio propagado?

Solução:

$0{,}8\cdot0{,}7=0{,}56$.

4. Combine sucessivamente $0{,}5$, $0{,}3$ e $0{,}2$.

Solução:

Primeiro, $0{,}5+0{,}3(0{,}5)=0{,}65$. Depois, $0{,}65+0{,}2(0{,}35)=0{,}72$.

5. Por que CF não é probabilidade?

Solução:

A combinação não deriva dos axiomas de Kolmogorov, não exige uma distribuição normalizada sobre hipóteses mutuamente exclusivas e depende de pressupostos próprios sobre evidências. Um CF $0{,}7$ não significa automaticamente probabilidade $70\%$.

6. Redes semânticas, frames e ontologias

Uma rede semântica representa conceitos como nós e relações como arestas. canario is-a ave permite herdar propriedades de ave; asa part-of ave representa composição. A notação é intuitiva, mas relações desenhadas sem semântica formal podem esconder ambiguidades.

Uma estrutura de atributos (frame) organiza um conceito em campos, ou slots, com valores, padrões e procedimentos associados. O frame Ave pode ter revestimento=penas e locomocao=voo, enquanto Pinguim herda de Ave e substitui locomocao. A exceção revela que herança do senso comum não é monotônica: acrescentar informação pode cancelar uma conclusão anterior.

Uma ontologia especifica classes, propriedades, indivíduos e axiomas de um domínio. Em OWL 2, a linguagem recomendada pelo W3C, podemos declarar classes disjuntas, restrições de propriedade e equivalências que um raciocinador usa para inferir classificação ou detectar inconsistência.

Ontologias operam tipicamente sob a hipótese de mundo aberto: não conhecer uma afirmação não implica conhecer sua negação. Bancos de dados costumam adotar mundo fechado, no qual o que não está registrado pode ser tratado como falso. Misturar os dois regimes produz erros silenciosos. Não há informação de alergia e a pessoa não tem alergia são sentenças diferentes.

7. Um motor de regras em C++23

O motor abaixo usa encadeamento para frente, prioridade e especificidade para resolver conflitos. Cada regra dispara no máximo uma vez e registra sua justificativa. Também implementa as três fórmulas de CF como funções constexpr, com verificações estáticas dos exemplos da Seção 5. No MSVC 19.51, usamos cl /std:c++latest /permissive- /W4 /EHsc /utf-8 /O2 especialista.cpp.

#include <algorithm>
#include <cstddef>
#include <iostream>
#include <limits>
#include <ranges>
#include <string_view>
#include <unordered_set>
#include <vector>

struct Regra {
    std::string_view nome;
    std::vector<std::string_view> antecedentes;
    std::string_view conclusao;
    int prioridade;
};

[[nodiscard]] constexpr double absoluto(const double x) noexcept {
    return x < 0.0 ? -x : x;
}

[[nodiscard]] constexpr double combinar_cf(
    const double a, const double b) noexcept {
    if (a >= 0.0 && b >= 0.0) {
        return a + b * (1.0 - a);
    }
    if (a <= 0.0 && b <= 0.0) {
        return a + b * (1.0 + a);
    }
    const double menor = std::min(absoluto(a), absoluto(b));
    return (a + b) / (1.0 - menor);
}

static_assert(absoluto(combinar_cf(0.6, 0.4) - 0.76) < 1e-12);
static_assert(absoluto(combinar_cf(0.7, -0.4) - 0.5) < 1e-12);

[[nodiscard]] bool satisfeita(
    const Regra& regra,
    const std::unordered_set<std::string_view>& fatos) {
    return std::ranges::all_of(
        regra.antecedentes,
        [&fatos](const std::string_view antecedente) {
            return fatos.contains(antecedente);
        });
}

[[nodiscard]] std::size_t escolher(
    const std::vector<Regra>& regras,
    const std::vector<std::size_t>& agenda) {
    return *std::ranges::max_element(
        agenda,
        [&regras](const std::size_t a, const std::size_t b) {
            if (regras[a].prioridade != regras[b].prioridade) {
                return regras[a].prioridade < regras[b].prioridade;
            }
            return regras[a].antecedentes.size()
                < regras[b].antecedentes.size();
        });
}

int main() {
    const std::vector<Regra> regras{
        {"R1", {"temperatura_alta", "fumaca"}, "risco_incendio", 30},
        {"R2", {"risco_incendio"}, "acionar_alarme", 20},
        {"R3", {"acionar_alarme"}, "evacuar", 10},
        {"R4", {"temperatura_alta"}, "verificar_sensor", 5},
    };

    std::unordered_set<std::string_view> fatos{
        "temperatura_alta", "fumaca"};
    std::unordered_set<std::string_view> disparadas;
    std::vector<std::string_view> trilha;

    for (;;) {
        std::vector<std::size_t> agenda;
        for (std::size_t i = 0; i < regras.size(); ++i) {
            const Regra& regra = regras[i];
            const bool nova = !disparadas.contains(regra.nome);
            const bool produz_novidade = !fatos.contains(regra.conclusao);
            if (nova && produz_novidade && satisfeita(regra, fatos)) {
                agenda.push_back(i);
            }
        }
        if (agenda.empty()) {
            break;
        }

        const std::size_t indice = escolher(regras, agenda);
        const Regra& regra = regras[indice];
        fatos.insert(regra.conclusao);
        disparadas.insert(regra.nome);
        trilha.push_back(regra.nome);

        std::cout << regra.nome << ": ";
        for (const std::string_view antecedente : regra.antecedentes) {
            std::cout << antecedente << ' ';
        }
        std::cout << "=> " << regra.conclusao << '\n';
    }

    std::cout << "conclusao evacuar? "
              << (fatos.contains("evacuar") ? "sim" : "nao") << '\n';
    return fatos.contains("evacuar") && trilha.size() == 4 ? 0 : 2;
}

Com os fatos iniciais, a agenda escolhe $R1$, depois $R2$, $R3$ e por fim $R4$. A prioridade determina a ordem, mas não apaga conclusões de menor prioridade. A trilha registra o nome de cada regra e permite reconstruir a cadeia até evacuar. std::string_view é seguro aqui porque todos os textos apontam para literais de duração estática; receber regras de um arquivo exigiria armazenamento proprietário.

O laboratório usa a mesma base. Marque fatos, execute o motor e observe agenda, disparos e explicação. Remover fumaca mostra a diferença entre uma condição suficiente da regra e uma impressão intuitiva de risco.

8. Conhecimento explícito cobra manutenção

Regras de produção tornam o raciocínio rastreável; encadeamento escolhe a direção da busca; RETE evita recomputar casamentos; fatores de certeza administram evidência dentro de um modelo próprio; ontologias dão semântica formal aos conceitos e relações.

O preço é visível: adquirir, revisar e alinhar conhecimento. Um modelo aprendido desloca parte desse trabalho para dados e treinamento, mas não elimina a necessidade de definir o que as saídas significam.

No próximo artigo, substituiremos fatores de certeza por probabilidade. A incerteza deixará de ser uma convenção de regras e passará a obedecer axiomas, condicionamento e o teorema de Bayes.

Acrônimos e Abreviações neste artigo

A seguir está a lista de todos os acrônimos e abreviações identificados no texto, organizados em ordem alfabética com o termo original em inglês e a tradução para o português:

Referências

BUCHANAN, B. G.; SHORTLIFFE, E. H. Rule-based expert systems: the MYCIN experiments of the Stanford Heuristic Programming Project. Reading: Addison-Wesley, 1984. Disponível em: https://impact.dbmi.columbia.edu/shortliffe/Buchanan-Shortliffe-1984/Chapter-10.pdf. Acesso em: 24 jul. 2026.

FORGY, C. L. Rete: a fast algorithm for the many pattern/many object pattern match problem. Artificial Intelligence, Amsterdam, v. 19, n. 1, p. 17–37, 1982. DOI: https://doi.org/10.1016/0004-3702(82)90020-0. Acesso em: 24 jul. 2026.

HECKERMAN, D. The certainty-factor model. Redmond: Microsoft Research, 1992. Disponível em: https://www.microsoft.com/en-us/research/publication/certainty-factor-model/. Acesso em: 24 jul. 2026.

LUGER, G. F. Artificial Intelligence: structures and strategies for complex problem solving. 6. ed. Albuquerque: University of New Mexico, 2009. Disponível em: https://www.cs.unm.edu/~luger/ai-final/. Acesso em: 24 jul. 2026.

MICROSOFT. Microsoft C/C++ language conformance by Visual Studio version. Redmond, 2026. Disponível em: https://learn.microsoft.com/en-us/cpp/overview/visual-cpp-language-conformance?view=msvc-170. Acesso em: 24 jul. 2026.

NOY, N. F.; MCGUINNESS, D. L. Ontology development 101: a guide to creating your first ontology. Stanford: Stanford University, 2001. Disponível em: https://protege.stanford.edu/publications/ontology_development/ontology101.pdf. Acesso em: 24 jul. 2026.

RUSSELL, S.; NORVIG, P. Artificial Intelligence: a modern approach. 4. ed. Hoboken: Pearson, 2020. Disponível em: https://aima.cs.berkeley.edu/. Acesso em: 24 jul. 2026.

WORLD WIDE WEB CONSORTIUM. OWL 2 Web Ontology Language primer: second edition. Cambridge, 2012. Disponível em: https://www.w3.org/TR/owl2-primer/. Acesso em: 24 jul. 2026.