def block(tensor, filters, kernel_size, strides, name, rate=1, with_relu=True): if strides == 1: x = Conv2D(filters, kernel_size, strides, padding='SAME', use_bias=False, dilation_rate=rate, kernel_regularizer=l2(0.5 * 1.0), name=name + '/conv2d', kernel_initializer=VarianceScaling( mode="fan_avg", distribution="uniform"))(tensor) else: pad_1 = (kernel_size - 1) // 2 pad_2 = (kernel_size - 1) - pad_1 x = zero_padding(tensor, pad_1, pad_2) x = Conv2D(filters, kernel_size, strides, padding='VALID', use_bias=False, dilation_rate=rate, kernel_regularizer=l2(0.5 * (1.0)), name=name + '/conv2d', kernel_initializer=VarianceScaling( mode="fan_avg", distribution="uniform"))(x) x = BatchNormalization(name=name + '/batch_normalization')(x) if with_relu: x = ReLU()(x) return x
def get_model(output_dims: int) -> Model: """Get the DQN model.""" model = Sequential() model.add( Conv2D( 16, 8, strides=4, activation="relu", kernel_initializer=VarianceScaling(2), input_shape=(*IMG_SIZE, STATE_FRAMES), )) model.add( Conv2D( 32, 4, strides=2, activation="relu", kernel_initializer=VarianceScaling(2), )) model.add(Flatten()) model.add( Dense(256, activation="relu", kernel_initializer=VarianceScaling(2))) model.add(Dense(output_dims, kernel_initializer=VarianceScaling(2))) return model
def get_functional_graph(self, input_shapes, batch_size=None): input_shape = input_shapes[0] input = Input(shape=input_shape, name="input") conv1 = Convolution2D(32, (8, 8), strides=4, padding='valid', activation="relu", kernel_initializer=VarianceScaling(scale=2), use_bias=False, name="conv_1")(input) conv2 = Convolution2D(64, (4, 4), strides=2, padding='valid', activation="relu", kernel_initializer=VarianceScaling(scale=2), use_bias=False, name="conv_2")(conv1) conv3 = Convolution2D(64, (3, 3), strides=1, padding='valid', activation="relu", kernel_initializer=VarianceScaling(scale=2), use_bias=False, name="conv_3")(conv2) flat = Flatten(name='flat')(conv3) return [input], flat
def BRModule(self, input_data, BRM_x, scale=4): """ A single Block Residual Module (BRM) :param input_data: tf object :param BRM_x: index of BRM, x sub-index in the paper :param scale: magnifying scale factor :return: two tf objects for upper (super resolved) and lower (back-projected) flows """ x1 = Conv2DTranspose(filters=64, kernel_size=scale, strides=scale, padding='valid', activation=PReLU(), kernel_initializer=VarianceScaling( scale=2.0, mode="fan_in", distribution="untruncated_normal"), name='BRM{}_CT'.format(str(BRM_x)))(input_data) xup = x1 for i in range(3): xup = Conv2D(filters=64, kernel_size=3, padding='same', activation=PReLU(), kernel_initializer=VarianceScaling( scale=2.0, mode="fan_in", distribution="untruncated_normal"), name='BRM{}_C{}_u'.format(str(BRM_x), str(i + 1)))(xup) x2 = Conv2D(filters=64, kernel_size=scale, strides=scale, padding='valid', activation=PReLU(), kernel_initializer=VarianceScaling( scale=2.0, mode="fan_in", distribution="untruncated_normal"), name='BRM{}_C{}_b'.format(str(BRM_x), str(1)))(x1) x2 = Subtract(name='BRM{}_S_b'.format(str(BRM_x)))([input_data, x2]) xdn = x2 for i in range(3): x2 = Conv2D(filters=64, kernel_size=3, padding='same', activation=PReLU(), kernel_initializer=VarianceScaling( scale=2.0, mode="fan_in", distribution="untruncated_normal"), name='BRM{}_C{}_b'.format(str(BRM_x), str(i + 2)))(x2) xdn = Add(name='BRM{}_A_b'.format(str(BRM_x)))([xdn, x2]) return xup, xdn # xup: SR flow in upper line,,, xdn: Residual flow in bottom line
def __init__(self, n_attention, n_attention_hidden, n_attention_out, n_feat, n_hidden, activation="sigmoid", concat_activity_regularizer=None, kernel_initializer=VarianceScaling(distribution="uniform"), kernel_regularizer='l1', bias_initializer=Zeros(), bias_regularizer='l1', attention_initializer=VarianceScaling(distribution="uniform"), attention_hidden_activation="sigmoid", attention_output_activation="sigmoid", attention_trainable=True, batch_norm_kwargs={}, **kwargs): self.n_attention = n_attention self.n_attention_hidden = n_attention_hidden self.n_attention_out = n_attention_out self.n_feat = n_feat self.n_hidden = n_hidden self.activation = activations.get(activation) self.concat_activity_regularizer = concat_activity_regularizer self.kernel_initializer = kernel_initializer self.kernel_regularizer = kernel_regularizer self.bias_initializer = bias_initializer self.bias_regularizer = bias_regularizer self.attention_initializer = attention_initializer self.attention_hidden_activation = attention_hidden_activation self.attention_output_activation = attention_output_activation self.attention_trainable = attention_trainable self.batch_norm_kwargs = batch_norm_kwargs self.attention_layers = [] for i in range(self.n_attention): attention_layer = DenseAttention( n_feat=self.n_feat, n_hidden=self.n_attention_hidden, out=self.n_attention_out, hidden_activation=self.attention_hidden_activation, output_activation=self.attention_output_activation, kernel_initializer=self.attention_initializer, trainable=self.attention_trainable) self.attention_layers.append(attention_layer) self.concat_layer = Concatenate( activity_regularizer=self.concat_activity_regularizer) #Current (v3): Use Dense layer and batch normalization self.dense_layer = Dense( self.n_hidden, activation=None, #Batch normalization before activation kernel_initializer=self.kernel_initializer, bias_initializer=self.bias_initializer, kernel_regularizer=self.kernel_regularizer, bias_regularizer=self.bias_regularizer, ) self.batch_norm_layer = BatchNormalization(**batch_norm_kwargs) super(ConcatAttentions, self).__init__(**kwargs)
def main(): # Load the data train_data, train_label, validation_data, validation_label, test_data, test_label, output_info = data_preparation( ) num_features = train_data.shape[1] print('Training data shape = {}'.format(train_data.shape)) print('Validation data shape = {}'.format(validation_data.shape)) print('Test data shape = {}'.format(test_data.shape)) print(output_info) # [(2, 'income'), (2, 'marital')] # Set up the input layer input_layer = Input(shape=(num_features, )) #[499,] # Set up MMoE layer mmoe_layers = MMoE(units=4, num_experts=8, num_tasks=2)(input_layer) output_layers = [] # Build tower layer from MMoE layer for index, task_layer in enumerate(mmoe_layers): tower_layer = layers.Dense( units=8, activation='relu', kernel_initializer=VarianceScaling())(task_layer) output_layer = layers.Dense( units=output_info[index][0], name=output_info[index][1], activation='softmax', kernel_initializer=VarianceScaling())(tower_layer) output_layers.append(output_layer) # Compile model model = Model(inputs=[input_layer], outputs=output_layers) # Print out model architecture summary model.summary() adam_optimizer = Adam() model.compile(loss={ 'income': 'binary_crossentropy', 'marital': 'binary_crossentropy' }, optimizer=adam_optimizer, metrics=['accuracy']) # Train the model model.fit(x=train_data, y=train_label, validation_data=(validation_data, validation_label), callbacks=[ ROCCallback(training_data=(train_data, train_label), validation_data=(validation_data, validation_label), test_data=(test_data, test_label)) ], epochs=100)
def rtvsrgan(channels=3,scale=2): varscale = 1. def SubpixelConv2D(scale=2,name="subpixel"): def subpixel_shape(input_shape): dims = [input_shape[0], None if input_shape[1] is None else input_shape[1] * scale, None if input_shape[2] is None else input_shape[2] * scale, int(input_shape[3] / (scale ** 2))] output_shape = tuple(dims) return output_shape def subpixel(x): return tf.nn.depth_to_space(x, scale) return Lambda(subpixel, output_shape=subpixel_shape, name=name) inputs = Input(shape=(None, None, channels),name='input_1') x = Conv2D(filters = 32, kernel_size = (3,3), strides=1, kernel_regularizer=l2_reg, kernel_initializer=VarianceScaling(scale=varscale, mode='fan_in', distribution='normal', seed=None), padding = "same",name='conv_1')(inputs) x = LeakyReLU(0.2)(x) x1 = x x = Conv2D(filters = 32, kernel_size = (3,3), strides=1, kernel_regularizer=l2_reg, kernel_initializer=VarianceScaling(scale=varscale, mode='fan_in', distribution='normal', seed=None), padding = "same",name='conv_2')(x) x2 = LeakyReLU(0.2)(x) x = Concatenate()([x1, x2]) x = Conv2D(filters = 32, kernel_size = (3,3), strides=1, kernel_regularizer=l2_reg, kernel_initializer=VarianceScaling(scale=varscale, mode='fan_in', distribution='normal', seed=None), padding = "same",name='conv_3')(x) x = LeakyReLU(0.2)(x) x = Lambda(lambda x: x * 0.2)(x) x = Concatenate()([x1, x2,x]) x = Conv2D(filters = scale**2*channels, kernel_size = (3,3), strides=1, kernel_regularizer=l2_reg, kernel_initializer=VarianceScaling(scale=varscale, mode='fan_in', distribution='normal', seed=None), padding = "same", name='conv_4')(x) x = SubpixelConv2D(scale=scale,name='subpixel_')(x) x = Activation('tanh',name='tanh_')(x) model = Model(inputs=inputs, outputs=x) #model.summary() return model
def __init__(self, num_filters, augment_dim=0, time_dependent=False, activation=None, groups=None, **kwargs): """ Convolutional block modeling the derivative of ODE system. # Arguments: num_filters : int Number of convolutional filters. augment_dim: int Number of augmentation channels to add. If 0 does not augment ODE. time_dependent : bool If True adds time as input, making ODE time dependent. activation : string One of 'relu' and 'softplus' """ dynamic = kwargs.pop('dynamic', True) super(Conv2dODEFunc, self).__init__(**kwargs, dynamic=dynamic) self.num_filters = num_filters self.augment_dim = augment_dim self.time_dependent = time_dependent self.nfe = tf.Variable(0., trainable=False) # Number of function evaluations self.groups = groups if groups is not None else self.num_filters # Inits are weird to replicate PyTorch's initialization self.kernel_init = VarianceScaling(scale=1/3., distribution='uniform') self.bias_init = VarianceScaling(scale=1/3. * 1/9., distribution='uniform') if time_dependent: self.conv1 = Conv2dTime(self.num_filters, kernel_size=(3, 3), strides=(1, 1), padding='same', kernel_initializer=self.kernel_init, bias_initializer=self.bias_init) self.conv2 = Conv2dTime(self.num_filters, kernel_size=(3, 3), strides=(1, 1), padding='same', kernel_initializer=self.kernel_init, bias_initializer=self.bias_init) else: self.conv1 = Conv2D(self.num_filters, kernel_size=(3, 3), strides=(1, 1), padding='same', kernel_initializer=self.kernel_init, bias_initializer=self.bias_init) self.conv2 = Conv2D(self.num_filters, kernel_size=(3, 3), strides=(1, 1), padding='same', kernel_initializer=self.kernel_init, bias_initializer=self.bias_init) self.norm1 = GroupNormalization(self.groups) self.norm2 = GroupNormalization(self.groups) self.norm3 = GroupNormalization(self.groups) self.activation = Activation(activation)
def main(): # Load the data train_data, train_label, validation_data, validation_label, test_data, test_label = data_preparation( ) num_features = train_data.shape[1] print('Training data shape = {}'.format(train_data.shape)) print('Validation data shape = {}'.format(validation_data.shape)) print('Test data shape = {}'.format(test_data.shape)) # Set up the input layer input_layer = Input(shape=(num_features, )) # Set up MMoE layer mmoe_layers = MMoE(units=16, num_experts=8, num_tasks=2)(input_layer) output_layers = [] output_info = ['y0', 'y1'] # Build tower layer from MMoE layer for index, task_layer in enumerate(mmoe_layers): tower_layer = Dense(units=8, activation='relu', kernel_initializer=VarianceScaling())(task_layer) output_layer = Dense(units=1, name=output_info[index], activation='linear', kernel_initializer=VarianceScaling())(tower_layer) output_layers.append(output_layer) # Compile model model = Model(inputs=[input_layer], outputs=output_layers) learning_rates = [1e-4, 1e-3, 1e-2] adam_optimizer = Adam(lr=learning_rates[0]) model.compile(loss={ 'y0': 'mean_squared_error', 'y1': 'mean_squared_error' }, optimizer=adam_optimizer, metrics=[metrics.mae]) # Print out model architecture summary model.summary() # Train the model model.fit(x=train_data, y=train_label, validation_data=(validation_data, validation_label), epochs=100)
def __init__(self, n_attention, n_attention_hidden, n_attention_out, n_feat, n_hidden, activation="sigmoid", concat_activity_regularizer=None, kernel_initializer=VarianceScaling(distribution="uniform"), kernel_regularizer='l1', bias_initializer=Zeros(), bias_regularizer='l1', attention_initializer=VarianceScaling(distribution="uniform"), attention_hidden_activation="sigmoid", attention_output_activation="sigmoid", attention_trainable=True, attention_feat_weight_trainable=True, **kwargs): self.n_attention = n_attention self.n_attention_hidden = n_attention_hidden self.n_attention_out = n_attention_out self.n_feat = n_feat self.n_hidden = n_hidden self.activation = activations.get(activation) self.concat_activity_regularizer = concat_activity_regularizer self.kernel_initializer = kernel_initializer self.kernel_regularizer = kernel_regularizer self.bias_initializer = bias_initializer self.bias_regularizer = bias_regularizer self.attention_initializer = attention_initializer self.attention_hidden_activation = attention_hidden_activation self.attention_output_activation = attention_output_activation self.attention_trainable = attention_trainable self.attention_feat_weight_trainable = attention_feat_weight_trainable self.concat_layer = Concatenate( activity_regularizer=self.concat_activity_regularizer) self.attention_layers = [] for i in range(self.n_attention): attention_layer = DenseAttentionwFeatWeights( n_feat=self.n_feat, n_hidden=self.n_attention_hidden, out=self.n_attention_out, hidden_activation=self.attention_hidden_activation, output_activation=self.attention_output_activation, feat_weight_trainable=self.attention_feat_weight_trainable, initializer=self.attention_initializer, trainable=self.attention_trainable) self.attention_layers.append(attention_layer) super(ConcatAttentionswFeatWeights, self).__init__(**kwargs)
def wrn_block(x, subnet_id, block_offset, stride, drop_rate, channels_dict, regularizer, se_factor): """creates a w.r.n block with the given parameters, the output is returned""" conv1_name = f"Conv_{subnet_id}_{block_offset}_1" conv2_name = f"Conv_{subnet_id}_{block_offset}_2" x_bn_a_1 = BatchNormalization(beta_regularizer=regularizer, gamma_regularizer=regularizer)(x) x_bn_a_1 = Activation('relu')(x_bn_a_1) out = Conv2D(channels_dict[conv1_name], kernel_size=3, padding="same", use_bias=False, strides=stride, name=conv1_name, kernel_initializer=VarianceScaling(scale=2.0, mode='fan_out'), kernel_regularizer=regularizer)(x_bn_a_1) if drop_rate > 0: out = Dropout(rate=drop_rate)(out) out = BatchNormalization(beta_regularizer=regularizer, gamma_regularizer=regularizer)(out) out = Activation('relu')(out) out = Conv2D(channels_dict[conv2_name], kernel_size=3, padding="same", use_bias=False, strides=1, name=conv2_name, kernel_initializer=VarianceScaling(scale=2.0, mode='fan_out'), kernel_regularizer=regularizer)(out) if block_offset == 0: # skip_layer skip_name = f"Skip_{subnet_id}" x = Conv2D(channels_dict[skip_name], kernel_size=1, padding="same", use_bias=False, strides=stride, name=skip_name, kernel_initializer=VarianceScaling(scale=2.0, mode='fan_out'), kernel_regularizer=regularizer)(x_bn_a_1) if se_factor != 0 and stride == 1: x = se_block(x, channels_dict[conv2_name], se_factor, regularizer) return Add()([out, x])
def make_actor(state_shape: Tuple[int, ...], action_shape: Tuple[int, ...], scope_name: str) -> Model: with tf.variable_scope(scope_name): final_initializer = RandomUniform(-3e-3, 3e-3) initializer = VarianceScaling(scale=1 / 3, mode='fan_in') state_input = Input(shape=state_shape) temp = Flatten()(state_input) temp = BatchNormalization()(temp) temp = Dense(400, activation='relu', kernel_initializer=initializer, bias_initializer=initializer)(temp) temp = BatchNormalization()(temp) temp = Dense(300, activation='relu', kernel_initializer=initializer, bias_initializer=initializer)(temp) temp = BatchNormalization()(temp) temp = Dense(sum(action_shape), activation='tanh', kernel_initializer=final_initializer, bias_initializer=final_initializer)(temp) output = Reshape(action_shape, name='action')(temp) model = Model(inputs=state_input, outputs=output, name='actor') model.compile(optimizer=Adam(1e-4), loss='mean_squared_error') return model
def build(self, input_shape): # input_shape: [(None, ?, 128), (None, ?, 128)] init = VarianceScaling(scale=1.0, mode='fan_avg', distribution='uniform') self.W0 = self.add_weight(name='W0', shape=(input_shape[0][-1], 1), initializer=init, regularizer=l2(3e-7), trainable=True) self.W1 = self.add_weight(name='W1', shape=(input_shape[1][-1], 1), initializer=init, regularizer=l2(3e-7), trainable=True) self.W2 = self.add_weight(name='W2', shape=(1, 1, input_shape[0][-1]), initializer=init, regularizer=l2(3e-7), trainable=True) self.bias = self.add_weight(name='linear_bias', shape=([1]), initializer='zero', regularizer=l2(3e-7), trainable=True) super(context2query_attention, self).build(input_shape)
def to_rgb(inp, style): size = inp.shape[2] x = Conv2DMod(3, 1, kernel_initializer=VarianceScaling(200 / size), demod=False)( [inp, style] ) return Lambda(upsample_to_size, output_shape=[None, im_size, im_size, None])(x)
def __init__(self, num_filters=256, filter_size=3, strides=1, weights_regularizer=None): super().__init__() self.layers = [] if strides > 1: self.layers.append(ZeroPadding2D(padding=((filter_size - 1) // 2))) self.layers.append( Conv2D( filters=num_filters, kernel_size=filter_size, strides=strides, padding=('SAME' if strides == 1 else 'VALID'), use_bias=False, kernel_initializer=VarianceScaling(), # kernel_regularizer=weights_regularizer, )) for layer in self.layers: logger.debug(' {}'.format(layer.name))
def __init__( self, n_feat, n_hidden, out=1, name_idx=0, hidden_activation="sigmoid", output_activation="sigmoid", feat_weight_trainable=True, kernel_initializer=VarianceScaling(), bias_initializer=Zeros(), width=1., #Width of Softmin layer **kwargs): self.n_feat = n_feat self.n_hidden = n_hidden self.out = out self.name_idx = name_idx self.kernel_initializer = kernel_initializer self.bias_initializer = bias_initializer self.feat_weight_trainable = feat_weight_trainable self.hidden_activation = activations.get(hidden_activation) self.output_activation = activations.get(output_activation) self.width = width self.min_layer = Softmin(width=self.width) super(DenseAttentionwFeatWeights, self).__init__(**kwargs)
def g_block(inp, istyle, inoise, fil, u=True): if u: #Custom upsampling because of clone_model issue out = Lambda( upsample, output_shape=[None, inp.shape[2] * 2, inp.shape[2] * 2, None])(inp) else: out = Activation('linear')(inp) rgb_style = Dense(fil, kernel_initializer=VarianceScaling(200 / out.shape[2]))(istyle) style = Dense(inp.shape[-1], kernel_initializer='he_uniform')(istyle) delta = Lambda(crop_to_fit)([inoise, out]) d = Dense(fil, kernel_initializer='zeros')(delta) out = Conv2DMod(filters=fil, kernel_size=3, padding='same', kernel_initializer='he_uniform')([out, style]) out = add([out, d]) out = LeakyReLU(0.2)(out) style = Dense(fil, kernel_initializer='he_uniform')(istyle) d = Dense(fil, kernel_initializer='zeros')(delta) out = Conv2DMod(filters=fil, kernel_size=3, padding='same', kernel_initializer='he_uniform')([out, style]) out = add([out, d]) out = LeakyReLU(0.2)(out) return out, to_rgb(out, rgb_style)
def conv2d_fixed_padding(self, inputs, filters, kernel_size, strides, data_format='channels_last'): """ Strided 2-D convolution with explicit padding. The padding is consistent and is based only on `kernel_size`, not on the dimensions of `inputs` (as opposed to using `tf.layers.conv2d` alone). :param inputs: (Tensor) The input of size `[batch, channels, height_in, width_in]`. :param filters: (Integer) The number of filters in the convolution. :param kernel_size: (Integer) The size of the kernel to be used in the convolution. :param strides: (Integer) The strides of the convolution. :param data_format: (String) Either "channels_first" for `[batch, channels, height, width]` or "channels_last for `[batch, height, width, channels]`. :return: output: (tensor) A `Tensor` of shape `[batch, filters, height_out, width_out]`. """ if strides > 1: inputs = self.fixed_padding(inputs, kernel_size, data_format=data_format) return Conv2D(filters=filters, kernel_size=kernel_size, strides=strides, padding=('SAME' if strides == 1 else 'VALID'), use_bias=False, kernel_initializer=VarianceScaling(), data_format=data_format, kernel_regularizer=tf.keras.regularizers.l2( self.weight_decay), bias_regularizer=tf.keras.regularizers.l2( self.weight_decay))(inputs)
def wrn_sub_network(x, subnet_id, nb_layers, stride, drop_rate, channels_dict, regularizer): """creates a w.r.n subnetwork with the given parameters, x denotes the input, the output is returned""" for i in range(nb_layers): conv1_name = f"Conv_{subnet_id}_{i}_1" if conv1_name not in channels_dict or channels_dict[conv1_name] == 0: if i == 0: # in the case the first layer was skipped, we have to use the skip 1*1 convolution as # input for the second layer skip_name = f"Skip_{subnet_id}" x = BatchNormalization(beta_regularizer=regularizer, gamma_regularizer=regularizer)(x) x = Activation('relu')(x) x = Conv2D(channels_dict[skip_name], kernel_size=1, padding="same", use_bias=False, strides=stride, name=skip_name, kernel_initializer=VarianceScaling(scale=2.0, mode='fan_out'), kernel_regularizer=regularizer)(x) # otherwise there is nothing to add to the WRN else: x = wrn_block(x, subnet_id, i, stride if i == 0 else 1, drop_rate, channels_dict, regularizer=regularizer) return x
def conv_cfg(data_format='channels_first', activation=None, scale=1.0): return dict( padding='same', activation=activation, data_format=data_format, kernel_initializer=VarianceScaling(scale=2.0*scale) # what's VarianceScaling? )
def __init__(self, in_state, in_actions, layers=[128, 128], reg=0.01, activation=ELU, range_high=1, range_low=-1): self.obs = in_state self.act = in_actions self.init = VarianceScaling() self.reg = l2(reg) self.state_input = Input(shape = self.obs) if isinstance(activation, (str, )): x = BatchNormalization()(self.state_input) x = Dense(layers[0], activation=activation, kernel_initializer=self.init, kernel_regularizer=self.reg)(x) for l in layers[1:]: x = Dense(l, activation=activation, kernel_initializer=self.init, kernel_regularizer=self.reg)(x) else: x = BatchNormalization()(self.state_input) x = Dense(layers[0], activation=None, kernel_initializer = self.init, kernel_regularizer = self.reg)(x) x = activation()(x) for l in layers[1:]: x = Dense(l, activation=None, kernel_initializer = self.init, kernel_regularizer = self.reg)(x) x = activation()(x) x = Dense(self.act, activation='tanh', use_bias=False)(x) # move to action range out = Lambda(lambda i: range_high * i)(x) self.model = Model(inputs = [self.state_input], outputs=[out])
def autoencoder(dims, act='relu'): """ Fully connected auto-encoder model, symmetric. Arguments: dims: list of number of units in each layer of encoder. dims[0] is input dim, dims[-1] is units in hidden layer. The decoder is symmetric with encoder. So number of layers of the auto-encoder is 2*len(dims)-1 act: activation, not applied to Input, Hidden and Output layers return: (ae_model, encoder_model), Model of autoencoder and model of encoder """ n_stacks = len(dims) - 1 init = VarianceScaling(scale=1. / 3., mode='fan_in', distribution='uniform') # input x = Input(shape=(dims[0],), name='input') h = x # internal layers in encoder for i in range(n_stacks-1): h = Dense(dims[i + 1], activation=act, kernel_initializer=init, name='encoder_%d' % i)(h) # hidden layer h = Dense(dims[-1], kernel_initializer=init, name='encoder_%d' % (n_stacks - 1))(h) y = h # internal layers in decoder for i in range(n_stacks-1, 0, -1): y = Dense(dims[i], activation=act, kernel_initializer=init, name='decoder_%d' % i)(y) # output y = Dense(dims[0], kernel_initializer=init, name='decoder_0')(y) return Model(inputs=x, outputs=y, name='AE'), Model(inputs=x, outputs=h, name='encoder')
def Linear(in_channels, out_channels, act=None, kernel_init=None, bias_init=None): kernel_initializer = kernel_init or VarianceScaling(1.0 / 3, 'fan_in', 'uniform') bound = math.sqrt(1 / in_channels) bias_initializer = bias_init or RandomUniform(-bound, bound) return Dense(out_channels, activation=act, kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)
def build_q_network(n_actions, learning_rate=0.00001, input_shape=(84, 84), history_length=4): """Builds a dueling DQN as a Keras model Arguments: n_actions: Number of possible action the agent can take learning_rate: Learning rate input_shape: Shape of the preprocessed frame the model sees history_length: Number of historical frames the agent can see Returns: A compiled Keras model """ model_input = Input(shape=(input_shape[0], input_shape[1], history_length)) x = Lambda(lambda layer: layer / 255)(model_input) # normalize by 255 #print(x.shape) AE_model = tf.keras.models.load_model("./checkpoint/AE.h5", compile=False) AE_model.trainable = False encoder = AE_model.layers[0] # x = Conv2D(32, (8, 8), strides=4, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x) # x = Conv2D(64, (4, 4), strides=2, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x) # x = Conv2D(64, (3, 3), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x) #print(x.get_shape()) out_flat = Lambda(lambda f: reshape(f))(x) #print(out_flat.get_shape()) lstm = tf.keras.layers.LSTM(512) x = lstm(out_flat) #print(x.get_shape()) # Split into value and advantage streams val_stream, adv_stream = Lambda(lambda w: tf.split(w, num_or_size_splits=2, axis=1))(x) # custom splitting layer val_stream = Flatten()(val_stream) val = Dense(1, kernel_initializer=VarianceScaling(scale=2.))(val_stream) adv_stream = Flatten()(adv_stream) adv = Dense(n_actions, kernel_initializer=VarianceScaling(scale=2.))(adv_stream) # Combine streams into Q-Values reduce_mean = Lambda(lambda w: tf.reduce_mean(w, axis=1, keepdims=True)) # custom layer for reduce mean q_vals = Add()([val, Subtract()([adv, reduce_mean(adv)])]) # Build model model = Model(model_input, q_vals) model.compile(Adam(learning_rate), loss=tf.keras.losses.Huber()) return model
def to_image(inp, style, channels, image_size): # Not sure if this works for rectangular images x = Conv2DMod(channels, 1, kernel_initializer=VarianceScaling(200 / inp.shape[2]), demod=False)([inp, style]) return Lambda(Generator.upsample_to_size, output_shape=[None, image_size[0], image_size[1], None])([x, image_size])
def build(self, input_shape): num_level_pyramid = len(input_shape[0]) self.lateral_connection_2345 = [ layers.Conv2D(self._dim, (1, 1), padding='same', kernel_initializer=VarianceScaling(scale=1.), kernel_regularizer=self._kernel_regularizer) for _ in range(num_level_pyramid) ] self.anti_aliasing_conv = [ layers.Conv2D(self._dim, (3, 3), padding='same', kernel_initializer=VarianceScaling(scale=1.), kernel_regularizer=self._kernel_regularizer) for _ in range(num_level_pyramid) ] super().build(input_shape)
def build_q_network(n_actions, learning_rate=0.00001, input_shape=(84, 84), history_length=4): model_input = Input(shape=(input_shape[0], input_shape[1], history_length)) x = Lambda(lambda layer: layer / 255)(model_input) # normalize by 255 x = Conv2D(32, (8, 8), strides=4, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x) x = Conv2D(64, (4, 4), strides=2, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x) x = Conv2D(64, (3, 3), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x) # x = Conv2D(1024, (7, 7), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False)(x) val_stream, adv_stream = Lambda(lambda w: tf.split(w, 2, 3))( x) # custom splitting layer val_stream = Flatten()(val_stream) val = Dense(1, kernel_initializer=VarianceScaling(scale=2.))(val_stream) adv_stream = Flatten()(adv_stream) adv = Dense(n_actions, kernel_initializer=VarianceScaling(scale=2.))(adv_stream) reduce_mean = Lambda(lambda w: tf.reduce_mean(w, axis=1, keepdims=True)) q_vals = Add()([val, Subtract()([adv, reduce_mean(adv)])]) model = Model(model_input, q_vals) model.compile(Adam(learning_rate), loss=tf.keras.losses.Huber()) model.summary() return model
def buildDQN(n_actions=4, learning_rate=0.00001, frame_height=84, frame_width=84, sequence_length=4): input_tensor=Input(shape=(frame_height, frame_width, sequence_length), dtype=tf.float32) input_scaled = Lambda(lambda input_unscaled: input_unscaled / 255)(input_tensor) # normalize by 255 conv1 = Conv2D(32, (8, 8), strides=4, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False,name='conv1')(input_scaled) conv2 = Conv2D(64, (4, 4), strides=2, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False,name='conv2')(conv1) conv3 = Conv2D(64, (3, 3), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False,name='conv3')(conv2) conv4 = Conv2D(1024, (7, 7), strides=1, kernel_initializer=VarianceScaling(scale=2.), activation='relu', use_bias=False,name='conv4')(conv3) value_stream, advantage_stream = Lambda(lambda w: tf.split(w, 2, 3))(conv4) value_stream = Flatten(name="value_stream_flatten")(value_stream) value = Dense(1, kernel_initializer=VarianceScaling(scale=2.),name="value_stream_dense")(value_stream) advantage_stream = Flatten(name="advantage_stream_flatten")(advantage_stream) advantage = Dense(n_actions, kernel_initializer=VarianceScaling(scale=2.),name="advantage_stream_dense")(advantage_stream) reduce_mean = Lambda(lambda w: tf.reduce_mean(w, axis=1, keepdims=True),name="reduce_mean") q_values = Add(name="q_values")([value, Subtract()([advantage, reduce_mean(advantage)])]) model = Model(input_tensor, q_values) model.compile(Adam(learning_rate), loss=tf.keras.losses.Huber()) return model
def get_functional_graph(self, input_shapes, batch_size=None): input_shape = input_shapes[0] input = Input(shape=input_shape, name="input") conv1 = Convolution2D(32, (6, 6), strides=4, padding='valid', activation="relu", kernel_initializer=VarianceScaling(scale=2), use_bias=False, name="conv_1")(input) # pool1 = MaxPool2D((2, 2))(conv1) conv2 = Convolution2D(64, (4, 4), strides=2, padding='valid', activation="relu", kernel_initializer=VarianceScaling(scale=2), use_bias=False, name="conv_2")(conv1) # pool2 = MaxPool2D((2, 2))(conv2) conv3 = Convolution2D(64, (3, 3), strides=1, padding='valid', activation="relu", kernel_initializer=VarianceScaling(scale=2), use_bias=False, name="conv_3")(conv2) # pool3 = MaxPool2D((2, 2))(conv3) conv4 = Convolution2D(self.latent_dim, (9, 6), strides=1, padding='valid', activation="relu", kernel_initializer=VarianceScaling(scale=2), use_bias=False, name="conv_4")(conv3) # pool4 = MaxPool2D((2, 2))(conv4) flat = Flatten(name='flat')(conv4) latent = Dense(self.latent_dim, activation="relu", name="latent")(flat) return [input], latent
def fully_connected_dyke_dqn_agent_network( sizes: Tuple[int, ...]) -> List[Layer]: """ Constructs a list of DQN agent network layers, all fully connected. :param sizes: :return: """ return [ Dense(units=size, activation=relu, kernel_initializer=VarianceScaling(scale=2e0)) for size in sizes ]