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)