def __init__(self, is_training=True):
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
# self.X = tf.placeholder(tf.float32, shape=(None, 28, 28, 1))
# self.labels = tf.placeholder(tf.int64, shape=(None,))
self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads, train_mode='train',
graph=self.graph)
self.valX, self.vallabels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads,
train_mode='test', graph=self.graph)
self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32)
self.build_arch()
self.loss()
self._summary()
# t_vars = tf.trainable_variables()
self.global_step = tf.Variable(0, name='global_step', trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(self.total_loss,
global_step=self.global_step) # var_list=t_vars)
# self.step_op = self.global_step.assign_add(1)
# self.init_op = tf.global_variables_initializer()
else:
self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1))
self.labels = tf.placeholder(tf.int32, shape=(cfg.batch_size,))
self.Y = tf.reshape(self.labels, shape=(cfg.batch_size, 10, 1))
self.build_arch()
tf.logging.info('Setting up the main structure')
def predict(self, x_test, y_test, model_path):
"""
Use to predict batch data so as to get predicted results
:param x_test: the test images
:param y_test: the test masks
:param model_path: the path stores trained model
:return: predictions (uint8)
"""
tf.reset_default_graph()
with tf.compat.v1.Session() as sess:
saver = tf.compat.v1.train.import_meta_graph(model_path + ".meta")
saver.restore(sess, model_path)
graph = tf.compat.v1.get_default_graph()
x = graph.get_operation_by_name("x_input").outputs[0]
y = tf.compat.v1.get_collection("network_architecture")[0]
no_samples = x_test.shape[0]
predictions = []
n_iteration = no_samples // self.batch_size
for step in range(n_iteration):
x_batch, y_batch = get_batch_data(x_test,
y_test,
iter_step=step,
batch_size=self.batch_size)
preds = sess.run(y, feed_dict={x: x_batch})
predictions.append(preds)
return predictions
def __init__(self, is_training=True):
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
self.X, self.labels = get_batch_data()
self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32)
self.build_arch()
self.loss()
self._summary()
# t_vars = tf.trainable_variables()
self.global_step = tf.Variable(0, name='global_step', trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step) # var_list=t_vars)
elif cfg.mask_with_y:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 28, 28, 1))
self.Y = tf.placeholder(tf.float32, shape=(cfg.batch_size, 10, 1))
self.build_arch()
else:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 28, 28, 1))
self.build_arch()
tf.logging.info('Seting up the main structure')
def __init__(self, batch_size, use_recons_loss, recon_with_y):
self.graph = tf.Graph()
# param
self.batch_size = batch_size
self.use_recons_loss = use_recons_loss
self.recon_with_y = recon_with_y
self.x, self.labels = None, None
self.caps_digit, self.v_length, self.prediction, self.batch_accuracy = None, None, None, None
self.recons_input, self.decoded = None, None
self.margin_loss, self.total_loss = None, None
self.train_op = None
with self.graph.as_default():
# input
self.x, self.labels = get_batch_data(batch_size)
# network: result + reconstruction
self.caps_digit, self.v_length, self.prediction, self.batch_accuracy, self.recons_input, self.decoded = self.caps_net(
)
# loss
self.margin_loss, _, self.total_loss = self.loss_total(
self.x, self.labels, self.v_length, self.decoded)
# train
self.train_op = self._train_op(self.use_recons_loss,
self.margin_loss, self.total_loss)
pass
def __init__(self, is_training=True, height=28, width=28, channels=1, num_label=10):
"""
Args:
height: Integer, the height of inputs.
width: Integer, the width of inputs.
channels: Integer, the channels of inputs.
num_label: Integer, the category number.
"""
self.height = height
self.width = width
self.channels = channels
self.num_label = num_label
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads)
self.Y = tf.one_hot(self.labels, depth=self.num_label, axis=1, dtype=tf.float32)
self.build_arch()
self.loss()
self._summary()
# t_vars = tf.trainable_variables()
self.global_step = tf.Variable(0, name='global_step', trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step)
else:
self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, self.height, self.width, self.channels))
self.labels = tf.placeholder(tf.int32, shape=(cfg.batch_size, ))
self.Y = tf.reshape(self.labels, shape=(cfg.batch_size, self.num_label, 1))
self.build_arch()
tf.logging.info('Seting up the main structure')
def __init__(self, is_train=True):
#tf.reset_default_graph()
self.graph = tf.Graph()
with self.graph.as_default():
if is_train:
self.x, self.labels = get_batch_data()
self.y = tf.one_hot(self.labels,
depth=10,
axis=1,
dtype=tf.float32)
self.model_builder()
self.loss()
self._summary()
self.tmp = tf.Variable(0, name='tmp', trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(self.final_loss,
global_step=self.tmp)
elif cfg.mask_with_y:
self.x = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 28, 28, 1))
self.y = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 10, 1))
self.model_builder()
else:
self.x = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 28, 28, 1))
self.model_builder()
def __init__(self, is_training=True):
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
self.X, self.labels = get_batch_data(cfg.dataset,
cfg.batch_size,
cfg.num_threads)
self.Y = tf.one_hot(self.labels,
depth=10,
axis=1,
dtype=tf.float32)
self.build_arch()
self.loss()
self._summary()
self.global_step = tf.Variable(0,
name='global_step',
trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(
self.total_loss, global_step=self.global_step)
else:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 28, 28, 1))
self.labels = tf.placeholder(tf.int32,
shape=(cfg.batch_size, ))
self.Y = tf.reshape(self.labels, shape=(cfg.batch_size, 10, 1))
self.build_arch()
tf.logging.info('Setting up the main structure')
def __init__(self, is_training=True):
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
self.X, self.Y = get_batch_data()
self.build_arch()
self.loss()
self.global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate = tf.train.exponential_decay(cfg.learning_rate, self.global_step,
cfg.step_size, cfg.learning_rate_decay,
staircase=True)
tf.summary.scalar('learning rate', learning_rate)
# set up adam optimizer with default setting
self._optimizer = tf.train.AdamOptimizer(learning_rate)
gradidents = self._optimizer.compute_gradients(self.total_loss)
self.train_op = self._optimizer.apply_gradients(gradidents,
global_step=self.global_step)
else:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 28, 28, 1))
self.build_arch()
tf.logging.info('Seting up the main structure')
def __init__(self, is_training=True):
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
self.X, self.labels = get_batch_data()
self.Y = tf.one_hot(self.labels,
depth=10,
axis=1,
dtype=tf.float32)
self.build_arch()
self.loss()
self._summary()
# t_vars = tf.trainable_variables()
self.global_step = tf.Variable(0,
name='global_step',
trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(
self.total_loss,
global_step=self.global_step) # var_list=t_vars)
elif cfg.mask_with_y:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 150, 150, 3))
self.Y = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 10, 1))
self.build_arch()
else:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 150, 150, 3))
self.build_arch()
tf.logging.info('Seting up the main structure')
def __init__(self,
is_training=True,
height=28,
width=28,
channels=1,
num_label=10):
"""
:param is_training: boolean, 训练还是测试
:param height: Integer, the height of inputs.
:param width: Integer, the width of inputs.
:param channels: Integer, the channels of inputs.
:param num_label: Integer, the category number.
"""
self.height = height
self.width = width
self.channels = channels
self.num_label = num_label
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
self.X, self.labels = get_batch_data(
cfg.dataset,
cfg.batch_size,
cfg.num_threads,
train_data_number=cfg.train_data_number,
validation_data_number=cfg.validation_data_number,
test_data_number=cfg.test_data_number)
self.Y = tf.one_hot(self.labels,
depth=self.num_label,
axis=1,
dtype=tf.float32)
self.build_arch()
self.loss()
self._summary()
# t_vars = tf.trainable_variables()
self.global_step = tf.Variable(0,
name='global_step',
trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(
self.total_loss, global_step=self.global_step)
else:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, self.height,
self.width, self.channels))
self.labels = tf.placeholder(tf.int32,
shape=(cfg.batch_size, ))
self.Y = tf.reshape(self.labels,
shape=(cfg.batch_size, self.num_label, 1))
self.build_arch()
tf.logging.info("Setting up {} network structure".format(
'train' if is_training else 'test'))
def evaluation():
num_te_batch = 500 // cfg.batch_size
fd_test_acc = save_to()
with tf.Session() as sess:
saver = tf.train.import_meta_graph(cfg.logdir +
'/model_epoch_0001_step_4719.meta')
saver.restore(sess, cfg.logdir + '/model_epoch_0001_step_4719')
graph = tf.get_default_graph()
for ii in graph.get_collection(name=tf.GraphKeys.QUEUE_RUNNERS):
print(ii)
print(len(graph.get_collection(name=tf.GraphKeys.QUEUE_RUNNERS)))
teX, teY = get_batch_data(cfg.dataset,
cfg.batch_size,
cfg.num_threads,
train_mode='test',
graph=sess.graph)
tf.logging.info('Model restored!')
sess.run(tf.local_variables_initializer())
# sess.run(tf.global_variables_initializer())
test_acc = 0
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord,
sess=sess,
start=True)
for i in tqdm(range(num_te_batch), ncols=70, leave=False, unit='b'):
# print(tf.train.latest_checkpoint('./'))
X = graph.get_tensor_by_name('shuffle_batch:0')
labels = graph.get_tensor_by_name('shuffle_batch:1')
print(len(threads))
accuracy = graph.get_tensor_by_name('acc:0')
tteX, tteY = sess.run([teX, teY])
print(len(threads))
acc = sess.run(accuracy, {X: tteX, labels: tteY})
test_acc += acc
test_acc = test_acc / num_te_batch
fd_test_acc.write(str(test_acc))
fd_test_acc.close()
print('Test accuracy has been saved to ' + cfg.results +
'/test_acc.csv')
coord.request_stop()
print(len(threads))
# for th in threads:
# print(th, '\n')
coord.join(threads)
def train_recon(sess, update, loss, idx_list, raw, model):
recon_loss = 0.0
total_batch = len(idx_list) // args.batch_size
for batch_idx in range(total_batch + 1):
batch_idx_list = utils.get_batch_data([idx_list], batch_idx,
args.batch_size)[0]
if len(batch_idx_list) == 0:
continue
_, tmp_loss = sess.run(
[update, loss],
feed_dict={model.input: raw[batch_idx_list, :]})
recon_loss += tmp_loss
recon_loss = recon_loss / total_batch
return recon_loss
def __init__(self, is_training=True):
if is_training:
self.X, self.Y = get_batch_data()
self.build_arch()
self.loss()
t_vars = tf.trainable_variables()
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(self.total_loss,
var_list=t_vars)
else:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 28, 28, 1))
tf.logging.info('Seting up the main structure')
def train(input_train_x,
input_train_y,
input_dim,
input_aspect,
hidden_size,
batch_size,
embedding_dim,
word_embeddings,
num_layers,
is_shuffle=True):
print("Ready to train")
# AF_LSTM
af_lstm = AF_LSTM(input_dim,
hidden_size,
batch_size,
embedding_dim,
word_embeddings,
num_layers,
is_shuffle=True,
bias=True)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(af_lstm.parameters(), lr=0.001, momentum=0.9)
running_loss = 0.0
for i in range(n_iter):
for x, y, s in get_batch_data(input_train_x,
input_train_y,
input_aspect,
batch_size,
n_iter=n_iter,
is_shuffle=is_shuffle):
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = af_lstm(x, s)
loss = criterion(outputs, y)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 50 == 0:
print('[%d, %5d] loss: %.3f' %
(i + 1, i + 1, running_loss / 50))
running_loss = 0.0
def get_val_loss(net, loss_fn, valid, seq_len, chunk_size):
losses = []
net.eval()
hidden = net.init_hidden(chunk_size)
cum_loss = 0
cum_tgt_words = 0
for i in range(0, valid.shape[0] - 1, seq_len):
input_val, label = get_batch_data(valid, i, seq_len)
predictions, hidden = net(to_variable(input_val),
hidden) # Feed forward
loss = loss_fn(
predictions,
to_variable(label).contiguous().view(-1)).sum() # Compute losses
losses.append(loss.data.cpu().numpy())
hidden = detach_hidden_state(hidden)
cum_loss += loss.data.cpu().numpy()
tgt_word_num_to_predict = label.size(0) * label.size(1)
cum_tgt_words += tgt_word_num_to_predict
return np.asscalar(np.mean(losses)), math.exp(cum_loss / cum_tgt_words)
def train_local(sess, update, loss, c_list, n_list, y_list, raw, model):
local_loss = 0.0
total_batch = len(c_list) // args.batch_size
for batch_idx in range(total_batch + 1):
batch_c_list, batch_n_list, batch_y_list = utils.get_batch_data(
[c_list, n_list, y_list], batch_idx, args.batch_size)
if len(batch_c_list) == 0:
continue
_, tmp_loss = sess.run(
[update, loss],
feed_dict={
model.m_input: raw[batch_c_list, :],
model.n_input: raw[batch_n_list, :],
model.y_handle: batch_y_list
})
local_loss += tmp_loss
local_loss = local_loss / total_batch
return local_loss
def __init__(self, is_training=True):
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
self.X, self.Y = get_batch_data()
self.build_arch()
self.loss()
# t_vars = tf.trainable_variables()
self.optimizer = tf.train.AdamOptimizer()
self.global_step = tf.Variable(0, name='global_step', trainable=False)
self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step) # var_list=t_vars)
else:
self.X = tf.placeholder(tf.float32,
shape=(cfg.batch_size, 28, 28, 1))
self.build_arch()
tf.logging.info('Seting up the main structure')
def __init__(self, is_training=True):
self.graph = tf.Graph()
with self.graph.as_default():
if not cfg.use_multimnist:
self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads)
self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32)
else:
self.X, self.labels = get_batch_data_multimnist(cfg.batch_size, cfg.num_threads)
self.Y = tf.cast(self.labels, dtype=tf.float32)
self.keep_prob = tf.placeholder_with_default(1.0, shape=(), name='keep_prob')
self.build_arch()
self.loss()
self._summary()
# t_vars = tf.trainable_variables()
self.global_step = tf.Variable(0, name='global_step', trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step) # var_list=t_vars)
tf.logging.info('Seting up the main structure')
def train_attr_struc(sess, data_type):
attr_struc_loss = 0.0
a_list = []
s_list = []
y_list = []
if data_type == 'user':
update = uas_update
loss = uas_loss
cache = user_user_cache
deg_table = user_u_deg
attr_raw = user_attr_raw
struc_raw = user_struc_raw
attr_model = model.user_attr
struc_model = model.user_struc
adr = model.uadr
sdr = model.usdr
y_handle = model.uy_handle
else: # item data type
update = ias_update
loss = ias_loss
cache = item_item_cache
deg_table = item_i_deg
attr_raw = item_attr_raw
struc_raw = item_struc_raw
attr_model = model.item_attr
struc_model = model.item_struc
adr = model.iadr
sdr = model.isdr
y_handle = model.iy_handle
attr_dr2, struc_dr2 = sess.run([adr, sdr],
feed_dict={
attr_model.input: attr_raw,
struc_model.input: struc_raw
})
struc_index = nmslib.init(method='hnsw', space='negdotprod')
struc_index.addDataPointBatch(struc_dr2)
struc_index.createIndex({'post': 2}, print_progress=False)
attr_struc_neighbours = struc_index.knnQueryBatch(attr_dr2,
k=args.samp_num,
num_threads=4)
for node_id, struc_neigh in enumerate(attr_struc_neighbours):
# pos_set = cache[node_id] | set(struc_neigh[0])
pos_set = set(struc_neigh[0]) | set([node_id])
pos_num = len(pos_set)
candidate_set = set(deg_table[np.random.randint(args.table_size,
size=3 * pos_num)])
neg_list = list(candidate_set - pos_set)
if len(neg_list) < pos_num:
continue
a_list.extend([node_id] * 2 * pos_num)
s_list.extend(list(pos_set))
s_list.extend(neg_list[:pos_num])
y_list.extend([1] * pos_num)
y_list.extend([0] * pos_num)
attr_index = nmslib.init(method='hnsw', space='negdotprod')
attr_index.addDataPointBatch(attr_dr2)
attr_index.createIndex({'post': 2}, print_progress=False)
struc_attr_neighbours = attr_index.knnQueryBatch(struc_dr2,
k=args.samp_num,
num_threads=4)
for node_id, attr_neigh in enumerate(struc_attr_neighbours):
# pos_set = cache[node_id] | set(attr_neigh[0])
pos_set = set(attr_neigh[0]) | set([node_id])
pos_num = len(pos_set)
candidate_set = set(deg_table[np.random.randint(args.table_size,
size=3 * pos_num)])
neg_list = list(candidate_set - pos_set)
if len(neg_list) < pos_num:
continue
s_list.extend([node_id] * 2 * pos_num)
a_list.extend(list(pos_set))
a_list.extend(neg_list[:pos_num])
y_list.extend([1] * pos_num)
y_list.extend([0] * pos_num)
rand_seed = random.randint(0, 10000000)
random.seed(rand_seed)
random.shuffle(a_list)
random.seed(rand_seed)
random.shuffle(s_list)
random.seed(rand_seed)
random.shuffle(y_list)
total_batch = len(a_list) // args.batch_size
for batch_idx in range(total_batch + 1):
batch_a_list, batch_s_list, batch_y_list = utils.get_batch_data(
[a_list, s_list, y_list], batch_idx, args.batch_size)
if len(batch_a_list) == 0:
continue
_, tmp_loss = sess.run(
[update, loss],
feed_dict={
attr_model.input: attr_raw[batch_a_list, :],
struc_model.input: struc_raw[batch_s_list, :],
y_handle: batch_y_list
})
attr_struc_loss += tmp_loss
attr_struc_loss = attr_struc_loss / total_batch
return attr_struc_loss
def train(args):
def degrees_normalization(node_degree):
norm = sum([
math.pow(node_degree[i], args.power)
for i in range(len(node_degree))
])
sampling_table = np.zeros(int(args.table_size), dtype=np.uint32)
p = 0
i = 0
for j in range(len(node_degree)):
p += float(math.pow(node_degree[j], args.power)) / norm
while i < args.table_size and float(i) / args.table_size < p:
sampling_table[i] = j
i += 1
return sampling_table
logger = logging.getLogger('mylogger')
logger.setLevel(logging.DEBUG)
fh = logging.FileHandler('{}.log'.format(args.dataset), mode='w')
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
user_n2i, user_i2n = read_node_id(
os.path.join('../data', args.dataset, 'user_id.tsv'))
item_n2i, item_i2n = read_node_id(
os.path.join('../data', args.dataset, 'item_id.tsv'))
adj_user_n2i, adj_user_i2n = read_node_id(
os.path.join('../data', args.dataset, 'adjlist_user_id.tsv'))
adj_item_n2i, adj_item_i2n = read_node_id(
os.path.join('../data', args.dataset, 'adjlist_item_id.tsv'))
user_list = [i for i in range(len(user_n2i))]
item_list = [i for i in range(len(item_n2i))]
with open(os.path.join('../data', args.dataset, 'user_attr.pkl'),
'rb') as f:
user_attr_raw = pickle.load(f)
with open(os.path.join('../data', args.dataset, 'item_attr.pkl'),
'rb') as f:
item_attr_raw = pickle.load(f)
struc_raw = {}
with open(os.path.join('../data', args.dataset,
'emb_{}.txt'.format(args.dataset)),
'r',
encoding='utf-8') as f:
line = f.readline(
) # header line 1 (skip this header line): node_num, emb_dim
line = f.readline(
) # header line 2 (skip this header line): </s>(invalid token) embedding
while True:
line = f.readline()
if not line:
break
line = line.strip().split()
node_id = int(line[0]) # adjlist.txt node id
emb = np.array([float(v) for v in line[1:]])
struc_raw[node_id] = emb
user_struc_raw = []
for user_id in range(len(user_n2i)):
user_struc_raw.append(struc_raw[user_id])
item_struc_raw = []
for item_id in range(len(user_n2i), len(user_n2i) + len(item_n2i)):
item_struc_raw.append(struc_raw[item_id])
user_struc_raw = np.array(user_struc_raw)
item_struc_raw = np.array(item_struc_raw)
del struc_raw
with open(os.path.join('../data', args.dataset, 'adjlist.txt'),
'r',
encoding='utf-8') as f:
user_adjlist_dict = {}
item_adjlist_dict = {}
while True:
line = f.readline()
if not line:
break
line = line.strip().split()
if int(line[0]) < len(user_n2i):
user_id = int(line[0])
user_adjlist_dict[user_id] = set(
[item_n2i[adj_item_i2n[int(i)]] for i in line[1:]])
else:
item_id = item_n2i[adj_item_i2n[int(line[0])]]
item_adjlist_dict[item_id] = set([int(i) for i in line[1:]])
with open(os.path.join('../data', args.dataset, 'train.csv'),
'r',
encoding='utf-8') as f:
user_pos_train = {}
item_pos_train = {}
while True:
line = f.readline()
if not line:
break
line = line.strip().split(',')
user_pos_train.setdefault(int(line[0]), set()).add(int(line[1]))
item_pos_train.setdefault(int(line[1]), set()).add(int(line[0]))
with open(os.path.join('../data', args.dataset, 'valid.tsv'),
'r',
encoding='utf-8') as f:
u_list_valid = []
i_list_valid = []
y_list_valid = []
while True:
line = f.readline()
if not line:
break
line = line.strip().split('\t')
u_list_valid.append(int(line[0]))
i_list_valid.append(int(line[1]))
y_list_valid.append(float(line[2]))
logger.info('DATA LOADING DONE')
user_user_cache = []
item_item_cache = []
user_i_deg = []
item_u_deg = []
user_u_deg = []
item_i_deg = []
for user_id in user_list:
user_i_deg.append(len(user_adjlist_dict[user_id]))
tmp_user_cache = set()
for item_id in user_adjlist_dict[user_id]:
tmp_user_cache = tmp_user_cache | item_adjlist_dict[item_id]
user_user_cache.append(tmp_user_cache)
user_u_deg.append(len(tmp_user_cache))
for item_id in item_list:
item_u_deg.append(len(item_adjlist_dict[item_id]))
tmp_item_cache = set()
for user_id in item_adjlist_dict[item_id]:
tmp_item_cache = tmp_item_cache | user_adjlist_dict[user_id]
item_item_cache.append(tmp_item_cache)
item_i_deg.append(len(item_item_cache[item_id]))
user_i_deg = degrees_normalization(np.array(user_i_deg))
item_u_deg = degrees_normalization(np.array(item_u_deg))
user_u_deg = degrees_normalization(np.array(user_u_deg))
item_i_deg = degrees_normalization(np.array(item_i_deg))
del user_adjlist_dict
del item_adjlist_dict
logger.info('INTRA-PARTITION NETWORK SYNTHESIZED')
if args.dataset == 'ami':
dim_list = [[args.attr_dim_0_u, args.attr_dim_1, args.attr_dim_2],
[args.struc_dim_0, args.struc_dim_1, args.struc_dim_2],
[args.attr_dim_0_v, args.attr_dim_1, args.attr_dim_2],
[args.struc_dim_0, args.struc_dim_1, args.struc_dim_2]]
model = jointmodel.JointModelAmi(dim_list, None)
elif args.dataset == 'mvl':
dim_list = [[
args.attr_dim_0_u, args.attr_dim_1, args.attr_dim_2,
args.attr_dim_3
],
[
args.struc_dim_0, args.struc_dim_1, args.struc_dim_2,
args.struc_dim_3
],
[
args.attr_dim_0_v, args.attr_dim_1, args.attr_dim_2,
args.attr_dim_3
],
[
args.struc_dim_0, args.struc_dim_1, args.struc_dim_2,
args.struc_dim_3
]]
model = jointmodel.JointModelMvl(dim_list, None)
else:
sys.exit(1)
ua_recon_loss = tf.reduce_mean([
args.lambda_0 * model.user_attr.recon_loss,
args.lambda_11 * model.user_attr.en_l2_loss,
args.lambda_11 * model.user_attr.de_l2_loss
])
ua_recon_update = tf.train.AdamOptimizer(
learning_rate=args.intra_lr).minimize(
ua_recon_loss,
var_list=model.user_attr.vars_en + model.user_attr.vars_de)
us_recon_loss = tf.reduce_mean([
args.lambda_1 * model.user_struc.recon_loss,
args.lambda_11 * model.user_struc.en_l2_loss,
args.lambda_11 * model.user_struc.de_l2_loss,
])
us_recon_update = tf.train.AdamOptimizer(
learning_rate=args.intra_lr).minimize(
us_recon_loss,
var_list=model.user_struc.vars_en + model.user_struc.vars_de)
ia_recon_loss = tf.reduce_mean([
args.lambda_2 * model.item_attr.recon_loss,
args.lambda_11 * model.item_attr.en_l2_loss,
args.lambda_11 * model.item_attr.de_l2_loss
])
ia_recon_update = tf.train.AdamOptimizer(
learning_rate=args.intra_lr).minimize(
ia_recon_loss,
var_list=model.item_attr.vars_en + model.item_attr.vars_de)
is_recon_loss = tf.reduce_mean([
args.lambda_3 * model.item_struc.recon_loss,
args.lambda_11 * model.item_struc.en_l2_loss,
args.lambda_11 * model.item_struc.de_l2_loss
])
is_recon_update = tf.train.AdamOptimizer(
learning_rate=args.intra_lr).minimize(
is_recon_loss,
var_list=model.item_struc.vars_en + model.item_struc.vars_de)
ua_local_loss = tf.reduce_mean([
args.lambda_4 * model.user_attr.local_loss,
args.lambda_11 * model.user_attr.en_l2_loss,
])
ua_local_update = tf.train.AdamOptimizer(
learning_rate=args.intra_lr).minimize(ua_local_loss,
var_list=model.user_attr.vars_en)
us_local_loss = tf.reduce_mean([
args.lambda_5 * model.user_struc.local_loss,
args.lambda_11 * model.user_struc.en_l2_loss
])
us_local_update = tf.train.AdamOptimizer(
learning_rate=args.intra_lr).minimize(
us_local_loss, var_list=model.user_struc.vars_en)
uas_loss = tf.reduce_mean([
args.lambda_6 * model.uas_loss,
args.lambda_11 * model.user_attr.en_l2_loss,
args.lambda_11 * model.user_attr.dr_l2_loss,
args.lambda_11 * model.user_struc.en_l2_loss,
args.lambda_11 * model.user_struc.dr_l2_loss
])
uas_update = tf.train.AdamOptimizer(learning_rate=args.intra_lr).minimize(uas_loss,
var_list=model.user_attr.vars_en+model.user_attr.vars_dr+\
model.user_struc.vars_en+model.user_struc.vars_dr)
ia_local_loss = tf.reduce_mean([
args.lambda_7 * model.item_attr.local_loss,
args.lambda_11 * model.item_attr.en_l2_loss,
])
ia_local_update = tf.train.AdamOptimizer(
learning_rate=args.intra_lr).minimize(ia_local_loss,
var_list=model.item_attr.vars_en)
is_local_loss = tf.reduce_mean([
args.lambda_8 * model.item_struc.local_loss,
args.lambda_11 * model.item_struc.en_l2_loss
])
is_local_update = tf.train.AdamOptimizer(
learning_rate=args.intra_lr).minimize(
is_local_loss, var_list=model.item_struc.vars_en)
ias_loss = tf.reduce_mean([
args.lambda_9 * model.ias_loss,
args.lambda_11 * model.item_attr.en_l2_loss,
args.lambda_11 * model.item_attr.dr_l2_loss,
args.lambda_11 * model.item_struc.en_l2_loss,
args.lambda_11 * model.item_struc.dr_l2_loss
])
ias_update = tf.train.AdamOptimizer(learning_rate=args.intra_lr).minimize(ias_loss,
var_list=model.item_attr.vars_en+model.item_attr.vars_dr+\
model.item_struc.vars_en+model.item_struc.vars_dr)
global_loss = tf.reduce_mean([
args.lambda_10 * model.pred_loss,
args.lambda_11 * model.user_attr.en_l2_loss,
args.lambda_11 * model.user_struc.en_l2_loss,
args.lambda_11 * model.item_attr.en_l2_loss,
args.lambda_11 * model.item_struc.en_l2_loss
])
global_update = tf.train.AdamOptimizer(learning_rate=args.lr).minimize(global_loss,
var_list=model.user_attr.vars_en+\
model.user_struc.vars_en+\
model.item_attr.vars_en+\
model.item_struc.vars_en)
# INTER-PARTITION PROXIMITY
def generate_candidate_train():
u_list = []
i_list = []
y_list = []
for user in user_list:
pos_set = user_pos_train[user]
pos_num = len(pos_set)
candidate_set = set(item_u_deg[np.random.randint(args.table_size,
size=3 *
pos_num)])
neg_list = list(candidate_set - pos_set)
if len(neg_list) < pos_num:
continue
u_list.extend([user] * 2 * pos_num)
i_list.extend(list(pos_set))
i_list.extend(neg_list[:pos_num])
y_list.extend([1] * pos_num)
y_list.extend([0] * pos_num)
for item in item_list:
pos_set = item_pos_train[item]
pos_num = len(pos_set)
candidate_set = set(user_i_deg[np.random.randint(args.table_size,
size=3 *
pos_num)])
neg_list = list(candidate_set - pos_set)
if len(neg_list) < pos_num:
continue
u_list.extend(list(pos_set))
u_list.extend(neg_list[:pos_num])
i_list.extend([item] * 2 * pos_num)
y_list.extend([1] * pos_num)
y_list.extend([0] * pos_num)
rand_seed = random.randint(0, 10000000)
random.seed(rand_seed)
random.shuffle(u_list)
random.seed(rand_seed)
random.shuffle(i_list)
random.seed(rand_seed)
random.shuffle(y_list)
return u_list, i_list, y_list
# FIRST-ORDER PROXIMITY
def generate_candidate_local_train(cache, deg_table):
c_list = []
n_list = []
y_list = []
for idx, pos_set in enumerate(cache):
if len(pos_set) == 1:
continue
pos_num = len(pos_set)
candidate_set = set(deg_table[np.random.randint(args.table_size,
size=3 * pos_num)])
neg_list = list(candidate_set - pos_set)
pos_set.remove(idx)
pos_num = pos_num - 1
if len(neg_list) < pos_num:
continue
c_list.extend([idx] * 2 * pos_num)
n_list.extend(list(pos_set))
n_list.extend(neg_list[:pos_num])
y_list.extend([1] * pos_num)
y_list.extend([0] * pos_num)
rand_seed = random.randint(0, 10000000)
random.seed(rand_seed)
random.shuffle(c_list)
random.seed(rand_seed)
random.shuffle(n_list)
random.seed(rand_seed)
random.shuffle(y_list)
return c_list, n_list, y_list
# RECONSTRUCTION LOSS
def train_recon(sess, update, loss, idx_list, raw, model):
recon_loss = 0.0
total_batch = len(idx_list) // args.batch_size
for batch_idx in range(total_batch + 1):
batch_idx_list = utils.get_batch_data([idx_list], batch_idx,
args.batch_size)[0]
if len(batch_idx_list) == 0:
continue
_, tmp_loss = sess.run(
[update, loss],
feed_dict={model.input: raw[batch_idx_list, :]})
recon_loss += tmp_loss
recon_loss = recon_loss / total_batch
return recon_loss
# FIRST-ORDER PROXIMITY
def train_local(sess, update, loss, c_list, n_list, y_list, raw, model):
local_loss = 0.0
total_batch = len(c_list) // args.batch_size
for batch_idx in range(total_batch + 1):
batch_c_list, batch_n_list, batch_y_list = utils.get_batch_data(
[c_list, n_list, y_list], batch_idx, args.batch_size)
if len(batch_c_list) == 0:
continue
_, tmp_loss = sess.run(
[update, loss],
feed_dict={
model.m_input: raw[batch_c_list, :],
model.n_input: raw[batch_n_list, :],
model.y_handle: batch_y_list
})
local_loss += tmp_loss
local_loss = local_loss / total_batch
return local_loss
# ATTR-STRUC CORRELATION
def train_attr_struc(sess, data_type):
attr_struc_loss = 0.0
a_list = []
s_list = []
y_list = []
if data_type == 'user':
update = uas_update
loss = uas_loss
cache = user_user_cache
deg_table = user_u_deg
attr_raw = user_attr_raw
struc_raw = user_struc_raw
attr_model = model.user_attr
struc_model = model.user_struc
adr = model.uadr
sdr = model.usdr
y_handle = model.uy_handle
else: # item data type
update = ias_update
loss = ias_loss
cache = item_item_cache
deg_table = item_i_deg
attr_raw = item_attr_raw
struc_raw = item_struc_raw
attr_model = model.item_attr
struc_model = model.item_struc
adr = model.iadr
sdr = model.isdr
y_handle = model.iy_handle
attr_dr2, struc_dr2 = sess.run([adr, sdr],
feed_dict={
attr_model.input: attr_raw,
struc_model.input: struc_raw
})
struc_index = nmslib.init(method='hnsw', space='negdotprod')
struc_index.addDataPointBatch(struc_dr2)
struc_index.createIndex({'post': 2}, print_progress=False)
attr_struc_neighbours = struc_index.knnQueryBatch(attr_dr2,
k=args.samp_num,
num_threads=4)
for node_id, struc_neigh in enumerate(attr_struc_neighbours):
# pos_set = cache[node_id] | set(struc_neigh[0])
pos_set = set(struc_neigh[0]) | set([node_id])
pos_num = len(pos_set)
candidate_set = set(deg_table[np.random.randint(args.table_size,
size=3 * pos_num)])
neg_list = list(candidate_set - pos_set)
if len(neg_list) < pos_num:
continue
a_list.extend([node_id] * 2 * pos_num)
s_list.extend(list(pos_set))
s_list.extend(neg_list[:pos_num])
y_list.extend([1] * pos_num)
y_list.extend([0] * pos_num)
attr_index = nmslib.init(method='hnsw', space='negdotprod')
attr_index.addDataPointBatch(attr_dr2)
attr_index.createIndex({'post': 2}, print_progress=False)
struc_attr_neighbours = attr_index.knnQueryBatch(struc_dr2,
k=args.samp_num,
num_threads=4)
for node_id, attr_neigh in enumerate(struc_attr_neighbours):
# pos_set = cache[node_id] | set(attr_neigh[0])
pos_set = set(attr_neigh[0]) | set([node_id])
pos_num = len(pos_set)
candidate_set = set(deg_table[np.random.randint(args.table_size,
size=3 * pos_num)])
neg_list = list(candidate_set - pos_set)
if len(neg_list) < pos_num:
continue
s_list.extend([node_id] * 2 * pos_num)
a_list.extend(list(pos_set))
a_list.extend(neg_list[:pos_num])
y_list.extend([1] * pos_num)
y_list.extend([0] * pos_num)
rand_seed = random.randint(0, 10000000)
random.seed(rand_seed)
random.shuffle(a_list)
random.seed(rand_seed)
random.shuffle(s_list)
random.seed(rand_seed)
random.shuffle(y_list)
total_batch = len(a_list) // args.batch_size
for batch_idx in range(total_batch + 1):
batch_a_list, batch_s_list, batch_y_list = utils.get_batch_data(
[a_list, s_list, y_list], batch_idx, args.batch_size)
if len(batch_a_list) == 0:
continue
_, tmp_loss = sess.run(
[update, loss],
feed_dict={
attr_model.input: attr_raw[batch_a_list, :],
struc_model.input: struc_raw[batch_s_list, :],
y_handle: batch_y_list
})
attr_struc_loss += tmp_loss
attr_struc_loss = attr_struc_loss / total_batch
return attr_struc_loss
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.global_variables_initializer())
logger.info('INITIALIZATION DONE')
best_valid_loss = np.finfo(float).max
for epoch in range(1, args.epochs + 1):
# RECONSTRUCTION LOSS
epoch_ua_recon_loss = train_recon(sess, ua_recon_update, ua_recon_loss,
user_list, user_attr_raw,
model.user_attr)
epoch_us_recon_loss = train_recon(sess, us_recon_update, us_recon_loss,
user_list, user_struc_raw,
model.user_struc)
epoch_ia_recon_loss = train_recon(sess, ia_recon_update, ia_recon_loss,
item_list, item_attr_raw,
model.item_attr)
epoch_is_recon_loss = train_recon(sess, is_recon_update, is_recon_loss,
item_list, item_struc_raw,
model.item_struc)
# FIRST-ORDER PROXIMITY
user_c_list, user_n_list, user_y_list = generate_candidate_local_train(
copy.deepcopy(user_user_cache), user_u_deg)
epoch_ua_local_loss = train_local(sess, ua_local_update, ua_local_loss,
user_c_list, user_n_list,
user_y_list, user_attr_raw,
model.user_attr)
epoch_us_local_loss = train_local(sess, us_local_update, us_local_loss,
user_c_list, user_n_list,
user_y_list, user_struc_raw,
model.user_struc)
item_c_list, item_n_list, item_y_list = generate_candidate_local_train(
copy.deepcopy(item_item_cache), item_i_deg)
epoch_ia_local_loss = train_local(sess, ia_local_update, ia_local_loss,
item_c_list, item_n_list,
item_y_list, item_attr_raw,
model.item_attr)
epoch_is_local_loss = train_local(sess, is_local_update, is_local_loss,
item_c_list, item_n_list,
item_y_list, item_struc_raw,
model.item_struc)
del user_c_list, user_n_list, user_y_list, item_c_list, item_n_list, item_y_list
# ATTR-STRUC CORRELATION
epoch_uas_loss = train_attr_struc(sess, 'user')
epoch_ias_loss = train_attr_struc(sess, 'item')
# INTER-PARTITION PROXIMITY
train_u_list, train_i_list, train_y_list = generate_candidate_train()
total_batch = len(train_u_list) // args.batch_size
train_epoch_loss = 0.0
for batch_idx in range(total_batch + 1):
batch_u_list, batch_i_list, batch_y_list = utils.get_batch_data(
[train_u_list, train_i_list, train_y_list], batch_idx,
args.batch_size)
if len(batch_u_list) == 0:
continue
_, tmp_loss = sess.run(
[global_update, global_loss],
feed_dict={
model.user_attr.input: user_attr_raw[batch_u_list, :],
model.user_struc.input: user_struc_raw[batch_u_list, :],
model.item_attr.input: item_attr_raw[batch_i_list, :],
model.item_struc.input: item_struc_raw[batch_i_list, :],
model.y_handle: batch_y_list
})
train_epoch_loss += tmp_loss
train_epoch_loss = train_epoch_loss / total_batch
valid_epoch_loss = 0.0
total_batch = len(u_list_valid) // args.batch_size
for batch_idx in range(total_batch + 1):
batch_u_list, batch_i_list, batch_y_list = utils.get_batch_data(
[u_list_valid, i_list_valid, y_list_valid], batch_idx,
args.batch_size)
if len(batch_u_list) == 0:
continue
tmp_loss = sess.run(global_loss,
feed_dict={
model.user_attr.input:
user_attr_raw[batch_u_list, :],
model.user_struc.input:
user_struc_raw[batch_u_list, :],
model.item_attr.input:
item_attr_raw[batch_i_list, :],
model.item_struc.input:
item_struc_raw[batch_i_list, :],
model.y_handle:
batch_y_list
})
valid_epoch_loss += tmp_loss
if valid_epoch_loss < best_valid_loss:
best_valid_loss = valid_epoch_loss
model.save_model(sess, '{}_best_model.pkl'.format(args.dataset))
logger.info('SAVED BEST MODEL AT EPOCH {}'.format(epoch))
model.save_model(sess, '{}_final_model.pkl'.format(args.dataset))
sess.close()
logging.shutdown()
nr_classes = len(labels)
batch_size = 64
epochs = 10
rate = 16000 #16000fps - 0.0625ms per frame
stepsize = 64 #for spectogram reduction
freq_bins = 32
frame_size = (int)((0.060 * rate) / stepsize) #30ms
frame_step = (int)((0.030 * rate) / stepsize) #15ms
print('Frame size: {}, frame step size: {}'.format(frame_size, frame_step))
# preprocess data
training_set = TimitDataset('./data', labels, stepsize, freq_bins, frame_step, frame_size)
trainloader = get_batch_data(training_set, batch_size)
test_set = TimitDataset('./data', labels, stepsize, freq_bins, frame_step, frame_size, traintest='TEST')
testloader = get_batch_data(test_set, batch_size)
device = torch.cuda.device(0)
capsnet = CapsuleNet(num_classes=nr_classes)
capsnet.cuda()
capsnet_optimizer = optim.Adam(capsnet.parameters())
convnet = ConvNet(num_classes = nr_classes)
convnet.cuda()
convnet_loss = torch.nn.MSELoss()
def main():
print("loading model...")
generator = GEN(ITEM_NUM,USER_NUM,EMB_DIM,lamda = 0.0 / BATCH_SIZE,param = None,initdelta= INIT_DELTA,
learning_rate = 0.001)
discriminator = DIS(ITEM_NUM,USER_NUM,EMB_DIM,lamda = 0.1/BATCH_SIZE,param=None,initdelta = INIT_DELTA,
learning_rate = 0.001)
config = tf.ConfigProto()
config.gpu_options.allow_growth=True
with tf.Session(config=config) as sess:
sess.run(tf.global_variables_initializer())
print("gen ",simple_test(sess,generator))
print("dis ",simple_test(sess,discriminator))
dis_log = open(workdir + 'dis_log.txt','w')
gen_log = open(workdir + 'gen_log.txt','w')
best = 0.
for epoch in range(15):
if epoch >= 0:
for d_epoch in range(100):
if d_epoch % 5 == 0:
generate_for_d(sess,generator,DIS_TRAIN_FILE)
train_size = ut.file_len(DIS_TRAIN_FILE)
index = 1
while True:
if index > train_size:
break
if index + BATCH_SIZE <= train_size + 1:
input_user,input_item,input_label = ut.get_batch_data(DIS_TRAIN_FILE,index,BATCH_SIZE)
else:
input_user,input_item,input_label = ut.get_batch_data(DIS_TRAIN_FILE,index,train_size-index+1)
index += BATCH_SIZE
_ = sess.run(discriminator.d_updates,feed_dict={
discriminator.u:input_user,discriminator.i:input_item,discriminator.label:input_label
})
for g_epoch in range(50):
for u in user_pos_train:
sample_lambda = 0.2
pos = user_pos_train[u]
rating = sess.run(generator.all_logits,{generator.u:u})
exp_rating = np.exp(rating)
prob = exp_rating / np.sum(exp_rating)
pn = (1-sample_lambda) * prob
pn[pos] += sample_lambda * 1.0 / len(pos)
sample = np.random.choice(np.arange(ITEM_NUM), 2 * len(pos), p=pn)
reward = sess.run(discriminator.reward, {discriminator.u: u, discriminator.i: sample})
reward = reward * prob[sample] / pn[sample]
_ = sess.run(generator.gan_updates,
{generator.u: u, generator.i: sample, generator.reward: reward})
result = simple_test(sess, generator)
print("epoch ", epoch, "gen: ", result)
buf = '\t'.join([str(x) for x in result])
gen_log.write(str(epoch) + '\t' + buf + '\n')
gen_log.flush()
p_5 = result[1]
if p_5 > best:
print('best: ', result)
best = p_5
gen_log.close()
dis_log.close()
# cfg['sess_path'] = '/Users/jiayu/PycharmProjects/NLU/run/1523829796'
# cfg['batch_size'] = 50
# cfg['max_length'] = 30
# load dict
with open('word2id_dict.pkl', 'rb') as f:
word2id_dict = pickle.load(f)
id2word_dict = {}
for item in word2id_dict.items():
id2word_dict[item[1]] = item[0]
if cfg['t']:
train_path = "data/sentences.train"
train_text = load_data(train_path)
train_batch_data = get_batch_data(train_text[:cfg['text_num']],
word2id_dict=word2id_dict,
batch_size=cfg['batch_size'],
max_length=cfg['max_length'])
model = RNNmodel(vocab_len=cfg['vocab_len'],
embedding_size=cfg['embedding_dim'],
hidden_size=cfg['hidden_size'],
sequency_length=cfg['max_length'],
batch_size=cfg['batch_size'],
is_add_layer=cfg['is_add_layer'])
result_path = train(model=model,
cfg=cfg,
id2word_dict=id2word_dict,
train_data=train_batch_data)
if cfg['e']:
def main(_):
coord_add = [[[8., 8.], [12., 8.], [16., 8.]],
[[8., 12.], [12., 12.], [16., 12.]],
[[8., 16.], [12., 16.], [16., 16.]]]
with tf.Graph().as_default():
batch_x, batch_labels, datanum = utils.get_batch_data(
is_training=False)
num_batches_test = math.ceil(datanum /
cfg.batch_size) #get the ceiling int
output = net.build_arch(batch_x, coord_add, is_train=False)
predict = tf.argmax(output, axis=1)
batch_acc = net.test_accuracy(output, batch_labels)
saver = tf.train.Saver()
step = 0
summaries = []
summaries.append(tf.summary.scalar('accuracy', batch_acc))
summary_op = tf.summary.merge(summaries)
sess = tf.Session()
tf.train.start_queue_runners(sess=sess)
ckpt = tf.train.get_checkpoint_state(cfg.logdir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print(ckpt.model_checkpoint_path)
summary_writer = tf.summary.FileWriter(cfg.test_logdir,
graph=sess.graph)
for epoch in range(cfg.test_epoch):
accuracy_sum = 0
for i in range(num_batches_test):
y_pred, y, batch_acc_v, summary_str = sess.run(
[predict, batch_labels, batch_acc, summary_op])
if i % 10 == 0:
print('%d/%d batches are tested.' %
(step, num_batches_test))
#print("labels:\n",batch_labels)
print("Y:\n", y)
print("Y_prediction:", batch_acc_v, "\n", y_pred)
summary_writer.add_summary(summary_str, step)
accuracy_sum += batch_acc_v
step += 1
if i == 0:
y_pred1 = y_pred
label1 = y
else:
y_pred1 = np.concatenate((y_pred1, y_pred), axis=0)
label1 = np.concatenate((label1, y), axis=0)
#print("Label:",np.shape(label1),"\n", label1)
ave_acc = accuracy_sum / num_batches_test
# print("The last batch----Y:",np.shape(y),"\n", y)
# print("Y_prediction:", batch_acc_v, "\n", y_pred)
print(epoch, 'epoch: average accuracy is %f' % ave_acc)
print(np.shape(y_pred1), ",", datanum)
label1 = label1[:datanum]
y_pred1 = y_pred1[:datanum]
print("label:", np.shape(label1))
trade_data.out_indi_data(cfg.test_dataset,
y_pred1,
datalen=cfg.image_size)
def main():
print "load model..."
param = cPickle.load(open(workdir + "model_dns_ori.pkl"))
generator = GEN(ITEM_NUM,
USER_NUM,
EMB_DIM,
lamda=0.0 / BATCH_SIZE,
param=None,
initdelta=INIT_DELTA,
learning_rate=0.001)
discriminator = DIS(ITEM_NUM,
USER_NUM,
EMB_DIM,
lamda=0.1 / BATCH_SIZE,
param=None,
initdelta=INIT_DELTA,
learning_rate=0.001)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.global_variables_initializer())
print "gen ", simple_test(sess, generator)
print "dis ", simple_test(sess, discriminator)
dis_log = open(workdir + 'dis_log.txt', 'w')
gen_log = open(workdir + 'gen_log.txt', 'w')
# minimax training
best = 0.
for epoch in range(300):
if epoch >= 0:
for d_epoch in range(100):
if d_epoch % 5 == 0:
generate_for_d(sess, generator, DIS_TRAIN_FILE)
train_size = ut.file_len(DIS_TRAIN_FILE)
index = 1
while True:
if index > train_size:
break
if index + BATCH_SIZE <= train_size + 1:
input_user, input_item, input_label = ut.get_batch_data(
DIS_TRAIN_FILE, index, BATCH_SIZE)
else:
input_user, input_item, input_label = ut.get_batch_data(
DIS_TRAIN_FILE, index, train_size - index + 1)
index += BATCH_SIZE
_ = sess.run(discriminator.d_updates,
feed_dict={
discriminator.u: input_user,
discriminator.i: input_item,
discriminator.label: input_label
})
# Train G
for g_epoch in range(50): # 50
for u in user_pos_train:
sample_lambda = 0.2
pos = user_pos_train[u]
rating = sess.run(generator.all_logits, {generator.u: u})
exp_rating = np.exp(rating)
prob = exp_rating / np.sum(
exp_rating) # prob is generator distribution p_\theta
pn = (1 - sample_lambda) * prob
pn[pos] += sample_lambda * 1.0 / len(pos)
# Now, pn is the Pn in importance sampling, prob is generator distribution p_\theta
sample = np.random.choice(np.arange(ITEM_NUM),
2 * len(pos),
p=pn)
###########################################################################
# Get reward and adapt it with importance sampling
###########################################################################
reward = sess.run(discriminator.reward, {
discriminator.u: u,
discriminator.i: sample
})
reward = reward * prob[sample] / pn[sample]
###########################################################################
# Update G
###########################################################################
_ = sess.run(
generator.gan_updates, {
generator.u: u,
generator.i: sample,
generator.reward: reward
})
result = simple_test(sess, generator)
print "epoch ", epoch, "gen: ", result
buf = '\t'.join([str(x) for x in result])
gen_log.write(str(epoch) + '\t' + buf + '\n')
gen_log.flush()
p_5 = result[4]
if p_5 > best:
print 'best: ', result
best = p_5
generator.save_model(sess, "ml-100k/gan_generator.pkl")
gen_log.close()
dis_log.close()
g_optimizer = torch.optim.SGD(
discriminator.parameters(), lr=0.001, momentum=0.9)
for epoch in range(15):
if epoch >= 0:
for d_epoch in range(100):
if d_epoch % 5 == 0:
generate_for_d(generator, DIS_TRAIN_FILE)
train_size = ut.file_len(DIS_TRAIN_FILE)
index = 1
while True:
if index > train_size:
break
if index + BATCH_SIZE <= train_size + 1:
users, items, labels = ut.get_batch_data(
DIS_TRAIN_FILE, index, BATCH_SIZE)
else:
users, items, labels = ut.get_batch_data(
DIS_TRAIN_FILE, index, train_size - index + 1)
loss_d = discriminator(users, items, labels)
d_optimizer.zero_grad()
loss_d.backward()
d_optimizer.step()
for g_epoch in range(50):
for user in user_pos_train:
sample_lambda = 0.2
pos = user_pos_train[user]
rating = generator.all_logits(user)
def __init__(self, is_training = True):
self.graph = tf.Graph()
with self.graph.as_default():
if is_training:
self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads)
self.Y = tf.one_hot(self.labels, depth = 10, axis = 1, dtype = tf.float32) #depth = 10 for 10 classes
self.build_arch()
self.loss()
self.summary()
self.global_step = tf.Variable(0,name='global_step',trainable=False)
self.optimizer = tf.train.AdamOptimizer()
self.train_op = self.optimizer.minimize(self.total_loss, global_step = self.global_step)
else:
#Which is either Testing or Validation
self.X = tf.placeholder(tf.float32, shape = (cfg.batch_size,28,28,1)) # 28 by 28 pixel and 1 channel
self.labels = tf.placeholder(tf.int32, shape = (cfg.batch_size, ))
self.Y = tf.reshape(self.labels, shape = (cfg.batch_size, 10, 1))
self.build_arch()
tf.logging.info('Seting up the main structure')
def build_arch(self):
with tf.variable_scope('Conv1_layer'):
# Conv1_layer:
# Input [batch_size, 20, 20, 256]
conv1 = tf.contrib.layers.conv2d(self.X, num_outputs=256, kernel_size=9, stride=1, padding='VALID')
assert conv1.get_shape() == [cfg.batch_size, 20, 20, 256]
# Primary Cap Layer
# Output: [batch_size, 6, 6, 32, 8-Dim tensor]
# i.e: [cfg.batch_size, 1152, 8, 1]
with tf.variable_scope('PrimaryCaps_layer'):
primaryCaps = CapsLayer(num_outputs=32, vec_len=8, with_routing=False, layer_type='CONV')
caps1 = primaryCaps(conv1,kernel_size=9,stride=2)
assert caps1.get_shape() == [cfg.batch_size,1152,8,1]
with tf.variable_scope('DigitCaps_layer'):
digitCaps = CapsLayer(num_outputs=10, vec_len=16,with_routing=True,layer_type='FC')
self.caps2 = digitCaps(caps1) # Don't understand
# REVIEW WHAT's MASKING
with tf.variable_scope('Masking'):
# calculate ||v_c||, then softmax(||v_c||)
# [batch_size, 10, 16, 1] => [batch_size, 10, 1, 1]
self.v_length = tf.sqrt(reduce_sum(tf.square(self.caps2),axis=2,keepdims=True)+epsilon)
self.softmax_v = softmax(self.v_length, axis=1)
assert self.softmax_v == [cfg.batch_size, 10, 1, 1]
# Pick the index with the max softmax val of the 10 caps
# [batch_size, 10, 1 ,1] => [batch_size] (index)
self.argmax_idx = tf.to_int32(tf.argmax(self.softmax_v, axis=1))
assert self.argmax_idx.get_shape() == [cfg.batch_size, 1,1]
self.argmax_idx = tf.reshape(self.argmax_idx, shape=(cfg.batch_size, ))
# WHAT's MASK WITH Y
if not cfg.mask_with_y:
# indexing
masked_v = []
for batch_size in range(cfg.batch_size):
v = self.caps[batch_size][se;f.argmax_idx[batch_size], :]
masked_v.append(tf.reshape(v,shape=(1,1,16,1)))
self.masked_v = tf.concat(masked_v, axis=0)
assert self.masked_v.get_shape() == [cfg.batch_size, 1, 16, 1]
else:
# MASK WITH TRUE LABEL
self.masked_v = tf.multiply(tf.squeeze(self.caps2), tf.reshape(self.Y,(-1,10,1)))
self.v_length = tf.sqrt(reduce_sum(tf.square(self.caps2),axis=2,keepdims=True)+epsilon)
with tf.variable_scope('Decoder'):
def main():
print("loading model...")
generator = GEN(ITEM_NUM,
USER_NUM,
EMB_DIM,
lamda=0.0 / BATCH_SIZE,
param=None,
initdelta=INIT_DELTA,
learning_rate=0.001)
discriminator = DIS(ITEM_NUM,
USER_NUM,
EMB_DIM,
lamda=0.1 / BATCH_SIZE,
param=None,
initdelta=INIT_DELTA,
learning_rate=0.001)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(tf.global_variables_initializer())
print("gen ", simple_test(sess, generator))
print("dis ", simple_test(sess, discriminator))
dis_log = open(workdir + 'dis_log.txt', 'w')
gen_log = open(workdir + 'gen_log.txt', 'w')
best = 0.
for epoch in range(15):
if epoch >= 0:
for d_epoch in range(100):
if d_epoch % 5 == 0:
generate_for_d(sess, generator, DIS_TRAIN_FILE)
train_size = ut.file_len(DIS_TRAIN_FILE)
index = 1
while True:
if index > train_size:
break
if index + BATCH_SIZE <= train_size + 1:
input_user, input_item, input_label = ut.get_batch_data(
DIS_TRAIN_FILE, index, BATCH_SIZE)
else:
input_user, input_item, input_label = ut.get_batch_data(
DIS_TRAIN_FILE, index, train_size - index + 1)
index += BATCH_SIZE
_ = sess.run(discriminator.d_updates,
feed_dict={
discriminator.u: input_user,
discriminator.i: input_item,
discriminator.label: input_label
})
for g_epoch in range(50):
for u in user_pos_train:
sample_lambda = 0.2
pos = user_pos_train[u]
rating = sess.run(generator.all_logits,
{generator.u: u})
exp_rating = np.exp(rating)
prob = exp_rating / np.sum(exp_rating)
pn = (1 - sample_lambda) * prob
pn[pos] += sample_lambda * 1.0 / len(pos)
sample = np.random.choice(np.arange(ITEM_NUM),
2 * len(pos),
p=pn)
reward = sess.run(discriminator.reward, {
discriminator.u: u,
discriminator.i: sample
})
reward = reward * prob[sample] / pn[sample]
_ = sess.run(
generator.gan_updates, {
generator.u: u,
generator.i: sample,
generator.reward: reward
})
result = simple_test(sess, generator)
print("epoch ", epoch, "gen: ", result)
buf = '\t'.join([str(x) for x in result])
gen_log.write(str(epoch) + '\t' + buf + '\n')
gen_log.flush()
p_5 = result[1]
if p_5 > best:
print('best: ', result)
best = p_5
gen_log.close()
dis_log.close()
def main():
i_file_output = 0
print "load model..."
generator = GEN(AUTHER_NUM,
EMB_DIM,
lamda=0.0 / BATCH_SIZE,
param=None,
initdelta=INIT_DELTA,
learning_rate=FLAGS.init_lr_gen,
lr_decay_step=FLAGS.lr_decay_iter_gen)
discriminator = DIS(AUTHER_NUM,
EMB_DIM,
lamda=0.01 / BATCH_SIZE,
param=None,
initdelta=INIT_DELTA,
learning_rate=FLAGS.init_lr_dis,
lr_decay_step=FLAGS.lr_decay_iter_dis)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.global_variables_initializer())
dis_log = open(outputdir + 'dis_log.txt', 'w')
gen_log = open(outputdir + 'gen_log.txt', 'w')
# minimax training
best_gen = 0.
best_dis = 0.
draw_count_D = 0
draw_count_G = 0
for epoch in range(FLAGS.epochs): #5000
if epoch >= 0:
# Train D
generate_for_d(sess, generator, DIS_TRAIN_FILE)
train_size = ut.file_len(DIS_TRAIN_FILE) # generate file length
for d_epoch in range(5):
index = 1
while True:
if index > train_size:
break
if index + BATCH_SIZE <= train_size + 1:
input_auther, input_coauther_real, input_coauther_fake = ut.get_batch_data(
DIS_TRAIN_FILE, index, BATCH_SIZE)
else:
input_auther, input_coauther_real, input_coauther_fake = ut.get_batch_data(
DIS_TRAIN_FILE, index, train_size - index + 1)
index += BATCH_SIZE
_ = sess.run(
[discriminator.d_updates, discriminator.clip_D],
feed_dict={
discriminator.auther: input_auther,
discriminator.co_real: input_coauther_real,
discriminator.co_fake: input_coauther_fake
})
result = simple_test(sess, discriminator)
buf = '\t'.join([str(x) for x in result])
dis_log.write(str(epoch) + '\t' + buf + '\n')
dis_log.flush()
p_5 = result[2]
if p_5 > best_dis:
print 'best_dis: ', epoch, result
best_dis = p_5
discriminator.save_model(sess,
outputdir + "gan_discriminator.pkl")
# Train G
for g_epoch in range(1):
for u in auther_pos_train:
sample_lambda = 0.2
pos = list(set(auther_pos_train[u]))
sample_times = 128
rating = sess.run(generator.softmax_logits,
{generator.auther: [u]})
prob = np.reshape(rating, [-1])
sample = np.random.choice(np.arange(AUTHER_NUM),
size=sample_times,
p=prob)
###########################################################################
# Get reward and adapt it with importance sampling
###########################################################################
reward = sess.run(
discriminator.reward, {
discriminator.auther: np.tile(u, (sample_times)),
discriminator.co_fake: sample
})
###########################################################################
# Update G
###########################################################################
_ = sess.run(
generator.gan_updates, {
generator.auther: np.tile(u, (sample_times)),
generator.co: sample,
generator.reward: reward
})
result = simple_test(sess, generator)
buf = '\t'.join([str(x) for x in result])
gen_log.write(str(epoch) + '\t' + buf + '\n')
gen_log.flush()
p_5 = result[2]
if p_5 > best_gen:
print 'best_gen: ', epoch, result
best_gen = p_5
generator.save_model(sess, outputdir + "gan_generator.pkl")
draw_count_G += 1
gen_log.close()
dis_log.close()
def build_network(self):
self.word2idx, word_embedding = data_helper.load_embedding(self.FLAGS.embedding_path)
self.inputs, self.labels, self.train_num = utils.get_batch_data(self.FLAGS.train_data_path,
self.FLAGS.batch_size, self.FLAGS.seq_length, self.word2idx)
self.labels = tf.one_hot(self.labels, depth=self.FLAGS.class_num)
# embedding layer
with tf.variable_scope('embedding'):
embedding = tf.get_variable('embedding', shape=word_embedding.shape, dtype=tf.float32,
initializer=tf.constant_initializer(word_embedding), trainable=False)
# [batch, 30, 300]
inputs = tf.nn.embedding_lookup(embedding, self.inputs)
self.origin = tf.reduce_mean(inputs, axis=1)
inputs = tf.expand_dims(inputs, -1)
with tf.variable_scope('conv1_layer'):
# [batch, 30, 1, 300]
input_conv = tf.layers.conv2d(inputs, self.FLAGS.filter_num,
[self.FLAGS.filter_size, self.FLAGS.embedding_size])
# Primary Capsules layer
with tf.variable_scope('PrimaryCaps_layer'):
primaryCaps = CapsLayer(num_outputs=30, vec_len=10, with_routing=False, layer_type='CONV')
caps1 = primaryCaps(input_conv, kernel_size=3, stride=1)
# DigitCaps layer, return [batch_size, 2, vec_len, 1]
with tf.variable_scope('DigitCaps_layer'):
digitCaps = CapsLayer(num_outputs=self.FLAGS.class_num, vec_len=32, with_routing=True, layer_type='FC')
# [batch_size, 2, 100, 1]
self.caps2 = digitCaps(caps1)
# Decoder structure
# 1. Do masking, how:
with tf.variable_scope('Masking'):
# [batch_size, class_num, vec_len, 1] => [batch_size, class_num, 1, 1]
self.v_length = tf.sqrt(tf.reduce_sum(tf.square(self.caps2),
axis=2, keep_dims=True) + epsilon)
# [batch_size, class_num, 1, 1]
self.softmax_v = tf.nn.softmax(self.v_length, dim=1)
# [batch_size, class_num, 1, 1] => [batch_size] (index)
self.argmax_idx = tf.to_int32(tf.argmax(self.softmax_v, axis=1))
self.argmax_idx = tf.reshape(self.argmax_idx, shape=[-1])
# Method 1.
if not mask_with_y:
# indexing
# [batch_size, class_num, 1, 1]
one_hot_idx = tf.expand_dims(tf.expand_dims(tf.one_hot(self.argmax_idx, self.FLAGS.class_num), -1), -1)
# [batch_size, 1, vec_len, 1]
self.masked_v = tf.reduce_sum(self.caps2 * one_hot_idx, 1)
# Method 2. masking with true label, default mode
else:
self.masked_v = tf.multiply(tf.squeeze(self.caps2, 3),
tf.reshape(self.labels, (-1, self.FLAGS.class_num, 1)))
# [batch_size, class_num, 1]
self.v_length = tf.sqrt(tf.reduce_sum(tf.square(self.caps2), axis=2) + epsilon)
# 2. Reconstructe the data with 3 FC layers
# [batch_size, 2, vec_len, 1] => [batch_size, 64] => [batch_size, 300]
with tf.variable_scope('Decoder'):
vector_j = tf.reshape(self.masked_v, shape=(-1, self.FLAGS.class_num * 32))
fc1 = tf.contrib.layers.fully_connected(vector_j, num_outputs=256)
fc2 = tf.contrib.layers.fully_connected(fc1, num_outputs=512)
self.decoded = tf.contrib.layers.fully_connected(fc2, num_outputs=300, activation_fn=tf.tanh)
def main():
discriminator = DIS(FEATURE_SIZE,
HIDDEN_SIZE,
WEIGHT_DECAY,
D_LEARNING_RATE,
param=None)
generator = GEN(FEATURE_SIZE,
HIDDEN_SIZE,
WEIGHT_DECAY,
G_LEARNING_RATE,
temperature=TEMPERATURE,
param=None)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.initialize_all_variables())
print('start adversarial training')
p_best_val = 0.0
ndcg_best_val = 0.0
for epoch in range(30):
if epoch >= 0:
# G generate negative for D, then train D
print('Training D ...')
for d_epoch in range(100):
if d_epoch % 30 == 0:
generate_for_d(sess, generator, DIS_TRAIN_FILE)
train_size = ut.file_len(DIS_TRAIN_FILE)
index = 1
while True:
if index > train_size:
break
if index + BATCH_SIZE <= train_size + 1:
input_pos, input_neg = ut.get_batch_data(
DIS_TRAIN_FILE, index, BATCH_SIZE)
else:
input_pos, input_neg = ut.get_batch_data(
DIS_TRAIN_FILE, index, train_size - index + 1)
index += BATCH_SIZE
pred_data = []
pred_data.extend(input_pos)
pred_data.extend(input_neg)
pred_data = np.asarray(pred_data)
pred_data_label = [1.0] * len(input_pos)
pred_data_label.extend([0.0] * len(input_neg))
pred_data_label = np.asarray(pred_data_label)
_ = sess.run(discriminator.d_updates,
feed_dict={
discriminator.pred_data: pred_data,
discriminator.pred_data_label:
pred_data_label
})
# Train G
print('Training G ...')
for g_epoch in range(30):
for query in query_pos_train.keys():
pos_list = query_pos_train[query]
pos_set = set(pos_list)
all_list = query_index_url[query]
all_list_feature = [
query_url_feature[query][url] for url in all_list
]
all_list_feature = np.asarray(all_list_feature)
all_list_score = sess.run(
generator.pred_score,
{generator.pred_data: all_list_feature})
# softmax for all
exp_rating = np.exp(all_list_score - np.max(all_list_score))
prob = exp_rating / np.sum(exp_rating)
prob_IS = prob * (1.0 - LAMBDA)
for i in range(len(all_list)):
if all_list[i] in pos_set:
prob_IS[i] += (LAMBDA / (1.0 * len(pos_list)))
choose_index = np.random.choice(np.arange(len(all_list)),
[5 * len(pos_list)],
p=prob_IS)
choose_list = np.array(all_list)[choose_index]
choose_feature = [
query_url_feature[query][url] for url in choose_list
]
choose_IS = np.array(prob)[choose_index] / np.array(
prob_IS)[choose_index]
choose_index = np.asarray(choose_index)
choose_feature = np.asarray(choose_feature)
choose_IS = np.asarray(choose_IS)
choose_reward = sess.run(
discriminator.reward,
feed_dict={discriminator.pred_data: choose_feature})
_ = sess.run(generator.g_updates,
feed_dict={
generator.pred_data: all_list_feature,
generator.sample_index: choose_index,
generator.reward: choose_reward,
generator.important_sampling: choose_IS
})
p_5 = precision_at_k(sess,
generator,
query_pos_test,
query_pos_train,
query_url_feature,
k=5)
ndcg_5 = ndcg_at_k(sess,
generator,
query_pos_test,
query_pos_train,
query_url_feature,
k=5)
if p_5 > p_best_val:
p_best_val = p_5
ndcg_best_val = ndcg_5
generator.save_model(sess, GAN_MODEL_BEST_FILE)
print("Best:", "gen p@5 ", p_5, "gen ndcg@5 ", ndcg_5)
elif p_5 == p_best_val:
if ndcg_5 > ndcg_best_val:
ndcg_best_val = ndcg_5
generator.save_model(sess, GAN_MODEL_BEST_FILE)
print("Best:", "gen p@5 ", p_5, "gen ndcg@5 ", ndcg_5)
sess.close()
param_best = cPickle.load(open(GAN_MODEL_BEST_FILE))
assert param_best is not None
generator_best = GEN(FEATURE_SIZE,
HIDDEN_SIZE,
WEIGHT_DECAY,
G_LEARNING_RATE,
temperature=TEMPERATURE,
param=param_best)
sess = tf.Session(config=config)
sess.run(tf.initialize_all_variables())
p_1_best = precision_at_k(sess,
generator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=1)
p_3_best = precision_at_k(sess,
generator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=3)
p_5_best = precision_at_k(sess,
generator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=5)
p_10_best = precision_at_k(sess,
generator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=10)
ndcg_1_best = ndcg_at_k(sess,
generator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=1)
ndcg_3_best = ndcg_at_k(sess,
generator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=3)
ndcg_5_best = ndcg_at_k(sess,
generator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=5)
ndcg_10_best = ndcg_at_k(sess,
generator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=10)
map_best = MAP(sess, generator_best, query_pos_test, query_pos_train,
query_url_feature)
mrr_best = MRR(sess, generator_best, query_pos_test, query_pos_train,
query_url_feature)
print("Best ", "p@1 ", p_1_best, "p@3 ", p_3_best, "p@5 ", p_5_best,
"p@10 ", p_10_best)
print("Best ", "ndcg@1 ", ndcg_1_best, "ndcg@3 ", ndcg_3_best, "ndcg@5 ",
ndcg_5_best, "p@10 ", ndcg_10_best)
print("Best MAP ", map_best)
print("Best MRR ", mrr_best)
def main():
discriminator = DIS(FEATURE_SIZE,
HIDDEN_SIZE,
WEIGHT_DECAY,
D_LEARNING_RATE,
param=None)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.initialize_all_variables())
print('start random negative sampling with log ranking discriminator')
generate_uniform(DIS_TRAIN_FILE)
train_size = ut.file_len(DIS_TRAIN_FILE)
p_best_val = 0.0
ndcg_best_val = 0.0
for epoch in range(200):
index = 1
while True:
if index > train_size:
break
if index + BATCH_SIZE <= train_size + 1:
input_pos, input_neg = ut.get_batch_data(
DIS_TRAIN_FILE, index, BATCH_SIZE)
else:
input_pos, input_neg = ut.get_batch_data(
DIS_TRAIN_FILE, index, train_size - index + 1)
index += BATCH_SIZE
pred_data = []
pred_data.extend(input_pos)
pred_data.extend(input_neg)
pred_data = np.asarray(pred_data)
pred_data_label = [1.0] * len(input_pos)
pred_data_label.extend([0.0] * len(input_neg))
pred_data_label = np.asarray(pred_data_label)
_ = sess.run(discriminator.d_updates,
feed_dict={
discriminator.pred_data: pred_data,
discriminator.pred_data_label: pred_data_label
})
p_5 = precision_at_k(sess,
discriminator,
query_pos_test,
query_pos_train,
query_url_feature,
k=5)
ndcg_5 = ndcg_at_k(sess,
discriminator,
query_pos_test,
query_pos_train,
query_url_feature,
k=5)
if p_5 > p_best_val:
p_best_val = p_5
discriminator.save_model(sess, MLE_MODEL_BEST_FILE)
print("Best: ", " p@5 ", p_5, "ndcg@5 ", ndcg_5)
elif p_5 == p_best_val:
if ndcg_5 > ndcg_best_val:
ndcg_best_val = ndcg_5
discriminator.save_model(sess, MLE_MODEL_BEST_FILE)
print("Best: ", " p@5 ", p_5, "ndcg@5 ", ndcg_5)
sess.close()
param_best = cPickle.load(open(MLE_MODEL_BEST_FILE))
assert param_best is not None
discriminator_best = DIS(FEATURE_SIZE,
HIDDEN_SIZE,
WEIGHT_DECAY,
D_LEARNING_RATE,
param=param_best)
sess = tf.Session(config=config)
sess.run(tf.initialize_all_variables())
p_1_best = precision_at_k(sess,
discriminator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=1)
p_3_best = precision_at_k(sess,
discriminator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=3)
p_5_best = precision_at_k(sess,
discriminator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=5)
p_10_best = precision_at_k(sess,
discriminator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=10)
ndcg_1_best = ndcg_at_k(sess,
discriminator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=1)
ndcg_3_best = ndcg_at_k(sess,
discriminator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=3)
ndcg_5_best = ndcg_at_k(sess,
discriminator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=5)
ndcg_10_best = ndcg_at_k(sess,
discriminator_best,
query_pos_test,
query_pos_train,
query_url_feature,
k=10)
map_best = MAP(sess, discriminator_best, query_pos_test, query_pos_train,
query_url_feature)
mrr_best = MRR(sess, discriminator_best, query_pos_test, query_pos_train,
query_url_feature)
print("Best ", "p@1 ", p_1_best, "p@3 ", p_3_best, "p@5 ", p_5_best,
"p@10 ", p_10_best)
print("Best ", "ndcg@1 ", ndcg_1_best, "ndcg@3 ", ndcg_3_best, "ndcg@5 ",
ndcg_5_best, "p@10 ", ndcg_10_best)
print("Best MAP ", map_best)
print("Best MRR ", mrr_best)
