def __init__(self, files):
super().__init__()
self.network = Network()
self.loader = DataLoader(files)
self.subject_view = None
self.num_trained = 0
self.previous = []
self.draw_mode = App.DRAW_NONE
self.setGeometry(100, 100, 500, 500)
self.path = None
self.next()
def get_model(cfg, num_classes, device, logger):
model = Network(cfg, mode="train", num_classes=num_classes)
if cfg.BACKBONE.FREEZE == True:
model.freeze_backbone()
logger.info("Backbone has been freezed")
if cfg.CPU_MODE:
model = model.to(device)
else:
model = torch.nn.DataParallel(model).cuda()
return model
def get_model(cfg, num_classes, device, logger):
model = Network(cfg, mode="train", num_classes=num_classes)
if cfg.BACKBONE.FREEZE == True:
model.freeze_backbone()
logger.info("Backbone has been freezed")
if not cfg.DATASET.GENERATE_CAM_BASED_DATASET and cfg.TRAIN.DISTRIBUTED:
if cfg.TRAIN.SYNCBN:
model = apex.parallel.convert_syncbn_model(model)
else:
model = model.cuda()
return model
def __init__(self,
bind_address="INADDR_ANY",
bind_port=5354,
multicast_address="224.1.2.3",
multicast_port=5355):
if bind_address == "localhost":
self.bind_address = net.get_local_ip_address()
else:
self.bind_address = bind_address
self.bind_port = bind_port
self.multicast_address = multicast_address
self.multicast_port = multicast_port
self.multicast_group = (multicast_address, multicast_port)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
try:
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
except AttributeError:
pass
if hasattr(self.sock, 'SO_REUSEPORT'):
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, True)
ttl = struct.pack('b', Multicast.ttl)
self.sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, ttl)
def send(self, message):
localhost = network.get_local_ip_address()
self.logger.debug('UDP send for host ' + localhost + ", message: " +
message)
self.logger.debug("To: " + self.dest_address + " / " +
str(self.dest_port))
self.sock.sendto(message, (self.dest_address, self.dest_port))
def get_model(cfg, num_classes, device, logger):
if 'decouple' in cfg.NAME:
if cfg.TRAIN_STAGE == 1:
model = Network1(cfg, mode="train", num_classes=num_classes)
else:
model = Network(cfg,
mode="train",
num_classes=int(sum(num_classes) / 100) * 100)
else:
if isinstance(num_classes, list) and not cfg.MULTI_BRANCH:
model = Network1(cfg, mode="train", num_classes=num_classes)
elif isinstance(num_classes, list) and cfg.MULTI_BRANCH:
model = Network2(cfg, mode="train", num_classes=num_classes)
else:
model = Network(cfg, mode="train", num_classes=num_classes)
if cfg.BACKBONE.FREEZE == True:
model.freeze_backbone()
logger.info("Backbone has been freezed")
if cfg.CPU_MODE:
model = model.to(device)
else:
model = torch.nn.DataParallel(model).cuda()
return model
def run():
image = read()
input = list(read_image(image))
net = Network.load(LAYER1_FILENAME)
hidden = net.forward(input)
for _ in xrange(5):
print_images([net.backwards(hidden)])
def validate(args):
torch.cuda.set_device(0)
test_set = Dataset(args.test_path, args.u_mask_path, args.s_mask_up_path, args.s_mask_down_path, args.test_sample_rate)
test_loader = DataLoader(dataset=test_set, batch_size=args.batch_size, shuffle=False, pin_memory=True)
model = Network(num_layers=args.num_layers, rank=0)
# load checkpoint
model_path = os.path.join(args.model_save_path, 'best_checkpoint.pth.tar')
assert os.path.isfile(model_path)
checkpoint = torch.load(model_path, map_location='cuda:{}'.format(0))
model.load_state_dict(checkpoint['model'])
print('The model is loaded.')
model = model.up_network.cuda(0)
print('Now testing {}.'.format(args.exp_name))
model.eval()
with torch.no_grad():
average_psnr, average_ssim, average_psnr_zerof, average_ssim_zerof, average_time, total_num = 0.0, 0.0, 0.0, 0.0, 0.0, 0
t = tqdm(test_loader, desc='testing', total=int(len(test_loader)))
for iter_num, data_batch in enumerate(t):
label = data_batch[0].to(0, non_blocking=True)
mask_under = data_batch[1].to(0, non_blocking=True)
# fname = data_batch[4]
# slice_id = data_batch[5]
under_img = rAtA(label, mask_under)
# inference
start_time = time.time()
output, _ = model(under_img.permute(0, 3, 1, 2).contiguous(), mask_under)
infer_time = time.time() - start_time
average_time += infer_time
output = output.permute(0, 2, 3, 1).contiguous()
# calculate and print test information
under_img, output, label = under_img.detach().cpu().numpy(), output.detach().cpu().numpy(), label.float().detach().cpu().numpy()
total_num += under_img.shape[0]
batch_psnr, batch_ssim, batch_psnr_zerof, batch_ssim_zerof = 0.0, 0.0, 0.0, 0.0
for i in range(under_img.shape[0]):
under_slice, output_slice, label_slice = under_img[i].squeeze(), output[i].squeeze(), label[i].squeeze()
psnr = peak_signal_noise_ratio(label_slice, output_slice, data_range=label_slice.max())
psnr_zerof = peak_signal_noise_ratio(label_slice, under_slice, data_range=label_slice.max())
ssim = structural_similarity(label_slice, output_slice, data_range=label_slice.max())
ssim_zerof = structural_similarity(label_slice, under_slice, data_range=label_slice.max())
batch_psnr += psnr
batch_ssim += ssim
batch_psnr_zerof += psnr_zerof
batch_ssim_zerof += ssim_zerof
average_psnr += batch_psnr
average_ssim += batch_ssim
average_psnr_zerof += batch_psnr_zerof
average_ssim_zerof += batch_ssim_zerof
average_psnr /= total_num
average_ssim /= total_num
average_psnr_zerof /= total_num
average_ssim_zerof /= total_num
average_time /= total_num
print('average_time:{:.5f}s\tzerof_psnr:{:.5f}\tzerof_ssim:{:.5f}\ttest_psnr:{:.5f}\ttest_ssim:{:.5f}'.format(
average_time, average_psnr_zerof, average_ssim_zerof, average_psnr, average_ssim))
def check_loop(l):
net = Network(cube)
prev_rotation = -1
while(True):
try:
l.acquire()
cube.check_rotation()
current_rotation = cube.get_rotation()
l.release()
if(current_rotation != prev_rotation):
#Send it to the server
logging.info('Rotation changed from ', prev_rotation, ' to ', current_rotation)
rot = Rotation(current_rotation, datetime.datetime.now())
net.send_rotation_data(rot)
prev_rotation = current_rotation
time.sleep(10)
except StandardError, e:
print e
logging.error("Generic Error! " + str(e))
def run():
net = Network.load(LAYER1_FILENAME)
input = [.0] * IMAGE_DIM * IMAGE_DIM
while True:
hidden = net.forward(input)
input = net.backwards(hidden)
print_images([input])
time.sleep(.075)
def test():
import torch.optim as optim
import numpy as np
net = Network(128)
opt = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
updater = Updater(net, opt)
x = torch.Tensor([[0.4, 0.3], [0.5, 0.9]])
t = torch.Tensor([[0.7, 0.1, 0.12], [1.4, -0.4, 0.45]])
mc = np.array([2, 2, 1])
sc = np.array([0, -1, 0])
print(net(x).data.numpy() * mc + sc)
for i in range(10000):
loss = updater.step(x, t)
if i % 1000 + 1 == 1000:
print("iter {} : {}".format(i + 1, loss))
print(net(x).data.numpy() * mc + sc)
def train_model():
"""
This function will train model
Tips: Load test,validation data first
Then, seperately load training data, since training data is really huge.
:return:
"""
path = '/home/jht00622/wiki_new.pkl'
data = load_data(path)
## extract different type data
train_dataset = data['train_dataset'] / 255
train_age_labels = data['train_age_labels']
#train_gender_labels = data['train_gender_labels']
valid_dataset = data['valid_dataset'] / 255
valid_age_labels = data['valid_age_labels']
#valid_gender_labels = data['valid_gender_labels']
test_dataset = data['test_dataset'] / 255
test_age_labels = data['test_age_labels']
#test_gender_labels = data['test_gender_labels']
hight = 128
channel = 1
batch_size = 50
learn_rate = 0.001
n_output = 4
total_size = train_dataset.shape[0]
net = Network(n_output=n_output,
n_length=hight,
learning_rate=learn_rate,
batch_size=batch_size,
channel=channel,
output_graph=False,
use_ckpt=False)
num_steps = 50000
for i in range(num_steps):
# randomly sample batch memory from all memory
indices = np.random.permutation(total_size)[:batch_size]
batch_x = train_dataset[indices, :, :, :]
batch_y = train_age_labels[indices, :]
net.learn(batch_x, batch_y)
if i % 20 == 0:
cost, accu_rate = net.get_accuracy_rate(batch_x, batch_y)
print("Iteration: %i. Train loss %.5f, Minibatch accuracy:"
" %.1f%%" % (i, cost, accu_rate))
if i % 100 == 0:
cost, accu_rate = net.get_accuracy_rate(valid_dataset,
valid_age_labels)
print("Iteration: %i. Validation loss %.5f, Validation accuracy:"
" %.1f%%" % (i, cost, accu_rate))
cost, accu_rate = net.get_accuracy_rate(test_dataset,
test_age_labels)
print("Iteration: %i. Test loss %.5f, Test accuracy:"
" %.1f%%" % (i, cost, accu_rate))
def main_train():
env=gym.make('CartPole-v0').env
net=Network(load_model='neural_net/net_2.meta', ckpt_location='neural_net', save_dest='neural_net/net_2')
a=Agent(env, 'neural_net/net_2.meta', 'neural_net')
NO_EPISODES=10000
TIMESTEPS=300
EXPLORATION_PROB=0.2
DISCOUNT_FACTOR=0.9 #implement
TRAIN_EVERY_N=5
RENDER_EVERY_N=1
VERBOSE=True
MODIFIED_REWARD=True
PENALTY=-10
WRITE_EVERY_N=50
NO_EPOCHS=2
BATCH_SIZE=128
for ep in range(NO_EPISODES):
prev_state=env.reset()
for t in range(TIMESTEPS):
if random.uniform(0, 1)>EXPLORATION_PROB:
action=a.get_action(prev_state)
else:
action=a.get_random_action()
new_state, reward, done, info = env.step(action)
if ep%RENDER_EVERY_N==0:
env.render()
if done and MODIFIED_REWARD:
reward=PENALTY
data_point=[prev_state, action, reward, done, new_state]
write_data(data_point, WRITE_EVERY_N)
prev_state=new_state
if done:
if VERBOSE:
print "episode:", ep, "score:", t
break
if ep%TRAIN_EVERY_N==0:
net.train(n_epochs=1, print_every_n=200)
def main():
clock = pygame.time.Clock()
run = True
n = Network()
startpos = read_pos(n.get_pos())
print(startpos)
p = Player(startpos[0], startpos[1], 100, 100, (0, 255, 0))
p2 = Player(0, 0, 100, 100, (255, 0, 0))
while run:
clock.tick(60)
p2pos = read_pos(n.send(make_pos((p.x, p.y))))
print(p2pos)
p2.x = p2pos[0]
p2.y = p2pos[1]
p2.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
p.move()
redraw(win, p, p2)
def init_wrapper(transport_impl, bind_address, bind_port, receive_address, receive_port):
exc_info = None
logger = logging.getLogger('Transport: Initialize Client')
if bind_address == "localhost":
bind_address = net.get_local_ip_address()
else:
bind_address = bind_address
if receive_address == "localhost":
receive_address = net.get_local_ip_address()
else:
receive_address = receive_address
logger.debug("Binding to address " + bind_address + " and port " + str(bind_port))
try:
init(transport_impl, bind_address, bind_port, receive_address, receive_port)
except Exception as err:
import sys
exc_info = sys.exc_info()
print "ERROR OF TYPE: " + str(type(err)) # the exception instance
print "Details: " + str(err)
send_address = ", RECEIVE/DESTINATION ADDRESS AND PORT IS NOT DEFINED FOR THIS 'OUTPUT TYPE' SOCKET"
if receive_address is not None:
send_address = ", Receiver Address=" + receive_address + ", Receiver Port=" + str(receive_port)
print "Socket Details: Bind Address=" + bind_address + ", Bind Port=" + str(bind_port) + send_address
finally:
# Display the *original* exception
if exc_info is not None:
import traceback
traceback.print_exception(*exc_info)
del exc_info
exit(1)
transport_impl.bind_address = bind_address
transport_impl.bind_port = bind_port
def standardExtract(generateNet=True):
'''
@brief Create a network wrapper that dumps dataset contents
@param generateNet IFF TRUE, a network prototxt will be made and printed
@returns Block(..) function that adds a data layer and dumping functions to a net
'''
def Block(net, datasetName, out_path='data'):
'''
@brief Add data a data layer and file outputs to a network
@param net Incomplete network definition
@param datasetName Name of the desired dataset (see Dataset.py)
@param out_path Output path for file dumps
'''
blobs = net.namedBlobs()
## Create data layer
dataset = Dataset.get(name=datasetName, phase='TEST')
img0, img1, flow_gt = dataset.flowLayer(net)
if not os.path.isdir(out_path):
os.makedirs(out_path)
## Write configuration file for viewer tool
f = open('%s/viewer.cfg' % (out_path), 'w')
f.write('2 2\n')
f.write('0 0 -img0.ppm\n')
f.write('1 0 -img1.ppm\n')
f.write('0 1 -gt.flo\n')
f.write('1 1 none\n')
f.close()
## Create network file outputs
net.writeImage(img0, folder=out_path, prefix='', suffix='-img0')
net.writeImage(img1, folder=out_path, prefix='', suffix='-img1')
net.writeFlow(flow_gt, folder=out_path, prefix='', suffix='-gt')
if generateNet:
net = Network()
dataset = str(param('dataset'))
if dataset is None:
raise Exception('please specify dataset=...')
Block(net, dataset)
print net.toProto()
return Block
def __init__(self,
target_method,
bind_address="INADDR_ANY",
bind_port=5354):
self.is_running = False
self.target_method = target_method
self.logger = logging.getLogger('UDPServer')
localhost = network.get_local_ip_address()
self.logger.debug('UDP __init__ for host ' + localhost +
' using bind address: ' + bind_address + "/" +
str(bind_port))
SocketServer.UDPServer.allow_reuse_address = True
SocketServer.UDPServer.__init__(self,
(str(bind_address), int(bind_port)),
RequestHandler)
return
def main():
read_f = file("./data/train_data", "rb")
train_generator = cPickle.load(read_f)
read_f.close()
read_f = file("./data/emb", "rb")
embedding_matrix, _, _ = cPickle.load(read_f)
read_f.close()
test_generator = DataGenerator("test", args.batch_size)
model = Network(args.embedding_size, args.embedding_dimension, embedding_matrix, args.hidden_dimension).cuda()
best_model = Network(args.embedding_size, args.embedding_dimension, embedding_matrix, args.hidden_dimension).cuda()
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.l2_reg)
best_result = 0.0
for echo in range(args.epoch_num):
info = "[" + echo * ">" + " " * (args.epoch_num - echo) + "]"
sys.stderr.write(info + "\r")
cost1, cost2, cost, total_num = 0.0, 0.0, 0.0, 0
for data in train_generator.generate_data(shuffle=True):
zp_rep, npc_rep, np_rep, feature = model.forward(data, dropout=args.dropout)
output = model.generate_score(zp_rep, npc_rep, np_rep, feature)
optimizer.zero_grad()
dis1 = output[data['wid']] - output[data['cid']] + args.margin
dis2 = output[data['uwid']] - args.wrong_bound
dis3 = args.correct_bound - output[data['ucid']]
triplet_loss = torch.sum(dis1 * (dis1 > 0).cuda().float()) + torch.sum(
dis2 * (dis2 > 0).cuda().float()) + torch.sum(dis3 * (dis3 > 0).cuda().float())
cos_sim_sum = torch.sum(1 - F.cosine_similarity(np_rep[data['cid1']], np_rep[data['cid2']]))
sim_w = 0.5
num = data["result"].shape[0]
total_loss = triplet_loss + sim_w * cos_sim_sum
total_loss.backward()
cost += total_loss.item() * num
cost1 += triplet_loss.item() * num
cost2 += cos_sim_sum.item() * num
total_num += num
optimizer.step()
train_re = evaluate_train(train_generator, model)
dev_re, dev_cost = evaluate_dev(train_generator, model, args.margin)
if dev_re > best_result:
best_result = dev_re
net_copy(best_model, model)
test_re = evaluate_test(test_generator, model)
print 'Epoch %s; Train Cost: %.4f, %.4f, %.4f; Train Result: %.4f; Dev Result: %.4f, %.4f; Test Result: %.4f' % (
echo, cost / total_num, cost1 / total_num, cost2 / total_num, train_re, dev_re, dev_cost, test_re)
print >> sys.stderr
torch.save(best_model, "./models/model")
re = evaluate_test(test_generator, best_model)
print "Performance on Test: F", re
def load_model(cls, ensemble_path):
"""Load up ensembled models given a folder location."""
json_file = "{}_metadata.json".format(
os.path.join(ensemble_path, os.path.basename(ensemble_path)))
with open(json_file, 'r') as file:
config = json.load(file)
networks = []
for model_file in sorted(os.listdir(ensemble_path)):
if model_file.endswith('.network'):
file = os.path.join(ensemble_path, model_file)
networks += [Network.load_model(file)]
snap = Snapshot(name='snap1',
template_network=networks[0],
n_snapshots=config[ensemble_path]['n_snapshots'])
snap.networks = networks
return snap
def graphic(net: Network, env: Env):
window = pygame.display.set_mode((env.width, env.height))
pygame.mouse.set_visible(False)
while True:
window.fill((0, 0, 0))
pygame.draw.line(window, WHITE, env.goal_line_left.convert_cords(env),
env.goal_line_right.convert_cords(env))
pygame.draw.line(window, GREEN, env.left_post.convert_cords(env),
env.right_post.convert_cords(env))
pygame.draw.circle(window, GREEN, env.left_post.convert_cords(env), 2)
pygame.draw.circle(window, GREEN, env.right_post.convert_cords(env), 2)
pygame.draw.circle(window, GREEN, env.center_goal.convert_cords(env),
env.penalty_area_r, 1)
t.sleep(0.01)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if any(pygame.mouse.get_pressed()):
atk = pygame.mouse.get_pos()
pygame.draw.line(window, LIGHT_RED, atk,
env.left_post.convert_cords(env))
pygame.draw.line(window, LIGHT_RED, atk,
env.right_post.convert_cords(env))
pygame.draw.circle(window, RED, atk, 2)
gk_x, gk_y = net.predict(
np.array(
[[atk[0] / (env.width / 2),
atk[1] / (env.height / 2)]]))[0][0]
gk_x, gk_y = int(gk_x * (env.width // 2)), int(gk_y *
(env.height // 2))
gk = Point(gk_x, gk_y)
pygame.draw.circle(window, GREEN, gk.convert_cords(env), 2)
pygame.display.flip()
def init_wrapper(transport_impl, target_method, bind_address, bind_port,
multicast_address=None, multicast_port=None):
logger = logging.getLogger('Transport: Initialize Server')
exc_info = None
if bind_address == "localhost":
bind_address = net.get_local_ip_address()
else:
bind_address = bind_address
logger.debug("Init Server: Binding to address " + bind_address + " and port " + str(bind_port))
try:
if multicast_address is None:
init(transport_impl, target_method, bind_address, bind_port)
else:
init(transport_impl, target_method, bind_address, bind_port, multicast_address, multicast_port)
except socket.error as socket_error:
import sys
exc_info = sys.exc_info()
print "ERROR OF TYPE: " + str(type(socket_error)) # the exception instance
print "Details: " + str(socket_error)
mcast_text = ""
if multicast_address is not None:
mcast_text = ", Multicast Address=" + multicast_address + ", Multicast Port=" + str(multicast_port)
print "Socket Details: Bind Address=" + bind_address + ", Bind Port=" + str(bind_port) + mcast_text
finally:
# Display the *original* exception
if exc_info is not None:
import traceback
traceback.print_exception(*exc_info)
del exc_info
exit(1)
transport_impl.bind_address = bind_address
transport_impl.bind_port = bind_port
#!/usr/bin/env python2
from net import Network
import libxml2
import libssh2
import socket
import re
doc = libxml2.parseDoc(open('test.xml').read())
ssh_host = doc.xpathEval('//ssh/@host')[0].children
ssh_user = doc.xpathEval('//ssh/@user')[0].children
ssh_pass = doc.xpathEval('//ssh/@pass')[0].children
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((str(ssh_host),22))
session = libssh2.Session()
session.startup(sock)
session.userauth_password(str(ssh_user),str(ssh_pass))
channel = session.open_session()
channel.execute('ip addr')
while True:
data = channel.read(1024)
if data == '' or data is None: break
linelist = data.split('\n')
for line in linelist:
if "inet" in line:
ip = (' '.join(line.split())).split(' ')[1]
if not(':' in ip):
print ip.split('/')[0] + " can be pinged: " + str(Network.ping(ip.split('/')[0]))
class LearningPlayerStrategy(PlayerStrategy):
def __init__(self):
PlayerStrategy.__init__(self)
self.net = Network(FEATURE_COUNT, NHIDDEN)
def update_model(self, player, game):
# Update model.
features = self.extract_features(player, game)
self.train(player, features=features)
player.prev_features = features
def evaluate_features(self, features):
return self.net.calc(features)
def evaluate(self, player, game):
return self.evaluate_features(self.extract_features(player, game))
def extract_features(self, player, game):
ret = numpy.array([0.0]*FEATURE_COUNT)
NPF = len(PLAYER_FEATURES)
NSF = len(SUPPLY_FEATURES)
for i,f in enumerate(PLAYER_FEATURES):
ret[i] = f.player_extract(game, player.idx)
ret[NPF+i] = f.player_extract(game, 1-player.idx)
for i,f in enumerate(SUPPLY_FEATURES):
ret[2*NPF+i] = f.supply_extract(game)
ret[2*NPF+NSF] = 1.0
return ret
def train(self, player, features=None, outcome=None):
global sumsqerr
global nsamples
if player.prev_features is None:
say(' Player %d skipping model training on first turn.' % player.idx)
return
if player.experimented:
say(' Player %d skipping model training due to experiment.' % player.idx)
return
if outcome is None:
assert features is not None
outcome = 2*self.net.calc(features) - 1
if features is not None: mode = 'difference'
else: mode = 'final'
say(' Player %d training %s:' % (player.idx, mode))
x_t = player.prev_features
target = (outcome + 1) / 2.0
prediction = self.net.calc(x_t)
say(' target = %.5lf' % target)
say(' prediction = %.5lf' % prediction)
err = target - prediction
sumsqerr += err**2
nsamples += 1
self.net.train(x_t, target, alpha)
new_prediction = self.net.calc(x_t)
say(' new prediction = %.5lf' % new_prediction)
print(
"Top1:{:>5.2f}% Top2:{:>5.2f}% Top3:{:>5.2f}%".format(
top1_acc * 100, top2_acc * 100, top3_acc * 100
)
)
pbar.close()
if __name__ == "__main__":
args = parse_args()
update_config(cfg, args)
test_set = eval(cfg.DATASET.DATASET)("valid", cfg)
num_classes = test_set.get_num_classes()
device = torch.device("cpu" if cfg.CPU_MODE else "cuda")
model = Network(cfg, mode="test", num_classes=num_classes)
model_dir = os.path.join(cfg.OUTPUT_DIR, cfg.NAME, "models")
model_file = cfg.TEST.MODEL_FILE
if "/" in model_file:
model_path = model_file
else:
model_path = os.path.join(model_dir, model_file)
model.load_model(model_path)
if cfg.CPU_MODE:
model = model.to(device)
else:
model = torch.nn.DataParallel(model).cuda()
testLoader = DataLoader(
def __init__(self,
sess,
height,
width,
phi_length,
n_actions,
name,
gamma=0.99,
copy_interval=4,
optimizer='RMS',
learning_rate=0.00025,
epsilon=0.01,
decay=0.95,
momentum=0.,
l2_decay=0.0001,
error_clip=1.0,
slow=False,
tau=0.01,
verbose=False,
path='',
folder='_networks',
decay_learning_rate=False,
transfer=False):
""" Initialize network """
Network.__init__(self, sess, name=name)
self.gamma = gamma
self.slow = slow
self.tau = tau
self.name = name
self.sess = sess
self.path = path
self.folder = folder
self.copy_interval = copy_interval
self.update_counter = 0
self.decay_learning_rate = decay_learning_rate
self.observation = tf.placeholder(tf.float32,
[None, height, width, phi_length],
name=self.name + '_observation')
self.actions = tf.placeholder(tf.float32,
shape=[None, n_actions],
name=self.name +
"_actions") # one-hot matrix
self.next_observation = tf.placeholder(
tf.float32, [None, height, width, phi_length],
name=self.name + '_t_next_observation')
self.rewards = tf.placeholder(tf.float32,
shape=[None],
name=self.name + "_rewards")
self.terminals = tf.placeholder(tf.float32,
shape=[None],
name=self.name + "_terminals")
self.slow_learnrate_vars = []
self.fast_learnrate_vars = []
self.observation_n = tf.div(self.observation, 255.)
self.next_observation_n = tf.div(self.next_observation, 255.)
# q network model:
self.is_training = tf.placeholder(tf.bool, [])
with tf.name_scope("Conv1") as scope:
kernel_shape = [8, 8, phi_length, 32]
self.W_conv1 = self.weight_variable(phi_length, kernel_shape,
'conv1')
#self.b_conv1 = self.bias_variable(kernel_shape, 'conv1')
self.h_conv1_bn = batch_norm(self.conv2d(self.observation_n,
self.W_conv1, 4),
32,
self.is_training,
self.sess,
slow=self.slow,
tau=self.tau)
self.h_conv1 = tf.nn.relu(self.h_conv1_bn.bnorm,
name=self.name + '_conv1_activations')
tf.add_to_collection('conv_weights', self.W_conv1)
tf.add_to_collection('conv_output', self.h_conv1)
if transfer:
self.slow_learnrate_vars.append(self.W_conv1)
self.slow_learnrate_vars.append(self.h_conv1_bn.scale)
self.slow_learnrate_vars.append(self.h_conv1_bn.beta)
with tf.name_scope("Conv2") as scope:
kernel_shape = [4, 4, 32, 64]
self.W_conv2 = self.weight_variable(32, kernel_shape, 'conv2')
#self.b_conv2 = self.bias_variable(kernel_shape, 'conv2')
self.h_conv2_bn = batch_norm(self.conv2d(self.h_conv1,
self.W_conv2, 2),
64,
self.is_training,
self.sess,
slow=self.slow,
tau=self.tau)
self.h_conv2 = tf.nn.relu(self.h_conv2_bn.bnorm,
name=self.name + '_conv2_activations')
tf.add_to_collection('conv_weights', self.W_conv2)
tf.add_to_collection('conv_output', self.h_conv2)
if transfer:
self.slow_learnrate_vars.append(self.W_conv2)
self.slow_learnrate_vars.append(self.h_conv2_bn.scale)
self.slow_learnrate_vars.append(self.h_conv2_bn.beta)
with tf.name_scope("Conv3") as scope:
kernel_shape = [3, 3, 64, 64]
self.W_conv3 = self.weight_variable(64, kernel_shape, 'conv3')
#self.b_conv3 = self.bias_variable(kernel_shape, 'conv3')
self.h_conv3_bn = batch_norm(self.conv2d(self.h_conv2,
self.W_conv3, 1),
64,
self.is_training,
self.sess,
slow=self.slow,
tau=self.tau)
self.h_conv3 = tf.nn.relu(self.h_conv3_bn.bnorm,
name=self.name + '_conv3_activations')
tf.add_to_collection('conv_weights', self.W_conv3)
tf.add_to_collection('conv_output', self.h_conv3)
if transfer:
self.slow_learnrate_vars.append(self.W_conv3)
self.slow_learnrate_vars.append(self.h_conv3_bn.scale)
self.slow_learnrate_vars.append(self.h_conv3_bn.beta)
self.h_conv3_flat = tf.reshape(self.h_conv3, [-1, 3136])
with tf.name_scope("FullyConnected1") as scope:
kernel_shape = [3136, 512]
self.W_fc1 = self.weight_variable_linear(kernel_shape, 'fc1')
#self.b_fc1 = self.bias_variable(kernel_shape, 'fc1')
self.h_fc1_bn = batch_norm(tf.matmul(self.h_conv3_flat,
self.W_fc1),
512,
self.is_training,
self.sess,
slow=self.slow,
tau=self.tau,
linear=True)
self.h_fc1 = tf.nn.relu(self.h_fc1_bn.bnorm,
name=self.name + '_fc1_activations')
if transfer:
self.fast_learnrate_vars.append(self.W_fc1)
self.fast_learnrate_vars.append(self.h_fc1_bn.scale)
self.fast_learnrate_vars.append(self.h_fc1_bn.beta)
with tf.name_scope("FullyConnected2") as scope:
kernel_shape = [512, n_actions]
self.W_fc2 = self.weight_variable_linear(kernel_shape, 'fc2')
self.b_fc2 = self.bias_variable_linear(kernel_shape, 'fc2')
self.q_value = tf.add(tf.matmul(self.h_fc1, self.W_fc2),
self.b_fc2,
name=self.name + '_fc1_outputs')
if transfer:
self.fast_learnrate_vars.append(self.W_fc2)
self.fast_learnrate_vars.append(self.b_fc2)
if transfer:
self.load_transfer_model(optimizer=optimizer.lower())
# Scale down the last layer
W_fc2_scaled = tf.scalar_mul(0.01, self.W_fc2)
b_fc2_scaled = tf.scalar_mul(0.01, self.b_fc2)
self.sess.run([
self.W_fc2.assign(W_fc2_scaled),
self.b_fc2.assign(b_fc2_scaled)
])
if verbose:
self.init_verbosity()
# target q network model:
self.t_is_training = tf.placeholder(tf.bool, [])
with tf.name_scope("TConv1") as scope:
kernel_shape = [8, 8, phi_length, 32]
self.t_W_conv1 = self.weight_variable(phi_length, kernel_shape,
't_conv1')
#self.t_b_conv1 = self.bias_variable(kernel_shape, 't_conv1')
self.t_h_conv1_bn = batch_norm(self.conv2d(self.next_observation_n,
self.t_W_conv1, 4),
32,
self.t_is_training,
self.sess,
parForTarget=self.h_conv1_bn,
slow=self.slow,
tau=self.tau)
self.t_h_conv1 = tf.nn.relu(self.t_h_conv1_bn.bnorm,
name=self.name +
'_t_conv1_activations')
with tf.name_scope("TConv2") as scope:
kernel_shape = [4, 4, 32, 64]
self.t_W_conv2 = self.weight_variable(32, kernel_shape, 't_conv2')
#self.t_b_conv2 = self.bias_variable(kernel_shape, 't_conv2')
self.t_h_conv2_bn = batch_norm(self.conv2d(self.t_h_conv1,
self.t_W_conv2, 2),
64,
self.t_is_training,
self.sess,
parForTarget=self.h_conv2_bn,
slow=self.slow,
tau=self.tau)
self.t_h_conv2 = tf.nn.relu(self.t_h_conv2_bn.bnorm,
name=self.name +
'_t_conv2_activations')
with tf.name_scope("TConv3") as scope:
kernel_shape = [3, 3, 64, 64]
self.t_W_conv3 = self.weight_variable(64, kernel_shape, 't_conv3')
#self.t_b_conv3 = self.bias_variable(kernel_shape, 't_conv3')
self.t_h_conv3_bn = batch_norm(self.conv2d(self.t_h_conv2,
self.t_W_conv3, 1),
64,
self.t_is_training,
self.sess,
parForTarget=self.h_conv3_bn,
slow=self.slow,
tau=self.tau)
self.t_h_conv3 = tf.nn.relu(self.t_h_conv3_bn.bnorm,
name=self.name +
'_t_conv3_activations')
self.t_h_conv3_flat = tf.reshape(self.t_h_conv3, [-1, 3136])
with tf.name_scope("TFullyConnected1") as scope:
kernel_shape = [3136, 512]
self.t_W_fc1 = self.weight_variable_linear(kernel_shape, 't_fc1')
#self.t_b_fc1 = self.bias_variable(kernel_shape, 't_fc1')
self.t_h_fc1_bn = batch_norm(tf.matmul(self.t_h_conv3_flat,
self.t_W_fc1),
512,
self.t_is_training,
self.sess,
parForTarget=self.h_fc1_bn,
slow=self.slow,
tau=self.tau,
linear=True)
self.t_h_fc1 = tf.nn.relu(self.t_h_fc1_bn.bnorm,
name=self.name + '_t_fc1_activations')
with tf.name_scope("TFullyConnected2") as scope:
kernel_shape = [512, n_actions]
self.t_W_fc2 = self.weight_variable_linear(kernel_shape, 't_fc2')
self.t_b_fc2 = self.bias_variable_linear(kernel_shape, 't_fc2')
self.t_q_value = tf.add(tf.matmul(self.t_h_fc1, self.t_W_fc2),
self.t_b_fc2,
name=self.name + '_t_fc1_outputs')
if transfer:
# only intialize tensor variables that are not loaded from the transfer model
#self.sess.run(tf.variables_initializer(fast_learnrate_vars))
self._global_vars_temp = set(tf.global_variables())
# cost of q network
#self.l2_regularizer_loss = l2_decay * (tf.reduce_sum(tf.pow(self.W_conv1, 2)) + tf.reduce_sum(tf.pow(self.W_conv2, 2)) + tf.reduce_sum(tf.pow(self.W_conv3, 2)) + tf.reduce_sum(tf.pow(self.W_fc1, 2)) + tf.reduce_sum(tf.pow(self.W_fc2, 2)))
self.cost = self.build_loss(error_clip,
n_actions) #+ self.l2_regularizer_loss
# self.parameters = [
# self.W_conv1, self.h_conv1_bn.scale, self.h_conv1_bn.beta,
# self.W_conv2, self.h_conv2_bn.scale, self.h_conv2_bn.beta,
# self.W_conv3, self.h_conv3_bn.scale, self.h_conv3_bn.beta,
# self.W_fc1, self.h_fc1_bn.scale, self.h_fc1_bn.beta,
# self.W_fc2, self.b_fc2,
# ]
with tf.name_scope("Train") as scope:
if optimizer == "Graves":
# Nature RMSOptimizer
self.train_step, self.grads_vars = graves_rmsprop_optimizer(
self.cost, learning_rate, decay, epsilon, 1)
else:
if optimizer == "Adam":
self.opt = tf.train.AdamOptimizer(
learning_rate=learning_rate, epsilon=epsilon)
elif optimizer == "RMS":
# Tensorflow RMSOptimizer
self.opt = tf.train.RMSPropOptimizer(learning_rate,
decay=decay,
momentum=momentum,
epsilon=epsilon)
else:
print(colored("Unknown Optimizer!", "red"))
sys.exit()
self.grads_vars = self.opt.compute_gradients(self.cost)
grads = []
params = []
for p in self.grads_vars:
if p[0] == None:
continue
grads.append(p[0])
params.append(p[1])
#grads = tf.clip_by_global_norm(grads, 1)[0]
self.grads_vars_updates = zip(grads, params)
self.train_step = self.opt.apply_gradients(
self.grads_vars_updates)
# for grad, var in self.grads_vars:
# if grad == None:
# continue
# tf.summary.histogram(var.op.name + '/gradients', grad)
if transfer:
vars_diff = set(tf.global_variables()) - self._global_vars_temp
self.sess.run(tf.variables_initializer(vars_diff))
self.sess.run(
tf.variables_initializer([
self.t_h_conv1_bn.pop_mean, self.t_h_conv1_bn.pop_var,
self.t_h_conv2_bn.pop_mean, self.t_h_conv2_bn.pop_var,
self.t_h_conv3_bn.pop_mean, self.t_h_conv3_bn.pop_var,
self.t_h_fc1_bn.pop_mean, self.t_h_fc1_bn.pop_var
]))
else:
# initialize all tensor variable parameters
self.sess.run(tf.global_variables_initializer())
# Make sure q and target model have same initial parameters copy the parameters
self.sess.run([
self.t_W_conv1.assign(
self.W_conv1), #self.t_b_conv1.assign(self.b_conv1),
self.t_W_conv2.assign(
self.W_conv2), #self.t_b_conv2.assign(self.b_conv2),
self.t_W_conv3.assign(
self.W_conv3), #self.t_b_conv3.assign(self.b_conv3),
self.t_W_fc1.assign(self.W_fc1), #self.t_b_fc1.assign(self.b_fc1),
self.t_W_fc2.assign(self.W_fc2),
self.t_b_fc2.assign(self.b_fc2),
self.t_h_conv1_bn.scale.assign(self.h_conv1_bn.scale),
self.t_h_conv1_bn.beta.assign(self.h_conv1_bn.beta),
self.t_h_conv2_bn.scale.assign(self.h_conv2_bn.scale),
self.t_h_conv2_bn.beta.assign(self.h_conv2_bn.beta),
self.t_h_conv3_bn.scale.assign(self.h_conv3_bn.scale),
self.t_h_conv3_bn.beta.assign(self.h_conv3_bn.beta),
self.t_h_fc1_bn.scale.assign(self.h_fc1_bn.scale),
self.t_h_fc1_bn.beta.assign(self.h_fc1_bn.beta)
])
if self.slow:
self.update_target_op = [
self.t_W_conv1.assign(self.tau * self.W_conv1 +
(1 - self.tau) * self.t_W_conv1
), #self.t_b_conv1.assign(self.b_conv1),
self.t_W_conv2.assign(self.tau * self.W_conv2 +
(1 - self.tau) * self.t_W_conv2
), #self.t_b_conv2.assign(self.b_conv2),
self.t_W_conv3.assign(self.tau * self.W_conv3 +
(1 - self.tau) * self.t_W_conv3
), #self.t_b_conv3.assign(self.b_conv3),
self.t_W_fc1.assign(self.tau * self.W_fc1 +
(1 - self.tau) * self.t_W_fc1
), #self.t_b_fc1.assign(self.b_fc1),
self.t_W_fc2.assign(self.tau * self.W_fc2 +
(1 - self.tau) * self.t_W_fc2),
self.t_b_fc2.assign(self.tau * self.b_fc2 +
(1 - self.tau) * self.t_b_fc2),
self.t_h_conv1_bn.updateTarget,
self.t_h_conv2_bn.updateTarget,
self.t_h_conv3_bn.updateTarget,
self.t_h_fc1_bn.updateTarget
]
else:
self.update_target_op = [
self.t_W_conv1.assign(
self.W_conv1), #self.t_b_conv1.assign(self.b_conv1),
self.t_W_conv2.assign(
self.W_conv2), #self.t_b_conv2.assign(self.b_conv2),
self.t_W_conv3.assign(
self.W_conv3), #self.t_b_conv3.assign(self.b_conv3),
self.t_W_fc1.assign(
self.W_fc1), #self.t_b_fc1.assign(self.b_fc1),
self.t_W_fc2.assign(self.W_fc2),
self.t_b_fc2.assign(self.b_fc2),
self.t_h_conv1_bn.updateTarget,
self.t_h_conv2_bn.updateTarget,
self.t_h_conv3_bn.updateTarget,
self.t_h_fc1_bn.updateTarget
]
self.saver = tf.train.Saver()
self.merged = tf.summary.merge_all()
self.writer = tf.summary.FileWriter(
self.path + self.folder + '/log_tb', self.sess.graph)
def __init__(self): PlayerStrategy.__init__(self) self.net = Network(FEATURE_COUNT, NHIDDEN)
def train(args):
"""Train
"""
if not os.path.exists(args.save_path):
os.makedirs(args.save_path)
net = Network(args.vocab_size, args.emb_size, args.hidden_size)
train_program = fluid.Program()
train_startup = fluid.Program()
if "CE_MODE_X" in os.environ:
train_program.random_seed = 110
train_startup.random_seed = 110
with fluid.program_guard(train_program, train_startup):
with fluid.unique_name.guard():
logits, loss = net.network(args.loss_type)
loss.persistable = True
logits.persistable = True
# gradient clipping
fluid.clip.set_gradient_clip(
clip=fluid.clip.GradientClipByValue(max=1.0, min=-1.0))
optimizer = fluid.optimizer.Adam(learning_rate=args.learning_rate)
optimizer.minimize(loss)
print("begin memory optimization ...")
fluid.memory_optimize(train_program)
print("end memory optimization ...")
test_program = fluid.Program()
test_startup = fluid.Program()
if "CE_MODE_X" in os.environ:
test_program.random_seed = 110
test_startup.random_seed = 110
with fluid.program_guard(test_program, test_startup):
with fluid.unique_name.guard():
logits, loss = net.network(args.loss_type)
loss.persistable = True
logits.persistable = True
test_program = test_program.clone(for_test=True)
if args.use_cuda:
place = fluid.CUDAPlace(0)
dev_count = fluid.core.get_cuda_device_count()
else:
place = fluid.CPUPlace()
dev_count = int(os.environ.get('CPU_NUM', multiprocessing.cpu_count()))
print("device count %d" % dev_count)
print("theoretical memory usage: ")
print(
fluid.contrib.memory_usage(program=train_program,
batch_size=args.batch_size))
exe = fluid.Executor(place)
exe.run(train_startup)
exe.run(test_startup)
train_exe = fluid.ParallelExecutor(use_cuda=args.use_cuda,
loss_name=loss.name,
main_program=train_program)
test_exe = fluid.ParallelExecutor(use_cuda=args.use_cuda,
main_program=test_program,
share_vars_from=train_exe)
if args.word_emb_init is not None:
print("start loading word embedding init ...")
if six.PY2:
word_emb = np.array(pickle.load(open(args.word_emb_init,
'rb'))).astype('float32')
else:
word_emb = np.array(
pickle.load(open(args.word_emb_init, 'rb'),
encoding="bytes")).astype('float32')
net.set_word_embedding(word_emb, place)
print("finish init word embedding ...")
print("start loading data ...")
def train_with_feed(batch_data):
"""
Train on one batch
"""
#to do get_feed_names
feed_dict = dict(zip(net.get_feed_names(), batch_data))
cost = train_exe.run(feed=feed_dict, fetch_list=[loss.name])
return cost[0]
def test_with_feed(batch_data):
"""
Test on one batch
"""
feed_dict = dict(zip(net.get_feed_names(), batch_data))
score = test_exe.run(feed=feed_dict, fetch_list=[logits.name])
return score[0]
def evaluate():
"""
Evaluate to choose model
"""
val_batches = reader.batch_reader(args.val_path, args.batch_size,
place, args.max_len, 1)
scores = []
labels = []
for batch in val_batches:
scores.extend(test_with_feed(batch))
labels.extend([x[0] for x in batch[2]])
return eva.evaluate_Recall(zip(scores, labels))
def save_exe(step, best_recall):
"""
Save exe conditional
"""
recall_dict = evaluate()
print('evaluation recall result:')
print('1_in_2: %s\t1_in_10: %s\t2_in_10: %s\t5_in_10: %s' %
(recall_dict['1_in_2'], recall_dict['1_in_10'],
recall_dict['2_in_10'], recall_dict['5_in_10']))
if recall_dict['1_in_10'] > best_recall and step != 0:
fluid.io.save_inference_model(args.save_path,
net.get_feed_inference_names(),
logits,
exe,
main_program=train_program)
print("Save model at step %d ... " % step)
print(
time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())))
best_recall = recall_dict['1_in_10']
return best_recall
# train over different epoches
global_step, train_time = 0, 0.0
best_recall = 0
for epoch in six.moves.xrange(args.num_scan_data):
train_batches = reader.batch_reader(args.train_path, args.batch_size,
place, args.max_len,
args.sample_pro)
begin_time = time.time()
sum_cost = 0
ce_cost = 0
for batch in train_batches:
if (args.save_path is not None) and (global_step % args.save_step
== 0):
best_recall = save_exe(global_step, best_recall)
cost = train_with_feed(batch)
global_step += 1
sum_cost += cost.mean()
ce_cost = cost.mean()
if global_step % args.print_step == 0:
print('training step %s avg loss %s' %
(global_step, sum_cost / args.print_step))
sum_cost = 0
pass_time_cost = time.time() - begin_time
train_time += pass_time_cost
print("Pass {0}, pass_time_cost {1}".format(
epoch, "%2.2f sec" % pass_time_cost))
if "CE_MODE_X" in os.environ and epoch == args.num_scan_data - 1:
card_num = get_cards()
print("kpis\ttrain_duration_card%s\t%s" %
(card_num, pass_time_cost))
print("kpis\ttrain_loss_card%s\t%s" % (card_num, ce_cost))
#Configure network to reconstruct two provided images (flower,Lincoln)
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from utils import getData
from net import Network,train
matplotlib.use('Agg')
#Flower
iterations = 1000
X,y = getData(2)
netF = Network(2,3)
netF,loss = train(netF,X,y,iterations,100)
preds = netF.predict(X)
plt.imshow(preds.reshape(133,140,3))
plt.title('Flower')
plt.savefig('Flower2.png')
plt.clf()
plt.plot(np.arange(iterations),loss)
plt.ylabel('Loss')
plt.xlabel('Iterations')
plt.title('Flower Loss')
plt.savefig('Flowerloss2.png')
#Lincoln
def train_model():
"""
This function will train model
Tips: Load test,validation data first
Then, seperately load training data, since training data is really huge.
:return:
"""
path = '/home/hengtong/project/age_gender/data/small/wiki_new.pkl'
data = load_data(path)
## extract different type data
train_dataset = data['train_dataset']/255
train_age_labels = data['train_age_labels']
#train_gender_labels = data['train_gender_labels']
valid_dataset = data['valid_dataset']/255
valid_age_labels = data['valid_age_labels']
#valid_gender_labels = data['valid_gender_labels']
test_dataset = data['test_dataset']/255
test_age_labels = data['test_age_labels']
#test_gender_labels = data['test_gender_labels']
hight = 128
channel = 1
batch_size = 128
learn_rate = 0.01
n_output = 4 # age mode
total_size = train_dataset.shape[0]
net = Network(
n_output = n_output,
n_length=hight,
learning_rate=learn_rate,
batch_size=batch_size,
channel=channel,
output_graph=False,
use_ckpt=False
)
epoch = 400 # epoch
iteration = int(total_size / batch_size)
print iteration
i = 1 # total training time
accu_train_age = []
accu_valid_age = []
accu_test_age = []
early_stop =0 # early stopping flag
train_rate_age = 0
for e in range(epoch):
print("-------------------------------")
print("epoch %d" % (e + 1))
# randomly sample batch memory from all memory
indices = np.random.permutation(total_size)
for ite in range(iteration):
mini_indices = indices[ite * batch_size:(ite + 1) * batch_size]
batch_x = train_dataset[mini_indices, :, :, :]
batch_y_age = train_age_labels[mini_indices, :]
net.learn(batch_x, batch_y_age)
if i % 50 == 0:
cost, train_rate_age= net.get_accuracy_rate(batch_x, batch_y_age)
print("Iteration: %i. Train loss %.5f, Minibatch gen accuracy:"" %.1f%%"% (i, cost, train_rate_age))
accu_train_age.append(train_rate_age)
if i % 50 == 0:
cost, valid_rate_age = net.get_accuracy_rate(valid_dataset, valid_age_labels)
print("Iteration: %i. Validation loss %.5f, Validation gen accuracy:" " %.1f%%" % (i, cost, valid_rate_age))
accu_valid_age.append(valid_rate_age)
cost, test_rate_age= net.get_accuracy_rate(test_dataset, test_age_labels)
print("Iteration: %i. Test loss %.5f, Test gen accuracy:"" %.1f%%" % (i, cost, test_rate_age))
accu_test_age.append(test_rate_age)
if i % 500 == 0:
net.save_parameters()
i = i + 1
# early stopping
if train_rate_age == 100:
if early_stop == 10:
print("Early Stopping!")
break
else:
early_stop = early_stop + 1
net.plot_cost() # plot trainingi cost
plt.figure() # plot accuracy
plt.plot(np.arange(len(accu_train_age)), accu_train_age, label='train age', linestyle='--')
plt.plot(np.arange(len(accu_valid_age)), accu_valid_age, label='valid age', linestyle='-')
plt.plot(np.arange(len(accu_test_age)), accu_test_age, label='test age', linestyle=':')
plt.ylabel('age accuracy')
plt.xlabel('epoch')
plt.legend(loc='lower right')
plt.grid()
plt.savefig('age.png')
def solvers(rank, ngpus_per_node, args):
if rank == 0:
logger = create_logger()
logger.info('Running distributed data parallel on {} gpus.'.format(
args.world_size))
torch.cuda.set_device(rank)
torch.distributed.init_process_group(backend='nccl',
init_method=args.init_method,
world_size=args.world_size,
rank=rank)
# set initial value
start_epoch = 0
best_ssim = 0.0
# model
model = Network(num_layers=args.num_layers, rank=rank)
# whether load checkpoint
if args.pretrained or args.mode == 'test':
model_path = os.path.join(args.model_save_path,
'best_checkpoint.pth.tar')
assert os.path.isfile(model_path)
checkpoint = torch.load(model_path,
map_location='cuda:{}'.format(rank))
start_epoch = checkpoint['epoch']
lr = checkpoint['lr']
args.lr = lr
best_ssim = checkpoint['best_ssim']
model.load_state_dict(checkpoint['model'])
if rank == 0:
logger.info('Load checkpoint at epoch {}.'.format(start_epoch))
logger.info('Current learning rate is {}.'.format(lr))
logger.info(
'Current best ssim in train phase is {}.'.format(best_ssim))
logger.info('The model is loaded.')
elif args.use_init_weights:
init_weights(model, init_type=args.init_type, gain=args.gain)
if rank == 0:
logger.info('Initialize model with {}.'.format(args.init_type))
model = model.to(rank)
model = DDP(model, device_ids=[rank])
# criterion, optimizer, learning rate scheduler
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=args.lr)
if not args.pretrained:
warm_up = lambda epoch: epoch / args.warmup_epochs if epoch <= args.warmup_epochs else 1
scheduler_wu = torch.optim.lr_scheduler.LambdaLR(optimizer=optimizer,
lr_lambda=warm_up)
scheduler_re = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer=optimizer, mode='max', factor=0.3, patience=20)
early_stopping = EarlyStopping(patience=50, delta=1e-5)
# test step
if args.mode == 'test':
test_set = Dataset(args.test_path, args.u_mask_path,
args.s_mask_up_path, args.s_mask_down_path,
args.test_sample_rate)
test_loader = DataLoader(dataset=test_set,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True)
if rank == 0:
logger.info('The size of test dataset is {}.'.format(
len(test_set)))
logger.info('Now testing {}.'.format(args.exp_name))
model.eval()
with torch.no_grad():
test_log = []
start_time = time.time()
test_log = forward('test', rank, model, test_loader, criterion,
optimizer, test_log, args)
test_time = time.time() - start_time
# test information
test_loss = test_log[0]
test_psnr = test_log[1]
test_ssim = test_log[2]
if rank == 0:
logger.info(
'time:{:.5f}s\ttest_loss:{:.7f}\ttest_psnr:{:.5f}\ttest_ssim:{:.5f}'
.format(test_time, test_loss, test_psnr, test_ssim))
return
# training step
train_set = Dataset(args.train_path, args.u_mask_path, args.s_mask_up_path,
args.s_mask_down_path, args.train_sample_rate)
train_sampler = DistributedSampler(train_set)
train_loader = DataLoader(dataset=train_set,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
pin_memory=True,
sampler=train_sampler)
val_set = Dataset(args.val_path, args.u_mask_path, args.s_mask_up_path,
args.s_mask_down_path, args.val_sample_rate)
val_loader = DataLoader(dataset=val_set,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True)
if rank == 0:
logger.info(
'The size of training dataset and validation dataset is {} and {}, respectively.'
.format(len(train_set), len(val_set)))
logger.info('Now training {}.'.format(args.exp_name))
writer = SummaryWriter(args.loss_curve_path)
for epoch in range(start_epoch + 1, args.num_epochs + 1):
train_sampler.set_epoch(epoch)
train_log = [epoch]
epoch_start_time = time.time()
model.train()
train_log = forward('train', rank, model, train_loader, criterion,
optimizer, train_log, args)
model.eval()
with torch.no_grad():
train_log = forward('val', rank, model, val_loader, criterion,
optimizer, train_log, args)
epoch_time = time.time() - epoch_start_time
# train information
epoch = train_log[0]
train_loss = train_log[1]
lr = train_log[2]
val_loss = train_log[3]
val_psnr = train_log[4]
val_ssim = train_log[5]
is_best = val_ssim > best_ssim
best_ssim = max(val_ssim, best_ssim)
if rank == 0:
logger.info(
'epoch:{:<8d}time:{:.5f}s\tlr:{:.8f}\ttrain_loss:{:.7f}\tval_loss:{:.7f}\tval_psnr:{:.5f}\t'
'val_ssim:{:.5f}'.format(epoch, epoch_time, lr, train_loss,
val_loss, val_psnr, val_ssim))
writer.add_scalars('loss', {
'train_loss': train_loss,
'val_loss': val_loss
}, epoch)
# save checkpoint
checkpoint = {
'epoch': epoch,
'lr': lr,
'best_ssim': best_ssim,
'model': model.module.state_dict()
}
if not os.path.exists(args.model_save_path):
os.makedirs(args.model_save_path)
model_path = os.path.join(args.model_save_path,
'checkpoint.pth.tar')
best_model_path = os.path.join(args.model_save_path,
'best_checkpoint.pth.tar')
torch.save(checkpoint, model_path)
if is_best:
shutil.copy(model_path, best_model_path)
# scheduler
if epoch <= args.warmup_epochs and not args.pretrained:
scheduler_wu.step()
scheduler_re.step(val_ssim)
early_stopping(val_ssim, loss=False)
if early_stopping.early_stop:
if rank == 0:
logger.info('The experiment is early stop!')
break
if rank == 0:
writer.close()
return
roiimage = gray[y:y + h, x:x + w]
roiimage = cv2.resize(roiimage, (128, 128),
interpolation=cv2.INTER_CUBIC)
cv2.imwrite('./' + str(index) + '.jpg', roiimage)
i += 1
new_path = '/home/htkang/bigdata/age_gender/code/age_gender/joint/' + str(
index) + '.jpg'
test_image = cv2.imread(new_path)
test_gray = cv2.cvtColor(test_image, cv2.COLOR_BGR2GRAY) # test image
net = Network(n_output_gen=2,
n_output_age=4,
n_length=128,
learning_rate=0.01,
batch_size=32,
channel=1,
output_graph=False,
use_ckpt=True)
test_gray_1 = tf.expand_dims(test_gray, 0) # add dimension
test_gray_2 = tf.expand_dims(test_gray_1, -1)
with tf.Session() as sess:
input_image = sess.run(test_gray_2)
gender, age = net.get_result(input_image)
print("gender is:%d, age is:%d " % (gender, age))
gender, age = transform(age, gender)
font = cv2.cv.InitFont(cv2.cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 1)
from player import Player
pygame.font.init()
WIDTH, HEIGHT = 1280, 720
WIN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("game_a")
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
DISCONNECT_MESSAGE = "!DISCONNECT"
n = Network(socket.gethostbyname(socket.gethostname()))
name = "PGCLIENT"
first = Message(name, "CONNECTED", "default", time.time())
n.connect(first)
last_message = None
def main():
run = True
FPS = 60
main_font = pygame.font.SysFont("Arial", 24)
clock = pygame.time.Clock()
def finetune(args):
"""
Finetune
"""
if not os.path.exists(args.save_path):
os.makedirs(args.save_path)
net = Network(args.vocab_size, args.emb_size, args.hidden_size)
train_program = fluid.Program()
train_startup = fluid.Program()
if "CE_MODE_X" in os.environ:
train_program.random_seed = 110
train_startup.random_seed = 110
with fluid.program_guard(train_program, train_startup):
with fluid.unique_name.guard():
logits, loss = net.network(args.loss_type)
loss.persistable = True
logits.persistable = True
# gradient clipping
fluid.clip.set_gradient_clip(
clip=fluid.clip.GradientClipByValue(max=1.0, min=-1.0))
optimizer = fluid.optimizer.Adam(
learning_rate=fluid.layers.exponential_decay(
learning_rate=args.learning_rate,
decay_steps=400,
decay_rate=0.9,
staircase=True))
optimizer.minimize(loss)
print("begin memory optimization ...")
fluid.memory_optimize(train_program)
print("end memory optimization ...")
test_program = fluid.Program()
test_startup = fluid.Program()
if "CE_MODE_X" in os.environ:
test_program.random_seed = 110
test_startup.random_seed = 110
with fluid.program_guard(test_program, test_startup):
with fluid.unique_name.guard():
logits, loss = net.network(args.loss_type)
loss.persistable = True
logits.persistable = True
test_program = test_program.clone(for_test=True)
if args.use_cuda:
place = fluid.CUDAPlace(0)
dev_count = fluid.core.get_cuda_device_count()
else:
place = fluid.CPUPlace()
dev_count = int(os.environ.get('CPU_NUM', multiprocessing.cpu_count()))
print("device count %d" % dev_count)
print("theoretical memory usage: ")
print(
fluid.contrib.memory_usage(program=train_program,
batch_size=args.batch_size))
exe = fluid.Executor(place)
exe.run(train_startup)
exe.run(test_startup)
train_exe = fluid.ParallelExecutor(use_cuda=args.use_cuda,
loss_name=loss.name,
main_program=train_program)
test_exe = fluid.ParallelExecutor(use_cuda=args.use_cuda,
main_program=test_program,
share_vars_from=train_exe)
if args.init_model:
init.init_pretraining_params(exe,
args.init_model,
main_program=train_startup)
print('sccuess init %s' % args.init_model)
print("start loading data ...")
def train_with_feed(batch_data):
"""
Train on one batch
"""
#to do get_feed_names
feed_dict = dict(zip(net.get_feed_names(), batch_data))
cost = train_exe.run(feed=feed_dict, fetch_list=[loss.name])
return cost[0]
def test_with_feed(batch_data):
"""
Test on one batch
"""
feed_dict = dict(zip(net.get_feed_names(), batch_data))
score = test_exe.run(feed=feed_dict, fetch_list=[logits.name])
return score[0]
def evaluate():
"""
Evaluate to choose model
"""
val_batches = reader.batch_reader(args.val_path, args.batch_size,
place, args.max_len, 1)
scores = []
labels = []
for batch in val_batches:
scores.extend(test_with_feed(batch))
labels.extend([x[0] for x in batch[2]])
scores = [x[0] for x in scores]
return eva.evaluate_cor(scores, labels)
def save_exe(step, best_cor):
"""
Save exe conditional
"""
cor = evaluate()
print('evaluation cor relevance %s' % cor)
if cor > best_cor and step != 0:
fluid.io.save_inference_model(args.save_path,
net.get_feed_inference_names(),
logits,
exe,
main_program=train_program)
print("Save model at step %d ... " % step)
print(
time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())))
best_cor = cor
return best_cor
# train over different epoches
global_step, train_time = 0, 0.0
best_cor = 0.0
pre_index = -1
for epoch in six.moves.xrange(args.num_scan_data):
train_batches = reader.batch_reader(args.train_path, args.batch_size,
place, args.max_len,
args.sample_pro)
begin_time = time.time()
sum_cost = 0
for batch in train_batches:
if (args.save_path is not None) and (global_step % args.save_step
== 0):
best_cor = save_exe(global_step, best_cor)
cost = train_with_feed(batch)
global_step += 1
sum_cost += cost.mean()
if global_step % args.print_step == 0:
print('training step %s avg loss %s' %
(global_step, sum_cost / args.print_step))
sum_cost = 0
pass_time_cost = time.time() - begin_time
train_time += pass_time_cost
print("Pass {0}, pass_time_cost {1}".format(
epoch, "%2.2f sec" % pass_time_cost))
tf.reset_default_graph()
train_data_200='/home/juliussurya/workspace/360pano/tfrecords/pano_FOVrand_200_outdoor'
train_data_full = '/home/juliussurya/workspace/360pano/tfrecords/pano_FOVrand_train_outdoor'
val_data = '/home/juliussurya/workspace/360pano/tfrecords/pano_FOVrand_val_outdoor'
test_data = '/home/juliussurya/workspace/360pano/tfrecords/pano_FOVrand_test_outdoor'
graph_path = '/home/juliussurya/workspace/360pano/graph/fov/enc_dec_flow_gan'
model_path = '/home/juliussurya/workspace/360pano/checkpoint/'
if sys.argv[1] == 'train':
dataset = train_data_200
elif sys.argv[1] == 'test':
dataset = val_data
with tf.name_scope('ReadDataset'):
net = Network()
x, y, fov = net.readDataset(dataset,2,50) #return output for checking
with tf.name_scope('FoVNet'):
net.forwardFOV() # Run FOV network estimation
net.lossFOV() # Compute loss FOV
net.forwardSmall() # Run single model network
net.forwardMed()
net.addSoftNoise(random.uniform(0.8,1.1),random.uniform(0.0,0.4)) #Add label noise
net.lossGANsmall()
net.lossGANmed()
with tf.name_scope('Minimizer'):
# Learning rate , decay step
lr_fov = [0.0001, 5000]
#Test on plotting quadratic curve
import numpy as np
from net import Network, train
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use('Agg')
iterations = 500
X = np.random.rand(1000, 1) * 2 * np.pi
y = (1 + np.sin(X)) / 2
net = Network(1, 1)
net, loss = train(net, X, y, iterations, 10)
plt.scatter(X, net.predict(X))
plt.xlabel('X')
plt.ylabel('Predicted y: sin(x)')
plt.savefig('sin2.png')
plt.clf()
plt.plot(np.arange(iterations), loss)
plt.xlabel('Iterations')
plt.ylabel('Loss')
plt.title('Sin Approximation Loss')
plt.savefig('sinloss2.png')
import sys
import time
import socket
from net import Network
from message import Message
ip = input("Server: ")
if ip == "":
ip = socket.gethostbyname(socket.gethostname())
name = input("Username: "******"!DISCONNECT"
n = Network(ip)
first = Message(name, "test", "default", time.time())
n.connect(first)
def send_msg(msg):
m = Message(name, str(msg), "default", time.time())
return n.send(m)
def main():
while True:
send_msg(str(input()))
if __name__ == '__main__':
try:
main()
