def build_graph(num_actions):
s, q_network = build_network(num_actions=num_actions, agent_history_length=FLAGS.agent_history_length,
resized_width=FLAGS.resized_width, resized_height=FLAGS.resized_height, name_scope="q-network")
network_params = q_network.trainable_weights
q_values = q_network(s)
st, target_q_network = build_network(num_actions=num_actions, agent_history_length=FLAGS.agent_history_length,
resized_width=FLAGS.resized_width, resized_height=FLAGS.resized_height, name_scope="target-network")
target_network_params = target_q_network.trainable_weights
target_q_values = target_q_network(st)
reset_target_network_params = [target_network_params[i].assign(network_params[i]) for i in range(len(target_network_params))]
a = tf.placeholder("float", [None, num_actions])
y = tf.placeholder("float", [None])
action_q_values = tf.reduce_sum(tf.multiply(q_values, a), reduction_indices=1)
cost = tf.reduce_mean(tf.square(y - action_q_values))
optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
grad_update = optimizer.minimize(cost, var_list=network_params)
graph_ops = {"s" : s,
"q_values" : q_values,
"st" : st,
"target_q_values" : target_q_values,
"reset_target_network_params" : reset_target_network_params,
"a" : a,
"y" : y,
"grad_update" : grad_update}
return graph_ops
def build_graph(num_actions):
# Create shared deep q network
s, q_network = build_network(num_actions=num_actions, agent_history_length=FLAGS.agent_history_length, resized_width=FLAGS.resized_width, resized_height=FLAGS.resized_height)
network_params = q_network.trainable_weights
q_values = q_network(s)
# Create shared target network
st, target_q_network = build_network(num_actions=num_actions, agent_history_length=FLAGS.agent_history_length, resized_width=FLAGS.resized_width, resized_height=FLAGS.resized_height)
target_network_params = target_q_network.trainable_weights
target_q_values = target_q_network(st)
# Op for periodically updating target network with online network weights
reset_target_network_params = [target_network_params[i].assign(network_params[i]) for i in range(len(target_network_params))]
# Define cost and gradient update op
a = tf.placeholder("float", [None, num_actions])
y = tf.placeholder("float", [None])
action_q_values = tf.reduce_sum(tf.mul(q_values, a), reduction_indices=1)
cost = tf.reduce_mean(tf.square(y - action_q_values))
optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
grad_update = optimizer.minimize(cost, var_list=network_params)
graph_ops = {"s" : s,
"q_values" : q_values,
"st" : st,
"target_q_values" : target_q_values,
"reset_target_network_params" : reset_target_network_params,
"a" : a,
"y" : y,
"grad_update" : grad_update}
return graph_ops
def predict(model_path, data_path):
model_dict = torch.load(model_path, map_location='cpu')
c = model_dict['c']
net = build_network('LG_LeNet')
net.load_state_dict(model_dict['net_dict'])
outlier_dist = model_dict['outlier_dist']
ae_net = build_network('LG_LeNet_Autoencoder')
ae_net.load_state_dict(model_dict['ae_net_dict'])
net.to('cuda')
images = read_data(data_path)
output = []
for i in range(len(images)):
outputs = net(torch.tensor(images[i], dtype=torch.float32).to('cuda'))
dist = torch.sum((outputs - c) ** 2, dim=1)
if dist > outlier_dist:
label = 1
print(print(f"label:{label}, abnormal"))
else:
label = 0
print(print(f"label:{label}, normal"))
# print(f"Show output : {output}")
return output
def build_graph(num_actions):
# Create shared deep q network
s, q_network = build_network(num_actions=num_actions, agent_history_length=FLAGS.agent_history_length,
resized_width=FLAGS.resized_width, resized_height=FLAGS.resized_height)
network_params = q_network.trainable_weights
q_values = q_network(s)
# Create shared target network
st, target_q_network = build_network(num_actions=num_actions, agent_history_length=FLAGS.agent_history_length,
resized_width=FLAGS.resized_width, resized_height=FLAGS.resized_height)
target_network_params = target_q_network.trainable_weights
target_q_values = target_q_network(st)
# Op for periodically updating target network with online network weights
reset_target_network_params = [target_network_params[i].assign(network_params[i]) for i in
range(len(target_network_params))]
# Define cost and gradient update op
a = tf.placeholder("float", [None, num_actions])
y = tf.placeholder("float", [None])
action_q_values = tf.reduce_sum(tf.multiply(q_values, a), reduction_indices=1)
cost = tf.reduce_mean(tf.square(y - action_q_values))
optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
grad_update = optimizer.minimize(cost, var_list=network_params)
graph_ops = {"s": s,
"q_values": q_values,
"st": st,
"target_q_values": target_q_values,
"reset_target_network_params": reset_target_network_params,
"a": a,
"y": y,
"grad_update": grad_update}
return graph_ops
def evaluate(X, y, names):
tf.logging.info('building model...')
input_shape = [None, 8 * 8 * 2048]
t_u = tf.placeholder(tf.float32, input_shape, 'u_inputs')
t_v = tf.placeholder(tf.float32, input_shape, 'v_inputs')
t_fu = build_network(t_u)
t_fv = build_network(t_v, reuse=True)
distance = tf.sqrt(tf.reduce_sum((t_fu - t_fv)**2, axis=-1))
optimal_saver = tf.train.Saver(max_to_keep=1)
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
tf.logging.info('restoring...')
optimal_saver.restore(s, FLAGS.ckpt_file)
tf.logging.info('evaluating model...')
d = np.array([
s.run(distance, feed_dict={
t_u: u,
t_v: v
}) for (u, v), y, name in zip(X, y, names)
])
print('avg distance for identities:', d[y == 1].mean())
print('avg distance for non-identities:', d[y == 0].mean())
for threshold in (.1, .2, .3, .4, .5):
labels = (d <= FLAGS.decision_threshold).astype(np.int)
for strategy in ('contrastive_mean', 'most_frequent'):
p = strategies.get(strategy)(labels, d, t=threshold)
accuracy_score = metrics.accuracy_score(y, p)
print(
'score (%s, %.1f): %.2f%%' %
(strategy, threshold, 100 * accuracy_score),
'\nConfusion matrix:\n', metrics.confusion_matrix(y, p),
'\nWrong predictions: %s\n' % names[y != p])
def test(time_steps=32, target_cost_dev=0.05):
test_samples = 32*32
if not os.path.isdir('test'):
print('Creating {} Complete Test instances'.format(test_samples), flush=True)
create_dataset_metric(
20, 20,
1, 1,
bins=10**6,
samples=test_samples,
path='test')
#end
d = 64
epochs_n = 100
batch_size = 1
test_batches_per_epoch = 16*32
# Create test loader
test_loader = InstanceLoader("test")
# Build model
print("Building model ...", flush=True)
GNN = build_network(d)
# Disallow GPU use
config = tf.ConfigProto( device_count = {"GPU":0})
with tf.Session(config=config) as sess:
# Initialize global variables
print("Initializing global variables ... ", flush=True)
sess.run( tf.global_variables_initializer() )
# Restore saved weights
load_weights(sess,'./TSP-checkpoints-decision-0.05/epoch=200.0')
with open('TSP-log.dat','w') as logfile:
# Run for a number of epochs
for epoch_i in range(1):
test_loader.reset()
test_loss = np.zeros(test_batches_per_epoch)
test_acc = np.zeros(test_batches_per_epoch)
test_sat = np.zeros(test_batches_per_epoch)
test_pred = np.zeros(test_batches_per_epoch)
print("Testing model...", flush=True)
for (batch_i, batch) in islice(enumerate(test_loader.get_batches(batch_size, target_cost_dev=target_cost_dev)), test_batches_per_epoch):
test_loss[batch_i], test_acc[batch_i], test_sat[batch_i], test_pred[batch_i] = run_batch(sess, GNN, batch, batch_i, epoch_i, time_steps, train=False, verbose=True)[:4]
#end
summarize_epoch(epoch_i,test_loss,test_acc,test_sat,test_pred,train=False)
def __init__(self,cpkt_file,input_shape):
self.input_x = tf.placeholder(tf.float32,shape = input_shape,name = "input")
self.logit = model.build_network(self.input_x,False,True)
self.input_shape = input_shape
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(cpkt_file)
self.sess = tf.Session()
if ckpt and ckpt.model_checkpoint_path:
global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
saver.restore(self.sess, ckpt.model_checkpoint_path)
print('Loading success, global_step is %s' % global_step)
else:
print('No checkpoint file found')
def eval():
maxstep, image_batch, label_batch = input_data.get_eval_image(
VALPATH, BATCH_SIZE, WIDTH, HEIGHT, CHANNELS)
with tf.Graph().as_default():
input_x = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, WIDTH, HEIGHT, CHANNELS],
name="input")
datamax, datamin, logit = model.build_network(input_x, False, True)
if modeltype == 'NOQUANT': goto.next
print("create eval quantize")
tf.contrib.quantize.create_eval_graph()
label.next
saver = tf.train.Saver()
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(TRAIN_LOGS_DIR)
if ckpt and ckpt.model_checkpoint_path:
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
saver.restore(sess, ckpt.model_checkpoint_path)
print('Loading success, global_step is %s' % global_step)
else:
print('No checkpoint file found')
graph = graph_util.convert_variables_to_constants(
sess, sess.graph_def, ["output"])
modelname = 'frozen_model_NQ.pb'
if modeltype == 'AWAREQUANT': modelname = 'frozen_model_Q.pb'
tf.io.write_graph(graph, VAL_LOGS_DIR, modelname, as_text=False)
if evaltype == 'COUNT':
datamax_, datamin_ = sess.run(
[datamax, datamin], feed_dict={input_x: image_batch[0]})
print(tf.reduce_max(datamax_).eval())
print(tf.reduce_min(datamin_).eval())
else:
acc_count = 0
max_count = maxstep * BATCH_SIZE
for i in range(maxstep):
output = sess.run(logit,
feed_dict={input_x: image_batch[i]})
prediction = np.argmax(output, axis=1)
for j in range(BATCH_SIZE):
print("predict label: %s true label : %s" %
(prediction[j], label_batch[i][j]))
if str(prediction[j]) == str(label_batch[i][j]):
acc_count = acc_count + 1
print("final accuracy is :{:.2f}%".format(100 * acc_count /
max_count))
def test(epoch, ckpt_dir):
network = build_network()
network.load_weights(
ckpt_dir) # Comment récupérer les poids d'une epoch donnée ?
data_test = data_set('test')
inputs = data_test[0]
label = data_test[1]
predicted = network.predict(inputs)
PSNR = psnr(label, predicted)
SSIM = ssim(label, predicted)
print('PSNR :')
print(PSNR)
print('SSIM :')
print(SSIM)
def train(lr=0.01,
batchsize=64,
epochs=5,
ckpt_dir="./checkpoint",
log_dir="log_dir"):
data, label = data_set(phase="train")
Model = build_network()
Model.compile(optimizer=tf.keras.optimizers.Adam(), loss='MSE')
# metrics= skimage.metrics.peak_signal_noise_ratio(image_true, image_test, *, data_range=None))
callbacks = make_callback(ckpt_dir, log_dir)
Model.fit(data,
label,
batch_size=batchsize,
epochs=epochs,
callbacks=callbacks)
def get_skeleton_model(criterion):
model = build_network()
model.cuda()
for module in model.modules():
if isinstance(module, torch.nn.BatchNorm2d):
if hasattr(module, 'weight') and module.weight is not None:
module.weight.data.fill_(1.0)
module.eps = 0.00001
module.momentum = 0.1
else:
module.half()
if isinstance(module, torch.nn.Conv2d) and hasattr(module, 'weight'):
# torch.nn.init.kaiming_uniform_(module.weight, a=math.sqrt(5)) # original
torch.nn.init.kaiming_uniform_(module.weight,
mode='fan_in',
nonlinearity='linear')
# torch.nn.init.xavier_uniform_(module.weight, gain=torch.nn.init.calculate_gain('linear'))
if isinstance(module, torch.nn.Linear) and hasattr(module, 'weight'):
# torch.nn.init.kaiming_uniform_(module.weight, a=math.sqrt(5)) # original
torch.nn.init.kaiming_uniform_(module.weight,
mode='fan_in',
nonlinearity='linear')
# torch.nn.init.xavier_uniform_(module.weight, gain=1.)
class ModelLoss(torch.nn.Module):
def __init__(self, model, criterion):
super(ModelLoss, self).__init__()
self.model = model
self.criterion = criterion
def forward(self, inputs, targets):
inputs = inputs.cuda().to(dtype=torch.half)
targets = targets.cuda(non_blocking=True) #.to(dtype=torch.half)
logits = self.model(inputs)
loss = self.criterion(logits, targets)
return logits, loss
model = ModelLoss(model, criterion)
return model
def eval():
maxstep, image_batch, label_batch = input_data.get_eval_image(
VALPATH, BATCH_SIZE)
with tf.Graph().as_default():
input_x = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, WIDTH, HEIGHT, CHANNELS],
name="input")
logit = model.build_network(input_x, False, True)
if modeltype == 'NOQUANT': goto.next
print("create eval quantize")
tf.contrib.quantize.create_eval_graph()
label.next
saver = tf.train.Saver()
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(TRAIN_LOGS_DIR)
if ckpt and ckpt.model_checkpoint_path:
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
saver.restore(sess, ckpt.model_checkpoint_path)
print('Loading success, global_step is %s' % global_step)
else:
print('No checkpoint file found')
acc_count = 0
max_count = maxstep * BATCH_SIZE
for i in range(maxstep):
output = sess.run(logit, feed_dict={input_x: image_batch[i]})
prediction = np.argmax(output, axis=1)
for j in range(BATCH_SIZE):
print("predict label: %s true label : %s" %
(prediction[j], label_batch[i][j]))
if str(prediction[j]) == str(label_batch[i][j]):
acc_count = acc_count + 1
print("final accuracy is :{:.2f}%".format(100 * acc_count /
max_count))
def draw_routes():
d = 64
n = 20
bins = 10**6
connectivity = 1
# Build model
print('Building model ...')
model = build_network(d)
# Disallow GPU use
config = tf.ConfigProto( device_count = {'GPU':0})
with tf.Session(config=config) as sess:
# Initialize global variables
print('Initializing global variables ...')
sess.run( tf.global_variables_initializer() )
# Restore saved weights
load_weights(sess,'./TSP-checkpoints-decision-0.05/epoch=200.0')
target_cost_dev = +0.05
# Create instance
while True:
instance = create_graph_metric(n,bins,connectivity)
Ma,Mw,route,nodes = instance
edges = list(zip(np.nonzero(Ma)[0],np.nonzero(Ma)[1]))
edge_weights = [ Mw[i,j] for (i,j) in edges ]
_,_, predictions = extract_embeddings_and_predictions(sess, model, instance, time_steps=32, target_cost_dev=target_cost_dev)
if predictions[0] < 1:
break
#end
#end
# Define timesteps range
timesteps = np.arange(2,32+1,10)
# Init figure
f, axes = plt.subplots(1, len(timesteps), dpi=200, sharex=True, sharey=True)
# Iterate over timesteps
for i,(t,ax) in enumerate(zip(timesteps,axes)):
# Fetch embeddings and predictions
vertex_embeddings, edge_embeddings, predictions = extract_embeddings_and_predictions(sess, model, instance, time_steps=t, target_cost_dev=target_cost_dev)
# Obtain 2D vertex embedding projections
vertex_projections = get_projections(vertex_embeddings,2)
# Obtain 2D edge embedding projections
edge_projections = get_projections(edge_embeddings,2)
# Obtain 2-clustering
clusters, cluster_centers = get_k_cluster(edge_embeddings,2)
print('#1 Cluster size, #2 Cluster size: {},{}'.format(len(clusters[0]),len(clusters[1])))
# Set subplot title
ax.set_title('{t} steps\npred:{pred:.0f}%'.format(t=t,pred=100*predictions[0]))
if len(clusters[0]) < len(clusters[1]):
clusters = clusters[::-1]
cluster_centers = cluster_centers[::-1]
#end
# Plot edges
for k in range(1,2):
color = ['red','blue'][k]
for e,(i,j) in enumerate(edges):
if e in clusters[k]:
x0,y0 = nodes[i,:]
x1,y1 = nodes[j,:]
ax.plot([x0,x1],[y0,y1], c=color, linewidth=0.5, zorder=1)
#end
#end
#end
edge_in_route = []
edge_not_in_route = []
for e,(i,j) in enumerate(edges):
if (i,j) in zip(route,route[:1]+route[1:]):
edge_in_route.append(e)
else:
edge_not_in_route.append(e)
#end
#end
ax.scatter(nodes[:,0], nodes[:,1], c='white', edgecolors='black', zorder=2)
#ax.scatter(edge_projections[edge_not_in_route,0],edge_projections[edge_not_in_route,1], c='red', edgecolors='black')
#ax.scatter(edge_projections[edge_in_route,0],edge_projections[edge_in_route,1], c='blue', edgecolors='black')
#ax.scatter(edge_projections[clusters[1],0],edge_projections[clusters[1],1], c='red', edgecolors='black')
#ax.scatter(edge_projections[clusters[0],0],edge_projections[clusters[0],1], c='blue', edgecolors='black')
#end
plt.show()
def evaluate():
vangogh = VanGogh(base_dir=FLAGS.data_dir,
image_shape=[299, 299, 3],
n_jobs=FLAGS.n_jobs,
train_n_patches=FLAGS.nb_patches_loaded,
valid_n_patches=FLAGS.nb_patches_loaded,
test_n_patches=FLAGS.nb_patches_loaded,
random_state=FLAGS.dataset_seed)
train, valid, test = vangogh.load_patches_from_full_images()
X_train, y_train, n_train = map(np.concatenate, zip(train, valid))
del valid
X_test, y_test, n_test = test
X_train /= 255.
X_test /= 255.
X, y, names = combine_pairs_for_evaluation(
X_train,
y_train,
n_train,
X_test,
y_test,
n_test,
anchor_label=1,
patches_used=FLAGS.nb_patches_compared)
del X_train, y_train, n_train, X_test, y_test, n_test, train, test
tf.logging.info('building model...')
image_shape = [299, 299, 3]
batch_shape = [None] + image_shape
t_u = tf.placeholder(tf.float32, batch_shape, 'u_inputs')
t_v = tf.placeholder(tf.float32, batch_shape, 'v_inputs')
t_fu = build_network(t_u)
t_fv = build_network(t_v, reuse=True)
distance = tf.reduce_sum((t_fu - t_fv)**2, axis=-1)
optimal_saver = tf.train.Saver(max_to_keep=1)
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
tf.global_variables_initializer().run()
tf.logging.info('restoring...')
optimal_saver.restore(s, FLAGS.ckpt_file)
tf.logging.info('evaluating model...')
d = np.array(
[s.run(distance, feed_dict={
t_u: u,
t_v: v
}) for u, v in X])
print('avg distance for identities:', d[y == 1].mean())
print('avg distance for non-identities:', d[y == 0].mean())
labels = (d <= FLAGS.decision_threshold).astype(np.int)
for threshold in (7.6e-6, 8e-6, 8.4e-6, 8.6e-6):
for strategy in ('contrastive_mean', ):
p = strategies.get(strategy)(labels, d, t=threshold)
accuracy_score = metrics.accuracy_score(y, p)
print(
'score using', strategy, 'strategy, threshold %f: %.2f%%' %
(threshold, 100 * accuracy_score), '\nConfusion matrix:\n',
metrics.confusion_matrix(y, p),
'\nWrong predictions: %s' % names[y != p])
def train(X_train, y_train, names_train, X_valid, y_valid, names_valid):
os.makedirs('/work/ckpt/vangogh/1-triplets/frozen-base/opt/',
exist_ok=True)
os.makedirs('/work/ckpt/vangogh/1-triplets/frozen-base/progress/',
exist_ok=True)
tf.logging.info('building model...')
input_shape = [None, 8 * 8 * 2048]
with tf.device(FLAGS.device):
i_embedding = tf.placeholder(tf.float32, input_shape,
'input_embedding')
i_a = tf.placeholder(tf.float32, input_shape, 'input_anchors')
i_p = tf.placeholder(tf.float32, input_shape, 'input_positives')
i_n = tf.placeholder(tf.float32, input_shape, 'input_negatives')
with tf.name_scope('embedding_net'):
f_embedding = build_network(i_embedding)
with tf.name_scope('anchor_leg_net'):
f_a = build_network(i_a, is_training=True, reuse=True)
with tf.name_scope('positive_leg_net'):
f_p = build_network(i_p, is_training=True, reuse=True)
with tf.name_scope('negative_leg_net'):
f_n = build_network(i_n, is_training=True, reuse=True)
with tf.name_scope('triplet_loss'):
loss = triplet_loss(f_a, f_p, f_n)
tf.summary.scalar("loss", loss)
merged_summary_op = tf.summary.merge_all()
gs = tf.Variable(0, trainable=False)
with tf.name_scope('train'):
lr = tf.train.exponential_decay(0.001, gs, 250, .5)
optimizer = tf.train.AdamOptimizer(lr).minimize(loss)
opt_saver = tf.train.Saver(max_to_keep=1)
progress_saver = tf.train.Saver()
best_val_loss = np.inf
train_data = triplets_gen(X_train,
y_train,
names_train,
i_embedding,
f_embedding,
batch_size=FLAGS.batch_size,
window_size=FLAGS.window_size)
valid_data = triplets_gen(X_valid,
y_valid,
names_valid,
i_embedding,
f_embedding,
batch_size=FLAGS.batch_size,
window_size=FLAGS.window_size)
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
tf.global_variables_initializer().run()
summary_writer = tf.summary.FileWriter(FLAGS.logs_dir,
graph=tf.get_default_graph())
tf.logging.info('training...')
for it in range(FLAGS.nb_iterations):
a, p, n = next(train_data)
_, _train_loss, summary = s.run(
[optimizer, loss, merged_summary_op],
feed_dict={
i_a: a,
i_p: p,
i_n: n
})
summary_writer.add_summary(summary, it)
if not it % FLAGS.nb_val_interval:
print('#%i train_loss: %f' % (it, _train_loss), end=' ')
a, p, n = next(valid_data)
_val_loss = s.run(loss, feed_dict={i_a: a, i_p: p, i_n: n})
print('val_loss: %f' % _val_loss)
if _val_loss < best_val_loss:
tf.logging.info('val_acc improved from %.4f to %.4f',
best_val_loss, _val_loss)
opt_saver.save(
s,
'/work/ckpt/vangogh/1-triplets/frozen-base/opt/opt.ckpt',
global_step=gs)
best_val_loss = _val_loss
if not it % FLAGS.nb_save_interval:
progress_saver.save(
s,
'/work/ckpt/vangogh/1-triplets/frozen-base/progress/progress.ckpt',
global_step=gs)
def draw_projections():
d = 64
n = 20
bins = 10**6
connectivity = 1
# Build model
print('Building model ...')
model = build_network(d)
# Disallow GPU use
config = tf.ConfigProto( device_count = {'GPU':0})
with tf.Session(config=config) as sess:
# Initialize global variables
print('Initializing global variables ...')
sess.run( tf.global_variables_initializer() )
# Restore saved weights
load_weights(sess,'./TSP-checkpoints-decision-0.05/epoch=100.0')
target_cost_dev = +0.1
# Create instance
while True:
instance = create_graph_metric(n,bins,connectivity)
Ma,Mw,_,nodes = instance
edges = list(zip(np.nonzero(Ma)[0],np.nonzero(Ma)[1]))
edge_weights = [ Mw[i,j] for (i,j) in edges ]
_,_, predictions = extract_embeddings_and_predictions(sess, model, instance, time_steps=32, target_cost_dev=target_cost_dev)
if predictions[0] > 0.7:
break
#end
#end
# Define timesteps range
timesteps = np.arange(20,32+1,4)
# Init figure
f, axes = plt.subplots(1, len(timesteps), dpi=200, sharex=True, sharey=True)
# Iterate over timesteps
for i,(t,ax) in enumerate(zip(timesteps,axes)):
# Fetch embeddings and predictions
vertex_embeddings, edge_embeddings, predictions = extract_embeddings_and_predictions(sess, model, instance, time_steps=t, target_cost_dev=target_cost_dev)
# Compute accuracy
acc = 100*( (target_cost_dev > 0) == (predictions[0] > 0.5) ).astype(float)
# Obtain 2D vertex embedding projections
vertex_projections = get_projections(vertex_embeddings,2)
# Obtain 2D edge embedding projections
edge_projections = get_projections(edge_embeddings,2)
# Set subplot title
ax.set_title('{t} steps\npred:{pred:.0f}%'.format(t=t,acc=acc,pred=100*predictions[0]))
# Plot projections
#ax.scatter(vertex_projections[:,0],vertex_projections[:,1], edgecolors='black')
ax.scatter(edge_projections[:,0],edge_projections[:,1], edgecolors='black', c=edge_weights, cmap='jet')
#end
plt.show()
def predict_supervised(model_path, data_path):
net = build_network('resnet')
net.load_state_dict(torch.load(model_path))
net.eval()
# file open
label_true = []
label_pred = []
f = open(data_path, 'r')
header = f.readline() # ignore first line if header
t_new = t_old = time.time()
idx = 0
while 1:
line = f.readline()
if not line:
break
#label
label_true.append(int(line[0]))
# data
line = line[1:].strip().split('\t')
line[1] = int(line[1][1])
data = np.array(line, dtype=np.float32)
# preprocess each line
freqs_image = preprocess(data)
# freqs_image = preprocess_spectrogram(data) # for spectrogram
freqs_image = torch.Tensor(freqs_image).unsqueeze(0)
# predict
output = net(freqs_image)
output = round(float(output[0][0]))
label_pred.append(int(output))
# print(int(output))
idx += 1
if idx % 1000 == 0:
t_new = time.time()
print(idx, f'{(t_new - t_old):.2f}초 / 1000개, 초당 {(1000 / (t_new - t_old)):.2f}개')
t_old = time.time()
print('label_true : ', label_true)
print('label_pred : ', label_pred)
# ploting confusion matrix
matrix = confusion_matrix(label_true, label_pred)
print('confusion matrix : ', matrix)
total=sum(sum(matrix))
#####from confusion matrix calculate accuracy
accuracy=(matrix[0,0]+matrix[1,1])/total
print ('Accuracy : ', accuracy)
sensitivity = matrix[0,0]/(matrix[0,0]+matrix[0,1])
print('Sensitivity(recall) : ', sensitivity )
specificity = matrix[1,1]/(matrix[1,0]+matrix[1,1])
print('Specificity : ', specificity)
precision = matrix[0,0]/(matrix[0,0]+matrix[1,0])
print('Precision : ', precision)
f1 = 2 * (precision * sensitivity) / (precision+ sensitivity)
print('F1 Score : ', f1)
print("\n\nSensitivity or recall: TP / (TP + FN) // 맞는 케이스에 대해 얼마나 많이 맞다고 실제로 예측했나?")
print("Specificity: TN / (FP + TN) // 틀린 케이스에 대해 얼마나 틀리다고 실제로 예측했나?")
print("Precision: TP / (TP + FP) // 맞다고 예측 한 것 중에 실제로 정답이 얼마나 되나?")
fig, ax = plot_confusion_matrix(conf_mat=matrix,
show_absolute=True,
show_normed=True,
colorbar=True)
plt.plot()
plt.savefig('/workspace/confusion.png')
y = np.array([1, 1, 2, 2])
scores = np.array([0.1, 0.4, 0.35, 0.8])
fpr, tpr, thresholds = roc_curve(label_true, label_pred, pos_label=2)
roc_auc = auc(fpr, tpr)
# fig, ax = plot_roc_curve(1, label_true, label_pred)
plt.plot()
plt.savefig('/workspace/roc_curve.png')
def train_net():
#------进入计算图--------
x_train, y_train, x_val, y_val = input_data.read_img(
FILEPATH, WIDTH, HEIGHT, CHANNELS, ratio)
x_train_batch, y_train_batch = input_data.bulid_batch(
x_train, y_train, BATCH_SIZE)
x_val_batch, y_val_batch = input_data.bulid_batch(x_val, y_val, BATCH_SIZE)
batch_train_len = x_train_batch.shape[0]
batch_val_len = x_val_batch.shape[0]
#定义网络 x为输入占位符 y为输出占位符
#image_max = tf.reduce_max(x_train, name='image_max')
#image_min = tf.reduce_min(x_train,name='image_min')
x = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, HEIGHT, WIDTH, CHANNELS],
name='input')
y = tf.placeholder(tf.int64, shape=[BATCH_SIZE], name='labels_placeholder')
_, _, softmax_linear = model.build_network(x, True, False)
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits\
(logits=softmax_linear, labels=y, name='xentropy_per_example')
train_loss = tf.reduce_mean(cross_entropy, name='loss')
if modeltype == 'NOQUANT': goto.end
#fake quant插入到op之前
tf.contrib.quantize.create_training_graph(
input_graph=tf.get_default_graph(), quant_delay=2000)
label.end
train_step = trainning(train_loss, LEARNING_RATE)
#准确略计算
correct = tf.nn.in_top_k(softmax_linear, y, 1)
correct = tf.cast(correct, tf.float16)
train_acc = tf.reduce_mean(correct)
#------------结束计算图-------------
with tf.Session() as sess:
saver = tf.compat.v1.train.Saver()
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
valstep = 0
#max = sess.run(image_max)
#min = sess.run(image_min)
#训练
try:
ckpt = tf.train.get_checkpoint_state(TRAIN_LOGS_DIR)
global_step = 0
if ckpt and ckpt.model_checkpoint_path:
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
saver.restore(sess, ckpt.model_checkpoint_path)
print('Loading success, global_step is %s' % global_step)
for i in range(MAX_STEP + 1):
#if_train = True
pos = i % batch_train_len
_, acc, loss = sess.run([train_step, train_acc, train_loss],
feed_dict={
x: x_train_batch[pos],
y: y_train_batch[pos]
})
#每50步打印一次准确率和损失函数
if i % 50 == 0:
print(
'Step %d, train loss = %.2f, train accuracy = %.2f%%' %
(i, loss, acc * 100.0))
#每200步用验证集的数据进行验证
if i % 200 == 0:
#if_train = False #量化模式下用变量替代占位符.注意 如果要用tflite的话,if_train不要用占位符！
vpos = valstep % batch_val_len
val_loss, val_acc = sess.run([train_loss, train_acc],
feed_dict={
x: x_val_batch[vpos],
y: y_val_batch[vpos]
})
valstep = valstep + 1
print(
'** Step %d, val loss = %.2f, val accuracy = %.2f%% **'
% (i, val_loss, val_acc * 100.0))
#每500步保存一次变量值
if i % 500 == 0:
checkpoint_path = os.path.join(TRAIN_LOGS_DIR,
'saved_model.ckpt')
tmpstep = i + int(global_step)
saver.save(sess, checkpoint_path, global_step=tmpstep)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def _build_network(self):
return build_network(self.state_shape, self.nb_actions, self.device, self.network_size)
def main(xp_path,
network,
optimizer_name,
c,
eta,
lr,
n_epochs,
batch_size,
lr_milestones,
weight_decay,
ae_optimizer_name,
ae_lr,
ae_n_epochs,
ae_lr_milestone,
ae_batch_size,
ae_weight_decay,
device,
n_jobs_dataloader,
stage_n_degc=None):
"""
xp_path : 결과물 출력할 폴더의 절대 경로
"""
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
log_file = xp_path + '/log.txt'
export_model = xp_path + '/models/DeepSADModel.tar'
file_handler = logging.FileHandler(log_file)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
train_set = LGDataset(root='/workspace/eddie/ai_championship/data',
dataset_name='lg_train',
train=True,
random_state=None,
stage_n_degc=False)
idx, _, semi_targets = create_semisupervised_setting(
train_set.targets.cpu().data.numpy(),
normal_classes=(0, ),
outlier_classes=(1, ),
known_outlier_classes=(),
ratio_known_normal=0,
ratio_known_outlier=0,
ratio_pollution=0)
train_set.semi_targets[idx] = torch.tensor(semi_targets, dtype=torch.int32)
train_set = Subset(train_set, idx)
test_set = LGDataset(root='/workspace/eddie/ai_championship/data',
dataset_name='lg_train',
train=False,
random_state=None,
stage_n_degc=False)
ae_train = AETrainer(ae_optimizer_name, ae_lr, ae_n_epochs,
ae_lr_milestone, ae_batch_size, ae_weight_decay,
device, n_jobs_dataloader)
deep_sad_train = DeepSADTrainer(c, eta, optimizer_name, lr, n_epochs,
lr_milestones, batch_size, weight_decay,
device, n_jobs_dataloader)
# Register your network in model.py
ae_net = build_network('LG_LeNet_Autoencoder')
net = build_network('LG_LeNet')
ae_net = ae_train.train(train_set, ae_net)
net_dict = net.state_dict()
ae_net_dict = ae_net.state_dict()
ae_net_dict = {k: v for k, v in ae_net_dict.items() if k in net_dict}
# Overwrite values in the existing state_dict
net_dict.update(ae_net_dict)
# Load the new state_dict
net.load_state_dict(net_dict)
net, c = deep_sad_train.train(train_set, net)
outlier_dist = deep_sad_train.test(test_set, net)
# save model
net_dict = net.state_dict()
ae_net_dict = ae_net.state_dict()
torch.save(
{
'c': c,
'net_dict': net_dict,
'ae_net_dict': ae_net_dict,
'outlier_dist': outlier_dist
}, export_model)
def main(argv):
#load data
test_data_1 = np.load(FLAGS.data_dir + 'test_x_1.npy')
test_data_2 = np.load(FLAGS.data_dir + 'test_x_2.npy')
test_data_3 = np.load(FLAGS.data_dir + 'test_x_3.npy')
test_data_4 = np.load(FLAGS.data_dir + 'test_x_4.npy')
test_data = [test_data_1, test_data_2, test_data_3, test_data_4]
test_labels_1 = np.load(FLAGS.data_dir + 'test_y_1.npy')
test_labels_2 = np.load(FLAGS.data_dir + 'test_y_2.npy')
test_labels_3 = np.load(FLAGS.data_dir + 'test_y_3.npy')
test_labels_4 = np.load(FLAGS.data_dir + 'test_y_4.npy')
test_labels = [test_labels_1, test_labels_2, test_labels_3, test_labels_4]
train_data_1 = np.load(FLAGS.data_dir + 'train_x_1.npy')
train_data_2 = np.load(FLAGS.data_dir + 'train_x_2.npy')
train_data_3 = np.load(FLAGS.data_dir + 'train_x_3.npy')
train_data_4 = np.load(FLAGS.data_dir + 'train_x_4.npy')
train_data = [train_data_1, train_data_2, train_data_3, train_data_4]
train_labels_1 = np.load(FLAGS.data_dir + 'train_y_1.npy')
train_labels_2 = np.load(FLAGS.data_dir + 'train_y_2.npy')
train_labels_3 = np.load(FLAGS.data_dir + 'train_y_3.npy')
train_labels_4 = np.load(FLAGS.data_dir + 'train_y_4.npy')
train_labels = [
train_labels_1, train_labels_2, train_labels_3, train_labels_4
]
#count data
test_count = [
test_data[0].shape[0], test_data[1].shape[0], test_data[2].shape[0],
test_data[3].shape[0]
]
train_count = [
train_data[0].shape[0], train_data[1].shape[0], train_data[2].shape[0],
train_data[3].shape[0]
]
#specify model
input_placeholder = tf.placeholder(tf.float32, [None, 16641],
name='input_placeholder')
my_network = tf.identity(model.build_network(input_placeholder),
name='output2')
#define classification loss
#code adapted from Paul Quint's hackathon 3
REG_COEFF = 0.0001
labels = tf.placeholder(tf.float32, [None, 7], name='labels')
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=labels,
logits=my_network)
confusion_matrix_op = tf.confusion_matrix(tf.argmax(labels, axis=1),
tf.argmax(my_network, axis=1),
num_classes=7)
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = cross_entropy + REG_COEFF * sum(regularization_losses)
#set up training and saving
#code adapted from Paul Quint's hackathon 3
global_step_tensor = tf.get_variable('global_step',
trainable=False,
shape=[],
initializer=tf.zeros_initializer)
optimizer = tf.train.AdamOptimizer()
train_op = optimizer.minimize(total_loss, global_step=global_step_tensor)
saver = tf.train.Saver()
sum_cross_entropy = tf.reduce_mean(cross_entropy)
EPOCHS_BEFORE_STOPPING = 12
#run the actual training
#code adapted from Paul Quint's hackathon 3
with tf.Session() as session:
session.run(tf.global_variables_initializer())
best_test_conf_mxs = []
best_epoch = [0, 0, 0, 0]
best_test_ce = [10, 10, 10, 10]
best_train_ce = [0, 0, 0, 0]
best_classification_rate = [0, 0, 0, 0]
epochs_since_best = [0, 0, 0, 0]
for k in range(0, 4):
session.run(tf.global_variables_initializer())
batch_size = FLAGS.batch_size
print("\n !!!!! NEW K (" + str(k) + ") !!!!!\n")
for epoch in range(FLAGS.max_epoch_num):
print("################### EPOCH " + str(epoch) +
" #####################")
print("##################################################\n")
ce_vals = []
for i in range(train_count[k] // batch_size):
batch_data = train_data[k][i * batch_size:(i + 1) *
batch_size, :]
batch_labels = train_labels[k][i * batch_size:(i + 1) *
batch_size]
_, train_ce = session.run([train_op, sum_cross_entropy], {
input_placeholder: batch_data,
labels: batch_labels
})
ce_vals.append(train_ce)
avg_train_ce = sum(ce_vals) / len(ce_vals)
best_train_ce[k] = avg_train_ce
print('TRAIN CROSS ENTROPY: ' + str(avg_train_ce))
print("\n##################################################")
# run gradient steps and report mean loss on train data
ce_vals = []
conf_mxs = []
for i in range(test_count[k] // batch_size):
batch_data = test_data[k][i * batch_size:(i + 1) *
batch_size, :]
batch_labels = test_labels[k][i * batch_size:(i + 1) *
batch_size]
test_ce, conf_matrix = session.run(
[sum_cross_entropy, confusion_matrix_op], {
input_placeholder: batch_data,
labels: batch_labels
})
ce_vals.append(test_ce)
conf_mxs.append(conf_matrix)
avg_test_ce = sum(ce_vals) / len(ce_vals)
classification_rate = util.classification_rate(sum(conf_mxs), 7)
print('TEST CROSS ENTROPY: ' + str(avg_test_ce))
print('TEST CONFUSION MATRIX:')
print(str(sum(conf_mxs)))
print('TEST CLASSIFICATION RATE:' + str(classification_rate))
best_test_conf_mxs.append(sum(conf_mxs))
best_test_ce[k] = avg_test_ce
best_classification_rate[k] = classification_rate
print('Confusion Matrix: ')
print(str(sum(best_test_conf_mxs)))
print('Avg Test CE: ' + str(np.average(best_test_ce)))
print('Avg Train CE: ' + str(np.average(best_train_ce)))
print('Avg Classification Rate: ' +
str(np.average(best_classification_rate)))
print('Generating model now...')
session.run(tf.global_variables_initializer())
for j in range(0, 4):
for epoch in range(FLAGS.max_epoch_num):
for i in range(train_count[j] // batch_size):
batch_data = train_data[j][i * batch_size:(i + 1) *
batch_size, :]
batch_labels = train_labels[j][i * batch_size:(i + 1) *
batch_size]
_, train_ce = session.run([train_op, sum_cross_entropy], {
input_placeholder: batch_data,
labels: batch_labels
})
saver.save(session, FLAGS.save_dir)
print('Model is generated and saved')
parser.add_argument('-checkpoint', default='training/dev=0.02/checkpoints/epoch=100', help='Path for the checkpoint of the trained model')
# Parse arguments from command line
args = parser.parse_args()
# Setup parameters
d = vars(args)['d']
time_steps = vars(args)['time_steps']
target_cost_dev = vars(args)['dev']
# Create instance loader
loader = InstanceLoader(vars(args)['instances'])
# Build model
print('Building model ...', flush=True)
GNN = build_network(d)
# Disallow GPU use
config = tf.ConfigProto( device_count = {'GPU':0})
with tf.Session(config=config) as sess:
# Initialize global variables
print("Initializing global variables ... ", flush=True)
sess.run( tf.global_variables_initializer() )
# Restore saved weights
load_weights(sess,vars(args)['checkpoint']);
n_instances = len(loader.filenames)
stats = { k:np.zeros(n_instances) for k in ['loss','acc','sat','pred','TP','FP','TN','FN'] }
losses.append((d_loss.item(), g_loss.item()))
# print discriminator and generator loss
print(
'Epoch [{:5d}/{:5d}] | d_loss: {:6.4f} | g_loss: {:6.4f}'.
format(epoch + 1, n_epochs, d_loss.item(), g_loss.item()))
## AFTER EACH EPOCH##
# this code assumes your generator is named G, feel free to change the name
# generate and save sample, fake images
G.eval() # for generating samples
samples_z = G(fixed_z)
samples.append(samples_z)
G.train() # back to training mode
# Save training generator samples
with open('train_samples.pkl', 'wb') as f:
pkl.dump(samples, f)
# finally return losses
return losses
if __name__ == '__main__':
D, G = build_network(args.d_conv_dim, args.g_conv_dim, args.z_size)
d_optimizer = optim.Adam(D.parameters(), args.lr, (args.beta1, args.beta2))
g_optimizer = optim.Adam(G.parameters(), args.lr, (args.beta1, args.beta2))
celeba_train_loader = get_dataloader(args.batch_size, args.img_size)
losses = train(D, G, n_epochs=args.n_epochs)
if args.logLevel:
logging.basicConfig()
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.basicConfig(level=getattr(logging, 'INFO'))
###############################################################################
# Begin actual work
###############################################################################
BATCH_SIZE = args.BATCH_SIZE
NUM_WORKERS = args.NUM_WORKERS
# Build the model
model = build_network()
def generator():
for s1, s2, s3 in zip(ds_a, ds_p, ds_n):
yield {
"anchor": format_example(s1, img_size=args.patch_size),
"pos_img": format_example(s2, img_size=args.patch_size),
"neg_img": format_example(s3, img_size=args.patch_size)
}, [1, 1, 0]
def vgenerator():
for s1, s2, s3 in zip(vds_a, vds_p, vds_n):
yield {
"anchor": format_example(s1, img_size=args.patch_size),
def train():
os.makedirs('/work/ckpt/1-triplets/training-from-scratch/opt/', exist_ok=True)
os.makedirs('/work/ckpt/1-triplets/training-from-scratch/progress/', exist_ok=True)
tf.logging.info('building model...')
image_shape = [299, 299, 3]
batch_shape = [None] + image_shape
with tf.device(FLAGS.device):
i_embedding = tf.placeholder(tf.float32, batch_shape, 'input_embedding')
i_a = tf.placeholder(tf.float32, batch_shape, 'input_anchors')
i_p = tf.placeholder(tf.float32, batch_shape, 'input_positives')
i_n = tf.placeholder(tf.float32, batch_shape, 'input_negatives')
f_embedding = build_network(i_embedding, is_training=True)
f_a = build_network(i_a, is_training=True, reuse=True)
f_p = build_network(i_p, is_training=True, reuse=True)
f_n = build_network(i_n, is_training=True, reuse=True)
loss_op = triplet_loss(f_a, f_p, f_n)
tf.summary.scalar("loss", loss_op)
merged_summary_op = tf.summary.merge_all()
gs = tf.Variable(0, trainable=False)
lr = tf.train.exponential_decay(0.001, gs, 20000, .5)
opt_op = tf.train.AdamOptimizer(lr).minimize(loss_op)
optimal_saver = tf.train.Saver(max_to_keep=1)
progress_saver = tf.train.Saver()
best_val_loss = np.inf
g = ImageDataGenerator(rescale=1. / 255.)
train_data = g.flow_from_directory(
os.path.join(FLAGS.data_dir, 'extracted_patches', 'train'),
target_size=image_shape[:2], augmentations=('brightness', 'contrast'),
batch_size=FLAGS.window_size, shuffle=True, seed=None)
valid_data = g.flow_from_directory(
os.path.join(FLAGS.data_dir, 'extracted_patches', 'valid'),
target_size=image_shape[:2], augmentations=('brightness', 'contrast'),
batch_size=FLAGS.window_size, shuffle=True, seed=None)
train_data = triplets_gen_from_gen(train_data, i_embedding, f_embedding,
batch_size=FLAGS.batch_size)
valid_data = triplets_gen_from_gen(valid_data, i_embedding, f_embedding,
batch_size=FLAGS.batch_size)
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
tf.global_variables_initializer().run()
summary_writer = tf.summary.FileWriter(FLAGS.logs_dir, graph=tf.get_default_graph())
tf.logging.info('training...')
for it in range(FLAGS.nb_iterations):
a, p, n = next(train_data)
_, _train_loss, summary = s.run([opt_op, loss_op, merged_summary_op],
feed_dict={i_a: a, i_p: p, i_n: n})
summary_writer.add_summary(summary, it)
if not it % FLAGS.nb_val_interval:
print('#%i train_loss: %f' % (it, _train_loss), end=' ')
val_loss = val_samples_seen = 0
val_batches_seen = 0
while val_samples_seen < FLAGS.nb_val_samples:
a, p, n = next(valid_data)
val_loss += s.run(loss_op, feed_dict={i_a: a, i_p: p, i_n: n})
val_batches_seen += 1
val_samples_seen += len(a)
val_loss /= val_batches_seen
print('val_loss: %f' % val_loss)
if val_loss < best_val_loss:
tf.logging.info('val_acc improved from %.4f to %.4f', best_val_loss, val_loss)
optimal_saver.save(s, '/work/ckpt/1-triplets/training-from-scratch/opt/'
'opt.ckpt', global_step=gs)
best_val_loss = val_loss
if not it % FLAGS.nb_save_interval:
progress_saver.save(s, '/work/ckpt/1-triplets/training-from-scratch/progress/'
'progress.ckpt', global_step=gs)
