def discriminator(self, inputs, scope='discriminator', reuse=None):
with tf.variable_scope(scope, reuse=reuse):
# Set discriminator to always be training. Reason for doing this is
# For the WGAN gradient loss (which is not the default loss function for
# this model, still uses this architecture), the loss function has an expression
# which is the gradient of an instance of the discriminator. Putting that
# into the optimizer creates a dependency on the second order gradient of the
# disriminator. Batch normalization where the training vs running flag is itself
# a TF variable (rather than normal python boolean) seems to break this. Easier to
# just set to True because in this model we only ever use the discriminator for
# training (to train the generator).
bn = BN(True)
t = lrelu(conv2d(inputs, 64)) # no bn here
t = lrelu(bn(conv2d(t, 128)))
t = lrelu(bn(conv2d(t, 256)))
t = lrelu(bn(conv2d(t, 512)))
t = lrelu(bn(conv2d(t, 1024)))
# flatten 3D tensor into 1D to prepare for a dense (fully connected)
# layer. Flattened tensor can also be treated as vector that can be
# used for learned similarty measurements between images.
similarity = flatten(t)
# return logits (before sigmoid activation) because several TF
# accumulator functions expect logits, and do the sigmoid for you
logits = dense(similarity, 1)
classification = sigmoid(logits)
return classification, logits, similarity
def E_x(m_opts, m_vars):
PSI = m_vars['U_batch'].dot(m_vars['V'].T)
PSI_sigmoid = sigmoid(-PSI)
E_x = (m_vars['mu'] * PSI_sigmoid) / (EPS + m_vars['mu'] * PSI_sigmoid +
(1. - m_vars['mu']))
E_x[m_vars['Y_batch'].nonzero()] = 1.
return E_x
def predict(m_opts, m_vars, X, break_chunks=1):
if break_chunks != 1:
print "Warning, break_chunks no longer supported in predict."
U = X.dot(m_vars['W'].T)
Y_pred = U.dot(m_vars['V'].T)
Y_pred = sigmoid(Y_pred)
Y_pred_1 = Y_pred * m_vars['mu']
return Y_pred_1, Y_pred
def E_x_omega_col(m_opts, m_vars):
PSI = m_vars['V'].dot(m_vars['U_batch'].T)
E_omega = 0.5 * np.tanh(0.5 * PSI) / (EPS + PSI)
PSI_sigmoid = sigmoid(-PSI)
mu_temp = m_vars['mu'][:, np.newaxis]
E_x = (mu_temp * PSI_sigmoid) / (EPS + mu_temp * PSI_sigmoid +
(1. - mu_temp))
E_x[m_vars['Y_batch_T'].nonzero()] = 1.
return E_x, E_omega
def E_x_omega_row(m_opts, m_vars):
PSI = m_vars['U_batch'].dot(m_vars['V'].T)
E_omega = 0.5 * np.tanh(0.5 * PSI) / (EPS + PSI)
PSI_sigmoid = sigmoid(-PSI)
E_x = (m_vars['mu'] * PSI_sigmoid) / (EPS + m_vars['mu'] * PSI_sigmoid +
(1. - m_vars['mu']))
E_x[m_vars['Y_batch'].nonzero()] = 1.
return E_x, E_omega
def __init__(self):
self.inputs = tf.placeholder(tf.float32, [None, IMG_H, IMG_W, 3])
self.is_training = tf.placeholder(tf.bool)
_, _, class_logits_dict, box_logits_dict = backbone(self.inputs, self.is_training)
class_logits_dict["P3"], class_logits_dict["P4"], class_logits_dict["P5"], class_logits_dict["P6"], class_logits_dict["P7"] = \
tf.reshape(class_logits_dict["P3"], [-1, K]), tf.reshape(class_logits_dict["P4"], [-1, K]), tf.reshape(class_logits_dict["P5"], [-1, K]), \
tf.reshape(class_logits_dict["P6"], [-1, K]), tf.reshape(class_logits_dict["P7"], [-1, K])
box_logits_dict["P3"], box_logits_dict["P4"], box_logits_dict["P5"], box_logits_dict["P6"], box_logits_dict["P7"] = \
tf.reshape(box_logits_dict["P3"], [-1, 4]), tf.reshape(box_logits_dict["P4"], [-1, 4]), tf.reshape(box_logits_dict["P5"], [-1, 4]), \
tf.reshape(box_logits_dict["P6"], [-1, 4]), tf.reshape(box_logits_dict["P7"], [-1, 4])
P3_class_pred, P4_class_pred, P5_class_pred, P6_class_pred, P7_class_pred = \
sigmoid(class_logits_dict["P3"]), sigmoid(class_logits_dict["P4"]), sigmoid(class_logits_dict["P5"]), sigmoid(class_logits_dict["P6"]), sigmoid(class_logits_dict["P7"])
P3_bbox_pred, P4_bbox_pred, P5_bbox_pred, P6_bbox_pred, P7_bbox_pred = \
box_logits_dict["P3"], box_logits_dict["P4"], box_logits_dict["P5"], box_logits_dict["P6"], box_logits_dict["P7"]
# thresholding confidence at 0.05 at most 1000 top k score
P3_topK_score, P3_topK_bbox, P3_topK_anchors, P3_topK_class = top_k_score_bbox(P3_class_pred, P3_bbox_pred, anchors_p3, threshold=0.05, k=1000)
P4_topK_score, P4_topK_bbox, P4_topK_anchors, P4_topK_class = top_k_score_bbox(P4_class_pred, P4_bbox_pred, anchors_p4, threshold=0.05, k=1000)
P5_topK_score, P5_topK_bbox, P5_topK_anchors, P5_topK_class = top_k_score_bbox(P5_class_pred, P5_bbox_pred, anchors_p5, threshold=0.05, k=1000)
P6_topK_score, P6_topK_bbox, P6_topK_anchors, P6_topK_class = top_k_score_bbox(P6_class_pred, P6_bbox_pred, anchors_p6, threshold=0.05, k=1000)
P7_topK_score, P7_topK_bbox, P7_topK_anchors, P7_topK_class = top_k_score_bbox(P7_class_pred, P7_bbox_pred, anchors_p7, threshold=0.05, k=1000)
self.topK_score = tf.concat([P3_topK_score, P4_topK_score, P5_topK_score, P6_topK_score, P7_topK_score], axis=0)
self.topK_bbox = tf.concat([P3_topK_bbox, P4_topK_bbox, P5_topK_bbox, P6_topK_bbox, P7_topK_bbox], axis=0)
self.topK_anchors = tf.concat([P3_topK_anchors, P4_topK_anchors, P5_topK_anchors, P6_topK_anchors, P7_topK_anchors], axis=0)
self.topK_class = tf.concat([P3_topK_class, P4_topK_class, P5_topK_class, P6_topK_class, P7_topK_class], axis=0)
self.bbox = offset2bbox(self.topK_anchors, self.topK_bbox)
self.nms_idx = tf.image.non_max_suppression(self.bbox, self.topK_score, max_output_size=300)
self.sess = tf.Session()
self.sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(self.sess, "./model/model.ckpt")
def predictPrecision(m_opts, m_vars, X, k=5, break_chunks=2):
U = ssp.csr_matrix(X.dot(m_vars['W'].T))
n_users_test = m_vars['Y_test'].shape[0]
chunk_size = n_users_test // break_chunks
start_idx = range(0, n_users_test, chunk_size)[:break_chunks]
end_idx = start_idx[1:] + [n_users_test]
p_1 = np.zeros((break_chunks, k))
p_2 = np.zeros((break_chunks, k))
n_total_items = 0
n_labels = 0
Y_predict_chunk = None
Y_test_chunk = None
print "Chunk #",
for i, (lo, hi) in enumerate(zip(start_idx, end_idx)):
print i,
Y_pred_chunk = np.asarray(U[lo:hi].dot(m_vars['V'].T))
Y_pred_chunk_2 = sigmoid(Y_pred_chunk)
Y_pred_chunk_1 = m_vars['mu'] * Y_pred_chunk_2
prevMatch_1 = 0
prevMatch_2 = 0
Y_pred_1 = Y_pred_chunk_1.copy()
Y_pred_2 = Y_pred_chunk_2.copy()
Y_true = m_vars['Y_test'][lo:hi].copy()
n_items, n_labels = Y_pred_1.shape
n_total_items += n_items
for t in xrange(1, k + 1):
Jidx_1 = np.argmax(Y_pred_1, 1)
prevMatch_1 += Y_true[np.arange(n_items), Jidx_1].sum()
Y_pred_1[np.arange(n_items), Jidx_1] = -np.inf
p_1[i, t - 1] = prevMatch_1 #/(t*n_items)
Jidx_2 = np.argmax(Y_pred_2, 1)
prevMatch_2 += Y_true[np.arange(n_items), Jidx_2].sum()
Y_pred_2[np.arange(n_items), Jidx_2] = -np.inf
p_2[i, t - 1] = prevMatch_2 #/(t*n_items)
print "Done"
q_1 = np.zeros(k)
q_2 = np.zeros(k)
for i in range(1, k + 1):
q_1[i - 1] = p_1[:, i - 1].sum() / (i * n_total_items)
q_2[i - 1] = p_2[:, i - 1].sum() / (i * n_total_items)
return tuple(q_1[[0, 2, 4]]), tuple(q_2[[0, 2, 4]])
for user_id, item_id, outcome, nb_wins, nb_fails in np.array(df_test):
if user_id > 3374:
break
print('Welcome', user_id)
train_users[user_id].append(user_id)
train_items[user_id].append(item_id)
train_rates[user_id].append(outcome)
train_wins[user_id].append(nb_wins)
train_fails[user_id].append(nb_fails)
item_logit = sess.run(logits, feed_dict={
user_batch: [user_id], item_batch: [item_id], wins_batch: [nb_wins], fails_batch: [nb_fails]})
item_proba = ops.sigmoid(item_logit)
all_truth.append(outcome)
all_pred.append(item_proba)
# print('Asking', item_id, 'predicted', item_proba, 'actually', outcome)
for i in range(1, EPOCH_MAX + 1):
_, train_logits_cdf, train_infer, train_user_bias, train_item_bias, train_user_features, train_thresholds = sess.run(
[train_op, logits_cdf, infer, user_bias, item_bias, user_features, thresholds], feed_dict={
user_batch: train_users[user_id], item_batch: train_items[user_id], rate_batch: train_rates[user_id], wins_batch: train_wins[user_id], fails_batch: train_fails[user_id]})
if i % LOG_STEP == 0:
train_cost = deque()
train_acc = deque()
def fprop(self):
self.out = sigmoid(self.pred.out)
def fprop(self):
self.out = sigmoid(self.pred.out)
def svd(train, test):
nb_batches = len(train) // BATCH_SIZE
iter_train = dataio.ShuffleIterator([
train["user"], train["item"], train["outcome"], train["wins"],
train["fails"]
],
batch_size=BATCH_SIZE)
iter_test = dataio.OneEpochIterator([
test["user"], test["item"], test["outcome"], test["wins"],
test["fails"]
],
batch_size=-1)
user_batch = tf.placeholder(tf.int32, shape=[None], name="id_user")
item_batch = tf.placeholder(tf.int32, shape=[None], name="id_item")
rate_batch = tf.placeholder(tf.float32, shape=[None])
wins_batch = tf.placeholder(tf.float32, shape=[None], name="nb_wins")
fails_batch = tf.placeholder(tf.float32, shape=[None], name="nb_fails")
# infer, logits, logits_cdf, logits_pdf, regularizer, user_bias, user_features, item_bias, item_features, thresholds = ops.inference_svd(user_batch, item_batch, wins_batch, fails_batch, user_num=USER_NUM, item_num=ITEM_NUM, dim=DIM, device=DEVICE)
infer, logits, regularizer, user_bias, user_features, item_bias, item_features = ops.inference_svd(
user_batch,
item_batch,
wins_batch,
fails_batch,
user_num=USER_NUM,
item_num=ITEM_NUM,
dim=DIM,
device=DEVICE)
global_step = tf.train.get_or_create_global_step()
#cost_l2, train_op = ops.optimization(infer, regularizer, rate_batch, learning_rate=LEARNING_RATE, reg=LAMBDA_REG, device=DEVICE)
cost_nll, train_op = ops.optimization(infer,
logits,
regularizer,
rate_batch,
learning_rate=LEARNING_RATE,
reg=LAMBDA_REG,
device=DEVICE)
#cost, train_op = ops.optimization(infer, logits, logits_cdf, logits_pdf, regularizer, rate_batch, learning_rate=LEARNING_RATE, reg=LAMBDA_REG, device=DEVICE)
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(init_op)
summary_writer = tf.summary.FileWriter(logdir="/tmp/svd/log",
graph=sess.graph)
print("{} {} {} {}".format("epoch", "train_error", "val_error",
"elapsed_time"))
train_se = deque(maxlen=nb_batches)
train_nll = deque(maxlen=nb_batches)
train_cost = deque(maxlen=nb_batches)
train_acc = deque(maxlen=nb_batches)
train_obo = deque(maxlen=nb_batches)
train_auc = deque(maxlen=nb_batches)
start = time.time()
for i in range(EPOCH_MAX * nb_batches):
train_users, train_items, train_rates, train_wins, train_fails = next(
iter_train)
batch_size = len(train_rates)
_, train_logits, train_infer = sess.run(
[train_op, logits, infer],
feed_dict={
user_batch: train_users,
item_batch: train_items,
rate_batch: train_rates,
wins_batch: train_wins,
fails_batch: train_fails
})
#print('values', train_infer[42], train_logits[42], train_logits_cdf[42], ops.sigmoid(train_logits[42]), ops.sigmoid(train_logits_cdf[42]))
# print(train_logits_cdf[42])
# print(train_logits_pdf[42])
# print(train_rates[42])
if DISCRETE:
if NB_CLASSES > 2:
cost_batch = sess.run(cost,
feed_dict={
rate_batch: train_rates,
item_batch: train_items,
user_batch: train_users,
logits_cdf: train_logits_cdf
})
# print(train_users[42])
# print(train_items[42])
# print(train_logits_pdf[42])
# print(train_logits_cdf[42])
# print('thr', all_thresholds)
# print('infer', train_infer[42])
train_cost.append(cost_batch)
train_acc.append(train_infer == train_rates)
train_obo.append(abs(train_infer - train_rates) <= 1)
train_se.append(np.power(train_infer - train_rates, 2))
else:
nll_batch = sess.run(cost_nll,
feed_dict={
rate_batch: train_rates,
logits: train_logits
})
proba_batch = ops.sigmoid(train_logits)
train_acc.append(np.round(proba_batch) == train_rates)
train_auc.append(roc_auc_score(train_rates, proba_batch))
train_nll.append(nll_batch)
else:
l2_batch = sess.run(cost_l2,
feed_dict={
rate_batch: train_rates,
infer: train_infer
})
#print('est-ce', np.sum(np.power(train_rates - train_pred_batch, 2)))
#print('que = ', l2_batch)
#train_se.append(np.power(l2_batch, 2))
train_se.append(np.power(train_rates - train_infer, 2))
if i % nb_batches == 0:
# Compute test error
train_rmse = np.sqrt(np.mean(train_se))
train_macc = np.mean(train_acc)
train_mobo = np.mean(train_obo)
train_mauc = np.mean(train_auc)
train_mnll = np.mean(train_nll) / BATCH_SIZE
train_mcost = np.mean(train_cost)
test_se = []
test_acc = []
test_obo = []
test_auc = 0
test_nll = []
test_cost = []
for test_users, test_items, test_rates, test_wins, test_fails in iter_test:
test_logits, test_infer = sess.run(
[logits, infer],
feed_dict={
user_batch: test_users,
item_batch: test_items,
wins_batch: test_wins,
fails_batch: test_fails
})
test_size = len(test_rates)
# print(test_logits_cdf[42], test_logits_pdf[42])
# print(test_infer[42], test_rates[42])
if DISCRETE:
if NB_CLASSES > 2:
cost_batch = sess.run(cost,
feed_dict={
rate_batch: test_rates,
item_batch: test_items,
user_batch: test_users
})
#print(cost_batch)
test_cost.append(cost_batch)
test_acc.append(test_infer == test_rates)
test_obo.append(abs(test_infer - test_rates) <= 1)
test_se.append(np.power(test_infer - test_rates,
2))
else:
#train_cost.append(cost_batch)
nll_batch = sess.run(cost_nll,
feed_dict={
rate_batch: test_rates,
logits: test_logits
})
proba_batch = ops.sigmoid(test_logits)
test_acc.append(
np.round(proba_batch) == test_rates)
test_auc = roc_auc_score(test_rates, proba_batch)
# print(proba_batch[:5], test_rates[:5], test_auc)
test_nll.append(nll_batch)
else:
l2_batch = sess.run(cost_l2,
feed_dict={
rate_batch: rates,
infer: pred_batch
})
test_se.append(np.power(rates - pred_batch, 2))
end = time.time()
test_rmse = np.sqrt(np.mean(test_se))
test_macc = np.mean(test_acc)
test_mobo = np.mean(test_obo)
test_mnll = np.mean(test_nll) / len(test)
test_mcost = np.mean(test_cost)
if DISCRETE:
if NB_CLASSES > 2:
print(
"{:3d} TRAIN(size={:d}/{:d}, macc={:f}, mobo={:f}, rmse={:f}, mcost={:f}) TEST(size={:d}, macc={:f}, mobo={:f}, rmse={:f}, mcost={:f}) {:f}(s)"
.format(i // nb_batches, len(train_users),
len(train), train_macc,
train_mobo, train_rmse, train_mcost,
len(test), test_macc, test_mobo, test_rmse,
test_mcost, end - start))
else:
print(
"{:3d} TRAIN(size={:d}/{:d}, macc={:f}, mauc={:f}, mnll={:f}) TEST(size={:d}, macc={:f}, auc={:f}, mnll={:f}) {:f}(s)"
.format(
i // nb_batches,
len(train_users),
len(train),
#train_rmse, # rmse={:f}
train_macc,
train_mauc,
train_mnll,
len(test),
#test_rmse, # rmse={:f}
test_macc,
test_auc,
test_mnll,
end - start))
else:
print(
"{:3d} TRAIN(size={:d}/{:d}, rmse={:f}) TEST(size={:d}, rmse={:f}) {:f}(s)"
.format(
i // nb_batches,
len(train_users),
len(train),
train_rmse, # rmse={:f}
#train_macc, train_mauc, train_mnll,
len(test),
test_rmse, # rmse={:f}
#test_macc, test_mauc, test_mnll,
end - start))
train_err_summary = make_scalar_summary(
"training_error", train_rmse)
test_err_summary = make_scalar_summary("test_error", test_rmse)
summary_writer.add_summary(train_err_summary, i)
summary_writer.add_summary(test_err_summary, i)
start = end
# print('thr', all_thresholds)
# Save model
print(os.path.join(BASE_DIR, 'fm.ckpt'))
saver.save(sess, os.path.join(BASE_DIR, 'fm.ckpt'))
