def loadMapTest(self, map_name, pc_coords, pc_sprite):
print("* Loading map test...")
self.unloadMap()
self.world = World(self)
#self.world = World(self, "Ashgrove")
#campaign.init(self.world)
self.world.current_map_name = map_name
if not pc_sprite.endswith(".xml"):
print("Incorrect sprite file name", pc_sprite)
return
pc_sprite_name = pc_sprite.split("\\")[-1][:-4]
print(pc_sprite, pc_sprite_name)
pc = self.world.addCharacterAt(pc_coords, map_name, "test_character",
"test character", str(pc_sprite_name))
self.world.enablePlayerCharacter(pc)
self.loadObject("objects\\Sprites - Characters\\" + str(pc_sprite))
self.loadMap(self.world.current_map_name)
self.world.visual = WorldVisual(self, self.maplayer, self.world)
self.view = View(self)
#self.view.camera.getLocationRef().setLayerCoordinates(
# fife.ModelCoordinate(40, 0, 0))
self.gui.showHUD()
self.unpause(True)
self.change_map_name = None
self.exploration = Exploration(self)
print("* Map loaded!")
def loadGame(self, save_name):
self.loadMap(self.world.current_map_name)
self.world.application = self
self.world.visual = WorldVisual(self, self.maplayer, self.world)
self.view = View(self)
self.gui.showHUD()
self.unpause(True)
self.change_map_name = None
self.exploration = Exploration(self)
print("* Game loaded!")
def newGame(self):
self.loadMap(self.world.current_map_name)
self.world.visual = WorldVisual(self, self.maplayer, self.world)
self.view = View(self)
camera_loc = self.view.camera.getLocation()
camera_loc.setLayerCoordinates(self.world.camera_coords)
self.view.camera.setLocation(camera_loc)
self.gui.showHUD()
self.unpause(True)
self.change_map_name = None
self.exploration = Exploration(self)
print("* Game started!")
def main():
entrypoint = 0x401094
fuzzed_address = set()
queue = multiprocessing.Queue()
process = list()
ctx = TritonContext()
ctx.setArchitecture(ARCH.X86_64)
ctx.enableMode(MODE.ALIGNED_MEMORY, True)
ctx.setAstRepresentationMode(AST_REPRESENTATION.PYTHON)
exploration = Exploration()
tracer = Tracer(program_name, True)
tracer.tracer_init(ctx)
# Sets callbacks
tracer.add_start_callback(exploration.start)
tracer.add_instruction_callback(exploration.get_instruction)
tracer.add_end_callback(exploration.end)
tracer.add_memory_callback(exploration.symbolized_memory_input)
tracer.add_register_callback(exploration.symbolized_register_input)
for i in range(30):
tracer.start(ctx, 1, entrypoint)
if exploration.fuzz_is_needed is True:
untaken_branch = set(exploration.get_untaken_branch())
for i in untaken_branch:
if i not in fuzzed_address:
if exploration.untaken_branch[i] != 0:
process.append(
send_to_fuzz(
entrypoint,
copy.deepcopy(exploration.exploration_memory),
copy.deepcopy(
exploration.exploration_registers),
copy.copy(exploration.untaken_branch[i]), i,
queue))
process[-1].start()
process[-1].join()
fuzzed_address.add(i)
try:
new_inputs = queue.get(block=True, timeout=5)
exploration.add_fuzz_inputs(new_inputs[0], new_inputs[1])
except Queue.Empty:
print(map(hex, exploration.get_untaken_branch()))
print("Can't find more branch")
break
exploration.show_exploration()
def get_services():
try:
self.memory = self.session.service('ALMemory')
self.motion_service=self.session.service("ALMotion")
self.decos_navigation_files_service=self.session.service("DecosNavigationFiles")
self.navigation_service=self.session.service("ALNavigation")
self.exploration = Exploration(self.navigation_service,self.motion_service,self.decos_navigation_files_service)
self.logger.info('All services are now connected')
self.services_connected.setValue(True)
except RuntimeError as e:
self.logger.warning('Still missing some service:\n {}'.format(e))
def __init__(self) -> None:
self.network = NetWork().to(device)
print("Number of parameters in network:",
count_parameters(self.network))
self.criterion = MSELoss()
self.optimizer = Adam(self.network.parameters(),
lr=0.001,
weight_decay=0.001)
self.memory = ReplayBuffer(100000)
self.remember = self.memory.remember()
self.exploration = Exploration()
self.explore = self.exploration.epsilonGreedy
self.target_network = NetWork().to(device)
self.placeholder_network = NetWork().to(device)
def changeMap(self, map_name):
self.real_timeline.clear()
self.world.visual.cleanUp()
self.world.visual = None
self.world.current_map_name = map_name
if self.map:
self.model.deleteMap(self.map)
if self.imagemanager.getMemoryUsed() > 700000000:
self.imagemanager.freeUnreferenced()
print("Memory used by the image manager:",
"{:,}".format(self.imagemanager.getMemoryUsed()))
self.loadMap(self.world.current_map_name)
self.world.visual = WorldVisual(self, self.maplayer, self.world)
self.view = View(self)
self.gui.showHUD()
self.unpause(True)
self.exploration = Exploration(self)
def __init__(self,
game: Game,
network: Networks,
learner: Learners,
exploration: Explorations,
gamma: float = None,
K: float = None,
width: int = None,
height: int = None,
batch: int = None,
_extra_dim: int = 0,
**kwargs) -> None:
self.extradim = _extra_dim
self.batch = batch
self.height = height
self.width = width
self.net = Net(
len(game.layers) + _extra_dim, width, height, network, **kwargs)
self.learner = Learner(self.net, learner, gamma, **kwargs)
self.exploration = Exploration(exploration, K, **kwargs)
def dfExplore(df):
explore = Exploration(df)
explore.scatter()
explore.classGraph()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
""" Set GUI to track mouse """
QWidget.setMouseTracking(self, True)
"""
Dynamixel bus
TODO: add other motors here as needed with their correct address"""
# self.dxlbus = DXL_BUS(DEVICENAME, BAUDRATE)
# port_num = self.dxlbus.port()
# base = DXL_XL(port_num, 1)
# shld = DXL_XL(port_num, 2)
# elbw = DXL_XL(port_num, 3)
# wrst = DXL_XL(port_num, 4)
# grip = DXL_XL(port_num, 5)
"""Objects Using Other Classes"""
self.camera = PiCamera()
# self.rexarm = Rexarm((base, shld, elbw, wrst, grip))
# self.tp = TrajectoryPlanner(self.rexarm)
self.sm = StateMachine(self.rexarm, self.tp)
global explore_obj
explore_obj = Exploration(self.sm)
self.taskThread = TaskThread(self.sm)
self.rgb_image = None
"""
Attach Functions to Buttons & Sliders
TODO: NAME AND CONNECT BUTTONS AS NEEDED
"""
self.ui.btn_estop.clicked.connect(self.estop)
self.ui.btnUser1.setText("Calibrate")
self.ui.btnUser1.clicked.connect(
partial(self.sm.set_current_state, "calibrate"))
self.ui.btnUser2.setText("Moving Arm")
self.ui.btnUser2.clicked.connect(
partial(self.sm.set_current_state, "moving_arm"))
self.ui.btnUser3.setText("Return Home")
self.ui.btnUser3.clicked.connect(
partial(self.sm.set_current_state, "arm_return_home"))
self.ui.btnUser4.setText("Exploration")
self.ui.btnUser4.clicked.connect(
partial(self.sm.set_current_state, "exploration"))
self.ui.btnUser5.setText("Swipe")
self.ui.btnUser5.clicked.connect(
partial(self.sm.set_current_state, "swipe"))
self.ui.btnUser6.setText("Put back block")
self.ui.btnUser6.clicked.connect(
partial(self.sm.set_current_state, "put_back_block"))
self.ui.btnUser7.setText("Moving back")
self.ui.btnUser7.clicked.connect(
partial(self.sm.set_current_state, "moving_back"))
self.ui.btnUser8.setText("Reach block")
self.ui.btnUser8.clicked.connect(
partial(self.sm.set_current_state, "reach_block"))
self.ui.btnUser9.setText("Moving to side")
self.ui.btnUser9.clicked.connect(
partial(self.sm.set_current_state, "moving_to_block_side"))
# self.ui.btn_task1.clicked.connect(
# partial(self.taskThread.set_task_num, 1))
self.ui.btn_task1.clicked.connect(partial(self.taskThread.run))
# Button for exploration code to run
# self.ui.explore_btn.clicked.connect(self.taskThread.start)
self.ui.sldrBase.valueChanged.connect(self.sliderChange)
self.ui.sldrShoulder.valueChanged.connect(self.sliderChange)
self.ui.sldrElbow.valueChanged.connect(self.sliderChange)
self.ui.sldrWrist.valueChanged.connect(self.sliderChange)
self.ui.sldrWrist2.valueChanged.connect(self.sliderChange)
self.ui.sldrGrip1.valueChanged.connect(self.sliderChange)
self.ui.sldrMaxTorque.valueChanged.connect(self.sliderChange)
self.ui.sldrSpeed.valueChanged.connect(self.sliderChange)
self.ui.chk_directcontrol.stateChanged.connect(self.directControlChk)
self.ui.rdoutStatus.setText("Waiting for input")
"""initalize manual control off"""
self.ui.SliderFrame.setEnabled(False)
"""initalize rexarm"""
self.rexarm.initialize()
"""Setup Threads"""
self.videoThread = VideoThread(self.camera)
self.videoThread.updateFrame.connect(self.setImage)
self.videoThread.updateAprilTags.connect(self.updateAprilTags)
self.videoThread.start()
self.logicThread = LogicThread(self.sm)
self.logicThread.start()
# Moving line to button to start
# self.taskThread.start()
self.displayThread = DisplayThread(self.rexarm, self.sm)
self.displayThread.updateJointReadout.connect(self.updateJointReadout)
self.displayThread.updateEndEffectorReadout.connect(
self.updateEndEffectorReadout)
self.displayThread.updateStatusMessage.connect(
self.updateStatusMessage)
self.displayThread.start()
"""
Setup Timer
this runs the trackMouse function every 50ms
"""
self._timer = QTimer(self)
self._timer.timeout.connect(self.trackMouse)
self._timer.start(50)
#print(probleme.nombre_piece_mal_placees(etat_initial))
# Dijkstra
#fonction_score = lambda noeud: noeud.g
fonction_score = lambda noeud: noeud.g
#Greedy
#A*
###############################################
# Exploration (générique)
###############################################
#exploration = Exploration(probleme=probleme, critere=fonction_score)
exploration = Exploration(probleme=probleme, critere=fonction_score)
temps_debut = time.process_time()
chemin = exploration.explorer()
temps_fin = time.process_time()
###############################################
# Résultat
###############################################
print("=====================================================")
etapes = -1
X_rech = []
Y_rech = []
print("État initial :\t" + str(probleme.etat_initial))
if len(chemin) > 0:
last = None
def __init__(self,
exploration='epsilonGreedy',
memory=10000,
discount=0.99,
uncertainty=True,
uncertainty_weight=1,
update_every=200,
double=True,
use_distribution=True,
reward_normalization=False,
encoder=None,
hidden_size=40,
state_difference=True,
state_difference_weight=1,
**kwargs) -> None:
self.uncertainty = uncertainty
self.hidden_size = hidden_size
self.network = NetWork(self.hidden_size).to(device)
self.createEncoder(encoder)
self.network.hasEncoder = self.hasEncoder
print("Number of parameters in network:",
count_parameters(self.network))
self.criterion = MSELoss()
self.memory = ReplayBuffer(int(memory))
self.remember = self.memory.remember()
self.exploration = Exploration()
if exploration == 'greedy':
self.explore = self.exploration.greedy
elif exploration == 'epsilonGreedy':
self.explore = self.exploration.epsilonGreedy
elif exploration == 'softmax':
self.explore = self.exploration.softmax
elif exploration == 'epsintosoftmax':
self.explore = self.exploration.epsintosoftmax
self.target_network = NetWork(self.hidden_size).to(device)
self.target_network.hasEncoder = self.hasEncoder
self.placeholder_network = NetWork(self.hidden_size).to(device)
self.placeholder_network.hasEncoder = self.hasEncoder
self.gamma, self.f = discount, 0
self.update_every, self.double, self.use_distribution = update_every, double, use_distribution
self.counter = 0
self.reward_normalization = reward_normalization
self.state_difference = state_difference
self.true_state_trace = None
self.uncertainty_weight = uncertainty_weight
self.state_difference_weight = state_difference_weight
if encoder is not None:
self.optimizer_value = Adam(
list(self.network.fromEncoder.parameters()) +
list(self.network.lstm.parameters()) +
list(self.network.linear.parameters()),
lr=1e-4,
weight_decay=1e-5)
else:
self.optimizer_value = Adam(list(self.network.color.parameters()) +
list(self.network.conv1.parameters()) +
list(self.network.lstm.parameters()) +
list(self.network.linear.parameters()),
lr=1e-4,
weight_decay=1e-5)
if self.uncertainty:
self.optimizer_exploration = Adam(list(
self.network.exploration_network.parameters()),
lr=1e-4,
weight_decay=1e-5)
if self.state_difference:
self.optimizer_state_avoidance = Adam(list(
self.network.state_difference_network.parameters()),
lr=1e-4,
weight_decay=1e-5)
self.onpolicy = True
