PAI - Simulador de Decisões com Lógica Fuzzy

PAI é um simulador baseado em agentes que utiliza lógica fuzzy para modelar a tomada de decisão de um personagem (o "Pai") em um ambiente doméstico simulado. O Pai deve gerenciar seus próprios recursos (saciedade e energia), cuidar de um cachorro, zelar por uma planta e reagir às mudanças climáticas — tudo isso em tempo real, ciclo a ciclo.

1. Introdução

O projeto explora conceitos de Inteligência Artificial por meio de sistemas fuzzy, onde variáveis contínuas (como fome, cansaço, felicidade do cachorro, nível de água da planta, cobertura de nuvens e força do vento) são mapeadas para conjuntos nebulosos. A partir dessas entradas, regras difusas determinam qual ação o agente deve executar a cada ciclo da simulação.

O objetivo é demonstrar como um sistema especialista baseado em regras fuzzy pode produzir comportamentos emergentes e adaptativos em um ambiente dinâmico e imprevisível.

2. Organização do Repositório

Pai_SBC/
├── src/
│   └── simulator/
│       ├── __init__.py
│       ├── __main__.py          # Ponto de entrada (python -m simulator)
│       ├── app.py               # Função main que inicia a simulação
│       ├── simulacao.py         # Classe Simulacao (loop principal e UI)
│       ├── models/
│       │   ├── __init__.py      # Exporta os modelos
│       │   ├── pai.py           # Modelo do Pai (saciedade, energia)
│       │   ├── cachorro.py      # Modelo do Cachorro (felicidade)
│       │   ├── planta.py        # Modelo da Planta (água, luz)
│       │   └── clima.py         # Modelo do Clima (nuvens, vento)
│       └── engine/
│           ├── __init__.py      # Exporta o motor fuzzy
│           └── fuzzy_engine.py  # Motor de inferência fuzzy (scikit-fuzzy)
├── .gitignore
├── LICENSE                      # MIT License
├── README.md
└── requirements.txt

3. Como Executar o Projeto

Pré-requisitos

• Python 3.10+
• pip

Passos

# 1. Clone o repositório
git clone https://github.com/PedroPaiva186/Pai_SBC.git
cd Pai_SBC

# 2. Crie e ative um ambiente virtual
python -m venv .venv
source .venv/bin/activate  # Linux/macOS
# .venv\Scripts\activate   # Windows

# 3. Instale as dependências
pip install -r requirements.txt

# 4. Execute a simulação
python -m src.simulator

Ao executar, um terminal com atualização em tempo real exibirá:

• Pai: Barras de saciedade e energia
• Cachorro: Barra de felicidade
• Planta: Barras de água e luz
• Clima: Barras de nebulosidade e força do vento
• Última decisão: Nome da ação escolhida pelo motor fuzzy no ciclo

A simulação roda indefinidamente, com cada ciclo durando 1 segundo.

4. Tecnologias Utilizadas

Tecnologia	Versão	Finalidade
Python	3.10+	Linguagem principal
scikit-fuzzy	0.5.0	Criação e avaliação do sistema de lógica fuzzy
NumPy	2.4.6	Manipulação de arrays para os universos fuzzy
NetworkX	3.6.1	Dependências
scikit-learn / SciPy	—	Dependências

5. Entendendo a Simulação

5.1 Modelos

• Pai (pai.py): Possui saciedade e energia (0–100), que decaem a cada ciclo. Pode comer (em casa ou fora) e dormir (na cama ou na rede).
• Cachorro (cachorro.py): Possui felicidade (0–100), que decai a cada ciclo. Pode brincar ou passear para se sentir melhor.
• Planta (planta.py): Possui água e luz (0–100). A água evapora lentamente; a luz varia conforme o fator definido pelo agente.
• Clima (clima.py): Simula condições meteorológicas variáveis. nuvens (nebulosidade) e vento mudam aleatoriamente a cada ciclo.

5.2 Motor Fuzzy

O coração do projeto está em engine/fuzzy_engine.py. Ele utiliza o scikit-fuzzy para definir:

• Antecedentes (entradas): saciedade, energia, felicidade, luz, água, vento, nuvens
• Consequentes (saídas): comer_casa, comer_fora, dormir_cama, dormir_rede, brincar, passear, aguar, colocar_luz, retirar_luz, ficar_parado
• Conjuntos de pertinência: cada variável é particionada em 3 conjuntos (baixa/média/alta, ou aberto/nublado/fechado para nuvens, fraco/médio/forte para vento), usando funções trapezoidais e triangulares.
• Regras: 17 regras difusas do tipo Se-Então que codificam o conhecimento do domínio (ex.: "Se saciedade é baixa, então comer_casa é alto").
• Prioridades: cada ação tem um peso de prioridade, usado como fator de multiplicação sobre o grau de ativação fuzzy para desempate.
• Seleção da ação: a ação com maior score (ativação × prioridade) é executada; se todas forem zero, o agente fica parado.

5.3 Fluxo de Decisão

[Início do ciclo]
       │
       ▼
Passar ciclo (decaimento dos atributos)
       │
       ▼
Coletar estado atual
       │
       ▼
Avaliar entradas no motor fuzzy
       │
       ▼
Calcular ativações e aplicar prioridades
       │
       ▼
Selecionar ação de maior score
       │
       ▼
Executar ação e exibir dados
       │
       ▼
[Aguardar 1s → próximo ciclo]