class MbPA_KNN_Test:
def __init__(self, sess, args):
self.args = args
self.session = sess
self.w = {}
self.eval_w = {}
with tf.variable_scope(self.args.model_name):
self.x = tf.placeholder(tf.float32, shape=[None, 784], name="x")
self.y = tf.placeholder(tf.float32, shape=[None, 10], name="y")
self.memory_sample_batch = tf.placeholder(
tf.int16, shape=(), name="memory_sample_batch")
with tf.variable_scope("training"):
with tf.variable_scope("embedding"):
self.out = tf.reshape(self.x, [-1, 28, 28, 1])
with tf.variable_scope("conv"):
# # self.out, self.w["l1_w"], self.w["l1_b"] = conv2d(
# # x=self.out,
# # output_dim=16,
# # kernel_size=[8, 8],
# # stride=[4, 4],
# # activation_fn=tf.nn.relu,
# # name="conv1"
# # )
# # self.out, self.w["l2_w"], self.w["l2_b"] = conv2d(
# # x=self.out,
# # output_dim=32,
# # kernel_size=[4, 4],
# # stride=[2, 2],
# # activation_fn=tf.nn.relu,
# # name="conv2"
# # )
self.embed = layers.flatten(self.out)
# self.embed_dim = self.embed.get_shape()[-1]
self.M = Memory(self.args.memory_size,
self.x.get_shape()[-1],
self.y.get_shape()[-1])
embs_and_values = tf.py_func(self.get_memory_sample,
[self.memory_sample_batch],
[tf.float64, tf.float64])
self.memory_batch_x = tf.to_float(embs_and_values[0])
self.memory_batch_y = tf.to_float(embs_and_values[1])
self.xa = tf.concat(values=[self.x, self.memory_batch_x],
axis=0)
self.ya = tf.concat(values=[self.y, self.memory_batch_y],
axis=0)
with tf.variable_scope("fc"):
self.out = self.xa
# self.out, self.w["l3_w"], self.w["l3_b"] = linear(
# input_=self.out,
# output_size=1024,
# activation_fn=tf.nn.relu,
# name="fc_1"
# )
self.out, self.w["l4_w"], self.w["l4_b"] = linear(
input_=self.out, output_size=10, name="fc_2")
self.ya_ = self.out
self.cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=self.ya,
logits=self.ya_))
self.optim = tf.train.GradientDescentOptimizer(
self.args.learning_rate).minimize(self.cross_entropy)
self.correct_prediction = tf.equal(tf.argmax(self.ya, 1),
tf.argmax(self.ya_, 1))
self.accuracy = tf.reduce_mean(
tf.cast(self.correct_prediction, tf.float32))
self.session.run(tf.global_variables_initializer())
def update_training_to_prediction(self):
for name in self.eval_w.keys():
self.t_w_assign_op[name].eval(
{self.t_w_input[name]: self.w[name].eval()})
def train(self, xs, ys, memory_sample_batch):
embeds, _ = self.session.run([self.embed, self.optim],
feed_dict={
self.x:
xs,
self.y:
ys,
self.memory_sample_batch:
memory_sample_batch
})
return embeds
def get_memory_sample(self, batch_size):
xs, ys = self.M.sample(batch_size)
return xs, ys
def add_to_memory(self, xs, ys):
if self.args.sample_add == "normal":
self.M.add(xs, ys)
elif self.args.sample_add == "lru":
self.M.add_lru(xs, ys)
elif self.args.sample_add == "rand":
self.M.add_rand(xs, ys)
elif self.args.sample_add == "knn":
self.M.add_knn(xs, ys)
elif self.args.sample_add == "knn_lru":
self.M.add_knn_lru(xs, ys)
else:
raise Exception(
"error sample adding type, pleace choose in ['normal', 'lru', 'rand']"
)
def test(self, xs_test, ys_test):
# self.update_training_to_prediction()
acc = self.session.run(self.accuracy,
feed_dict={
self.x: xs_test,
self.y: ys_test,
self.memory_sample_batch: 0
})
return acc
@property
def memory_length(self):
return self.M.length
class MbPA:
def __init__(self, sess, args):
with tf.variable_scope(args.model_name):
self.args = args
self.learning_rate = args.learning_rate
self.session = sess
self.x = tf.placeholder(tf.float32, shape=[None, 784], name="x")
self.y = tf.placeholder(tf.float32, shape=[None, 10], name="y")
# self.trainable = tf.placeholder(tf.int32, shape=(), name="trainable")
self.memory_sample_batch = tf.placeholder(
tf.int16, shape=(), name="memory_sample_batch")
self.embed = self.embedding(self.x)
self.M = Memory(args.memory_size,
self.embed.get_shape()[-1],
self.y.get_shape()[-1])
embs_and_values = tf.py_func(self.get_memory_sample,
[self.memory_sample_batch],
[tf.float64, tf.float64])
self.memory_batch_x = tf.to_float(embs_and_values[0])
self.memory_batch_y = tf.to_float(embs_and_values[1])
self.xa = tf.concat(values=[self.embed, self.memory_batch_x],
axis=0)
self.ya = tf.concat(values=[self.y, self.memory_batch_y], axis=0)
self.y_ = self.output_network(self.xa)
self.cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=self.ya,
logits=self.y_))
self.optim = tf.train.GradientDescentOptimizer(
self.learning_rate).minimize(self.cross_entropy)
self.correct_prediction = tf.equal(tf.argmax(self.ya, 1),
tf.argmax(self.y_, 1))
self.accuracy = tf.reduce_mean(
tf.cast(self.correct_prediction, tf.float32))
self.session.run(tf.global_variables_initializer())
def train(self, xs, ys, memory_sample_batch):
# print(memory_sample_batch)
embeds, _ = self.session.run([self.embed, self.optim],
feed_dict={
self.x:
xs,
self.y:
ys,
self.memory_sample_batch:
memory_sample_batch
})
return embeds
def test(self, xs_test, ys_test):
acc = self.session.run(self.accuracy,
feed_dict={
self.x: xs_test,
self.y: ys_test,
self.memory_sample_batch: 0
})
return acc
def get_memory_sample(self, batch_size):
x, y = self.M.sample(batch_size)
return x, y
def add_to_memory(self, xs, ys):
if self.args.sample_add == "normal":
self.M.add(xs, ys)
elif self.args.sample_add == "lru":
self.M.add_lru(xs, ys)
elif self.args.sample_add == "rand":
self.M.add_rand(xs, ys)
elif self.args.sample_add == "knn":
self.M.add_knn(xs, ys)
elif self.args.sample_add == "knn_lru":
self.M.add_knn_lru(xs, ys)
else:
raise Exception(
"error sample adding type, pleace choose in ['normal', 'lru', 'rand']"
)
@staticmethod
def embedding(x):
out = tf.reshape(x, [-1, 28, 28, 1])
# convs = [(16, 8, 4), (32, 4, 2)]
# with tf.variable_scope("conv1"):
# out = layers.convolution2d(inputs=out,
# num_outputs=16,
# kernel_size=8,
# stride=4,
# trainable=trainable)
# out = tf.nn.relu(out)
# out = tf.nn.max_pool(out, ksize=[1, 2, 3, 1], strides=[1, 2, 2, 1], padding="SAME")
with tf.variable_scope("conv2"):
# out = layers.convolution2d(inputs=out,
# num_outputs=32,
# kernel_size=4,
# stride=2,
# trainable=trainable)
# out = tf.nn.relu(out)
# out = tf.nn.max_pool(out, ksize=[1, 2, 3, 1], strides=[1, 2, 2, 1], padding="SAME")
embed = layers.flatten(out)
return embed
@staticmethod
def output_network(embed):
out = embed
with tf.variable_scope("fc_1"):
out = layers.fully_connected(inputs=out, num_outputs=1024)
out = tf.nn.relu(out)
with tf.variable_scope("fc_2"):
out = layers.fully_connected(inputs=out, num_outputs=10)
return out
class MbPA_KNN_Test:
def __init__(self, sess, args):
self.args = args
self.session = sess
self.w = {}
self.eval_w = {}
with tf.variable_scope(self.args.model_name):
self.x = tf.placeholder(tf.float32, shape=[None, 784], name="x")
self.y = tf.placeholder(tf.float32, shape=[None, 10], name="y")
with tf.variable_scope("training"):
with tf.variable_scope("embedding"):
self.out = tf.reshape(self.x, [-1, 28, 28, 1])
with tf.variable_scope("conv"):
# self.out, self.w["l1_w"], self.w["l1_b"] = conv2d(
# x=self.out,
# output_dim=16,
# kernel_size=[8, 8],
# stride=[4, 4],
# activation_fn=tf.nn.relu,
# name="conv1"
# )
# self.out, self.w["l2_w"], self.w["l2_b"] = conv2d(
# x=self.out,
# output_dim=32,
# kernel_size=[4, 4],
# stride=[2, 2],
# activation_fn=tf.nn.relu,
# name="conv2"
# )
self.embed = layers.flatten(self.out)
self.embed_dim = self.embed.get_shape()[-1]
with tf.variable_scope("fc"):
self.out = self.embed
self.out, self.w["l3_w"], self.w["l3_b"] = linear(
input_=self.out,
output_size=1024,
activation_fn=tf.nn.relu,
name="fc_1")
self.out, self.w["l4_w"], self.w["l4_b"] = linear(
input_=self.out, output_size=10, name="fc_2")
self.y_ = self.out
self.cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=self.y,
logits=self.y_))
self.optim = tf.train.GradientDescentOptimizer(
self.args.learning_rate).minimize(self.cross_entropy)
self.correct_prediction = tf.equal(tf.argmax(self.y, 1),
tf.argmax(self.y_, 1))
self.accuracy = tf.reduce_mean(
tf.cast(self.correct_prediction, tf.float32))
self.M = Memory(self.args.memory_size,
self.embed.get_shape()[-1],
self.y.get_shape()[-1])
# print("self.embed_dim: ", self.embed.get_shape().as_list())
with tf.variable_scope("prediction"):
self.x_eval = tf.placeholder(tf.float32,
shape=[None, self.embed_dim],
name="x_test")
self.y_eval = tf.placeholder(tf.float32,
shape=[None, 10],
name="y_test")
with tf.variable_scope("test_fc"):
self.out = self.x_eval
self.out, self.eval_w["l3_w"], self.eval_w[
"l3_b"] = linear(input_=self.out,
output_size=1024,
activation_fn=tf.nn.relu,
name="fc_1")
self.out, self.eval_w["l4_w"], self.eval_w[
"l4_b"] = linear(input_=self.out,
output_size=10,
name="fc_2")
self.y_eval_ = self.out
self.cross_entropy_eval = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(
labels=self.y_eval, logits=self.y_eval_))
self.optim_eval = tf.train.GradientDescentOptimizer(
self.args.learning_rate / 10).minimize(
self.cross_entropy_eval)
self.correct_prediction_eval = tf.equal(
tf.argmax(self.y_eval, 1), tf.argmax(self.y_eval_, 1))
self.accuracy_eval = tf.reduce_mean(
tf.cast(self.correct_prediction_eval, tf.float32))
with tf.variable_scope("training_to_prediction"):
self.t_w_input = {}
self.t_w_assign_op = {}
for name in self.eval_w.keys():
self.t_w_input[name] = tf.placeholder(
tf.float32,
self.w[name].get_shape().as_list(),
name=name)
self.t_w_assign_op[name] = self.eval_w[name].assign(
self.t_w_input[name])
self.session.run(tf.global_variables_initializer())
def update_training_to_prediction(self):
for name in self.eval_w.keys():
self.t_w_assign_op[name].eval(
{self.t_w_input[name]: self.w[name].eval()})
def train(self, xs, ys):
embeds, _ = self.session.run([self.embed, self.optim],
feed_dict={
self.x: xs,
self.y: ys
})
return embeds
def get_memory_sample(self, xs, k=512):
xs, ys, dist = self.M.sample_knn_test(xs, self.args.k)
return xs, ys, dist
def add_to_memory(self, xs, ys):
if self.args.sample_add == "knn":
self.M.add_knn(xs, ys)
elif self.args.sample_add == "knn_lru":
self.M.add_knn_lru(xs, ys)
else:
raise Exception(
"error sample adding type, pleace choose in ['normal', 'lru', 'rand']"
)
def test(self, xs_test, ys_test):
# self.update_training_to_prediction()
test_embed = self.session.run(self.embed, feed_dict={self.x: xs_test})
acc = []
for i in tqdm(range(len(test_embed))):
self.update_training_to_prediction()
xs_test_embed_ = test_embed[i]
xs_test_embed_sample, ys_test_sample, dists = self.get_memory_sample(
xs_test_embed_)
sample_length = np.shape(xs_test_embed_sample)[0]
for j in range(100):
sample_permutation = np.random.permutation(
range(sample_length))
if sample_length < self.args.batch_size:
batch_size = sample_length
else:
batch_size = self.args.batch_size
xs_test_embed_sample_batch = xs_test_embed_sample[
sample_permutation[:batch_size]]
ys_test_sample_batch = ys_test_sample[
sample_permutation[:batch_size]]
self.session.run(self.optim_eval,
feed_dict={
self.x_eval: xs_test_embed_sample_batch,
self.y_eval: ys_test_sample_batch
})
# self.session.run(self.optim_eval,
# feed_dict={
# self.x_eval: xs_test_embed_sample,
# self.y_eval: ys_test_sample
# })
acc_ = self.session.run(self.accuracy_eval,
feed_dict={
self.x_eval: [xs_test_embed_],
self.y_eval: [ys_test[i]]
})
# print("acc_:", acc_)
acc.append(acc_)
acc = np.sum(np.array(acc)) / len(acc)
return acc
@property
def memory_length(self):
return self.M.length