mirror of
https://github.com/gsi-upm/soil
synced 2024-11-13 06:52:28 +00:00
343 lines
12 KiB
Python
343 lines
12 KiB
Python
from nxsim import NetworkSimulation
|
|
from nxsim import BaseNetworkAgent
|
|
from nxsim import BaseLoggingAgent
|
|
from random import randint
|
|
from pprint import pprint
|
|
from matplotlib import pyplot as plt
|
|
import random
|
|
import numpy as np
|
|
import networkx as nx
|
|
import settings
|
|
|
|
settings.init()
|
|
|
|
####################
|
|
# Network creation #
|
|
####################
|
|
|
|
if settings.network_type == 0:
|
|
G = nx.complete_graph(settings.number_of_nodes)
|
|
if settings.network_type == 1:
|
|
G = nx.barabasi_albert_graph(settings.number_of_nodes,3)
|
|
if settings.network_type == 2:
|
|
G = nx.margulis_gabber_galil_graph(settings.number_of_nodes, None)
|
|
# More types of networks can be added here
|
|
|
|
##############################
|
|
# Variables initializitation #
|
|
##############################
|
|
def init():
|
|
|
|
global networkStatus
|
|
networkStatus={} # Dict that will contain the status of every agent in the network
|
|
|
|
sentimentCorrelationNodeArray=[]
|
|
for x in range(0, settings.number_of_nodes):
|
|
sentimentCorrelationNodeArray.append({'id':x})
|
|
# Initialize agent states. Let's assume everyone is normal.
|
|
init_states = [{'id': 0, } for _ in range(settings.number_of_nodes)] # add keys as as necessary, but "id" must always refer to that state category
|
|
|
|
|
|
####################
|
|
# Available models #
|
|
####################
|
|
|
|
class ComportamientoBase(BaseNetworkAgent):
|
|
def __init__(self, environment=None, agent_id=0, state=()):
|
|
super().__init__(environment=environment, agent_id=agent_id, state=state)
|
|
self._attrs = {}
|
|
|
|
@property
|
|
def attrs(self):
|
|
now = self.env.now
|
|
if now not in self._attrs:
|
|
self._attrs[now] = {}
|
|
return self._attrs[now]
|
|
|
|
@attrs.setter
|
|
def attrs(self, value):
|
|
self._attrs[self.env.now] = value
|
|
|
|
def run(self):
|
|
while True:
|
|
self.step(self.env.now)
|
|
yield self.env.timeout(settings.timeout)
|
|
|
|
def step(self, now):
|
|
networkStatus['agente_%s'% self.id] = self.a_json()
|
|
|
|
def a_json(self):
|
|
final = {}
|
|
for stamp, attrs in self._attrs.items():
|
|
for a in attrs:
|
|
if a not in final:
|
|
final[a] = {}
|
|
final[a][stamp] = attrs[a]
|
|
return final
|
|
|
|
class BigMarketModel(ComportamientoBase):
|
|
|
|
def __init__(self, environment=None, agent_id=0, state=()):
|
|
super().__init__(environment=environment, agent_id=agent_id, state=state)
|
|
self.enterprises = settings.enterprises
|
|
self.type = ""
|
|
self.number_of_enterprises = len(settings.enterprises)
|
|
|
|
if self.id < self.number_of_enterprises: #Empresas
|
|
self.state['id']=self.id
|
|
self.type="Enterprise"
|
|
self.tweet_probability = settings.tweet_probability_enterprises[self.id]
|
|
else: #Usuarios normales
|
|
self.state['id']=self.number_of_enterprises
|
|
self.type="User"
|
|
self.tweet_probability = settings.tweet_probability_users
|
|
self.tweet_relevant_probability = settings.tweet_relevant_probability
|
|
self.tweet_probability_about = settings.tweet_probability_about #Lista
|
|
self.sentiment_about = settings.sentiment_about #Lista
|
|
|
|
def step(self, now):
|
|
|
|
if(self.id < self.number_of_enterprises): # Empresa
|
|
self.enterpriseBehaviour()
|
|
else: # Usuario
|
|
self.userBehaviour()
|
|
|
|
super().step(now)
|
|
|
|
def enterpriseBehaviour(self):
|
|
|
|
if random.random()< self.tweet_probability: #Twittea
|
|
aware_neighbors = self.get_neighboring_agents(state_id=self.number_of_enterprises) #Nodos vecinos usuarios
|
|
for x in aware_neighbors:
|
|
if random.uniform(0,10) < 5:
|
|
x.sentiment_about[self.id] += 0.1 #Aumenta para empresa
|
|
else:
|
|
x.sentiment_about[self.id] -= 0.1 #Reduce para empresa
|
|
|
|
# Establecemos limites
|
|
if x.sentiment_about[self.id] > 1:
|
|
x.sentiment_about[self.id] = 1
|
|
if x.sentiment_about[self.id]< -1:
|
|
x.sentiment_about[self.id] = -1
|
|
|
|
x.attrs['sentiment_enterprise_%s'% self.enterprises[self.id]] = x.sentiment_about[self.id]
|
|
|
|
|
|
def userBehaviour(self):
|
|
|
|
if random.random() < self.tweet_probability: #Twittea
|
|
if random.random() < self.tweet_relevant_probability: #Twittea algo relevante
|
|
#Probabilidad de tweet para cada empresa
|
|
for i in range(self.number_of_enterprises):
|
|
random_num = random.random()
|
|
if random_num < self.tweet_probability_about[i]:
|
|
#Se ha cumplido la condicion, evaluo los sentimientos hacia esa empresa
|
|
if self.sentiment_about[i] < 0:
|
|
#NEGATIVO
|
|
self.userTweets("negative",i)
|
|
elif self.sentiment_about[i] == 0:
|
|
#NEUTRO
|
|
pass
|
|
else:
|
|
#POSITIVO
|
|
self.userTweets("positive",i)
|
|
|
|
def userTweets(self,sentiment,enterprise):
|
|
aware_neighbors = self.get_neighboring_agents(state_id=self.number_of_enterprises) #Nodos vecinos usuarios
|
|
for x in aware_neighbors:
|
|
if sentiment == "positive":
|
|
x.sentiment_about[enterprise] +=0.003
|
|
elif sentiment == "negative":
|
|
x.sentiment_about[enterprise] -=0.003
|
|
else:
|
|
pass
|
|
|
|
# Establecemos limites
|
|
if x.sentiment_about[enterprise] > 1:
|
|
x.sentiment_about[enterprise] = 1
|
|
if x.sentiment_about[enterprise] < -1:
|
|
x.sentiment_about[enterprise] = -1
|
|
|
|
x.attrs['sentiment_enterprise_%s'% self.enterprises[enterprise]] = x.sentiment_about[enterprise]
|
|
|
|
class SentimentCorrelationModel(ComportamientoBase):
|
|
|
|
def __init__(self, environment=None, agent_id=0, state=()):
|
|
super().__init__(environment=environment, agent_id=agent_id, state=state)
|
|
self.outside_effects_prob = settings.outside_effects_prob
|
|
self.anger_prob = settings.anger_prob
|
|
self.joy_prob = settings.joy_prob
|
|
self.sadness_prob = settings.sadness_prob
|
|
self.disgust_prob = settings.disgust_prob
|
|
self.time_awareness=[]
|
|
for i in range(4): #En este modelo tenemos 4 sentimientos
|
|
self.time_awareness.append(0) #0-> Anger, 1-> joy, 2->sadness, 3 -> disgust
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=0
|
|
|
|
|
|
def step(self, now):
|
|
self.behaviour()
|
|
super().step(now)
|
|
|
|
def behaviour(self):
|
|
|
|
angry_neighbors_1_time_step=[]
|
|
joyful_neighbors_1_time_step=[]
|
|
sad_neighbors_1_time_step=[]
|
|
disgusted_neighbors_1_time_step=[]
|
|
|
|
|
|
angry_neighbors = self.get_neighboring_agents(state_id=1)
|
|
for x in angry_neighbors:
|
|
if x.time_awareness[0] > (self.env.now-500):
|
|
angry_neighbors_1_time_step.append(x)
|
|
num_neighbors_angry = len(angry_neighbors_1_time_step)
|
|
|
|
|
|
joyful_neighbors = self.get_neighboring_agents(state_id=2)
|
|
for x in joyful_neighbors:
|
|
if x.time_awareness[1] > (self.env.now-500):
|
|
joyful_neighbors_1_time_step.append(x)
|
|
num_neighbors_joyful = len(joyful_neighbors_1_time_step)
|
|
|
|
|
|
sad_neighbors = self.get_neighboring_agents(state_id=3)
|
|
for x in sad_neighbors:
|
|
if x.time_awareness[2] > (self.env.now-500):
|
|
sad_neighbors_1_time_step.append(x)
|
|
num_neighbors_sad = len(sad_neighbors_1_time_step)
|
|
|
|
|
|
disgusted_neighbors = self.get_neighboring_agents(state_id=4)
|
|
for x in disgusted_neighbors:
|
|
if x.time_awareness[3] > (self.env.now-500):
|
|
disgusted_neighbors_1_time_step.append(x)
|
|
num_neighbors_disgusted = len(disgusted_neighbors_1_time_step)
|
|
|
|
|
|
anger_prob= settings.anger_prob+(len(angry_neighbors_1_time_step)*settings.anger_prob)
|
|
joy_prob= settings.joy_prob+(len(joyful_neighbors_1_time_step)*settings.joy_prob)
|
|
sadness_prob = settings.sadness_prob+(len(sad_neighbors_1_time_step)*settings.sadness_prob)
|
|
disgust_prob = settings.disgust_prob+(len(disgusted_neighbors_1_time_step)*settings.disgust_prob)
|
|
outside_effects_prob= settings.outside_effects_prob
|
|
|
|
|
|
num = random.random()
|
|
|
|
|
|
if(num<outside_effects_prob):
|
|
self.state['id'] = random.randint(1,4)
|
|
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=self.state['id'] #Almaceno cuando se ha infectado para la red dinamica
|
|
self.time_awareness[self.state['id']-1] = self.env.now
|
|
self.attrs['sentiment'] = self.state['id']
|
|
|
|
|
|
|
|
if(num<anger_prob):
|
|
|
|
|
|
self.state['id'] = 1
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=1
|
|
self.time_awareness[self.state['id']-1] = self.env.now
|
|
elif (num<joy_prob+anger_prob and num>anger_prob):
|
|
|
|
|
|
self.state['id'] = 2
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=2
|
|
self.time_awareness[self.state['id']-1] = self.env.now
|
|
elif (num<sadness_prob+anger_prob+joy_prob and num>joy_prob+anger_prob):
|
|
|
|
|
|
self.state['id'] = 3
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=3
|
|
self.time_awareness[self.state['id']-1] = self.env.now
|
|
elif (num<disgust_prob+sadness_prob+anger_prob+joy_prob and num>sadness_prob+anger_prob+joy_prob):
|
|
|
|
|
|
self.state['id'] = 4
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=4
|
|
self.time_awareness[self.state['id']-1] = self.env.now
|
|
|
|
self.attrs['sentiment'] = self.state['id']
|
|
|
|
|
|
class BassModel(ComportamientoBase):
|
|
def __init__(self, environment=None, agent_id=0, state=()):
|
|
super().__init__(environment=environment, agent_id=agent_id, state=state)
|
|
self.innovation_prob = settings.innovation_prob
|
|
self.imitation_prob = settings.imitation_prob
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=0
|
|
|
|
def step(self, now):
|
|
self.behaviour()
|
|
super().step(now)
|
|
|
|
def behaviour(self):
|
|
#Outside effects
|
|
if random.random() < settings.innovation_prob:
|
|
if self.state['id'] == 0:
|
|
self.state['id'] = 1
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=1
|
|
else:
|
|
pass
|
|
|
|
self.attrs['status'] = self.state['id']
|
|
return
|
|
|
|
#Imitation effects
|
|
if self.state['id'] == 0:
|
|
aware_neighbors = self.get_neighboring_agents(state_id=1)
|
|
num_neighbors_aware = len(aware_neighbors)
|
|
if random.random() < (settings.imitation_prob*num_neighbors_aware):
|
|
self.state['id'] = 1
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=1
|
|
|
|
else:
|
|
pass
|
|
self.attrs['status'] = self.state['id']
|
|
|
|
|
|
class IndependentCascadeModel(ComportamientoBase):
|
|
def __init__(self, environment=None, agent_id=0, state=()):
|
|
super().__init__(environment=environment, agent_id=agent_id, state=state)
|
|
self.innovation_prob = settings.innovation_prob
|
|
self.imitation_prob = settings.imitation_prob
|
|
self.time_awareness = 0
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=0
|
|
|
|
def step(self,now):
|
|
self.behaviour()
|
|
super().step(now)
|
|
|
|
def behaviour(self):
|
|
aware_neighbors_1_time_step=[]
|
|
#Outside effects
|
|
if random.random() < settings.innovation_prob:
|
|
if self.state['id'] == 0:
|
|
self.state['id'] = 1
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=1
|
|
self.time_awareness = self.env.now #Para saber cuando se han contagiado
|
|
|
|
else:
|
|
pass
|
|
|
|
self.attrs['status'] = self.state['id']
|
|
return
|
|
|
|
#Imitation effects
|
|
if self.state['id'] == 0:
|
|
aware_neighbors = self.get_neighboring_agents(state_id=1)
|
|
for x in aware_neighbors:
|
|
if x.time_awareness == (self.env.now-1):
|
|
aware_neighbors_1_time_step.append(x)
|
|
num_neighbors_aware = len(aware_neighbors_1_time_step)
|
|
if random.random() < (settings.imitation_prob*num_neighbors_aware):
|
|
self.state['id'] = 1
|
|
sentimentCorrelationNodeArray[self.id][self.env.now]=1
|
|
else:
|
|
pass
|
|
|
|
self.attrs['status'] = self.state['id']
|
|
return
|