def _construct_model(self): # initialize dictionaries for holding indices of subnetworks self._layer_inds, self._tensor_inds = {}, {} # construct earlier parts of the model self._construct_inputs() self._construct_Phi() self._construct_latent() self._construct_F() # get output layers out_layer = Dense(self.output_dim, name=self._proc_name('output')) act_layer = _get_act_layer(self.output_act) self._layers.extend([out_layer, act_layer]) # append output tensors self._tensors.append(out_layer(self.tensors[-1])) self._tensors.append(act_layer(self.tensors[-1])) # construct a new model self._model = Model(inputs=self.inputs, outputs=self.output) # compile model self._compile_model()
def _construct_model(self): # get an input tensor self._input = Input(shape=(self.input_dim,), name=self._proc_name('input')) # get potential names of layers names = [self._proc_name('dense_'+str(i)) for i in range(len(self.dense_sizes))] # construct layers and tensors self._layers, tensors = construct_dense(self._input, self.dense_sizes, acts=self.acts, k_inits=self.k_inits, dropouts=self.dropouts, l2_regs=self.l2_regs, names=names) self._tensors = [self._input] + tensors # get output layers out_layer = Dense(self.output_dim, name=self._proc_name('output')) act_layer = _get_act_layer(self.output_act) self._layers.extend([out_layer, act_layer]) # append output tensors self._tensors.append(out_layer(self._tensors[-1])) self._tensors.append(act_layer(self._tensors[-1])) self._output = self._tensors[-1] # construct a new model self._model = Model(inputs=self._input, outputs=self._output) # compile model self._compile_model()
def construct_dense(input_tensor, sizes, acts='relu', k_inits='he_uniform', dropouts=0., l2_regs=0., names=None): """""" # repeat options if singletons acts, k_inits, names = iter_or_rep(acts), iter_or_rep(k_inits), iter_or_rep(names) dropouts, l2_regs = iter_or_rep(dropouts), iter_or_rep(l2_regs) # lists of layers and tensors layers, tensors = [], [input_tensor] # iterate to make specified layers z = zip(sizes, acts, k_inits, dropouts, l2_regs, names) for s, act, k_init, dropout, l2_reg, name in z: # get layers and append them to list kwargs = ({'kernel_regularizer': l2(l2_reg), 'bias_regularizer': l2(l2_reg)} if l2_reg > 0. else {}) dense_layer = Dense(s, kernel_initializer=k_init, name=name, **kwargs) act_layer = _get_act_layer(act) layers.extend([dense_layer, act_layer]) # get tensors and append them to list tensors.append(dense_layer(tensors[-1])) tensors.append(act_layer(tensors[-1])) # apply dropout if specified if dropout > 0.: dr_name = None if name is None else '{}_dropout'.format(name) layers.append(Dropout(dropout, name=dr_name)) tensors.append(layers[-1](tensors[-1])) return layers, tensors[1:]
def construct_distributed_dense(input_tensor, sizes, acts='relu', k_inits='he_uniform', names=None, l2_regs=0.): """""" # repeat options if singletons acts, k_inits, names = iter_or_rep(acts), iter_or_rep(k_inits), iter_or_rep(names) l2_regs = iter_or_rep(l2_regs) # list of tensors layers, tensors = [], [input_tensor] # iterate over specified layers for s, act, k_init, name, l2_reg in zip(sizes, acts, k_inits, names, l2_regs): # define a dense layer that will be applied through time distributed kwargs = {} if l2_reg > 0.: kwargs.update({'kernel_regularizer': l2(l2_reg), 'bias_regularizer': l2(l2_reg)}) d_layer = Dense(s, kernel_initializer=k_init, **kwargs) # get layers and append them to list tdist_layer = TimeDistributed(d_layer, name=name) act_layer = _get_act_layer(act) layers.extend([tdist_layer, act_layer]) # get tensors and append them to list tensors.append(tdist_layer(tensors[-1])) tensors.append(act_layer(tensors[-1])) return layers, tensors