def test(time_steps=25):
d = 128
epochs_n = 100
batch_size = 1
test_batches_per_epoch = 16 * 32
# Create train and test loaders
train_loader = InstanceLoader("train", target_cost_dev=0.25 * 0.04)
test_loader = InstanceLoader("test", target_cost_dev=0.25 * 0.04)
# Build model
print("Building model ...", flush=True)
GNN = build_network_v2(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')
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)),
test_batches_per_epoch):
test_loss[batch_i], test_acc[batch_i], test_sat[
batch_i], test_pred[batch_i] = run_batch_v2(
sess,
GNN,
batch,
batch_i,
epoch_i,
time_steps,
train=False,
verbose=True)
#end
summarize_epoch(epoch_i,
test_loss,
test_acc,
test_sat,
test_pred,
train=False)
def draw_routes():
d = 128
n = 20
bins = 10**6
connectivity = 1
# Build model
print('Building model ...')
model = build_network_v2(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')
k = 3
# Normalize item number values to colormap
norm = mcolors.Normalize(vmin=0, vmax=k**2)
for inst in range(k**2):
instance = create_graph_metric(n, bins, connectivity)
Ma, _, _, nodes = instance
edges = list(zip(np.nonzero(Ma)[0], np.nonzero(Ma)[1]))
predicted_edges = extract_solution(sess, model, instance)
nodes_ = nodes + np.array([inst // k, inst % k])
for (i, j) in edges:
x0, y0 = nodes_[i]
x1, y1 = nodes_[j]
if (i, j) in predicted_edges:
plt.plot([x0, x1], [y0, y1],
color=cm.jet(norm(inst)),
linewidth=1,
zorder=2)
else:
dummy = 0
#plt.plot([x0,x1],[y0,y1], 'r--', linewidth=0.5, zorder=1)
#end
#end
plt.scatter(x=nodes_[:, 0],
y=nodes_[:, 1],
edgecolors='black',
c='w',
zorder=3)
#end
plt.show()
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, gpu_id=0):
# os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
cur_path = os.path.realpath(__file__)
cur_dir = os.path.dirname(cur_path)
cur_list = os.listdir(cur_dir)
model_file_name = "kddata_decoder2_cls12_s2_ep-0065.params"
for cur_file in cur_list:
cur_name_list = cur_file.split(".")
if len(cur_name_list) == 2:
if cur_name_list[1] == "params":
model_file_name = cur_file
self.weights = os.path.join(cur_dir, model_file_name)
colours = os.path.join(cur_dir, 'self_clr.png')
self.label_colours = cv2.imread(colours).astype(np.uint8)
self.ignore_color = (0, 0, 0)
clr_dict = {l.name: l.color for l in self_server_label}
for name, color in clr_dict.items():
if name == u'Ignore':
self.ignore_color = color
break
network, net_args, net_auxs = load_weights(self.weights)
self.scale = 1.0 / 255
self.mean = [0.2476, 0.2469, 0.250]
self.std = [0.1147, 0.1056, 0.0966]
context = [mx.gpu(gpu_id)]
self.mod = mx.mod.Module(network, context=context)
self.result_shape = [1024, 2448]
self.input_shape = [512, 1224]
# self.batch_data_shape = (1, 3, 1024, 2448)
self.batch_data_shape = (1, 3, 512, 1224)
provide_data = [("data", self.batch_data_shape)]
self.batch_label_shape = (1, 3, 512, 612)
provide_label = [("softmax_label", self.batch_label_shape)]
self.mod.bind(provide_data,
provide_label,
for_training=False,
force_rebind=True)
self.mod.init_params(arg_params=net_args, aux_params=net_auxs)
self._flipping = False
self.batch_data = [mx.nd.empty(info[1]) for info in provide_data]
self.batch_label = [mx.nd.empty(info[1]) for info in provide_label]
symbol.cfg['workspace'] = 1024
symbol.cfg['bn_use_global_stats'] = True
def __init__(self, gpu_id=0):
# os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
cur_path = os.path.realpath(__file__)
cur_dir = os.path.dirname(cur_path)
# model_file_name = "densenet-kd-169-0-5000.params"
self.weights = model_file
network, net_args, net_auxs = load_weights(self.weights)
context = [mx.gpu(gpu_id)]
self.mod = mx.mod.Module(network, context=context)
self.input_shape = [224, 224]
self.mod.bind(for_training=False,
data_shapes=[('data', (1, 3, 224, 224))],
label_shapes=None)
self.mod.init_params(arg_params=net_args, aux_params=net_auxs)
self._flipping = False
def __init__(self, gpu_id=0):
# os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
cur_path = os.path.realpath(__file__)
cur_dir = os.path.dirname(cur_path)
cur_list = os.listdir(cur_dir)
model_file_name = model_file
self.weights = os.path.join(cur_dir, model_file_name)
network, net_args, net_auxs = load_weights(self.weights)
context = [mx.gpu(gpu_id)]
self.mod = mx.mod.Module(network, context=context)
self.input_shape = [112, 112]
self.mod.bind(for_training=False,
data_shapes=[('data', (1, 3, 112, 112))],
label_shapes=[('softmax_label', (1, ))])
self.mod.init_params(arg_params=net_args, aux_params=net_auxs)
self._flipping = False
def setup(self):
# load data
self.A,self.b,self.N,self.block_sizes,self.x_true,self.nz,self.f = \
util.load_data(self.f)
self.NT = self.N.T.tocsr()
# Assumption: Gaussian noise is proportional to link volume
if self.noise:
self.b_true = self.b
delta = np.random.normal(scale=self.b * self.noise)
self.b = self.b + delta
self.n = np.size(self.b)
self.x0 = np.array(util.block_e(self.block_sizes - 1,
self.block_sizes))
# self.x0 = self.x_true
logging.debug("Blocks: %s" % self.block_sizes.shape)
self.options = {
'max_iter': self.iter,
'verbose': 1,
'suff_dec': 0.003, # FIXME unused
'corrections': 500
} # FIXME unused
self.proj = lambda x: simplex_projection(self.block_sizes - 1, x)
# self.proj = lambda x: pysimplex_projection(self.block_sizes - 1,x)
self.z0 = np.zeros(self.N.shape[1])
if self.reg and self.weights == 'travel_time':
self.D = util.load_weights('%s/%s/travel_times.pkl' %
(c.DATA_DIR, c.ESTIMATION_INFO_DIR),
self.block_sizes,
weight=1)
self.D2 = self.D * self.D
import utilData
import util
from model import df_basedYolo
from test import evaluate
import tqdm
import time
import os
if __name__ == '__main__':
image_size = 192
device = torch.device('cuda')
now = time.strftime('%y%m%d_%H%M%S', time.localtime(time.time()))
model = df_basedYolo(image_size, device).cuda()
util.load_weights(model)
dataSet = utilData.ListDataset('./dog_dataset/dog_images/',
'./dog_dataset/dog_annotations/',
True,
img_size=image_size)
dataLoader = torch.utils.data.DataLoader(dataSet,
batch_size=64,
shuffle=True,
num_workers=0,
pin_memory=True,
collate_fn=dataSet.collate_fn)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=10,
gamma=0.8)
def main(args):
data = DataLoader(pca=args.PCA, norm=args.norm)
train_captions, train_feature, train_url, train_len = data.get_Training_data(
args.training)
test_captions, test_feature, test_url, test_len = data.get_val_data(
args.testing)
f, c, _ = data.eval_data()
writer = SummaryWriter()
encoder = Encoder(input_size=train_feature.shape[1],
hidden_size=args.hidden_size) \
.to(device)
decoder = Decoder(embed_size=args.embed_size,
hidden_size=args.hidden_size, attention_dim=args.attention_size,
vocab_size=len(data.word_to_idx)) \
.to(device)
if args.load_weight:
load_weights(encoder, args.model_path + "Jul28_10-04-57encoder")
load_weights(decoder, args.model_path + "Jul28_10-04-57decoder")
for epoch in range(args.num_epochs):
params = list(decoder.parameters()) + list(encoder.parameters())
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(params=params, lr=args.learning_rate)
# if epoch >= 100:
training_loss = step(encoder=encoder,
decoder=decoder,
criterion=criterion,
data=(train_captions, train_feature, train_len),
optimizer=optimizer)
# if epoch + 1 % 5 == 0:
# a = evaluate(encoder, decoder, train_feature[0:2], train_captions[0:2], 5, data.word_to_idx)
# print("bleu4 ", a)
with torch.no_grad():
test_loss = step(encoder=encoder,
decoder=decoder,
criterion=criterion,
data=(test_captions, test_feature, test_len))
# if epoch > 1:
b1, b2, b3, b4 = evaluate(encoder, decoder, f, c, 5, data.word_to_idx,
data.idx_to_word)
writer.add_scalars('BLEU', {
'BLEU1': b1,
'BLEU2': b2,
'BLEU3': b3,
'BLEU4': b4
}, epoch + 1)
if (epoch % 30) == 0:
save_weights(encoder, args.model_path + "encoder" + str(epoch))
save_weights(decoder, args.model_path + "decoder" + str(epoch))
writer.add_scalars('loss', {
'train': training_loss,
'val': test_loss
}, epoch + 1)
print(
'Epoch [{}/{}], Loss: {:.4f}, Perplexity: {:5.4f}, TestLoss: {:.4f}, TestPerplexity: {:5.4f}'
.format(epoch + 1, args.num_epochs, training_loss,
np.exp(training_loss), test_loss, np.exp(test_loss)))
args.learning_rate *= 0.995
if args.save_weight:
save_weights(encoder, args.model_path + "encoder" + str(epoch))
save_weights(decoder, args.model_path + "decoder" + str(epoch))
if args.save_weight:
save_weights(encoder, args.model_path + "encoder")
save_weights(decoder, args.model_path + "decoder")
if args.predict:
sample = Sample(encoder=encoder, decoder=decoder, device=device)
train_mask = [
random.randint(0, train_captions.shape[0] - 1)
for _ in range(args.numOfpredection)
]
test_mask = [
random.randint(0, test_captions.shape[0] - 1)
for _ in range(args.numOfpredection)
]
train_featur = torch.from_numpy(train_feature[train_mask])
train_featur = train_featur.to(device)
train_encoder_out = encoder(train_featur)
test_featur = torch.from_numpy(test_feature[test_mask])
test_featur = test_featur.to(device)
test_encoder_out = encoder(test_featur)
train_output = []
test_output = []
for i in range(len(test_mask)):
print(i)
pre = sample.caption_image_beam_search(
train_encoder_out[i].reshape(1, args.embed_size),
data.word_to_idx, 2)
train_output.append(pre)
pre = sample.caption_image_beam_search(
test_encoder_out[i].reshape(1, args.embed_size),
data.word_to_idx, 50)
test_output.append(pre)
print_output(output=test_output,
sample=0,
gt=test_captions[test_mask],
img=test_url[test_mask],
title="val",
show_image=args.show_image,
idx_to_word=data.idx_to_word)
print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
print("")
print_output(output=train_output,
sample=0,
gt=train_captions[train_mask],
img=train_url[train_mask],
title="traning",
show_image=args.show_image,
idx_to_word=data.idx_to_word)
# 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
if load_checkpoints:
load_weights(
sess,
'./TSP-checkpoints-{loss_type}-{target_cost_dev}/epoch=100.0'.
format(loss_type=loss_type, target_cost_dev=target_cost_dev))
print('Performing Stochastic Gradient Descent on {} loss...'.format(
loss_type))
with open(
'TSP-log-{loss_type}-{target_cost_dev}.dat'.format(
loss_type=loss_type, target_cost_dev=target_cost_dev),
'w') as logfile:
# Run for a number of epochs
for epoch_i in 100 + np.arange(epochs_n):
train_loader.reset()
test_loader.reset()
elisa_net = network.ElisaNet(args.c_feat).cuda()
params = [{'params': elisa_net.parameters()}]
solver = optim.Adam(params, lr=args.lr)
lmda = lambda x: 0.5 # TODO: can change this based on bad_epochs
scheduler = LS.MultiplicativeLR(solver, lr_lambda=lmda)
es = EarlyStopping(mode=args.es_mode,
min_delta=args.loss_delta,
patience=args.patience)
epoch = 0
if args.resume_epoch != 0:
load_weights([elisa_net], solver, args.resume_epoch, args)
epoch = args.resume_epoch
solver = lr_resume(solver, args.lr_resume)
print('Loaded weights from epoch {}'.format(args.resume_epoch))
while epoch < args.epochs and not args.eval:
epoch += 1
train_loss, _ = forward_pass(train_loader, elisa_net, solver, scheduler,
'TRAIN', epoch, args)
writer.add_scalars('Train Loss', {'ELISANET': np.mean(train_loss)}, epoch)
if epoch % 50 == 0:
valid_loss, valid_incorrect = forward_pass(valid_loader, elisa_net,
None, None, 'VALIDATE',
g.write(sampled_translation + '\n')
h.write('{0}/{1}\n'.format(count, sample))
bar.update(l + 1)
f.close()
if sample:
g.close()
h.close()
bar.finish()
if __name__ == "__main__":
weightpath = 'trained-weights/eps-40k-ml10-3trans/trained-1-'
parsepath = '../parses/dev/ml10-5trans/'
# parsepath = '../parses/eps-40k-ml10-5trans/'
# savepath = 'prediction/eps-40k-ml10-3trans/'
savepath = 'prediction/nonempty/'
# savepath = 'prediction/dev/ml10-3trans/'
w = load_weights(weightpath)
parses = [load_parses_separate(parsepath, k) for k in range(200)]
predict(parses,
w,
k=1,
savepath=savepath,
scale_weights=False,
sample=False)
# Build model
print('Building model ...', flush=True)
GNN = build_network(d)
# Disallow GPU use
#config = tf.ConfigProto( device_count = {'GPU':0})
with tf.Session() as sess:
# Initialize global variables
print('Initializing global variables ... ', flush=True)
sess.run( tf.global_variables_initializer() )
# Restore saved weights
if load_checkpoints:
start_epoch = load_weights(sess,loadpath)
else:
start_epoch = 0
#end
if not os.path.isdir('training'):
os.makedirs('training')
#end
if not os.path.isdir('training/dev={dev}'.format(dev=dev)):
os.makedirs('training/dev={dev}'.format(dev=dev))
#end
with open('training/dev={dev}/log.dat'.format(dev=dev),'a') as logfile:
# Run for a number of epochs
for epoch_i in np.arange(start_epoch, start_epoch + epochs_n):
print("{timestamp}\t{memory}\tBuilding model ...".format(
timestamp=timestamp(), memory=memory_usage()))
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(
"{timestamp}\t{memory}\tInitializing global variables ... ".format(
timestamp=timestamp(), memory=memory_usage()))
sess.run(tf.global_variables_initializer())
# Restore saved weights
load_weights(sess, "./TSP-checkpoints-{}".format(loss_type))
k = 3
# Run k² tests
n = 40
bins = 10**6
connectivity = 1
#normalize item number values to colormap
norm = mcolors.Normalize(vmin=0, vmax=k**2)
# Create metric TSP instance
route = []
while route == []:
Ma, Mw, route, nodes = create_graph_metric(n, bins, connectivity)
#end
def read_command(argv):
"""
Processes the command used to run pacman from the command line.
"""
from optparse import OptionParser
usage_str = """
USAGE: python checkers.py <options>
EXAMPLES: (1) python checkers.py
- starts a two player game
"""
parser = OptionParser(usage_str)
parser.add_option('-n',
'--numGames',
dest='num_games',
type='int',
help=default('the number of GAMES to play'),
metavar='GAMES',
default=1)
# k for keyboard agent
# ab for alphabeta agent
# rl for reinforcement learning agent
parser.add_option('-f',
'--agentFirstType',
dest='first_agent',
type='string',
help=default('the first agent of game'),
default='k')
parser.add_option(
'-l',
'--agentFirstLearn',
dest='first_agent_learn',
type='int',
help=default('the first agent of game is learning ' +
'(only applicable for learning agents_checker)'),
default=1)
parser.add_option('-s',
'--agentSecondType',
dest='second_agent',
type='string',
help=default('the second agent of game'),
default='k')
parser.add_option(
'-d',
'--agentsecondLearn',
dest='second_agent_learn',
type='int',
help=default('the second agent of game is learning ' +
'(only applicable for learning agents_checker)'),
default=1)
parser.add_option('-t',
'--turn',
dest='turn',
type='int',
help=default('which agent should take first turn'),
default=1)
parser.add_option(
'-r',
'--updateParam',
dest='update_param',
type='int',
help=default('update learning parameters as time passes'),
default=0)
parser.add_option('-q',
'--quiet',
dest='quiet',
type='int',
help=default('to be quiet or not'),
default=0)
parser.add_option(
'-x',
'--firstAgentSave',
dest='first_save',
type='string',
help=default('file to save for the first agent (used only ' +
'if this agent is a learning agent)'),
default='./data/first_save')
parser.add_option(
'-y',
'--secondAgentSave',
dest='second_save',
type='string',
help=default('file to save for the second agent (used only ' +
'if this agent is a learning agent)'),
default='./data/second_save')
parser.add_option(
'-z',
'--firstAgentWeights',
dest='first_weights',
type='string',
help=default('file to save weights for the first agent (used only ' +
'if this agent is a learning agent)'),
default='./data/first_weights')
parser.add_option(
'-w',
'--secondAgentWeights',
dest='second_weights',
type='string',
help=default('file to save weights for the second agent (used only ' +
'if this agent is a learning agent)'),
default='./data/second_weights')
parser.add_option(
'-u',
'--firstResult',
dest='first_results',
type='string',
help=default('file to save results for the first agent (used only ' +
'if this agent is a learning agent)'),
default='./data/first_results')
parser.add_option(
'-v',
'--secondResult',
dest='second_results',
type='string',
help=default('file to save results for the second agent (used only ' +
'if this agent is a learning agent)'),
default='./data/second_results')
parser.add_option(
'-g',
'--firstMResult',
dest='first_m_results',
type='string',
help=default('file to save num moves for the first agent (used only ' +
'if this agent is a learning agent)'),
default='./data/first_m_results')
parser.add_option(
'-i',
'--secondMResult',
dest='second_m_results',
type='string',
help=default(
'file to save num moves for the second agent (used only ' +
'if this agent is a learning agent)'),
default='./data/second_m_results')
parser.add_option(
'-p',
'--playSelf',
dest='play_against_self',
type='int',
help=default('whether first agent is to play agains itself (only' +
'for rl agents_checker)'),
default=0)
options, garbage = parser.parse_args(argv)
if len(garbage) > 0:
raise Exception('Command line input not understood ' + str(garbage))
args = dict()
args['num_games'] = options.num_games
first_weights = load_weights(options.first_weights)
args['first_agent'] = load_agent(options.first_agent,
options.first_agent_learn, first_weights)
second_weights = load_weights(options.second_weights)
args['second_agent'] = load_agent(options.second_agent,
options.second_agent_learn,
second_weights)
args['first_agent_turn'] = options.turn == 1
args['update_param'] = options.update_param
args['quiet'] = True if options.quiet else False
args['first_file_name'] = options.first_save
args['second_file_name'] = options.second_save
args['first_weights_file_name'] = options.first_weights
args['second_weights_file_name'] = options.second_weights
args['first_result_file_name'] = options.first_results
args['second_result_file_name'] = options.second_results
args['first_m_result_file_name'] = options.first_m_results
args['second_m_result_file_name'] = options.second_m_results
args['play_against_self'] = options.play_against_self == 1
return args
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()
if not os.path.exists('figures'): os.makedirs('figures')
# 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, '../training/dev=0.02/checkpoints/epoch=100')
# Init instance loader
loader = InstanceLoader('../instances/test')
avg_deviation = 0
with open('results/binary-search.dat', 'w') as out:
# Get instances from instance loader
for instance in loader.get_instances(len(loader.filenames)):
# Get number of cities
n = instance[0].shape[0]
# Compute cost with binary search
pred_cost, pred_prob, real_cost, iterations = get_cost(
print(aug_type, lam)
folder_name = aug_type + '_' + str(lam) # .replace('.','p')
dirType = '/weights/'
pathMkdir = os.getcwd() + dirType + folder_name + '/fake_samples/'
# mkdir
print(pathMkdir)
try:
os.mkdir(pathMkdir)
except OSError:
print("Creation of the directory %s failed" % pathMkdir)
else:
print("Successfully created the directory %s " % pathMkdir)
#end mkdir
path = os.getcwd() + dirType + folder_name
netG = util.load_weights(netG, path=path+'/netG_epoch_23.pth', device=device)
torch.manual_seed(42)
for i in tqdm(range(20000)):
fixed_noise2 = torch.randn(1, nz, 1, 1, device=device)
fake = netG(fixed_noise2)
vutils.save_image(fake[0, :, :, :].detach(), path + '/fake_samples/fake_sample_%03d.png' % (i),
normalize=True)
print('finish create folders')
# create Real Data folder
# for i, data in enumerate(dataloader, 0):
# real = data[0]
# for j in range(real.shape[0]):
# vutils.save_image(real[j, :, :, :].detach(), 'output/real_samples/real_sample_%03d.png' % (i*real.shape[0]+j), normalize=True)
# %% prepare FID
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()
import pickle
from util import load_weights
from processing import load_parses_separate
savepath1 = 'trained-weights/nonempty/eps-40k-ml10-3trans/trained-1-'
savepath2 = 'trained-weights/eps-40k-ml10-3trans/trained-1-'
w1 = load_weights(savepath1)
w2 = load_weights(savepath2)
def check(w):
for k, v in sorted(w.items(), key=lambda x: x[1], reverse=True):
print('{}'.format(k).ljust(25) + '{}'.format(v))
def compare(w1, w2):
for k, v in sorted(w1.items(), key=lambda x: x[1], reverse=True):
print('{}'.format(k).ljust(25) + '{}'.format(v))
print('\t{}'.format(k).ljust(25) + '{}'.format(w2[k]))
def check_difference(w1, w2):
for k, v in sorted(w1.items(), key=lambda x: x[1], reverse=True):
print('{}'.format(k).ljust(25) + '{}'.format(v - w2[k]))
check(w1)
#compare(w1, w2)
# check_difference(w1, w2)
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'] }
# Create batches of size 1
for (batch_i, batch) in enumerate(loader.get_batches(1, target_cost_dev)):
stats['loss'][batch_i], stats['acc'][batch_i], stats['sat'][batch_i], stats['pred'][batch_i], stats['TP'][batch_i], stats['FP'][batch_i], stats['TN'][batch_i], stats['FN'][batch_i] = run_batch(sess, GNN, batch, batch_i, 0, time_steps, train=False, verbose=True)
#end
# Summarize
summarize_epoch(0,stats['loss'],stats['acc'],stats['sat'],stats['pred'],train=False)
#end
#end
print('Building model ...', flush=True)
GNN = build_network(d)
# Comment the following line to allow GPU use
config = tf.ConfigProto()
#config.gpu_options.per_process_gpu_memory_fraction = 0.5
config.gpu_options.allow_growth=True
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
if load_checkpoints: load_weights(sess,loadpath);
if vars(args)['train']:
ptrain = 'training_'+seed
if not os.path.isdir(ptrain):
os.makedirs(ptrain)
with open(ptrain+'/log.dat','w') as logfile:
# Run for a number of epochs
for epoch_i in np.arange(epochs_n):
train_loader.reset()
train_stats = { k:np.zeros(train_params['batches_per_epoch']) for k in ['loss','acc','sat','pred','TP','FP','TN','FN'] }
print('Training model...', flush=True)
