Mudanças entre as edições de "Autômato celular e modelo baseado em indivíduos"

De Física Computacional
Ir para: navegação, pesquisa
(Criou página com '{{Ecologia| Simulação e modelo de campo médio | Contexto ecológico}} {{Ecologia| Simulação e modelo de campo médio |Contexto | Contexto ecol...')
 
 
(3 revisões intermediárias pelo mesmo usuário não estão sendo mostradas)
Linha 1: Linha 1:
{{Ecologia| [[Simulação e modelo de campo médio ]] |[[Contexto | Contexto ecológico]]}}
+
{{Ecologia| [[Simulação e modelo de campo médio ]] |[[Por que usar e o que são modelos baseados em indivíduos]]}}
  
{{Ecologia| [[Simulação e modelo de campo médio ]] |[[Contexto | Contexto ecológico]]}}
+
 
 +
[https://en.wikipedia.org/wiki/Artificial_society Sociedades artificiais] são modelos da sociologia computacional que são utilizados em análises sociais utilizando simulações computacionais, é um tema bastante conectado à sistemas complexos, desta forma se aproxima dos nossos modelos ecológicos.
 +
 
 +
Dentre as simulações computacionais utilizadas temos: algoritmos evolucionários (''evolutionary algorithms'' - EA), algoritmos genéticos (''genetic algorithms'' - GA), programação genética ''(genetic programming'' - GP), programação memetica (memetic programming - MP), modelos baseados em agentes (''agent based model'' - ABMs) e ''autômatos celulares'' (cellular automata - CA). Estes dois últimos são de especial interesse para nós.
 +
 
 +
==Autômatos celulares==
 +
 
 +
[https://en.wikipedia.org/wiki/Cellular_automaton Autômatos celulares] consistem em uma grade de células, onde cada uma está em um estado possível dentro de um conjunto finito de estados. Utilizando como exemplo para discussões posteriores o [[Modelo espacialmente explícito para 2 espécies|modelo de 2 herbívoros com dinâmica de destruição do sistema]], os possíveis estados de cada célula são:
 +
 
 +
#D - Destruído
 +
#L - Livre
 +
#O - Ocupado por ovelha
 +
#G - Ocupado por guanaco
 +
#OG - Ocupado por ovelhas e guanacos
 +
 
 +
Associado a cada célula temos um conjunto de células que são definidas em relação à esta célula específica, este conjunto recebe o nome de vizinhança. No nosso exemplo definimos como os 4 primeiros vizinhos da célula. Definimos um estado inicial <math display="inline">t=0</math> para todas as células e temos uma nova geração em <math display="inline">t+1</math> onde aplicamos uma regra de transição que determina o novo estado de um célula baseada em seu próprio estado atual e no estado das células vizinhas. Em geral as regras para atualização são as mesmas para cada células durante toda a simulação e é aplicado em toda a grade simultaneamente (síncrono). Algumas coisas que podem ser interessantes é mencionar que para o autômato celular, o espaço, o tempo e os estados são todos discretizados. Podemos comparar com outros sistemas dinâmicos espacialmente estendidos em termos da discretização destes três elementos<ref>[http://www.scholarpedia.org/article/Coupled_maps Coupled maps] (Kunihiko Kaneko e Tatsuo Yanagita, Scholarpedia)</ref>:
 +
 
 +
 
 +
<div align="center">
 +
 
 +
{| class="wikitable"
 +
! align="center" |Modelo
 +
! align="center" | Espaço
 +
! align="center" |Tempo
 +
! align="center" |Estado
 +
|-
 +
| align="center" |Autômato celular
 +
| align="center" |D
 +
| align="center" |D
 +
| align="center" |D
 +
|-
 +
| align="center" |Rede de mapas acoplados (CML)
 +
| align="center" |D
 +
| align="center" |D
 +
| align="center" |C
 +
|-
 +
| align="center" |Equação diferenciais ordinárias acopladas
 +
| align="center" |D
 +
| align="center" |C
 +
| align="center" |C
 +
|-
 +
| align="center" |Equação diferencial parcial
 +
| align="center" | C
 +
| align="center" |C
 +
| align="center" |C
 +
|}
 +
 
 +
</div>
 +
Onde D significa que é discreto e C que é contínuo, CML significa ''coupled map lattices''.Também é interessante de se destacar aqui, é que matemática e ciência computacional são disciplinas básicas para o autômato celular, então estamos efetivamente utilizando estes conjuntos de conhecimentos como ferramentas e expandindo um pouco nossos recursos disponíveis. Utilizando não mais apenas a matemática tradicional, mas também a ciência da computação. O que explica um pouco alguns problemas de nomenclatura e definições de termos que podem ser encontrados ao longo dos textos, aos poucos estes devem ser corrigidos conforme o próprio conhecimento vai sendo amadurecido.
 +
 
 +
Investigações teóricas de CA geralmente consistem em pegar uma dada regra e descobrir propriedades matemáticas relacionadas. Mas a maior parte das aplicações em ciências naturais seguem uma aproximação inversa, ou seja, busca-se descobrir a regra que reproduz as propriedades conhecidas que governam o fenômeno estudado.
 +
 
 +
Além disto, as regras de transições podem ser determinísticas ou estocásticas. Como os termos sugerem, no caso determinístico o novo estado de cada célula é determinado rigidamente baseado no estado presente da própria célula e no estado das células vizinhas. No caso estocástico (também chamado de autômato celular probabilístico) a seleção do estado da célula em cada tempo é sujeita a uma função probabilística, esta regra de transição oferece uma melhor analogia a sistemas naturais e também é o caso do nosso exemplo.
 +
 
 +
Além disso classicamente se discute quatro classes de comportamentos que podem ser reproduzidos por um autômato celular elementar, eles são qualitativamente caracterizados como:
 +
 
 +
*Classe 1: a evolução leva a um estado homogêneo; depois de um certo tempo, todas as células possuem um estado similar, independente do estado inicial.
 +
*Classe 2: a evolução leva a um conjunto de estruturas separadas simples ou periódicas; uma organização espacial surge com distintos domínios espaciais que podem ser homogêneos e estáveis ou periódico com alteração dos estados.
 +
*Classe 3: evolução leva a um padrão caótico; independente das condições iniciais o autômato celular leva a padrões aperiódicos em que não podem ser identificados qual foi o padrão inicial
 +
*Classe 4: evolução leva a estruturas complexas, algumas vezes com tempo de vida; nessa classe surge alguns padrões espaciais complexos que podem durar por um tempo específico, esses padrões possuem propagação espacial enquanto mantém uma conservação do seu formato.
 +
 
 +
Sem realizar análises detalhadas, aparentemente o exemplo que escolhemos pertence à classe 2. Claro que esta classificação é que com os parâmetros utilizados no artigo que levam o sistema à um regime oscilatório. Com outros parâmetros que levaria o sistema à uma extinção total por exemplo, teríamos uma classe 1.
 +
 
 +
A literatura ecológica que lida com autômatos celulares em sua maioria está de alguma forma relacionado à questão da heterogeneidade espacial. Alguns trabalhos buscam responder como os processos biológicos respondem a uma heterogeneidade preexistente. Pensando no outro [[Modelo espacialmente explícito|modelo com a destruição fixa]],  este tinha como objetivo estudar como o sistema evolui a partir de uma distribuição fixa das células destruídas no início. Outra classe de trabalhos busca a resposta inversa: como os processos biológicos podem criar heterogeneidade. Neste caso, podemos lembrar do próprio exemplo, onde estuda-se como a dinâmica produz as ondas de desertificação.
 +
 
 +
Além disso vale destacar que as interações em um CA são de curto alcance, o que é negligenciado em modelos de campo médio por exemplo. Outras características importantes e interessantes de um modelo de autômato celular são as capacidades de auto-manutenção e auto-organização.
 +
 
 +
Em todas aplicação de CA na ecologia, cada célula é considerado um espaço para um indivíduo biológico. No nosso exemplo cada ’indivíduo biológico’ ganha a interpretação de uma metapopulação de cada espécie, isto pode representar um indivíduo ou uma manada, não há distinções do tamanho desta metapopulação. Desta forma cada célula tem nos seus estados a informação, como comentamos anteriormente, apenas se ela está ocupada ou não por aquela espécie, mas não admite uma variação de indivíduos dentro da mesma célula, isto é, não admite variar o tamanho da metapopulação que ocupa cada célula. Não é claro como o CA determinístico poderia incorporar esta variação individual, mas é perfeitamente concebível utilizando uma regra de transição estocástica. Isto poderia ser feito por exemplo, variando a probabilidade de adotar determinado estado, desta forma um modelo de CA pode ser utilizado com o objetivo de construir um modelo baseado em indivíduos. Esta é uma alternativa.
 +
 
 +
==Modelos baseados em agentes==
 +
 
 +
[https://en.wikipedia.org/wiki/Agent-based_model Modelos baseados em agentes] são modelos computacionais para simular ações e interações entre agentes autônomos, estes modelos são mais intuitivos que modelos matemáticos ou estatísticos, uma vez que representam objetos como nós vemos: coisas individuais no mundo. Os exemplos mais familiares para muitas pessoas são os jogos The SIMS ou SIMCity.
 +
 
 +
Na ecologia estes modelos também são chamados de modelos baseados em indivíduos (''individual-based models'' - IBMs), modelo baseado em entidades ou simulações baseadas em indivíduos/entidades/agentes. Além disso há uma discussão sem nenhuma resposta conclusiva na literatura e entre profissionais envolvidos se modelos baseados em agentes são a mesma coisa que sistemas multi-agentes (''multi-agent system'' - MAS), ou se não são, então onde começaria um e terminaria outro, algumas autores ainda consideram IBMs como modelos pertencente à classe de modelos MAS. Para o resto do texto, se necessário vou considerar sistema de multi-agentes apenas como outro nome para modelo baseado em indivíduo<ref>[https://link.springer.com/referenceworkentry/10.1007%2F978-0-387-30440-3_13 Encyclopedia of Complexity and Systems Science] (Editor: Robert A. Meyers). Artigo: Agent Based Modeling andSimulation, Introduction to (Cilipo Castiglione, Conselho Nacional de Pesquisa da Itália)</ref>. Porém parece que MAS é um termo predominantemente das áreas baseadas em ciência computacionais e normalmente possui o propósito de resolver um problema real ou completar uma tarefa, um exemplo são redes de telecomunicação. Enquanto IBMs normalmente estão relacionados a ciências naturais como ecologia e ciência sociais, sendo predominantemente pesquisas sobre sistemas naturais em que a simulação tem por objetivo observar o comportamento coletivo dos agentes, mais que resolver um problema em específico<ref>[https://www.researchgate.net/post/How_to_differentiate_between_multi-agent_systems_and_agent-based_models Discussão aberta no Research Gate]</ref><ref>[https://arxiv.org/ftp/arxiv/papers/1708/1708.05872.pdf Agent-based computing from multi-agent systems to agent-based models: a visual survey] (Niazi Muaz e Amir Hussain, Scientometrics)</ref>.
 +
 
 +
Os modelos baseados em indivíduos historicamente evoluíram a partir dos autômatos celulares. Ainda explorando um pouco sua história nos anos 1990 houve uma grande expansão nas ciências sociais, e um os primeiros modelos úteis de autômatos celulares foi proposto por um cientista social e reimplementado muitas vezes em modelos IBM. Há três ideias centrais nos IBMs: agentes, [https://en.wikipedia.org/wiki/Emergence emergencia] e [https://en.wikipedia.org/wiki/Complexity complexidade].
 +
 
 +
*Agentes são os objetos que interagem seguindo algumas regras, tipicamente estão situados no espaço e residem em uma rede ou uma vizinhança tipo grade. Em alguns casos, como na ecologia, os agentes podem ser considerados como inteligentes e/ou com propósitos.
 +
* Emergencia ocorre quando uma entidade observada possui propriedades que suas partes não possuem. Então esta propriedade emerge somente quando as partes que constituem esta entidade interagem entre si, de forma simples, é algo que não pode ser obtido apenas como uma soma de suas partes.
 +
*A complexidade caracteriza o comportamento de um modelo em que seus componentes interagem de múltiplas formas e seguem regras locais.
 +
 
 +
Modelos baseados em agente são então simulações baseadas em consequências globais de interações locais dos membros de uma população. Neste tipo de modelo as características de cada indivíduo é rastreada através do tempo, em contraste com técnicas que caracterizam a população baseado em uma média, como os modelos de campo médio.
 +
 
 +
Alguns modelos baseados em indivíduos podem ser especialmente explícitos, isto é, os indivíduos estão associados a uma localização em um espaço geométrico, neste caso também podem (mas não necessariamente) exibir mobilidade através do ambiente.
 +
 
 +
Lembrando do exemplo que escolhemos para exemplificar características dos autômatos celulares, pensando na questão da mobilidade, se lembrarmos dos conceitos de meta-população originalmente proposto no modelo de Levins, não há mobilidade. Cada meta-população vive em determinado fragmento, o que ocorre na colonização é que uma nova geração coloniza um nova célula, mas não se desloca para ela. Na proposta original, a meta-população não possui mobilidade, ainda que o fenômeno de colonização de uma nova célula e extinção local produza um efeito análogo. Os modelos espacialmente explícitos ainda podem ser contínuos (valores reais) ou discreto (valores inteiros, tipo grade). Este último é o que se aproxima do nosso exemplo. Além disso os modelos também não precisam ser espacialmente explícitos, como uma rede de computadores por exemplo, onde as conexões entre os agentes não precisam estar relacionados a nenhuma localização espacial.
 +
 
 +
Conforme pode-se perceber, há uma relação entre modelos baseados em indivíduos e autômatos celulares. Conforme discutido enquanto uma célula de um autômato celular assume um estado que basicamente informa se a célula está ocupado ou não por uma espécie, em um modelo baseado em indivíduos podemos ter mais indivíduos ocupando o mesmo fragmento do ambiente e variando a população local de uma mesma espécie em um mesmo fragmento. É claro que podemos adicionar mais estados finitos no autômato celular, ou ainda conforme discutido adaptar as regras estocásticas de transição, mas talvez a diferença mais significativa seja se o loop da simulação procede célula por célula, ou indivíduo por indivíduo.
 +
 
 +
Mas a verdade é que muitos modelos estão entre CAs e IBMs, em geral uma das principais distinções dos modelos é exatamente se os agentes se movem ou simplesmente parecem se mover porque série de células mudam de estado, a exemplo da discussão que realizamos sobre nosso modelo baseado em autômatos, onde há apenas este movimento aparente. Já em IBMs os agentes que são os objetos no mundo tem posição conhecida e podem efetivamente se mover carregando propriedades auxiliares com eles. Dessa forma uma das vantagens chaves dos IBMs é que o conhecimento interno do agente é mantido com a entidade quando ela se move, enquanto no CA o conhecimento associado não se move. Como os agentes carregam conhecimento consigo, ele pode utilizar o conhecimento e a história para explorar novas áreas e conhecer outros agentes.
 +
 
 +
Com o desenvolvimento da programação orientada a objetos (''Object Orientated Programming - OOP'') que de certa forma lembra os conceitos dos IBMs, se tornou razoavelmente mais simples de implementar este tipo de modelo.
 +
 
 +
 
 +
===Introdução à modelos baseados em indivíduos===
 +
 
 +
Uma coisa interessante sobre os MBIs (modelos baseados em indivíduos) é quão longe podemos ir com relativa simplicidade devido a ascensão da programação orientada a objetos (''Object Orientated Programming'' - OOP ). OOP é uma forma de programar em que o código é dividido em objetos nos quais possuem um trabalho específico para fazer, estes objetos por sua vez são baseados em um modelo chamado “classe”. Essa forma de programar claramente lembra modelos baseados em indivíduos, onde por exemplo, podemos definir uma classe “Agente” e usar para construir múltiplos agentes.
 +
 
 +
Um ABM clássico usualmente é baseado no seguinte:
 +
 
 +
* '''Agente''': Uma classe que contém as variáveis (fields em C#) associadas aos agentes e representando seus estados (nome, idade, localização, etc ) e mais um bloco (ou mais) de códigos que regram a interação com outros agentes. Esse bloco de código é isolado e chamado de procedimentos (métodos em C#), normalmente possui um nome específico com que pode ser chamado para que o agente execute determinadas ações, como por exemplo “mover”.
 +
*'''Model''': Uma classe que chama os métodos dos agentes para fazê-los agir. É comum que os agentes ajam por um número fixo de vezes e então são interrompidos para que olhemos os estados dos agentes. Ou ainda pode-se definir uma condição de para para que os agentes ajam até que o objetivo seja atingido.
 +
 
 +
Isso é o suficiente pra construir um modelo simples baseado em agentes, onde os agentes agem baseado nos seus estados internos, mas nesse momento eles não possuem nada para interagir. Por isso, na maioria dos ABM existe algum tipo de ambiente que todos os agentes conhecem. É comum também que cada agente tenha uma lista com todos os agentes com que pode interagir, por exemplos outros agentes que estão próximos do agente em questão. Estas condições do ambiente podem ser incorporadas na classe Model, que muitas vezes também é chamada de “''environment''” (ambiente).
 +
 
 +
Quanto a escolha das regras comportamentais que regem a interação dos agentes, podem ser de vários tipos. O ideal é ter uma espécie de inteligência artificial com a tomada de decisão embutida, isto é, algo que tenha a tomada de decisão embutida em um modelo de pensamento e existência mais amplo. E por fim, ainda precisamos equilibrar a complexidade do modelo com a velocidade de processamento.
 +
 
 +
===Modelo de crença-desejo-intenção===
 +
 
 +
Um dos modelos mais famoso é baseado nestes três pilares:
 +
 
 +
#Crenças: fatos sobre o mundo (que podem aparecer no formato de regras).
 +
#Desejos: coisas que os agentes querem fazer ou que aconteça.
 +
#Intenção: ações que o agente escolhe, geralmente a partir de um conjunto de planos.
 +
 
 +
Sobre o processo de tomada de decisão pode ser implementado de várias formas. Uma vez que os desejos são objetivos, as decisões poderiam ser tomadas por exemplo:
 +
 
 +
* Priorizando o desejo mais importante;
 +
*Priorizando o plano que permite realizar mais desejos;
 +
* Priorizando o plano que tem mais chance de dar certo;
 +
* Seguindo o que a comunidade decidir (através de votação por exemplo);
 +
* Etc.
 +
 
 +
===Considerações===
 +
 
 +
Evidentemente, há muitas coisas que precisam ser consideradas durante a construção de um modelo baseado em indivíduos, abaixo discutirei algumas destas coisas.
 +
 
 +
'''Hardware''': Como são modelos computacionais, uma das preocupações naturalmente é sobre onde os modelos vão ser executados. Os modelos variam muito no processamento exigido, sendo necessário desde minutos a dias. Da mesma forma há também uma variação na quantidade de espaço de armazenamento que é necessário. Uma solução que pode ser implementada principalmente para lidar com o poder computacional que é necessário é a paralelização. Neste caso ainda há uma nova questão que precisa ser respondida: como o modelo pode ser dividido? Se os agentes fossem estáticos poderiam ser divididos em fragmentos geográficos, se os agentes não se comunicassem a divisão poderia ser por agentes. Mas na maioria dos modelos os agentes tanto se movem quanto se comunicam, então em algum momento será necessário permitir que os agentes se movimentem entre os fragmentos e/ou se comuniquem com agentes de outros nós.
 +
 
 +
'''Espaço''': O modelo é uma abstração da realidade, portanto não é inesperado que uma questão importante seja como esta abstração será feita. Isto é uma questão que começa desde a decisão sobre o tipo de fronteira que o modelo vai incorporar (infinitas, limitadas, etc), passa pela organização interna do próprio espaço (contínuo, em grade, rede, etc), e vai até sobre como a vizinhança é organizada. Pra citar alguns exemplos, nos nossos modelos baseados em autômatos celulares, foi escolhido uma vizinhança do tipo Von Neumann (diamante), mas poderia ser do tipo Moore (quadrado). Em um modelo contínuo poderia ser baseado na distância euclidiana dada por:<math display="inline">D\left(x,y\right)=\sqrt{\sum_{i=1}^{n}\left(x_{i}-y_{i}\right)^{2}}.</math>
 +
 
 +
'''Sincronização''': Discutindo sobre execução da simulação em si, uma preocupação que surge é a questão de sincronização, isto é, em que ordem os os agentes devem agir e quando. Sobre quando agir a opção mais simples é agir a cada intervalo específico de tempo. Apesar desta opção ser a mais simples, quando temos muitos agentes inativos pode ser pouco eficiente, desta forma outra opção é baseado em eventos específicos (por exemplo, quando é tocado por outro agente). Sobre a ordem uma opção usual é randomizar a ordem.
 +
 
 +
'''Calibração''': Tendo já resolvido os problemas relacionados ao hardware necessário e a modelagem do próprio modelo, o modelo precisa então ser calibrado. Isto é, é necessário encontrar a melhor combinação de valores que descrevem a realidade para os parâmetros presente no modelo. A primeira opção que surge naturalmente é utilizar o conhecimento de especialistas, porém nem sempre isto é o suficiente. Outras opções que podem ser exploradas são experimentar muitos diferentes valores (o que se torna mais difícil a medida que a quantidade de parâmetros aumenta) e/ou utilizar técnicas de inteligência artificial para obter os melhores parâmetros automaticamente (por exemplo algoritmo genético).
 +
 
 +
'''Validação''': Por fim então nos resta apenas validar, isto é, saber se o modelo funciona. Isto comumente implica em saber se é possível replicar quantitativamente algum dado ou padrão conhecido, logo, é importante saber exatamente no que estamos interessados em olhar.
 +
 
 +
Nesta etapa então podem ser utilizando alguns métodos para comparar os erros quantitativos dos dados obtidos através contra dados reais. Isto pode ser feito por exemplo simplesmente calculando diretamente a diferença absoluta entre ambos os valores ou utilizando técnicas estatísticas mais robustas. Pode-se utilizar matrizes de confusão, estatística difusa, análise multiescala, etc...
 +
 
 +
Pode-se por exemplo comparar as predições corretas obtidas a partir do modelo com predições corretas caso estas fossem feitas aleatoriamente. Desta forma podemos comparar se conseguimos fazer uma previsão melhor através do nosso modelo, do que se fosse feita aleatoriamente. Porém esta não parece uma comparação justa uma vez que os modelos foram iniciados com dados reais e um padrão real, então outra alternativa é pegar um estado passado e tratar como uma previsão, se nosso modelo não consegue fazer melhor que isso, temos um problema.
 +
 
 +
'''Erros''': Apesar de tudo, os erros não necessariamente são frutos apenas de erros do modelo. É possível também que existam erros nos dados do mundo real. Mas de toda forma, é necessário sabermos se o modelo é uma versão razoável da realidade para a variável que queremos observar. Também precisamos saber como o sistema responde para pequenos erros nos dados de entrada. Pois precisamos ter certeza se o modelo não é razoável para apenas um conjunto de dados de entrada.
 +
 
 +
Então podemos por exemplo causar pequenas variações nas principais variáveis e observar como o modelo responde. Ele pode ser ergodico, isto é, insensível para as condições iniciais após a simulação ser executada por tempo suficiente, ou responder fortemente às condições iniciais. Nestes último caso precisamos saber se é assim que o sistema real responde ou apenas um artefato do modelo. Se responde fortemente, talvez a predição seja comprometida caso os dados de entrada não sejam perfeitamente acurados e pode ser preciso analisar se a propagação do erro é um problema.
 +
 
 +
Para entender melhor a gama de respostas a diferentes entradas, podemos utilizar alguma randomização. Em geral isto é feito utilizando entradas aleatórias e então é feito uma amostragem ponderada pela distribuição chamada amostragem de Monte-Carlo (''Monte Carlo Sampling''). Executando o modelo múltiplas vezes é possível obter uma distribuição de saída probabilística.
 +
 
 +
;<span>Análise:</span>
 +
:Por fim, os modelos não são apenas para realizar predições. Podem ser utilizados também para experimentar e testar ideias preexistentes, assim como também para obter novas ideias.
 +
 
 +
===Modelo de crime===
 +
 
 +
Esse é um modelo de ’polícia e ladrão’, onde os ladrões andam aleatoriamente no espaço procurando por bancos para roubarem e também roubam uns aos outros, e os policiais andam aleatoriamente tomando o ouro dos ladrões e os removendo da simulação, isto é, prendendo. Um modelo mais sofisticado poderia ter decisões mais elaborados de quem e quando roubar porém este modelo serve como inspiração à esta introdução. Tanto a introdução à modelo baseado em indivíduos, quanto este modelo foram inspirados no texto ''Agent Based Modelling: Introduction'', que possui uma versão em Java deste modelo.<pre>
 +
/*
 +
Exemplo de modelo baseado em indivíduos
 +
Autor:          Jhordan Silveira de Borba
 +
*/
 +
 
 +
using System;              //Namespace padrão System
 +
using System.Collections.Generic; //Para usar listas
 +
 
 +
namespace Vida_selvagem_e_Pecuária
 +
{
 +
    class Agente
 +
    {
 +
        public int ID;                                    //Identificação
 +
        public int x;                                    //Coordenadas espaciais
 +
        public int y;
 +
        public int ouro;                                  //Dinheiro
 +
        public string nome;                              //Que tipo de agente é
 +
        public List<Agente> Agentes = new List<Agente>(); //Lista de todos os agentes
 +
        public int[,] ambiente;                          //Configuraçõe do ambiente
 +
        public int largura;
 +
        public int altura;
 +
        public bool serRemovido = false;                //Se o a gente foi preso
 +
        public Random rnd;
 +
 
 +
        //Método para mover o agente
 +
        public void Mover()
 +
        {
 +
            x += (rnd.NextDouble() < 0.5) ? -1 : 1; //Mover aleatoriamente para os lados
 +
            y += (rnd.NextDouble() < 0.5) ? -1 : 1; //Mover aleatoriamente para cima e baixo
 +
            //Obs.: Ele se move mais rápido na diagonal, pois o desloamento tem módulo maior que 1
 +
            //Checar as fronteiras
 +
            x = (x < 0) ? 0 : x;
 +
            x = (x >= largura) ? largura - 1 : x;
 +
            y = (y < 0) ? 0 : y;
 +
            y = (y >= altura) ? altura - 1 : y;
 +
           
 +
        }
 +
        //Método para roubar
 +
        public void Agir()
 +
        {
 +
            if (serRemovido == true) { return; } //Se o agentee está sendo removido, nao faz nada
 +
            if (nome == "ladrao")                //Interação com ambiente: se o agente atual é ladrão, checa a posição por ouro para roubar
 +
            {
 +
                if (ambiente[x, y] > 0)
 +
                {
 +
                    ouro += ambiente[x, y];
 +
                    ambiente[x, y] = 0;
 +
                }
 +
            }
 +
            foreach (Agente A in Agentes)      //Interação com outros agentes:
 +
            {
 +
                if (A.ID == ID) { continue; }  //Se for o prórprio agente
 +
                if ((A.x == x) && (A.y == y))
 +
                {
 +
                    if (A.nome == "ladrao")    //Se o outro agente não é policial, toma dinheiro dele
 +
                    {
 +
                        ouro = ouro + A.ouro;
 +
                        A.ouro = 0;
 +
                    }
 +
                    //Se o atual agente é policial e o outro é ladrão, deve ser removido
 +
                    A.serRemovido = (nome == "policial" && A.nome == "ladrao") ? true : false;
 +
                }
 +
            }
 +
        }
 +
    }
 +
 
 +
    class Modelo
 +
    {
 +
        private int nagentes = 100; //Número de agentes
 +
        private int it = 100;        // Número de iterações
 +
        private double ppol = 0.1;  //Probabilidade de ser gerado um policial
 +
        private double pbanco = 0.1;//Probabilidade de ser gerado um banco
 +
        private int dbanco = 10;    //Dinheiro no banco
 +
        private int largura = 100;  //Largura do espaço
 +
        private int altura = 100;  //altura o espaço
 +
        private int cont = 0;      //Contador de agentes
 +
        private Random rnd;
 +
        List<Agente> Agentes = new List<Agente>();
 +
        public Modelo() //Construto
 +
        {
 +
            rnd = new Random();                  //Números aleatórios
 +
            int[,] ambiente = new int[largura, altura];  //Criar os bancos
 +
            for (int i = 0; i < largura; i++)
 +
            {
 +
                for (int j = 0; j < altura; j++)
 +
                {
 +
                    ambiente[i, j] = (rnd.NextDouble() < pbanco) ? dbanco : 0;
 +
                }
 +
            }
 +
            for (int i = 0; i < nagentes; i++)                                  //Criar os agentes
 +
            {
 +
                Agente ag = new Agente() { ID = cont };
 +
                cont      += 1;
 +
                ag.x        = (int)(rnd.NextDouble() * largura);                //Posição inicial aleatória
 +
                ag.y        = (int)(rnd.NextDouble() *  altura);
 +
                ag.ambiente = ambiente;                                        //Configura o ambiente
 +
                ag.largura  = largura;
 +
                ag.altura  = altura;
 +
                ag.Agentes  = Agentes;                                          //Conhece outros agentes
 +
                ag.nome    = (rnd.NextDouble() < ppol) ? "policial" : "ladrao"; //Policia ou Ladrão
 +
                ag.rnd      = rnd;
 +
                Agentes.Add(ag);                                                //Adiciona à lista
 +
            }
 +
            for (int i = 0; i < it; i++)                //Roda a simulação
 +
            {
 +
                foreach (Agente A in Agentes)            //Move cada agente
 +
                {
 +
                    A.Mover();
 +
                }
 +
                foreach (Agente A in Agentes)
 +
                { A.Agir(); }                            //Cada agente age
 +
                //Expressão lambda: um método anônimo. Exemplo:  x => x + 1, basicamente recebe x, e retorna x+1
 +
                //Predicado: Recebe um parâmetro e retorna verdadeiro ou falso. Exemplo: Predicate<int> isOne = x => x == 1, recebe x e retorna verdadeiro se x==1
 +
                //Predicate<Agente> pred = (Agente obj) => obj.serRemovido == true;  //Removemos os agentes fora do foreach, pra não acessar elemento que não existes
 +
                Agentes.RemoveAll((Agente obj) => obj.serRemovido == true);          //Removemos os agentes
 +
            }
 +
            //Estatísticas
 +
            int cpol = 0;  //Quantos policiais tem
 +
            int dpol = 0;  //Quanto dinheiro os policiais acumularam
 +
            int clad = 0;  //Quantos ladroes tem
 +
            int dlad = 0;  //Quanto dinheiro os ladrões acumularam
 +
            foreach (Agente A in Agentes)
 +
            {
 +
            if (A.nome=="policial")
 +
                {
 +
                    cpol += 1;
 +
                    dpol += A.ouro;
 +
                }
 +
            else
 +
                {
 +
                    clad += 1;
 +
                    dlad += A.ouro;
 +
                }
 +
            }
 +
            Console.Write("Após " + it + " interações, há ");
 +
            Console.Write(cpol + " policiais com " + dpol + " ouro e ");
 +
            Console.Write(clad + " ladroes com " + dlad + " ouro.\n");
 +
        }
 +
    }
 +
    class Program
 +
    {
 +
        static void Main()
 +
        {
 +
          new Modelo();      //Inicia o modelo
 +
          //Console.ReadKey();
 +
        }
 +
    }
 +
}
 +
</pre>
 +
 
 +
 
 +
== Referências utilizadas ==
 +
<references />
 +
== Principal material utilizado ==
 +
 
 +
# [https://www.geog.leeds.ac.uk/courses/other/crime/abm/general-modelling/index.html Agent Based Modelling: Introduction] (Nick Malleson e Andy Evans ,Universidade de Leeds)
 +
# [http://wgbis.ces.iisc.ac.in/energy/HC270799/ibm.html Individual-Based Models] (Craig Reynolds, Instituto Indiano de Ciências)
 +
# [https://www.researchgate.net/publication/263746066_Individual-based_models_in_ecology_after_four_decades Individual-Basd Models and Approaches on Ecology] ( Editores: DonaldL. DeAngelis e Louis J. Gross). Artigo: From Local to Global: The Lesson of Cellular Automata (M.J.Phipps , Universidade de Ottawa)
 +
 
 +
 
 +
{{Ecologia| [[Simulação e modelo de campo médio ]] |[[Por que usar e o que são modelos baseados em indivíduos]]}}

Edição atual tal como às 14h19min de 3 de agosto de 2021

Anterior: Simulação e modelo de campo médio | Índice: Ecologia | Próximo: Por que usar e o que são modelos baseados em indivíduos


Sociedades artificiais são modelos da sociologia computacional que são utilizados em análises sociais utilizando simulações computacionais, é um tema bastante conectado à sistemas complexos, desta forma se aproxima dos nossos modelos ecológicos.

Dentre as simulações computacionais utilizadas temos: algoritmos evolucionários (evolutionary algorithms - EA), algoritmos genéticos (genetic algorithms - GA), programação genética (genetic programming - GP), programação memetica (memetic programming - MP), modelos baseados em agentes (agent based model - ABMs) e autômatos celulares (cellular automata - CA). Estes dois últimos são de especial interesse para nós.

Autômatos celulares

Autômatos celulares consistem em uma grade de células, onde cada uma está em um estado possível dentro de um conjunto finito de estados. Utilizando como exemplo para discussões posteriores o modelo de 2 herbívoros com dinâmica de destruição do sistema, os possíveis estados de cada célula são:

  1. D - Destruído
  2. L - Livre
  3. O - Ocupado por ovelha
  4. G - Ocupado por guanaco
  5. OG - Ocupado por ovelhas e guanacos

Associado a cada célula temos um conjunto de células que são definidas em relação à esta célula específica, este conjunto recebe o nome de vizinhança. No nosso exemplo definimos como os 4 primeiros vizinhos da célula. Definimos um estado inicial para todas as células e temos uma nova geração em onde aplicamos uma regra de transição que determina o novo estado de um célula baseada em seu próprio estado atual e no estado das células vizinhas. Em geral as regras para atualização são as mesmas para cada células durante toda a simulação e é aplicado em toda a grade simultaneamente (síncrono). Algumas coisas que podem ser interessantes é mencionar que para o autômato celular, o espaço, o tempo e os estados são todos discretizados. Podemos comparar com outros sistemas dinâmicos espacialmente estendidos em termos da discretização destes três elementos[1]:


Modelo Espaço Tempo Estado
Autômato celular D D D
Rede de mapas acoplados (CML) D D C
Equação diferenciais ordinárias acopladas D C C
Equação diferencial parcial C C C

Onde D significa que é discreto e C que é contínuo, CML significa coupled map lattices.Também é interessante de se destacar aqui, é que matemática e ciência computacional são disciplinas básicas para o autômato celular, então estamos efetivamente utilizando estes conjuntos de conhecimentos como ferramentas e expandindo um pouco nossos recursos disponíveis. Utilizando não mais apenas a matemática tradicional, mas também a ciência da computação. O que explica um pouco alguns problemas de nomenclatura e definições de termos que podem ser encontrados ao longo dos textos, aos poucos estes devem ser corrigidos conforme o próprio conhecimento vai sendo amadurecido.

Investigações teóricas de CA geralmente consistem em pegar uma dada regra e descobrir propriedades matemáticas relacionadas. Mas a maior parte das aplicações em ciências naturais seguem uma aproximação inversa, ou seja, busca-se descobrir a regra que reproduz as propriedades conhecidas que governam o fenômeno estudado.

Além disto, as regras de transições podem ser determinísticas ou estocásticas. Como os termos sugerem, no caso determinístico o novo estado de cada célula é determinado rigidamente baseado no estado presente da própria célula e no estado das células vizinhas. No caso estocástico (também chamado de autômato celular probabilístico) a seleção do estado da célula em cada tempo é sujeita a uma função probabilística, esta regra de transição oferece uma melhor analogia a sistemas naturais e também é o caso do nosso exemplo.

Além disso classicamente se discute quatro classes de comportamentos que podem ser reproduzidos por um autômato celular elementar, eles são qualitativamente caracterizados como:

  • Classe 1: a evolução leva a um estado homogêneo; depois de um certo tempo, todas as células possuem um estado similar, independente do estado inicial.
  • Classe 2: a evolução leva a um conjunto de estruturas separadas simples ou periódicas; uma organização espacial surge com distintos domínios espaciais que podem ser homogêneos e estáveis ou periódico com alteração dos estados.
  • Classe 3: evolução leva a um padrão caótico; independente das condições iniciais o autômato celular leva a padrões aperiódicos em que não podem ser identificados qual foi o padrão inicial
  • Classe 4: evolução leva a estruturas complexas, algumas vezes com tempo de vida; nessa classe surge alguns padrões espaciais complexos que podem durar por um tempo específico, esses padrões possuem propagação espacial enquanto mantém uma conservação do seu formato.

Sem realizar análises detalhadas, aparentemente o exemplo que escolhemos pertence à classe 2. Claro que esta classificação é que com os parâmetros utilizados no artigo que levam o sistema à um regime oscilatório. Com outros parâmetros que levaria o sistema à uma extinção total por exemplo, teríamos uma classe 1.

A literatura ecológica que lida com autômatos celulares em sua maioria está de alguma forma relacionado à questão da heterogeneidade espacial. Alguns trabalhos buscam responder como os processos biológicos respondem a uma heterogeneidade preexistente. Pensando no outro modelo com a destruição fixa, este tinha como objetivo estudar como o sistema evolui a partir de uma distribuição fixa das células destruídas no início. Outra classe de trabalhos busca a resposta inversa: como os processos biológicos podem criar heterogeneidade. Neste caso, podemos lembrar do próprio exemplo, onde estuda-se como a dinâmica produz as ondas de desertificação.

Além disso vale destacar que as interações em um CA são de curto alcance, o que é negligenciado em modelos de campo médio por exemplo. Outras características importantes e interessantes de um modelo de autômato celular são as capacidades de auto-manutenção e auto-organização.

Em todas aplicação de CA na ecologia, cada célula é considerado um espaço para um indivíduo biológico. No nosso exemplo cada ’indivíduo biológico’ ganha a interpretação de uma metapopulação de cada espécie, isto pode representar um indivíduo ou uma manada, não há distinções do tamanho desta metapopulação. Desta forma cada célula tem nos seus estados a informação, como comentamos anteriormente, apenas se ela está ocupada ou não por aquela espécie, mas não admite uma variação de indivíduos dentro da mesma célula, isto é, não admite variar o tamanho da metapopulação que ocupa cada célula. Não é claro como o CA determinístico poderia incorporar esta variação individual, mas é perfeitamente concebível utilizando uma regra de transição estocástica. Isto poderia ser feito por exemplo, variando a probabilidade de adotar determinado estado, desta forma um modelo de CA pode ser utilizado com o objetivo de construir um modelo baseado em indivíduos. Esta é uma alternativa.

Modelos baseados em agentes

Modelos baseados em agentes são modelos computacionais para simular ações e interações entre agentes autônomos, estes modelos são mais intuitivos que modelos matemáticos ou estatísticos, uma vez que representam objetos como nós vemos: coisas individuais no mundo. Os exemplos mais familiares para muitas pessoas são os jogos The SIMS ou SIMCity.

Na ecologia estes modelos também são chamados de modelos baseados em indivíduos (individual-based models - IBMs), modelo baseado em entidades ou simulações baseadas em indivíduos/entidades/agentes. Além disso há uma discussão sem nenhuma resposta conclusiva na literatura e entre profissionais envolvidos se modelos baseados em agentes são a mesma coisa que sistemas multi-agentes (multi-agent system - MAS), ou se não são, então onde começaria um e terminaria outro, algumas autores ainda consideram IBMs como modelos pertencente à classe de modelos MAS. Para o resto do texto, se necessário vou considerar sistema de multi-agentes apenas como outro nome para modelo baseado em indivíduo[2]. Porém parece que MAS é um termo predominantemente das áreas baseadas em ciência computacionais e normalmente possui o propósito de resolver um problema real ou completar uma tarefa, um exemplo são redes de telecomunicação. Enquanto IBMs normalmente estão relacionados a ciências naturais como ecologia e ciência sociais, sendo predominantemente pesquisas sobre sistemas naturais em que a simulação tem por objetivo observar o comportamento coletivo dos agentes, mais que resolver um problema em específico[3][4].

Os modelos baseados em indivíduos historicamente evoluíram a partir dos autômatos celulares. Ainda explorando um pouco sua história nos anos 1990 houve uma grande expansão nas ciências sociais, e um os primeiros modelos úteis de autômatos celulares foi proposto por um cientista social e reimplementado muitas vezes em modelos IBM. Há três ideias centrais nos IBMs: agentes, emergencia e complexidade.

  • Agentes são os objetos que interagem seguindo algumas regras, tipicamente estão situados no espaço e residem em uma rede ou uma vizinhança tipo grade. Em alguns casos, como na ecologia, os agentes podem ser considerados como inteligentes e/ou com propósitos.
  • Emergencia ocorre quando uma entidade observada possui propriedades que suas partes não possuem. Então esta propriedade emerge somente quando as partes que constituem esta entidade interagem entre si, de forma simples, é algo que não pode ser obtido apenas como uma soma de suas partes.
  • A complexidade caracteriza o comportamento de um modelo em que seus componentes interagem de múltiplas formas e seguem regras locais.

Modelos baseados em agente são então simulações baseadas em consequências globais de interações locais dos membros de uma população. Neste tipo de modelo as características de cada indivíduo é rastreada através do tempo, em contraste com técnicas que caracterizam a população baseado em uma média, como os modelos de campo médio.

Alguns modelos baseados em indivíduos podem ser especialmente explícitos, isto é, os indivíduos estão associados a uma localização em um espaço geométrico, neste caso também podem (mas não necessariamente) exibir mobilidade através do ambiente.

Lembrando do exemplo que escolhemos para exemplificar características dos autômatos celulares, pensando na questão da mobilidade, se lembrarmos dos conceitos de meta-população originalmente proposto no modelo de Levins, não há mobilidade. Cada meta-população vive em determinado fragmento, o que ocorre na colonização é que uma nova geração coloniza um nova célula, mas não se desloca para ela. Na proposta original, a meta-população não possui mobilidade, ainda que o fenômeno de colonização de uma nova célula e extinção local produza um efeito análogo. Os modelos espacialmente explícitos ainda podem ser contínuos (valores reais) ou discreto (valores inteiros, tipo grade). Este último é o que se aproxima do nosso exemplo. Além disso os modelos também não precisam ser espacialmente explícitos, como uma rede de computadores por exemplo, onde as conexões entre os agentes não precisam estar relacionados a nenhuma localização espacial.

Conforme pode-se perceber, há uma relação entre modelos baseados em indivíduos e autômatos celulares. Conforme discutido enquanto uma célula de um autômato celular assume um estado que basicamente informa se a célula está ocupado ou não por uma espécie, em um modelo baseado em indivíduos podemos ter mais indivíduos ocupando o mesmo fragmento do ambiente e variando a população local de uma mesma espécie em um mesmo fragmento. É claro que podemos adicionar mais estados finitos no autômato celular, ou ainda conforme discutido adaptar as regras estocásticas de transição, mas talvez a diferença mais significativa seja se o loop da simulação procede célula por célula, ou indivíduo por indivíduo.

Mas a verdade é que muitos modelos estão entre CAs e IBMs, em geral uma das principais distinções dos modelos é exatamente se os agentes se movem ou simplesmente parecem se mover porque série de células mudam de estado, a exemplo da discussão que realizamos sobre nosso modelo baseado em autômatos, onde há apenas este movimento aparente. Já em IBMs os agentes que são os objetos no mundo tem posição conhecida e podem efetivamente se mover carregando propriedades auxiliares com eles. Dessa forma uma das vantagens chaves dos IBMs é que o conhecimento interno do agente é mantido com a entidade quando ela se move, enquanto no CA o conhecimento associado não se move. Como os agentes carregam conhecimento consigo, ele pode utilizar o conhecimento e a história para explorar novas áreas e conhecer outros agentes.

Com o desenvolvimento da programação orientada a objetos (Object Orientated Programming - OOP) que de certa forma lembra os conceitos dos IBMs, se tornou razoavelmente mais simples de implementar este tipo de modelo.


Introdução à modelos baseados em indivíduos

Uma coisa interessante sobre os MBIs (modelos baseados em indivíduos) é quão longe podemos ir com relativa simplicidade devido a ascensão da programação orientada a objetos (Object Orientated Programming - OOP ). OOP é uma forma de programar em que o código é dividido em objetos nos quais possuem um trabalho específico para fazer, estes objetos por sua vez são baseados em um modelo chamado “classe”. Essa forma de programar claramente lembra modelos baseados em indivíduos, onde por exemplo, podemos definir uma classe “Agente” e usar para construir múltiplos agentes.

Um ABM clássico usualmente é baseado no seguinte:

  • Agente: Uma classe que contém as variáveis (fields em C#) associadas aos agentes e representando seus estados (nome, idade, localização, etc ) e mais um bloco (ou mais) de códigos que regram a interação com outros agentes. Esse bloco de código é isolado e chamado de procedimentos (métodos em C#), normalmente possui um nome específico com que pode ser chamado para que o agente execute determinadas ações, como por exemplo “mover”.
  • Model: Uma classe que chama os métodos dos agentes para fazê-los agir. É comum que os agentes ajam por um número fixo de vezes e então são interrompidos para que olhemos os estados dos agentes. Ou ainda pode-se definir uma condição de para para que os agentes ajam até que o objetivo seja atingido.

Isso é o suficiente pra construir um modelo simples baseado em agentes, onde os agentes agem baseado nos seus estados internos, mas nesse momento eles não possuem nada para interagir. Por isso, na maioria dos ABM existe algum tipo de ambiente que todos os agentes conhecem. É comum também que cada agente tenha uma lista com todos os agentes com que pode interagir, por exemplos outros agentes que estão próximos do agente em questão. Estas condições do ambiente podem ser incorporadas na classe Model, que muitas vezes também é chamada de “environment” (ambiente).

Quanto a escolha das regras comportamentais que regem a interação dos agentes, podem ser de vários tipos. O ideal é ter uma espécie de inteligência artificial com a tomada de decisão embutida, isto é, algo que tenha a tomada de decisão embutida em um modelo de pensamento e existência mais amplo. E por fim, ainda precisamos equilibrar a complexidade do modelo com a velocidade de processamento.

Modelo de crença-desejo-intenção

Um dos modelos mais famoso é baseado nestes três pilares:

  1. Crenças: fatos sobre o mundo (que podem aparecer no formato de regras).
  2. Desejos: coisas que os agentes querem fazer ou que aconteça.
  3. Intenção: ações que o agente escolhe, geralmente a partir de um conjunto de planos.

Sobre o processo de tomada de decisão pode ser implementado de várias formas. Uma vez que os desejos são objetivos, as decisões poderiam ser tomadas por exemplo:

  • Priorizando o desejo mais importante;
  • Priorizando o plano que permite realizar mais desejos;
  • Priorizando o plano que tem mais chance de dar certo;
  • Seguindo o que a comunidade decidir (através de votação por exemplo);
  • Etc.

Considerações

Evidentemente, há muitas coisas que precisam ser consideradas durante a construção de um modelo baseado em indivíduos, abaixo discutirei algumas destas coisas.

Hardware: Como são modelos computacionais, uma das preocupações naturalmente é sobre onde os modelos vão ser executados. Os modelos variam muito no processamento exigido, sendo necessário desde minutos a dias. Da mesma forma há também uma variação na quantidade de espaço de armazenamento que é necessário. Uma solução que pode ser implementada principalmente para lidar com o poder computacional que é necessário é a paralelização. Neste caso ainda há uma nova questão que precisa ser respondida: como o modelo pode ser dividido? Se os agentes fossem estáticos poderiam ser divididos em fragmentos geográficos, se os agentes não se comunicassem a divisão poderia ser por agentes. Mas na maioria dos modelos os agentes tanto se movem quanto se comunicam, então em algum momento será necessário permitir que os agentes se movimentem entre os fragmentos e/ou se comuniquem com agentes de outros nós.

Espaço: O modelo é uma abstração da realidade, portanto não é inesperado que uma questão importante seja como esta abstração será feita. Isto é uma questão que começa desde a decisão sobre o tipo de fronteira que o modelo vai incorporar (infinitas, limitadas, etc), passa pela organização interna do próprio espaço (contínuo, em grade, rede, etc), e vai até sobre como a vizinhança é organizada. Pra citar alguns exemplos, nos nossos modelos baseados em autômatos celulares, foi escolhido uma vizinhança do tipo Von Neumann (diamante), mas poderia ser do tipo Moore (quadrado). Em um modelo contínuo poderia ser baseado na distância euclidiana dada por:

Sincronização: Discutindo sobre execução da simulação em si, uma preocupação que surge é a questão de sincronização, isto é, em que ordem os os agentes devem agir e quando. Sobre quando agir a opção mais simples é agir a cada intervalo específico de tempo. Apesar desta opção ser a mais simples, quando temos muitos agentes inativos pode ser pouco eficiente, desta forma outra opção é baseado em eventos específicos (por exemplo, quando é tocado por outro agente). Sobre a ordem uma opção usual é randomizar a ordem.

Calibração: Tendo já resolvido os problemas relacionados ao hardware necessário e a modelagem do próprio modelo, o modelo precisa então ser calibrado. Isto é, é necessário encontrar a melhor combinação de valores que descrevem a realidade para os parâmetros presente no modelo. A primeira opção que surge naturalmente é utilizar o conhecimento de especialistas, porém nem sempre isto é o suficiente. Outras opções que podem ser exploradas são experimentar muitos diferentes valores (o que se torna mais difícil a medida que a quantidade de parâmetros aumenta) e/ou utilizar técnicas de inteligência artificial para obter os melhores parâmetros automaticamente (por exemplo algoritmo genético).

Validação: Por fim então nos resta apenas validar, isto é, saber se o modelo funciona. Isto comumente implica em saber se é possível replicar quantitativamente algum dado ou padrão conhecido, logo, é importante saber exatamente no que estamos interessados em olhar.

Nesta etapa então podem ser utilizando alguns métodos para comparar os erros quantitativos dos dados obtidos através contra dados reais. Isto pode ser feito por exemplo simplesmente calculando diretamente a diferença absoluta entre ambos os valores ou utilizando técnicas estatísticas mais robustas. Pode-se utilizar matrizes de confusão, estatística difusa, análise multiescala, etc...

Pode-se por exemplo comparar as predições corretas obtidas a partir do modelo com predições corretas caso estas fossem feitas aleatoriamente. Desta forma podemos comparar se conseguimos fazer uma previsão melhor através do nosso modelo, do que se fosse feita aleatoriamente. Porém esta não parece uma comparação justa uma vez que os modelos foram iniciados com dados reais e um padrão real, então outra alternativa é pegar um estado passado e tratar como uma previsão, se nosso modelo não consegue fazer melhor que isso, temos um problema.

Erros: Apesar de tudo, os erros não necessariamente são frutos apenas de erros do modelo. É possível também que existam erros nos dados do mundo real. Mas de toda forma, é necessário sabermos se o modelo é uma versão razoável da realidade para a variável que queremos observar. Também precisamos saber como o sistema responde para pequenos erros nos dados de entrada. Pois precisamos ter certeza se o modelo não é razoável para apenas um conjunto de dados de entrada.

Então podemos por exemplo causar pequenas variações nas principais variáveis e observar como o modelo responde. Ele pode ser ergodico, isto é, insensível para as condições iniciais após a simulação ser executada por tempo suficiente, ou responder fortemente às condições iniciais. Nestes último caso precisamos saber se é assim que o sistema real responde ou apenas um artefato do modelo. Se responde fortemente, talvez a predição seja comprometida caso os dados de entrada não sejam perfeitamente acurados e pode ser preciso analisar se a propagação do erro é um problema.

Para entender melhor a gama de respostas a diferentes entradas, podemos utilizar alguma randomização. Em geral isto é feito utilizando entradas aleatórias e então é feito uma amostragem ponderada pela distribuição chamada amostragem de Monte-Carlo (Monte Carlo Sampling). Executando o modelo múltiplas vezes é possível obter uma distribuição de saída probabilística.

Análise:
Por fim, os modelos não são apenas para realizar predições. Podem ser utilizados também para experimentar e testar ideias preexistentes, assim como também para obter novas ideias.

Modelo de crime

Esse é um modelo de ’polícia e ladrão’, onde os ladrões andam aleatoriamente no espaço procurando por bancos para roubarem e também roubam uns aos outros, e os policiais andam aleatoriamente tomando o ouro dos ladrões e os removendo da simulação, isto é, prendendo. Um modelo mais sofisticado poderia ter decisões mais elaborados de quem e quando roubar porém este modelo serve como inspiração à esta introdução. Tanto a introdução à modelo baseado em indivíduos, quanto este modelo foram inspirados no texto Agent Based Modelling: Introduction, que possui uma versão em Java deste modelo.
/*
Exemplo de modelo baseado em indivíduos
Autor:           Jhordan Silveira de Borba
*/

using System;               //Namespace padrão System
using System.Collections.Generic; //Para usar listas

namespace Vida_selvagem_e_Pecuária
{
    class Agente
    {
        public int ID;                                    //Identificação
        public int x;                                     //Coordenadas espaciais
        public int y;
        public int ouro;                                  //Dinheiro
        public string nome;                               //Que tipo de agente é
        public List<Agente> Agentes = new List<Agente>(); //Lista de todos os agentes
        public int[,] ambiente;                           //Configuraçõe do ambiente
        public int largura;
        public int altura;
        public bool serRemovido = false;                 //Se o a gente foi preso
        public Random rnd;

        //Método para mover o agente
        public void Mover()
        {
            x += (rnd.NextDouble() < 0.5) ? -1 : 1; //Mover aleatoriamente para os lados
            y += (rnd.NextDouble() < 0.5) ? -1 : 1; //Mover aleatoriamente para cima e baixo
            //Obs.: Ele se move mais rápido na diagonal, pois o desloamento tem módulo maior que 1
            //Checar as fronteiras
            x = (x < 0) ? 0 : x;
            x = (x >= largura) ? largura - 1 : x;
            y = (y < 0) ? 0 : y;
            y = (y >= altura) ? altura - 1 : y;
            
        }
        //Método para roubar
        public void Agir()
        {
            if (serRemovido == true) { return; } //Se o agentee está sendo removido, nao faz nada
            if (nome == "ladrao")                //Interação com ambiente: se o agente atual é ladrão, checa a posição por ouro para roubar
            {
                if (ambiente[x, y] > 0)
                {
                    ouro += ambiente[x, y];
                    ambiente[x, y] = 0;
                }
            }
            foreach (Agente A in Agentes)       //Interação com outros agentes: 
            {
                if (A.ID == ID) { continue; }   //Se for o prórprio agente
                if ((A.x == x) && (A.y == y))
                {
                    if (A.nome == "ladrao")     //Se o outro agente não é policial, toma dinheiro dele
                    {
                        ouro = ouro + A.ouro;
                        A.ouro = 0;
                    }
                    //Se o atual agente é policial e o outro é ladrão, deve ser removido
                    A.serRemovido = (nome == "policial" && A.nome == "ladrao") ? true : false;
                }
            }
        }
    }

    class Modelo
    {
        private int nagentes = 100; //Número de agentes
        private int it = 100;        // Número de iterações
        private double ppol = 0.1;  //Probabilidade de ser gerado um policial
        private double pbanco = 0.1;//Probabilidade de ser gerado um banco
        private int dbanco = 10;    //Dinheiro no banco
        private int largura = 100;  //Largura do espaço
        private int altura = 100;   //altura o espaço
        private int cont = 0;       //Contador de agentes
        private Random rnd;
        List<Agente> Agentes = new List<Agente>();
        public Modelo() //Construto
        {
            rnd = new Random();                   //Números aleatórios
            int[,] ambiente = new int[largura, altura];  //Criar os bancos
            for (int i = 0; i < largura; i++)
            {
                for (int j = 0; j < altura; j++)
                {
                    ambiente[i, j] = (rnd.NextDouble() < pbanco) ? dbanco : 0;
                }
            }
            for (int i = 0; i < nagentes; i++)                                  //Criar os agentes
            {
                Agente ag = new Agente() { ID = cont };
                cont       += 1;
                ag.x        = (int)(rnd.NextDouble() * largura);                //Posição inicial aleatória
                ag.y        = (int)(rnd.NextDouble() *  altura);
                ag.ambiente = ambiente;                                         //Configura o ambiente
                ag.largura  = largura;
                ag.altura   = altura;
                ag.Agentes  = Agentes;                                           //Conhece outros agentes
                ag.nome     = (rnd.NextDouble() < ppol) ? "policial" : "ladrao"; //Policia ou Ladrão
                ag.rnd      = rnd;
                Agentes.Add(ag);                                                 //Adiciona à lista
            }
            for (int i = 0; i < it; i++)                //Roda a simulação
            {
                foreach (Agente A in Agentes)            //Move cada agente
                {
                    A.Mover();
                }
                foreach (Agente A in Agentes)
                { A.Agir(); }                            //Cada agente age
                //Expressão lambda: um método anônimo. Exemplo:  x => x + 1, basicamente recebe x, e retorna x+1
                //Predicado: Recebe um parâmetro e retorna verdadeiro ou falso. Exemplo: Predicate<int> isOne = x => x == 1, recebe x e retorna verdadeiro se x==1
                //Predicate<Agente> pred = (Agente obj) => obj.serRemovido == true;   //Removemos os agentes fora do foreach, pra não acessar elemento que não existes
                Agentes.RemoveAll((Agente obj) => obj.serRemovido == true);           //Removemos os agentes
            }
            //Estatísticas
            int cpol = 0;   //Quantos policiais tem
            int dpol = 0;   //Quanto dinheiro os policiais acumularam
            int clad = 0;   //Quantos ladroes tem
            int dlad = 0;   //Quanto dinheiro os ladrões acumularam
            foreach (Agente A in Agentes)
            {
            if (A.nome=="policial")
                {
                    cpol += 1;
                    dpol += A.ouro;
                }
            else
                {
                    clad += 1;
                    dlad += A.ouro;
                }
            }
            Console.Write("Após " + it + " interações, há ");
            Console.Write(cpol + " policiais com " + dpol + " ouro e ");
            Console.Write(clad + " ladroes com " + dlad + " ouro.\n");
        }
    }
    class Program
    {
        static void Main()
        {
           new Modelo();       //Inicia o modelo
           //Console.ReadKey();
        }
    }
}


Referências utilizadas

  1. Coupled maps (Kunihiko Kaneko e Tatsuo Yanagita, Scholarpedia)
  2. Encyclopedia of Complexity and Systems Science (Editor: Robert A. Meyers). Artigo: Agent Based Modeling andSimulation, Introduction to (Cilipo Castiglione, Conselho Nacional de Pesquisa da Itália)
  3. Discussão aberta no Research Gate
  4. Agent-based computing from multi-agent systems to agent-based models: a visual survey (Niazi Muaz e Amir Hussain, Scientometrics)

Principal material utilizado

  1. Agent Based Modelling: Introduction (Nick Malleson e Andy Evans ,Universidade de Leeds)
  2. Individual-Based Models (Craig Reynolds, Instituto Indiano de Ciências)
  3. Individual-Basd Models and Approaches on Ecology ( Editores: DonaldL. DeAngelis e Louis J. Gross). Artigo: From Local to Global: The Lesson of Cellular Automata (M.J.Phipps , Universidade de Ottawa)


Anterior: Simulação e modelo de campo médio | Índice: Ecologia | Próximo: Por que usar e o que são modelos baseados em indivíduos