simulation_collective_emotion.py 8.42 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
""" simluation of the agents
    - we define network structure here as well
"""

# NOTE: this uses sequential dynamics -- agents act in turn, not simultaneously
from __future__ import division, print_function
import numpy as np
import matplotlib
import networkx as nx
import pandas as pd
from time import time
import matplotlib.animation as animation
from script_ABM_collective_emotion import ColEmo
from ComplexNetworkSim import NetworkSimulation, utils, PlotCreator

#get_ipython().magic(u'matplotlib inline')

"""network"""

nodes = 30 # the amount of nodes for the graph.


#typologt
#G = nx.gnm_random_graph (nodes,nodes*2.5) # the type of network we are building.
G=nx.complete_graph(nodes) # complete network
#G = nx.gnm_random_graph (nodes,nodes*2.5)
#G = nx.barbell_graph (nodes,0) # the graph is connected by just one person.
#G = [complete,randomg] # we can create a list of networks and activate it.
nx.draw_networkx(G) # draw the network

""" parameter combination """

#event_set = [0.1,0,2] # the rate of emotion eliciting events (the change that an agent will experience)
preference_set = [0.01,0.25 ,0.5,0.75,1 ]
gamma_set = [0.9, 0.95]
#bump_set = [2]

param_combos = [ {'preference':preference, 'gamma':gamma}
                  for preference in preference_set for gamma in gamma_set]


"""simulation routine"""

MAX_SIMULATION_TIME = 100 # the amounts of simulations
TRIALS = 10 # how many repititions is the system doing
mean_total = []#pd.DataFrame(range(MAX_SIMULATION_TIME))

sim_name = 'wide'
states = [ np.random.normal(3,1) for n in G.nodes()]  # initiation state of all agenges
states[0] = np.random.normal(3,1) # infecting partcipiant 0
states[0] =  sorted([1, states[0], 8])[1] # define an upper limit.

def main(): # we are defining a function that activates the sumulation.
    directory = 'test' #output directory

    # run simulation with parameters
    # - complex network structure
    # - initial state list
    # - agent behaviour class
    # - output directory
    # - maximum simulation time
    # - number of trials
#use this is you are using the infection ration that you built in the main code
    for global_params in param_combos:
        t = time()
        directory =(
            'results/'
            '{gamma}--{preference}'.format(
            preference = global_params['preference'],
            gamma = global_params['gamma'])
            )

        simulation = NetworkSimulation(G,states,ColEmo,directory,MAX_SIMULATION_TIME,TRIALS,**global_params)
        simulation.runSimulation()

        """
        plotting
        1. Single graphe (trial 0).
        2. average and std of all trials.
        """
        # assuming that you have multiple trials - this code will consolidate all the trails data sets
        data = []
        for j in range(TRIALS): # for all j (wich are all the trials).
            from ComplexNetworkSim import utils
            contents = utils.retrieve('%s/log_trial_%d_states.pickled' % (directory,j) ) # get the pickeled data
            # you can change the name of the data set.
            ra = [] # form and empty list in which this data will look
            for i in contents:  # we need to manipulate the list because it has the number of each person in it
                y = (i[1]) # each list comes as [1,[content]] so we need to remove the first part.
                ra.append (y) # once we are done we have ra which is a list of lists of the first trial
            data.append (pd.DataFrame (np.array (ra)))


        plot_state =data[0].plot (title="collective emotion- single trial %s" % (directory), legend = None, ylim = (1,8))
        plot_state.set_xlabel("time")
        plot_state.set_ylabel("intensity")

        # save the picture
        fig = plot_state.get_figure()
        fig.savefig('%s.png' %(directory))


        """average and std """
        # create a data fram that I could use to capture all the data.
        data_t=sum (data)/len(data) # we are adding all the data sets to each other.
        m=[]
        std =[]

        m.append(data_t.mean(1)) # take the mean of every time (every row).
        std.append(data_t.std(1)) # take the sd of every time (every row).
        m = pd.DataFrame(np.array(m)) # transform into a dataset
        #m = m.T # transport - for the graph
        #m.columns =['n=10', 'n=50' , 'n=100']
        mean_total.append (m)

        std = pd.DataFrame (np.array (std)) # transform into a data set.
        std = std.fillna(value=0) # fill the nas with 0
        std = std.T
        #std.columns = ['n=10

        """"
        # this can be the plot of each of the averages. I don't need it.
        plot_m =m.plot (title="mean collective emotion - average of trials %s" % (directory), legend = None, ylim = (1,8))
        plot_m.set_xlabel("time")
        plot_m.set_ylabel("collective emotion")
        fig = plot_m.get_figure()
        fig.savefig('%s.png' %(directory))

        plot_std =std.plot (title="std collective emotion %s" % directory)
        plot_std.set_xlabel("time")
        plot_std.set_ylabel("collective emotion")
        fig = plot_std.get_figure()
        fig.savefig('%s.png' %(directory))
        """

# run main
if __name__ == '__main__':
    main()

""" in this part I print mean total which is the list of all the means"""
mean_total = np.vstack(mean_total) # stack them. I could not combine the arrays for some reason.
mean_total = pd.DataFrame(np.array(mean_total)) # transform into dataset
mean_total = mean_total.T # transform to long

param_title = [] #create a list of the parameters for the table
for i in param_combos:
    param_title.append( 'pre:%s-gamma:%s' % (i.get('preference'),i.get('gamma')))

mean_total.columns = param_title

get_ipython().magic(u'matplotlib inline')
plot_m =mean_total.plot (title="mean collective emotion - average of trials " , ylim = (1,8))
plot_m.set_xlabel("time")
plot_m.set_ylabel("collective emotion")


# assuming that you have multiple trials - this code will consolidate all the trails data sets
"""data = []

for j in range(TRIALS): # for all j (wich are all the trials).
    from ComplexNetworkSim import utils
    contents = utils.retrieve('test/log_trial_%d_statevectors.pickled' % j) # get the pickeled data
    # you can change the name of the data set.
    ra = [] # form and empty list in which this data will look
    for i in contents:  # we need to manipulate the list because it has the number of each person in it
        y = (i[1]) # each list comes as [1,[content]] so we need to remove the first part.
        ra.append (y) # once we are done we have ra which is a list of lists of the first trial

    data.append (pd.DataFrame (np.array (ra))) # data is a list of lists of lists we want to make in into just a list of arrays.

#print len(data)
#print len(data[0])


# In[38]:

plot_state =data[0].plot (title="collective emotion", legend = None, ylim = (1,8))
plot_state.set_xlabel("time")
plot_state.set_ylabel("intensity")



# In[12]:

data_t=sum (data)/len(data) # we are adding all the data sets to each other.
m=[]
std =[]

m.append(data_t.mean(1)) # take the mean of every time (every row).
std.append(data_t.std(1)) # take the sd of every time (every row).
m = pd.DataFrame(np.array(m)) # transform into a dataset
m = m.T # transport - for the graph
#m.columns =['n=10', 'n=50' , 'n=100']

std = pd.DataFrame (np.array (std)) # transform into a data set.
std = std.fillna(value=0) # fill the nas with 0
std = std.T
#std.columns = ['n=10

get_ipython().magic(u'matplotlib inline')

plot_m =m.plot (title="mean collective emotion", legend = None, ylim = (1,8))
plot_m.set_xlabel("time")
plot_m.set_ylabel("collective emotion")

plot_std =std.plot (title="std collective emotion")
plot_std.set_xlabel("time")
plot_std.set_ylabel("collective emotion")"""


# In[13]:

"""# animation
from ComplexNetworkSim import PlotCreator, AnimationCreator


directory = 'r_1' #location of simulation result files
myName = "collective_emotion" #name that you wish to give your image output files
title = "collective_emotion"
#define three simulation-specific constants:


statesToMonitor = ["1", "2", "3", "4"] #even if we have states 0,1,2,3,... plot only 1 and 0
colours = ["kakhi1", "yellow2", "sienna1", "red2"] #state 1 in red, state 0 in green
labels = ["1", "2", "3", "4"]

mapping = {"1":"0" , "2":".4", "3": ".7", "4": "1"}
trialToVisualise = 0

visualiser = AnimationCreator(directory, myName, title, mapping, trial=trialToVisualise, delay = 60)
#gif speed can be changed by giving a parameter 'delay' (default=100) to AnimationCreator
visualiser.create_gif(verbose=True)"""