def test_transition_can_fire():
t = Transition([], [])
assert t.can_fire(State([0])) == True
t1 = Transition([], [0])
assert t1.can_fire(State([6])) == True
t2 = Transition([0], [])
assert t2.can_fire(State([1])) == True
t3 = Transition([0],[])
assert t3.can_fire(State([0])) == False
t4 = Transition([0, 1], [])
assert t4.can_fire(State([320, 0])) == False
def get_data(file_name): wrd_voc, wrd_list, pos_voc, pos_list, depen_voc, depen_list = read_data(file_name) sentences = getTree(file_name) #skip the empty catagories # input data: # top 2 words at buffer & stack; leftmost and rightmost child of the top 2 words at stack # wordIndex ===> wordVec, posIndex ==>posVec, arc_labels ==> arcLabels cnt_case = 1 trn_case_name = file_name + '_case' #trn_label_name = '../data/trn_label' f_case = codecs.open(trn_case_name, 'w', 'utf-8') #f_label = codecs.open(trn_label_name, 'w', 'utf-8') for i in range(0, len(sentences)): sentence = sentences[i] words = sentence['words'] poses = sentence['poses'] indexs = sentence['indexs'] arc_labels = sentence['arc_labels'] trans = Transition(sentence) while not trans.finish(): index_i = trans.stack[-1] index_j = trans.buffer[0] #print index_i if index_i == -1: if indexs[index_j] == index_i: if legal_right_arc(index_j, indexs, trans.buffer): save_case(f_case, words, poses, 'R_' + arc_labels[index_j], trans.buffer, trans.stack) trans.right_arc(arc_labels[index_j]) #if len(trans.stack) != 0: print len(trans.stack) if len(trans.buffer) != 1: print len(trans.buffer) break# finish parsing else: save_case(f_case, words, poses, 'SHIFT\n', trans.buffer, trans.stack) trans.shift() continue # we must confirm there are no any arc belong to the buffer header if indexs[index_j] == index_i: if legal_right_arc(index_j, indexs, trans.buffer): save_case(f_case, words, poses, 'R_' + arc_labels[index_j], trans.buffer, trans.stack) trans.right_arc(arc_labels[index_j]) else: save_case(f_case, words, poses, 'SHIFT\n', trans.buffer, trans.stack) trans.shift() continue # all the left arc is OK~ if indexs[index_i] == index_j: save_case(f_case, words, poses, 'L_' + arc_labels[index_i], trans.buffer, trans.stack) trans.left_arc(arc_labels[index_i]) continue save_case(f_case, words, poses, 'SHIFT\n', trans.buffer, trans.stack) trans.shift() f_case.close()
def addNewTransition(self, q_from, q_to, symbol, timeguard):
t = Transition(q_from, q_to, symbol, timeguard)
self.DELTA.append(t)
qui permettent de tester vos fonctions.
Pour cela il suffit de décommenter le code
de la fonction que vous souhaiter tester
"""
from automate import Automate
from state import State
from transition import Transition
from parser import *
#from essai import Essai
#import projet
s0 = State(0, True, False)
s1 = State(1, False, False)
s2 = State(2, False, True)
t1 = Transition(s0, 'a', s0)
t2 = Transition(s0, 'b', s1)
t3 = Transition(s1, 'a', s2)
t4 = Transition(s1, 'b', s2)
t5 = Transition(s2, 'a', s0)
t6 = Transition(s2, 'b', s1)
L = [t1, t2, t3, t4, t5, t6]
#auto=Automate(L)
print(" -auto est l'automate suivant : ")
autoB = Automate.creationAutomate("tripleA.txt")
autoA = Automate.creationAutomate("auto.txt")
#autoA.show('autoA')
#autoB.show('autoB')
#print(autoA)
de la fonction que vous souhaiter tester
"""
from automate import Automate
from state import State
from transition import Transition
from parser import *
#from essai import Essai
#import projet
print "DEBUT PROGRAMME\n"
s = State(1, False, False)
s2 = State(1, True, False)
t = Transition(s, "a", s)
t2 = Transition(s, "a", s2)
s.insertPrefix(2)
a = Automate([t, t2])
a.prefixStates(3)
a.show("justep")
"""
print "etat s " + s.id
print "s "+ str(s)
print "t "+ str(t)
print "a "+ str(a)
"""
print "s=s2? " + str(s == s2)
print "t=t2? " + str(t == t2)
num_episodes = 25_000
save_every = 50
rewards = []
for episode in range(1, num_episodes + 1):
state = env.reset()
done = False
start_time = time.time()
ep_rewards = []
while not done:
action = agent.get_action(state, False)
new_state, reward, done, _ = env.step(action)
#env.render()
agent.update_mem(Transition(state, action, new_state, reward,
done))
agent.train()
state = new_state
ep_rewards.append(reward)
rewards.append(np.sum(ep_rewards))
print(
f'ep: {episode}, time: {round(time.time() - start_time, 3)}s, ep_reward: {round(np.sum(ep_rewards),2)}, avg_reward: {round(np.mean(rewards[-25:]),2)} epsilon: {round(agent.epsilon,2)}'
)
if episode % save_every == 0:
torch.save(
agent.model.state_dict(),
f'models/episode={episode} avg_reward={round(np.mean(rewards[episode-save_every:]),2)}'
def fire_alarm():
t = Transition(transition_step_time)
t.start()
time.sleep(post_alarm_wait)
def test_multi_in_out():
t = Transition([0, 1, 2, 3], [4, 5, 6])
state = State([1, 2, 3, 4, 0, 1, 2])
s2 = t.fire(state)
assert s2.tokens == [0, 1, 2, 3, 1, 2, 3]
import sys
sys.path.append('../')
from replay import Replay
from transition import Transition
import numpy as np
def f(arr):
return np.array(arr)
replay = Replay(2, 2)
t1 = Transition(f([]), 1, 2, f([]))
t11 = Transition(f([]), 1, 2, f([]))
t2 = Transition(f([1, 2, 3]), 4, 2, f([77, 2, 1]))
t22 = Transition(f([1, 2, 3]), 4, 2, f([77, 2, 1]))
t3 = Transition(f([1, 2, 1]), 4, 2, f([77, 5, 1]))
t33 = Transition(f([1, 2, 1]), 4, 2, f([77, 5, 1]))
replay.add_transition(t1)
replay.add_transition(t2)
replay.add_transition(t3)
replay.add_transition(t11)
replay.add_transition(t22)
replay.add_transition(t33)
print("Replay: " + str(replay))
print("Transition: " + str(t22))
from transition import Transition
from side import Side
from data.vars import *
from typing import Dict
cipher_name = 'misty2' # type: str
systems = dict() # type: Dict[int, System]
systems[2] = System(inputs=[a1, a2, a3, a4],
outputs=[c1, c2, c3, c4],
transitions=[
Transition(Side(a1), Side(c3, cp_with_lo(a2, mu)), F),
Transition(Side(a3), Side(c1, cp_with_lo(a4, mu)), F),
Transition(Side(a2), Side(c4, cp_with_lo(c1, lmbda)),
G),
Transition(Side(a4), Side(c2, cp_with_lo(c3, lmbda)),
G)
])
systems[3] = System(inputs=[a1, a2, a3, a4],
outputs=[c1, c2, c3, c4],
transitions=[
Transition(Side(a1), Side(b2, cp_with_lo(a2, mu)), F),
Transition(Side(a3), Side(b1, cp_with_lo(a4, mu)), F),
Transition(Side(a2), Side(c3, cp_with_lo(b1, lmbda)),
G),
Transition(Side(a4), Side(c1, cp_with_lo(b2, lmbda)),
G),
Transition(Side(b1), Side(c4, cp_with_lo(c1, mu)), F),
Transition(Side(b2), Side(c2, cp_with_lo(c3, mu)), F)
])
from automate import Automate
from state import State
from transition import Transition
from parser import *
print("DEBUT PROGRAMME\n")
s1=State(1, True, True)
s2=State(2, False, False)
t1= Transition(s1,"a",s1)
t2=Transition(s1,"a",s2)
t4=Transition(s2,"a", s2)
t5=Transition(s2,"b",s2)
t6= Transition(s1,"a",s1)
t7= Transition(s2,"b",s1)
listeT1 = [t1,t2,t4,t5,t6,t7]
a=Automate(listStates=[], label="a", listTransitions=listeT1)
print(a)
s3=State(1,True,False)
s4=State(2,False,True)
tb1= Transition(s3,"b",s3)
tb2= Transition(s3,"a",s4)
tb3= Transition(s4,"b",s4)
tb4= Transition(s4,"c",s3)
tb5 = Transition(s3,"b",s4)
listeT2 = [tb1,tb2,tb3,tb4,tb5]
b=Automate(listStates=[s3,s4], label= "b", listTransitions = listeT2)
print(b)
def petri(elements):
print(elements)
between = ''
list_places = []
in_statement = False
checklbrac = '['
checkrbrac = ']'
checktime = 'time'
checkstar = '*'
checknarrow = '|'
checkless = '<'
checkmore = '>'
listoutinbeforenarrow = []
listoutinafternarrow = []
for i in elements:
if checklbrac in i:
in_statement = True
if in_statement:
between += i
if checkrbrac in i:
in_statement = False
break
between = between.replace('[','').replace(']','')
for i in between:
list_places.append(int(i))
print(list_places)
between = ''
for i in elements:
if checktime in i:
in_statement = True
if in_statement:
between += i
if checkstar in i:
in_statement = False
break
between = between.replace('time','').replace('*','').replace('=', '')
firings = int(between)
print(firings)
between = ''
for i in elements:
if checkstar in i:
in_statement = True
if in_statement:
between += i
if checknarrow in i:
in_statement = False
break
between = between.replace('*','').replace('|','')
for i in between:
listoutinbeforenarrow.append(i)
print(listoutinbeforenarrow)
listoutinafternarrow = elements[13]
#between = between.replace('|','').replace('*','')
# for i in between:
# listoutinafternarrow.append(i)
# print(listoutinafternarrow)
ps = [Place(m) for m in list_places]
countless = 0
countmore = 0
for i in listoutinbeforenarrow:
if checkless in i:
countless += 1
if checkmore in i:
countmore += 1
print(countless, countmore)
listout = []
listin = []
for i in range(countless):
listout = [Out(ps[i])]
for i in range(countmore):
listin = [In(ps[i])]
for i in range(1):
ts = dict(i=Transition(listout, listin + [In(ps[1])]))
# a = elements[0]
# firings = elements[1]
# coeff = [num for num in elements[2:] if isinstance(num, int)]
# print('all coeff', coeff)
# ps = [Place(m) for m in a]
# ts = dict(
# t1=Transition(
# [Out(ps[0])],
# [In(ps[0]), In(ps[1])]
# )
# t2=Transition(
# [Out(ps[1])],
# [In(ps[2]), In(ps[0])])
# ,)
firing_sequence = [choice(list(ts.keys())) for _ in range(firings)] # stochastic execution
print(firing_sequence)
petri_net = PetriNet(ts)
petri_net.run(firing_sequence, ps)
def test_hash(self, s1, s2, inp, out, cnt, s12, s22, inp2, out2, cnt2,
equal):
t = Transition(s1, s2, inp, out, cnt)
t2 = Transition(s12, s22, inp2, out2, cnt2)
assert (hash(t) == hash(t2)) == equal
def test_ne(self, s1, s2, inp, out, cnt, s12, s22, inp2, out2, cnt2):
t = Transition(s1, s2, inp, out, cnt)
t2 = Transition(s12, s22, inp2, out2, cnt2)
assert t != t2
def test_no_output_transition():
t = Transition([0], [])
state = State([6])
s2 = t.fire(state)
assert s2.tokens == [5]
def test_in_and_out_transition():
t = Transition([0], [1])
state = State([6, 5])
s2 = t.fire(state)
assert s2.tokens == [5, 6]
def tick(self):
# print("tick: ", self.name)
self.__current_time = ticks_us()
elapsed_time = self.elapsed_time
# Check is the duration is up
if elapsed_time >= self.duration:
cur_angle = self.target_angle
self.angle(angle_value=cur_angle, channel=self.channel)
return True
cur_angle = self.__current_angle
valid_transition = False
# print("transition type is: ", self.__transition)
if self.__transition == 'linear_tween':
cur_angle = Transition().linear_tween(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration)
valid_transition = True
if self.__transition == 'ease_in_circ':
cur_angle = Transition().ease_in_circ(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration)
valid_transition = True
if self.__transition == 'ease_in_cubic':
cur_angle = Transition().ease_in_cubic(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration)
valid_transition = True
if self.__transition == 'ease_in_quad':
cur_angle = Transition().ease_in_quad(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration)
valid_transition = True
if self.__transition == 'ease_in_quart':
cur_angle = Transition().ease_in_quart(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration)
valid_transition = True
if self.__transition == 'ease_in_expo':
cur_angle = Transition().ease_in_expo(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration)
valid_transition = True
if self.__transition == 'ease_in_quart':
cur_angle = Transition().ease_in_quart(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration)
valid_transition = True
if self.__transition == 'ease_in_quint':
cur_angle = Transition().ease_in_quint(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration)
valid_transition = True
if self.__transition == 'ease_in_sine':
cur_angle = Transition().ease_in_sine(
current_time=self.elapsed_time,
start_value=self.start_angle,
change_in_value=self.change_in_value,
duration=self.duration,
start_time=self.__tick_start_time,
target_angle=self.target_angle)
valid_transition = True
if not valid_transition:
print("error - No Valid Transition provided")
cur_angle = int(cur_angle)
self.angle(angle_value=cur_angle, channel=self.channel)
if self.current_angle == self.target_angle:
return True
else:
return False
def test_no_input_transition():
t = Transition([], [0])
state = State([4])
s2 = t.fire(state)
assert s2.tokens == [5]
def create_Transition(self, condition):
self.transition = Transition(self, condition, self.next)
def test_transition_init_error(self, s1, s2, inp, out, cnt):
with pytest.raises(ValueError):
t = Transition(s1, s2, inp, out, cnt)
import os
import copy
import sp
from sp import *
from parser import Parser
from itertools import product
from automateBase import AutomateBase
from automate import Automate
#2.1 Creation d'automates
#1.
s0 = State(0, True, False)
s1 = State(1, False, False)
s2 = State(2, False, True)
t1 = Transition(s0, "a", s0)
t2 = Transition(s0, "b", s1)
t3 = Transition(s1, "a", s2)
t4 = Transition(s1, "b", s2)
t5 = Transition(s2, "a", s0)
t6 = Transition(s2, "b", s0)
autom = Automate([t1, t2, t3, t4, t5, t6])
#print(autom)
#autom.show("A_ListeTrans")
#2.
auto1 = Automate([t1, t2, t3, t4, t5, t6], [s0, s1, s2])
#print(auto1)
#auto1.show("A_ListeTrans")
def _write_header(self):
print(','.join(Transition.csv_headers()), file=self.file)
if __name__ == "__main__":
cnn = CNN()
stg = Strategy(cnn)
megaman = Agent(stg) # player 1
megaman.get_exploration_factor = constant_function(EXPLORATION)
megaman.train()
performance = []
print("Training ... ")
for t in itertools.count():
megaman.train()
# p1, p2 = play_many([megaman, "negamax"], num_games=GAMES_PER_EPISODE)
p1, p2 = play_many(["negamax", megaman], num_games=GAMES_PER_EPISODE)
transitions = Transition(*zip(*p2))
num_wins = transitions.reward.count(1)
win_ratio = num_wins / GAMES_PER_EPISODE
print(f"WR: {win_ratio:>6.2%}")
performance.append(win_ratio)
megaman.learn(transitions, player_id=2)
megaman.get_exploration_factor = constant_function(megaman.get_exploration_factor() * DECAY_FACTOR)
torch.save(megaman.strategy.model.state_dict(), PATH_RESULTS / "megaman2.pt")
with open(PATH_RESULTS / "megaman2_vs_negamax.json", "w") as f:
json.dump(performance, f)
if (win_ratio >= 0.95):
break
# Set up our FSM with the required info:
# Set of states
states = ['Q=0', 'Q=1', 'Error']
# Set of allowed inputs
# These represent possible permutations of S and R
alphabet = ['00', '01', '10', '11']
# Set of accepted states
accepting_states = ['Q=0', 'Q=1']
# The initial state
initial_state = 'Q=0'
fsm = FSM(states, alphabet, accepting_states, initial_state)
# Create the set of transitions
# S = 0: set, R = 0: reset
transition1 = Transition('Q=0', '00', 'Error')
transition2 = Transition('Q=0', '01', 'Q=1')
transition3 = Transition('Q=0', '10', 'Q=0')
transition4 = Transition('Q=0', '11', 'Q=0')
transition5 = Transition('Q=1', '00', 'Error')
transition6 = Transition('Q=1', '01', 'Q=1')
transition7 = Transition('Q=1', '10', 'Q=0')
transition8 = Transition('Q=1', '11', 'Q=1')
transition9 = Transition('Error', '00', 'Error')
transition10 = Transition('Error', '01', 'Error')
transition11 = Transition('Error', '10', 'Error')
transition12 = Transition('Error', '11', 'Error')
transitions = [
transition1, transition2, transition3, transition4, transition5,
transition5, transition6, transition7, transition8, transition9,
transition10, transition11, transition12
def play_once(agents):
env = make("connectx")
env.reset()
env.run(agents)
return Transition.parse_steps(env.steps)
def __evaluate_event_mrai(self, mrai_event_time: float, mrai_id: int,
data_frame: pd.DataFrame):
# Events before the MRAI timeout
events_before = data_frame[data_frame.time < mrai_event_time]
previous_mrai = None
if Events.MRAI in events_before.event.values:
previous_mrai = events_before[events_before.event ==
Events.MRAI].tail(1).time.values[0]
if previous_mrai is not None:
events_before = events_before[(events_before.time > previous_mrai) &\
(events_before.event != Events.MRAI) &\
(events_before.event != Events.TX)]
# Find events caused by the MRAI
events_after = pd.DataFrame(columns=NodeAnalyzer.EVALUATION_COLUMNS)
if mrai_id in data_frame.index:
events_after = data_frame.loc[[mrai_id], :]
# Keep a tmp variable with the state that can have been changed
# thanks to this reception
new_state = None
# Keep a list of received and transmitted routes
received_routes = []
transmitted_routes = []
rx_value = [] if self.rx_values_tmp is None else self.rx_values_tmp
# rx_events = []
memory_actual_state = self.actual_state.copy()
if len(events_before.index) == 0:
return
# Check each row of the events caused by the reception
for row_id, row_event, row_value in zip(
events_before[NodeAnalyzer.EVALUATION_COLUMNS[0]],
events_before[NodeAnalyzer.EVALUATION_COLUMNS[2]],
events_before[NodeAnalyzer.EVALUATION_COLUMNS[5]]):
# If the event is a change in the state, I update the local
# variable that keeps the state
if row_event == Events.RIB_CHANGE:
if len(rx_value) > 0:
if new_state is None:
new_state = set()
else:
self.actual_state = new_state
new_state = NodeAnalyzer.__evaluate_rib_change(row_value)
rx_v = rx_value.pop(0)
# rx_events.pop(0)
new_state = self.__state_analyzer(new_state, rx_v)
# If the event is a RX i update the corresponding sets
if row_event == Events.RX:
rx_value.append(row_value)
# rx_events.append(row_id)
elem = self.__evaluate_rx(row_value)
if elem not in received_routes:
received_routes.append(elem)
if len(rx_value) > 0:
self.rx_values_tmp = rx_value
else:
self.rx_values_tmp = None
new_state = set() if new_state is None else new_state
self.actual_state = memory_actual_state
self.__state_register(new_state)
# Check each row of the events caused by the reception
for row_event, row_value in zip(
events_after[NodeAnalyzer.EVALUATION_COLUMNS[2]],
events_after[NodeAnalyzer.EVALUATION_COLUMNS[5]]):
# If the event is a TX i update the corresponding sets
if row_event == Events.TX:
elem = self.__evaluate_tx(row_value)
if elem not in transmitted_routes:
transmitted_routes.append(elem)
received_routes = None if len(received_routes) == 0 else \
sorted(received_routes)
transmitted_routes = None if len(transmitted_routes) == 0 else \
sorted(transmitted_routes)
# Create the new transition
input_state = NodeAnalyzer.hash_state_set(self.actual_state)
output_state = NodeAnalyzer.hash_state_set(new_state)
transition = Transition(input_state, output_state, received_routes,
transmitted_routes)
# Change the state
self.actual_state = new_state
# Check if the transition has already been known
if hash(transition) not in self.transitions.index:
self.transitions.loc[hash(transition)] = [
transition.init_state, transition.output_state,
transition.input, transition.output, transition.counter
]
else:
# The transition is already in the dictionary, increase the
self.transitions.at[hash(transition),
NodeAnalyzer.TRANSITIONS_COLUMNS[5]] += 1
from transition import Transition, FSM
# Set up our FSM with the required info:
# Set of states
states = ['State 1', 'State 2', 'Error']
# Set of allowed inputs
alphabet = [1, 0]
# Set of accepted states
accepting_states = ['State 1']
# The initial state
initial_state = 'State 1'
fsm = FSM(states, alphabet, accepting_states, initial_state)
# Create the set of transitions
transition1 = Transition('State 1', 1, 'State 2')
transition2 = Transition('State 2', 0, 'State 1')
transition3 = Transition('State 1', 0, 'Error')
transition4 = Transition('State 2', 1, 'Error')
transition5 = Transition('Error', 1, 'Error')
transition6 = Transition('Error', 0, 'Error')
transitions = [
transition1, transition2, transition3, transition4, transition5,
transition6
]
# Verify and add them to the FSM
fsm.add_transitions(transitions)
# Now that our FSM is correctly set up, we can give it input to process
# Let's transition the FSM to a green light
should_be_accepted = fsm.accepts([1, 0, 1, 0])
print(should_be_accepted)
def trigger_update(self, update):
result = Transition.trigger_update(self, update)
def train(env, agent):
replay_buffer = ReplayBuffer(REPLAY_BUFFER_SIZE)
for cycle in range(EPOCH):
epoch_reward = 0.0
agent.update_target_net() # target network update
for episode in range(EPISODES):
state = env.reset()
goal, goal_program = env.sample_goal()
env.set_goal(goal, goal_program)
episode_reward = 0
no_of_achieved_goals = 0
current_instruction_steps = 0
trajectory = []
start = time.time()
for step in range(STEPS):
action = agent.get_action(state, goal)
next_state, reward, done, _ = env.step(
action, record_achieved_goal=True)
achieved_goals = env.get_achieved_goals()
transition = Transition(state, action, goal, reward,
next_state, achieved_goals, done)
trajectory.append(transition)
episode_reward += reward
if reward == 1.0:
goal, goal_program = env.sample_goal()
env.set_goal(goal, goal_program)
no_of_achieved_goals += 1
current_instruction_steps = 0
if done:
break
if current_instruction_steps == 10:
break
current_instruction_steps += 1
state = next_state
# end = time.time()
# print("environment interaction secs: ", end - start)
# start = end
for step in range(len(trajectory)):
replay_buffer.add(trajectory[step])
for goal_prime in trajectory[step].satisfied_goals_t:
transition = Transition(trajectory[step].current_state,
trajectory[step].action,
goal_prime, 1.0,
trajectory[step].next_state,
trajectory[step].satisfied_goals_t,
trajectory[step].done)
replay_buffer.add(transition)
deltas = relabel_future_instructions(trajectory, step, 4, 0.9)
for delta in deltas:
goal_prime, reward_prime = delta
transition = Transition(trajectory[step].current_state,
trajectory[step].action,
goal_prime, reward_prime,
trajectory[step].next_state,
trajectory[step].satisfied_goals_t,
trajectory[step].done)
replay_buffer.add(transition)
# end = time.time()
# print("HIR secs: ", end - start)
# start = end
epoch_reward += episode_reward
logging.error("[Episode] " + str(episode) + ": reward " +
str(episode_reward) + " no of achieved goals: " +
str(no_of_achieved_goals))
agent.update(replay_buffer, BATCH_SIZE)
# end = time.time()
# print("update model secs: ", end - start)
# start = end
logging.error("[Epoch] " + str(cycle) + ": total reward " +
str(epoch_reward))
agent.save_model()
agent.epsilon *= 0.96
if agent.epsilon < 0.1:
agent.epsilon = 0.1
"Window 672 x 512"
windowSurface = pygame.display.set_mode((WIDTH,HEIGHT))
x = WIDTH / 2
y = HEIGHT / 2
transitioning = False
title = TitleScreen(windowSurface)
title.start() # Starts the title screen, which just returns with no value to
# start the game
# new_position = (x,y)
player = Player((560,230), windowSurface)
playerGroup = pygame.sprite.RenderPlain(player)
HUB = HUB()
transition = Transition(windowSurface)
my_font = pygame.font.SysFont('Verdana', 15)
dialogbox = DialogBox((440, 51), (255, 255, 204),
(102, 0, 0), my_font)
level_maker = Levels()
"""
Level maker is used below to generate all the array of sprites of enemies, rocks,
doors, and dialog
"""
rocks_by_level = level_maker.createLevels_Rock()
doors_by_level = level_maker.createLevels_Door()
enemies_by_level = level_maker.createLevels_enemies(windowSurface)
enemies_by_level.append(pygame.sprite.RenderPlain(Wizderp(windowSurface)))
done = False
ep_rewards = []
while not done:
action = agent.get_action(state, train=(not args.vis))
new_state, reward, done, _ = env.step(action)
if args.vis:
env.render()
ep_rewards.append(reward)
if not args.vis:
agent.update_mem(
Transition(state, action, new_state, reward, done))
agent.train()
state = new_state
sum_rewards.append(np.sum(ep_rewards))
if ep % config_obj['lr_decay_interval'] == 0:
lr *= config_obj['lr_decay_rate']
agent.optimizer = torch.optim.Adam(agent.model.parameters(), lr=lr)
if ep % chkpt_every == 0 and not args.vis:
# save model checkpoint and log training progress
# evaluate model performance (no random actions)
def test_nothing_transition():
t = Transition([], [])
state = State([6])
s2 = t.fire(state)
assert s2.tokens == [6]
def main():
TimerUtility.start_timer('total_time')
valid_modes = ["predict", "restart", "test", "calibrate"]
Globals.mype = 0
Globals.npes = 1
packing = False
restart_run = 0
# Parse command line
if len(sys.argv) != 3:
__print_usage(sys.argv[0])
sys.exit(1)
if len(sys.argv) != 3 or sys.argv[1] not in valid_modes:
__print_usage(sys.argv[0])
sys.exit(1)
Processing.set_processing_type(Globals.mode_enum[sys.argv[1]])
if Processing.get_processing_type() == Globals.mode_enum['restart']:
Processing.set_restart_flag(True)
Scenario.init(sys.argv[2], Processing.get_restart_flag())
try:
log_it = Scenario.get_scen_value("logging")
random_seed = Scenario.get_scen_value("random_seed")
Random.set_seed(random_seed)
landuse_class_info = Scenario.get_scen_value("landuse_class_info")
LandClass.num_landclasses = len(landuse_class_info)
# filling in the class array in Land_Class
for i, landuse_class in enumerate(landuse_class_info):
# num, class_id, name, idx, hexColor
landuse_class_meta = LanduseMeta(landuse_class.grayscale,
landuse_class.type,
landuse_class.name, i,
landuse_class.color[2:])
LandClass.landuse_classes.append(landuse_class_meta)
# Set up Coefficients
if sys.argv[1] == 'restart':
if log_it:
print("Implement log here")
diffusion, breed, spread, slope_resistance, road_gravity, random_seed, restart_run = \
Input.read_restart_file(Scenario.get_scen_value("output_dir"))
Processing.set_current_run(restart_run)
else:
Processing.set_current_run(0)
Coeff.set_start_coeff(
Scenario.get_scen_value("calibration_diffusion_start"),
Scenario.get_scen_value("calibration_spread_start"),
Scenario.get_scen_value("calibration_breed_start"),
Scenario.get_scen_value("calibration_slope_start"),
Scenario.get_scen_value("calibration_road_start"))
Coeff.set_stop_coeff(
Scenario.get_scen_value("calibration_diffusion_stop"),
Scenario.get_scen_value("calibration_spread_stop"),
Scenario.get_scen_value("calibration_breed_stop"),
Scenario.get_scen_value("calibration_slope_stop"),
Scenario.get_scen_value("calibration_road_stop"))
Coeff.set_step_coeff(
Scenario.get_scen_value("calibration_diffusion_step"),
Scenario.get_scen_value("calibration_spread_step"),
Scenario.get_scen_value("calibration_breed_step"),
Scenario.get_scen_value("calibration_slope_step"),
Scenario.get_scen_value("calibration_road_step"))
Coeff.set_best_fit_coeff(
Scenario.get_scen_value("prediction_diffusion_best_fit"),
Scenario.get_scen_value("prediction_spread_best_fit"),
Scenario.get_scen_value("prediction_breed_best_fit"),
Scenario.get_scen_value("prediction_slope_best_fit"),
Scenario.get_scen_value("prediction_road_best_fit"))
# Initial IGrid
IGrid.init(packing, Processing.get_processing_type())
'''
Skipped memory and logging stuff for now, don't know if I'll need it
If there is a problem, I can go back and implement
'''
# Initialize Landuse
if len(Scenario.get_scen_value("landuse_data_file")) > 0:
LandClass.init()
if Scenario.get_scen_value("log_landclass_summary"):
if log_it:
# this is where we would log
Logger.log("Test log")
# Initialize Colortables
Color.init(IGrid.ncols)
# Read and validate input
IGrid.read_input_files(packing,
Scenario.get_scen_value("echo_image_files"),
Scenario.get_scen_value("output_dir"))
IGrid.validate_grids(log_it)
# Normalize Roads
IGrid.normalize_roads()
landuse_flag = len(Scenario.get_scen_value("landuse_data_file")) != 0
IGrid.verify_inputs(log_it, landuse_flag)
# Initialize PGRID Grids
PGrid.init(IGrid.get_total_pixels())
if log_it and Scenario.get_scen_value("log_colortables"):
Color.log_colors()
# Count the Number of Runs
Processing.set_total_runs()
Processing.set_last_monte(
int(Scenario.get_scen_value("monte_carlo_iterations")) - 1)
if log_it:
if Processing.get_processing_type(
) == Globals.mode_enum["calibrate"]:
Logger.log(
f"Total Number of Runs = {Processing.get_total_runs()}")
# Compute Transition Matrix
if len(Scenario.get_scen_value("landuse_data_file")) > 0:
Transition.create_matrix()
if log_it and Scenario.get_scen_value("log_transition_matrix"):
Transition.log_transition()
# Compute the Base Statistics against which the calibration will take place
Stats.set_base_stats()
if log_it and Scenario.get_scen_value("log_base_statistics"):
Stats.log_base_stats()
if log_it and Scenario.get_scen_value("log_debug"):
IGrid.debug("main.py")
Processing.set_num_runs_exec_this_cpu(0)
if Processing.get_current_run() == 0 and Globals.mype == 0:
output_dir = Scenario.get_scen_value("output_dir")
if Processing.get_processing_type(
) != Globals.mode_enum["predict"]:
filename = f"{output_dir}control_stats.log"
Stats.create_control_file(filename)
if Scenario.get_scen_value("write_std_dev_file"):
filename = f"{output_dir}std_dev.log"
Stats.create_stats_val_file(filename)
if Scenario.get_scen_value("write_avg_file"):
filename = f"{output_dir}avg.log"
Stats.create_stats_val_file(filename)
if Scenario.get_scen_value("write_coeff_file"):
output_dir = Scenario.get_scen_value("output_dir")
filename = f"{output_dir}coeff.log"
Coeff.create_coeff_file(filename, True)
if Processing.get_processing_type() == Globals.mode_enum["predict"]:
# Prediction Runs
Processing.set_stop_year(
Scenario.get_scen_value("prediction_stop_date"))
Coeff.set_current_coeff(Coeff.get_best_diffusion(),
Coeff.get_best_spread(),
Coeff.get_best_breed(),
Coeff.get_best_slope_resistance(),
Coeff.get_best_road_gravity())
if Globals.mype == 0:
Driver.driver()
Processing.increment_num_runs_exec_this_cpu()
# Timing stuff
if log_it and int(Scenario.get_scen_value('log_timings')) > 1:
TimerUtility.log_timers()
else:
# Calibration and Test Runs
Processing.set_stop_year(
IGrid.igrid.get_urban_year(IGrid.igrid.get_num_urban() - 1))
output_dir = Scenario.get_scen_value('output_dir')
d_start, d_step, d_stop = Coeff.get_start_step_stop_diffusion()
for diffusion_coeff in range(d_start, d_stop + 1, d_step):
b_start, b_step, b_stop = Coeff.get_start_step_stop_breed()
for breed_coeff in range(b_start, b_stop + 1, b_step):
s_start, s_step, s_stop = Coeff.get_start_step_stop_spread(
)
for spread_coeff in range(s_start, s_stop + 1, s_step):
sr_start, sr_step, sr_stop = Coeff.get_start_step_stop_slope_resistance(
)
for slope_resist_coeff in range(
sr_start, sr_stop + 1, sr_step):
rg_start, rg_step, rg_stop = Coeff.get_start_step_stop_road_gravity(
)
for road_grav_coeff in range(
rg_start, rg_stop + 1, rg_step):
filename = f"{output_dir}{UGMDefines.RESTART_FILE}{Globals.mype}"
Output.write_restart_data(
filename, diffusion_coeff, breed_coeff,
spread_coeff, slope_resist_coeff,
road_grav_coeff,
Scenario.get_scen_value('random_seed'),
restart_run)
restart_run += 1
Coeff.set_current_coeff(
diffusion_coeff, spread_coeff, breed_coeff,
slope_resist_coeff, road_grav_coeff)
Driver.driver()
Processing.increment_num_runs_exec_this_cpu()
# Timing Logs
if log_it and int(
Scenario.get_scen_value(
'log_timings')) > 1:
TimerUtility.log_timers()
Processing.increment_current_run()
if Processing.get_processing_type(
) == Globals.mode_enum['test']:
TimerUtility.stop_timer('total_time')
if log_it and int(
Scenario.get_scen_value(
'log_timings')) > 0:
TimerUtility.log_timers()
Logger.close()
sys.exit(0)
# Stop timer
TimerUtility.stop_timer('total_time')
if log_it and int(Scenario.get_scen_value('log_timings')) > 0:
TimerUtility.log_timers()
# Close Logger
Logger.close()
except KeyError as err:
traceback.print_exc()
print("{0} is not set. Please set it in your scenario file".format(
str(err).upper()))
Logger.log("Something went wrong")
Logger.close()
sys.exit(1)
except FileNotFoundError as err:
traceback.print_exc()
print(err)
Logger.log("Something went wrong")
Logger.close()
sys.exit(1)
except Exception:
traceback.print_exc()
Logger.log("Something went wrong")
Logger.close()
sys.exit(1)
def test_loop():
t = Transition([0], [0])
state = State([6])
s2 = t.fire(state)
assert s2.tokens == [6]
def decisionIsIncorrect(state: State, hole):
if state.stones[state.turn - 1][hole - 1] == 0:
return True
if hole <= 0 or hole > numberOfHoles:
return True
return False
if __name__ == '__main__':
currentState = getInitialState()
while currentState.isFinal() == False:
displayState(currentState)
if currentState.turn == turnHuman:
decision = int(input('Enter your decision: '))
else:
decision = getBestAIDecision(currentState)
print(f'AI took decision {decision}')
if decisionIsIncorrect(currentState, decision):
print('Decision is incorrect, hole is empty!')
continue
transition = Transition(decision)
currentState = makeTransition(currentState, transition)
print('')
print('Final state:')
displayState(currentState)
scores = getFinalScores(currentState)
print(f'Game over. Scores: {scores}')
def main1():
print(
"\nTuring machine recognizes whether or not the number of 0s is a power of 2."
)
st = '0000000000000000000000'
tape1 = Tape(st, '0x')
print("\nInput string:")
print(st)
states = [
State('q1', StateType.Start),
State('q2', StateType.Empty),
State('q3', StateType.Empty),
State('q4', StateType.Empty),
State('q5', StateType.Empty),
State('qa', StateType.Accept),
State('qr', StateType.Reject)
]
transitions = [
Transition('q1', '$', 'q1', '$', Direction.Right),
Transition('q1', '0', 'q2', '#', Direction.Right),
Transition('q1', '#', 'qr', '#', Direction.Right),
Transition('q1', 'x', 'qr', 'x', Direction.Right),
Transition('q2', 'x', 'q2', 'x', Direction.Right),
Transition('q2', '#', 'qa', '#', Direction.Right),
Transition('q2', '0', 'q3', 'x', Direction.Right),
Transition('q3', 'x', 'q3', 'x', Direction.Right),
Transition('q3', '#', 'q5', '#', Direction.Left),
Transition('q3', '0', 'q4', '0', Direction.Right),
Transition('q4', '0', 'q3', 'x', Direction.Right),
Transition('q4', 'x', 'q4', 'x', Direction.Right),
Transition('q4', '#', 'qr', '#', Direction.Right),
Transition('q5', '#', 'q2', '#', Direction.Right),
Transition('q5', '0', 'q5', '0', Direction.Left),
Transition('q5', 'x', 'q5', 'x', Direction.Left)
]
tm = TuringMachine(states, transitions, tape1)
tm.process1()
if (tm.current_state.type == StateType.Accept):
print('\nAccepting')
if (tm.current_state.type == StateType.Reject):
print('\nRejecting')
pass
from emission import Gaussian
from duration import Poisson
from transition import Transition
from initial import Initial
from edhmm import EDHMM
import pylab as pb
import numpy as np
import logging
import sys
logging.basicConfig(filename="experiment_4.log",
filemode="w",
level=logging.DEBUG)
A = Transition(K=3, A=pb.array([[0, 0.3, 0.7], [0.6, 0, 0.4], [0.3, 0.7, 0]]))
O = Gaussian(nu=1,
Lambda=np.array([1]),
mu_0=[0, 0, 0],
kappa=0.01,
mu=[-3, 0, 3],
tau=[np.array([[1]]),
np.array([[1]]),
np.array([[1]])])
D = Poisson(mu=[5, 15, 20],
alpha=[1, 1, 1],
beta=[0.0001, 0.0001, 0.0001],
support_step=20)
pi = Initial(K=3, beta=0.001)
m = EDHMM(A, O, D, pi)
dev_result_name = '../data/dev_result.ec' sentences = getTree(dev_file_name) word_vec = get_word_vec() pos_vec, label_index = get_pos_label_vec() f_result = codecs.open(dev_result_name, 'w', 'utf-8') for i in range(0, len(sentences)): sentence = sentences[i] words = sentence['words'] poses = sentence['poses'] indexs = sentence['indexs'] arc_labels = sentence['arc_labels'] for i in range(len(indexs)): indexs[i] = -2 arc_labels[i] = 'None\n' trans = Transition(sentence) while not trans.finish(): arc_index = 0 # everytime we should find an arc index # get test_vec input_array = [] if len(trans.stack) == 0: trans.shift() continue ''' if len(trans.stack) == 0: wrd_v = word_vec['unk'] pos_v = pos_vec['unk'] together = np.hstack((wrd_v, pos_v)) input_array = np.hstack((input_array, together)) wrd_v = word_vec['unk'] pos_v = pos_vec['unk']
def add_transition(re, states):
char = re.get_current_token()
return_states = []
if char == "\\":
re.index += 1
char = re.get_current_token()
for current in states:
state = State("inner", None, current)
transition = Transition(char, state)
current.add_transition(transition)
return_states.append(state)
elif char == "[":
set_of_chars = []
re.index += 1
current_char = re.get_current_token()
m = True
if current_char == "^":
m = False
re.index += 1
current_char = re.get_current_token()
while current_char != "]":
set_of_chars.append(current_char)
re.index += 1
current_char = re.get_current_token()
for current in states:
state = State("inner", None, current)
for new_char in set_of_chars:
transition = Transition(new_char, state, m)
current.add_transition(transition)
return_states.append(state)
elif char == ".":
for current in states:
state = State("inner", None, current)
transition = Transition("any", state)
current.add_transition(transition)
return_states.append(state)
elif char == "*":
for current in states:
last_state = current.last_state
if last_state is None:
raise SyntaxError("Invalid Token " + char)
last_state_transitions = last_state.transitions
last_state.transitions = []
zero_transition = Transition(None, current)
last_state.add_transition(zero_transition)
for transition in last_state_transitions:
if transition.char is not None:
char_to_match = transition.char
same_transition = Transition(char_to_match, last_state)
last_state.add_transition(same_transition)
return_states.append(current)
elif char == "+":
for current in states:
last_state = current.last_state
if last_state is None:
raise SyntaxError("Invalid Token " + char)
new_transitions = []
for transition in last_state.transitions:
char_to_match = transition.char
same_transition = Transition(char_to_match, last_state)
new_transitions.append(same_transition)
last_state.add_multiple_transitions(new_transitions)
return_states.append(current)
elif char == "?":
for current in states:
last_state = current.last_state
skip_char_transition = Transition(None, current)
last_state.add_transition(skip_char_transition)
return_states.append(current)
elif char == "!":
re.index += 1
char = re.get_current_token()
for current in states:
state = State("inner", None, current)
transition = Transition(char, state, False)
current.add_transition(transition)
return_states.append(state)
else:
for current in states:
state = State("inner", None, current)
transition = Transition(char, state)
current.add_transition(transition)
return_states.append(state)
re.index += 1
return return_states
logger.setLevel(logging.INFO)
env = gym.make(pms.gameName)
# You provide the directory to write to (can be an existing
# directory, including one with existing data -- all monitor files
# will be namespaced). You can also dump to a tempdir if you'd
# like: tempfile.mkdtemp().
outdir = '/tmp/DQN-' + pms.gameName
env.monitor.start(outdir, force=True, seed=0)
# This declaration must go *after* the monitor call, since the
# monitor's seeding creates a new action_space instance with the
# appropriate pseudorandom number generator.
agent = dqn.DqnAgent(env.action_space)
tran = Tran(max_size=pms.bufferSize)
caffe.set_mode_gpu()
imageDim = np.array((pms.frameHeight,
pms.frameWidth))
curFrame = np.zeros((pms.frameChannel,
pms.frameHeight,
pms.frameWidth))
nextFrame = np.zeros((pms.frameChannel,
pms.frameHeight,
pms.frameWidth))
testStep = 0
update_step = 0
for i in range(pms.episodeCount):
def test_str(self, s1, s2, inp, out, cnt, expected_str):
t = Transition(s1, s2, inp, out, counter=cnt)
assert str(t) == expected_str
