def get_model_representation(self):
"""Initialize an embedding representation of the entire model.
At runtime, a specific row in the embedding matrix is chosen (depending on
the current state) and the dynamic fields in the resulting state-embedding
vector are updated.
"""
num_states = self.net_wrapper.num_pruned_layers()
network_obs = np.empty(shape=(num_states, ObservationLen))
for state_id, layer_id in enumerate(self.net_wrapper.model_metadata.pruned_idxs):
layer = self.net_wrapper.get_layer(layer_id)
layer_macs = self.net_wrapper.layer_macs(layer)
conv_module = distiller.model_find_module(self.model, layer.name)
obs = [state_id,
conv_module.out_channels,
conv_module.in_channels,
layer.ifm_h,
layer.ifm_w,
layer.stride[0],
layer.k,
distiller.volume(conv_module.weight),
layer_macs,
0, 0, 0]
network_obs[state_id:] = np.array(obs)
# Feature normalization
for feature in range(ObservationLen):
feature_vec = network_obs[:, feature]
fmin = min(feature_vec)
fmax = max(feature_vec)
if fmax - fmin > 0:
network_obs[:, feature] = (feature_vec - fmin) / (fmax - fmin)
# msglogger.debug("model representation=\n{}".format(network_obs))
return network_obs
def get_layer_macs(self, layer):
"""Return the number of MACs required to compute <layer>'s Convolution"""
if layer is None:
return 0
conv_module = distiller.model_find_module(self.model, layer.name)
# MACs = volume(OFM) * (#IFM * K^2)
dense_macs = (conv_module.out_channels * layer.ofm_h *
layer.ofm_w) * (conv_module.in_channels * layer.k**2)
return dense_macs
def get_obs(self):
"""Produce a state embedding (i.e. an observation)"""
current_layer_macs = self.net_wrapper.layer_net_macs(self.current_layer())
current_layer_macs_pct = current_layer_macs/self.original_model_macs
current_layer = self.current_layer()
conv_module = distiller.model_find_module(self.model, current_layer.name)
obs = self.model_representation[self.current_state_id, :]
obs[-1] = self.prev_action
obs[-2] = self.rest_macs()
obs[-3] = self.removed_macs_pct
msglogger.debug("obs={}".format(Observation._make(obs)))
# Sanity check
assert (self.removed_macs_pct + current_layer_macs_pct + self.rest_macs()) <= 1
return obs
def get_macs(self, layer):
"""Return the number of MACs required to compute <layer>'s Convolution"""
if layer is None:
return 0
conv_module = distiller.model_find_module(self.model, layer.name)
# MACs = volume(OFM) * (#IFM * K^2)
dense_macs = (conv_module.out_channels * layer.ofm_h * layer.ofm_w) * (conv_module.in_channels * layer.k**2)
if PERFORM_THINNING:
return dense_macs
# If we didn't physically remove structures, we need to use the structural sparsity to compute MACs
conv_pname = layer.name + ".weight"
conv_p = distiller.model_find_param(self.model, conv_pname)
return dense_macs * distiller.density_ch(conv_p)
def _get_obs(self, macs):
"""Produce a state embedding (i.e. an observation)"""
layer = self.current_layer()
conv_module = distiller.model_find_module(self.model, layer.name)
obs = np.array([
layer.t, conv_module.out_channels, conv_module.in_channels,
layer.ifm_h, layer.ifm_w, layer.stride[0], layer.k,
macs / self.dense_model_macs,
self.removed_macs(),
self.remaining_macs(), self.prev_action
])
assert len(obs) == self.STATE_EMBEDDING_LEN
assert (macs / self.dense_model_macs + self.removed_macs() +
self.remaining_macs()) <= 1
msglogger.info("obs={}".format(Observation._make(obs)))
return obs
def get_obs(self):
"""Produce a state embedding (i.e. an observation)"""
current_layer_macs = self.net_wrapper.get_layer_macs(
self.current_layer())
current_layer_macs_pct = current_layer_macs / self.dense_model_macs
current_layer = self.current_layer()
conv_module = distiller.model_find_module(self.model,
current_layer.name)
obs = [ #current_layer.t,
conv_module.out_channels, conv_module.in_channels,
current_layer.ifm_h, current_layer.ifm_w, current_layer.stride[0],
current_layer.k, current_layer_macs_pct * 100,
self.removed_macs() * 100,
self.rest_macs() * 100, self.prev_action * 100
]
onehot_id = self.one_hot(self.current_layer_id,
self.net_wrapper.num_layers())
msglogger.info("obs={} {}".format(onehot_id, Observation._make(obs)))
obs = np.array(onehot_id + obs)
assert (self.removed_macs() + current_layer_macs_pct +
self.rest_macs()) <= 1
return obs
def whole_network_get_obs(self):
"""Produce a state embedding (i.e. an observation)"""
num_layers = self.net_wrapper.num_layers()
network_obs = np.empty(shape=(LayerDescLen, num_layers))
for layer_id in range(num_layers):
layer = self.get_layer(layer_id)
layer_macs = self.net_wrapper.get_layer_macs(layer)
layer_macs_pct = layer_macs / self.dense_model_macs
conv_module = distiller.model_find_module(self.model, layer.name)
obs = [
layer.t, conv_module.out_channels, conv_module.in_channels,
layer.ifm_h, layer.ifm_w, layer.stride[0], layer.k,
layer_macs_pct,
self.removed_macs(),
self.rest_macs()
]
network_obs[:, layer_id] = np.array(obs)
#msglogger.info("obs={} {}".format(onehot_id, Observation._make(obs)))
#network_obs = network_obs.reshape(network_obs.shape[0], network_obs.shape[1], 1)
network_obs = network_obs.reshape(network_obs.shape[0] *
network_obs.shape[1])
#msglogger.info("* obs={}".format(network_obs))
return network_obs
def _get_obs(self, current_layer_macs):
current_layer = self.current_layer()
conv_module = distiller.model_find_module(self.model,
current_layer.name)
return self._get_obs4(current_layer_macs, current_layer, conv_module)
