def _setup_ak(self, post, nn, n2): # This is the equivalent of CalculateAk in Fabber # # Some of this could probably be better done using linalg # operations but bear in mind this is one parameter only self.sigmaK = self.log_tf(tf.matrix_diag_part(post.cov)[:, self.idx], name="sigmak") # [W] self.wK = self.log_tf(post.mean[:, self.idx], name="wk") # [W] self.num_nn = self.log_tf(tf.sparse_reduce_sum(self.nn, axis=1), name="num_nn") # [W] # Sum over vertices of parameter variance multiplied by number of # nearest neighbours for each vertex trace_term = self.log_tf(tf.reduce_sum(self.sigmaK * self.num_nn), name="trace") # [1] # Sum of nearest and next-nearest neighbour mean values self.sum_means_nn = self.log_tf(tf.reshape(tf.sparse_tensor_dense_matmul(self.nn, tf.reshape(self.wK, (-1, 1))), (-1,)), name="wksum") # [W] self.sum_means_n2 = self.log_tf(tf.reshape(tf.sparse_tensor_dense_matmul(self.n2, tf.reshape(self.wK, (-1, 1))), (-1,)), name="contrib8") # [W] # vertex parameter mean multipled by number of nearest neighbours wknn = self.log_tf(self.wK * self.num_nn, name="wknn") # [W] swk = self.log_tf(wknn - self.sum_means_nn, name="swk") # [W] term2 = self.log_tf(tf.reduce_sum(swk * self.wK), name="term2") # [1] gk = 1 / (0.5 * trace_term + 0.5 * term2 + 0.1) hk = tf.multiply(tf.to_float(self.nvertices), 0.5) + 1.0 self.ak = self.log_tf(tf.identity(gk * hk, name="ak"))
def _inference(self, x, dropout): with tf.name_scope('gconv1'): N, M = x.get_shape() # N: number of samples, M: number of features M = int(M) # Transform to Chebyshev basis xt0 = tf.transpose(x) # M x N xt = tf.expand_dims(xt0, 0) # 1 x M x N def concat(xt, x): x = tf.expand_dims(x, 0) # 1 x M x N return tf.concat([xt, x], axis=0) # K x M x N if self.K > 1: xt1 = tf.sparse_tensor_dense_matmul(self.L, xt0) xt = concat(xt, xt1) for k in range(2, self.K): xt2 = 2 * tf.sparse_tensor_dense_matmul(self.L, xt1) - xt0 # M x N xt = concat(xt, xt2) xt0, xt1 = xt1, xt2 xt = tf.transpose(xt) # N x M x K xt = tf.reshape(xt, [-1,self.K]) # NM x K # Filter W = self._weight_variable([self.K, self.F]) y = tf.matmul(xt, W) # NM x F y = tf.reshape(y, [-1, M, self.F]) # N x M x F # Bias and non-linearity # b = self._bias_variable([1, 1, self.F]) b = self._bias_variable([1, M, self.F]) y += b # N x M x F y = tf.nn.relu(y) with tf.name_scope('fc1'): W = self._weight_variable([self.F*M, NCLASSES]) b = self._bias_variable([NCLASSES]) y = tf.reshape(y, [-1, self.F*M]) y = tf.matmul(y, W) + b return y
def _call(self, inputs): # vecs: input feature of the current layer. # adj_partition_list: the row partitions of the full graph adj # (only used in full-batch evaluation on the val/test sets) vecs, adj_norm, len_feat, adj_partition_list, _ = inputs vecs = tf.nn.dropout(vecs, 1 - self.dropout) vecs_hop = [tf.identity(vecs) for o in range(self.order + 1)] for o in range(self.order): for a in range(o + 1): ans1 = tf.sparse_tensor_dense_matmul(adj_norm, vecs_hop[o + 1]) ans_partition = [ tf.sparse_tensor_dense_matmul(adj, vecs_hop[o + 1]) for adj in adj_partition_list ] ans2 = tf.concat(ans_partition, 0) vecs_hop[o + 1] = tf.cond(self.is_train, lambda: tf.identity(ans1), lambda: tf.identity(ans2)) vecs_hop = [self._F_nonlinear(v, o) for o, v in enumerate(vecs_hop)] if self.aggr == 'mean': ret = vecs_hop[0] for o in range(len(vecs_hop) - 1): ret += vecs_hop[o + 1] elif self.aggr == 'concat': ret = tf.concat(vecs_hop, axis=1) else: raise NotImplementedError return ret
def __init__(self, lr, batch_size, dimension, util_train, util_test, campaign, reg_lambda, nn=False): # hyperparameters self.lr = lr self.batch_size = batch_size self.util_train = util_train self.util_test = util_test self.reg_lambda = reg_lambda self.train_data_amt = util_train.get_data_amt() self.test_data_amt = util_test.get_data_amt() # output dir model_name = "{}_{}_{}".format(self.lr, self.reg_lambda, self.batch_size) if nn: self.output_dir = "output/coxnn/{}/{}/".format(campaign, model_name) else: self.output_dir = "output/cox/{}/{}/".format(campaign, model_name) if not os.path.exists(self.output_dir): os.makedirs(self.output_dir) # reset graph ops.reset_default_graph() # placeholders, sorted value tfc.disable_eager_execution() self.X = tfc.sparse_placeholder(tf.float64) self.z = tfc.placeholder(tf.float64) self.b = tfc.placeholder(tf.float64) self.y = tfc.placeholder(tf.float64) # computation graph, linear estimator or neural network if nn: hidden_size = 20 self.w1 = tf.Variable(initial_value=tfc.truncated_normal(shape=[dimension, hidden_size], dtype=tf.float64), name='w1') self.w2 = tf.Variable(initial_value=tfc.truncated_normal(shape=[hidden_size, 1], dtype=tf.float64), name='w2') self.hidden_values = tf.nn.relu(tfc.sparse_tensor_dense_matmul(self.X, self.w1)) self.index = tf.matmul(self.hidden_values, self.w2) self.reg = tf.nn.l2_loss(self.w1[1:, ]) + tf.nn.l2_loss(self.w2[1:, ]) else: self.w = tf.Variable(initial_value=tfc.truncated_normal(shape=[dimension, 1], dtype=tf.float64), name='w') self.index = tfc.sparse_tensor_dense_matmul(self.X, self.w) self.reg = tf.reduce_sum(tf.abs(self.w[1:, ])) self.multiple_times = tf.exp(self.index) self.loss = -tf.reduce_sum((self.index - tfc.log(tf.cumsum(self.multiple_times, reverse=True))) * self.y) + \ self.reg self.optimizer = tfc.train.GradientDescentOptimizer(self.lr) self.train_step = self.optimizer.minimize(self.loss) # for test h0 self.base = self.z * self.y + self.b * (1 - self.y) self.candidate = (1 / tf.cumsum(tf.exp(self.index), reverse=True)) * self.y # session initialization config = tfc.ConfigProto() config.gpu_options.allow_growth = True self.sess = tfc.Session(config=config) tfc.global_variables_initializer().run(session=self.sess)
def _get_bi_pooling_predictions(self, feats): # Linear terms: batch_size * 1 term0 = tf.sparse_tensor_dense_matmul(feats, self.weights['var_linear']) # Interaction terms w.r.t. first sum then square: batch_size * emb_size. # e.g., sum_{k from 1 to K}{(v1k+v2k)**2} sum_emb = tf.sparse_tensor_dense_matmul(feats, self.weights['var_factor']) term1 = tf.square(sum_emb) # Interaction terms w.r.t. first square then sum: batch_size * emb_size. # e.g., sum_{k from 1 to K}{v1k**2 + v2k**2} square_emb = tf.sparse_tensor_dense_matmul( tf.square(feats), tf.square(self.weights['var_factor'])) term2 = square_emb # "neural factorization machine", Equation 3, the result of bi-interaction pooling: batch_size * emb_size term3 = 0.5 * (term1 - term2) # "neural factorization machine", Equation 7, the result of MLP: batch_size * 1 z = [term3] for i in range(self.n_layers): temp = tf.nn.relu( tf.matmul(z[i], self.weights['W_%d' % i]) + self.weights['b_%d' % i]) temp = tf.nn.dropout(temp, 1 - self.mess_dropout[i]) z.append(temp) preds = term0 + tf.matmul(z[-1], self.weights['h']) return preds
def _inference(self, x, dropout): with tf.name_scope('gconv1'): N, M = x.get_shape() # N: number of samples, M: number of features M = int(M) # Filter W = self._weight_variable([self.K, self.F]) def filter(xt, k): xt = tf.transpose(xt) # N x M xt = tf.reshape(xt, [-1, 1]) # NM x 1 w = tf.slice(W, [k,0], [1,-1]) # 1 x F y = tf.matmul(xt, w) # NM x F return tf.reshape(y, [-1, M, self.F]) # N x M x F xt0 = tf.transpose(x) # M x N y = filter(xt0, 0) if self.K > 1: xt1 = tf.sparse_tensor_dense_matmul(self.L, xt0) y += filter(xt1, 1) for k in range(2, self.K): xt2 = 2 * tf.sparse_tensor_dense_matmul(self.L, xt1) - xt0 # M x N y += filter(xt2, k) xt0, xt1 = xt1, xt2 # Bias and non-linearity # b = self._bias_variable([1, 1, self.F]) b = self._bias_variable([1, M, self.F]) y += b # N x M x F y = tf.nn.relu(y) with tf.name_scope('fc1'): W = self._weight_variable([self.F*M, NCLASSES]) b = self._bias_variable([NCLASSES]) y = tf.reshape(y, [-1, self.F*M]) y = tf.matmul(y, W) + b return y
def chebyshev5(self, x, L, Fout, K): N, M, Fin = x.get_shape() N, M, Fin = int(N), int(M), int(Fin) # Rescale Laplacian and store as a TF sparse tensor. Copy to not modify the shared L. L = scipy.sparse.csr_matrix(L) L = graph.rescale_L(L, lmax=2) L = L.tocoo() indices = np.column_stack((L.row, L.col)) L = tf.SparseTensor(indices, L.data, L.shape) L = tf.sparse_reorder(L) # Transform to Chebyshev basis x0 = tf.transpose(x, perm=[1, 2, 0]) # M x Fin x N x0 = tf.reshape(x0, [M, Fin*N]) # M x Fin*N x = tf.expand_dims(x0, 0) # 1 x M x Fin*N print("Test") def concat(x, x_): x_ = tf.expand_dims(x_, 0) # 1 x M x Fin*N return tf.concat([x, x_], axis=0) # K x M x Fin*N if K > 1: x1 = tf.sparse_tensor_dense_matmul(L, x0) x = concat(x, x1) print(" K = 1") for k in range(2, K): x2 = 2 * tf.sparse_tensor_dense_matmul(L, x1) - x0 # M x Fin*N x = concat(x, x2) x0, x1 = x1, x2 x = tf.reshape(x, [K, M, Fin, N]) # K x M x Fin x N x = tf.transpose(x, perm=[3,1,2,0]) # N x M x Fin x K x = tf.reshape(x, [N*M, Fin*K]) # N*M x Fin*K # Filter: Fin*Fout filters of order K, i.e. one filterbank per feature pair. W = self._weight_variable([Fin*K, Fout], regularization=False) x = tf.matmul(x, W) # N*M x Fout return tf.reshape(x, [N, M, Fout]) # N x M x Fout
def chebyshev(self, x, L, Fout, K , normalized=False, algo='LB'): '''normalized or not, algo='LB' or 'gL' (graph Laplacian) will affact the value of "lmax" (maximum eigenvalue)''' N, M, Fin = x.get_shape() N, M, Fin = int(N), int(M), int(Fin) # Rescale Laplacian and store as a TF sparse tensor. Copy to not modify the shared L. L = scipy.sparse.csr_matrix(L) lmax=graph.lmax(L, normalized, algo) # 202000912 # L = graph.rescale_L(L, lmax=2) L = graph.rescale_L(L, lmax) # 202000912 L = L.tocoo() indices = np.column_stack((L.row, L.col)) L = tf.SparseTensor(indices, L.data, L.shape) L = tf.sparse_reorder(L) # Transform to Chebyshev basis x0 = tf.transpose(x, perm=[1, 2, 0]) # M x Fin x N x0 = tf.reshape(x0, [M, Fin*N]) # M x Fin*N x = tf.expand_dims(x0, 0) # 1 x M x Fin*N def concat(x, x_): x_ = tf.expand_dims(x_, 0) # 1 x M x Fin*N return tf.concat([x, x_], axis=0) # K x M x Fin*N if K > 1: x1 = tf.sparse_tensor_dense_matmul(L, x0) x = concat(x, x1) for k in range(1, K-1): x2 = 2 * tf.sparse_tensor_dense_matmul(L, x1) - x0 # M x Fin*N x = concat(x, x2) x0, x1 = x1, x2 x = tf.reshape(x, [K, M, Fin, N]) # K x M x Fin x N x = tf.transpose(x, perm=[3,1,2,0]) # N x M x Fin x K x = tf.reshape(x, [N*M, Fin*K]) # N*M x Fin*K # Filter: Fin*Fout filters of order K, i.e. one filterbank per feature pair. W = self._weight_variable([Fin*K, Fout], regularization=False) x = tf.matmul(x, W) # N*M x Fout return tf.reshape(x, [N, M, Fout]) # N x M x Fout
def _call(self, inputs): x = inputs x = dropout_sparse(x, 1 - self.dropout, self.features_nonzero) x = tf.sparse_tensor_dense_matmul(x, self.vars['weights']) x = tf.sparse_tensor_dense_matmul(self.adj, x) outputs = self.act(x) return outputs
def dot1(x, y, sparse=False): """Wrapper for tf.matmul (sparse vs dense).""" if sparse: y = tf.sparse_tensor_to_dense(y) res = tf.sparse_tensor_dense_matmul(x, y) else: res = tf.sparse_tensor_dense_matmul(x, y) return res
def build(self): """Wrapper for _build().""" with tf.variable_scope(self.name): self._build() # FM self.fm_embedding = tf.get_variable('fm_embedding', [self.input_dim, FLAGS.hidden1]) squared_feature_emb = tf.square(self.fm_embedding) if self.sparse_inputs: summed_feature_emb = tf.sparse_tensor_dense_matmul( self.inputs, self.fm_embedding) squared_feature_emb_sum = tf.sparse_tensor_dense_matmul( self.inputs, squared_feature_emb) else: summed_feature_emb = tf.matmul(self.inputs, self.fm_embedding) squared_feature_emb_sum = tf.matmul(self.inputs, squared_feature_emb) summed_feature_emb_square = tf.square(summed_feature_emb) self.NFM = 0.5 * tf.subtract( summed_feature_emb_square, squared_feature_emb_sum, name='nfm') self.NFM = tf.nn.dropout(self.NFM, 1 - self.fm_dropout) # Build sequential layer model self.activations.append(self.inputs) for layer in self.layers: hidden = layer(self.activations[-1]) if isinstance(hidden, tuple): tf.logging.info('{} shape = {}'.format(layer.name, hidden[0].get_shape())) else: tf.logging.info('{} shape = {}'.format(layer.name, hidden.get_shape())) self.activations.append(hidden) self.GCN = self.activations[-1] self.outputs = self.project_layer( tf.concat([self.GCN, self.NFM], axis=1)) # Store model variables for easy access variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=self.name) self.vars = variables for k in self.vars: tf.logging.info((k.name, k.get_shape())) # Build metrics self._loss() self._accuracy() self._predict() self.opt_op = self.optimizer.minimize(self.loss)
def __encoder(self, A, H, layer): # H = tf.matmul(H, self.W[layer]) if layer == 0: H = layers.sparse_dropout( H, 1 - self.dropout, self.placeholders['num_features_nonzero']) H = tf.sparse_tensor_dense_matmul(H, self.W[layer]) else: H = tf.nn.dropout(H, 1 - self.dropout) H = tf.matmul(H, self.W[layer]) self.C[layer] = self.graph_attention_layer(A, H, self.v[layer], layer) # attention value return tf.sparse_tensor_dense_matmul(self.C[layer], H)
def _call(self, inputs): outputs = [] # 有num_types种关系类型,分别计算后,append for k in range(self.num_types): x = dropout_sparse(inputs, 1 - self.dropout, self.nonzero_feat[self.edge_type[1]]) #防止过拟合 x = tf.sparse_tensor_dense_matmul(x, self.vars['weights_%d' % k]) x = tf.sparse_tensor_dense_matmul(self.adj_mats[self.edge_type][k], x) #稀疏矩阵变成密集矩阵 outputs.append(self.act(x)) outputs = tf.add_n(outputs) outputs = tf.nn.l2_normalize(outputs, dim=1) #l2归一化按行 return outputs #outputs就是特征
def _create_gcmc_embed(self): A_fold_hat = self._split_A_hat(self.norm_adj) embeddings = tf.concat( [self.weights['user_embedding'], self.weights['item_embedding']], axis=0) all_embeddings = [] for k in range(0, self.n_layers): temp_embed = [] for f in range(self.n_fold): temp_embed.append( tf.sparse_tensor_dense_matmul(A_fold_hat[f], embeddings)) embeddings = tf.concat(temp_embed, 0) # convolutional layer. embeddings = tf.nn.leaky_relu( tf.matmul(embeddings, self.weights['W_gc_%d' % k]) + self.weights['b_gc_%d' % k]) # dense layer. mlp_embeddings = tf.matmul( embeddings, self.weights['W_mlp_%d' % k]) + self.weights['b_mlp_%d' % k] # mlp_embeddings = tf.nn.dropout(mlp_embeddings, 1 - self.mess_dropout[k]) all_embeddings += [mlp_embeddings] all_embeddings = tf.concat(all_embeddings, 1) u_g_embeddings, i_g_embeddings = tf.split(all_embeddings, [self.n_users, self.n_items], 0) return u_g_embeddings, i_g_embeddings
def _create_lightgcn_embed(self): if self.node_dropout_flag: A_fold_hat = self._split_A_hat_node_dropout(self.norm_adj) else: A_fold_hat = self._split_A_hat(self.norm_adj) ego_embeddings = tf.concat( [self.weights['user_embedding'], self.weights['item_embedding']], axis=0) all_embeddings = [ego_embeddings] for k in range(0, self.n_layers): temp_embed = [] for f in range(self.n_fold): temp_embed.append( tf.sparse_tensor_dense_matmul(A_fold_hat[f], ego_embeddings)) side_embeddings = tf.concat(temp_embed, 0) ego_embeddings = side_embeddings all_embeddings += [ego_embeddings] all_embeddings = tf.stack(all_embeddings, 1) all_embeddings = tf.reduce_mean(all_embeddings, axis=1, keepdims=False) u_g_embeddings, i_g_embeddings = tf.split(all_embeddings, [self.n_users, self.n_items], 0) return u_g_embeddings, i_g_embeddings
def call(self, inputs): inputs = self.batch_normlization(inputs) mapped_inputs = tf.matmul(inputs, self.kernel) attention_inputs1 = tf.matmul(inputs, self.kernel1) attention_inputs2 = tf.matmul(inputs, self.kernel2) con_sa_1 = tf.reduce_sum(tf.multiply(attention_inputs1, inputs), 1, keepdims=True) con_sa_2 = tf.reduce_sum(tf.multiply(attention_inputs2, inputs), 1, keepdims=True) con_sa_1 = tf.keras.activations.tanh(con_sa_1) con_sa_2 = tf.keras.activations.tanh(con_sa_2) if self.dropout_rate > 0.0: con_sa_1 = tf.nn.dropout(con_sa_1, self.dropout_rate) con_sa_2 = tf.nn.dropout(con_sa_2, self.dropout_rate) con_sa_1 = tf.cast(self.adjs[0], dtype=tf.float32) * con_sa_1 con_sa_2 = tf.cast(self.adjs[0], dtype=tf.float32) * tf.transpose( con_sa_2, [1, 0]) weights = tf.sparse_add(con_sa_1, con_sa_2) weights = tf.SparseTensor(indices=weights.indices, values=tf.nn.leaky_relu(weights.values), dense_shape=weights.dense_shape) attention_adj = tf.sparse_softmax(weights) attention_adj = tf.sparse_reshape( attention_adj, shape=[self.nodes_num, self.nodes_num]) value = tf.sparse_tensor_dense_matmul(attention_adj, mapped_inputs) return self.activation(value)
def _call(self, inputs): x = inputs x = tf.nn.dropout(x, 1 - self.dropout) x = tf.matmul(x, self.vars['weights']) x = tf.sparse_tensor_dense_matmul(self.adj, x) outputs = self.act(x) return outputs
def _create_gcn_embed(self): A = self.A_in # Generate a set of adjacency sub-matrix. A_fold_hat = self._split_A_hat(A) embeddings = tf.concat( [self.weights['user_embed'], self.weights['entity_embed']], axis=0) all_embeddings = [embeddings] for k in range(0, self.n_layers): # A_hat_drop = tf.nn.dropout(A_hat, 1 - self.node_dropout[k], [self.n_users + self.n_items, 1]) temp_embed = [] for f in range(self.n_fold): temp_embed.append( tf.sparse_tensor_dense_matmul(A_fold_hat[f], embeddings)) embeddings = tf.concat(temp_embed, 0) embeddings = tf.nn.leaky_relu( tf.matmul(embeddings, self.weights['W_gc_%d' % k]) + self.weights['b_gc_%d' % k]) embeddings = tf.nn.dropout(embeddings, 1 - self.mess_dropout[k]) # normalize the distribution of embeddings. norm_embeddings = tf.math.l2_normalize(embeddings, axis=1) all_embeddings += [norm_embeddings] all_embeddings = tf.concat(all_embeddings, 1) ua_embeddings, ea_embeddings = tf.split( all_embeddings, [self.n_users, self.n_entities], 0) return ua_embeddings, ea_embeddings
def sparse_linear(input_, input_size, output_size, scope, init_bias=0.0): with tf.variable_scope(scope): W = tf.get_variable( "Matrix", [input_size, output_size], tf.float32, tf.random_normal_initializer(stddev=1.0 / math.sqrt(output_size))) b = tf.get_variable("bias", [output_size], initializer=tf.constant_initializer(init_bias)) return tf.sparse_tensor_dense_matmul(input_, W) + b
def add_diag_layer(self, inlayer, init=ones): inlayer = tf.nn.dropout(inlayer, 1 - self.dropout) w0 = init([1, self.dim]) tosum = tf.sparse_tensor_dense_matmul(self.M, tf.multiply(inlayer, w0)) if self.act_func is None: return tosum else: return self.act_func(tosum)
def add_full_layer(self, inlayer, init=glorot): inlayer = tf.nn.dropout(inlayer, 1 - self.dropout) w0 = init([self.dim, self.dim]) tosum = tf.sparse_tensor_dense_matmul(self.M, tf.matmul(inlayer, w0)) if self.act_func is None: return tosum else: return self.act_func(tosum)
def dot(x, y, sparse=False): """Wrapper for tf.matmul (sparse vs dense).""" print(x) if sparse: res = tf.sparse_tensor_dense_matmul(x, y) else: res = tf.matmul(x, y) return res
def _post_setup(self): self.sum_rho = _tf.reduce_sum([ _tf.sparse_tensor_dense_matmul(self.b_maps[t], self.rho[t]) for t in self.atom_types ], axis=0, name="SumRho") _tf.summary.histogram("SumRho", self.sum_rho) with _tf.variable_scope(self.name + "_EmbeddingFunc", reuse=_tf.AUTO_REUSE): self.F_out = self.F(self.sum_rho) self.output = _tf.add(_tf.reduce_sum([ _tf.sparse_tensor_dense_matmul(self.b_maps[t], self.pairPot[t]) for t in self.atom_types ], axis=0, name="SumPairPot") + self.F_out, self.offset, name="AtomicEnergy")
def build(self): """Wrapper for _build().""" with tf.variable_scope(self.name): self._build() # FM self.fm_embedding = tf.get_variable('fm_embedding', [self.input_dim, FLAGS.fm_dims]) squared_feature_emb = tf.square(self.fm_embedding) if self.sparse_inputs: summed_feature_emb = tf.sparse_tensor_dense_matmul( self.inputs, self.fm_embedding) squared_feature_emb_sum = tf.sparse_tensor_dense_matmul( self.inputs, squared_feature_emb) else: summed_feature_emb = tf.matmul(self.inputs, self.fm_embedding) squared_feature_emb_sum = tf.matmul(self.inputs, squared_feature_emb) summed_feature_emb_square = tf.square(summed_feature_emb) self.NFM = 0.5 * tf.subtract( summed_feature_emb_square, squared_feature_emb_sum, name='nfm') self.NFM = tf.nn.dropout(self.NFM, 1 - self.fm_dropout) self.outputs = self.project_layer( tf.concat([self.GAT, self.NFM], axis=1)) # Store model variables for easy access variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=self.name) self.vars = variables for k in self.vars: tf.logging.info((k.name, k.get_shape())) # Build metrics self._loss() self._accuracy() self._predict() self.opt_op = self.optimizer.minimize(self.loss)
def _call(self, inputs): outputs = [] for k in range(self.num_types): x = tf.nn.dropout(inputs, 1 - self.dropout) x = tf.matmul(x, self.vars['weights_%d' % k]) x = tf.sparse_tensor_dense_matmul(self.adj_mats[self.edge_type][k], x) outputs.append(self.act(x)) outputs = tf.add_n(outputs) #对列表内的元素相加 outputs = tf.nn.l2_normalize(outputs, dim=1) #dim=1 按行进行l2范化 return outputs
def create(self): rotation = tf.eye(self.dim) #rotation = tf.SparseTensor(indices=[[i, i] for i in range(self.dim)], values=[1.0 for _ in range(self.dim)], dense_shape=[self.dim, self.dim]) for plane in self.planes: old_rotation = rotation new_rotation = self.rotation_matrix(plane) #rotation = tf.matmul(old_rotation, tf.sparse_add(tf.zeros([self.dim, self.dim]), new_rotation)) rotation = tf.sparse_tensor_dense_matmul(new_rotation, old_rotation) return rotation
def _create_bi_interaction_embed(self): A = self.A_in # Generate a set of adjacency sub-matrix. A_fold_hat = self._split_A_hat(A) ego_embeddings = tf.concat( [self.weights['user_embed'], self.weights['entity_embed']], axis=0) all_embeddings = [ego_embeddings] for k in range(0, self.n_layers): # A_hat_drop = tf.nn.dropout(A_hat, 1 - self.node_dropout[k], [self.n_users + self.n_items, 1]) temp_embed = [] for f in range(self.n_fold): # set_trace() # GTL temp_embed.append( tf.sparse_tensor_dense_matmul(A_fold_hat[f], ego_embeddings)) # sum messages of neighbors. side_embeddings = tf.concat(temp_embed, 0) add_embeddings = ego_embeddings + side_embeddings # transformed sum messages of neighbors. sum_embeddings = tf.nn.leaky_relu( tf.matmul(add_embeddings, self.weights['W_gc_%d' % k]) + self.weights['b_gc_%d' % k]) # bi messages of neighbors. bi_embeddings = tf.multiply(ego_embeddings, side_embeddings) # transformed bi messages of neighbors. bi_embeddings = tf.nn.leaky_relu( tf.matmul(bi_embeddings, self.weights['W_bi_%d' % k]) + self.weights['b_bi_%d' % k]) ego_embeddings = bi_embeddings + sum_embeddings # message dropout. ego_embeddings = tf.nn.dropout(ego_embeddings, 1 - self.mess_dropout[k]) # normalize the distribution of embeddings. norm_embeddings = tf.math.l2_normalize(ego_embeddings, axis=1) all_embeddings += [norm_embeddings] all_embeddings = tf.concat(all_embeddings, 1) ua_embeddings, ea_embeddings = tf.split( all_embeddings, [self.n_users, self.n_entities], 0) return ua_embeddings, ea_embeddings
def add_sparse_att_layer(self, inlayer, dual_layer): dual_transform = tf.reshape( tf.layers.conv1d(tf.expand_dims(dual_layer, 0), 1, 1), (-1, 1)) logits = tf.reshape( tf.nn.embedding_lookup(dual_transform, self.r_mat.values), [-1]) lrelu = tf.SparseTensor(indices=self.r_mat.indices, values=tf.nn.leaky_relu(logits), dense_shape=self.r_mat.dense_shape) coefs = tf.sparse_softmax(lrelu) vals = tf.sparse_tensor_dense_matmul(coefs, inlayer) if self.act_func is None: return vals else: return self.act_func(vals)
def test(self): print('Test begin') self.pred_mp = tf.exp(tf.sparse_tensor_dense_matmul(self.X, self.w)) self.MSE = tf.reduce_mean(tf.square(self.z - self.pred_mp)) x, b, z, y = self.util_test.get_all_data_origin() feed_dict = {} feed_dict[self.X] = tf.SparseTensorValue( x, [1] * len(x), [self.test_data_amt, dimension]) feed_dict[self.z] = z feed_dict[self.y] = y feed_dict[self.b] = b # calculate MSE mse = self.sess.run(self.MSE, feed_dict) print("MSE: {}".format(mse)) ks = self.pred_mp / self.theta ps = tf.pow(self.z, (ks - 1.)) * tf.exp(-self.z / self.theta) / tf.pow( self.theta, ks) / tf.exp(tf.lgamma(ks)) cs = tf.igamma(ks, self.b / self.theta) / tf.exp(tf.lgamma(ks)) # calculate AUC and LogLoss win_rate = self.sess.run(cs, feed_dict) auc = roc_auc_score(y, win_rate) print("AUC: {}".format(auc)) logloss = log_loss(y, win_rate) print("Log Loss: {}".format(logloss)) # calculate ANLP logp = -tf.log(tf.clip_by_value(ps, 1e-8, 1.0)) logp_arr = self.sess.run(logp, feed_dict) logp_arr[np.isnan(logp_arr)] = 1e-20 #for overflow values, minor logp_arr[logp_arr == 0] = 1e-20 anlp = np.mean(logp_arr) print("ANLP: {}".format(anlp)) # save result and params fin = open(self.output_dir + 'result.txt', 'w') fin.writelines([ "MSE: {0} AUC: {1} Log Loss: {2} ANLP: {3}\n".format( mse, auc, logloss, anlp) ]) fin.close() np.save(self.output_dir + 'w', self.sess.run(self.w)) np.save(self.output_dir + 'k', self.sess.run(ks, feed_dict)) np.save(self.output_dir + 'theta', self.sess.run(self.theta))
def _create_ngcf_embed(self): if self.node_dropout_flag: A_fold_hat = self._split_A_hat_node_dropout(self.norm_adj) else: A_fold_hat = self._split_A_hat(self.norm_adj) ego_embeddings = tf.concat( [self.weights['user_embedding'], self.weights['item_embedding']], axis=0) all_embeddings = [ego_embeddings] for k in range(0, self.n_layers): temp_embed = [] for f in range(self.n_fold): temp_embed.append( tf.sparse_tensor_dense_matmul(A_fold_hat[f], ego_embeddings)) side_embeddings = tf.concat(temp_embed, 0) sum_embeddings = tf.nn.leaky_relu( tf.matmul(side_embeddings, self.weights['W_gc_%d' % k]) + self.weights['b_gc_%d' % k]) # bi messages of neighbors. bi_embeddings = tf.multiply(ego_embeddings, side_embeddings) # transformed bi messages of neighbors. bi_embeddings = tf.nn.leaky_relu( tf.matmul(bi_embeddings, self.weights['W_bi_%d' % k]) + self.weights['b_bi_%d' % k]) # non-linear activation. ego_embeddings = sum_embeddings + bi_embeddings # message dropout. # ego_embeddings = tf.nn.dropout(ego_embeddings, 1 - self.mess_dropout[k]) # normalize the distribution of embeddings. norm_embeddings = tf.nn.l2_normalize(ego_embeddings, axis=1) all_embeddings += [norm_embeddings] all_embeddings = tf.concat(all_embeddings, 1) u_g_embeddings, i_g_embeddings = tf.split(all_embeddings, [self.n_users, self.n_items], 0) return u_g_embeddings, i_g_embeddings