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()