def conv3x3(x, filters=64,
strides=1, use_bias=False,
kernel_initializer=initializers.VarianceScaling(
scale=2.0, mode='fan_out'),
name=None):
return convnxn(x, filters, 3, strides, use_bias,
kernel_initializer, name)
def get_model(self):
# Input Layer
user_input = Input(shape=(1,), dtype='int32', name='user_input')
item_input = Input(shape=(1,), dtype='int32', name='item_input')
text_input = Input(shape=(self.sim_feature_size,), dtype='float32', name='text_input')
# Embedding layer
MF_Embedding_User = Embedding(input_dim=self.num_users, output_dim=self.mf_embedding_dim, name='mf_embedding_user',
embeddings_initializer=initializers.VarianceScaling(scale=0.01,distribution='normal'),
embeddings_regularizer=l2(0.01), input_length=1)
MF_Embedding_Item = Embedding(input_dim=self.num_items, output_dim=self.mf_embedding_dim, name='mf_embedding_item',
embeddings_initializer=initializers.VarianceScaling(scale=0.01,distribution='normal'),
embeddings_regularizer=l2(0.01), input_length=1)
# MF part
mf_user_latent = tf.keras.layers.Flatten()(MF_Embedding_User(user_input))
mf_item_latent = tf.keras.layers.Flatten()(MF_Embedding_Item(item_input)) # why Flatten？
mf_vector = concatenate([mf_user_latent, mf_item_latent]) # element-wise multiply ???
for idx in range(len(self.mf_fc_unit_nums)): # 学习非线性关系
layer = Dense(self.mf_fc_unit_nums[idx], activation='relu', name="layer%d" % idx)
mf_vector = layer(mf_vector)
# Text part
# text_input = Dense(10, activation='relu', kernel_regularizer=l2(0.01))(text_input) # sim? 需要再使用MLP处理下？
# Concatenate MF and TEXT parts
predict_vector = concatenate([mf_vector, text_input])
for idx in range(len(self.final_MLP_layers)): # 整合后再加上MLP？
layer = Dense(self.final_MLP_layers[idx], activation='relu')# name="layer%d" % idx
predict_vector = layer(predict_vector)
predict_vector = tf.keras.layers.Dropout(0.5)(predict_vector) # 使用dropout?
if new_Para.param.final_activation == 'softmax':
predict_vector = Dense(2, activation='softmax', name="prediction")(predict_vector)
elif new_Para.param.final_activation == 'sigmoid':
predict_vector = Dense(1, activation='sigmoid', kernel_initializer='lecun_uniform', name="prediction")(predict_vector)
# # Final prediction layer
# predict_vector = Dense(1, activation='sigmoid', kernel_initializer='lecun_uniform', name="prediction")(predict_vector)
model = Model(inputs=[user_input, item_input, text_input],outputs=predict_vector)
return model
def conv2d_bn(x, n_filter, n_row, n_col, padding='same', stride=(1, 1), use_bias=False):
x = Convolution2D(n_filter, (n_row, n_col), strides=stride, padding=padding, use_bias=use_bias,
kernel_regularizer=regularizers.l2(0.0004),
kernel_initializer=initializers.VarianceScaling(scale=1, mode='fan_in',
distribution='normal',
seed=None)
)(x)
x = BatchNormalization()(x)
x = tf.nn.elu(x)
return x
def build(self, input_shape):
batch_size, input_dim, input_atoms = input_shape
self.kernel = self.add_weight(name="kernel", initializer=initializers.VarianceScaling(scale=0.1),
shape=[*self.kernel_size, input_atoms, self.output_dim * self.output_atoms])
self.bias = self.add_weight(name="bias", initializer=initializers.Constant(value=0.1),
shape=[self.output_dim, self.output_atoms])
self.input_dim = input_dim
self.input_atoms = input_atoms
def convnxn(x, filters=64, kernel_size=3,
strides=1, use_bias=False,
kernel_initializer=initializers.VarianceScaling(
scale=2.0, mode='fan_out'),
name=None):
return layers.Conv2D(
filters=filters, kernel_size=kernel_size,
strides=strides, padding='SAME',
use_bias=use_bias,
kernel_initializer=kernel_initializer,
name=name)(x)
def build(self, input_shape):
""" The __call__ method of layer will automatically run build the first time it is called.
Create trainable layer weights (embedding dictionary) here """
input_shape = tf.TensorShape(input_shape)
if input_shape.rank != 3:
raise ValueError("The input tensor must be rank of 3"
) # (num_fts, batch_size, input_dense_unit)
num_var = input_shape[0]
shape = tf.TensorShape(
[num_var, self.embedding_dim, self.num_embeddings])
initializer = init.VarianceScaling(distribution='uniform')
self.embeddings = self.add_weight(name='embeddings',
shape=shape,
initializer=initializer,
trainable=True)
# Make sure to call the `build` method at the end or set self.built = True
super(VectorQuantizer, self).build(input_shape)
def build(self, input_shape):
input_shape = tf.TensorShape(input_shape)
if input_shape.rank != 3:
raise ValueError("Input shape must be 3")
# last_dim = input_shape[-1]
num_var = input_shape[0]
shape = tf.TensorShape(
[num_var, self.embedding_dim, self.num_embeddings])
initializer = init.VarianceScaling(distribution='uniform')
self.embeddings = self.add_weight(name='embeddings',
shape=shape,
initializer=initializer)
self.ema_cluster_size = self.add_weight(
name='ema_cluster_size',
shape=[num_var, self.num_embeddings],
initializer=init.get('zeros'))
self.ema_w = self.add_weight(name='ema_dw', shape=shape)
self.ema_w.assign(self.embeddings.read_value())
super(VectorQuantizerEMA, self).build(input_shape)
def build(self, input_shape):
# input_shape = tf.TensorShape(input_shape)
if input_shape.rank == 6: # hidden variable structure
ls = input_shape.as_list()
ls[1] = 1
input_shape = tf.TensorShape(ls)
last_dim = input_shape[-1]
# build custom initializer
n_pots = tf.reduce_prod(input_shape[:-2]).numpy()
scale, mode = (2 * n_pots,
"fan_in") if "he" in self.kernel_initializer else (
n_pots, "fan_avg")
distribution = "uniform" if "uniform" in self.kernel_initializer else "truncated_normal"
self.kernel_initializer = init.VarianceScaling(scale, mode,
distribution)
self.kernel = self.add_weight(name='kernel',
shape=input_shape[:-3].concatenate(
[1, last_dim, self.units]),
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint,
dtype=self.dtype,
trainable=True)
if self.use_bias:
self.bias = self.add_weight(name='bias',
shape=input_shape[:-3].concatenate(
[1, 1, self.units]),
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint,
dtype=self.dtype,
trainable=True)
else:
self.bias = None
self.built = True