def inference_net(self, C, reuse=None):
# input
h = tf.nn.relu(tf.sparse_matmul(C, self.inference_params[0], a_is_sparse=True))
# intermediate hidden layer
for l in range(1, self.L):
h = tf.nn.relu(tf.sparse_matmul(h, self.inference_params[l], a_is_sparse=True))
# output
beta = tf.nn.softplus(tf.matmul(h, self.inference_params[self.L], a_is_sparse=True)) + 0.3
alpha = tf.nn.softplus(tf.matmul(h, self.inference_params[self.L + 1], a_is_sparse=True)) + 0.3
return alpha, beta
def nn_decision_tree(self, x, cut_points_list, leaf_score):
# cut_points_list contains the cut_points for each dimension of feature
return tf.sparse_matmul(reduce(
self.tf_kron_prod,
map(lambda z: self.tf_bin(x[:, z[0]:z[0] + 1], z[1]),
enumerate(cut_points_list))),
leaf_score,
a_is_sparse=True,
b_is_sparse=True)
def generative_net(self, Z, reuse=None):
# with tf.variable_scope("generative",reuse=reuse):
if self.w_determinist:
h2 = tf.nn.relu(tf.matmul(Z, self.generator_params[0]))
for l in range(1, self.L):
h2 = tf.nn.relu(tf.sparse_matmul(h2, self.generator_params[l], a_is_sparse=True))
d_x = tf.nn.sigmoid(tf.matmul(h2, self.generator_params[self.L], a_is_sparse=True))
else:
e = tf.random_normal(tf.shape(self.generator_params[0]), dtype=tf.float32, mean=0., stddev=1.0,
name='epsilon')
h2 = tf.nn.relu(tf.matmul(Z, self.generator_params[0] + 0.01 * e))
for l in range(1, self.L):
e = tf.random_normal(tf.shape(self.generator_params[l]), dtype=tf.float32, mean=0., stddev=1.0,
name='epsilon')
h2 = tf.nn.relu(tf.sparse_matmul(h2, self.generator_params[l] + 0.01 * e, a_is_sparse=True))
e = tf.random_normal(tf.shape(self.generator_params[self.L]), dtype=tf.float32, mean=0., stddev=1.0,
name='epsilon')
d_x = tf.nn.sigmoid(tf.matmul(h2, self.generator_params[self.L] + 0.01 * e, a_is_sparse=True))
return d_x
def InitFM(self, output_type="finish"):
'''
初始化graph图
:param output: (str)"finish" or "like"
:return: None
'''
# Define weights
with tf.variable_scope('weights'+output_type):
W0 = tf.Variable(0.1, name="W0")
W1 = tf.Variable(tf.truncated_normal([self.embed_num]), name="W1")
W2 = tf.Variable(tf.truncated_normal([self.embed_num, self.embedding_size]), name="W2")
# Calculate the linear part
with tf.variable_scope("linear"+output_type):
# y_linear shape(batch_size, 1)
y_linear = tf.sparse_matmul(a=self.input_sparse,
b=W1,
transpose_b=True,
a_is_sparse=True,
name="y_linear")
# Calculate the cross part
with tf.variable_scope("cross"+output_type):
# part1 shape(batch_size, embedding_size)
part1 = tf.matmul(a=self.input_sparse,
b=W2,
a_is_sparse=True,
name="part1")
part1_square = tf.square(part1, name="cross1_square")
# part2 shape(batch_size, embedding_size)
W2_square = tf.square(W2,name="W2_square")
input_sparse_square = tf.math.square(self.input_sparse,name="input_square")
part2 = tf.matmul(a=input_sparse_square,
b=W2_square,
a_is_sparse=True,
name="part2")
# apply sub
sub = tf.subtract(part1_square, part2, name="part1_part2_sub")
# get cross output, shape(batch_size, 1)
cross_out = 0.5 * tf.reduce_sum(sub, reduction_indices=1,
keep_dims=True,
name="cross_out")
# Calculate the final result
with tf.variable_scope("output"+output_type):
logits = W0 + y_linear + cross_out
return logits
def fc_layer(x, output_num, activation='none', dropout=None, name='fc'):
weight = tf.get_variable(
name, [47236, output_num],
initializer=tf.random_normal_initializer(stddev=0.01))
bias = tf.Variable(tf.zeros(output_num))
y = tf.sparse_matmul(x, weight, a_is_sparse=True)
y = tf.sparse_add(y, bias)
if activation == 'relu':
y = tf.nn.relu(y)
elif activation == 'sigmoid':
y = tf.nn.sigmoid(y)
elif activation == 'none':
pass
if not dropout is None:
y = tf.nn.dropout(y, dropout)
return y
print("check")
indices = sorted(list(set(indices)), key=lambda x: (x[0], x[1]))
print("check")
enum = len(indices)
print("check")
values = np.ones(enum, dtype=np.float32)
print("check")
spmat = tf.SparseTensor(indices,values,[nnum, nnum])
print("check")
var = tf.Variable(np.random.rand(nnum,K).astype(np.float32))
mat = tf.constant(np.random.rand(K,K).astype(np.float32))
print("check")
mul2 = tf.sparse_matmul(spmat, var)
targets = tf.placeholder(name="target", dtype="bool", shape=[nnum])
spmat_t = tf.boolean_mask(spmat, targets)
var_t = tf.boolean_mask(var, targets)
mul = tf.matmul(var_t, tf.matmul(spmat_t, var_t, a_is_sparse=True, transpose_a=True), transpose_b=True)
print("check")
loss = tf.nn.l2_loss(mul)
init = tf.initialize_all_variables()
sess = tf.InteractiveSession()
sess.run(init)
import pdb; pdb.set_trace()
def __init__(self,
params,
init_embeddings,
init_weights,
G,
modify_list,
num_new=1):
self.num_nodes_init, self.embedding_size = init_embeddings.shape
self.num_nodes = self.num_nodes_init + num_new
self.num_modify = len(modify_list)
self.batch_size = params["batch_size"]
self.learn_rate = params["learn_rate"]
self.optimizer = params[
"optimizer"] if "optimizer" in params else "GradientDescentOptimizer"
self.tol = params["tol"] if "tol" in params else 0.0001
self.neighbor_size = params["neighbor_size"]
self.negative_distortion = params["negative_distortion"]
self.num_sampled = params["num_sampled"]
self.epoch_num = params["epoch_num"]
self.lbd = params["lambda"]
self.bs = __import__(
"batch_strategy." + params["batch_strategy"]["func"],
fromlist=["batch_strategy"
]).BatchStrategy(G, num_new, modify_list,
params["batch_strategy"])
unigrams_in = None
if "in_negative_sampling_distribution" in params:
unigrams_in = getattr(
dh, params["in_negative_sampling_distribution"]["func"])(
G, params["in_negative_sampling_distribution"])
unigrams_out = None
if "out_negative_sampling_distribution" in params:
unigrams_out = getattr(
dh, params["out_negative_sampling_distribution"]["func"])(
G, params["out_negative_sampling_distribution"])
self.tensor_graph = tf.Graph()
with self.tensor_graph.as_default():
tf.set_random_seed(157)
self.init_embeddings = tf.constant(init_embeddings)
self.init_weights = tf.constant(init_weights)
self.mask_matrix = tf.sparse_to_dense(
sparse_indices=[(modify_list[i], i)
for i in xrange(self.num_modify)],
output_shape=[self.num_nodes_init, self.num_modify],
sparse_values=1.0,
validate_indices=False)
self.delta_embeddings_pre = tf.Variable(tf.random_uniform(
[self.num_modify, self.embedding_size], -1.0, 1.0),
dtype=tf.float32)
self.delta_weights_pre = tf.Variable(tf.random_uniform(
[self.num_modify, self.embedding_size], -1.0, 1.0),
dtype=tf.float32)
self.delta_embeddings = tf.sparse_matmul(self.mask_matrix,
self.delta_embeddings_pre,
a_is_sparse=True)
self.delta_weights = tf.sparse_matmul(self.mask_matrix,
self.delta_weights_pre,
a_is_sparse=True)
self.embeddings = self.init_embeddings + self.delta_embeddings
self.weights = self.init_weights + self.delta_weights
self.x_in = tf.placeholder(tf.int64, shape=[None])
self.x_out = tf.placeholder(tf.int64, shape=[None])
self.labels_in = tf.placeholder(tf.int64,
shape=[None, self.neighbor_size])
self.labels_out = tf.placeholder(tf.int64,
shape=[None, self.neighbor_size])
self.new_embeddings = tf.Variable(tf.random_uniform(
[num_new, self.embedding_size], -1.0, 1.0),
dtype=tf.float32)
self.new_weights = tf.Variable(tf.random_uniform(
[num_new, self.embedding_size], -1.0, 1.0),
dtype=tf.float32)
self.nce_biases = tf.zeros([self.num_nodes], tf.float32)
self.embed = tf.concat([self.embeddings, self.new_embeddings], 0)
self.w = tf.concat([self.weights, self.new_weights], 0)
self.delta_embeddings_pad = tf.concat([
self.delta_embeddings,
tf.zeros([num_new, self.embedding_size], dtype=tf.float32)
],
axis=0)
self.delta_weights_pad = tf.concat([
self.delta_weights,
tf.zeros([num_new, self.embedding_size], dtype=tf.float32)
],
axis=0)
self.embedding_batch = tf.nn.embedding_lookup(
self.embed, self.x_in)
self.weight_batch = tf.nn.embedding_lookup(self.w, self.x_out)
self.delta_embeddings_batch = tf.nn.embedding_lookup(
self.delta_embeddings_pad, self.x_in)
self.delta_weights_batch = tf.nn.embedding_lookup(
self.delta_weights_pad, self.x_out)
if unigrams_in is None:
self.loss_in = tf.reduce_mean(
tf.nn.nce_loss(weights=self.w,
biases=self.nce_biases,
labels=self.labels_in,
inputs=self.embedding_batch,
num_sampled=self.num_sampled,
num_classes=self.num_nodes,
num_true=self.neighbor_size))
else:
self.sampled_values_in = tf.nn.fixed_unigram_candidate_sampler(
true_classes=self.labels_in,
num_true=self.neighbor_size,
num_sampled=self.num_sampled,
unique=False,
range_max=self.num_nodes,
distortion=self.negative_distortion,
unigrams=unigrams_in)
self.loss_in = tf.reduce_mean(
tf.nn.nce_loss(weights=self.w,
biases=self.nce_biases,
labels=self.labels_in,
inputs=self.embedding_batch,
num_sampled=self.num_sampled,
num_classes=self.num_nodes,
num_true=self.neighbor_size,
sampled_values=self.sampled_values_in))
if unigrams_out is None:
self.loss_out = tf.reduce_mean(
tf.nn.nce_loss(weights=self.embed,
biases=self.nce_biases,
labels=self.labels_out,
inputs=self.weight_batch,
num_sampled=self.num_sampled,
num_classes=self.num_nodes,
num_true=self.neighbor_size))
else:
self.sampled_values_out = tf.nn.fixed_unigram_candidate_sampler(
true_classes=self.labels_out,
num_true=self.neighbor_size,
num_sampled=self.num_sampled,
unique=False,
range_max=self.num_nodes,
distortion=self.negative_distortion,
unigrams=unigrams_out)
self.loss_out = tf.reduce_mean(
tf.nn.nce_loss(weights=self.embed,
biases=self.nce_biases,
labels=self.labels_out,
inputs=self.weight_batch,
num_sampled=self.num_sampled,
num_classes=self.num_nodes,
num_true=self.neighbor_size,
sampled_values=self.sampled_values_out))
self.loss = self.loss_out + self.loss_in + self.lbd * (
tf.norm(self.delta_embeddings_batch) +
tf.norm(self.delta_weights_batch))
self.train_step = getattr(tf.train, self.optimizer)(
self.learn_rate).minimize(self.loss)
att_neigh[self.adj.indices[i][1]])
for n in range(int(self.adj.indices.shape[0]))
],
dense_shape=self.adj.dense_shape)
list(D_sp.indices).eval()
A_sp.eval()
D_sp.eval()
D = tf.constant([[1, 2, 3, 4, 5, 6, 7, 8, 9]], dtype=tf.int64)
cc = tf.sparse_tensor_dense_matmul(A_sp, tf.transpose(D))
cc.eval()
c = tf.sparse_tensor_dense_matmul(A_sp, D_sp)
c = tf.sparse_matmul(A_sp, D_sp, a_is_sparse=True, b_is_sparse=True)
c = tf.matmul(tf.sparse_tensor_to_dense(A_sp, 0),
tf.sparse_tensor_to_dense(D_sp, 0),
a_is_sparse=True,
b_is_sparse=True)
tf.sparse_tensor_to_dense(A_sp, 0)
tf.sparse_tensor_to_dense(D_sp, 0)
sess.run(A_sp.dense_shape)
sess.run(D_sp.dense_shape)
len(G.nodes())
dim_in = 8
def __init__(self,
inputh,
n_in,
n_out,
mat_enc,
middle_activation=tf.nn.relu,
final_activation=tf.nn.sigmoid):
self.n_in = n_in
self.n_out = n_out
#self.chromo = chromo
self.mat_enc = mat_enc
self.input = inputh
self.con_mat_var_map = {}
self.wei_mat_var_map = {}
for key in self.mat_enc.CMatrix.keys():
self.con_mat_var_map[key] = tf.Variable(
initial_value=self.mat_enc.CMatrix[key].astype('float32'),
name='con_mat' + key,
dtype=tf.float32)
self.wei_mat_var_map[key] = tf.Variable(
initial_value=self.mat_enc.WMatrix[key],
name='con_mat' + key,
dtype=tf.float32)
to_effec_mat_node_map = {}
for key in self.con_mat_var_map.keys():
to_effec_mat_node_map[key] = opt_compwise_multiply(
self.con_mat_var_map[key], self.wei_mat_var_map[key])
density_map = {}
for key in to_effec_mat_node_map.keys():
density_map[key] = find_density(to_effec_mat_node_map[key])
self.bias_wei_arr = np.array(
[item.weight for item in self.mat_enc.Bias_conn_arr])
self.bias_var = tf.Variable(initial_value=self.bias_wei_arr,
name="bias",
dtype=tf.float32)
input_till_H2 = None
if 'IH1' in to_effec_mat_node_map.keys():
input_till_H1 = middle_activation(
tf.sparse_matmul(self.input,
to_effec_mat_node_map['IH1'],
b_is_sparse=True))
if 'IH2' in to_effec_mat_node_map.keys():
input_till_H2 = tf.sparse_matmul(self.input,
to_effec_mat_node_map['IH2'],
b_is_sparse=True)
if 'H1H2' in to_effec_mat_node_map.keys():
assert ('IH1' in to_effec_mat_node_map.keys())
twoh = tf.sparse_matmul(input_till_H1,
to_effec_mat_node_map['H1H2'],
b_is_sparse=True)
if 'IH2' in to_effec_mat_node_map.keys():
input_till_H2 = tf.add(twoh, input_till_H2)
else:
input_till_H2 = twoh
if input_till_H2 is not None:
input_till_H2 = middle_activation(input_till_H2)
output = None
if 'H2O' in to_effec_mat_node_map.keys():
assert ('IH2' in to_effec_mat_node_map.keys()
or 'H1H2' in to_effec_mat_node_map.keys())
threeh = tf.sparse_matmul(input_till_H2,
to_effec_mat_node_map['H2O'],
b_is_sparse=True)
output = threeh
if 'H1O' in to_effec_mat_node_map.keys():
assert ('IH1' in to_effec_mat_node_map.keys())
fourh = tf.sparse_matmul(input_till_H1,
to_effec_mat_node_map['H1O'],
b_is_sparse=True)
if output is not None:
output = tf.add(output, fourh)
else:
output = fourh
if 'IO' in to_effec_mat_node_map.keys():
assert ('IO' in to_effec_mat_node_map.keys())
fifth = tf.sparse_matmul(self.input,
to_effec_mat_node_map['IO'],
b_is_sparse=True)
if output is not None:
output = tf.add(output, fifth)
else:
output = fifth
output = final_activation(output)
"""input_till_H2 = middle_activation(
tf.add(
tf.sparse_matmul(self.input, to_effec_mat_node_map['IH2'], b_is_sparse = True),
tf.sparse_matmul( input_till_H1, to_effec_mat_node_map['H1H2'], b_is_sparse = True)
)
)
output = final_activation(
tf.add(
tf.add(
tf.add(
tf.sparse_matmul(input_till_H2, to_effec_mat_node_map['H2O'], b_is_sparse = True ),
tf.sparse_matmul(input_till_H1,to_effec_mat_node_map['H1O'], b_is_sparse = True)
),
tf.sparse_matmul(self.input, to_effec_mat_node_map['IO'] , b_is_sparse = True)
),
self.bias_var
)
)
"""
self.p_y_given_x = output
half = tf.constant(0.5, dtype=self.p_y_given_x.dtype)
if int(self.bias_wei_arr.shape[0]) != 1:
self.y_pred = tf.argmax(self.p_y_given_x, axis=1)
else:
half = tf.constant(0.5, dtype=self.p_y_given_x.dtype)
dadum = tf.constant(0.5, dtype=self.p_y_given_x.dtype)
q = tf.scan(lambda last, current: current[0],
elems=self.p_y_given_x,
initializer=dadum)
s = tf.scan(lambda y, x: tf.greater_equal(x, half),
elems=q,
initializer=False)
#print("herehrerhehrehrehrehrhe", s)
# print("hi",s)
self.y_pred = tf.cast(s, dtype=tf.int32)
self.params = [
self.wei_mat_var_map[key] for key in self.wei_mat_var_map.keys()
] + [self.bias_var]
tf.to_int64() tf.trace() tf.trainable_variables() tf.transpose() tf.truncated_normal() tf.truediv() tf.sparse_transpose() tf.sparse_tensor_dense_matmul() tf.sparse_accumulator_apply_gradient() tf.sparse_accumulator_take_gradient() tf.sparse_add() tf.sparse_concat() tf.sparse_conditional_accumulator() tf.sparse_mask() tf.sparse_matmul() tf.sparse_maximum() tf.sparse_merge() tf.sparse_minimum() tf.sparse_reduce_max() tf.sparse_reduce_max_sparse() tf.reduce_all() tf.reduce_any() tf.reduce_join() tf.reduce_logsumexp() tf.reduce_max() tf.reduce_mean() tf.reduce_min() tf.reduce_prod()
import os
import tensorflow as tf
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #close the warning
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
x = tf.placeholder("float", [None, 784])
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
y = tf.nn.softmax(tf.sparse_matmul(x, W) + b)
y_ = tf.placeholder("float", [None, 10])
# launch the module in a session
#sess = tf.Session()
sess = tf.InteractiveSession()
# cross-entropy cost function
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
# use backpropagation algorithm to minimize, 0.01: learning rate
# gradient descent algorithm
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
# initialize variable
#init = tf.global_variables_initializer()
# evaluate model
with tf.name_scope('accuracy'):
with tf.name_scope('correct_prediction'):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
with tf.name_scope('accuracy'):
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
def system_mat_fields(fwd_model, elec_imped=False):
p = fwd_model_parameters(fwd_model)
d0 = p['n_dims'] + 0
d1 = p['n_dims'] + 1
e = p['n_elem']
n = p['n_node']
num_elc = p['n_elec']
FF_shape = [d0 * e, d1 * e]
CC_shape = [d1 * e, n]
FFjidx = np.floor(
np.arange(d0 * e).T.reshape([d0 * e, 1]) / d0) * d1 * np.ones(
(1, d1)) + np.ones(
(d0 * e, 1)).reshape([d0 * e, 1]) * np.arange(1, d1 + 1)
FFiidx = np.arange(1, d0 * e + 1).T.reshape([d0 * e, 1]) * np.ones((1, d1))
FFdata = np.zeros([d0 * e, d1])
dfact = (d0 - 1) * d0
for j in range(1, e + 1):
a = inv(
np.hstack((np.ones((d1, 1)), (p['nodes'][p['elems'][j - 1] - 1]))))
idx = np.arange(d0 * (j - 1) + 1, d0 * j + 1)
FFdata[np.array(idx - 1),
0:d1] = a[np.arange(1, d1), :] / np.sqrt(dfact * np.abs(det(a)))
CCdata = np.ones((d1 * e, 1))
[F2data, F2iidx, F2jidx, C2data, C2iidx,
C2jidx] = compl_elec_mdl(fwd_model, p, elec_imped)
FF1_idx = np.vstack(
(FFiidx.flatten('F'), FFjidx.flatten('F'))).astype('int') - 1
CC1_idx = np.vstack(
(np.arange(1, d1 * e + 1), p['elems'].flatten())).astype('int') - 1
nn_elc = C2data.shape[0]
FF_shape = [ffs + nn_elc for ffs in FF_shape]
if (C2jidx.shape[0] > 0 and C2iidx.shape[0] > 0):
CC_shape = [
np.max(C2iidx).astype('int') + 1,
np.max(C2jidx).astype('int') + 1
]
F2_idx = np.vstack(
(F2iidx.flatten('F'), F2jidx.flatten('F'))).astype('int')
C2_idx = np.vstack(
(C2iidx.flatten('F'), C2jidx.flatten('F'))).astype('int')
FFdata = FFdata.astype(np.float32)
CCdata = CCdata.astype(np.float32)
F2data = F2data.astype(np.float32)
C2data = C2data.astype(np.float32)
FF1 = tf.SparseTensor(FF1_idx.T, FFdata.flatten('F'), dense_shape=FF_shape)
CC1 = tf.SparseTensor(CC1_idx.T, CCdata.flatten('F'), dense_shape=CC_shape)
FF2 = tf.SparseTensor(F2_idx.T, F2data.flatten('F'), dense_shape=FF_shape)
CC2 = tf.SparseTensor(C2_idx.T, C2data.flatten('F'), dense_shape=CC_shape)
FF = tf.sparse_add(FF1, FF2)
CC = tf.sparse_add(CC1, CC2)
FC = tf.sparse_matmul(tf.sparse_tensor_to_dense(FF,
validate_indices=False),
tf.sparse_tensor_to_dense(CC,
validate_indices=False),
a_is_sparse=True,
b_is_sparse=True)
return FC, FF1, FF2, CC1, CC2
def sparseNetworkSolver(data, given_learning_rate, n_epochs, batch_size):
n_iter, nn, _ = np.shape(data)
"""
* indices: generate a list to store the non-zero indices of the weights
* values: generate a list to store the values at those indices
* dense_shape: shape of the co-efficient matrix
"""
indices = []
indices.append([0, 0])
indices.append([0, 1])
for i in range(1, nn - 1):
indices.append([i, i - 1])
indices.append([i, i])
indices.append([i, i + 1])
indices.append([nn - 1, nn - 2])
indices.append([nn - 1, nn - 1])
nn_nonZero_entries = 2 + 3 * (nn - 2) + 2
values = np.random.rand(nn_nonZero_entries)
weights = tf.SparseTensor(indices=indices,
values=values,
dense_shape=[nn, nn])
X = tf.placeholder(tf.float32, shape=(None, nn), name="batchX")
y = tf.placeholder(tf.float32, shape=(None, nn), name="batchY")
learning_rate = tf.placeholder(tf.float32, shape=(), name="learning_rate")
return_weights = tf.sparse_tensor_to_dense(weights)
output = tf.sparse_matmul(weights,
X,
transpose_a=False,
transpose_b=True,
a_is_sparse=True,
b_is_sparse=False,
name="multiply_Operation")
mse = tf.reduce_mean(tf.square(y - tf.transpose(output)), name="mse")
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
training_op = optimizer.minimize(mse)
init = tf.global_variables_initializer()
count = 0
with tf.Session() as sess:
sess.run(init)
for epoch in range(n_epochs):
if epoch >= 30000:
given_learning_rate = 0.01
x_batch, y_batch = fetch_batch(data, batch_size, epoch, n_iter)
try:
sess.run(training_op,
feed_dict={
X: x_batch,
y: y_batch,
learning_rate: given_learning_rate
})
except:
sess.run("Training operation failed")
if epoch % 100 == 0:
print(mse.eval(feed_dict={X: x_batch, y: y_batch}))
sess.run(return_weights)
return 0.0
x_data = xy[:, 0:3] y_data = xy[:, 3:5] # Make sure the shape and data are OK print(x_data.shape, x_data) print(y_data.shape, y_data) # placeholders for a tensor that will be always fed. X = tf.placeholder(tf.float32, shape=[None, 3]) Y = tf.placeholder(tf.float32, shape=[None, 2]) W = tf.Variable(tf.random_normal([3, 2]), name='weight') b = tf.Variable(tf.random_normal([1]), name='bias') # Hypothesis hypothesis = tf.sparse_matmul(X, W) + b # Simplified cost/loss function cost = tf.reduce_mean(tf.square(hypothesis - Y)) #cost = tf.reduce_max(tf.square(hypothesis - Y)) # Minimize optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-5) train = optimizer.minimize(cost) # Launch the graph in a session. sess = tf.Session() # Initializes global variables in the graph. sess.run(tf.global_variables_initializer()) for step in range(5001):
# for i in range(pp['n_elec']):
# fwd_model['electrode'][i].z_contact = np.random.random(1)[0]
# zc[i] = fwd_model['electrode'][i].z_contact
#
# img['elem_data'] =np.random.random([pp['n_elem'], 1])
E_0 = sysmat.system_mat_1st_order(fwd_model, img)
E = sysmat.system_mat_1st_order_elec(fwd_model, img)
init = tf.initialize_all_tables()
sess = tf.Session()
sess.run(init)
dfc = sess.run(E)
FCc, FF1, FF2, CC1, CC2 = system_mat_fields(fwd_model, elec_imped=True)
fc1 = tf.sparse_matmul(tf.sparse_tensor_to_dense(FF1, validate_indices=False),
tf.sparse_tensor_to_dense(CC1, validate_indices=False),
a_is_sparse=True,
b_is_sparse=True)
fc2 = tf.sparse_matmul(tf.sparse_tensor_to_dense(FF2, validate_indices=False),
tf.sparse_tensor_to_dense(CC2, validate_indices=False),
a_is_sparse=True,
b_is_sparse=True)
fcc = tf.add(fc1, fc2)
#assert (np.max(np.abs(sess.run(E - E_0)))< 1e-4)
#assert(np.max(np.abs(sess.run(FCc - fcc))) < 1e-6)
#assert(np.max(np.abs(dfc- E_tr) < 1.0e-5)
# print
data = lm.loadmat('./data/model_sysmat')
# imdl = data['imdl']
st = tf.SparseTensor(indices=[[0, 0], [1, 2]],
values=[1.0, 2.0],
dense_shape=[30, 40])
mat = tf.placeholder(shape=(40, 30), dtype=tf.float32)
npmat = np.zeros((40, 30))
npmat[0][0] = 2.1
npmat[1][1] = 3.2
npmat[30][23] = 4.5
newmat = tf.matmul(tf.sparse_to_dense(st.indices, st.dense_shape, st.values),
mat)
newnewmat = tf.sparse_matmul(tf.sparse_to_dense(st.indices, st.dense_shape,
st.values),
mat,
a_is_sparse=True,
b_is_sparse=True)
with tf.Session() as sess:
t1 = time.time()
mate = newmat.eval(feed_dict={mat: npmat})
t2 = time.time()
print(t2 - t1, mate)
t3 = time.time()
matee = newmat.eval(feed_dict={mat: npmat})
t4 = time.time()
print(t4 - t3, matee)
print("done")
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
A = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)
B = tf.constant([[5, 6], [7, 8], [9, 10]], dtype=tf.float32)
C = tf.SparseTensor([[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]],
tf.constant([5, 6, 7, 8, 9, 10], tf.float32), [3, 2])
r1 = tf.matmul(A, B, transpose_b=True)
rs = tf.sparse_tensor_dense_matmul(C, A, adjoint_b=True)
rs = tf.transpose(rs)
D = tf.sparse_tensor_to_dense(C)
r2 = tf.sparse_matmul(A, B, transpose_b=True, b_is_sparse=True)
sess = tf.Session()
Cd = tf.sparse_tensor_to_dense(C)
r3 = tf.matmul(A, Cd, b_is_sparse=True, transpose_b=True)
#Ct = tf.sparse_transpose(C)
Ct = C
Ci = tx.sparse_indices(Ct)
r4 = tf.nn.embedding_lookup_sparse(tf.transpose(A),
sp_ids=Ci,
sp_weights=Ct,
combiner="sum")
print(sess.run(r1))
def __init__(self, config):
author_layers = config.author_layers
paper_layers = config.paper_layers
author_layers_length = len(author_layers)
paper_layers_length = len(paper_layers)
author_input_size = author_layers[0]
paper_input_size = paper_layers[0]
l2_lambda = config.l2_lambda
keep_prob = config.keep_prob
gamma = config.gamma
delta = config.delta
alpha = config.alpha
step_num = config.step_num
hidden_num = config.hidden_num
elem_num = config.elem_num
pos_br = config.pos_br
self.pos_h = tf.placeholder(tf.float32, [None, author_input_size], name = 'pos_h')
self.pos_m = tf.placeholder(tf.float32, [None, paper_input_size], name = 'pos_m')
self.pos_t = tf.placeholder(tf.float32, [None, author_input_size], name = 'pos_t')
self.neg_h = tf.placeholder(tf.float32, [None, author_input_size], name = 'neg_h')
self.neg_m = tf.placeholder(tf.float32, [None, paper_input_size], name = 'neg_m')
self.neg_t = tf.placeholder(tf.float32, [None, author_input_size], name = 'neg_t')
self.batch_size = tf.placeholder(tf.int32, [None], name = 'batch_size')
self.pos_h_ids = tf.sparse_placeholder(tf.float32)
self.pos_t_ids = tf.sparse_placeholder(tf.float32)
self.neg_h_ids = tf.sparse_placeholder(tf.float32)
self.neg_t_ids = tf.sparse_placeholder(tf.float32)
#***********************************************************************************************
with tf.name_scope("ae"):
cur_seed = random.getrandbits(32)
encode = tf.get_variable(name = "encode", shape = [length, ae_d], initializer = tf.contrib.layers.xavier_initializer(uniform = False, seed=cur_seed))
encode_b = tf.get_variable(name="encode_b", initializer = tf.zeros([ae_d]))
decode = tf.get_variable(name = "decode", shape = [ae_d, length], initializer = tf.contrib.layers.xavier_initializer(uniform = False, seed=cur_seed))
decode_b = tf.get_variable(name="decode_b", initializer = tf.zeros([length]))
self.pos_h_ids1 = tf.sparse_tensor_to_dense(self.pos_h_ids, validate_indices = False)
self.pos_t_ids1 = tf.sparse_tensor_to_dense(self.pos_t_ids, validate_indices = False)
self.neg_h_ids1 = tf.sparse_tensor_to_dense(self.neg_h_ids, validate_indices = False)
self.neg_t_ids1 = tf.sparse_tensor_to_dense(self.neg_t_ids, validate_indices = False)
encode_pos_h = tf.nn.relu(tf.sparse_matmul(self.pos_h_ids1, encode, a_is_sparse = True) + encode_b)
decode_pos_h = tf.nn.relu(tf.sparse_matmul(encode_pos_h, decode) + decode_b)
encode_pos_t = tf.nn.relu(tf.sparse_matmul(self.pos_t_ids1, encode, a_is_sparse = True) + encode_b)
decode_pos_t = tf.nn.relu(tf.sparse_matmul(encode_pos_t, decode) + decode_b)
encode_neg_h = tf.nn.relu(tf.sparse_matmul(self.neg_h_ids1, encode, a_is_sparse = True) + encode_b)
decode_neg_h = tf.nn.relu(tf.sparse_matmul(encode_neg_h, decode) + decode_b)
encode_neg_t = tf.nn.relu(tf.sparse_matmul(self.neg_t_ids1, encode, a_is_sparse = True) + encode_b)
decode_neg_t = tf.nn.relu(tf.sparse_matmul(encode_neg_t, decode) + decode_b)
self.ae_loss = 0.0
self.ae_loss_init = tf.reduce_sum(abs(tf.multiply(self.pos_h_ids1 - decode_pos_h, tf.multiply(pos_br, tf.sign(self.pos_h_ids1)))))
self.ae_loss = self.ae_loss_init + tf.reduce_sum(abs(tf.multiply(self.pos_t_ids1 - decode_pos_t, tf.multiply(pos_br, tf.sign(self.pos_t_ids1)))))
self.ae_loss += tf.reduce_sum(abs(tf.multiply(self.neg_h_ids1 - decode_neg_h, tf.multiply(pos_br, tf.sign(self.neg_h_ids1)))))
self.ae_loss += tf.reduce_sum(abs(tf.multiply(self.neg_t_ids1 - decode_neg_t, tf.multiply(pos_br, tf.sign(self.neg_t_ids1)))))
with tf.name_scope("mlp"):
self.relation_W_a = []
self.relation_b_a = []
self.relation_W_p = []
self.relation_b_p = []
self.pos_a1_hidden = []
self.pos_a2_hidden = []
self.pos_p_hidden = []
self.pos_r_hidden_test = []
self.neg_a1_hidden = []
self.neg_a2_hidden = []
self.neg_p_hidden = []
self.mlp_l2_loss = 0.0
# author mlp
for i in range(author_layers_length - 1):
cur_seed = random.getrandbits(32)
self.relation_W_a.append(tf.get_variable(name = "relation_W_a"+str(i), shape = [author_layers[i], author_layers[i+1]], initializer = tf.contrib.layers.xavier_initializer(uniform = False, seed=cur_seed)))
self.relation_b_a.append(tf.get_variable(name="relation_b_a"+str(i), initializer = tf.zeros([author_layers[i+1]])))
self.mlp_l2_loss += tf.nn.l2_loss(self.relation_W_a[i])+tf.nn.l2_loss(self.relation_b_a[i])
# feed pos_h into mlp
if i == 0:
layers_pos_a1 = tf.nn.relu(tf.matmul(self.pos_h, self.relation_W_a[i]) + self.relation_b_a[i])
layers_neg_a1 = tf.nn.relu(tf.matmul(self.neg_h, self.relation_W_a[i]) + self.relation_b_a[i])
elif i == author_layers_length - 2:
layers_pos_a1 = tf.matmul(self.pos_a1_hidden[i-1], self.relation_W_a[i]) + self.relation_b_a[i]
layers_neg_a1 = tf.matmul(self.neg_a1_hidden[i-1], self.relation_W_a[i]) + self.relation_b_a[i]
else:
layers_pos_a1 = tf.nn.relu(tf.matmul(self.pos_a1_hidden[i-1], self.relation_W_a[i]) + self.relation_b_a[i])
layers_neg_a1 = tf.nn.relu(tf.matmul(self.neg_a1_hidden[i-1], self.relation_W_a[i]) + self.relation_b_a[i])
if i == (author_layers_length-3)/2:
cur_seed = random.getrandbits(32)
self.pos_a1_rep = tf.nn.dropout(layers_pos_a1, keep_prob, seed=cur_seed)
cur_seed = random.getrandbits(32)
self.neg_a1_rep = tf.nn.dropout(layers_neg_a1, keep_prob, seed=cur_seed)
self.pos_a1_hidden.append(self.pos_a1_rep)
self.neg_a1_hidden.append(self.neg_a1_rep)
else:
self.pos_a1_hidden.append(layers_pos_a1)
self.neg_a1_hidden.append(layers_neg_a1)
for i in range(author_layers_length - 1):
cur_seed = random.getrandbits(32)
# feed pos_h into mlp
if i == 0:
layers_pos_a2 = tf.nn.relu(tf.matmul(self.pos_t, self.relation_W_a[i]) + self.relation_b_a[i])
layers_neg_a2 = tf.nn.relu(tf.matmul(self.neg_t, self.relation_W_a[i])+ self.relation_b_a[i])
elif i == author_layers_length - 2:
layers_pos_a2 = tf.matmul(self.pos_a2_hidden[i-1], self.relation_W_a[i]) + self.relation_b_a[i]
layers_neg_a2 = tf.matmul(self.neg_a2_hidden[i-1], self.relation_W_a[i]) + self.relation_b_a[i]
else:
layers_pos_a2 = tf.nn.relu(tf.matmul(self.pos_a2_hidden[i-1], self.relation_W_a[i])+self.relation_b_a[i])
layers_neg_a2 = tf.nn.relu(tf.matmul(self.neg_a2_hidden[i-1], self.relation_W_a[i])+self.relation_b_a[i])
if i == (author_layers_length-3)/2:
cur_seed = random.getrandbits(32)
self.pos_a2_rep = tf.nn.dropout(layers_pos_a2, keep_prob, seed=cur_seed)
cur_seed = random.getrandbits(32)
self.neg_a2_rep = tf.nn.dropout(layers_neg_a2, keep_prob, seed=cur_seed)
self.pos_a2_hidden.append(self.pos_a2_rep)
self.neg_a2_hidden.append(self.neg_a2_rep)
else:
self.pos_a2_hidden.append(layers_pos_a2)
self.neg_a2_hidden.append(layers_neg_a2)
for i in range(paper_layers_length - 1):
cur_seed = random.getrandbits(32)
self.relation_W_p.append(tf.get_variable(name = "relation_W_p"+str(i), shape = [paper_layers[i], paper_layers[i+1]], initializer = tf.contrib.layers.xavier_initializer(uniform = False, seed=cur_seed)))
self.relation_b_p.append(tf.get_variable(name="relation_b_p"+str(i), initializer = tf.zeros([paper_layers[i+1]])))
self.mlp_l2_loss += tf.nn.l2_loss(self.relation_W_p[i])+tf.nn.l2_loss(self.relation_b_p[i])
# feed pos_m into mlp
if i == 0:
layers_pos_p = tf.nn.relu(tf.matmul(self.pos_m, self.relation_W_p[i]) + self.relation_b_p[i])
layers_neg_p = tf.nn.relu(tf.matmul(self.neg_m, self.relation_W_p[i]) + self.relation_b_p[i])
elif i == paper_layers_length - 2:
layers_pos_p = tf.matmul(self.pos_p_hidden[i-1], self.relation_W_p[i])+ self.relation_b_p[i]
layers_neg_p = tf.matmul(self.neg_p_hidden[i-1], self.relation_W_p[i]) + self.relation_b_p[i]
else:
layers_pos_p = tf.nn.relu(tf.matmul(self.pos_p_hidden[i-1], self.relation_W_p[i]) + self.relation_b_p[i])
layers_neg_p = tf.nn.relu(tf.matmul(self.neg_p_hidden[i-1], self.relation_W_p[i]) + self.relation_b_p[i])
if i == (paper_layers_length-3)/2:
cur_seed = random.getrandbits(32)
self.pos_p_rep = tf.nn.dropout(layers_pos_p, keep_prob, seed=cur_seed)
cur_seed = random.getrandbits(32)
self.neg_p_rep = tf.nn.dropout(layers_neg_p, keep_prob, seed=cur_seed)
self.pos_p_hidden.append(self.pos_p_rep)
self.neg_p_hidden.append(self.neg_p_rep)
else:
self.pos_p_hidden.append(layers_pos_p)
self.neg_p_hidden.append(layers_neg_p)
self.a1_embed = self.pos_a1_hidden[-1]
self.p_embed = self.pos_p_hidden[-1]
self.a2_embed = self.pos_a2_hidden[-1]
with tf.name_scope('concate'):
self.encode_pos_h = encode_pos_h
con_pos_h = tf.concat([self.pos_a1_hidden[-1], encode_pos_h], 1)
con_pos_t = tf.concat([self.pos_a2_hidden[-1], encode_pos_t], 1)
con_neg_h = tf.concat([self.neg_a1_hidden[-1], encode_neg_h], 1)
con_neg_t = tf.concat([self.neg_a2_hidden[-1], encode_neg_t], 1)
self.con_pos_h = con_pos_h
'''
with tf.name_scope("node_lookup"):
cur_seed = random.getrandbits(32)
embeddings = tf.get_variable(name = "embeddings", shape = [entityTotal, author_layers[-1]], initializer = tf.contrib.layers.xavier_initializer(uniform = False, seed=cur_seed))
pos_h_e = tf.nn.embedding_lookup(embeddings, self.pos_h_ids)
pos_m_e = tf.nn.embedding_lookup(embeddings, self.pos_m_ids)
pos_t_e = tf.nn.embedding_lookup(embeddings, self.pos_t_ids)
neg_h_e = tf.nn.embedding_lookup(embeddings, self.neg_h_ids)
neg_m_e = tf.nn.embedding_lookup(embeddings, self.neg_m_ids)
neg_t_e = tf.nn.embedding_lookup(embeddings, self.neg_t_ids)
with tf.name_scope("max"):
new_pos_h = tf.maximum(pos_h_e, self.pos_a1_hidden[-1])
new_pos_m = tf.maximum(pos_m_e, self.pos_p_hidden[-1])
new_pos_t = tf.maximum(pos_t_e, self.pos_a2_hidden[-1])
new_neg_h = tf.maximum(neg_h_e, self.neg_a1_hidden[-1])
new_neg_m = tf.maximum(neg_m_e, self.neg_p_hidden[-1])
new_neg_t = tf.maximum(neg_t_e, self.neg_a2_hidden[-1])
self.update_pos_h = tf.scatter_update(embeddings, self.pos_h_ids, new_pos_h)
self.update_pos_m = tf.scatter_update(embeddings, self.pos_m_ids, new_pos_m)
self.update_pos_t = tf.scatter_update(embeddings, self.pos_t_ids, new_pos_t)
self.update_neg_h = tf.scatter_update(embeddings, self.neg_h_ids, new_neg_h)
self.update_neg_m = tf.scatter_update(embeddings, self.neg_m_ids, new_neg_m)
self.update_neg_t = tf.scatter_update(embeddings, self.neg_t_ids, new_neg_t)
self.update = [self.update_pos_h, self.update_pos_m, self.update_pos_t,
self.update_neg_h, self.update_neg_m, self.update_neg_t]
'''
with tf.variable_scope("ape", reuse = None) as vs:
# vs.reuse_variables()
inputs_pos = tf.concat([tf.reduce_sum(tf.multiply(con_pos_h, self.pos_p_hidden[-1]),axis = 1, keep_dims = True), tf.reduce_sum(tf.multiply(con_pos_h, con_pos_t), axis = 1, keep_dims = True), tf.reduce_sum(tf.multiply(self.pos_p_hidden[-1], con_pos_t),axis = 1, keep_dims = True)], 1)
inputs_neg = tf.concat([tf.reduce_sum(tf.multiply(con_neg_h, self.neg_p_hidden[-1]),axis = 1, keep_dims = True), tf.reduce_sum(tf.multiply(con_neg_h, con_neg_t), axis = 1, keep_dims = True), tf.reduce_sum(tf.multiply(self.neg_p_hidden[-1], con_neg_t),axis = 1, keep_dims = True)], 1)
self.inputs_pos = inputs_pos
self.inputs_neg = inputs_neg
if config.no_weight:
merge_layers = tf.contrib.keras.layers.Dense(1, kernel_initializer = tf.ones_initializer(), trainable = False, name = 'merge_pos')
merge_pos = merge_layers(inputs_pos)
merge_pos = merge_layers(inputs_neg)
b_pos = tf.get_variable(name="b_pos", initializer = tf.zeros(1))
merge_pos_new = merge_pos + b_pos
merge_neg = tf.contrib.keras.layers.Dense(1, kernel_initializer = tf.ones_initializer(), trainable = False, name = 'merge_pos')(inputs_pos)
b_neg = tf.get_variable(name="b_pos", initializer = tf.zeros(1))
merge_neg_new = merge_neg + b_neg
else:
print('inputs_pos', inputs_pos)
merge_layers = tf.contrib.keras.layers.Dense(1, kernel_initializer = tf.ones_initializer(),kernel_constraint = 'NonNeg', trainable = True, name = 'merge_pos')
self.merge_pos_new = merge_layers(inputs_pos)
self.merge_neg_new = merge_layers(inputs_neg)
print(self.merge_pos_new)
outlier_loss_pos = tf.reduce_sum(tf.log(tf.clip_by_value(tf.sigmoid(tf.multiply(self.merge_pos_new, tf.ones_like(self.merge_pos_new))), 1e-8, 1.0 )))
outlier_loss = outlier_loss_pos + tf.reduce_sum(tf.log(tf.clip_by_value(tf.sigmoid(tf.multiply(self.merge_neg_new, tf.multiply(-1.0, tf.ones_like(self.merge_neg_new)))), 1e-8, 1.0)))
self.outlier_loss = tf.multiply(-1.0, outlier_loss)
# pos_h_test = tf.nn.embedding_lookup(embeddings, self.pos_h_ids)
# pos_m_test = tf.nn.embedding_lookup(embeddings, self.pos_m_ids)
# pos_t_test = tf.nn.embedding_lookup(embeddings, self.pos_t_ids)
inputs_test = tf.concat([tf.reduce_sum(tf.multiply(con_pos_h, self.pos_p_hidden[-1]),axis = 1, keep_dims = True), tf.reduce_sum(tf.multiply(con_pos_h, con_pos_t), axis = 1, keep_dims = True), tf.reduce_sum(tf.multiply(self.pos_p_hidden[-1], con_pos_t),axis = 1, keep_dims = True)], 1)
self.outlier_score = merge_layers(inputs_test)
self.loss = self.outlier_loss + alpha * self.ae_loss + l2_lambda * self.mlp_l2_loss
