Física Computacional - Contribuições do usuário [pt-br]

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T23:24:45Z

Bleo: /* Simulação de Mercados de Ações e o Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>Modelo de Ising[https://en.wikipedia.org/wiki/Ising_model]</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a magnitude de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tendem a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas visões em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo de interação é tomado como uma constante <math>J_{ij} = 1</math> para vizinhos e <math>J_{ij} = 0</math> para os demais spins, e ele é responsável pela indução de ordem ferromagnética local.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>. Podemos interpretar a temperatura nesse sistema como se fosse a velocidade com que as transações acontecem: para uma temperatura baixa, os agentes trocariam suas estratégias mais devagar, por exemplo. A temperatura no caso deste modelo, vai ditar a distribuição de estratégias: para uma temperatura baixa, as estratégias associadas ao spin up dominarão; já para uma temperatura mais elevada, as estratégias associadas ao spin down predominarão.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T23:21:03Z

Bleo: /* Introdução */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>Modelo de Ising[https://en.wikipedia.org/wiki/Ising_model]</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a magnitude de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tendem a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo de interação é tomado como uma constante <math>J_{ij} = 1</math> para vizinhos e <math>J_{ij} = 0</math> para os demais spins, e ele é responsável pela indução de ordem ferromagnética local.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>. Podemos interpretar a temperatura nesse sistema como se fosse a velocidade com que as transações acontecem: para uma temperatura baixa, os agentes trocariam suas estratégias mais devagar, por exemplo. A temperatura no caso deste modelo, vai ditar a distribuição de estratégias: para uma temperatura baixa, as estratégias associadas ao spin up dominarão; já para uma temperatura mais elevada, as estratégias associadas ao spin down predominarão.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T23:20:46Z

Bleo: /* Introdução */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>(Modelo de Ising)[https://en.wikipedia.org/wiki/Ising_model]</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a magnitude de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tendem a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo de interação é tomado como uma constante <math>J_{ij} = 1</math> para vizinhos e <math>J_{ij} = 0</math> para os demais spins, e ele é responsável pela indução de ordem ferromagnética local.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>. Podemos interpretar a temperatura nesse sistema como se fosse a velocidade com que as transações acontecem: para uma temperatura baixa, os agentes trocariam suas estratégias mais devagar, por exemplo. A temperatura no caso deste modelo, vai ditar a distribuição de estratégias: para uma temperatura baixa, as estratégias associadas ao spin up dominarão; já para uma temperatura mais elevada, as estratégias associadas ao spin down predominarão.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T23:17:54Z

Bleo: /* Introdução */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>Modelo de Ising[https://en.wikipedia.org/wiki/Ising_model]</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a magnitude de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tendem a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo de interação é tomado como uma constante <math>J_{ij} = 1</math> para vizinhos e <math>J_{ij} = 0</math> para os demais spins, e ele é responsável pela indução de ordem ferromagnética local.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>. Podemos interpretar a temperatura nesse sistema como se fosse a velocidade com que as transações acontecem: para uma temperatura baixa, os agentes trocariam suas estratégias mais devagar, por exemplo. A temperatura no caso deste modelo, vai ditar a distribuição de estratégias: para uma temperatura baixa, as estratégias associadas ao spin up dominarão; já para uma temperatura mais elevada, as estratégias associadas ao spin down predominarão.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Keller-Segel para relação população-economia

2021-05-26T23:11:33Z

Bleo: /* Discussão */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>, que originalmente descreve o movimento de células em direção a um sinal químico, para um sistema englobando população e atividade econômica, problema proposto no livro ''Introduction to the Modeling and Analysis of Complex Sistems '' de Hiroki Sayama <ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref>. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space''), método de resolução de equações diferenciais parciais, como a equação do calor e a da difusão, que é o caso deste trabalho.

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'', a taxa com que as células se movem em direção ao sinal químico, tem papel crítico na auto-organização das células. <ref name = 'thesis'> Hoffmann, F. C. O. Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis , Tese de doutorado. 2017 [https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]</ref>

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas <ref name='sayama'></ref>:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica<ref name='sayama'></ref>:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

O trabalho agora é traduzir essas premissas em equações. O primeiro ponto diz que que padrão não há mudança na população, dessa forma:
:<math>\frac{\partial p}{\partial t} = 0</math>

O segundo ponto nos diz que a economia tem um aumento que depende da quantidade de pessoas, e assim:

:<math>\frac{\partial m}{\partial t} = \alpha p</math>

em que <math>\alpha</math> é a taxa de aumento da atividade econômica per capita.

O terceiro ponto diz que a atividade econômica decai quando não há pessoas, e para isso adicionamos um termo de decaimento na equação:
:<math>\frac{\partial m}{\partial t} = \alpha p - \beta m</math>
em que <math>\beta</math> é a taxa de decaimento da atividade econômica.

O quarto ponto fala que tanto população quanto a atividade econômica difundem, o que uma premissa sobre o movimento espacial. Para isso são adicionados termos de difusão, os Laplacianos, as equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

onde <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da atividade econômica respectivamente.

O quinto e último ponto fala que as pessoas são atraídas pela atividade econômica e assim se movem para áreas que possuem mais dinheiro. Para cumprir essa premissa, a equação do transporte é utilizada:

:<math>
- \nabla \cdot (p \gamma \nabla m)
</math>

em que o gradiente de <math>m</math> é utilizado para obter a velocidade média do movimento da população, sendo <math>\gamma</math> uma constante que afeta essa velocidade.

O sistema de equação final fica da seguinte forma:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos, <ref name='scherer'>Scherer, C. Métodos Computacionais da Física. 2010
</ref>
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de explorar a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

N indica o limite do eixo x. Quanto maior o seu valor, mais demorada fica a simulação. Porém, valores pequenos de N podem gerar resultados inconclusivos.

<math>
\Delta x = 1
</math>

Indica a unidade infinitesimal do eixo x (neste caso, o único eixo do problema).

<math>
\Delta t = 0.3
</math>

Indica quanto tempo cada passo da simulação percorre.

<math>
D_m = 1
</math>

Constante de difusão da função de renda.

<math>
D_p = 1
</math>

Constante de difusão da função de densidade populacional.

<math>
\gamma = 1
</math>

<math>\gamma</math> é um parâmetro intimamente ligado com o movimento da população para regiões com alta concentração de dinheiro. Nas palavras de Sayama,<ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref> indica a "habilidade que as pessoas da rede tem de 'sentir o cheiro' do dinheiro".

<math>
\alpha = 1
</math>

O parâmetro <math>\alpha</math> é utilizado no cálculo de <math>v</math>, como descrito acima, seguindo a fórmula <math>v = \alpha \Delta t</math>. Está relacionado com a velocidade do progresso da economia, ou seja, quão rápido cresce a renda em uma posição da malha através da influência da população.

<math>
\beta = 1
</math>

<math>\beta</math> é utilizado na fórmula <math>\lambda = \beta \Delta t</math>, que indica a taxa de decaimento da renda em regiões da malha com baixa população.

Estes parâmetros foram utilizados pois representam bem a característica do sistema de Keller-Segel que queremos representar: a formação de clusters de população na malha <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>. Uma nova combinação de parâmetros poderia resultar em resultados diferentes, mas que fogem do escopo deste projeto.

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como um anel, onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> \mathcal{C}_1 = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> \mathcal{C}_2 = 80 </math>), em pouco tempo tem a sua renda líquida reduzida, pois o dinheiro decai a uma taxa <math>\beta</math>, como já falado. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a taxa de evolução do sistema monetário em pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de formato gaussiano sob a malha. Por isso, é interessante analisar a solução estacionária (se existir).

Como as equações diferenciais do sistema são dependentes umas das outras (isto é, a equação de m(x,t) depende de p(x,t) e a de p depende de m), a solução não é trivial. Utilizando o Método de Coeficientes a Determinar para solução de equações diferenciais em estado estacionário, conseguimos a seguinte relação genérica, que se mostra útil:

<math> m(x,t) = A_1 e^{- B_1 x^2} + A_2 p(x,t) + A_3 </math>

Onde <math>A_1,A_2,A_3</math> e <math>B_1</math> são constantes que dependem das condições iniciais do problema. Como o objetivo do trabalho não é resolver analiticamente esta EDP, estas constantes não foram calculadas.

Mas a equação acima mostra que, para o estado estacionário, o formato gaussiano obtido era previsto na solução analítica também. Portanto, o resultado obtido apresenta coerência.

Mais um ponto a ser aferido é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior largura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Um cuidado importante na iniciação deste sistema é que, como estamos modelando a densidade populacional, e consideramos que não há perda de população com o tempo, a integral da função p(x,t) deve ser sempre igual a 1. Em t=0, na iniciação do sistema, é necessário implementar esta condição ao problema, para que ela se mantenha durante a simulação. Para isso, basta sortear valores e normalizá-los depois. Um exemplo de código simples em Python que realiza esta operação está indicado abaixo.

<source lang="python">
import numpy as np
N = 100 #Limite no eixo x
p_auxiliar = np.random.rand(N) #Vetor auxiliar
p = p_auxiliar / np.sum(p_auxiliar) #Normalização, para que a soma de p em todo x seja 1
</source>

Esta condição inicial da população se assemelha muito à proposição inicial que Keller e Segel fizeram para um sistema celular, como descrito acima. Temos uma concentração homogênea de <math>p</math> com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se notar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com formato gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao estacionário, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de formato gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

Mais uma vez, como iniciamos aleatoriamente a população, é importante normalizá-la para que a integral seja igual a 1, como dito acima.

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial aleatório do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível mais uma vez a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema entre em um estado com somente um pico de formato gaussiano na população, e um pico na renda, com largura maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

Para a geração da evolução do sistema e do gif, o código utilizado foi o seguinte:
<source lang="python">
L = 100 # Tamanho do Grid
D_p = 0.5 # Coeficiente de difusão de pessoas
D_m = 0.5 # Coeficiente de difusão de dinheiro
ds = 1 # Diferencial Espacial
dt = 0.3 # Diferencial Temporal
alfa = 1.2 # Taxa de produção de economia per capita
beta = 0.03 # Taxa de decaimente da economia
gamma = 1 # Taxa de velocidade com que as pessoas migram em direção ao dinheiro

# CRIA OBJETO DE PARÂMETROS PARA O MODELO #
parametros = ParametrosKellerSegelModel(L, L, D_p, D_m, ds, dt, alfa, beta, gamma)

# INICIALIZA O MODELO COM OS PARÂMETROS #
modelo = KellerSegelModel(parametros)

# GERA CONDIÇÕES INICIAIS A SEREM ESTUDADAS #
condicao_inicial_populacao = np.matrix(np.full((parametros.N_x, parametros.N_x), 1 / (L ** 2)))
condicao_inicial_dinheiro = np.matrix(np.zeros((parametros.N_y, parametros.N_y)))

condicao_inicial_dinheiro[(0, 0)] = 0.125
condicao_inicial_dinheiro[(0, 99)] = 0.125
condicao_inicial_dinheiro[(99, 99)] = 0.125
condicao_inicial_dinheiro[(99, 0)] = 0.125
condicao_inicial_dinheiro[(49, 49)] = 2
condicao_inicial_dinheiro[(49, 69)] = 1
condicao_inicial_dinheiro[(49, 29)] = 1
condicao_inicial_dinheiro[(69, 49)] = 1
condicao_inicial_dinheiro[(29, 49)] = 1

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE GRÁFICO ESTÁTICO
jpeg = JpegTool(nome_imagem = 'comparacao_tempos_pop_eco_2d')

# GERA GRÁFICOS
jpeg.geraJpeg(modelo)

# REINICIALIZA MODELO
modelo = KellerSegelModel(parametros)

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE ANIMACAO #
ani = AnimacaoTool(nome_gif = 'dinamica_pop_eco_2d')

# GERA GIF COM A EVOLUCAO DO MODELO #
ani.geraGif(modelo)
</source>

'''''Código completo se encontra no Github.'''''

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Nas figuras abaixo, sendo a primeira uma figura retirada do livro do Sayama <ref name='sayama'></ref>, e a segunda gerada utilizando o modelo construído, a fim de comparar com a primeira, observa-se, partindo de uma população uniforme na malha e de uma renda aleatoriamente distribuída, a formação de grupos (pontos mais escuros), deste modo provando que o modelo construído chega nos mesmos resultados que a referência.

[[Arquivo:Clusters-keller-segel.png|600px|thumb|center|Fonte: Sayama]]

[[Arquivo:Clusters-pop-renda.png|600px|thumb|center|Clusters obtidos para os casos estudados, sob condições iniciais semelhantes às aplicadas por Sayama na imagem acima. Na imagem, observa-se, assim como na referência, o principal objetivo da aplicação do modelo: a presença de clusters de população sob a malha.]]

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Script para gerar os gifs ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt
import imageio """Biblioteca p/ gerar os gifs. Para instalar: pip install imageio"""
import os

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot_gif(p,m,t,images):
fig,ax = plt.subplots(1,2,figsize=(10,5))

#População
ax[0].set_title("População, t = {}".format(round(t,1)))
ax[0].plot(100*p,color='purple')
ax[0].set_ylabel("%")
ax[0].grid(False)

#Renda
ax[1].set_title("Renda, t = {}".format(round(t,1)))
ax[1].plot(m,color='darkgreen')
ax[1].fill_between(np.arange(m.shape[0]),m,color='green',alpha=0.5,label="Total money: $ {}".format(round(np.sum(m),2)))
ax[1].set_ylabel("$")
ax[1].grid(False)
ax[1].legend()

plt.tight_layout()
plt.savefig(imgname) #Salva o frame do sistema
plt.close()

images.append(imageio.imread(imgname)) #Adiciona a imagem na lista indicada
os.remove(imgname) #Remove a imagem recém criada
time.sleep(0.5)

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0. Varia conforme a condição inicial desejada.
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0. Varia conforme a condição inicial desejada.
m = np.zeros(N)
m[80] = 1

images = [] #Vetor para alocar as imagens que formarão o gif.
for t in np.arange(0,T,dt):
if i % 10 == 0: #Gera 1 imagem a cada 10 iterações, para não gerar um .gif muito pesado.
plot_gif(p,m,t,images)
p,m = FTCS(p,m,k1,k2,l,k3,v)

imageio.mimsave("foo.gif", images,fps=3) #Ajustar fps conforme desejar. Quanto maior, + imagens/segundo

</source>

=== Script para gerar os snapshots do sistema ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot_grid(fig,p,m,i,t,ncols,nrows=2):
#Population
ax_p = fig.add_subplot(nrows,ncols,i+1)
ax_p.set_title("t = {}".format(t),fontsize=18)
ax_p.plot(100*p,color='purple')
ax_p.fill_between(np.arange(N),100*p,color='purple',alpha=0.5)

#Money
ax_m = fig.add_subplot(nrows,ncols,i+1+ncols)
ax_m.set_title("t = {}".format(t),fontsize=18)
ax_m.plot(m,color='darkgreen')
ax_m.fill_between(np.arange(N),m,color='green',alpha=0.5,label="Renda líquida: $ {}".format(round(np.sum(m),2)))
ax_m.legend(fontsize=10)

if i == 0:
ax_p.set_ylabel("%",fontsize=15)
ax_m.set_ylabel("$", fontsize=15)

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0. Varia conforme a condição inicial desejada.
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0. Varia conforme a condição inicial desejada.
m = np.zeros(N)
m[80] = 1

ncols = 5 #Número de colunas da imagem // Número de snapshots
snapshots = np.array([0*dt,5*dt,10*dt,15*dt,20*dt]) #Vetor que aloca os tempos onde serão tirados os snapshots do sistema

fig, big_axes = plt.subplots(nrows=2,ncols=1,figsize=(20,6),sharey=True)
titles = ["População (%)","Renda ($)"]
for row,big_ax in enumerate(big_axes):
big_ax.set_title(titles[row],fontsize=22,y=1.15)
big_ax.axis('off')

count = 0
for t in np.arange(0,T,dt):
if t in snapshots: #Gera 1 imagem a cada 10 iterações, para não gerar um .gif muito pesado.
plot_grid(fig,p,m,count,t,ncols)
count += 1
p,m = FTCS(p,m,k1,k2,l,k3,v)

fig.subplots_adjust(hspace=0.55)
plt.savefig("foo.png")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==

<references/>

Modelo de Keller-Segel para relação população-economia

2021-05-26T23:09:49Z

Bleo: /* 1D */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>, que originalmente descreve o movimento de células em direção a um sinal químico, para um sistema englobando população e atividade econômica, problema proposto no livro ''Introduction to the Modeling and Analysis of Complex Sistems '' de Hiroki Sayama <ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref>. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space''), método de resolução de equações diferenciais parciais, como a equação do calor e a da difusão, que é o caso deste trabalho.

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'', a taxa com que as células se movem em direção ao sinal químico, tem papel crítico na auto-organização das células. <ref name = 'thesis'> Hoffmann, F. C. O. Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis , Tese de doutorado. 2017 [https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]</ref>

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas <ref name='sayama'></ref>:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica<ref name='sayama'></ref>:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

O trabalho agora é traduzir essas premissas em equações. O primeiro ponto diz que que padrão não há mudança na população, dessa forma:
:<math>\frac{\partial p}{\partial t} = 0</math>

O segundo ponto nos diz que a economia tem um aumento que depende da quantidade de pessoas, e assim:

:<math>\frac{\partial m}{\partial t} = \alpha p</math>

em que <math>\alpha</math> é a taxa de aumento da atividade econômica per capita.

O terceiro ponto diz que a atividade econômica decai quando não há pessoas, e para isso adicionamos um termo de decaimento na equação:
:<math>\frac{\partial m}{\partial t} = \alpha p - \beta m</math>
em que <math>\beta</math> é a taxa de decaimento da atividade econômica.

O quarto ponto fala que tanto população quanto a atividade econômica difundem, o que uma premissa sobre o movimento espacial. Para isso são adicionados termos de difusão, os Laplacianos, as equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

onde <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da atividade econômica respectivamente.

O quinto e último ponto fala que as pessoas são atraídas pela atividade econômica e assim se movem para áreas que possuem mais dinheiro. Para cumprir essa premissa, a equação do transporte é utilizada:

:<math>
- \nabla \cdot (p \gamma \nabla m)
</math>

em que o gradiente de <math>m</math> é utilizado para obter a velocidade média do movimento da população, sendo <math>\gamma</math> uma constante que afeta essa velocidade.

O sistema de equação final fica da seguinte forma:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos, <ref name='scherer'>Scherer, C. Métodos Computacionais da Física. 2010
</ref>
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de explorar a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

N indica o limite do eixo x. Quanto maior o seu valor, mais demorada fica a simulação. Porém, valores pequenos de N podem gerar resultados inconclusivos.

<math>
\Delta x = 1
</math>

Indica a unidade infinitesimal do eixo x (neste caso, o único eixo do problema).

<math>
\Delta t = 0.3
</math>

Indica quanto tempo cada passo da simulação percorre.

<math>
D_m = 1
</math>

Constante de difusão da função de renda.

<math>
D_p = 1
</math>

Constante de difusão da função de densidade populacional.

<math>
\gamma = 1
</math>

<math>\gamma</math> é um parâmetro intimamente ligado com o movimento da população para regiões com alta concentração de dinheiro. Nas palavras de Sayama,<ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref> indica a "habilidade que as pessoas da rede tem de 'sentir o cheiro' do dinheiro".

<math>
\alpha = 1
</math>

O parâmetro <math>\alpha</math> é utilizado no cálculo de <math>v</math>, como descrito acima, seguindo a fórmula <math>v = \alpha \Delta t</math>. Está relacionado com a velocidade do progresso da economia, ou seja, quão rápido cresce a renda em uma posição da malha através da influência da população.

<math>
\beta = 1
</math>

<math>\beta</math> é utilizado na fórmula <math>\lambda = \beta \Delta t</math>, que indica a taxa de decaimento da renda em regiões da malha com baixa população.

Estes parâmetros foram utilizados pois representam bem a característica do sistema de Keller-Segel que queremos representar: a formação de clusters de população na malha <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>. Uma nova combinação de parâmetros poderia resultar em resultados diferentes, mas que fogem do escopo deste projeto.

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como um anel, onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> \mathcal{C}_1 = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> \mathcal{C}_2 = 80 </math>), em pouco tempo tem a sua renda líquida reduzida, pois o dinheiro decai a uma taxa <math>\beta</math>, como já falado. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a taxa de evolução do sistema monetário em pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de formato gaussiano sob a malha. Por isso, é interessante analisar a solução estacionária (se existir).

Como as equações diferenciais do sistema são dependentes umas das outras (isto é, a equação de m(x,t) depende de p(x,t) e a de p depende de m), a solução não é trivial. Utilizando o Método de Coeficientes a Determinar para solução de equações diferenciais em estado estacionário, conseguimos a seguinte relação genérica, que se mostra útil:

<math> m(x,t) = A_1 e^{- B_1 x^2} + A_2 p(x,t) + A_3 </math>

Onde <math>A_1,A_2,A_3</math> e <math>B_1</math> são constantes que dependem das condições iniciais do problema. Como o objetivo do trabalho não é resolver analiticamente esta EDP, estas constantes não foram calculadas.

Mas a equação acima mostra que, para o estado estacionário, o formato gaussiano obtido era previsto na solução analítica também. Portanto, o resultado obtido apresenta coerência.

Mais um ponto a ser aferido é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior largura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Um cuidado importante na iniciação deste sistema é que, como estamos modelando a densidade populacional, e consideramos que não há perda de população com o tempo, a integral da função p(x,t) deve ser sempre igual a 1. Em t=0, na iniciação do sistema, é necessário implementar esta condição ao problema, para que ela se mantenha durante a simulação. Para isso, basta sortear valores e normalizá-los depois. Um exemplo de código simples em Python que realiza esta operação está indicado abaixo.

<source lang="python">
import numpy as np
N = 100 #Limite no eixo x
p_auxiliar = np.random.rand(N) #Vetor auxiliar
p = p_auxiliar / np.sum(p_auxiliar) #Normalização, para que a soma de p em todo x seja 1
</source>

Esta condição inicial da população se assemelha muito à proposição inicial que Keller e Segel fizeram para um sistema celular, como descrito acima. Temos uma concentração homogênea de <math>p</math> com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se notar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com formato gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao estacionário, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de formato gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

Mais uma vez, como iniciamos aleatoriamente a população, é importante normalizá-la para que a integral seja igual a 1, como dito acima.

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial aleatório do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível mais uma vez a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema entre em um estado com somente um pico de formato gaussiano na população, e um pico na renda, com largura maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

Para a geração da evolução do sistema e do gif, o código utilizado foi o seguinte:
<source lang="python">
L = 100 # Tamanho do Grid
D_p = 0.5 # Coeficiente de difusão de pessoas
D_m = 0.5 # Coeficiente de difusão de dinheiro
ds = 1 # Diferencial Espacial
dt = 0.3 # Diferencial Temporal
alfa = 1.2 # Taxa de produção de economia per capita
beta = 0.03 # Taxa de decaimente da economia
gamma = 1 # Taxa de velocidade com que as pessoas migram em direção ao dinheiro

# CRIA OBJETO DE PARÂMETROS PARA O MODELO #
parametros = ParametrosKellerSegelModel(L, L, D_p, D_m, ds, dt, alfa, beta, gamma)

# INICIALIZA O MODELO COM OS PARÂMETROS #
modelo = KellerSegelModel(parametros)

# GERA CONDIÇÕES INICIAIS A SEREM ESTUDADAS #
condicao_inicial_populacao = np.matrix(np.full((parametros.N_x, parametros.N_x), 1 / (L ** 2)))
condicao_inicial_dinheiro = np.matrix(np.zeros((parametros.N_y, parametros.N_y)))

condicao_inicial_dinheiro[(0, 0)] = 0.125
condicao_inicial_dinheiro[(0, 99)] = 0.125
condicao_inicial_dinheiro[(99, 99)] = 0.125
condicao_inicial_dinheiro[(99, 0)] = 0.125
condicao_inicial_dinheiro[(49, 49)] = 2
condicao_inicial_dinheiro[(49, 69)] = 1
condicao_inicial_dinheiro[(49, 29)] = 1
condicao_inicial_dinheiro[(69, 49)] = 1
condicao_inicial_dinheiro[(29, 49)] = 1

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE GRÁFICO ESTÁTICO
jpeg = JpegTool(nome_imagem = 'comparacao_tempos_pop_eco_2d')

# GERA GRÁFICOS
jpeg.geraJpeg(modelo)

# REINICIALIZA MODELO
modelo = KellerSegelModel(parametros)

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE ANIMACAO #
ani = AnimacaoTool(nome_gif = 'dinamica_pop_eco_2d')

# GERA GIF COM A EVOLUCAO DO MODELO #
ani.geraGif(modelo)
</source>

'''''Código completo se encontra no Github.'''''

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Nas figuras abaixo, sendo a primeira uma figura retirada do livro do Sayama <ref name='sayama'></ref>, e a segunda gerada utilizando o modelo construído, a fim de comparar com a primeira, observa-se, partindo de uma população constante na malha e de uma renda aleatoriamente distribuída, a formação de grupos (pontos mais escuros), deste modo provando que o modelo construído chega nos mesmos resultados que a referência.

[[Arquivo:Clusters-keller-segel.png|600px|thumb|center|Fonte: Sayama]]

[[Arquivo:Clusters-pop-renda.png|600px|thumb|center|Clusters obtidos para os casos estudados, sob condições iniciais semelhantes às aplicadas por Sayama na imagem acima. Na imagem, observa-se, assim como na referência, o principal objetivo da aplicação do modelo: a presença de clusters de população sob a malha.]]

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Script para gerar os gifs ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt
import imageio """Biblioteca p/ gerar os gifs. Para instalar: pip install imageio"""
import os

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot_gif(p,m,t,images):
fig,ax = plt.subplots(1,2,figsize=(10,5))

#População
ax[0].set_title("População, t = {}".format(round(t,1)))
ax[0].plot(100*p,color='purple')
ax[0].set_ylabel("%")
ax[0].grid(False)

#Renda
ax[1].set_title("Renda, t = {}".format(round(t,1)))
ax[1].plot(m,color='darkgreen')
ax[1].fill_between(np.arange(m.shape[0]),m,color='green',alpha=0.5,label="Total money: $ {}".format(round(np.sum(m),2)))
ax[1].set_ylabel("$")
ax[1].grid(False)
ax[1].legend()

plt.tight_layout()
plt.savefig(imgname) #Salva o frame do sistema
plt.close()

images.append(imageio.imread(imgname)) #Adiciona a imagem na lista indicada
os.remove(imgname) #Remove a imagem recém criada
time.sleep(0.5)

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0. Varia conforme a condição inicial desejada.
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0. Varia conforme a condição inicial desejada.
m = np.zeros(N)
m[80] = 1

images = [] #Vetor para alocar as imagens que formarão o gif.
for t in np.arange(0,T,dt):
if i % 10 == 0: #Gera 1 imagem a cada 10 iterações, para não gerar um .gif muito pesado.
plot_gif(p,m,t,images)
p,m = FTCS(p,m,k1,k2,l,k3,v)

imageio.mimsave("foo.gif", images,fps=3) #Ajustar fps conforme desejar. Quanto maior, + imagens/segundo

</source>

=== Script para gerar os snapshots do sistema ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot_grid(fig,p,m,i,t,ncols,nrows=2):
#Population
ax_p = fig.add_subplot(nrows,ncols,i+1)
ax_p.set_title("t = {}".format(t),fontsize=18)
ax_p.plot(100*p,color='purple')
ax_p.fill_between(np.arange(N),100*p,color='purple',alpha=0.5)

#Money
ax_m = fig.add_subplot(nrows,ncols,i+1+ncols)
ax_m.set_title("t = {}".format(t),fontsize=18)
ax_m.plot(m,color='darkgreen')
ax_m.fill_between(np.arange(N),m,color='green',alpha=0.5,label="Renda líquida: $ {}".format(round(np.sum(m),2)))
ax_m.legend(fontsize=10)

if i == 0:
ax_p.set_ylabel("%",fontsize=15)
ax_m.set_ylabel("$", fontsize=15)

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0. Varia conforme a condição inicial desejada.
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0. Varia conforme a condição inicial desejada.
m = np.zeros(N)
m[80] = 1

ncols = 5 #Número de colunas da imagem // Número de snapshots
snapshots = np.array([0*dt,5*dt,10*dt,15*dt,20*dt]) #Vetor que aloca os tempos onde serão tirados os snapshots do sistema

fig, big_axes = plt.subplots(nrows=2,ncols=1,figsize=(20,6),sharey=True)
titles = ["População (%)","Renda ($)"]
for row,big_ax in enumerate(big_axes):
big_ax.set_title(titles[row],fontsize=22,y=1.15)
big_ax.axis('off')

count = 0
for t in np.arange(0,T,dt):
if t in snapshots: #Gera 1 imagem a cada 10 iterações, para não gerar um .gif muito pesado.
plot_grid(fig,p,m,count,t,ncols)
count += 1
p,m = FTCS(p,m,k1,k2,l,k3,v)

fig.subplots_adjust(hspace=0.55)
plt.savefig("foo.png")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==

<references/>

Modelo de Keller-Segel para relação população-economia

2021-05-26T23:08:07Z

Bleo: /* 1D */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>, que originalmente descreve o movimento de células em direção a um sinal químico, para um sistema englobando população e atividade econômica, problema proposto no livro ''Introduction to the Modeling and Analysis of Complex Sistems '' de Hiroki Sayama <ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref>. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space''), método de resolução de equações diferenciais parciais, como a equação do calor e a da difusão, que é o caso deste trabalho.

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'', a taxa com que as células se movem em direção ao sinal químico, tem papel crítico na auto-organização das células. <ref name = 'thesis'> Hoffmann, F. C. O. Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis , Tese de doutorado. 2017 [https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]</ref>

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas <ref name='sayama'></ref>:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica<ref name='sayama'></ref>:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

O trabalho agora é traduzir essas premissas em equações. O primeiro ponto diz que que padrão não há mudança na população, dessa forma:
:<math>\frac{\partial p}{\partial t} = 0</math>

O segundo ponto nos diz que a economia tem um aumento que depende da quantidade de pessoas, e assim:

:<math>\frac{\partial m}{\partial t} = \alpha p</math>

em que <math>\alpha</math> é a taxa de aumento da atividade econômica per capita.

O terceiro ponto diz que a atividade econômica decai quando não há pessoas, e para isso adicionamos um termo de decaimento na equação:
:<math>\frac{\partial m}{\partial t} = \alpha p - \beta m</math>
em que <math>\beta</math> é a taxa de decaimento da atividade econômica.

O quarto ponto fala que tanto população quanto a atividade econômica difundem, o que uma premissa sobre o movimento espacial. Para isso são adicionados termos de difusão, os Laplacianos, as equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

onde <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da atividade econômica respectivamente.

O quinto e último ponto fala que as pessoas são atraídas pela atividade econômica e assim se movem para áreas que possuem mais dinheiro. Para cumprir essa premissa, a equação do transporte é utilizada:

:<math>
- \nabla \cdot (p \gamma \nabla m)
</math>

em que o gradiente de <math>m</math> é utilizado para obter a velocidade média do movimento da população, sendo <math>\gamma</math> uma constante que afeta essa velocidade.

O sistema de equação final fica da seguinte forma:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos, <ref name='scherer'>Scherer, C. Métodos Computacionais da Física. 2010
</ref>
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de explorar a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

N indica o limite do eixo x. Quanto maior o seu valor, mais demorada fica a simulação. Porém, valores pequenos de N podem gerar resultados inconclusivos.

<math>
\Delta x = 1
</math>

Indica a unidade infinitesimal do eixo x (neste caso, o único eixo do problema).

<math>
\Delta t = 0.3
</math>

Indica quanto tempo cada passo da simulação percorre.

<math>
D_m = 1
</math>

Constante de difusão da função de renda.

<math>
D_p = 1
</math>

Constante de difusão da função de densidade populacional.

<math>
\gamma = 1
</math>

<math>\gamma</math> é um parâmetro intimamente ligado com o movimento da população para regiões com alta concentração de dinheiro. Nas palavras de Sayama,<ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref> indica a "habilidade que as pessoas da rede tem de 'sentir o cheiro' do dinheiro".

<math>
\alpha = 1
</math>

O parâmetro <math>\alpha</math> é utilizado no cálculo de <math>v</math>, como descrito acima, seguindo a fórmula <math>v = \alpha \Delta t</math>. Está relacionado com a velocidade do progresso da economia, ou seja, quão rápido cresce a renda em uma posição da malha através da influência da população.

<math>
\beta = 1
</math>

<math>\beta</math> é utilizado na fórmula <math>\lambda = \beta \Delta t</math>, que indica a taxa de decaimento da renda em regiões da malha com baixa população.

Estes parâmetros foram utilizados pois representam bem a característica do sistema de Keller-Segel que queremos representar: a formação de clusters de população na malha <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>. Uma nova combinação de parâmetros poderia resultar em resultados diferentes, mas que fogem do escopo deste projeto.

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como um anel, onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> \mathcal{C}_1 = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> \mathcal{C}_2 = 80 </math>), em pouco tempo tem a sua renda líquida reduzida, pois o dinheiro decai a uma taxa <math>\beta</math>, como já falado. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a taxa de evolução do sistema monetário em pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de formato gaussiano sob a malha. Por isso, é interessante analisar a solução estacionária (se existir).

Como as equações diferenciais do sistema são dependentes umas das outras (isto é, a equação de m(x,t) depende de p(x,t) e a de p depende de m), a solução não é trivial. Utilizando o Método de Coeficientes a Determinar para solução de equações diferenciais em estado estacionário, conseguimos a seguinte relação genérica, que se mostra útil:

<math> m(x,t) = A_1 e^{- B_1 x^2} + A_2 p(x,t) + A_3 </math>

Onde <math>A_1,A_2,A_3</math> e <math>B_1</math> são constantes que dependem das condições iniciais do problema. Como o objetivo do trabalho não é resolver analiticamente esta EDP, estas constantes não foram calculadas.

Mas a equação acima mostra que, para o estado estacionário, o formato gaussiano obtido era previsto na solução analítica também. Portanto, o resultado obtido apresenta coerência.

Mais um ponto a ser aferido é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior largura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Um cuidado importante na iniciação deste sistema é que, como estamos modelando a densidade populacional, e consideramos que não há perda de população com o tempo, a integral da função p(x,t) deve ser sempre igual a 1. Em t=0, na iniciação do sistema, é necessário implementar esta condição ao problema, para que ela se mantenha durante a simulação. Para isso, basta sortear valores e normalizá-los depois. Um exemplo de código simples em Python que realiza esta operação está indicado abaixo.

<source lang="python">
import numpy as np
N = 100 #Limite no eixo x
p_auxiliar = np.random.rand(N) #Vetor auxiliar
p = p_auxiliar / np.sum(p_auxiliar) #Normalização, para que a soma de p em todo x seja 1
</source>

Esta condição inicial da população se assemelha muito à proposição inicial que Keller e Segel fizeram para um sistema celular, como descrito acima. Temos uma concentração homogênea de <math>p</math> com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se notar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com formato gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao estacionário, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de formato gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

Mais uma vez, como iniciamos aleatoriamente a população, é importante normalizá-la para que a integral seja igual a 1, como dito acima.

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial aleatório do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível mais uma vez a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema entre em um estado com somente um pico de formato gaussiano na população, e um pico na renda, com largura maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

Para a geração da evolução do sistema e do gif, o código utilizado foi o seguinte:
<source lang="python">
L = 100 # Tamanho do Grid
D_p = 0.5 # Coeficiente de difusão de pessoas
D_m = 0.5 # Coeficiente de difusão de dinheiro
ds = 1 # Diferencial Espacial
dt = 0.3 # Diferencial Temporal
alfa = 1.2 # Taxa de produção de economia per capita
beta = 0.03 # Taxa de decaimente da economia
gamma = 1 # Taxa de velocidade com que as pessoas migram em direção ao dinheiro

# CRIA OBJETO DE PARÂMETROS PARA O MODELO #
parametros = ParametrosKellerSegelModel(L, L, D_p, D_m, ds, dt, alfa, beta, gamma)

# INICIALIZA O MODELO COM OS PARÂMETROS #
modelo = KellerSegelModel(parametros)

# GERA CONDIÇÕES INICIAIS A SEREM ESTUDADAS #
condicao_inicial_populacao = np.matrix(np.full((parametros.N_x, parametros.N_x), 1 / (L ** 2)))
condicao_inicial_dinheiro = np.matrix(np.zeros((parametros.N_y, parametros.N_y)))

condicao_inicial_dinheiro[(0, 0)] = 0.125
condicao_inicial_dinheiro[(0, 99)] = 0.125
condicao_inicial_dinheiro[(99, 99)] = 0.125
condicao_inicial_dinheiro[(99, 0)] = 0.125
condicao_inicial_dinheiro[(49, 49)] = 2
condicao_inicial_dinheiro[(49, 69)] = 1
condicao_inicial_dinheiro[(49, 29)] = 1
condicao_inicial_dinheiro[(69, 49)] = 1
condicao_inicial_dinheiro[(29, 49)] = 1

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE GRÁFICO ESTÁTICO
jpeg = JpegTool(nome_imagem = 'comparacao_tempos_pop_eco_2d')

# GERA GRÁFICOS
jpeg.geraJpeg(modelo)

# REINICIALIZA MODELO
modelo = KellerSegelModel(parametros)

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE ANIMACAO #
ani = AnimacaoTool(nome_gif = 'dinamica_pop_eco_2d')

# GERA GIF COM A EVOLUCAO DO MODELO #
ani.geraGif(modelo)
</source>

'''''Código completo se encontra no Github.'''''

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Nas figuras abaixo, sendo a primeira uma figura retirada do livro do Sayama <ref name='sayama'></ref>, e a segunda gerada utilizando o modelo construído, a fim de comparar com a primeira, observa-se, partindo de uma população constante na malha e de uma renda aleatoriamente distribuída, a formação de grupos (pontos mais escuros), deste modo provando que o modelo construído chega nos mesmos resultados que a referência.

[[Arquivo:Clusters-keller-segel.png|600px|thumb|center|Fonte: Sayama]]

[[Arquivo:Clusters-pop-renda.png|600px|thumb|center|Clusters obtidos para os casos estudados, sob condições iniciais semelhantes às aplicadas por Sayama na imagem acima. Na imagem, observa-se, assim como na referência, o principal objetivo da aplicação do modelo: a presença de clusters de população sob a malha.]]

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Script para gerar os gifs ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt
import imageio """Biblioteca p/ gerar os gifs. Para instalar: pip install imageio"""
import os

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot_gif(p,m,t,images):
fig,ax = plt.subplots(1,2,figsize=(10,5))

#População
ax[0].set_title("População, t = {}".format(round(t,1)))
ax[0].plot(100*p,color='purple')
ax[0].set_ylabel("%")
ax[0].grid(False)

#Renda
ax[1].set_title("Renda, t = {}".format(round(t,1)))
ax[1].plot(m,color='darkgreen')
ax[1].fill_between(np.arange(m.shape[0]),m,color='green',alpha=0.5,label="Total money: $ {}".format(round(np.sum(m),2)))
ax[1].set_ylabel("$")
ax[1].grid(False)
ax[1].legend()

plt.tight_layout()
plt.savefig(imgname) #Salva o frame do sistema
plt.close()

images.append(imageio.imread(imgname)) #Adiciona a imagem na lista indicada
os.remove(imgname) #Remove a imagem recém criada
time.sleep(0.5)

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0. Varia conforme a condição inicial desejada.
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0. Varia conforme a condição inicial desejada.
m = np.zeros(N)
m[80] = 1

images = [] #Vetor para alocar as imagens que formarão o gif.
for t in np.arange(0,T,dt):
if i % 10 == 0: #Gera 1 imagem a cada 10 iterações, para não gerar um .gif muito pesado.
plot_gif(p,m,t,images)
p,m = FTCS(p,m,k1,k2,l,k3,v)

imageio.mimsave("foo.gif", images,fps=3) #Ajustar fps conforme desejar. Quanto maior, + imagens/segundo

</source>

=== Script para gerar os snapshots do sistema ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot_grid(fig,p,m,i,t,ncols,nrows=2):
#Population
ax_p = fig.add_subplot(nrows,ncols,i+1)
ax_p.set_title("t = {}".format(t),fontsize=18)
ax_p.plot(100*p,color='purple')
ax_p.fill_between(np.arange(N),100*p,color='purple',alpha=0.5)

#Money
ax_m = fig.add_subplot(nrows,ncols,i+1+ncols)
ax_m.set_title("t = {}".format(t),fontsize=18)
ax_m.plot(m,color='darkgreen')
ax_m.fill_between(np.arange(N),m,color='green',alpha=0.5,label="Renda líquida: $ {}".format(round(np.sum(m),2)))
ax_m.legend(fontsize=10)

if i == 0:
ax_p.set_ylabel("%",fontsize=15)
ax_m.set_ylabel("$", fontsize=15)

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0. Varia conforme a condição inicial desejada.
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0. Varia conforme a condição inicial desejada.
m = np.zeros(N)
m[80] = 1

ncols = 5 #Número de colunas da imagem // Número de snapshots
snapshots = np.array([0*dt,5*dt,10*dt,15*dt,20*dt]) #Vetor que aloca os tempos onde serão tirados os snapshots do sistema

fig, big_axes = plt.subplots(nrows=2,ncols=1,figsize=(20,6),sharey=True)
titles = ["População (%)","Renda ($)"]
for row,big_ax in enumerate(big_axes):
big_ax.set_title(titles[row],fontsize=22,y=1.15)
big_ax.axis('off')

count = 0
for t in np.arange(0,T,dt):
if t in snapshots: #Gera 1 imagem a cada 10 iterações, para não gerar um .gif muito pesado.
plot_grid(fig,p,m,count,t,ncols)
count += 1
p,m = FTCS(p,m,k1,k2,l,k3,v)

fig.subplots_adjust(hspace=0.55)
plt.savefig("foo.png")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T23:05:03Z

Bleo: /* Cenários de Simulação */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>https://en.wikipedia.org/wiki/Ising_model</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a magnitude de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tendem a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo de interação é tomado como uma constante <math>J_{ij} = 1</math> para vizinhos e <math>J_{ij} = 0</math> para os demais spins, e ele é responsável pela indução de ordem ferromagnética local.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>. Podemos interpretar a temperatura nesse sistema como se fosse a velocidade com que as transações acontecem: para uma temperatura baixa, os agentes trocariam suas estratégias mais devagar, por exemplo. A temperatura no caso deste modelo, vai ditar a distribuição de estratégias: para uma temperatura baixa, as estratégias associadas ao spin up dominarão; já para uma temperatura mais elevada, as estratégias associadas ao spin down predominarão.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T22:52:41Z

Bleo: /* Cenários de Simulação */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>https://en.wikipedia.org/wiki/Ising_model</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a magnitude de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tendem a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo de interação é tomado como uma constante <math>J_{ij} = 1</math> para vizinhos e <math>J_{ij} = 0</math> para os demais spins, e ele é responsável pela indução de ordem ferromagnética local.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>. Podemos interpretar a temperatura nesse sistema como se fosse a velocidade com que as transações acontecem: para uma temperatura baixa, os agentes trocariam suas estratégias mais devagar, por exemplo.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T22:47:53Z

Bleo: /* Simulação de Mercados de Ações e o Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>https://en.wikipedia.org/wiki/Ising_model</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a magnitude de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tendem a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo de interação é tomado como uma constante <math>J_{ij} = 1</math> para vizinhos e <math>J_{ij} = 0</math> para os demais spins, e ele é responsável pela indução de ordem ferromagnética local.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T22:44:12Z

Bleo: /* Introdução */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>https://en.wikipedia.org/wiki/Ising_model</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a magnitude de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tendem a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T22:43:27Z

Bleo: /* Introdução */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>https://en.wikipedia.org/wiki/Ising_model</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z ,</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j ,</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases} ,
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t).</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-26T22:40:00Z

Bleo: /* Introdução */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising<ref name='ising'>https://en.wikipedia.org/wiki/Ising_model</ref>. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''2h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 85%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T23:35:17Z

Bleo: /* Simulação de Mercados de Ações e o Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

Em todos os casos, a simulação foi feita usando a dinâmica de banho térmico já apresentada, juntamente com Monte Carlo. Para cada passo (''sweep'') de MC, sorteia-se várias posições no sistema e aplica-se a dinâmica de ''heat-bath'' sobre cada uma, calculando, após isso, a orientação do spin.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos, para que fiquem na mesma escala:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE)<ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>. Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref> <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a Transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 80%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

===Objeto que implementa o Modelo de Bornholdt em Python===
<source lang="python">
class Bornholdt():
def __init__(self,N_rows,N_cols,T):
self.L = N_rows #Size of mesh in X
self.N = N_cols #Size of mesh in Y
self.beta = 1/T #beta ~ 1/T
self.state = init_state(self.L,self.N) #Initialize the network
self.Mag = calc_mag(self.state) #Magnetization for a specific state

def update_spins(self):
""" Provides a single update in the network """
self.state = heat_bath(self.state,self.beta)
self.Mag = calc_mag(self.state)

def reset_state(self):
""" Reset the grid to the initial state """
self.state = init_state(self.L,self.N)
self.Mag = calc_mag(self.state)

def magnetization(self,mcSteps,plot=False,number_prints=8):
""" Calculates the magnetization and updates the spins of system. """
n = int(mcSteps/number_prints)
Magnetism = np.zeros(mcSteps)
#Heat-Bath
for j in np.arange(mcSteps):
if j % n == 0:
print("MC Sweep nº: {}".format(j))
self.update_spins()
Magnetism[j] = self.Mag
#Plot
if plot:
fig,ax = plt.subplots(1,1,figsize=(8,4))
ax.set_ylabel("M(t)",fontsize=12)
ax.set_xlabel("t",fontsize=12)
ax.plot(Magnetism,lw=0.8,color='black')
ax.set_xlim(0,len(Magnetism))
plt.tight_layout()
plt.show()
return Magnetism

def print_state(self):
""" Plots the current status of the grid, in a 2D mesh """
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))

fig,ax = plt.subplots(1,1,figsize=(3,3))
ax.set_xticks([])
ax.set_yticks([])
ax.pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)

plt.tight_layout()
plt.show()

def plot_grid(self,mcSteps,n_plots,number_prints=8):
""" Built a grid with 2D meshs plots, perfect to visualize the system. """
n = n_plots**2
X,Y = np.meshgrid(np.arange(self.L),np.arange(self.N))
fig,ax = plt.subplots(n_plots,n_plots,figsize=(8,8))
print_graph = int(mcSteps/n)
snapshots = []
#Constructing snapshots list
for i in np.arange(mcSteps):
if (i % print_graph==0) and (len(snapshots) < n):
snapshots.append(i)
#Heat-Bath
count = 0
for j in np.arange(mcSteps):
if j % int(mcSteps/number_prints) == 0:
print("-- MC sweep nº {}...".format(j))
if j in snapshots:
#Plot config.
x_i = int(count/n_plots)%n_plots
y_i = int(count%n_plots)
ax[x_i,y_i].pcolor(X, Y, self.state, cmap=plt.cm.Greys,shading='auto',linewidth=0,rasterized=True)
ax[x_i,y_i].set_title("t = {}".format(j),fontsize=22)
ax[x_i,y_i].set_xticks([])
ax[x_i,y_i].set_yticks([])
count += 1
self.update_spins()
#Plot config.
plt.tight_layout()
plt.show()
</source>

===Implementação do Modelo de Bornholdt com variação de opiniões ao longo da simulação (Julia)===
<source lang="julia">
using Statistics
println("Statistics imported sucessfully")

function calc_ret(M)
N = length(M)
corrected_M = []
for m in M
if m == 0.0
append!(corrected_M,0.000001)
else
append!(corrected_M,m)
end
end
r = []
for i in 2:N
ret = log(abs(corrected_M[i]/corrected_M[i-1]))
append!(r,ret)
end
r_ = mean(r)
sigma_r = std(r)
r_norm = [(ret-r_)/sigma_r for ret in r]
return r_norm
end

function agent_opinion(p1,p2)
opinion = rand()
if opinion <= p1
return +1,+1.0 #Strategy 1 - Player that wants to join the minority (fundamentalist)
elseif opinion <= (p2+p1)
return +2,-1.0 #Strategy 2 - Player wants to join majority of agents (chartist)
else
return +3,(2*rand(0:1) - 1) #Strategy 3 - Dumb irrational player
end
end

function flip_opinion(current_opinion)
opinions = [1,2,3]
d = Dict()
d[1] = +1.0
d[2] = -1.0
d[3] = (rand() - 0.5)
splice!(opinions,Int64(current_opinion))
n = length(opinions)
new_opinion = rand(1:n)
return new_opinion,d[new_opinion]
end

function count_states(opinion_mesh)
N,L = size(opinion_mesh)
opinion1 = 0
opinion2 = 0
opinion3 = 0
for i in 1:N
for j in 1:L
if opinion_mesh[i,j] == 1
opinion1 += 1/(N*L)
elseif opinion_mesh[i,j] == 2
opinion2 += 1/(N*L)
else
opinion3 += 1/(N*L)
end
end
end
return [opinion1,opinion2,opinion3]
end

function get_C(spins,p1,p2)
N,L = size(spins)
C = zeros(N,L)
opinions = [0,0,0]
opinion_mesh = zeros(N,L)
for i in 1:N
for j in 1:L
opinion, C_value = agent_opinion(p1,p2)
C[i,j] = C_value
opinion_mesh[i,j] = opinion
opinions[opinion] += 1
end
end
return opinions,C,opinion_mesh
end

function init_network(N,L)
spins = zeros(N,L)
for i in 1:N
for j in 1:L
r = rand()
if r < 0.5
spins[i,j] = -1
else
spins[i,j] = +1
end
end
end
return spins
end

function find_nb(spins,a,b)
N,L = size(spins)
#Adjusting for a
if (a-1) <= 0
back_a = N
else
back_a = a-1
end

if (a+1) > N
forward_a = 1
else
forward_a = a+1
end

#Adjusting for b
if (b-1) <= 0
back_b = N
else
back_b = b-1
end

if (b+1) > L
forward_b = 1
else
forward_b = b+1
end

left = spins[a,back_b]
right = spins[a,forward_b]
top = spins[back_a,b]
bottom = spins[forward_a,b]
return [left,right,top,bottom]
end

function calc_spin(arg)
p = 1 / (1 + exp((-1)*arg))
r = rand()
if r < p
spin = +1
else
spin = -1
end
return spin
end

function heat_bath(spins,beta,alpha,C,change_opinions)
N,L = size(spins)
J = 1
a_vec = rand(1:N,N^2)
b_vec = rand(1:L,L^2)
for (a,b) in zip(a_vec,b_vec)
s = spins[a,b]
nb = sum(find_nb(spins,a,b))
local_field_h = J*nb - alpha*C[a,b]*sum(spins)/(N*L)
spins[a,b] = calc_spin(2*beta*local_field_h)
if opinion_mesh[a,b] == 3
C[a,b] = (2*rand(0:1) - 1)
end
if change_opinions
if s != spins[a,b]
(opinion,C_value) = flip_opinion(opinion_mesh[a,b])
C[a,b] = C_value #If the agent changes signal, he changes strategy
opinion_mesh[a,b] = opinion
end
end
end
return spins
end

function calc_mag(spins)
N,L = size(spins)
m = sum(spins)
return m / (N*L)
end

function write_to_file(filename,data1,data2)
N = length(data1)
open(filename,"w") do file
write(file,"M(t),r(t)\n")
write(file,(string(data1[1])*",-\n"))
for i in 2:N
write(file,string(data1[i])*","*string(data2[i-1])*"\n")
end
end
end

function print_state(filename,C)
N,L = size(C)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(C[i,j])*",")
end
write(file,"\n")
end
close(file)
end

function print_opinions(filename,opinions)
N,L = size(opinions)
file = open(filename,"w")
for i in 1:N
for j in 1:L
write(file,string(opinions[i,j])*",")
end
write(file,"\n")
end
end

N = 32
L = 32
mcSteps = 3000
n_prints = Int(floor(mcSteps/4))
T = 1.5
beta = 1/T
alpha = 4.0

p1 = 1/3 # Prob. opinion #1: fundamentalist
p2 = 1/3 # Prob. opinion #2: chartist
change_opinions = true # If true, opinion of agents can change during simulation.

spins = init_network(N,N)
M = zeros(mcSteps)
opinions,C,opinion_mesh = get_C(spins,p1,p2)

println("Network opinions:")
for (i,opinion) in enumerate(opinions)
println("Opinion ",i,": ",100*opinion/(N*L)," %")
end
println("====================================")
perc_opinions = zeros(mcSteps,3)
plot_grid = floor(mcSteps/15)
shots = [1]
append!(shots,[i*plot_grid for i in 1:15])
count = 0

for i in 1:mcSteps
if (i in shots)
println("----- Grid in ",i)
filename = "state_MC"*string(count)*".txt"
print_state(filename,opinion_mesh)
global count += 1
end
percs = count_states(opinion_mesh)
for j in 1:3
perc_opinions[i,j] = percs[j]
end
heat_bath(spins,beta,alpha,C,change_opinions)
M[i] = calc_mag(spins)
if i % n_prints == 0
println("-- Sweep nº ",i," concluded.")
end
end
filename = "mag_ret_N"*string(N*L)*".txt"
write_to_file(filename,M,calc_ret(M))
print_opinions("opinions_N"*string(N^2)*".txt",perc_opinions)
</source>

===Implementação do Modelo de Bornholdt simples em C===
OBS: código não otimizado.
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define N 32
#define L 32
#define MAX_STRING_SIZE 15
#define NUMBER_OF_PLOTS 9
int spins[N][L];

double rng(){
return (float)rand()/RAND_MAX;
}

int int_rng(int max_value){
return rand() % max_value;
}

void initialize_network(){
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
spins[i][j]=2*int_rng(2)-1;
}
}
}

double sum_array(){
double sum = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
sum = sum + spins[i][j];
}
}
return sum;
}

int calc_spin(double arg){
double p = 1 / (1 + exp(arg));
double r = rng();
if(r < p){
return +1;
}
else{
return -1;
}
}

double calc_magnetization(){
double m = 0.0;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
m = m + spins[i][j];
}
}
return (double) (m/(L*N));
}

void print_state(char filename[]){
FILE *grid;
grid = fopen(filename,"w");
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
fprintf(grid,"%d,",spins[i][j]);
}
fprintf(grid,"\n");
}
fclose(grid);
}

void heat_bath(double beta){
double alpha = 4.0;
double J = 1.0;
int a;
int b;
int s;
int nb_left,nb_right,nb_top,nb_bottom,sum_nb;
double arg;
for(int i=0;i<N;i++){
for(int j=0;j<L;j++){
a = int_rng(N);
b = int_rng(L);
s = spins[a][b];
nb_top = spins[(a+N-1)%N][b];
nb_bottom = spins[(a+1)%N][b];
nb_left = spins[a][(b+L-1)%L];
nb_right = spins[a][(b+1)%L];
sum_nb = nb_left+nb_top+nb_right+nb_bottom;
arg = (double)2*beta*(J*sum_nb - alpha*s*abs(sum_array(*spins))/(L*N));
spins[a][b] = calc_spin(-arg);
}
}
}

void main(){
srand(time(NULL));
//!Declarate variables
clock_t begin;
clock_t end;
double T = 1.5;
double beta = 1/T;
int mcSteps = 1000;
int n_prints = (int)(mcSteps/5);
char filename[][MAX_STRING_SIZE] = {"grid1.txt","grid2.txt","grid3.txt","grid4.txt","grid5.txt","grid6.txt","grid7.txt","grid8.txt","grid9.txt"};
int snapshots[NUMBER_OF_PLOTS];
for(int i=0;i<NUMBER_OF_PLOTS;i++){
snapshots[i] = i*(mcSteps/NUMBER_OF_PLOTS);
}
int plot_index = 0;
FILE *mag_file;
mag_file = fopen("magnetization.dat","w");
//////////////////////////////////////////////////////////////////////!
begin = clock();
//!Init. Network
initialize_network();
end = clock();
printf("Network initiated\n");
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
printf("==========================================================\n");
//////////////////////////////////////////////////////////////////////!
begin = clock();
for(int j=0;j<mcSteps;j++){
if(j % n_prints == 0){
printf("Simulation %d...\n",j);
}
if(j == snapshots[plot_index]){
printf("-- Building %s...\n",filename[plot_index]);
print_state(filename[plot_index]);
plot_index++;
}
//!Heat-Bath
heat_bath(beta);
//!Magnetization
fprintf(mag_file,"%lf\n",calc_magnetization());
}
fclose(mag_file);
end = clock();
if(N>40){
printf("Executed time: %lf min\n", (double)(end-begin)/(60*CLOCKS_PER_SEC));
}
else{
printf("Executed time: %lf s\n", (double)(end-begin)/CLOCKS_PER_SEC);
}
printf("==========================================================\n");
system("python plot.py");
}

</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T18:32:39Z

Bleo: /* Introdução */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos_.5B4.5D|retornos]] dos preços e uma alta correlação da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Mais detalhes sobre como a opinião de um agente influencia no sistema estão na seção de [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Varia.C3.A7.C3.A3o_da_opini.C3.A3o_dos_agentes|opinião dos agentes]]

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 80%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T18:20:42Z

Bleo: /* Cenários de Simulação */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t), \qquad \text{se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 80%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T18:20:10Z

Bleo: /* Cenários de Simulação */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

Em 2002, Stefan Bornholdt apresentou um modelo de spins motivado pela dinâmica de agentes no mercado financeiro, que retornava observações observadas em situações reais, como distribuição de retorno de caudas pesadas e clusterização de volatilidade.<ref name='modelo'>Bornholdt, Stefan. (2011). Expectation bubbles in a spin model of markets: Intermittency from frustration across scales. International Journal of Modern Physics C. 12. 10.1142/S0129183101001845. </ref>

O objetivo deste trabalho é, então, apresentar o Modelo de Bornholdt como alternativa para a construção de um mercado financeiro artificial com características observadas em mercados reais. Dentre os principais resultados obtidos, destaca-se a formação de estados metaestáveis, distribuição de retornos de cauda pesada, e clusters de volatilidade.

Por fim, também é apresentado uma alternativa para o uso do Modelo de Bornholdt, analisando a opinião dos agentes da rede, e como estas influenciam no resultado final.

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi <ref name='bonrholdt12'>Lux, Thomas & Marchesi, Michele. (1998). Scaling and Criticality in a Stochastic Multi-Agent Model of a Financial Market. Nature. 397. 10.1038/17290.</ref> <ref name='bonrholdt13'>Lux, Thomas & Marchesi, Michele. (1998). Volatility Clustering in Financial Markets: A MicroSimulation of Interacting Agents. International Journal of Theoretical and Applied Finance. 3. 10.1142/S0219024900000826.</ref> que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de distribuição de potências (cauda pesada) dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t) \qquad \text{se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math display='inline'>\sigma_r</math> é o desvio padrão da serie de retornos e <math display='inline'>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. <ref name = 'fatoestilizado'> Da Cunha, Carlo & Silva, Roberto. (2019). Relevant Stylized Facts About Bitcoin: Fluctuations, First Return Probability, and Natural Phenomena.</ref> Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

Com o intuito de construir uma rede de opiniões mistas (como é em casos de mercados reais), foram testadas várias combinações de porcentagens de opiniões na rede, até se encontrar uma que reproduzisse resultados muito semelhantes à de dados reais.

Utilizando aproximadamente 80% de agentes com opinião 3, 10% de opinião 1 e 5% de opinião 2, obteve-se o resultado ilustrado nos gráficos abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

Alguns pontos importantes:
*provavelmente, se fossem feitos mais testes de combinações de probabilidade, chegaria-se a um resultado que encaixaria muito bem com alguma das curvas de dados reais. Porém, o intuito do trabalho, como dito anteriormente, não é replicar exatamente o que acontece com o mercado X ou Y, mas sim produzir um mercado artificial com características muito parecidas às observadas em mercados reais.
*os retornos apresentam transições de estados de alta e baixa muito mais agudas do que casos reais. É quase como se não houvesse meio termo, ou o agente ganha muito, ou perde muito, ou não ganha nada. Uma limitação do modelo.
*a distribuição de retornos apresenta cauda pesada, como observado em mercados reais.

A simulação acima indica que, para melhor simular mercados reais, a maioria dos agentes devem atuar de maneira irracional, enquanto que uma parcela de aproximadamente 10% atua de acordo com a minoria e aproximadamente 5% com a maioria.

Pode-se, também, permitir que os agentes troquem de opinião de forma minimamente racional ao longo da simulação. Deste modo, sempre que um agente "errar" no palpite (i.e. trocar a sua orientação de spin), ele escolhe outra opinião para seguir, até que erre novamente. A escolha da opinião é feita de forma aleatória pelo agente (portanto, não é 100% racional). O resultado para diferentes condições iniciais encontra-se nas figuras abaixo:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Sit1 igual.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial igual para as 3 opiniões.]]
! [[Arquivo:Sit2 op3.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 3.]]
! [[Arquivo:Sit3 op1.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 1.]]
! [[Arquivo:Sit4 op2.png|270px|thumb|center|Porcentagem de composição da rede para cada opinião ao longo da simulação, com condição inicial de 100% opinião 2.]]
|}

Observando a figura acima, nota-se a tendência do sistema em colapsar para um estado onde a maioria dos agentes têm opinião 2, até mesmo quando inicia-se com 0 agentes partilhando desta opinião.

Relembrando, a opinião 2 refere-se aos agentes que têm opinião ajustada pela maioria. Em todas as simulações feitas, após um certo tempo transcorrido da simulação, 100% da rede é composta por esta opinião, o que implica em um estado de consenso da rede quanto à opinião de compra ou venda sobre um ativo. Faz muito sentido que a tendência natural do sistema seja colapsar para esta opinião, porque nela todos os agentes saem sem perder dinheiro da negociação (em compensação, também ganham um retorno ínfimo).

O problema é que este resultado não pode ser observado na prática, pois o modelo de Bornholdt tem a limitação de não levar em consideração fatores como crises financeiras, por exemplo, de modo que o preço do ativo é reflexo exclusivamente da opinião dos agentes. Caso o mercado financeiro real fosse comportado desta forma, bastaria que todos os investidores tomassem a mesma opinião para que não houvesse prejuízo.

Porém, na vida real, a imprevisibilidade de ativos acaba compensando alguns agentes a terem opinião contrária à maioria, de modo que, quando um ativo em alta cai na bolsa, estes ganham um retorno consideravelmente maior do que os que optaram por partilhar da mesma opinião.

Na figura abaixo, têm-se uma malha que representa o sistema, onde cada pixel representa um agente, e as cores indicam qual a opinião de cada agente ao longo do tempo. Foram utilizadas as mesmas condições iniciais que no exemplo acima.
{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mesh equal.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com o mesmo número de agentes para cada opinião em t=0.]]
! [[Arquivo:Mesh op3.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 3 em t=0.]]
! [[Arquivo:Mesh op1.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 1 em t=0.]]
! [[Arquivo:Mesh op2.png|270px|thumb|center|Comportamento dos agentes ao longo do tempo, com 100% de agentes de opinião 2 em t=0.]]
|}

A figura reforça o que já foi confirmado antes, sobre o sistema tender a colapsar inteiramente para a opinião 2. Mais um fator interessante que pode ser observado está na concentração de agentes de opinião 1 ao longo do tempo. Há um momento logo no início das simulações onde há a formação de pequenos clusters de opinião 1, que logo se dissolvem e viram de opinião 2.

No início da simulação, ainda há um breve retorno para agentes que apostam contra a maioria, o que justifica a formação destes aglomerados. Porém, com o passar do tempo e a maioria da rede sendo formada pela opinião 2, estes clusters somem, e a malha fica 100% coberta de opinião 2.

==Conclusões==

Tendo em vista o que foi abordado até aqui, algumas conclusões podem ser tiradas:

*simulações com um número de agentes da ordem de 1024 (grade 32x32) descrevem melhor um mercado financeiro, visto que apresentam ''clusters'' de volatilidade e possuem uma distribuição de retornos próxima a de um índice de mercado;
*através de simulações, verificou-se o perfil de investidores em mercados reais, baseado em suas opiniões. Em geral, a população que investe em ações é distribuída de forma que a grande maioria (aproximadamente 80%) atua de forma irracional (sem uma estratégia), uma parcela que gira em torno de 10% atua como fundamentalista (atua de acordo com a minoria do sistema) e aproximadamente 5% atua de maneira chartista (segue a opinião da maioria).
*ao permitir que agentes troquem de opinião livremente durante a simulação, observou-se a tendência do sistema de colapsar para um estado em que todos ou quase todos os agentes sigam o que a maioria do sistema está fazendo. Esta situação não descreve bem um sistema real, já que em um sistema financeiro existem fatores imprevisíveis que compõem o preço de ativos, não somente a opinião dos agentes. A partir do momento em que há possibilidade da minoria lucrar, surgem agentes de opinião 1. Também observou-se que, ao "forçar" que um agente que perde troque de opinião, elimina-se do sistema a opinião 3, ou seja, todos os agentes tornam-se minimamente racionais.

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T01:20:17Z

Bleo: /* Introdução */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t) \qquad \text{se} \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T01:16:40Z

Bleo: /* Simulação de Mercados de Ações e o Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
onde <math>\beta = \frac{1}{k_B T}</math>. Neste trabalho, por simplicidade assumiu-se que <math>k_B = 1</math>.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t) \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T01:07:53Z

Bleo: /* Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Introdução==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações e o Modelo de Bornholdt===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t) \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T01:05:00Z

Bleo: /* Cenários de Simulação */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam adotar duas estratégias diferentes, sendo possível agora adotar <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t) \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T01:00:34Z

Bleo: /* Simulação de Mercados de Ações */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j}^N J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j}^N S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam duas estratégias diferentes, sendo possível agora adotar a estratégia <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t) \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T00:58:22Z

Bleo: /* Cenários de Simulação */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j} J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam duas estratégias diferentes, sendo possível agora adotar a estratégia <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

Por fim, podemos definir regras para a transição entre as duas estratégias estratégias, onde cada ''trader'' tenderá a adotar uma estratégia ótima. Consideremos o cenário mais simples para trocas de estratégia: um agente no grupo majoritário frequentemente tenderá a mudar para o grupo minoritário, por exemplo para apostar em um comodity que ainda não está na moda (e possivelmente escapar de um crash do seu bem mais popular no momento). Por outro lado, um agente que se encontra no grupo minoritário (portanto esperando retornos futuros) pode não estar satisfeito com seus retornos atuais. Em resumo agentes nos grupos majoritários sempre irão escolher a estratégia <math>C_i(t) = 1</math>, enquanto a minoria irá escolher <math>C_i(t) = -1</math>. Cada agente escolhe uma estratégia arriscada a fim de aumentar seus retornos. A dinâmica da transição de estratégias é dada pela expressão:
<math>C_i(t + 1) = -C_i(t) \text{ se } \alpha C_i(t) \sum_{j=1}^N S_j(t) < 0.</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T00:43:00Z

Bleo: /* Cenários de Simulação */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j} J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_c</math>.

Um cenário mais interessante, é permitir que os agentes possam duas estratégias diferentes, sendo possível agora adotar a estratégia <math>C_i(t) = -1</math>, que corresponde a um acoplamento ferromagnético com a magnetização global. Essa estratégia é chamada de chartista, visto que os agentes tendem a seguir a opinião da maioria dos ''traders''.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Mixed opinions.png|400px|thumb|center|Simulação com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
! [[Arquivo:Mixed opinions kde.png|400px|thumb|center|Distribuição de retornos com 15% da rede contendo agentes de opinião 1, 5% de opinião 2 e 80% de opinião 3]]
|}

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-24T00:36:47Z

Bleo: /* Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j} J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J = 1</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

====Cenários de Simulação====
Vários cenários podem ser analisados, dependendo do valor e da dinâmica das estratégias. Consideremos o caso mais simples, em que <math>C_i(t) = 1 \forall i,t</math>. Cada agente, apesar do acoplamento ferromagnético local com os primeiros vizinhos, tem um acoplamento antiferromagnético com a magnetização. Esta dinâmica corresponde a ''traders'' que em adição a um nível básico de ferromagnetismo, ou seja, tendem a adotar estratégias parecidas com seus vizinhos, também têm o desejo de se juntar a minoria global, por exemplo a fim de investir em possíveis ganhos futuros. Portanto, ''traders'' com <math>C_i(t) = 1</math> podem ser chamados de fundamentalistas. Se todos os agentes adotam esta estratégia, a dinâmica global do sistema tenderá rápidamente a um estado de magnetização quase zero, mesmo para temperaturas abaixo da temperatura crítica <math>T_C</math>.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 3]]
|}
Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor. Não é um sistema muito realista pois os retornos não oscilam tão rapidamente assim.

Já no sistema composto apenas da opinião 2, há uma estabilidade quase que instantânea. Como todos os agentes seguem a maioria, uma vez atingido um determinado número mínimo de agentes com a mesma opinião, todos os outros passam a segui-la. E como não há agentes que discordem dessa opinião na rede, o sistema se mantem neste estado ''ad eternum''. É um sistema bem longe do realista, pois há praticamente 0 risco.

Por último, o sistema composto da opinião 3 é, dentre os 3, o que mais se parece com a realidade. Isso porque, mesmo que de forma desorganizada e sem sentido lógico, os agentes acabam tendo opiniões diferentes, o que resulta em ganhadores e perdedores.

A imagem abaixo mostra as distribuições de retorno para cada um dos 3 casos mencionados:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de Opinião 1]]
! [[Arquivo:Opinion2 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de Opinião 2]]
! [[Arquivo:Opinion3 kde.png|350px|thumb|center|Distribuição de retornos para 100% da rede contendo agentes de Opinião 3]]
|}

Enquanto que, para a rede composta apenas de agentes com opinião 1, temos caudas tão pesadas que apresentam sub-picos, na rede composta de opinião 2 a cauda é leve, e basicamente todos os retornos estão situados bem próximos à média da distribuição. Por último, para o caso 3, a cauda é pesada, porém ainda há concentração grande de retornos muito próximos ao centro da distribuição.

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-23T23:28:45Z

Bleo: /* Simulação de Mercados de Ações */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j} J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>

Neste trabalho, o termo <math>J_{ij}</math> é tomado como uma constante <math>J</math>, e ele é responsável pela indução de ordem ferromagnética local. Em particular, o segundo acomplamento permite casos de ordem ferromagnética local e ordem antiferromagnética global.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 3]]
|}

Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor.

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-23T23:13:08Z

Bleo: /* Simulação de Mercados de Ações */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Por simplicidade, assume-se que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}
</math>
Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j} J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 3]]
|}

Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor.

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-23T23:07:50Z

Bleo: /* Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i \frac{1}{N} \sum_{j} S_j</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i</math> representa a estratégia com relação à magnetização da rede.

Considerando um modelo com <math>i = 1,...,N</math> spins, com as orientações <math>S_i(t) = \pm 1</math>, a dinâmica dos spins dependerá do campo local <math>h_i(t)</math>:
<math>h_i(t) = \sum_{j} J_{ij} S_j - \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>
Por simplicidade, assuma que cada spin é atualizado com uma dinâmica de banho térmico de acordo com:
<math>S_i(t+1) = \begin{cases}
+1, & \text{com } p = 1/[1 + exp(-2 \beta h_i(t))] \\
-1, & \text{com } 1 - p
\end{cases}

</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*para números muito grandes de agentes, há uma distribuição de retorno de cauda mais leve, o que implica em muito menos situações de alto retorno, um mercado mais estável e consequentemente irreal.

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a sua auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis, e portanto não descrevem tão bem um sistema financeiro;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a partir da simulação com 1024 agentes, nota-se a presença de ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil se comparada com um mercado real. Com isto, considera-se que a grade de tamanho 32x32 melhor representa um mercado de ações, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 3]]
|}

Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor.

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-23T22:04:05Z

Bleo: /* Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

===Simulação de Mercados de Ações===
Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i(t)</math> representa a estratégia com relação à magnetização da rede.

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a simulação com 1024 agentes apresenta ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil, não descrevendo muito bem o mercado. Com isto, considera-se que a grade de tamanho 32x32 melhor descreve o mercado, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 3]]
|}

Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor.

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-23T22:02:59Z

Bleo: /* Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como lei de potências distribuídas dos retornos <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:
# O quê os vizinhos fazem: comumente associado à ação de chartistas;
# O quê a minoria faz: comportamento associado a fundamentalistas, ''traders'' com maior conhecimento sobre valores fundamentais dos mercados de ações.

Neste modelo, essas duas interações conflitantes são combinadas: as interações entre vizinhos são representadas pelo modelo de Ising mais simples; um acoplamento à minoria como um observável global é introduzido por um acoplamento à magnetização global do sistema de spins. Assim, o hamiltoniano incrementado fica com a seguinte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>
onde <math>\alpha</math> é o termo de acomplamento de cada spin com a magnetização da rede<math>(\alpha > 0)</math> e <math>C_i(t)</math> representa a estratégia com relação à magnetização da rede.
<math>\mathcal{h}</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a simulação com 1024 agentes apresenta ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil, não descrevendo muito bem o mercado. Com isto, considera-se que a grade de tamanho 32x32 melhor descreve o mercado, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 3]]
|}

Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor.

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-23T21:36:17Z

Bleo: /* Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

OBJETIVO

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado de ações e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados. Para o caso em que <math>J_{ij} < 0</math>, os agentes irão adotar estratégias contrárias aos seus vizinhos, e isso também não nos levará a uma representação realista do mercado financeiro. Para que o modelo possa se aproximar da realidade, devemos incrementar o hamiltoniano do sistema.

Um modelo bastante próximo da realidade dos mercados de ações é o proposto por Lux e Marchesi [referências 12 e 13 bornholdt] que classificam os agentes em duas estratégias: os fundamentalistas e os chartistas. Este modelo reproduz muitas das propriedades observadas em mercados reais, como (power-law distribuited returns) <math>ret(t) = ln \left(\frac{p(t)}{p(t-1)} \right)</math> dos preços <math>p(t)</math> e uma alta correlação da volatilidade de preços. Além disso, no nível de estratégias, apresenta o fenômeno em que o número de chartistas (ou ''traders'' ruidoso)[talvez tirar essa parte] se correlacionam com fases de grande volatilidade, como visto em mercados reais. Este modelo tem grande sucesso, no entanto sua complexidade é alta. Stefan Bornholdt então propôs um modelo de máxima simplicidade, baseado no modelo de Ising, desenhado para simular a dinâmica de expectativas em sistemas de muitos agentes.

No modelo de Bornholdt, há pelo menos duas forças conflitantes vistas em ações econômicas:

<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>
onde <math>\alpha</math> é o termo de acomplamento do spin com a magnetização da rede toda <math>(\alpha > 0)</math>, <math>C_i(t)</math>

==Alguns conceitos importantes==

===Retornos <ref name='ret'>[http://www.portalaction.com.br/series-temporais/51-retornos Retornos. Portal Action.]</ref>===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos <ref name='kde'>[https://en.wikipedia.org/wiki/Kernel_density_estimation Kernel Density Estimation. Wikipedia]</ref>===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

[[Arquivo:Exemplo volatilidade.png|500px|thumb|right|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura ao lado.

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin <ref name='wiener1'>[https://mathworld.wolfram.com/Wiener-KhinchinTheorem.html Wiener-Khinchin Theorem. Wolfram Math World]</ref> <ref name='wiener2'>[https://en.wikipedia.org/wiki/Wiener%E2%80%93Khinchin_theorem Wiener–Khinchin theorem. Wikipedia]</ref> foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===

Um dos objetivos deste estudo é verificar qual o tamanho de grade gera um resultado que melhor simula um índice financeiro. A escolha de índices financeiros para comparação, ao invés de ações ou commodities, é por causa da instabilidade que ativos financeiros separados têm. Imaginando um cenário fictício onde uma empresa A vende sorvetes enquanto a empresa B vende chocolate quente. A tendência é que haja uma sazonalidade nos 2 ativos, de tal forma que, no verão, as ações de A subam enquanto B desce, e vice-versa no inverno. Porém, enquanto os 2 ativos estão se movimentando, o movimento do mercado representado por estas 2 ações permanece aproximadamente constante. Como índices financeiros são, na verdade, médias de um conjunto grande e diverso de ações presentes no mercado, são melhores para a comparação com o modelo.

Foram escolhidos 4 diferentes tamanhos de grade:

*16x16: 256 agentes
*32x32: 1024 agentes
*50x50: 2500 agentes
*100x100: 10000 agentes

Cada uma das simulações se deu sob as seguintes condições:

*<math>\alpha = 4</math>
*<math>J = 1</math>
*<math>T = 1,5 </math>
*Todos os agentes são racionais, ou seja, eles podem trocar de opinião ao longo da simulação, assumindo <math>C_i = -1</math> em alguns momentos e <math>C_i = 1</math> em outros, de acordo com o grupo que o agente está inserido: maioria ou minoria.

Abaixo é possível observar fotografias do sistema em diferentes instantes para cada uma das simulações:

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:N16.png|250px|thumb|center|Situação do sistema de 256 agentes (grade 16 x 16) em 9 instantes diferentes. ]]
! [[Arquivo:N32.png|250px|thumb|center|Situação do sistema de 1024 agentes (grade 32 x 32) em 9 instantes diferentes. ]]
! [[Arquivo:N50.png|250px|thumb|center|Situação do sistema de 2500 agentes (grade 50 x 50) em 9 instantes diferentes. ]]
! [[Arquivo:N100.jpg|250px|thumb|center|Situação do sistema de 10000 agentes (grade 100 x 100) em 9 instantes diferentes.]]
|}

Como saída da simulação é obtida uma série temporal dos valores de magnetização, que neste modelo significam o preço de um ativo presente no mercado. Utilizando a série de preços (magnetização), foi obtido, então, a série dos retornos logarítmicos normalizados, através do método explicado na seção dos [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Retornos|Retornos]]. Para comparar o modelo com dados reais, obteve-se as series temporais do preço de índices do mercado financeiro: Ibovespa, S&P 500, Dow Jones e NASDAQ. Esses dados foram obtidos com a biblioteca [https://pandas-datareader.readthedocs.io/en/latest/ ''Pandas Datareader''] do Python, que permite obter dados de páginas da internet como a [https://finance.yahoo.com/ ''Yahoo Finance''], que possui a série temporal dos preços de vários ativos financeiros. Assim como nas simulações, a partir da série de preços dos índices foram calculadas a série temporal dos retornos logarítmicos normalizados.

Na figura abaixo pode-se observar os retornos de cada simulação e índice financeiro:

[[Arquivo:Retornos.png|600px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

Alguns pontos interessantes a se observar:

*os retornos dos índices S&P 500, Dow Jones e NASDAQ são muito parecidos, isso de deve ao fato de que todos são índices de mercados dos Estados Unidos, enquanto o Ibovespa é um índice de mercado brasileiro;
*os retornos das simulações vão variando mais tempo perto do zero conforme o número de agentes cresce;
*conforme o número de agentes no sistema aumenta, diminui-se o número de transições agudas de retorno, representadas pelos picos no gráfico. Isso indica um mercado mais estável.
*o objeto da simulação não é retornar uma cópia do observado nos dados reais, mas sim um cenário parecido. O intuito é criar um novo mercado, artificial, com características parecidas ao observado nos mercados reais.

Para ter uma comparação melhor a fim de entender que tamanho de grade simula melhor um mercado financeiro, é importante ver a [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|distribuição dos retornos]] e a auto correlação das [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidades]]. Com base no conteúdo da seção [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Distribui.C3.A7.C3.A3o_dos_Retornos_.5B2.5D|Distribuição dos Retornos]] foi gerado uma curva de densidade de probabilidade para cada série de retorno, que podem ser observadas na figura abaixo:

[[Arquivo:Dist.png|600px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

Desta figura pode-se também observar alguns pontos:

*quanto maior o número de agentes, mais longe a distribuição dos retornos das simulações ficam da distribuição dos retornos dos índices de mercado;
*as caudas das distribuições dos retornos das simulações vão ficando mais pesadas conforme o número de agentes diminui, o que indica mais uma vez que as simulações com menor número de agentes possuem distribuição dos retornos mais parecidas com a do mercado financeiro, que também possui uma cauda pesada;
*

Na figura abaixo estão presentes as auto correlações dos retornos quadrados, ou seja, da [[Modelo_de_Bornholdt_para_simulação_de_mercados_financeiros_artificiais#Volatilidade|volatilidade]] dos retornos:

[[Arquivo:Volatilidade.png|600px|thumb|center|Auto correlação das volatilidades dos retornos das simulações (primeira coluna) e do retorno dos índices financeiros (segunda coluna). Em ambas as colunas, a escala dos eixos y e x dos gráficos é logarítmica.]]

Desta imagem são notados alguns aspectos como:

*o comportamento da auto correlação das volatilidades das simulações com mais agentes são mais parecidas com as dos índices financeiros;
*embora a simulação com 256 agentes tenha a distribuição dos retornos que mais se aproximou, analisando a auto correlação da volatilidade se observa que para este número de agentes os retornos são muito voláteis;
*mesmo que as simulações com maior número de agentes apresente a auto correlação das volatilidades mais similar as do mercado financeiro, a simulação com 1024 agentes apresenta ''clusters'' de volatilidade, comprovando o fato estilizado de que existe memória do retorno quadrado.

Considerando os pontos apresentados, percebe-se que grades de um tamanho grande não descrevem o mercado financeiro da melhor forma, e da mesma forma, mesmo que aparente descrever bem devido a distribuição de retornos semelhantes a do mercado financeiro, a simulação de 256 agentes é muito volátil, não descrevendo muito bem o mercado. Com isto, considera-se que a grade de tamanho 32x32 melhor descreve o mercado, pois possui uma distribuição dos retornos que não difere tanto da distribuição dos retornos dos índices financeiros, e ainda apresenta o fato estilizado da memória da volatilidade.

===Variação da opinião dos agentes===

O parâmetro <math>C_i</math>, como dito anteriormente, indica a opinião de um agente <math>i</math> presente na rede. Esta opinião está relacionada a seguir (ou não) o comportamento da maioria dos outros agentes presentes no sistema.

Por consequência, pode-se resumir as possíveis opiniões que um agente tem na rede em 3 ramos diferentes:

*Opinião 1: <math>C_i = +1</math>. Agente que opõe sua opinião à da maioria dos outros agentes no sistema, chamado de '''fundamentalista'''. Recebem este nome pois se apoiam no princípio fundamental de oferta e demanda da economia, o qual diz que, com demanda maior, a oferta é menor, enquanto que para demandas menores, a oferta é maior. Logo, opinando diferente da maioria, garante-se um maior retorno.
*Opinião 2: <math>C_i = -1</math>. Agente que iguala sua opinião à da maioria dos outros agentes no sistema, chamado de '''chartista'''. Recebe este nome do termo em inglês ''chart'' (gráfico). São agentes que sempre analisam, através de gráficos, as ações em alta, para comprá-las, e as em baixa, para vendê-las. Por isso, seguem a maioria do sistema.
*Opinião 3: <math>C_i = c \in \{-1;+1\}</math>. Agente que não possui estratégia, e a cada passo da simulação joga aleatoriamente do lado dos chartistas ou fundamentalistas, sem raciocínio. É chamado de '''completamente irracional'''.

Abaixo, estão gráficos que mostram o comportamento do sistema composto inteiramente por cada tipo de opinião considerada na rede.

{| style="margin-left: auto; margin-right: auto; border: none;"
|-
! [[Arquivo:Opinion1.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 1]]
! [[Arquivo:Opinion2.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 2]]
! [[Arquivo:Opinion3.png|350px|thumb|center|Simulação com 100% da rede contendo agentes de Opinião 3]]
|}

Para o sistema composto apenas pela opinião 1, nota-se uma volatilidade muito grande na série temporal. Como os agentes de opinião 1 sempre jogam contra a maioria, quando o sistema atinge um estado de preços grande o suficiente, por exemplo, ocorre uma "debandada" dos agentes, que passam a opinar contra. Desta forma, o preço abaixa rapidamente, até chegar num estado suficientemente baixo, onde os agentes passam a opinar a favor.

==Conclusões==

==Programas==

===Código para obter a série temporal do preço dos índices financeiros===
<source lang="python">
import pandas_datareader as pdr
from datetime import datetime

ibov = pdr.get_data_yahoo(symbols='^BVSP',start=datetime(1995,1,1),end=datetime(2021,1,1))
SP500 = pdr.get_data_yahoo(symbols='^GSPC',start=datetime(1995,1,1),end=datetime(2021,1,1))
DJ = pdr.get_data_yahoo(symbols='^DJI',start=datetime(1995,1,1),end=datetime(2021,1,1))
Nasdaq = pdr.get_data_yahoo(symbols='^IXIC',start=datetime(1995,1,1),end=datetime(2021,1,1))
</source>

===Código para calcular os retornos e para os normalizar===
<source lang="python">
def ret(x):
N = len(x)

y = []
for i in range(N-1):
r = np.log(x[i+1])-np.log(x[i])
y.append(r)

return y

def normalize(x):

N = len(x)
y = []

for i in range(N):
n = x[i] - np.mean(x)
n = n/np.std(x)

y.append(n)

return np.array(y)
</source>

===Código que realiza a estimativa de densidade ''kernel''===

<source lang="python">
def gauss(x,mean,std_dev):
u = (x - mean) / std_dev
c = 1 / (np.sqrt(2 * np.pi))
return c * np.exp(- 0.5 * u ** 2)

def kde(x,kernel="gauss",bw=0.1,n_points=1500):
kernel_options = ["gauss"]
data = np.array(x)
x_kde = np.linspace(np.min(data)-bw,np.max(data)+bw,n_points)
n = data.shape[0] #Number of rows
m = x_kde.shape[0] #Number of columns
kde_i = []
if kernel == kernel_options[0]:
for x in data:
kde_i.append(gauss(x_kde,x,bw))
else:
print("Kernel not found!")
print("Kernel options are:")
for k in kernel_options:
print(" - " + k)
return np.nan

kde_i = np.array(kde_i).reshape(n,m)

kde = np.array([np.sum(kde_i[:,i]) for i in np.arange(m)])
kde_norm = kde / np.sum(kde)
return x_kde,kde_norm
</source>

===Código para calcular a auto correlação das volatilidades===
<source lang="python">
from scipy.signal import get_window
from scipy.fft import rfft, rfftfreq, irfft

def fft_calculation(y,window="parzen"):
w = get_window(window=window, Nx=len(y))
f = y * w
freqs = np.fft.rfftfreq(len(y))
return freqs,np.abs(rfft(f))

def autocorr_calculation(y):
ift = irfft(np.abs(y) ** 2)
ift_norm = np.abs(ift) / np.abs(ift).max()
return ift_norm

w_ibov, s_ibov = fft_calculation(np.array(normalize(r_ibov))**2)
c_ibov = autocorr_calculation(s_ibov)

w_sp500, s_sp500 = fft_calculation(np.array(normalize(r_SP500))**2)
c_sp500 = autocorr_calculation(s_sp500)

w_DJ, s_DJ = fft_calculation(np.array(normalize(r_DJ))**2)
c_DJ = autocorr_calculation(s_DJ)

w_nasdaq, s_nasdaq = fft_calculation(np.array(normalize(r_nasdaq))**2)
c_nasdaq = autocorr_calculation(s_nasdaq)

w100, s100 = fft_calculation(np.array(normalize(R100))**2)
c100 = autocorr_calculation(s100)

w50, s50 = fft_calculation(np.array(normalize(R50))**2)
c50 = autocorr_calculation(s50)

w32, s32 = fft_calculation(np.array(normalize(R32))**2)
c32 = autocorr_calculation(s32)

w16, s16 = fft_calculation(np.array(normalize(R16))**2)
c16 = autocorr_calculation(s16)
</source>

===Código para gerar a figura dos retornos===
<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(np.arange(len(R16)),R16,'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(np.arange(len(R32)),R32,'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(np.arange(len(R50)),R50,'blue',label='# agentes = 2500')
ax[3][0].plot(np.arange(len(R100)),R100,'midnightblue',label='# agentes = 10000')

ax[0][1].plot(np.arange(len(r_ibov)),normalize(r_ibov),'pink',label='Ibovespa')
ax[1][1].plot(np.arange(len(r_SP500)),normalize(r_SP500),'palevioletred',label='S&P500')
ax[2][1].plot(np.arange(len(r_DJ)),normalize(r_DJ),'mediumvioletred',label='Dow Jones')
ax[3][1].plot(np.arange(len(r_nasdaq)),normalize(r_nasdaq),'purple',label='NASDAQ')

# Setting labels & titles

fig.suptitle('Retornos(t)',fontsize=14)
fig.text(0.5,0, 't', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Índices', ha='center', fontsize=12)
fig.text(0, 0.5, 'r(t)', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='upper left')

fig.tight_layout()
plt.show()
</source>

===Código para gerar a figura da distribuição dos retornos===
<source lang="python">
y100 = np.array(R100)
y50 = np.array(R50)
y32 = np.array(R32)
y16 = np.array(R16)

kde100 = kde(y100,"gauss",np.std(y100)/3,1500)
kde50 = kde(y50,"gauss",np.std(y50)/3,1500)
kde32 = kde(y32,"gauss",np.std(y32)/3,1500)
kde16 = kde(y16,"gauss",np.std(y16)/3,1500)

y_ibov = np.array(normalize(r_ibov))
y_sp500 = np.array(normalize(r_SP500))
y_dj = np.array(normalize(r_DJ))
y_nasdaq = np.array(normalize(r_nasdaq))

kde_ibov = kde(y_ibov,"gauss",np.std(y_ibov)/3,1500)
kde_sp500= kde(y_sp500,"gauss",np.std(y_sp500)/3,1500)
kde_dj = kde(y_dj,"gauss",np.std(y_dj)/3,1500)
kde_nasdaq = kde(y_nasdaq,"gauss",np.std(y_nasdaq)/3,1500)

fig, ax = plt.subplots(figsize=(10,6))

ax.set_xlabel('Retorno normalizado',fontsize=12)
ax.set_ylabel('Densidade de probabilidade',fontsize=12)
fig.suptitle('Distribuição do retorno (normalizado)',fontsize=14)

plt.plot(kde100[0],kde100[1],label='# agentes 10000')
plt.plot(kde50[0],kde50[1],label='# agentes 2500')
plt.plot(kde32[0],kde32[1],label='# agentes 1024')
plt.plot(kde16[0],kde16[1],label='16')

plt.plot(kde_ibov[0],kde_ibov[1],'--',label='Ibovespa')
plt.plot(kde_sp500[0],kde_sp500[1],'--', label='S&P500')
plt.plot(kde_dj[0],kde_dj[1],'--', label='Dow Jones')
plt.plot(kde_nasdaq[0],kde_nasdaq[1],'--', label='NASDAQ')

ax.set_xlim(-3,3)
plt.legend()
fig.tight_layout()
</source>

===Código para gerar a figura da auto correlação das volatilidades===

<source lang="python">
fig, ax = plt.subplots(4,2,figsize=(10,7))

ax[0][0].plot(c16[:int(len(c16)/2)],'lightsteelblue',label='# agentes = 256')
ax[1][0].plot(c32[:int(len(c32)/2)],'cornflowerblue',label='# agentes = 1024')
ax[2][0].plot(c50[:int(len(c50)/2)],'blue',label='# agentes = 2500')
ax[3][0].plot(c100[:int(len(c100)/2)],'midnightblue',label='# agentes = 10000')

ax[0][1].plot(c_ibov[:int(len(c_ibov)/2)],'pink',label='Ibovespa')
ax[1][1].plot(c_sp500[:int(len(c_sp500)/2)],'palevioletred',label='S&P500')
ax[2][1].plot(c_DJ[:int(len(c_DJ)/2)],'mediumvioletred',label='Dow Jones')
ax[3][1].plot(c_nasdaq[:int(len(c_nasdaq)/2)],'purple',label='NASDAQ')

# Setting labels & titles
#ax[2].set_xlabel('Data',fontsize=12)
#ax[1].set_ylabel('Retorno',fontsize=12)
fig.suptitle('Autocorrelação das volatilidades',fontsize=14)
fig.text(0.5,0, '$\\tau$', ha='center', fontsize=12)
fig.text(0.28,0.93, 'Bornholdt', ha='center', fontsize=12)
fig.text(0.77,0.93, 'Indíces', ha='center', fontsize=12)
fig.text(0, 0.5, '$A(\\tau)$', va='center', rotation='vertical',fontsize=12)

for aa in ax:
for a in aa:
a.xaxis.set_major_locator(plt.MaxNLocator(8))
a.yaxis.set_major_locator(plt.MaxNLocator(5))
a.legend(loc='lower left')
a.set_yscale('log')
a.set_xscale('log')

fig.tight_layout()
plt.show()
</source>

==Referências==

<references/>

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-22T18:50:47Z

Bleo: /* Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples, que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado financeiro e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados.

O Modelo de Bornholdt, se incluid {coisas do artigo}. Assim, o hamiltoniano do sistema fica complementado:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i S_j - \sum_{i} \alpha C_i(t) \frac{1}{N} \sum_{j} S_j(t)</math>
onde <math>\alpha</math> é o termo de acomplamento do spin com a rede toda <math>(\alpha > 0)</math>

==Alguns conceitos importantes==

===Retornos===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura abaixo:

[[Arquivo:Exemplo volatilidade.png|700px|thumb|center|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===
Em Julia, 8000 passos de MC
16x16: 0.512 s
32x32: 2.332 s
50x50: 10.674 s
100x100: 154.134 s

[[Arquivo:Retornos.png|700px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

[[Arquivo:Dist.png|700px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

==Conclusões==

==Programas==

Modelo de Bornholdt para simulação de mercados financeiros artificiais

2021-05-22T18:33:39Z

Bleo: /* Modelo de Bornholdt */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

==Modelo de Bornholdt==
Para estudar os fenômenos físicos que nos rodeiam, usamos modelos matemáticos para entender como sistemas evoluem com o tempo. No entanto, esses modelos muitas vezes podem ser base para estudos além do sistema físico de interesse. Para um sistema de spins, um dos modelos mais simples, que leva em conta apenas a interação de cada spin com seus primeiros vizinhos, é o Modelo de Ising. O hamiltoniano que o descreve é defindo pela segunte expressão:
<math>\mathcal{H} = \sum_{\langle i, j \rangle} J_{ij} S_i^z S_j^z</math>
onde <math>J_{ij}</math> é o termo que define a força de interação entre os spins '''i''' e '''j''' e <math>S^z</math> a componente Z do spin. Além disso <math>\langle i, j \rangle</math> denota que estamos somando somente sobre os primeiros vizinhos. Para um valor de <math>J_{ij} > 0</math>, a interação ferromagnética é favorecida, e os spins vizinhos tendem a se alinhar conjuntamente, formando domínios magnéticos. No entanto, para <math>J_{ij} < 0</math> a interação antiferromagnética é favorecida, e os spins tende a se "anti-alinhar".

Podemos fazer um paralelo interessante entre os spins e a sua interação com seus vizinhos com ''traders'' em mercados finaceiros e a suas interações com outros ''traders''. No caso do Modelo de Ising, podemos interpretar cada spin como um ''trader'', ou agente, em um mercado financeiro e a direção da componente Z desse spin como a sua estratégia de compra ou venda. Então neste caso mais simples, para <math>J_{ij} > 0</math>, os agentes tenderão a adotar a mesma estratégia de mercado, e isso não descreve bem a realidade dos mercados.

==Alguns conceitos importantes==

===Retornos===

Quando se trata de sistemas financeiros, os estudos se concentram mais no retorno dos ativos do que no preço em si, pois a série temporal dos retornos tem propriedades estatísticas mais interessantes que a série dos preços.

Sendo ''P(t)'' o preço de um ativo financeiro no instante ''t'', e ''P(t-1)'' o preço do ativo no instante ''(t-1)'', o retorno linear do ativo é:

<math>r(t) = \frac{P(t) - P(t-1)}{P(t-1)}</math>

Reescrevendo esta equação, obtemos que:

<math>r(t) + 1= \frac{P(t)}{P(t-1)}</math>

Aplicando a função logarítmica em ambos os lados da equação, e considerando que:

<math>ln(x + 1) \approx x</math>

obtêm-se o retorno logarítmico, que é mais indicado quando se têm ativos voláteis, que possuem uma variação muito alta:

<math>r(t) = ln\left(\frac{P(t)}{P(t-1)}\right)</math>

Considerando que neste estudo serão comparados retornos de diferentes índices, e também os retornos obtidos através das simulações com o modelo de Bornholdt, é importante normalizar os retornos:

<math>\bar{r}_n = \frac{r_n - \langle r \rangle}{\sigma_r}</math>

em que <math>\sigma_r</math> é o desvio padrão da serie de retornos e <math>\langle r \rangle</math> a média.

===Distribuição dos Retornos===
Quando se tem um volume considerável de dados é possível obter a distribuição probabilística deles. Para isso pode-se utilizar a estimação de densidade de Kernel (KDE). Ao observar uma pequena janela de tamanho ''h'' em torno de um ponto em análise, pode-se dizer que:

<math>P(x-h \leq x \leq x+h ) \approx \frac{1}{N}\sum_n^N W(u) </math>

sendo <math>W(u)</math> uma função ''kernel'' e <math>u</math> uma variável tal que:

<math>u = \frac{x - x_n}{2h}</math>

Para este estudo utilizou-se um ''kernel'' gaussiano:

<math>W(u) = \frac{1}{\sqrt{2\pi}} e^{-\frac{1}{2}u^2}</math>

Este método foi aplicado para as séries de retorno para obter a distribuição deles, utilizando <math>h = 0.5 \sigma</math>.

===Volatilidade===

Uma forma de calcular a volatilidade da série temporal de retornos ao longo do tempo é elevar ao quadrado os valores da série. Deste modo pode-se obter uma variável como a que está ilustrada na figura abaixo:

[[Arquivo:Exemplo volatilidade.png|700px|thumb|center|Exemplo de uso da volatilidade como série temporal de um retorno arbitrário.]]

O interessante em estudar volatilidade de retornos financeiros é que essa variável reflete o quão ''imprevisível'' é um determinado ativo. Uma ação com alta volatilidade tende a ter um risco maior de investimento, ao passo que ações com baixa volatilidade geralmente retornam riscos menores, pois seu comportamento acaba sendo mais previsível.

Um fato estilizado financeiro é que a volatilidade das séries temporais de retorno apresentam comportamento sazonal por natureza. Há períodos de alta volatilidade, seguidos por períodos com baixa volatilidade, que então são novamente seguidos por alta volatilidade, e assim adiante. E uma forma de mensurar isto é verificando a presença de ''clusters'' de autocorrelação na volatilidade de retornos. Isto é, através da análise da autocorrelação da volatilidade, encontrar bolhas que indiquem as fases destes comportamentos.

Para obter a auto correlação o Teorema de Wiener-Khinchin foi utilizado, de forma que:

<math>A(\tau) =\mathcal{F}\{|S(\omega)|^2\}</math>

onde <math>S(\omega)</math> é a transformada de Fourier do quadrado dos retornos.

==Simulações==
===Variação do tamanho da grade===
Em Julia, 8000 passos de MC
16x16: 0.512 s
32x32: 2.332 s
50x50: 10.674 s
100x100: 154.134 s

[[Arquivo:Retornos.png|700px|thumb|center|Retornos logarítmicos normalizados obtidos para as simulações com diferentes números de agentes (tamanho da grade) na primeira coluna, e na segunda coluna os retornos logarítmicos normalizados para os índices financeiros Ibovespa, S&P 500, Dow Jones e NASDAQ]]

[[Arquivo:Dist.png|700px|thumb|center|Distribuição dos retornos das simulações (linha cheia) e dos índices financeiros (linha tracejada). Percebe-se que a distribuição dos retornos das simulações que mais se aproximam da distribuição dos índices financeiros são as que possuem um menor número de agentes.]]

==Conclusões==

==Programas==

Modelo de Keller-Segel para relação população-economia

2021-04-06T00:44:38Z

Bleo: /* 2D */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>, que originalmente descreve o movimento de células em direção a um sinal químico, para um sistema englobando população e atividade econômica, problema proposto no livro ''Introduction to the Modeling and Analysis of Complex Sistems '' de Hiroki Sayama <ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref>. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space''), método de resolução de equações diferenciais parciais, como a equação do calor e a da difusão, que é o caso deste trabalho.

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'', a taxa com que as células se movem em direção ao sinal químico, tem papel crítico na auto-organização das células. <ref name = 'thesis'> Hoffmann, F. C. O. Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis , Tese de doutorado. 2017 [https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]</ref>

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas <ref name='sayama'></ref>:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica<ref name='sayama'></ref>:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

O trabalho agora é traduzir essas premissas em equações. O primeiro ponto diz que que padrão não há mudança na população, dessa forma:
:<math>\frac{\partial p}{\partial t} = 0</math>

O segundo ponto nos diz que a economia tem um aumento que depende da quantidade de pessoas, e assim:

:<math>\frac{\partial m}{\partial t} = \alpha p</math>

em que <math>\alpha</math> é a taxa de aumento da atividade econômica per capita.

O terceiro ponto diz que a atividade econômica decai quando não há pessoas, e para isso adicionamos um termo de decaimento na equação:
:<math>\frac{\partial m}{\partial t} = \alpha p - \beta m</math>
em que <math>\beta</math> é a taxa de decaimento da atividade econômica.

O quarto ponto fala que tanto população quanto a atividade econômica difundem, o que uma premissa sobre o movimento espacial. Para isso são adicionados termos de difusão, os Laplacianos, as equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

onde <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da atividade econômica respectivamente.

O quinto e último ponto fala que as pessoas são atraídas pela atividade econômica e assim se movem para áreas que possuem mais dinheiro. Para cumprir essa premissa, a equação do transporte é utilizada:

:<math>
- \nabla \cdot (p \gamma \nabla m)
</math>

em que o gradiente de <math>m</math> é utilizado para obter a velocidade média do movimento da população, sendo <math>\gamma</math> uma constante que afeta essa velocidade.

O sistema de equação final fica da seguinte forma:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos, <ref name='scherer'>Scherer, C. Métodos Computacionais da Física. 2010
</ref>
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de explorar e estudar a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como um anel, onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de formato gaussiano sob a malha. Por isso, é interessante analisar a solução estacionária (se existir).

Como as equações diferenciais do sistema são dependentes umas das outras (isto é, a equação de m(x,t) depende de p(x,t) e a de p depende de m), a solução não é trivial. Utilizando o Método de Coeficientes a Determinar para solução de equações diferenciais em estado estacionário, conseguimos a seguinte relação genérica, que se mostra útil:

<math> m(x,t) = A_1 e^{- B_1 x^2} + A_2 p(x,t) + A_3 </math>

Onde <math>A_1,A_2,A_3</math> e <math>B_1</math> são constantes que dependem das condições iniciais do problema. Como o objetivo do trabalho não é resolver analiticamente esta EDP, estas constantes não foram calculadas.

Mas a equação acima mostra que, para o estado estacionário, o formato gaussiano obtido era previsto na solução analítica também. Portanto, o resultado obtido apresenta coerência.

Mais um ponto a ser aferido é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Um cuidado importante na iniciação deste sistema é que, como estamos modelando a densidade populacional, e consideramos que não há perda de população com o tempo, a integral da função p(x,t) deve ser sempre igual a 1. Em t=0, na iniciação do sistema, é necessário implementar esta condição ao problema, para que ela se mantenha durante a simulação. Para isso, basta sortear valores e normalizá-los depois. Um exemplo de código simples em Python que realiza esta operação está indicado abaixo.

<source lang="python">
import numpy as np
N = 100 #Limite no eixo x
p_auxiliar = np.random.rand(N) #Vetor auxiliar
p = p_auxiliar / np.sum(p_auxiliar) #Normalização, para que a soma de p em todo x seja 1
</source>

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se notar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao estacionário, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

Mais uma vez, como iniciamos aleatoriamente a população, é importante normalizá-la para que a integral seja igual a 1, como dito acima.

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial aleatório do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de formato gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

Para a geração da evolução do sistema e do gif, o código utilizado foi o seguinte:
<source lang="python">
L = 100 # Tamanho do Grid
D_p = 0.5 # Coeficiente de difusão de pessoas
D_m = 0.5 # Coeficiente de difusão de dinheiro
ds = 1 # Diferencial Espacial
dt = 0.3 # Diferencial Temporal
alfa = 1.2 # Taxa de produção de economia per capita
beta = 0.03 # Taxa de decaimente da economia
gamma = 1 # Taxa de velocidade com que as pessoas migram em direção ao dinheiro

# CRIA OBJETO DE PARÂMETROS PARA O MODELO #
parametros = ParametrosKellerSegelModel(L, L, D_p, D_m, ds, dt, alfa, beta, gamma)

# INICIALIZA O MODELO COM OS PARÂMETROS #
modelo = KellerSegelModel(parametros)

# GERA CONDIÇÕES INICIAIS A SEREM ESTUDADAS #
condicao_inicial_populacao = np.matrix(np.full((parametros.N_x, parametros.N_x), 1 / (L ** 2)))
condicao_inicial_dinheiro = np.matrix(np.zeros((parametros.N_y, parametros.N_y)))

condicao_inicial_dinheiro[(0, 0)] = 0.125
condicao_inicial_dinheiro[(0, 99)] = 0.125
condicao_inicial_dinheiro[(99, 99)] = 0.125
condicao_inicial_dinheiro[(99, 0)] = 0.125
condicao_inicial_dinheiro[(49, 49)] = 2
condicao_inicial_dinheiro[(49, 69)] = 1
condicao_inicial_dinheiro[(49, 29)] = 1
condicao_inicial_dinheiro[(69, 49)] = 1
condicao_inicial_dinheiro[(29, 49)] = 1

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE GRÁFICO ESTÁTICO
jpeg = JpegTool(nome_imagem = 'comparacao_tempos_pop_eco_2d')

# GERA GRÁFICOS
jpeg.geraJpeg(modelo)

# REINICIALIZA MODELO
modelo = KellerSegelModel(parametros)

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE ANIMACAO #
ani = AnimacaoTool(nome_gif = 'dinamica_pop_eco_2d')

# GERA GIF COM A EVOLUCAO DO MODELO #
ani.geraGif(modelo)
</source>

'''''Código completo se encontra no Github.'''''

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==

<references/>

Modelo de Keller-Segel para relação população-economia

2021-04-06T00:40:06Z

Bleo: /* 2D */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>, que originalmente descreve o movimento de células em direção a um sinal químico, para um sistema englobando população e atividade econômica, problema proposto no livro ''Introduction to the Modeling and Analysis of Complex Sistems '' de Hiroki Sayama <ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref>. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space''), método de resolução de equações diferenciais parciais, como a equação do calor e a da difusão, que é o caso deste trabalho.

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'', a taxa com que as células se movem em direção ao sinal químico, tem papel crítico na auto-organização das células. <ref name = 'thesis'> Hoffmann, F. C. O. Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis , Tese de doutorado. 2017 [https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]</ref>

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas <ref name='sayama'></ref>:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica<ref name='sayama'></ref>:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

O trabalho agora é traduzir essas premissas em equações. O primeiro ponto diz que que padrão não há mudança na população, dessa forma:
:<math>\frac{\partial p}{\partial t} = 0</math>

O segundo ponto nos diz que a economia tem um aumento que depende da quantidade de pessoas, e assim:

:<math>\frac{\partial m}{\partial t} = \alpha p</math>

em que <math>\alpha</math> é a taxa de aumento da atividade econômica per capita.

O terceiro ponto diz que a atividade econômica decai quando não há pessoas, e para isso adicionamos um termo de decaimento na equação:
:<math>\frac{\partial m}{\partial t} = \alpha p - \beta m</math>
em que <math>\beta</math> é a taxa de decaimento da atividade econômica.

O quarto ponto fala que tanto população quanto a atividade econômica difundem, o que uma premissa sobre o movimento espacial. Para isso são adicionados termos de difusão, os Laplacianos, as equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

onde <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da atividade econômica respectivamente.

O quinto e último ponto fala que as pessoas são atraídas pela atividade econômica e assim se movem para áreas que possuem mais dinheiro. Para cumprir essa premissa, a equação do transporte é utilizada:

:<math>
- \nabla \cdot (p \gamma \nabla m)
</math>

em que o gradiente de <math>m</math> é utilizado para obter a velocidade média do movimento da população, sendo <math>\gamma</math> uma constante que afeta essa velocidade.

O sistema de equação final fica da seguinte forma:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos, <ref name='scherer'>Scherer, C. Métodos Computacionais da Física. 2010
</ref>
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de explorar e estudar a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como um anel, onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de formato gaussiano sob a malha. Por isso, é interessante analisar a solução estacionária (se existir).

Como as equações diferenciais do sistema são dependentes umas das outras (isto é, a equação de m(x,t) depende de p(x,t) e a de p depende de m), a solução não é trivial. Utilizando o Método de Coeficientes a Determinar para solução de equações diferenciais em estado estacionário, conseguimos a seguinte relação genérica, que se mostra útil:

<math> m(x,t) = A_1 e^{- B_1 x^2} + A_2 p(x,t) + A_3 </math>

Onde <math>A_1,A_2,A_3</math> e <math>B_1</math> são constantes que dependem das condições iniciais do problema. Como o objetivo do trabalho não é resolver analiticamente esta EDP, estas constantes não foram calculadas.

Mas a equação acima mostra que, para o estado estacionário, o formato gaussiano obtido era previsto na solução analítica também. Portanto, o resultado obtido apresenta coerência.

Mais um ponto a ser aferido é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Um cuidado importante na iniciação deste sistema é que, como estamos modelando a densidade populacional, e consideramos que não há perda de população com o tempo, a integral da função p(x,t) deve ser sempre igual a 1. Em t=0, na iniciação do sistema, é necessário implementar esta condição ao problema, para que ela se mantenha durante a simulação. Para isso, basta sortear valores e normalizá-los depois. Um exemplo de código simples em Python que realiza esta operação está indicado abaixo.

<source lang="python">
import numpy as np
N = 100 #Limite no eixo x
p_auxiliar = np.random.rand(N) #Vetor auxiliar
p = p_auxiliar / np.sum(p_auxiliar) #Normalização, para que a soma de p em todo x seja 1
</source>

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se notar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao estacionário, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

Mais uma vez, como iniciamos aleatoriamente a população, é importante normalizá-la para que a integral seja igual a 1, como dito acima.

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial aleatório do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de formato gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

Para a geração da evolução do sistema e do gif, o código utilizado foi o seguinte:
<source lang="python">
L = 100 # Tamanho do Grid
D_p = 0.5 # Coeficiente de difusão de pessoas
D_m = 0.5 # Coeficiente de difusão de dinheiro
ds = 1 # Diferencial Espacial
dt = 0.3 # Diferencial Temporal
alfa = 1.2 # Taxa de produção de economia per capita
beta = 0.03 # Taxa de decaimente da economia
gamma = 1 # Taxa de velocidade com que as pessoas migram em direção ao dinheiro

# CRIA OBJETO DE PARÂMETROS PARA O MODELO #
parametros = ParametrosKellerSegelModel(L, L, D_p, D_m, ds, dt, alfa, beta, gamma)

# INICIALIZA O MODELO COM OS PARÂMETROS #
modelo = KellerSegelModel(parametros)

# GERA CONDIÇÕES INICIAIS A SEREM ESTUDADAS #
condicao_inicial_populacao = np.matrix(np.full((parametros.N_x, parametros.N_x), 1 / (L ** 2)))
condicao_inicial_dinheiro = np.matrix(np.zeros((parametros.N_y, parametros.N_y)))

condicao_inicial_dinheiro[(0, 0)] = 0.125
condicao_inicial_dinheiro[(0, 99)] = 0.125
condicao_inicial_dinheiro[(99, 99)] = 0.125
condicao_inicial_dinheiro[(99, 0)] = 0.125
condicao_inicial_dinheiro[(49, 49)] = 2
condicao_inicial_dinheiro[(49, 69)] = 1
condicao_inicial_dinheiro[(49, 29)] = 1
condicao_inicial_dinheiro[(69, 49)] = 1
condicao_inicial_dinheiro[(29, 49)] = 1

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE GRÁFICO ESTÁTICO
jpeg = JpegTool(nome_imagem = 'comparacao_tempos_pop_eco_2d')

# GERA GRÁFICOS
jpeg.geraJpeg(modelo)

# REINICIALIZA MODELO
modelo = KellerSegelModel(parametros)

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE ANIMACAO #
ani = AnimacaoTool(nome_gif = 'dinamica_pop_eco_2d')

# GERA GIF COM A EVOLUCAO DO MODELO #
ani.geraGif(modelo)
</source>

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==

<references/>

Modelo de Keller-Segel para relação população-economia

2021-04-06T00:38:59Z

Bleo: /* 2D */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>, que originalmente descreve o movimento de células em direção a um sinal químico, para um sistema englobando população e atividade econômica, problema proposto no livro ''Introduction to the Modeling and Analysis of Complex Sistems '' de Hiroki Sayama <ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref>. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space''), método de resolução de equações diferenciais parciais, como a equação do calor e a da difusão, que é o caso deste trabalho.

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'', a taxa com que as células se movem em direção ao sinal químico, tem papel crítico na auto-organização das células. <ref name = 'thesis'> Hoffmann, F. C. O. Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis , Tese de doutorado. 2017 [https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]</ref>

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas <ref name='sayama'></ref>:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica<ref name='sayama'></ref>:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

O trabalho agora é traduzir essas premissas em equações. O primeiro ponto diz que que padrão não há mudança na população, dessa forma:
:<math>\frac{\partial p}{\partial t} = 0</math>

O segundo ponto nos diz que a economia tem um aumento que depende da quantidade de pessoas, e assim:

:<math>\frac{\partial m}{\partial t} = \alpha p</math>

em que <math>\alpha</math> é a taxa de aumento da atividade econômica per capita.

O terceiro ponto diz que a atividade econômica decai quando não há pessoas, e para isso adicionamos um termo de decaimento na equação:
:<math>\frac{\partial m}{\partial t} = \alpha p - \beta m</math>
em que <math>\beta</math> é a taxa de decaimento da atividade econômica.

O quarto ponto fala que tanto população quanto a atividade econômica difundem, o que uma premissa sobre o movimento espacial. Para isso são adicionados termos de difusão, os Laplacianos, as equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

onde <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da atividade econômica respectivamente.

O quinto e último ponto fala que as pessoas são atraídas pela atividade econômica e assim se movem para áreas que possuem mais dinheiro. Para cumprir essa premissa, a equação do transporte é utilizada:

:<math>
- \nabla \cdot (p \gamma \nabla m)
</math>

em que o gradiente de <math>m</math> é utilizado para obter a velocidade média do movimento da população, sendo <math>\gamma</math> uma constante que afeta essa velocidade.

O sistema de equação final fica da seguinte forma:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos, <ref name='scherer'>Scherer, C. Métodos Computacionais da Física. 2010
</ref>
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de explorar e estudar a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como um anel, onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de formato gaussiano sob a malha. Por isso, é interessante analisar a solução estacionária (se existir).

Como as equações diferenciais do sistema são dependentes umas das outras (isto é, a equação de m(x,t) depende de p(x,t) e a de p depende de m), a solução não é trivial. Utilizando o Método de Coeficientes a Determinar para solução de equações diferenciais em estado estacionário, conseguimos a seguinte relação genérica, que se mostra útil:

<math> m(x,t) = A_1 e^{- B_1 x^2} + A_2 p(x,t) + A_3 </math>

Onde <math>A_1,A_2,A_3</math> e <math>B_1</math> são constantes que dependem das condições iniciais do problema. Como o objetivo do trabalho não é resolver analiticamente esta EDP, estas constantes não foram calculadas.

Mas a equação acima mostra que, para o estado estacionário, o formato gaussiano obtido era previsto na solução analítica também. Portanto, o resultado obtido apresenta coerência.

Mais um ponto a ser aferido é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Um cuidado importante na iniciação deste sistema é que, como estamos modelando a densidade populacional, e consideramos que não há perda de população com o tempo, a integral da função p(x,t) deve ser sempre igual a 1. Em t=0, na iniciação do sistema, é necessário implementar esta condição ao problema, para que ela se mantenha durante a simulação. Para isso, basta sortear valores e normalizá-los depois. Um exemplo de código simples em Python que realiza esta operação está indicado abaixo.

<source lang="python">
import numpy as np
N = 100 #Limite no eixo x
p_auxiliar = np.random.rand(N) #Vetor auxiliar
p = p_auxiliar / np.sum(p_auxiliar) #Normalização, para que a soma de p em todo x seja 1
</source>

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se notar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao estacionário, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

Mais uma vez, como iniciamos aleatoriamente a população, é importante normalizá-la para que a integral seja igual a 1, como dito acima.

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial aleatório do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de formato gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

Para a geração da evolução do sistema e do gif, o código utilizado foi o seguinte:
<source lang="python">
L = 100 # Tamanho do Grid
D_p = 0.5 # Coeficiente de difusão de pessoas
D_m = 0.5 # Coeficiente de difusão de dinheiro
ds = 1 # Diferencial Espacial
dt = 0.3 # Diferencial Temporal
alfa = 1.2 # Taxa de produção de economia per capita
beta = 0.03 # Taxa de decaimente da economia
gamma = 1 # Taxa de velocidade com que as pessoas migram em direção ao dinheiro

# CRIA OBJETO DE PARÂMETROS PARA O MODELO #
parametros = ParametrosKellerSegelModel(L, L, D_p, D_m, ds, dt, alfa, beta, gamma)

# INICIALIZA O MODELO COM OS PARÂMETROS #
modelo = KellerSegelModel(parametros)

# GERA CONDIÇÕES INICIAIS A SEREM ESTUDADAS #
condicao_inicial_populacao = np.matrix(np.full((parametros.N_x, parametros.N_x), 1 / (L ** 2)))
condicao_inicial_dinheiro = np.matrix(np.full((parametros.N_y, parametros.N_y), 1 / (L ** 2)))

condicao_inicial_dinheiro[(0, 0)] = 0.125
condicao_inicial_dinheiro[(0, 99)] = 0.125
condicao_inicial_dinheiro[(99, 99)] = 0.125
condicao_inicial_dinheiro[(99, 0)] = 0.125
condicao_inicial_dinheiro[(49, 49)] = 2
condicao_inicial_dinheiro[(49, 69)] = 1
condicao_inicial_dinheiro[(49, 29)] = 1
condicao_inicial_dinheiro[(69, 49)] = 1
condicao_inicial_dinheiro[(29, 49)] = 1

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE GRÁFICO ESTÁTICO
jpeg = JpegTool(nome_imagem = 'comparacao_tempos_pop_eco_2d')

# GERA GRÁFICOS
jpeg.geraJpeg(modelo)

# REINICIALIZA MODELO
modelo = KellerSegelModel(parametros)

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE ANIMACAO #
ani = AnimacaoTool(nome_gif = 'dinamica_pop_eco_2d')

# GERA GIF COM A EVOLUCAO DO MODELO #
ani.geraGif(modelo)
</source>

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==

<references/>

Modelo de Keller-Segel para relação população-economia

2021-04-06T00:34:48Z

Bleo: /* 2D */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>, que originalmente descreve o movimento de células em direção a um sinal químico, para um sistema englobando população e atividade econômica, problema proposto no livro ''Introduction to the Modeling and Analysis of Complex Sistems '' de Hiroki Sayama <ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref>. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space''), método de resolução de equações diferenciais parciais, como a equação do calor e a da difusão, que é o caso deste trabalho.

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'', a taxa com que as células se movem em direção ao sinal químico, tem papel crítico na auto-organização das células. <ref name = 'thesis'> Hoffmann, F. C. O. Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis , Tese de doutorado. 2017 [https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]</ref>

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas <ref name='sayama'></ref>:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica<ref name='sayama'></ref>:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

O trabalho agora é traduzir essas premissas em equações. O primeiro ponto diz que que padrão não há mudança na população, dessa forma:
:<math>\frac{\partial p}{\partial t} = 0</math>

O segundo ponto nos diz que a economia tem um aumento que depende da quantidade de pessoas, e assim:

:<math>\frac{\partial m}{\partial t} = \alpha p</math>

em que <math>\alpha</math> é a taxa de aumento da atividade econômica per capita.

O terceiro ponto diz que a atividade econômica decai quando não há pessoas, e para isso adicionamos um termo de decaimento na equação:
:<math>\frac{\partial m}{\partial t} = \alpha p - \beta m</math>
em que <math>\beta</math> é a taxa de decaimento da atividade econômica.

O quarto ponto fala que tanto população quanto a atividade econômica difundem, o que uma premissa sobre o movimento espacial. Para isso são adicionados termos de difusão, os Laplacianos, as equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

onde <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da atividade econômica respectivamente.

O quinto e último ponto fala que as pessoas são atraídas pela atividade econômica e assim se movem para áreas que possuem mais dinheiro. Para cumprir essa premissa, a equação do transporte é utilizada:

:<math>
- \nabla \cdot (p \gamma \nabla m)
</math>

em que o gradiente de <math>m</math> é utilizado para obter a velocidade média do movimento da população, sendo <math>\gamma</math> uma constante que afeta essa velocidade.

O sistema de equação final fica da seguinte forma:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos, <ref name='scherer'>Scherer, C. Métodos Computacionais da Física. 2010
</ref>
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de explorar e estudar a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como um anel, onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de formato gaussiano sob a malha. Por isso, é interessante analisar a solução estacionária (se existir).

Como as equações diferenciais do sistema são dependentes umas das outras (isto é, a equação de m(x,t) depende de p(x,t) e a de p depende de m), a solução não é trivial. Utilizando o Método de Coeficientes a Determinar para solução de equações diferenciais em estado estacionário, conseguimos a seguinte relação genérica, que se mostra útil:

<math> m(x,t) = A_1 e^{- B_1 x^2} + A_2 p(x,t) + A_3 </math>

Onde <math>A_1,A_2,A_3</math> e <math>B_1</math> são constantes que dependem das condições iniciais do problema. Como o objetivo do trabalho não é resolver analiticamente esta EDP, estas constantes não foram calculadas.

Mas a equação acima mostra que, para o estado estacionário, o formato gaussiano obtido era previsto na solução analítica também. Portanto, o resultado obtido apresenta coerência.

Mais um ponto a ser aferido é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Um cuidado importante na iniciação deste sistema é que, como estamos modelando a densidade populacional, e consideramos que não há perda de população com o tempo, a integral da função p(x,t) deve ser sempre igual a 1. Em t=0, na iniciação do sistema, é necessário implementar esta condição ao problema, para que ela se mantenha durante a simulação. Para isso, basta sortear valores e normalizá-los depois. Um exemplo de código simples em Python que realiza esta operação está indicado abaixo.

<source lang="python">
import numpy as np
N = 100 #Limite no eixo x
p_auxiliar = np.random.rand(N) #Vetor auxiliar
p = p_auxiliar / np.sum(p_auxiliar) #Normalização, para que a soma de p em todo x seja 1
</source>

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se notar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao estacionário, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

Mais uma vez, como iniciamos aleatoriamente a população, é importante normalizá-la para que a integral seja igual a 1, como dito acima.

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial aleatório do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de formato gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

Para a geração da evolução do sistema e do gif, o código utilizado foi o seguinte:
<source lang="python">
L = 100 # Tamanho do Grid
D_p = 0.5 # Coeficiente de difusão de pessoas
D_m = 0.5 # Coeficiente de difusão de dinheiro
ds = 1 # Diferencial Espacial
dt = 0.3 # Diferencial Temporal
alfa = 1.2 # Taxa de produção de economia per capita
beta = 0.03 # Taxa de decaimente da economia
gamma = 1 # Taxa de velocidade com que as pessoas migram em direção ao dinheiro

# CRIA OBJETO DE PARÂMETROS PARA O MODELO #
parametros = ParametrosKellerSegelModel(L, L, D_p, D_m, ds, dt, alfa, beta, gamma)

# INICIALIZA O MODELO COM OS PARÂMETROS #
modelo = KellerSegelModel(parametros)

# GERA CONDIÇÕES INICIAIS A SEREM ESTUDADAS #
condicao_inicial_populacao = np.matrix(np.full((parametros.N_x, parametros.N_x), 1 / (L ** 2)))
condicao_inicial_dinheiro = np.matrix(np.full((parametros.N_y, parametros.N_y), 1 / (L ** 2)))

condicao_inicial_dinheiro[(0, 0)] = 0.125
condicao_inicial_dinheiro[(0, 99)] = 0.125
condicao_inicial_dinheiro[(99, 99)] = 0.125
condicao_inicial_dinheiro[(99, 0)] = 0.125
condicao_inicial_dinheiro[(49, 49)] = 2
condicao_inicial_dinheiro[(49, 69)] = 1
condicao_inicial_dinheiro[(49, 29)] = 1
condicao_inicial_dinheiro[(69, 49)] = 1
condicao_inicial_dinheiro[(29, 49)] = 1

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE GRÁFICO ESTÁTICO
jpeg = JpegTool(nome_imagem = 'comparacao_tempos_pop_uniforme_sem_dinheiro')

# GERA GRÁFICOS
jpeg.geraJpeg(modelo)

# REINICIALIZA MODELO
modelo = KellerSegelModel(parametros)

# SETA AS CONDIÇÕES INICIAIS DO MODELO #
modelo.setEstadoInicial(condicao_inicial_populacao, condicao_inicial_dinheiro)

# GERA O OBJETO DE ANIMACAO #
ani = AnimacaoTool(nome_gif = 'dinamica_pop_eco_2d_pop_uniforme_sem_dinheiro')

# GERA GIF COM A EVOLUCAO DO MODELO #
ani.geraGif(modelo)
</source>

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==

<references/>

Modelo de Keller-Segel para relação população-economia

2021-04-04T03:52:17Z

Bleo: /* 2D */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel <ref name='keller-segel-original'>Evelyn F. Keller, Lee A. Segel, Initiation of slime mold aggregation viewed as an instability, Journal of Theoretical Biology, Volume 26, Issue 3, 1970, Pages 399-415</ref>, que originalmente descreve o movimento de células em direção a um sinal químico, para um sistema englobando população e atividade econômica, problema proposto no livro ''Introduction to the Modeling and Analysis of Complex Sistems '' de Hiroki Sayama <ref name='sayama'>Sayama, H. Introduction to the Modeling and Analysis of Complex Systems. 2015</ref>. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space''), método de resolução de equações diferenciais parciais, como a equação do calor e a da difusão, que é o caso deste trabalho.

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'', a taxa com que as células se movem em direção ao sinal químico, tem papel crítico na auto-organização das células. <ref name = 'thesis'> Hoffmann, F. C. O. Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis , Tese de doutorado. 2017 [https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]</ref>

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas <ref name='sayama'></ref>:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica<ref name='sayama'></ref>:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

O trabalho agora é traduzir essas premissas em equações. O primeiro ponto diz que que padrão não há mudança na população, dessa forma:
:<math>\frac{\partial p}{\partial t} = 0</math>

O segundo ponto nos diz que a economia tem um aumento que depende da quantidade de pessoas, e assim:

:<math>\frac{\partial m}{\partial t} = \alpha p</math>

em que <math>\alpha</math> é a taxa de aumento da atividade econômica per capita.

O terceiro ponto diz que a atividade econômica decai quando não há pessoas, e para isso adicionamos um termo de decaimento na equação:
:<math>\frac{\partial m}{\partial t} = \alpha p - \beta m</math>
em que <math>\beta</math> é a taxa de decaimento da atividade econômica.

O quarto ponto fala que tanto população quanto a atividade econômica difundem, o que uma premissa sobre o movimento espacial. Para isso são adicionados termos de difusão, os Laplacianos, as equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

onde <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da atividade econômica respectivamente.

O quinto e último ponto fala que as pessoas são atraídas pela atividade econômica e assim se movem para áreas que possuem mais dinheiro. Para cumprir essa premissa, a equação do transporte é utilizada:

:<math>
- \nabla \cdot (p \gamma \nabla m)
</math>

em que o gradiente de <math>m</math> é utilizado para obter a velocidade média do movimento da população, sendo <math>\gamma</math> uma constante que afeta essa velocidade.

O sistema de equação final fica da seguinte forma:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos, <ref name='scherer'>Scherer, C. Métodos Computacionais da Física. 2010
</ref>
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de testar melhor a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como uma "rosquinha", onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de shape gaussiano sob a malha. Considerando que a equação que define o movimento populacional com o tempo contém um termo difusivo, e que a solução para uma difusão simples em 1 dimensão também assume um shape gaussiano, este resultado faz sentido. Mas uma coisa interessante é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se enxergar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao equilíbrio, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial caótico do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de shape gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==

<references/>

Modelo de Keller-Segel para relação população-economia

2021-03-30T00:25:09Z

Bleo: /* Modelagem bidimensional */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel, que originalmente descreve ''chemotaxis'': movimento de organismo em direção ou contra algum sinal químico, para um sistema englobando população e atividade econômica. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space'').

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'' tem papel crítico na auto-ormanização das células.

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

Traduzindo estes pontos em equações matemáticas, se obtêm as seguintes equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

em que <math>p</math> representa a população e <math>m</math> a atividade econômica. <math>\alpha</math> é a constante que determina a taxa de produção de atividade econômica per capita, <math>\beta</math> é a constante da taxa de decaimento da atividade econômica, <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da economia respectivamente, e <math>\gamma</math> é a constante que afeta a velocidade média do movimento da população.

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos,
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de testar melhor a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como uma "rosquinha", onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de shape gaussiano sob a malha. Considerando que a equação que define o movimento populacional com o tempo contém um termo difusivo, e que a solução para uma difusão simples em 1 dimensão também assume um shape gaussiano, este resultado faz sentido. Mas uma coisa interessante é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se enxergar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao equilíbrio, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial caótico do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de shape gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''0.2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

<source lang="python">
import numpy as np
import matplotlib.pyplot as plt

def FTCS(p,m,k1,k2,l,k3,v):
N = p.shape[0]

p_ = np.zeros(N)
m_ = np.zeros(N)

for j in np.arange(0,N):
back = (j-1)%N
forward = (j+1)%N
p_[j] = (1 - 2*k1 - k2*(m[back] - m[j]))*p[j] + k1*(p[back]+p[forward]) - k2*(m[forward] - m[j])*p[forward]
m_[j] = (1 - l - k3)*m[j] + k3*(m[back] + m[forward]) + v*p[j]
return p_,m_

def plot(p,m,filename):
#Plota o estado final do sistema em um arquivo
fig,ax = plt.subplots(2,1)

#População
ax[0].set_title("População")
ax[0].plot(p)

#Renda
ax[1].set_title("Renda")
ax[1].plot(m)

plt.savefig(filename + ".png")

##########################################################################################
"""DECLARAÇÃO DE CONSTANTES"""
N = 100 #Tamanho do eixo x
dx = 1
dt = 0.3
Dm = 1.0 #Constante de difusão p/ renda.
Dp = 1.0 #Constante de difusão p/ população.
gamma = 1.0
alpha = 1.0
beta = 1.0

k1 = Dp*dt/(dx**2)
k2 = gamma*k1/Dp
k3 = Dm*dt/(dx**2)
v = alpha*dt
l = beta*dt
##########################################################################################

print("=================================================================================")
print("Caso 1: População e dinheiro em pontos separados")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa totalmente focado em 1 ponto da rede longe do ponto da população.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p = np.zeros(N)
p[20] = 1

#Setando renda para t = 0
m = np.zeros(N)
m[80] = 1

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 2: Sem dinheiro p/ t = 0")
print("População começa totalmente concentrada em 1 ponto da rede.")
print("Dinheiro começa zerado")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.zeros(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_2")

##########################################################################################
print("=================================================================================")
print("Caso 3: Rede aleatória")
print("População começa distribuída aleatoriamente sobre a rede.")
print("Dinheiro começa totalmente focado em um ponto no meio da rede.")
print("=================================================================================")

N_simulations = 500 #Número de simulações desejado.
T = N_simulations * dt #Tempo máximo de duração da simulação.

#Setando população para t = 0
p1 = np.random.rand(N)
p = p / np.sum(p)

#Setando renda para t = 0
m = np.random.rand(N)

for t in np.arange(0,T,dt):
p,m = FTCS(p,m,k1,k2,l,k3,v)

#Criação da figura com o estado final
plot(p,m,"caso_3")

</source>

=== Modelagem bidimensional ===
<source lang="python">
class KellerSegelModel():
def __init__(self, parametros):
self.parametros = parametros

self.zeros = np.matrix(np.zeros((parametros.N_x, parametros.N_y)))

self.tempo = 0

def contagemPopulacao(self):
return self.estado_populacao.sum()

def contagemDinheiro(self):
return self.estado_dinheiro.sum()

def setEstadoInicial(self, matriz_populacao, matriz_dinheiro):
self.estado_populacao = np.matrix(matriz_populacao)
self.estado_dinheiro = np.matrix(matriz_dinheiro)

def getEstado(self):
return (self.estado_populacao, self.estado_dinheiro, self.tempo)

def atualizaEstado(self):
# Pega o estado atual da população e dinheiro
pn = self.estado_populacao
mn = self.estado_dinheiro

# Inicializa as variáveis que receberão o estado seguinte
pn1 = self.zeros.copy()
mn1 = self.zeros.copy()

k1 = self.parametros.k1
k2 = self.parametros.k2
k3 = self.parametros.k3
lamb = self.parametros.lamb
v = self.parametros.v

# Realiza o FTCS
for i in np.arange(0, self.parametros.N_x):
i_previous = (i - 1) % self.parametros.N_x # Garante que em i == 0 o item anterior seja o último da lista
i_next = (i + 1) % self.parametros.N_x # Garante que em i == N_x o item posterior seja o primeiro da lista

for j in np.arange(0, self.parametros.N_y):
j_previous = (j - 1) % self.parametros.N_y # Garante que em j == 0 o item anterior seja o último da lista
j_next = (j + 1) % self.parametros.N_y # Garante que em j == N_y o item posterior seja o primeiro da lista

pn1[(i, j)] = pn[(i, j)] * (1 - 4 * k1 - k2 * (mn[(i_previous, j)] - 2 * mn[(i, j)] + mn[(i, j_previous)])) \
+ k1 * (pn[(i_previous, j)] + pn[(i, j_previous)] + pn[(i_next, j)] + pn[(i, j_next)]) \
- k2 * (pn[(i_next, j)] * (mn[(i_next, j)] - mn[(i, j)]) + pn[(i, j_next)] * (mn[(i, j_next)] - mn[(i, j)]))

mn1[(i, j)] = mn[(i, j)] * (1 - 4 * k3 - lamb) + k3 * (mn[(i_previous, j)] + mn[(i, j_previous)] + mn[(i_next, j)] + mn[(i, j_next)]) + v * pn[(i, j)]

self.estado_populacao = pn1 # Atualiza o estado da população
self.estado_dinheiro = mn1 # Atualiza o estado do dinheiro
self.tempo += self.parametros.dt # Atualiza o tempo decorrido no modelo

def atualizaEstadoMultiplasVezes(self, n = 1):
for _ in range(0, n):
self.atualizaEstado()
</source>

==Referências==
* Sayama, H. '''Introduction to the Modeling and Analysis of Complex Systems'''. 2015

* Scherer, C. '''Métodos Computacionais da Física'''. 2010

* Hoffmann, F. C. O. '''Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis ''', Tese de doutorado. 2017[https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]

Modelo de Keller-Segel para relação população-economia

2021-03-30T00:10:32Z

Bleo: /* Programas */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel, que originalmente descreve ''chemotaxis'': movimento de organismo em direção ou contra algum sinal químico, para um sistema englobando população e atividade econômica. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space'').

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'' tem papel crítico na auto-ormanização das células.

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

Traduzindo estes pontos em equações matemáticas, se obtêm as seguintes equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

em que <math>p</math> representa a população e <math>m</math> a atividade econômica. <math>\alpha</math> é a constante que determina a taxa de produção de atividade econômica per capita, <math>\beta</math> é a constante da taxa de decaimento da atividade econômica, <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da economia respectivamente, e <math>\gamma</math> é a constante que afeta a velocidade média do movimento da população.

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos,
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de testar melhor a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como uma "rosquinha", onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de shape gaussiano sob a malha. Considerando que a equação que define o movimento populacional com o tempo contém um termo difusivo, e que a solução para uma difusão simples em 1 dimensão também assume um shape gaussiano, este resultado faz sentido. Mas uma coisa interessante é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se enxergar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao equilíbrio, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial caótico do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de shape gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''0.2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
* '''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

=== Modelagem bidimensional ===

==Referências==
* Sayama, H. '''Introduction to the Modeling and Analysis of Complex Systems'''. 2015

* Scherer, C. '''Métodos Computacionais da Física'''. 2010

* Hoffmann, F. C. O. '''Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis ''', Tese de doutorado. 2017[https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]

Modelo de Keller-Segel para relação população-economia

2021-03-30T00:10:07Z

Bleo: /* 2D */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel, que originalmente descreve ''chemotaxis'': movimento de organismo em direção ou contra algum sinal químico, para um sistema englobando população e atividade econômica. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space'').

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'' tem papel crítico na auto-ormanização das células.

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

Traduzindo estes pontos em equações matemáticas, se obtêm as seguintes equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

em que <math>p</math> representa a população e <math>m</math> a atividade econômica. <math>\alpha</math> é a constante que determina a taxa de produção de atividade econômica per capita, <math>\beta</math> é a constante da taxa de decaimento da atividade econômica, <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da economia respectivamente, e <math>\gamma</math> é a constante que afeta a velocidade média do movimento da população.

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos,
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de testar melhor a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como uma "rosquinha", onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de shape gaussiano sob a malha. Considerando que a equação que define o movimento populacional com o tempo contém um termo difusivo, e que a solução para uma difusão simples em 1 dimensão também assume um shape gaussiano, este resultado faz sentido. Mas uma coisa interessante é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se enxergar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao equilíbrio, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial caótico do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de shape gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''0.2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema. Além disso, foi utilizado PBC.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
'''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

=== Modelagem bidimensional ===

==Referências==
* Sayama, H. '''Introduction to the Modeling and Analysis of Complex Systems'''. 2015

* Scherer, C. '''Métodos Computacionais da Física'''. 2010

* Hoffmann, F. C. O. '''Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis ''', Tese de doutorado. 2017[https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]

Modelo de Keller-Segel para relação população-economia

2021-03-30T00:07:38Z

Bleo: /* Programas */

''' Grupo: Leonardo Barcelos, Luana Bianchi e Rubens Borrasca '''

O objetivo deste trabalho é implementar o modelo de Keller-Segel, que originalmente descreve ''chemotaxis'': movimento de organismo em direção ou contra algum sinal químico, para um sistema englobando população e atividade econômica. O método computacional utilizado para resolver o problema e implementar o modelo foi o FTCS (''Forward Time Centered Space'').

==Modelo de Keller-Segel==

Proposto por Evelyn Fox Keller, física norte-americana, e Lee Aaron Segel, matemático também norte-americano, o modelo de Keller-Segel foi historicamente utilizado para descrever o movimento de bactérias. Introduzido primeiramente em 1970 para descrever a agregação de uma espécie de bolor limoso (ou ''slime mold'') ameboide, ''Dictyostelium discoideum'', o modelo se tornou um dos mais usados nos estudos biológicos-matemáticos. As células deste ''slime mold'' se comportam como amoebas individuais, e se alimentam de bactérias, mas quando a quantidade de comida fica pequena, elas se difundem pelo espaço e então se agregam em formato mais alongado, como o formato das lesmas, para uma migração de longa distância. Keller e Segel desenvolveram um modelo matemático para o processo de agregação, em que a ''chemotaxis'' tem papel crítico na auto-ormanização das células.

Baseados no que já era conhecido sobre esses organismos, Keller e Segel utilizaram as seguintes premissas:
* As células estão inicialmente distribuídas sobre o espaço de maneira mais ou menos homogênea, com algumas flutuações aleatótias;
* As células apresentam ''chemotaxis'' em direção ao sinal químico denominado cAMP (''cyclic adenosine monophosphate'');
* As células produzem moléculas cAMP;
* As células e as moléculas cAMP difundem pelo espaço;
* As células não morrem e não se dividem

De forma simplificada, ocultando alguns detalhes biológicos mais complicados a equação de Keller-Segel é a seguinte:

:<math>
\frac{\partial a}{\partial t} = \mu \nabla^2 a - \chi \nabla \cdot (a \nabla c)
</math>

:<math>
\frac{\partial c}{\partial t} = D \nabla^2 c + f a - k c
</math>

em que <math>a</math> e <math>c</math> são respectivamente as variáveis de estado para a concentração de células e a concentração de cMAP. <math>\mu</math> é o parâmetro de mobilidade das células, <math>\chi</math> é o parâmetro da ''chemotaxis'' celular, <math>D</math> é a constante de difusão das moléculas cAMP, <math>f</math> é a taxa de secreção de cMAP pelas células, e <math>k</math> é a taxa de decaimento das moléculas cMAP.

===Aplicação população-economia===

De forma parecida com as premissas de Keller e Segel, os seguintes pontos são assumidos para modelar a relação entre a população e a atividade econômica:
* A população não cresce e não decresce ao longo do tempo;
* A economia é ativada por existir mais pessoas em uma região;
* Sem pessoas a atividade econômica diminui;
* População e atividade econômica difundem gradualmente;
* As pessoas são atraídas por regiões com maior atividade econômica

Traduzindo estes pontos em equações matemáticas, se obtêm as seguintes equações:

:<math>
\frac{\partial p}{\partial t} = D_p \nabla^2 p - \gamma \nabla \cdot (p \nabla m)
</math>

:<math>
\frac{\partial m}{\partial t} = D_m \nabla^2 m + \alpha p - \beta m
</math>

em que <math>p</math> representa a população e <math>m</math> a atividade econômica. <math>\alpha</math> é a constante que determina a taxa de produção de atividade econômica per capita, <math>\beta</math> é a constante da taxa de decaimento da atividade econômica, <math>D_p</math> e <math>D_m</math> são as constantes de difusão da população e da economia respectivamente, e <math>\gamma</math> é a constante que afeta a velocidade média do movimento da população.

Comparando o sistema obtido com o problema original de Keller-Segel, percebe-se que se trocarmos células por pessoas e cMAP por atividade econômica os problemas ficam iguais, e até se poderia denominar como ''moneytaxis'' a migração das pessoas em direção a atividade econômica, como a ''chemotaxis'' descreve o movimento das células em direção ao cAMP.

==Método FTCS==
O FTCS (''Forward Time Centered Space'', em tradução livre significa "avançado no tempo, centrado no espaço), é um método de discretização de Equações Diferenciais Parciais(EDP). Para a derivada temporal teremos,
:<math>\frac{\partial f}{\partial t} \rightarrow \frac{f^{n+1} - f^n}{\Delta t}</math>
e para a parte espacial,
:<math>\frac{\partial^2 f}{\partial s^2} \rightarrow \frac{f_{i-1} - 2f_i + f_{i+1}}{(\Delta s)^2}</math>
onde <math>s</math> é uma variável espacial qualquer <math>(x, y, z, ...)</math> e <math>t</math> é o tempo.

=== Discretização do Modelo de Keller-Segel em 1D ===
Em 1D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \frac{\partial^2 p}{\partial x^2} - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + p \frac{\partial^2 m}{\partial x^2} \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \frac{\partial^2 m}{\partial x^2} + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS teremos:
:<math>\frac{p_{i}^{n+1} - p_{i}^{n}}{\Delta t} = \frac{D_p}{(\Delta x)^2} \left[ p_{i-1}^{n} - 2 p_{i}^{n} + p_{i+1}^{n} \right] - \frac{\gamma}{(\Delta x)^2} \left[ (p_{i+1}^n - p_{i}^n)(m_{i+1}^n - m_{i}^n) + p_{i}^n (m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}) \right]</math>

:<math>\frac{m_{i}^{n+1} - m_{i}^{n}}{\Delta t} = \frac{D_m}{(\Delta x)^2} \left[ m_{i-1}^{n} - 2 m_{i}^{n} + m_{i+1}^{n}\right] + \alpha p_{i}^{n} - \beta m_{i}^{n} </math>

onde o sub-índice <math>i</math> se refere à coordenada <math>x</math>; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i}^{n+1} = p_{i}^{n} \left[ 1 - 2K_1 - K_2 \left( m_{i-1}^n - m_i^n \right) \right] + K_1 \left[ p_{i-1}^n + p_{i+1}^n \right] - K_2 \left[ p_{i+1}^n (m_{i+1}^n - m_{i}^n) \right]</math>
:<math>m_{i}^{n+1} = m_{i}^n \left[ 1 - K_3 - \lambda \right] + K_3 \left[ m_{i-1}^n + m_{i+1}^n \right] + V p_{i}^n</math>

onde os termos agrupados são:
<math>K_1 = \frac{D_p \Delta t}{(\Delta x)^2}</math> ,
<math>K_2 = \frac{\gamma \Delta t}{(\Delta x)^2}</math> ,
<math>K_3 = \frac{D_m \Delta t}{(\Delta x)^2}</math> ,
<math>V = \alpha \Delta t</math> ,
<math>\lambda = \beta \Delta t</math>

=== Discretização do Modelo de Keller-Segel em 2D ===
Em 2D o sistema de equações diferenciais parciais será:
:<math>\frac{\partial p}{\partial t} = D_p \left[\frac{\partial^2 p}{\partial x^2} + \frac{\partial^2 p}{\partial y^2} \right] - \gamma \left[\frac{\partial p}{\partial x} \frac{\partial m}{\partial x} + \frac{\partial p}{\partial y} \frac{\partial m}{\partial y} + p \left(\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right) \right]</math>

:<math>\frac{\partial m}{\partial t} = D_m \left[\frac{\partial^2 m}{\partial x^2} + \frac{\partial^2 m}{\partial y^2} \right] + \alpha p - \beta m</math>

Agora utilizando a discretização FTCS e assumindo que <math>\Delta x = \Delta y = \Delta s </math> teremos:
:<math>\frac{p_{i,j}^{n+1} - p_{i,j}^{n}}{\Delta t} = \frac{D_p}{(\Delta s)^2} \left[ (p_{i-1,j}^{n} - 2 p_{i,j}^{n} + p_{i+1,j}^{n}) + (p_{i,j-1}^{n} - 2 p_{i,j}^{n} + p_{i,j+1}^{n})\right] - \frac{\gamma}{(\Delta s)^2} \left[ (p_{i+1,j}^n - p_{i,j}^n)(m_{i+1,j}^n - m_{i,j}^n) + (p_{i,j+1}^n - p_{i,j}^n)(m_{i,j+1}^n - m_{i,j}^n) + p_{i,j}^n \left( (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n}) \right) \right]</math>

:<math>\frac{m_{i,j}^{n+1} - m_{i,j}^{n}}{\Delta t} = \frac{D_m}{(\Delta s)^2} \left[ (m_{i-1,j}^{n} - 2 m_{i,j}^{n} + m_{i+1,j}^{n}) + (m_{i,j-1}^{n} - 2 m_{i,j}^{n} + m_{i,j+1}^{n})\right] + \alpha p_{i,j}^{n} - \beta m_{i,j}^{n} </math>

onde os sub-índices <math>i</math> e <math>j</math> se referem às coordenadas <math>x</math> e <math>y</math> respectivamente; e o superíndice <math>n</math> se refere ao tempo. Reorganizando as equações e agrupando alguns termos teremos:
:<math>p_{i,j}^{n+1} = p_{i,j}^{n} \left[ 1 - 4K_1 - K_2 \left( m_{i-1, j}^n - 2m_{1, j}^n + m_{i, j-1}^n \right) \right] + K_1 \left[ p_{i-1,j}^n + p_{i,j-1}^n + p_{i+1,j}^n + p_{i,j+1}^n \right] - K_2 \left[ p_{i+1,j}^n (m_{i+1,j}^n - m_{i,j}^n) + p_{i,j+1}^n (m_{i,j+1}^n - m_{i,j}^n) \right]</math>
:<math>m_{i,j}^{n+1} = m_{i,j}^n \left[ 1 - 4K_3 - \lambda \right] + K_3 \left[ m_{i-1,j}^n + m_{i,j-1}^n + m_{i+1,j}^n + m_{i,j+1}^n \right] + V p_{i,j}^n</math>

==Resultados==
===1D===

Com o intuito de testar melhor a equação e suas consequências, os resultados foram divididos em várias simulações diferentes.

Para todas as simulações realizadas, exceto onde indicado, os parâmetros utilizados foram os seguintes:

<math>
N = 100
</math>

<math>
dx = 1
</math>

<math>
dt = 0.3
</math>

<math>
D_m = 1
</math>

<math>
D_p = 1
</math>

<math>
\gamma = 1
</math>

<math>
\alpha = 1
</math>

<math>
\beta = 1
</math>

Além disso, foram utilizadas condições periódicas de contorno (PBC) para a solução das equações diferenciais parciais. Deste modo, pode-se pensar no eixo x como uma "rosquinha", onde, considerando um sistema de tamanho <math>N</math>, os pontos <math>x=0</math> e <math>x=N</math> estão conectados.
====População e Dinheiro em pontos separados====

Para esta simulação, considera-se que no tempo 0, toda a população está concentrada em 1 ponto <math> x = \mathcal{C}_1</math>, enquanto todo o dinheiro está em um outro ponto, distante deste, <math> x = \mathcal{C}_2 </math>. Deste modo, temos as seguintes equações para as condições iniciais:

<math>
p(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_1, \mathcal{C}_1 \in [0,N]\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

<math>
m(x,t=0)=\left\{\begin{array}{lc} 1, \quad \text{p/}\quad x = \mathcal{C}_2, \mathcal{C}_2 \in [0,N], \mathcal{C}_2 \neq \mathcal{C}_1\\
0, \quad \text{caso contrario}\end{array}\right.
</math>

Na figura abaixo, consegue-se observar o resultado da construção do sistema desta maneira:

[[Arquivo:Split money pop.png|1000px|thumb|center|Resultados da simulação para o caso de população e dinheiro em pontos separados e distantes na malha]]

Com toda a população concentrada em 1 ponto (<math> x = 20 </math>), a atividade econômica cresce consideravelmente neste intervalo ao longo do tempo. Em contrapartida, o local que continha todo o dinheiro no começo da simulação (<math> x = 80 </math>), em pouco tempo tem a sua renda líquida migrada para onde tem uma densidade populacional maior. Essa tendência indica, portanto, que o sistema é construído de tal forma que a atração da população por regiões de alta renda líquida é menor que a atração do sistema monetário de seguir para pontos de alta densidade populacional.

Além disso, outra observação interessante é que nota-se para <math> t \rightarrow \infty</math> uma tendência inerente da densidade populacional em seguir uma distribuição de shape gaussiano sob a malha. Considerando que a equação que define o movimento populacional com o tempo contém um termo difusivo, e que a solução para uma difusão simples em 1 dimensão também assume um shape gaussiano, este resultado faz sentido. Mas uma coisa interessante é que, depois de se desfazer de seu formato inicial, o total de dinheiro sob a malha tende a seguir a distribuição populacional, porém com um desvio padrão maior (maior abertura na Gaussiana). Essa observação indica que, para centros econômicos (regiões com alto <math> m </math>) a tendência é que suas periferias também possuam valores altos de renda, apesar da população consideravelmente menor. Além disso, para regiões fora do contorno de centros econômicos (distância maior do que 3 vezes o desvio padrão da gaussiana) a atividade econômica é basicamente nula, assim como a densidade populacional. Este último fato descreve de forma genérica e simplista o comportamento atual observado em metrópoles nos dias de hoje: uma cidade grande possui alto número de habitantes, alta renda, seus contornos também apresentam atividade econômica forte (porém menor que o centro), mas para um raio suficientemente grande, tanto dinheiro quanto população caem exponencialmente.

==== População uniforme e sem dinheiro no sistema para t = 0 ====

Nesta simulação, considera-se que, para t=0, não há dinheiro sob a malha. Deste modo, a equação que descreve o dinheiro no sistema ao longo do tempo pode ser escrita como:

<math>
m(x,t=0) = 0, \forall x \in [0,N]
</math>

Além disso, a população é iniciada de forma aleatória sob a malha. Deste modo, não há tendência inicial à formação de centros com alta densidade de população.

Esta forma inicial da população se assemelha muito à proposição inicial que Keller-Segel fizeram para um sistema celular, como descrito acima. Na prática, temos uma concentração homogênea com pequenas flutuações ao longo do eixo.

[[Arquivo:M0.png|1000px|thumb|center|Resultados da simulação para o caso de m(x,t=0)=0, e população iniciada aleatoriamente.]]

Na imagem acima, para t = 0 (início da simulação) compreende-se melhor as condições iniciais do sistema. Enquanto que a população, aleatoriamente distribuída sob o eixo x, se assemelha a um ruído branco, o dinheiro não existe na malha.

Na segunda coluna de imagens, nota-se um ponto interessante: a formação de clusters de população (e consequentemente, de dinheiro). Estes clusters são, na verdade, picos que aparecem no gráfico de p(x,t), e indicam alta concentração da população em pontos específicos. Além dos picos claramente visíveis (um deles próximo a x=50, e outro próximo a x=90) pode-se enxergar, também, sub-picos nas bases destes picos de população. Para t=24.9 e dt=0.3, deduz-se que o sistema, nesta representação, havia passado por 83 iterações até então, o que indica que, durante estas 83 iterações, haviam mais clusters de população em tempos passados, menores porém definidos. E estes "mini-clusters" se agruparam até formar os 2 picos que vemos.

Com o passar do tempo na simulação, nota-se que o comportamento continua, de modo que para a última coluna de figuras é visível que apenas 1 dos picos iniciais se manteve, enquanto o outro foi praticamente inteiro "engolido" pela cauda do maior. Este comportamento de formação de 1 único cluster de população, com shape gaussiano, já havia sido observado na simulação anterior, para <math> t </math> suficientemente grande.

[[Arquivo:M0 equilibrium.png|1000px|thumb|center|Simulação do mesmo sistema anterior, para t suficientemente grande (t = 270 neste caso) a ponto de chegar em um estado próximo ao equilíbrio, onde as funções que descrevem população e renda do sistema praticamente não se alteram mais com o tempo.]]

A figura acima mostra o que acontece caso deixemos o mesmo sistema apresentado antes evoluir até um estado de equilíbrio, onde não há alterações para a população ou renda do sistema. Neste caso, observa-se com mais clareza uma curva de shape gaussiano, em localização bem próxima àquela que vimos para t=124.8 na figura anterior, tanto para a distribuição da população quanto da renda. E mais uma vez, mesmo que não muito perceptível pois as 2 curvas apresentadas são bem largas, o desvio padrão da curva que descreve a renda aparenta ser maior que o desvio padrão da curva que descreve a população.

==== População e renda iniciados aleatoriamente na rede ====

Sob a perspectiva de testar a formação de clusters de população, foi criada uma rede completamente aleatória, sem nenhum viés, seja populacional ou econômico. Para isto, tanto população quanto renda possuem valores aleatórios para <math> t = 0 </math>

[[Arquivo:Random population.png|thumb|1000px|center|Resultados da simulação para rede iniciada com população e renda aleatórias em t = 0.]]

Enquanto que a primeira coluna de gráficos mostra o estado inicial caótico do sistema, a segunda coluna (t = 9.9) indica exatamente o esperado: 5 clusters bem visíveis são formados para a população. Nota-se, entretanto, que os mesmos 5 picos não são tão visíveis no gráfico de rendas. Uma explicação para isto seria que, mais uma vez, com os valores de desvio padrão da distribuição mais elevados, um pico acaba se sobrepondo a outro, tornando as distribuições difícies de se distinguir.

Conforme a simulação avança no tempo, é perceptível também a tendência entre os picos de se mergirem. E, como visto anteriormente, para <math> t \rightarrow \infty</math>, a tendência é que o sistema colapse para um estado com somente um pico de shape gaussiano na população, e um pico na renda, com desvio padrão maior.

Com isso, conclui-se que a formação destes clusters é, de fato, inerente ao sistema, e consequência do modelo utilizado.

===2D===
Para o caso em duas dimensões, foi utilizada uma distribuição populacional uniforme em todo o espaço. Já a distribuição econômica, no instante '''t=0''' começou da seguinte forma: Em cada canto do espaço foi atribuído um valor de '''0.125''', no centro '''0.2''' e ao redor do centro em 4 pontos '''1'''. A seguir, é confirmado um comportamento que foi observado no caso unidimensional, em que os picos concentrados, após a evolução do sistema, tomam a forma de gaussianas. É possível notar também que a população tende a ''"clusterizar"'' em torno dos locais em que a atividade econômica tinha valores altos no início da simulação. Isso se deve principalmente ao termo que é influenciado pela constante <math>\gamma</math> do sistema de EDPs que modela o sistema.
[[Arquivo:evoluca_2d_keller_segel.png|1366px|thumb|center|Evolução da atividade econômica e da população para população inicial uniformemente distribuída]]

A seguir, foi gerada uma animação com a evolução do sistema até a estabilização da atividade econômica. A estabilidade da atividade econômica foi entendida como <math>max(m^{n+10}_{i,j} - m^n_{i,j}) \leqslant \epsilon</math>, onde <math>\epsilon</math> é o valor que regula o erro. Para este caso <math>\epsilon = 1 \times 10^{-9}</math>.

[[Arquivo:Evolucao 2d gif.gif|1000px|thumb|center|Animação da evolução do sistema]]

Os parâmetros utilizados para gerar as imagens foram os seguintes:
<math>L = 100</math>,
<math>ds = 1</math>,
<math>dt = 0.3</math>,
<math>D_m = 0.5</math>,
<math>D_p = 0.5</math>,
<math>\alpha = 1.2</math>,
<math>\beta = 0.03</math>,
<math>\gamma = 1</math>

==Discussão==

Nota-se que, independente do caso 1D ou 2D, as conclusões tiradas dos modelos construídos se assemelham bastante. Assim como previsto pela teoria de Keller e Segel, base deste estudo, observa-se a formação de clusters de densidade populacional e de renda a partir do momento em que se inicia a simulação, para um intervalo de tempo suficientemente grande a ponto de que estes sejam formados. E essa tendência independe das condições iniciais apresentadas.

Também foi observado, para ambas as análises, a tendência da função que representa a renda da rede em seguir o comportamento da função que descreve a densidade populacional, algo que também é previsto pelo modelo natural de Keller e Segel, visto que cada foco de população é considerado também um foco de criação de renda por definição.

Por último, apesar deste modelo não ser ideal na simulação de sistemas reais população-renda, pois deixa de fora várias variáveis importantes para manter um modelo realista, algumas conclusões obtidas aqui podem ser observadas no mundo real. É o caso da distribuição populacional gaussiana por exemplo, que modela convincentemente a população, a nível macro-geográfico, em centros urbanos, assim como a concentração monetária ser intimamente ligada com a concentração da população.

Um estudo mais aplicado sob a estabilidade do método, algo que não é ponto de foco deste trabalho, pode possibilitar a exploração de novas combinações de parâmetros do modelo, vindo a surgir análises sob pontos de vista diferentes.

==Programas==
'''Código disponível da plataforma GitHub'''[https://github.com/leonardob17/keller-segel]

=== Modelagem unidimensional ===

=== Modelagem bidimensional ===

==Referências==
* Sayama, H. '''Introduction to the Modeling and Analysis of Complex Systems'''. 2015

* Scherer, C. '''Métodos Computacionais da Física'''. 2010

* Hoffmann, F. C. O. '''Keller-Segel-Type Models and Kinetic Equations for Interacting Particles: Long-Time Asymptotic Analysis ''', Tese de doutorado. 2017[https://francahoffmann.files.wordpress.com/2017/09/thesis_corrected_post_graduation.pdf]

Modelo de Keller-Segel para relação população-economia

2021-03-29T02:22:54Z

Bleo: /* 2D */

Modelo de Keller-Segel para relação população-economia

2021-03-29T02:22:29Z

Bleo: /* 2D */

Modelo de Keller-Segel para relação população-economia

2021-03-29T02:22:14Z

Bleo: /* 2D */

Modelo de Keller-Segel para relação população-economia

2021-03-29T02:00:33Z

Bleo: /* Discussão */

Modelo de Keller-Segel para relação população-economia

2021-03-29T01:58:36Z

Bleo: /* 2D */

Modelo de Keller-Segel para relação população-economia

2021-03-29T01:58:25Z

Bleo: /* 2D */

Modelo de Keller-Segel para relação população-economia

2021-03-29T01:58:00Z

Bleo: /* 2D */

Modelo de Keller-Segel para relação população-economia

2021-03-29T01:57:34Z

Bleo: /* 2D */