def test_step(self, word):
"""Test the behaviour of the method 'step'."""
simulator = AutomatonSimulator(self.dfa)
for symbol in word:
previous_states = simulator.cur_state
current_states = simulator.step(symbol)
expected_current_states = reduce(
set.union,
[self.dfa.get_successors(s, symbol) for s in previous_states],
set(),
)
assert simulator.cur_state == current_states == expected_current_states
def test_reset(self, word):
"""Test the behaviour of the method 'reset'."""
simulator = AutomatonSimulator(self.dfa)
assert not simulator.is_started
assert simulator.cur_state == {self.dfa.initial_state}
for symbol in word:
simulator.step(symbol)
assert simulator.is_started
initial_state = simulator.reset()
assert not simulator.is_started
assert simulator.cur_state == initial_state == {self.dfa.initial_state}
def test_initialization(self):
"""Test the initialization of a simulator."""
simulator = AutomatonSimulator(self.dfa)
assert simulator.automaton == self.dfa
assert simulator.cur_state == {self.dfa.initial_state}
assert not simulator.is_started
def test_accepts(self, word):
"""Test the behaviour of the method 'accepts'."""
simulator = AutomatonSimulator(self.dfa)
assert simulator.accepts(word) == self.dfa.accepts(word)
for index, symbol in enumerate(word):
simulator.step(symbol)
assert simulator.accepts(word[index:]) == self.dfa.accepts(word)
def test_is_failed(self):
"""Test the behaviour of the method 'is_failed'."""
simulator = AutomatonSimulator(self.dfa)
assert not simulator.is_failed()
simulator.step("a")
assert not simulator.is_failed()
simulator.step("b")
assert not simulator.is_failed()
simulator.step("c")
assert not simulator.is_failed()
simulator.step("d")
assert simulator.is_failed()
def test_is_true(self):
"""Test the behaviour of the method 'is_true'."""
simulator = AutomatonSimulator(self.dfa)
assert not simulator.is_true()
simulator.step({"a": True})
assert not simulator.is_true()
simulator.step({"b": True})
assert not simulator.is_true()
simulator.step({"c": True})
assert simulator.is_true()
def __init__(
self,
env_name,
fluents,
reward,
logdir,
load=None,
verbose=True,
):
"""Initialize.
:param env_name: a gym atari environment name.
:param fluents: the list of propositional atoms that are known at
each step.
:param reward: (float) this reward is returned when the execution
reaches a final state (at the first instant an execution satisfies
the restraining specification).
:param logdir: the automaton just parsed is saved here.
:param load: if provided, the automaton is not computed but loaded
from this file. A path to a rb.pickle file.
:param verbose: verbose flag (automaton conversion may take a while).
"""
# Read
data = selector.read_back(env_name)
json_rb = data["restraining_bolt"] + data["constraints"]
# Parsing
restraining_spec = " & ".join(json_rb)
formula = LDLfParser()(restraining_spec) # type: LDLfFormula
# Check: all atoms must be evaluated
atoms = formula.find_labels()
all_predicted = all((a in fluents for a in atoms))
if not all_predicted:
raise ValueError("One of the atoms " + str(atoms) +
" is not in fluents")
# Parse
if load is None:
# Conversion (slow op)
if verbose:
print("> Parsing", env_name, "restraining specification")
automaton = formula.to_automaton() # type: SymbolicAutomaton
automaton = automaton.determinize().complete()
if verbose:
print("> Parsed")
# Save and visualize the automaton
graphviz = automaton.to_graphviz()
graphviz.render("rb.gv",
directory=logdir,
view=False,
cleanup=False)
with open(os.path.join(logdir, "rb.pickle"), "wb") as f:
pickle.dump(automaton, f)
# Load
else:
with open(load, "rb") as f:
automaton = pickle.load(f)
if verbose:
print(">", load, "loaded")
# Visualize the automaton loaded (debugging)
graphviz = automaton.to_graphviz()
graphviz.render("loaded_rb.gv",
directory=logdir,
view=False,
cleanup=False)
# Runner
simulator = AutomatonSimulator(automaton)
# Store
self.env_name = env_name
self.fluents = fluents
self._str = restraining_spec
self._formula = formula
self._automaton = automaton
self._simulator = simulator
self._reward = reward
self._last_state = None