def alt_combine_markov_chains(main, adjustment, alpha):
r"""
Takes two Pykov chains and creates a linear combination of them.
#. `main_chain`: the starting point for the combined chain
#. `adjustment_chain`: steers the output away from `main_chain`
#. 0 < `adjustment` < 0.5: the magnitude of the adjustment
**Note: name is due to improvement over older version.**
"""
LOG.debug('Main chain: {m}'.format(m=main))
main_copy = pykov.Chain(main)
adjustment_copy = pykov.Chain(adjustment)
main_keys = set((key for key in main))
adjustment_keys = set((key for key in adjustment))
main_start_keys = set((key[0] for key in main_keys))
adjustment_start_keys = set((key[0] for key in adjustment_keys))
_alt_supplement_chain(main_copy, main_keys, main_start_keys,
adjustment_copy, adjustment_keys,
adjustment_start_keys)
_alt_supplement_chain(adjustment_copy, adjustment_keys,
adjustment_start_keys, main_copy, main_keys,
main_start_keys)
return (1 - alpha) * main_copy + alpha * adjustment_copy
def to_pykov_chains(global_structure):
global_structure_new = dict()
for key, chain_dict in global_structure.iteritems():
for name, chain in chain_dict.iteritems():
chain_dict[name] = pykov.Chain(
chain) # replace dict with pykov chain
return global_structure
def testCounter(self):
import pykov
mc = pykov.Chain()
mc["A", "B"] += 1
self.assertEqual(mc["A", "B"], 1, msg="Increment counter once")
mc["A", "B"] += 1
self.assertEqual(mc["A", "B"], 2, msg="Increment counter twice")
def transition_matrix_to_pykov_chain(matrix):
chain = pykov.Chain()
for i, row in enumerate(matrix):
for j, column in enumerate(row):
chain[(i, j)] = column
return chain
def to_mc(
self
): # prende in argomento una matrice stocastica e la transforma in una catena di markov
n = len(self)
mcs = {}
for i in range(0, n):
for j in range(0, n):
mcs[(i, j)] = self[i][j]
return pykov.Chain(mcs)
def setFirstLocationAndWhen(self, first_location, first_when):
self.current_cell = first_location
self.current_when = first_when
self.where_inputs.append(self.current_cell)
self.when_inputs.append(self.current_when)
self.counter_vector = pykov.Vector({self.current_cell: 1})
self.normalized_vector = self.counter_vector.copy()
self.T = pykov.Chain({(self.current_cell, self.current_cell): 1})
self.learn_max_probable_cells_from_each_cells(
self.most_probable_transition_matrix, self.t)
def generate(self,
head: Any = None) -> Generator[Tuple[Any, str], None, None]:
"""Return a generator that yields a new message on every next call.
Args:
head: User to start the interaction with. If no user supplied, the sender of the earliest message is used. Note, this user will not send a message but will be the user the first generated message responds to.
Examples:
# Generate 2 messages
>>> gen = cc.generate('Alice')
>>> for _ in range(2):
tpl = next(gen)
print(": ".join(tpl))
Bob: Hey, what's up?
Charlie: Shuf is fantastic. I tried it on a 78 billion line text file.
# Generates an infinite amount of messages
>>> for tpl in cc.generate('Alice')():
print(": ".join(tpl))
Bob: Hey, what's up?
Charlie: Shuf is fantastic. I tried it on a 78 billion line text file.
...
"""
user = pykov.Vector({self.messages[0][0] if head is None else head:
1}) # starting point for markov chain
while True:
choice = (
user *
self.Musers).choose() # choose next user to write a message
if choice is None: return
user = pykov.Vector(
{choice: 1}) # create pykov vector for future user calculation
if choice in self.word_matrices:
Mword = self.word_matrices[choice]
else: # create word matrix
Mword = pykov.Matrix({(1, 1):
1}) # create matrix for word chain
for mes in [m for m in self.messages
if m[0] == choice]: # add every word to matrix
splt = mes[1].split(' ')
if (0, splt[0]) not in Mword: Mword[(0, splt[0])] = 0
Mword[(0, splt[0])] += 1
for word, nxt in zip(splt[:-1], splt[1:]):
if (word, nxt) not in Mword: Mword[(word, nxt)] = 0
Mword[(word, nxt)] += 1
if (splt[-1], 1) not in Mword: Mword[(splt[-1], 1)] = 0
Mword[(splt[-1], 1)] += 1
Mword.stochastic()
if not self.enhance_speed: self.word_matrices[choice] = Mword
C = pykov.Chain(Mword)
yield (choice, " ".join(C.walk(self.MAX_WALK_LENGTH, 0, 1)[1:-1]))
def _markov_chain(time_step, day_time_series, time_step_size):
next_time_step = WeekMarkovChain._add_delta_to_time(time_step, time_step_size)
current_vector = day_time_series.ix[time_step]
next_vector = day_time_series.ix[next_time_step]
chain_elements = [((current_state, next_state), WeekMarkovChain._probability(current_state,
next_state,
current_vector,
next_vector))
for current_state in Activity
for next_state in Activity]
return pykov.Chain(OrderedDict(chain_elements))
def __init__(self, has_bike=False):
self.utilities = pk.Chain()
self.has_bike = has_bike
self.user_base = the_base
self.user_base.add_user(self)
## Initialize utilities
self.utilities["sweat"] = 0
self.utilities["scenery"] = 0
self.utilities["social"] = 0
self.utilities["time"] = 0
def get_markov_chain(labels, prob_matrix):
mc = pk.Chain()
for rowindex, rowlabel in enumerate(labels):
for colindex, collabel in enumerate(labels):
logging.debug(
"Adding entry (%s, %s) -> %s" %
(rowlabel, collabel, prob_matrix[rowindex][colindex]))
mc[rowlabel, collabel] = prob_matrix[rowindex][colindex]
logging.debug("chain = %s, converting to stochastic" % mc)
mc.stochastic()
logging.debug("final chain = %s" % mc)
return mc
def main():
# N = 100
# B = list(range(0, int(N/2), 1))
# C1 = [int((N - i)/2) for i in B]
# C2 = [N - B[i] - C1[i] for i in range(len(B))]
# k = 20
# alpha = list(range(int(k/2), k+1))
N = 100
B = 20
C1 = 40
C2 = 40
k = 20
alpha = 15
states = []
for i in range(int((C1 + C2) / 2), C1 + C2 + 1):
states.append((i, C1 + C2 - i))
chain = pykov.Chain()
for i in range(1, len(states) - 1):
# print(states[i])
# Prob of going up is prob choosing red and getting maj blue
up = (states[i][0] / (C1 + C2)) * hyper(N, states[i][1], k, alpha)
# Prob of going down is prob of choosing blue
down = (states[i][1] / (C1 + C2)) * hyper(N, states[i][0], k, alpha)
# Prob of staying is prob of choosing blue and getting maj blue
# or choosing red and getting maj red
# stay = ((states[i][0]/(C1+C2))*hyper(N, states[i][0], k, alpha))+((states[i][1]/(C1+C2))*hyper(N, states[i][1], k, alpha))
stay = 1 - up - down
chain[(str(states[i]), str(states[i - 1]))] = up
chain[(str(states[i]), str(states[i + 1]))] = down
chain[(str(states[i]), str(states[i]))] = stay
chain[(str(states[0]), str(
states[0]))] = 1 - (states[0][1] /
(C1 + C2)) * hyper(N, states[0][0], k, alpha)
chain[(str(states[0]),
str(states[1]))] = (states[0][1] /
(C1 + C2)) * hyper(N, states[0][0], k, alpha)
chain[(str(states[len(states) - 1]), str(
states[len(states) -
1]))] = 1 - (states[i][0] /
(C1 + C2)) * hyper(N, states[i][1], k, alpha)
chain[(str(states[len(states) - 1]),
str(states[len(states) -
2]))] = (states[i][0] /
(C1 + C2)) * hyper(N, states[i][1], k, alpha)
# for state_i in states:
# for state_j in states:
for k in chain:
print(k, chain[k])
p = pykov.Vector({str((40, 40)): 1})
print(chain.pow(p, 300000))
def buildMarkovChain(phrasesFile):
phrases = construct_phrases_list(phrasesFile)
print(phrases)
wordCount = buildWordCount(phrases)
connectionsCount = buildConnectionsCount(phrases)
vector = pykov.Matrix()
for connection in connectionsCount:
initialState = connection[0]
#print("(" + str(connectionsCount[connection]) + ", " + str(wordCount[initialState]) + ")")
probability = (float(connectionsCount[connection]) /
float(wordCount[initialState]))
#print(probability)
vector[connection] = probability
return pykov.Chain(vector)
def transition_matrix(x):
a = x.FeedbackColor.replace(['green', 'yellow'], [1, 0]).values
b = np.zeros((2, 2))
for (x, y), c in Counter(zip(a, a[1:])).iteritems():
b[x - 1, y - 1] = c
green_green = b[0][0]
green_yellow = b[0][1]
yellow_green = b[1][0]
yellow_yellow = b[1][1]
chain = pykov.Chain({
('green', 'yellow'): green_yellow,
('yellow', 'green'): yellow_green,
('green', 'green'): green_green,
('yellow', 'yellow'): yellow_yellow
})
return chain
def markov_chain(states):
T = pykov.Matrix()
markov_states = []
for i in xrange(0, len(states) - 1):
markov_states.append((
states[i],
states[i + 1],
))
for i in xrange(len(markov_states)):
total = len([j for j in markov_states if j[0] == markov_states[i][0]]),
amount = markov_states.count(markov_states[i])
markov_states[i] += (amount / float(total[0]), )
for i in markov_states:
if (i[0], i[1]) not in T:
T[(i[0], i[1])] = i[2]
return pykov.Chain(T)
def generate():
import pykov
phrasesData = ''
with open('sayings.txt', "rt") as f:
phrasesData = f.read()
phrasesLines = phrasesData.split("\n")
phrases = phrasesLines
wordCount = dict()
for phrase in phrases:
words = phrase.split(" ")
for index in range(len(words)):
word = words[index]
if word not in wordCount:
wordCount[word] = 0
wordCount[word] = wordCount.get(word) + 1
connectionsCount = dict()
for phrase in phrases:
words = phrase.split(" ")
for index in range(len(words) - 1):
currState = (words[index], words[index + 1])
if currState not in connectionsCount:
connectionsCount[currState] = 0
connectionsCount[currState] = connectionsCount.get(currState) + 1
vector = pykov.Matrix()
for connection in connectionsCount:
initialState = connection[0]
probability = (float(connectionsCount[connection]) /
float(wordCount[initialState]))
vector[connection] = probability
mc = pykov.Chain(vector)
newPhrases = mc.walk(100, '+', '+\r')
newPhrases = newPhrases[1:len(newPhrases) - 1]
newPhrases = " ".join(newPhrases)
newPhrase = newPhrases.split('+')[0].strip()
return newPhrase.replace("í", "'")
def markov_chain(states, transitions, policy):
import pykov
T = pykov.Chain()
q = Queue.Queue()
visited = [False] * len(states)
visited[0] = True
q.put(0)
start = pykov.Vector({states[0]: 1})
while not q.empty():
state_idx = q.get()
pol = policy[state_idx]
for i, p in enumerate(transitions[pol][state_idx]):
if p > 0:
if i == len(states):
T[(states[state_idx], "exit")] = p
T[("exit", "exit")] = 1
else:
T[(states[state_idx], states[i])] = p
if not visited[i]:
q.put(i)
visited[i] = True
return T, start
def __init__(self, ax, span=60, feedback=False):
self.x = x[half_w]
self.target = ax.plot(self.x,
0,
' o',
color='darkgreen',
alpha=0.75,
markersize=12,
animated=True)[0]
self.ax = ax
self.feedback = feedback
self.errs = []
self.colors, self.fake_colors = [], []
self.greens, self.yellows = [], []
self.span = span # average over 60 measurements @ 60FPS = 1 second
self.fake = pykov.Chain({
('green', 'green'): 0.99688064531915932,
('yellow', 'yellow'): 0.98290598290598286,
('yellow', 'green'): 0.017094017094017096,
('green', 'yellow'): 0.0031193546808406512
})
self.fake_walk = self.fake.walk(2000)
def walk_mc(self, choice=None, i1=None, i2=None):
song = pykov.Chain(self.oChain)
if choice == None or choice == 'RAND':
choice = random.choice(self.totallst).rstrip()
if i1 == None:
i1 = 6
if i2 == None:
i2 = 12
#print("WALK")
randLength = random.randint(i1, i2)
song.move(choice)
output = "['"
output += choice
output += "', '"
reccTimes = 0
dualReccTimes = 0
noteList = []
noteList.append(choice)
for x in range(0, randLength):
if x == 0:
note = song.move(choice)
noteList.append(note)
output += note
#output += "', '"
else:
tempNote = song.move(note)
#handles recurring notes
if tempNote == noteList[x - 1]:
#save first note to come into the duplicate note
#handling
if reccTimes == 0:
firstCaughtDuplicate = tempNote
#if note that came in as duplicate isn't the original
#need to reset the times it has occured and reset
#the first caught duplicate
if firstCaughtDuplicate != tempNote:
reccTimes = 0
firstCaughtDuplicate = tempNote
#if note has occurred twice in a row, new note needs
#to be generated and reocc needs to be reset
#else, increment the amount of times the note has recurred
if reccTimes >= MAXIMUM_RECURRING_TIMES:
if song.walk_propability([tempNote, tempNote]) == 0:
tempNote = song.move(
random.choice(self.totallst.rstrip()))
while tempNote == note:
tempNote = song.move(note)
reccTimes = 0
else:
reccTimes += 1
#handles recurring dual notes
if x > 2 and noteList[x - 3] == noteList[x - 1] and noteList[
x - 2] == tempNote:
#save first note to come into the duplicate note
#handling
if dualReccTimes == 0:
dualNote1 = noteList[x - 1]
dualNote2 = tempNote
#if note that came in as duplicate isn't the original
#need to reset the times it has occured and reset
#the first caught duplicate
if dualNote1 != noteList[x - 1] and dualNote2 != tempNote:
dualReccTimes = 0
dualNote1 = noteList[x - 1]
dualNote2 = tempNote
#if dual note set has occurred twice in a row, new note needs
#to be generated and dualRecc needs to be reset
#else, increment the amount of times the note has recurred
if reccTimes >= MAXIMUM_RECURRING_TIMES:
while tempNote == noteList[x - 1]:
tempNote = song.move(note)
dualReccTimes = 0
else:
dualReccTimes += 1
note = tempNote
noteList.append(note)
output += "', '"
output += note
#print ("%d: %s" % (x, note))
output += "']"
print(noteList)
#print (song.walk_propability(choice))
return song.walk(random.randint(i1, i2), choice)
a = np.array([s, i, h, u, o, r])
str_states = ['S', 'I', 'H', 'U', 'O', 'R']
states = dict(zip(list(range(1, len(a) + 1)), str_states))
dic = {(states[i + 1], states[j + 1]): a[i][j]
for i in range(len(a)) for j in range(len(a[i]))}
M = pykov.Matrix(dic)
print(M, end='\n\n')
# Todos os estados
print(M.states(), end='\n\n')
# Antecessores de cada estado
print(M.pred(), end='\n\n')
# Sucessores de cada estado
print(M.succ(), end='\n\n')
C = pykov.Chain(dic)
state = pykov.Vector(S=1)
# Distribuição de prob após N dias, começando no estado state
n_inicio = 282 # dias, entre o dia do primeiro infetado em Portugal e o dia da submissão do projeto
dia274 = C.pow(state, n_inicio)
n_fim = 365 - (31 + 28 + 1)
fim2020 = C.pow(state, n_fim)
# % aumento de recuperados esperado entre 09/12/2020 e 01/01/2021
rate_r = (fim2020 - dia274)['R'] * 100
# média de recuperados diários esperada entre 09/12/2020 e 01/01/2021
pop = 10.28 * 10**6
dias = n_fim - n_inicio
avg_r_daily = (rate_r / 100 * pop / dias)
print('rate_r {}\navg_r_daily {}\n'.format(round(rate_r, 2),
round(avg_r_daily)))
('coal', 'NHN'): 0.2658,
('oil', 'WW'): 0.1399,
('oil', 'COD'): 0.1820,
('oil', 'NHN'): 0.2666,
('chemistry', 'WW'): 0.1397,
('chemistry', 'COD'): 0.1826,
('chemistry', 'NHN'): 0.1916,
('smelt', 'WW'): 0.0759,
('smelt', 'COD'): 0.0515,
('smelt', 'NHN'): 0.0417,
('farm', 'WW'): 0.0458,
('farm', 'COD'): 0.1116,
('farm', 'NHN'): 0.0355,
})
T = pykov.Chain(d)
import matplotlib.pyplot as plt
import numpy as np
# create some data to use for the plot
dt = 0.001
t = np.arange(0.0, 10.0, dt)
r = np.exp(-t[:1000] / 0.05) # impulse response
x = np.random.randn(len(t))
s = np.convolve(x, r)[:len(x)] * dt # colored noise
# the main axes is subplot(111) by default
plt.plot(t, s)
plt.axis([0, 1, 1.1 * np.amin(s), 2 * np.amax(s)])
plt.xlabel('time (s)')
def __init__(self, num_states, rand=True, arm_count=0):
self.num_states = num_states
self.cumulative_reward = 0.0
self.pull_count = 0
self.rand = rand
self.arm_count = arm_count
if self.rand:
# create ergodic transition matrix
self.tran_matrix = np.zeros((num_states, num_states))
ergodic = False
while ergodic == False:
P = np.random.rand(num_states, num_states)
P = preprocessing.normalize(P,
norm='l1',
axis=1,
copy=True,
return_norm=False)
dic = {}
for i in range(num_states):
for j in range(num_states):
dic[(i, j)] = P[i, j]
T = pykov.Chain(dic)
G = nx.DiGraph(list(T.keys()))
if nx.is_strongly_connected(G) and nx.is_aperiodic(G):
ergodic = True
self.tran_matrix = P
else:
if self.arm_count == 0:
self.tran_matrix = np.array([[0., 1.], [.01, .99]])
if self.arm_count == 1:
self.tran_matrix = np.array([[.99, .01], [1., 0.]])
# find the steady state distribution
mc = markovChain(self.tran_matrix)
mc.computePi('linear') # We can also use 'power', 'krylov' or 'eigen'
self.steady_state = np.asmatrix(mc.pi)
# find ergodic constants
P_tilde = np.zeros(
(self.num_states,
self.num_states)) # P_tilde as per Formula 2.1 in Page 65
for x in range(self.num_states):
for y in range(self.num_states):
P_tilde[x, y] = self.steady_state[0, y] * self.tran_matrix[
y, x] / self.steady_state[0, x]
MP = np.dot(self.tran_matrix, P_tilde)
eigenval, _ = np.linalg.eig(MP)
self.eta = np.sort(eigenval)[-2] # Second largest eigenvalue
self.eta = np.sqrt(self.eta) # sqrt for TV norm
# Now we need to compute C using chi_0 square in Thm 2.7
# Here we don't have information about current state,
# given a steady state distribution, chi_0 is maximized when current state is of the form (1,0,0,0,0,0)
curr_state = np.zeros((1, self.num_states))
index = np.argmin(self.steady_state)
curr_state[0, index] = 1.0
self.C = 0.25 * sum([(self.steady_state[0, i] - curr_state[0, i])**2 /
self.steady_state[0, i]
for i in range(self.num_states)])
self.C = np.sqrt(self.C) # sqrt for TV norm
if self.rand:
self.reward_type = np.random.randint(0, 3)
self.set_reward_parameters()
else:
if self.arm_count == 0:
self.rewards = np.array([0, 1])
elif self.arm_count == 1:
self.rewards = np.array([.5, .5])
26, 24, 43, 45, 35, 48, 22, 41, 47, 60, 47, 33, 32, 31, 39, 23, 20, 38, 33,
24, 37, 29, 58, 31, 42, 30, 39, 28, 41, 29, 38, 35, 42, 35, 32, 49, 23, 39,
37, 31, 42, 29, 34, 37, 46, 31, 35, 31, 32, 52, 53, 41, 34, 34, 46, 29, 35,
33, 35, 40, 39, 34, 19, 28, 16, 30, 41, 32
])
total_pcts = (total_kills - total_errors) / total_attempts
# Load set scores.
with open("./set_scores.csv") as f:
reader = csv.reader(f)
set_scores = list(reader)
# The csv module doesn't do any conversion for us, so convert the set scores
# from strings to integers.
# 2017-09-03: I note that at least one set has less than 25 plays recorded.
# This is impossible for a 25-point set, but it looks like it's only one set,
# so I don't really care right now.
set_scores = [[int(s) for s in score] for score in set_scores]
transition_matrix = estimate_transition_probs(set_scores)
P = transition_matrix
chain = pykov.Chain({
("OU", "OPP"): P[0, 1],
("OU", "OU"): P[1, 1],
("OPP", "OU"): P[1, 0],
("OPP", "OPP"): P[0, 0]
})
def prepare_pykov_chain_with_single_user_mobility_states(
grouped_by_date_grid_by_minute_of_day_mp_fetched, current_day_str,
predicted_day_str):
list_of_day_str_applicable = support.difference_of_days(
current_day_str, predicted_day_str)
from_to_user_entry_dict = {}
for date, grid_by_minute_of_day_mp_fetched in grouped_by_date_grid_by_minute_of_day_mp_fetched.items(
):
if support.calc_day(date) in list_of_day_str_applicable:
#It seems this day is a contender in the prediction.
#For each minute of the day look at the cell id(source) and look at the next because that is the destination
#Each pair of source and destination should be added to the from_to user_entry_dict (date doesn't matter anymore as link is formed)
#Using the source as the key and adding the destination to the list
i = 0
for source_mp_fetched in grid_by_minute_of_day_mp_fetched:
if i == common_config.MINUTES_IN_A_DAY - 1:
#We have reached the end of the day, must look at the next if possible in the next day
next_date = date + support.Range.RESOLUTION_DATETIME_DAY
if support.calc_day(
next_date) in list_of_day_str_applicable:
#It seems the adjoining day is also a contender in the prediction. Configure the destination correctly
destination_mp_fetched = grouped_by_date_grid_by_minute_of_day_mp_fetched[
next_date][0]
else:
#There is no connection to the next day
destination_mp_fetched = None
else:
#In the middle of the day, destination is next in the grid
destination_mp_fetched = grid_by_minute_of_day_mp_fetched[
i + 1]
if destination_mp_fetched:
source_user_entry = UserEntry(
source_mp_fetched.day, source_mp_fetched.minute_of_day,
source_mp_fetched.cell_id)
destination_user_entry = UserEntry(
destination_mp_fetched.day,
destination_mp_fetched.minute_of_day,
destination_mp_fetched.cell_id)
#Add it to the from to user entry dict but with the source_user_entry as key
#Add it as a key if it doesn't exist yet
if source_user_entry in from_to_user_entry_dict:
from_to_user_entry_dict[source_user_entry].append(
destination_user_entry)
else:
from_to_user_entry_dict[source_user_entry] = [
destination_user_entry
]
i += 1
#Calculate all percentages the same from and to user entry coincide
pykov_chain_entries = {}
for starting_user_entry, destinations in from_to_user_entry_dict.items():
starting_key = starting_user_entry.to_pykov_key()
total_amount = float(len(destinations))
grouped_by_cell_id = support.group_by(
destinations, lambda user_entry: user_entry.cell_id)
for destination_cell_id, destinations_with_same_cell_id in grouped_by_cell_id.items(
):
destination_key = destinations_with_same_cell_id[0].to_pykov_key()
amount_of_destinations_with_same_cell_id = len(
destinations_with_same_cell_id)
percentage = float(
amount_of_destinations_with_same_cell_id) / total_amount
pykov_chain_entries[starting_key, destination_key] = percentage
return pykov.Chain(pykov_chain_entries)
def language_game(number_of_agents, number_of_rounds, plot_time_points,
word_frequencies, initial_word_memory,
initial_word_transitions, reward):
history = []
agents = {}
for agent_int in range(number_of_agents):
agents[str(agent_int)] = {
'id': agent_int,
'word memory': deepcopy(initial_word_memory),
'word transitions': pykov.Chain(deepcopy(initial_word_transitions))
}
def update_association_strength(agent, word, speaker_association, reward):
successor_states = agent['word transitions'].succ(word)
transition_probabilities = markov_update_words(successor_states,
speaker_association,
reward)
for state, value in transition_probabilities.items():
agent['word transitions'][word, state] = value
def communicate(speaker, hearer, word, speaker_association,
hearer_association):
success = 0
if hearer_association != speaker_association:
pass
else:
success = 1
update_association_strength(hearer, word, speaker_association,
reward)
update_association_strength(speaker, word, speaker_association,
reward)
speaker['word memory'] = markov_update_words(
speaker['word memory'], speaker_association, reward)
hearer['word memory'] = markov_update_words(
hearer['word memory'], speaker_association, reward)
return success
def communicate_teach(speaker, hearer, word, speaker_association,
hearer_association):
success = 0
if hearer_association != speaker_association:
update_association_strength(hearer, word, speaker_association,
reward)
hearer['word memory'] = markov_update_words(
hearer['word memory'], speaker_association, reward)
else:
success = 1
update_association_strength(hearer, word, speaker_association,
reward)
update_association_strength(speaker, word, speaker_association,
reward)
speaker['word memory'] = markov_update_words(
speaker['word memory'], speaker_association, reward)
hearer['word memory'] = markov_update_words(
hearer['word memory'], speaker_association, reward)
return success
for i in range(number_of_rounds):
random_agents = random.sample(range(number_of_agents), 2)
speaker_id = random_agents[0]
hearer_id = random_agents[1]
speaker = agents[str(speaker_id)]
hearer = agents[str(hearer_id)]
word = speaker['word memory'].choose()
if i % plot_time_points == 0:
word_index = word_frequencies['word indices'][word]
index = int(i / plot_time_points)
word_frequencies['word frequencies'][word_index][index] += 1
speaker_association = speaker['word transitions'].move(word)
hearer_association = hearer['word transitions'].move(word)
success = communicate(speaker, hearer, word, speaker_association,
hearer_association)
history.append(success)
agent_memories = []
word_frequencies['word associations'][word_frequencies['word indices'][
word]][word_frequencies['word indices'][speaker_association]] += 1
agent_memory_matrix = [
np.zeros((len(initial_word_memory), len(initial_word_memory)))
for i in range(number_of_agents)
]
for agent_id, agent_values in agents.items():
word_memory = agent_values['word memory'].values()
agent_memories.append(list(word_memory))
word_frequencies['word game counts'].append(np.mean(agent_memories,
axis=0))
return history, word_frequencies
def _add_transition(self, day, time, from_activity, to_activity, probability):
chain = self.__chain[day][time]
elements = OrderedDict(chain)
elements[(from_activity, to_activity)] = probability
self.__chain[day][time] = pykov.Chain(elements)
