Opinion spread
This is a simple model of how an opinion spreads through a community. Each individual has a number of opinions as a list of integers. They can change their opinion by changing the numbers in the list.
Agents can change their opinion at each step. They choose one of their neighbors randomly, and adopt one of the neighbor's opinion. They are more likely to adopt their neighbors opinion if the share more opinions with each other.
using Agents
using AgentsPlots
using Random
Building the model
1. Model creation
mutable struct Citizen <: AbstractAgent
id::Int
pos::Tuple{Int, Int}
stabilized::Bool
opinion::Array{Int, 1}
prev_opinion::Array{Int, 1}
end
function create_model(;dims=(10, 10), nopinions=3, levels_per_opinion=4)
space = GridSpace(dims, periodic=true, moore=true)
properties = Dict(:nopinions=>nopinions)
model = AgentBasedModel(Citizen, space, scheduler=random_activation, properties=properties)
for cell in 1:nv(model)
add_agent!(cell, model, false, rand(1:levels_per_opinion, nopinions), rand(1:levels_per_opinion, nopinions))
end
return model
end
create_model (generic function with 1 method)
2. Stepping functions
function adopt!(agent, model)
neighbor = rand(space_neighbors(agent, model))
matches = model[neighbor].opinion .== agent.opinion
nmatches = count(matches)
if nmatches < model.nopinions && rand() < nmatches/model.nopinions
switchId = rand(findall(x-> x==false, matches))
agent.opinion[switchId] = model[neighbor].opinion[switchId]
end
end
function update_prev_opinion!(agent, model)
for i in 1:model.nopinions
agent.prev_opinion[i] = agent.opinion[i]
end
end
function is_stabilized!(agent, model)
if agent.prev_opinion == agent.opinion
agent.stabilized = true
else
agent.stabilized = false
end
end
function agent_step!(agent, model)
update_prev_opinion!(agent, model)
adopt!(agent, model)
is_stabilized!(agent, model)
end
agent_step! (generic function with 1 method)
Running the model
levels_per_opinion=4
model = create_model(nopinions=3,levels_per_opinion=levels_per_opinion)
"run the model until all agents stabilize"
rununtil(model, s) = count(getproperty.(values(model.agents), :stabilized)) == prod(model.space.dimensions)
agentdata, _ = run!(model, agent_step!, dummystep, rununtil, adata=[(:stabilized, count)])
(250×2 DataFrame │ Row │ step │ count_stabilized │ │ │ Int64 │ Int64 │ ├─────┼───────┼──────────────────┤ │ 1 │ 0 │ 0 │ │ 2 │ 1 │ 83 │ │ 3 │ 2 │ 68 │ │ 4 │ 3 │ 75 │ │ 5 │ 4 │ 80 │ │ 6 │ 5 │ 70 │ │ 7 │ 6 │ 74 │ ⋮ │ 243 │ 242 │ 97 │ │ 244 │ 243 │ 95 │ │ 245 │ 244 │ 98 │ │ 246 │ 245 │ 98 │ │ 247 │ 246 │ 99 │ │ 248 │ 247 │ 98 │ │ 249 │ 248 │ 95 │ │ 250 │ 249 │ 100 │, 0×0 DataFrame )
Plotting
The plot shows the number of stable agents, that is, number of agents whose opinions don't change from one step to the next. Note that the number of stable agents can fluctuate before the final convergence.
plot(1:size(agentdata, 1), agentdata.count_stabilized, legend=false, xlabel="generation", ylabel="# of stabilized agents")
Animation
Here is an animation that shows change of agent opinions over time. The first three opinions of an agent determines its color in RGB.
levels_per_opinion = 3
ac(agent) = RGB((agent.opinion[1:3] ./ levels_per_opinion)...)
model = create_model(nopinions=3, levels_per_opinion=levels_per_opinion)
anim = @animate for sp in 1:500
step!(model, agent_step!)
p = plotabm(model, ac=ac, as=12, am=:square)
title!(p, "Step $(sp)")
if rununtil(model, 1)
break
end
end
gif(anim, "opinion.gif")