def act(self, state, action):
# decoding the numpy.float action to {key, value} action
action = state.environment[action]
new_masks = self.__new_pruned_mask(state, action)
# validate the model
self.model.set_new_masks(new_masks)
if not self.model.masks[0].weight.is_cuda:
self.model.masks = self.model.masks.to(self.device)
valid_loss, accuracy = validation(self.model, self.valid_loader,
self.criterion)
# compute the reward
reward = self.__compute_reward(state, valid_loss, accuracy)
for mask in self.model.masks:
mask = mask.to('cpu')
# self.model.masks[0] = self.model.masks[0].to('cpu')
# self.model.masks[1] = self.model.masks[1].to('cpu')
# self.model.masks[2] = self.model.masks[2].to('cpu')
# new subenvironment
new_env = deepcopy(state.environment)
new_env.remove(action)
new_state = State(new_masks, new_env, reward, state.n_prunes)
new_state.prune()
# Verify if the game has winned
if (new_state.remaining_weights <= self.remaining_weights):
self.is_done = True
reward += 1000
return new_state, reward, self.is_done
class TestState(unittest.TestCase):
def setUp(self):
self.file_location = tempfile.mkstemp()[1]
self.state = State(self.file_location)
self.mode = Mode(self.state)
def tearDown(self):
os.remove(self.file_location)
def test_get_set_mode(self):
self.mode.set_mode(MODE.NORMAL)
assert_that(self.mode.get_mode(), equal_to(MODE.NORMAL))
def test_get_default_mode(self):
assert_that(self.mode.get_mode(), equal_to(MODE.NORMAL))
@raises(AssertionError)
def test_set_invalid_type(self):
self.mode.set_mode("NORMAL")
@raises(ValueError)
def test_get_invalid_type(self):
# State.set_mode() will check the type of parameter. State.set() does
# not check parameter. The value could be corrupted. State.get_mode()
# will raise ValueError.
self.state.set(Mode.MODE_KEY, "123")
self.mode.get_mode()
@raises(ModeTransitionError)
def test_invalid_transition(self):
try:
self.mode.set_mode(MODE.MAINTENANCE, [MODE.ENTERING_MAINTENANCE])
except ModeTransitionError as e:
assert_that(e.from_mode, equal_to(MODE.NORMAL))
raise
def test_transition_to_self(self):
# Should allow to change mode from A to A (e.g. NORMAL to NORMAL)
assert_that(self.mode.get_mode(), equal_to(MODE.NORMAL))
self.mode.set_mode(MODE.NORMAL, [MODE.MAINTENANCE])
assert_that(self.mode.get_mode(), equal_to(MODE.NORMAL))
def test_callbacks(self):
enter_maintenance = MagicMock()
exit_normal = MagicMock()
change = MagicMock()
self.mode.on_enter_mode(MODE.MAINTENANCE, enter_maintenance)
self.mode.on_exit_mode(MODE.NORMAL, exit_normal)
self.mode.on_change(change)
self.mode.set_mode(MODE.ENTERING_MAINTENANCE)
assert_that(enter_maintenance.called, equal_to(False))
assert_that(exit_normal.called, equal_to(True))
assert_that(change.call_count, equal_to(1))
self.mode.set_mode(MODE.MAINTENANCE)
assert_that(enter_maintenance.called, equal_to(True))
assert_that(change.call_count, equal_to(2))
def loop(self):
"""
Main loop for training and testing, saving ...
"""
while self.epoch < self.args.epochs:
log('[Training] %s' % self.scheduler.report())
# Note that we test first, to also get the error of the untrained model.
testing = elapsed(functools.partial(self.test))
training = elapsed(functools.partial(self.train))
log('[Training] %gs training, %gs testing' % (training, testing))
if self.args.early_stopping:
validation = elapsed(functools.partial(self.validate))
log('[Training] %gs validation' % validation)
# Save model checkpoint after each epoch.
utils.remove(self.args.state_file + '.%d' % (self.epoch - 1))
State.checkpoint(self.model, self.scheduler.optimizer, self.epoch,
self.args.state_file + '.%d' % self.epoch)
log('[Training] %d: checkpoint' % self.epoch)
torch.cuda.empty_cache() # necessary?
# Save statistics and plots.
if self.args.training_file:
utils.write_hdf5(self.args.training_file,
self.train_statistics)
log('[Training] %d: wrote %s' %
(self.epoch, self.args.training_file))
if self.args.testing_file:
utils.write_hdf5(self.args.testing_file, self.test_statistics)
log('[Training] %d: wrote %s' %
(self.epoch, self.args.testing_file))
if utils.display():
self.plot()
self.epoch += 1 # !
# Final testing.
testing = elapsed(functools.partial(self.test))
log('[Training] %gs testing' % (testing))
# Save model checkpoint after each epoch.
utils.remove(self.args.state_file + '.%d' % (self.epoch - 1))
State.checkpoint(self.model, self.scheduler.optimizer, self.epoch,
self.args.state_file)
log('[Training] %d: checkpoint' % self.epoch)
self.results = {
'training_statistics': self.train_statistics,
'testing_statistics': self.test_statistics,
}
if self.args.results_file:
utils.write_pickle(self.args.results_file, self.results)
log('[Training] wrote %s' % self.args.results_file)
def setup(self):
self._threadpool = ThreadPoolExecutor(16)
self.state_file = tempfile.mktemp()
common.services.register(ThreadPoolExecutor, self._threadpool)
self._host_handler = MagicMock()
common.services.register(Host.Iface, self._host_handler)
common.services.register(ServiceName.MODE,
Mode(State(self.state_file)))
common.services.register(ServiceName.AGENT_CONFIG, MagicMock())
common.services.register(ServiceName.DATASTORE_TAGS,
DatastoreTags(State(self.state_file)))
def get_state():
""" Requests and returns the state from the atmega """
atmega.write("c\n")
# get the line, strip the newline char, split it
arr = atmega.readline().strip().split(" ")
if arr[0] != "s":
logger.error("Expected reply starting with 's' from control when asked"
" for state, got {}".format(arr[0]))
return State(*([0] * 6))
# exclude the first 's' char
arr = [float(i) for i in arr[1:]]
return State(*arr)
def compute_new_state(self, state, acceleration, delta_time):
"Compute the forward kinematics with finite difference method."
new_state = State(state.ndim)
# Velocity (m/s) at time_n+1
new_state.velocity = state.velocity + acceleration * delta_time
# Position (m) at time_n+1
new_state.position = state.position + state.velocity * delta_time
#new_state.position = state.position + new_state.velocity * delta_time
return new_state
def compute_new_state(self, state, acceleration, delta_time):
"Compute the forward kinematics with finite difference method."
new_state = State(state.ndim)
# Velocity (m/s) at time_n+1
new_state.velocity = state.velocity + acceleration * delta_time
# Position (m) at time_n+1
new_state.position = state.position + state.velocity * delta_time
#new_state.position = state.position + new_state.velocity * delta_time
return new_state
def setup(self):
self.state_file = tempfile.mktemp()
self._host_handler = MagicMock()
common.services.register(Host.Iface, self._host_handler)
common.services.register(ServiceName.MODE,
Mode(State(self.state_file)))
common.services.register(ServiceName.AGENT_CONFIG, MagicMock())
def load_models(self):
"""
Load models.
"""
self.N_class = numpy.max(self.test_codes) + 1
network_units = list(map(int, self.args.network_units.split(',')))
log('[Testing] using %d input channels' % self.test_images.shape[3])
self.model = models.Classifier(
self.N_class,
resolution=(self.test_images.shape[3], self.test_images.shape[1],
self.test_images.shape[2]),
architecture=self.args.network_architecture,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
start_channels=self.args.network_channels,
dropout=self.args.network_dropout,
units=network_units)
assert os.path.exists(
self.args.classifier_file
), 'state file %s not found' % self.args.classifier_file
state = State.load(self.args.classifier_file)
log('[Testing] read %s' % self.args.classifier_file)
self.model.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(self.model):
log('[Testing] classifier is not CUDA')
self.model = self.model.cuda()
log('[Testing] loaded classifier')
# !
self.model.eval()
log('[Testing] set classifier to eval')
def _register_services(self):
common.services.register(ServiceName.AGENT_CONFIG, self._config)
common.services.register(ServiceName.LOCKED_VMS, ExclusiveSet())
threadpool = RequestIdExecutor(
ThreadPoolExecutor(self._config.workers))
common.services.register(ThreadPoolExecutor, threadpool)
self._registrant = ChairmanRegistrant(self._config.chairman_list)
self._config.on_config_change(self._config.CHAIRMAN,
self._registrant.update_chairman_list)
common.services.register(ServiceName.REGISTRANT, self._registrant)
state_json_file = os.path.join(
self._config.options.config_path,
self._config.DEFAULT_STATE_FILE)
state = State(state_json_file)
mode = Mode(state)
mode.on_change(self._registrant.trigger_chairman_update)
common.services.register(ServiceName.MODE, mode)
ds_tags = DatastoreTags(state)
ds_tags.on_change(self._registrant.trigger_chairman_update)
common.services.register(ServiceName.DATASTORE_TAGS, ds_tags)
def __init__(self, id, networks, datastores, cpu, mem, disk, overcommit):
self.id = id
self.cpu = cpu
self.mem = mem
self.disk = disk
self.parent = ""
self.constraints = set()
host_constraint = ResourceConstraint(ResourceConstraintType.HOST,
["host-" + str(id)])
self.constraints.add(host_constraint)
[self.constraints.add(net) for net in networks]
[self.constraints.add(ds) for ds in datastores]
self.address = ""
self.port = ""
conf_dir = mkdtemp(delete=True)
state = State(os.path.join(conf_dir, "state.json"))
common.services.register(ServiceName.MODE, Mode(state))
self.hv = self._get_hypervisor_instance(
id, cpu, mem, disk, [ds.values[0] for ds in datastores],
[network.values[0] for network in networks], overcommit)
# need agent_config for create/delete vm.
agent_config = AgentConfig([
"--config-path", conf_dir, "--hostname", "localhost", "--port",
"1234", "--host-id", id
])
common.services.register(ServiceName.AGENT_CONFIG, agent_config)
super(Host, self).__init__(self.hv)
def setUp(self):
self.agent_conf_dir = mkdtemp(delete=True)
state = State(os.path.join(self.agent_conf_dir, "state.json"))
common.services.register(ServiceName.MODE, Mode(state))
common.services.register(ServiceName.DATASTORE_TAGS,
DatastoreTags(state))
self.agent = AgentConfig(["--config-path", self.agent_conf_dir])
def update_state(config, value, state, update_values):
if not state:
return State(update_values(value, []),
expired_time=config.property('expired_time'))
elif state.is_expired():
return None
else:
return state.update(value, update_values)
def choose_current_state():
Particles.probability[Particles.probability < .0001] = .0001
stack = np.stack((Particles.x, Particles.y, Particles.probability), 0)
np.save("data.csv", stack)
x = np.average(Particles.x, weights=Particles.probability)
y = np.average(Particles.y, weights=Particles.probability)
modeling.current_state = State(x, y, Particles.depth, Particles.yaw, 0, 0)
return
def setUp(self):
self.agent_conf_dir = mkdtemp(delete=True)
state = State(os.path.join(self.agent_conf_dir, "state.json"))
common.services.register(ServiceName.MODE, Mode(state))
common.services.register(ServiceName.DATASTORE_TAGS,
DatastoreTags(state))
self.multi_agent = MultiAgent(2200, AgentConfig.DEFAULT_CONFIG_PATH,
AgentConfig.DEFAULT_CONFIG_FILE)
self.agent = AgentConfig(["--config-path", self.agent_conf_dir])
def q_table_loader(path):
tsv = pd.read_csv(path, sep='\t')
q_table = dict()
for i in range(tsv.shape[0]):
string = tsv.iloc[i, 0]
st = State(string)
values = list(tsv.iloc[i, 1:])
q_table[st] = values
return q_table
def _register_services(self):
common.services.register(ServiceName.AGENT_CONFIG, self._config)
common.services.register(ServiceName.LOCKED_VMS, ExclusiveSet())
state_json_file = os.path.join(self._config.options.config_path,
self._config.DEFAULT_STATE_FILE)
state = State(state_json_file)
mode = Mode(state)
common.services.register(ServiceName.MODE, mode)
def __init__(self):
self.state = State()
self.cmd_queue = DeferredQueue()
self.x1_queue = DeferredQueue()
self.x1CliFac = X1ClientFactory(self.cmd_queue, self.x1_queue,
self.state)
self.x1tcp = None
self.x2CliFac = X2ServerFactory()
self._start_x2_server()
def validate(self):
"""
Validate for early stopping.
"""
self.model.eval()
log('[Training] %d set classifier to eval' % self.epoch)
assert self.model.training is False
loss = 0
error = 0
num_batches = int(
math.ceil(self.val_images.shape[0] / self.args.batch_size))
for b in range(num_batches):
perm = numpy.take(range(self.val_images.shape[0]),
range(b * self.args.batch_size,
(b + 1) * self.args.batch_size),
mode='clip')
batch_images = common.torch.as_variable(self.val_images[perm],
self.args.use_gpu)
batch_classes = common.torch.as_variable(self.val_codes[perm],
self.args.use_gpu)
batch_images = batch_images.permute(0, 3, 1, 2)
output_classes = self.model(batch_images)
e = self.loss(batch_classes, output_classes)
loss += e.item()
e = self.error(batch_classes, output_classes)
error += e.item()
loss /= num_batches
error /= num_batches
log('[Training] %d: val %g (%g)' % (self.epoch, loss, error))
if self.val_error is None or error < self.val_error:
self.val_error = error
State.checkpoint(self.model, self.scheduler.optimizer, self.epoch,
self.args.state_file + '.es')
log('[Training] %d: early stopping checkoint' % self.epoch)
def setUp(self):
self.tr = proto_helpers.StringTransportWithDisconnection()
self.clock = task.Clock()
cmd_queue = DeferredQueue()
x1_queue = DeferredQueue()
state = State()
factory = X1ClientFactory(cmd_queue, x1_queue, state)
self.proto = factory.buildProtocol(('127.0.0.1', 0))
self.proto.callLater = self.clock.callLater
self.tr.protocol = self.proto
config.pingEnable = False
self.cmd_data = []
def test_persistent(self):
t1 = {
"datastore1": set(["tag1", "tag2"]),
"datastore2": set(["tag3", "tag2"]),
}
self.tags.set(t1)
# Load from new State and DatastoreTags object. Verify the same result.
state = State(self.file_location)
tags = DatastoreTags(state)
t2 = tags.get()
assert_that(t1, equal_to(t2))
def main(self):
"""
Main which should be overwritten.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
log('[Testing] read %s' % self.args.test_images_file)
# For handling both color and gray images.
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
log('[Testing] no color images, adjusted size')
self.resolution = self.test_images.shape[2]
log('[Testing] resolution %d' % self.resolution)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.int)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Testing] read %s' % self.args.test_codes_file)
N_class = numpy.max(self.test_codes) + 1
network_units = list(map(int, self.args.network_units.split(',')))
log('[Testing] using %d input channels' % self.test_images.shape[3])
self.model = models.Classifier(
N_class,
resolution=(self.test_images.shape[3], self.test_images.shape[1],
self.test_images.shape[2]),
architecture=self.args.network_architecture,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
start_channels=self.args.network_channels,
dropout=self.args.network_dropout,
units=network_units)
assert os.path.exists(
self.args.state_file
), 'state file %s not found' % self.args.state_file
state = State.load(self.args.state_file)
log('[Testing] read %s' % self.args.state_file)
self.model.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(self.model):
log('[Testing] model is not CUDA')
self.model = self.model.cuda()
log('[Testing] loaded model')
self.model.eval()
log('[Testing] set classifier to eval')
self.test()
def _register_services(self):
common.services.register(ServiceName.AGENT_CONFIG, self._config)
common.services.register(ServiceName.LOCKED_VMS, ExclusiveSet())
threadpool = RequestIdExecutor(ThreadPoolExecutor(
self._config.workers))
common.services.register(ThreadPoolExecutor, threadpool)
state_json_file = os.path.join(self._config.options.config_path,
self._config.DEFAULT_STATE_FILE)
state = State(state_json_file)
mode = Mode(state)
common.services.register(ServiceName.MODE, mode)
def test_persist_state(self):
normal_state = "normal"
maintenance_state = "maintenance"
# test retrieving persisted value
state = State(self.file_location)
state.set("state", normal_state)
s = state.get("state")
assert_that(s, equal_to(normal_state))
# test retrieving updated persisted value
state.set("state", maintenance_state)
s = state.get("state")
assert_that(s, equal_to(maintenance_state))
# test retrieving non-existing key/value pair
s = state.get("non_state")
assert_that(s, is_(None))
# test read from persisted state
state = State(self.file_location)
s = state.get("state")
assert_that(s, equal_to(maintenance_state))
def load_model(self):
"""
Load model.
"""
database = utils.read_hdf5(self.args.database_file).astype(numpy.float32)
log('[Attack] read %sd' % self.args.database_file)
self.N_font = database.shape[0]
self.N_class = database.shape[1]
resolution = database.shape[2]
database = database.reshape((database.shape[0] * database.shape[1], database.shape[2], database.shape[3]))
database = torch.from_numpy(database)
if self.args.use_gpu:
database = database.cuda()
database = torch.autograd.Variable(database, False)
N_theta = self.test_theta.shape[1]
log('[Attack] using %d N_theta' % N_theta)
decoder = models.AlternativeOneHotDecoder(database, self.N_font, self.N_class, N_theta)
decoder.eval()
image_channels = 1 if N_theta <= 7 else 3
network_units = list(map(int, self.args.network_units.split(',')))
log('[Attack] using %d input channels' % image_channels)
classifier = models.Classifier(self.N_class, resolution=(image_channels, resolution, resolution),
architecture=self.args.network_architecture,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
start_channels=self.args.network_channels,
dropout=self.args.network_dropout,
units=network_units)
assert os.path.exists(self.args.classifier_file), 'state file %s not found' % self.args.classifier_file
state = State.load(self.args.classifier_file)
log('[Attack] read %s' % self.args.classifier_file)
classifier.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(classifier):
log('[Attack] classifier is not CUDA')
classifier = classifier.cuda()
log('[Attack] loaded classifier')
# !
classifier.eval()
log('[Attack] set classifier to eval')
self.model = models.DecoderClassifier(decoder, classifier)
def run(self):
"""The main loop"""
state = State(1)
time = 0
while time < 5: #TODO
time = time + self.delta_time
# Update state (physics)
acceleration = self.model.compute_acceleration(state)
state = self.kinematics.compute_new_state(state, acceleration, self.delta_time)
print time, acceleration, state.velocity[0], state.position[0]
def setUp(self):
self.hostname = "localhost"
self.host_port = 1234
self.availability_zone_id = "test"
self.host_addr = ServerAddress(self.hostname, self.host_port)
self.chairman_list = []
self.agent_id = "foo"
self.host_config = HostConfig(self.agent_id, self.availability_zone_id,
[Datastore("bar")], self.host_addr,
[Network("nw1")])
self.registrant = ChairmanRegistrant(self.chairman_list)
host_handler = MagicMock()
host_handler.get_host_config_no_logging.return_value = \
GetConfigResponse(hostConfig=self.host_config)
common.services.register(Host.Iface, host_handler)
self.request = RegisterHostRequest("foo", self.host_config)
self.state_file = tempfile.mktemp()
common.services.register(ServiceName.MODE,
Mode(State(self.state_file)))
def update_state(config, values, state, update_values):
# Inner method to check values before adding to state
def check_values(unchecked_values):
# Sort current values
result_values = []
current_flag = ''
# Check values with start|stop order
for value in sorted(unchecked_values):
if value[1] != current_flag:
result_values += [value]
current_flag = value[1]
elif current_flag == 'start':
del result_values[-1]
result_values += [value]
# Remove first stop value if it exists
if len(result_values) > 0 and result_values[0][1] != 'start':
del result_values[0]
return result_values
from common.state import State
# Create new state if it's none or previous one was expired
if state is None or state.is_worked_out():
checked_values = check_values(values)
if len(checked_values) > 0:
return State(update_values(checked_values, []),
expired_time=config.property('expire.delay'))
else:
return None
# Update values for current state unexpired yet
else:
checked_values = check_values(state.values() + values)
return state.update(checked_values, update_values)
def main(self):
"""
Main which should be overwritten.
"""
test_images = utils.read_hdf5(self.args.test_images_file)
log('[Sampling] read %s' % self.args.test_images_file)
if len(test_images.shape) < 4:
test_images = numpy.expand_dims(test_images, axis=3)
network_units = list(map(int, self.args.network_units.split(',')))
self.decoder = models.LearnedDecoder(
self.args.latent_space_size,
resolution=(test_images.shape[3], test_images.shape[1],
test_images.shape[2]),
architecture=self.args.network_architecture,
start_channels=self.args.network_channels,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
units=network_units)
log(self.decoder)
assert os.path.exists(self.args.decoder_file)
state = State.load(self.args.decoder_file)
log('[Sampling] loaded %s' % self.args.decoder_file)
self.decoder.load_state_dict(state.model)
log('[Sampling] loaded decoder')
if self.args.use_gpu and not cuda.is_cuda(self.decoder):
self.decoder = self.decoder.cuda()
log('[Sampling] model needs %gMiB' %
((cuda.estimate_size(self.decoder)) / (1024 * 1024)))
self.sample()
def load_model_and_scheduler(self):
"""
Load model.
"""
params = {
'lr': self.args.lr,
'lr_decay': self.args.lr_decay,
'lr_min': 0.0000001,
'weight_decay': self.args.weight_decay,
}
log('[Training] using %d input channels' % self.train_images.shape[3])
network_units = list(map(int, self.args.network_units.split(',')))
self.model = models.Classifier(
self.N_class,
resolution=(self.train_images.shape[3], self.train_images.shape[1],
self.train_images.shape[2]),
architecture=self.args.network_architecture,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
start_channels=self.args.network_channels,
dropout=self.args.network_dropout,
units=network_units)
self.epoch = 0
if os.path.exists(self.args.state_file):
state = State.load(self.args.state_file)
log('[Training] loaded %s' % self.args.state_file)
self.model.load_state_dict(state.model)
# needs to be done before costructing optimizer.
if self.args.use_gpu and not cuda.is_cuda(self.model):
self.model = self.model.cuda()
log('[Training] model is not CUDA')
log('[Training] loaded model')
optimizer = torch.optim.Adam(self.model.parameters(), params['lr'])
optimizer.load_state_dict(state.optimizer)
self.scheduler = ADAMScheduler(optimizer, **params)
self.epoch = state.epoch + 1
self.scheduler.update(self.epoch)
assert os.path.exists(self.args.training_file) and os.path.exists(
self.args.testing_file)
self.train_statistics = utils.read_hdf5(self.args.training_file)
log('[Training] read %s' % self.args.training_file)
self.test_statistics = utils.read_hdf5(self.args.testing_file)
log('[Training] read %s' % self.args.testing_file)
if utils.display():
self.plot()
else:
if self.args.use_gpu and not cuda.is_cuda(self.model):
self.model = self.model.cuda()
log('[Training] model is not CUDA')
log('[Training] did not load model, using new one')
self.scheduler = ADAMScheduler(self.model.parameters(), **params)
self.scheduler.initialize() # !
log(self.model)
def setUp(self):
self.file_location = tempfile.mktemp()
self.state = State(self.file_location)
def setUp(self):
self.file_location = tempfile.mktemp()
self.state = State(self.file_location)
self.tags = DatastoreTags(self.state)
common.services.register(ServiceName.DATASTORE_TAGS, self.tags)
def setUp(self):
self.file_location = tempfile.mkstemp()[1]
self.state = State(self.file_location)
self.mode = Mode(self.state)
