def __init__(self, knowledge_base):
# this knowledge base reference is used for updating the robot state
self.knowledge_base = knowledge_base
# create the viewer
self.viewer = Viewer()
BaseJob.__init__(self, None, None)
class ControlJob(BaseJob):
def __init__(self, knowledge_base):
# this knowledge base reference is used for updating the robot state
self.knowledge_base = knowledge_base
# create the viewer
self.viewer = Viewer()
BaseJob.__init__(self, None, None)
def _get_interface(self):
return ControlInterface
def _handler(self):
logger.debug('child {} start'.format(self.child.pid))
# hold a reference to the world so that it is not garbage collected
self.world = WorldModel()
# create the robot model for the controller
self.robot = self.world.loadRobot(os.path.join('klampt_models', baxter.klampt_model_name))
logger.debug('robot model loaded from {}'.format(baxter.klampt_model_name))
self.controller = LowLevelController(self.robot, baxter.klampt_model_name)
logger.debug('controller low-level controller initialized')
# send the initial controller state
self.child_pipe.send((None, RobotState(self.controller)))
while True:
# get the call information
try:
# update the viewer while waiting for a command
while not self.child_pipe.poll():
self._update_viewer()
sleep(interval)
# receive the command
(self.knowledge_base, self.method, self.args, self.kwargs) = self.child_pipe.recv()
except EOFError:
logger.info('child {} shutdown requested'.format(self.child.pid))
# signal to shut down
break
# distinguish between pure knowledge base updates and method calls
if not self.method:
self._update_viewer()
self._send_result(None)
continue
# route remote calls
self.init_args = (self.controller, self.knowledge_base)
# hook the sleep method to update the viewer during execution
self.kwargs['sleep'] = lambda n: self._sleep(n)
BaseJob._handler(self)
# clean up
# need to call the superclass since this class overrides with empty method
BaseJob._close()
# TODO: shutdown the controller
#controller.motion.shutdown()
self.viewer.close()
def _sleep(self, n):
while n > 0:
self._update_viewer()
n -= interval
sleep(interval)
def _update_viewer(self):
try:
# check to see if the viewer is alive
if self.viewer.heartbeat:
# update the viewer
logger.info('updating viewer')
self.viewer.update(self.knowledge_base, RobotState(self.controller))
logger.info('done updating viewer')
else:
logger.info('viewer missed heartbeat')
pass
except Exception as e:
logger.error('failed to update the viewer: {}'.format(e))
def _send_result(self, result):
# attach the robot state to the job result
BaseJob._send_result(self, (result, RobotState(self.controller)))
def _check(self):
# run even if child is still alive
# check for a result before attempting a blocking call
if self.pipe.poll():
self._process_result()
self._done = True
# extract the robot state and update the knowledge base
if not self.error:
(self._result, self.knowledge_base.robot_state) = self.result
# check that the child is alive
# this is done after the poll since the child could have sent a result and then executed
if not self.alive:
logger.error('child {} died unexpectedly: {}'.format(self.child.pid, self.child.exitcode))
# set this exception as the error result
self._error = Exception('child died unexpectedly: {}'.format(self.child.exitcode))
self._done = True
def _close(self):
# keep the pipes open by default
pass
clip_max=clip_max)
images_adv, = batch_eval(model._sess, [model.nodes.input], [n_fgsm],
[adv_image_lists[0]],
args={'batch_size': batch_size},
feed={model._is_training: False})
adv_image_lists.append(images_adv)
def generate_visualization(i0):
def get_row(i):
ims = adv_image_lists[i][i0:i0 + image_count]
s, m = Cifar10Loader.std, Cifar10Loader.mean
scale = lambda x: np.clip(x * s + m, 0, 255).astype(np.ubyte)
return list(map(scale, ims))
cols = [get_row(i) for i in range(i0, i0 + len(epss))]
return visualization.compose(cols, format=None)
images = [im for i in range(i0, i0 + 3) for im in get_row(i)]
comp_format = "".join([
str(i) + "," if i % image_count == image_count - 1 else ";"
for i in range(len(images))
])[:-1]
return visualization.compose(images, format=comp_format)
scaled_eps = eps * np.max(Cifar10Loader.std)
viewer = Viewer("Adversarial examples, scaled eps=" + str(scaled_eps) +
", eps=" + str(eps))
viewer.display(np.arange(batch_size), generate_visualization)
