def get_pose(img, res_only=False): threed_points = np.load( './pose_references/reference_3d_68_points_trans.npy') if not isinstance(img, Image.Image): img = Image.fromarray(img) transform = transforms.Compose([transforms.ToTensor()]) DEPTH = 18 MAX_SIZE = 1400 MIN_SIZE = 600 POSE_MEAN = "./models/WIDER_train_pose_mean_v1.npy" POSE_STDDEV = "./models/WIDER_train_pose_stddev_v1.npy" MODEL_PATH = "./models/img2pose_v1.pth" pose_mean = np.load(POSE_MEAN) pose_stddev = np.load(POSE_STDDEV) img2pose_model = img2poseModel( DEPTH, MIN_SIZE, MAX_SIZE, pose_mean=pose_mean, pose_stddev=pose_stddev, threed_68_points=threed_points, ) load_model(img2pose_model.fpn_model, MODEL_PATH, cpu_mode=str(img2pose_model.device) == "cpu", model_only=True) img2pose_model.evaluate() (w, h) = img.size image_intrinsics = np.array([[w + h, 0, w // 2], [0, w + h, h // 2], [0, 0, 1]]) res = img2pose_model.predict([transform(img)])[0] if res_only: return res all_bboxes = res["boxes"].cpu().numpy().astype('float') poses = [] bboxes = [] threshold = 0.9 for i in range(len(all_bboxes)): if res["scores"][i] > threshold: bbox = all_bboxes[i] pose_pred = res["dofs"].cpu().numpy()[i].astype('float') pose_pred = pose_pred.squeeze() print(pose_pred * 180) poses.append(pose_pred) bboxes.append(bbox) return render_plot(img.copy(), poses, bboxes)
def give_output(imgs): # img_path = '../../east-text-detection/crop' # imgs = os.listdir(img_path) label = '' backend = 'resnet18' snapshot = './snaps/crnn_best' input_size = [320, 32] seq_proj = [10, 20] print('Creating transform') transform = Compose([ # Rotation(), Resize(size=(input_size[0], input_size[1])) ]) abc = string.digits + string.ascii_letters print('Possibilities - ' + abc) # load model net = load_model(abc, seq_proj, backend, snapshot, cuda=True).eval() out_arr = [] for imgx in imgs: # prepare image # img = cv2.imread(os.path.join(img_path, imgx)) img = imgx print('Readed image of shape - ' + str(img.shape)) img = transform(img) img = torch.from_numpy(img.transpose((2, 0, 1))).float().unsqueeze(0) img = Variable(img) print('Image fed to model of shape - ', str(img.shape)) out = net(img, decode=True) out_arr.append(out) return out_arr
def main(): parser=argparse.ArgumentParser( description="Model training script\n" +\ "Usage: train.py [options]" ) parser.add_argument('--model', default="fsrcnn", help="name of model") parser.add_argument('--scale', default=2, type=int, help="factor by which to upscale the given model") parser.add_argument('--resolution', default=240, type=int, help="height of low resolution image") parser.add_argument('--learn_rate', default=1e-3, type=float, help="initial learning rate of optimizer") parser.add_argument('--batch_size', default=16, type=int, help="training batch size") parser.add_argument('--rebuild_freq', default=20, type=int, help="frequency to rebuild dataset (epochs)") parser.add_argument('--epochs', default=100, type=int, help="training epochs") parser.add_argument('--pre_epochs', default=0, type=int, help="restores model weights from checkpoint with given epochs of pretraining; set to 0 to train from scratch") parser.add_argument('--ckpt_epochs', default=0, type=int, help="number of training epochs in between checkpoints; set to 0 to not save checkpoints") parser.add_argument('--size', default='s', type=str, choices=['s', 'm', 'l'], help="size of core model") parser.add_argument('--upscale', default='sp', type=str, choices=['de', 'sp'], help="upscale method of core model") parser.add_argument('--residual', default='n', type=str, choices=['n', 'l', 'g'], help="residual method of core model") parser.add_argument('--activation', default='r', type=str, choices=['r', 'p'], help="activation of core model") parser.add_argument('--activation_removal', action='store_true', help="activation removal in core model") parser.add_argument('--recurrent', action='store_true', help="recurrent core model") args = parser.parse_args() core_args = None if args.model == 'core': core_args = CoreArgs(args.scale, args.size, args.upscale, args.residual, args.activation, args.activation_removal, args.recurrent) ckpt_args = CheckpointArgs( epochs=args.ckpt_epochs, completed=args.pre_epochs, model=args.model, scale=args.scale, res=args.resolution, core_args=core_args ) stopping_criterion = { 'epochs': args.epochs } if args.model == 'core' and args.recurrent: loader = VideoLoader( 'reds', scale=args.scale, prefetch_buffer_size=4 ) else: lr_shape = get_resolution(args.resolution) lr_shape.append(3) # Colour channels loader = ImageLoader( 'div2k', lr_shape=lr_shape, scale=args.scale, batch_size=args.batch_size, prefetch_buffer_size=4 ) model, lr_mul = load_model(ckpt_args) train(model, loader, stopping_criterion, args.learn_rate, ckpt_args, loader.get_num_train_batches(), args.rebuild_freq, lr_mul)
def create_model(self, args): img2pose_model = img2poseModel( args.depth, args.min_size[-1], args.max_size, pose_mean=self.pose_mean, pose_stddev=self.pose_stddev, threed_68_points=self.threed_68_points, ) load_model( img2pose_model.fpn_model, args.pretrained_path, cpu_mode=str(img2pose_model.device) == "cpu", model_only=True, ) img2pose_model.evaluate() return img2pose_model
def main(data_path, abc, seq_proj, backend, snapshot, input_size, gpu, visualize): os.environ["CUDA_VISIBLE_DEVICES"] = gpu cuda = True if gpu is not '' else False input_size = [int(x) for x in input_size.split('x')] transform = Compose( [Rotation(), Resize(size=(input_size[0], input_size[1]))]) if data_path is not None: data = TextDataset(abc=abc, data_path=data_path, mode="test", transform=transform) else: data = TestDataset(transform=transform, abc=abc) seq_proj = [int(x) for x in seq_proj.split('x')] net = load_model(data.get_abc(), seq_proj, backend, snapshot, cuda).eval() acc, avg_ed = test(net, data, data.get_abc(), cuda, visualize) print("Accuracy: {}".format(acc)) print("Edit distance: {}".format(avg_ed))
def main(): tf.logging.set_verbosity(tf.logging.INFO) args = get_args() tf.logging.info("Load wav from {}".format(args.wav_src_dir)) tf.logging.info("Generate marks to {}".format(args.marks_dst_dir)) net = GenerateModel() graph = tf.Graph() with graph.as_default(): with tf.variable_scope("data"): inputs = tf.placeholder(tf.float32, shape=(None, crop_radius*2 + 1)) with tf.variable_scope("extract_model"): tensor_dict = net.build(inputs, training=False) predictions = tensor_dict["predictions"] saver = tf.train.Saver() config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(graph=graph, config=config) as sess: sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()]) save_path = os.path.join(args.save_path, net.name) if not load_model(saver, sess, save_path): sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()]) global_step_eval = 0 keys = file_names(args.wav_src_dir) testing_steps = len(keys) pbar = tqdm.tqdm(total=testing_steps) pbar.update(global_step_eval) for key in keys: tf.logging.debug("File names: {}".format(key)) input_features = package_input_features(os.path.join(args.wav_src_dir, key + wav_extension)) predictions_eval = sess.run(predictions, feed_dict={inputs: input_features["wav"]}) marks = generate_marks(input_features["peak_indices"], predictions_eval, input_features["rate"]) tf.logging.debug("Number of marks: {}".format(len(marks))) save_marks(os.path.join(args.marks_dst_dir, key + marks_extension), marks) global_step_eval += 1 pbar.update(1) tf.logging.info("Congratulations!")
def predict(image_path, checkpoint_path, topk, is_gpu_available): image = load_image(image_path) model = load_model(checkpoint_path) [model] = to_cuda_when_available([model], is_gpu_available) with torch.no_grad(): [image] = to_cuda_when_available([image.unsqueeze(0)], is_gpu_available) model.eval() output = model.forward(image) probabilities = torch.exp(output) top_k_probabilities, top_k_index = torch.topk(probabilities, topk) index_to_class = { value: key for key, value in model.class_to_idx.items() } top_k_classes = list( map(lambda index: index_to_class[index], np.array(top_k_index.cpu())[0])) return top_k_probabilities, top_k_classes
def __init__(self, config): self.config = config # start tensorboard summary writer self.writer = SummaryWriter(config.log_path) # load training dataset generator if self.config.random_flip or self.config.random_crop: self.train_loader = LMDBDataLoaderAugmenter( self.config, self.config.train_source) else: self.train_loader = LMDBDataLoader(self.config, self.config.train_source) print(f"Training with {len(self.train_loader.dataset)} images.") # loads validation dataset generator if a validation dataset is given if self.config.val_source is not None: self.val_loader = LMDBDataLoader(self.config, self.config.val_source, False) # creates model self.img2pose_model = img2poseModel( depth=self.config.depth, min_size=self.config.min_size, max_size=self.config.max_size, device=self.config.device, pose_mean=self.config.pose_mean, pose_stddev=self.config.pose_stddev, distributed=self.config.distributed, gpu=self.config.gpu, threed_68_points=np.load(self.config.threed_68_points), threed_5_points=np.load(self.config.threed_5_points), ) # optimizer for the backbone and heads if args.optimizer == "Adam": self.optimizer = optim.Adam( self.img2pose_model.fpn_model.parameters(), lr=self.config.lr, weight_decay=self.config.weight_decay, ) elif args.optimizer == "SGD": self.optimizer = optim.SGD( self.img2pose_model.fpn_model.parameters(), lr=self.config.lr, weight_decay=self.config.weight_decay, momentum=self.config.momentum, ) else: raise Exception( "No optimizer founded, please select between SGD or Adam.") # loads a model with optimizer so that it can continue training where it stopped if self.config.resume_path: print(f"Resuming training from {self.config.resume_path}") load_model( self.img2pose_model.fpn_model, self.config.resume_path, model_only=False, optimizer=self.optimizer, cpu_mode=str(self.config.device) == "cpu", ) # loads a pretrained model without loading the optimizer if self.config.pretrained_path: print( f"Loading pretrained weights from {self.config.pretrained_path}" ) load_model( self.img2pose_model.fpn_model, self.config.pretrained_path, model_only=True, cpu_mode=str(self.config.device) == "cpu", ) # saves configuration to file for easier retrival later print(self.config) self.save_file(self.config, "config.txt") # saves optimizer config to file for easier retrival later print(self.optimizer) self.save_file(self.optimizer, "optimizer.txt") self.tensorboard_loss_every = max(len(self.train_loader) // 100, 1) # self.evaluate_every = max(len(self.train_loader) // 1, 1) # reduce learning rate when the validation loss stops to decrease if self.config.lr_plateau: self.scheduler = ReduceLROnPlateau( self.optimizer, mode="min", factor=0.1, patience=3, verbose=True, threshold=0.001, cooldown=1, min_lr=0.00001, ) # stops training before the defined epochs if validation loss stops to decrease if self.config.early_stop: self.early_stop = EarlyStop(mode="min", patience=5)
from PIL import Image from torchvision.transforms import ToTensor import numpy as np import torch from model_loader import load_model img_to_tensor = ToTensor() FSRCNN = load_model(upscale_factor=4) cuda = torch.cuda.is_available() if cuda: FSRCNN = FSRCNN.cuda() def convert_frame(frame, w=None, h=None, image=False): if image: img = Image.open(frame).convert('YCbCr') w, h = img.size y, cb, cr = img.split() else: y, cb, cr = Image.fromarray(frame).convert('YCbCr').split() input = img_to_tensor(y).view(1, -1, y.size[1], y.size[0]) if cuda: input = input.cuda() out = FSRCNN(input) del input out = out.cpu() out_img_y = out[0].detach().numpy() out_img_y *= 255.0 out_img_y = out_img_y.clip(0, 255) out_img_y = Image.fromarray(np.uint8(out_img_y[0]), mode='L')
def main(data_path, abc, seq_proj, backend, snapshot, input_size, base_lr, step_size, max_iter, batch_size, output_dir, test_epoch, test_init, gpu): print(abc) os.environ["CUDA_VISIBLE_DEVICES"] = gpu cuda = True if gpu is not '' else False input_size = [int(x) for x in input_size.split('x')] transform = Compose([ # Rotation(), Translation(), # Scale(), Resize(size=(input_size[0], input_size[1])) ]) if data_path is not None: data = TextDataset(data_path=data_path, mode="train", transform=transform, abc=abc) else: data = TestDataset(transform=transform, abc=abc) seq_proj = [int(x) for x in seq_proj.split('x')] net = load_model(data.get_abc(), seq_proj, backend, snapshot, cuda) optimizer = optim.Adam(net.parameters(), lr = base_lr, weight_decay=0.0001) lr_scheduler = StepLR(optimizer, step_size=step_size, max_iter=max_iter) loss_function = CTCLoss(average_frames=True, reduction="mean", blank=0) acc_best = 0 epoch_count = 0 while True: if (test_epoch is not None and epoch_count != 0 and epoch_count % test_epoch == 0) or (test_init and epoch_count == 0): print("Test phase") data.set_mode("test") net = net.eval() acc, avg_ed = test(net, data, data.get_abc(), cuda, visualize=False) net = net.train() data.set_mode("train") if acc > acc_best: if output_dir is not None: torch.save(net.state_dict(), os.path.join(output_dir, "crnn_" + backend + "_" + str(data.get_abc()) + "_best")) acc_best = acc print("acc: {}\tacc_best: {}; avg_ed: {}".format(acc, acc_best, avg_ed)) data_loader = DataLoader(data, batch_size=batch_size, num_workers=1, shuffle=True, collate_fn=text_collate) loss_mean = [] iterator = tqdm(data_loader) iter_count = 0 save_num = 0 for sample in iterator: # for multi-gpu support if sample["img"].size(0) % len(gpu.split(',')) != 0: continue optimizer.zero_grad() imgs = Variable(sample["img"]) # img = imgs[0] # print(img.shape) # cv2.imshow('image', img.numpy().transpose(1, 2, 0)) # cv2.waitKey(0) labels = Variable(sample["seq"]).view(-1) label_lens = Variable(sample["seq_len"].int()) if cuda: imgs = imgs.cuda() preds = net(imgs).cpu() pred_lens = Variable(Tensor([preds.size(0)] * batch_size).int()) loss = loss_function(preds, labels, pred_lens, label_lens) / batch_size loss.backward() nn.utils.clip_grad_norm(net.parameters(), 10.0) loss_mean.append(loss.data[0]) status = "epoch: {}; iter: {}; lr: {}; loss_mean: {}; loss: {}".format(epoch_count, lr_scheduler.last_iter+1, lr_scheduler.get_lr(), np.mean(loss_mean), loss.data[0]) iterator.set_description(status) optimizer.step() lr_scheduler.step() iter_count += 1 if output_dir is not None and iter_count % 500 == 0: torch.save(net.state_dict(), os.path.join(output_dir, "crnn_" + save_num + "_" + str(loss) + "_last")) save_num += 1 if output_dir is not None: torch.save(net.state_dict(), os.path.join(output_dir, "crnn_" + backend + "_" + str(data.get_abc()) + "_last")) epoch_count += 1 return
from model_loader import load_model parser = argparse.ArgumentParser(description= "Predict.py") parser.add_argument('img_dir', action='store') parser.add_argument('checkpoint_dir', action='store') parser.add_argument('--topK', action='store', default=1, type=int, dest='topK') parser.add_argument('--category_name', action='store', default='./cat_to_name.json', dest='category_names') parser.add_argument('--gpu', action='store_true', default=False, dest='gpu') args = parser.parse_args() with open('cat_to_name.json', 'r') as f: cat_to_name = json.load(f) checkpoint = torch.load(args.checkpoint_dir) model = load_model(checkpoint['model'], checkpoint['hidden_layer']) model.class_to_idx = checkpoint['class_to_idx'] model.load_state_dict(checkpoint['state_dict']) image = Image.open(args.img_dir) transformation = transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])]) img = transformation(image) idx_to_class = {value : key for key,value in model.class_to_idx.items()} img = img.unsqueeze_(0) if args.gpu: model.to('cuda') img = img.to('cuda')
def main(): tf.logging.set_verbosity(tf.logging.INFO) args = get_args() data_set_args = get_mix3_set_args() net = ExtractModel() graph = tf.Graph() with graph.as_default(): with tf.variable_scope("data"): training_set = get_testing_set(key=data_set_args.training_set_name, epochs=args.training_epochs, batch_size=args.training_batch_size) validation_set = get_testing_set( key=data_set_args.validation_set_name, epochs=args.training_epochs // args.validation_per_epochs, batch_size=args.validation_batch_size) iterator = training_set.make_one_shot_iterator() next_element = iterator.get_next() training_init_op = iterator.make_initializer(training_set) validation_init_op = iterator.make_initializer(validation_set) with tf.variable_scope("extract_model"): tensor_dict = net.build(next_element, training=True) """training summary""" loss_summary = tf.summary.scalar("loss", tensor_dict["loss"]) accuracy_summary = tf.summary.scalar("accuracy", tensor_dict["accuracy"]) recall_summary = tf.summary.scalar("recall", tensor_dict["recall"]) precision_summary = tf.summary.scalar("precision", tensor_dict["precision"]) f1_score_summary = tf.summary.scalar("f1_score", tensor_dict["f1_score"]) """validation summary""" validation_loss = tf.placeholder(tf.float32, shape=()) validation_accuracy = tf.placeholder(tf.float32, shape=()) validation_recall = tf.placeholder(tf.float32, shape=()) validation_precision = tf.placeholder(tf.float32, shape=()) validation_f1_score = tf.placeholder(tf.float32, shape=()) validation_loss_summary = tf.summary.scalar( "loss", validation_loss) validation_accuracy_summary = tf.summary.scalar( "accuracy", validation_accuracy) validation_recall_summary = tf.summary.scalar( "recall", validation_recall) validation_precision_summary = tf.summary.scalar( "precision", validation_precision) validation_f1_score_summary = tf.summary.scalar( "f1_score", validation_f1_score) """training""" global_step = tf.Variable(0, dtype=tf.int32, name="global_step") opt = tf.train.AdamOptimizer(1e-3) extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(extra_update_ops): upd = opt.minimize(tensor_dict["loss"], global_step=global_step) saver = tf.train.Saver(max_to_keep=50) config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(graph=graph, config=config) as sess: sess.run([ tf.global_variables_initializer(), tf.local_variables_initializer() ]) save_path = os.path.join(args.save_path, net.name) if not load_model(saver, sess, save_path): tf.logging.info("Run on an initialized graph.") sess.run([ tf.global_variables_initializer(), tf.local_variables_initializer() ]) training_writer = tf.summary.FileWriter( os.path.join(args.log_path, "training"), sess.graph) validation_writer = tf.summary.FileWriter( os.path.join(args.log_path, "validation"), sess.graph) global_step_eval = sess.run(global_step) training_steps = args.training_epochs * data_set_args.training_set_size // args.training_batch_size save_steps = args.save_per_epochs * data_set_args.training_set_size // args.training_batch_size validation_steps = args.validation_per_epochs * data_set_args.training_set_size // args.training_batch_size pbar = tqdm.tqdm(total=training_steps) pbar.update(global_step_eval) sess.run(training_init_op) while global_step_eval < training_steps: """validation""" if global_step_eval % validation_steps == 0: sess.run(validation_init_op) total_loss = 0.0 total_accuracy = 0.0 total_recall = 0.0 total_precision = 0.0 validation_steps = data_set_args.validation_set_size // args.validation_batch_size for s in range(validation_steps): tensor_dict_eval = sess.run(tensor_dict) total_loss += tensor_dict_eval["loss"] total_accuracy += tensor_dict_eval["accuracy"] total_recall += tensor_dict_eval["recall"] total_precision += tensor_dict_eval["precision"] total_loss /= validation_steps total_accuracy /= validation_steps total_recall /= validation_steps total_precision /= validation_steps total_f1_score = 2 * total_recall * total_precision / ( total_recall + total_precision) feed_dict = { validation_loss: total_loss, validation_accuracy: total_accuracy, validation_recall: total_recall, validation_precision: total_precision, validation_f1_score: total_f1_score } validation_list = [ validation_loss_summary, validation_accuracy_summary, validation_recall_summary, validation_precision_summary, validation_f1_score_summary ] validation_loss_summary_eval, validation_accuracy_summary_eval, validation_recall_summary_eval,\ validation_precision_summary_eval, validation_f1_score_summary_eval = sess.run(validation_list, feed_dict=feed_dict) validation_writer.add_summary(validation_loss_summary_eval, global_step=global_step_eval) validation_writer.add_summary(validation_accuracy_summary_eval, global_step=global_step_eval) validation_writer.add_summary(validation_recall_summary_eval, global_step=global_step_eval) validation_writer.add_summary( validation_precision_summary_eval, global_step=global_step_eval) validation_writer.add_summary(validation_f1_score_summary_eval, global_step=global_step_eval) tf.logging.info("Validation done.") sess.run(training_init_op) """training""" training_list = [ loss_summary, accuracy_summary, recall_summary, precision_summary, f1_score_summary, global_step, upd ] training_loss_summary_eval, training_accuracy_summary_eval, training_recall_summary_eval,\ training_precision_summary_eval, training_f1_score_summary_eval, global_step_eval,\ _ = sess.run(training_list) training_writer.add_summary(training_loss_summary_eval, global_step=global_step_eval) training_writer.add_summary(training_accuracy_summary_eval, global_step=global_step_eval) training_writer.add_summary(training_recall_summary_eval, global_step=global_step_eval) training_writer.add_summary(training_precision_summary_eval, global_step=global_step_eval) training_writer.add_summary(training_f1_score_summary_eval, global_step=global_step_eval) """save model""" if global_step_eval % save_steps == 0: if not os.path.exists(args.save_path) or not os.path.isdir( args.save_path): os.makedirs(args.save_path) save_model(saver, sess, save_path, global_step_eval) pbar.update(1) tf.logging.info("Congratulations!")
dataloaders = { 'train': torch.utils.data.DataLoader(image_datasets['train'], batch_size=32, shuffle=True), 'valid': torch.utils.data.DataLoader(image_datasets['valid'], batch_size=32, shuffle=True), 'test': torch.utils.data.DataLoader(image_datasets['test'], batch_size=32, shuffle=True) } model = load_model(args.model, args.hidden) optimizer = optim.Adam(model.classifier.parameters(), lr=args.lr) criterion = nn.NLLLoss() if args.gpu: model.to("cuda") steps = 0 print_every = 5 step = 0 with active_session(): for epoch in range(args.epochs): for images, labels in dataloaders['train']: running_loss = 0 steps += 1
else: parent_directory = "/Users/chientran/Documents/jaist/abstractive_summarization/preprocessed_data/duc_2004" def PrintException(): exc_type, exc_obj, tb = sys.exc_info() f = tb.tb_frame lineno = tb.tb_lineno filename = f.f_code.co_filename linecache.checkcache(filename) line = linecache.getline(filename, lineno, f.f_globals) print 'EXCEPTION IN ({}, LINE {} "{}"): {}'.format(filename, lineno, line.strip(), exc_obj) for doc_id in doc_ids: print "processing %s" % doc_id noun_phrases, verb_phrases, corefs, docs, indicator_matrix = \ load_model("%s/%s" % (parent_directory, doc_id)) def gamma_key(noun_id, verb_id): return "gamma_%d:%d" % (noun_id, verb_id) def phrase_to_phrase_key(phrase_1_id, phrase_2_id, is_np): if is_np: return "noun_%d:%d" % (phrase_1_id, phrase_2_id) else: return "verb_%d:%d" % (phrase_1_id, phrase_2_id) def score(phrases, docs): scores = [] scorer = Scorer(docs) for id, phrase in phrases.items():
def main(): args = get_args() net = FastGenModel() graph = tf.Graph() with graph.as_default(): with tf.variable_scope("data"): next_example = read_from_data_set(args.data_path, args.batch_size) wave_placeholder = tf.placeholder(shape=(args.batch_size, 1), dtype=tf.float32) gci_labels_placeholder = tf.placeholder(shape=(args.batch_size, 1), dtype=tf.float32) data = {"wave": wave_placeholder, "inputs": gci_labels_placeholder} # build net. net_tensor_dic = net.build(data=data) # get saver. saver = tf.train.Saver() config = tf.ConfigProto() config.gpu_options.allow_growth = True tf.logging.set_verbosity(tf.logging.INFO) with tf.Session(graph=graph, config=config) as sess: # Start input enqueue threads. coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) # init = tf.global_variables_initializer() # sess.run(init) for i in range(args.file_num): init = tf.global_variables_initializer() sess.run(init) value = sess.run(next_example) length = value["length"][0] wave = value["wave"] key = value["key"][0].decode('utf-8') rate = value["rate"][0] tf.logging.info("key: {}, wave_length: {}".format(key, length)) labels_batch = np.zeros(shape=(args.batch_size, 1), dtype=np.float32) sess.run(net_tensor_dic["init_op"], feed_dict={ gci_labels_placeholder: labels_batch, wave_placeholder: wave[:, 0:1] }) # get checkpoint save_path = os.path.join(args.save_path, net.name) load_model(saver, sess, save_path) result_batch = np.empty(shape=(args.batch_size, length), dtype=np.float32) for time_step in tqdm.trange(length): labels_batch = sess.run(net_tensor_dic["detected_gci"], feed_dict={ gci_labels_placeholder: labels_batch, wave_placeholder: wave[:, time_step:time_step + 1] }) result_batch[:, time_step] = labels_batch[:, 0] # Make generate directory if it doesn't exist. if not os.path.exists(args.gen_path) or not os.path.isdir( args.gen_path): os.makedirs(args.gen_path) for idx, result in enumerate(result_batch): marks = trans_labels2marks(result, rate=rate) marks_path = os.path.join(args.gen_path, key + ".marks") tf.logging.info("Save marks to " + marks_path) save_marks(marks_path, marks) pass pass # # warm-up queues # labels_batch = np.zeros(shape=(args.batch_size, 1), dtype=np.float32) # wave_batch = np.ones(shape=(args.batch_size, 1), dtype=np.float32) # tf.logging.info("init start!") # sess.run(net_tensor_dic["init_op"], # feed_dict={gci_labels_placeholder: labels_batch, wave_placeholder: wave_batch}) # tf.logging.info("init done!") # # # get checkpoint # save_path = os.path.join(args.save_path, net.name) # load_model(saver, sess, save_path) # # global_step_eval = sess.run(global_step) # # labels_batch = np.zeros(shape=(args.batch_size, 1), dtype=np.float32) # reuslt_batch = np.empty(shape=(args.batch_size, args.gen_samples), dtype=np.float32) # for idx in tqdm.trange(args.gen_samples): # labels_batch = sess.run(net_tensor_dic["detected_gci"], # feed_dict={gci_labels_placeholder: labels_batch, # wave_placeholder: wave_batch}) # # labels_batch = sess.run(net_tensor_dic["detected_gci"], # # feed_dict={gci_labels_placeholder: labels_batch}) # reuslt_batch[:, idx] = labels_batch[:, 0] # # # save syn-ed audios # if not os.path.exists(args.gen_path) or not os.path.isdir(args.gen_path): # os.makedirs(args.gen_path) # # reuslt_batch = np.int16(reuslt_batch * (1 << 15)) # for idx, result in enumerate(reuslt_batch): # # siowav.write(os.path.join(args.gen_path, "{}_{}.wav".format(global_step_eval, idx)), # # data=result, rate=args.sample_rate) # # TODO write result # pass coord.request_stop() # Terminate as usual. It is innocuous to request stop twice. coord.join(threads) print("Congratulations!")
if player_index == 0 and not s['return_tokens'] and not s['end']: game_round += 1 if game_round >= 80: env.end = True if show_game: PrintBoard.print_state(s, game_round, player_index) if s['end']: if training_mode: for model_name, model in players: if model_name != 'p': model.update_model_after_game(env) return env.winner if __name__ == '__main__': version = sys.argv[1] if version == 'm' or version == 'mini': env = minisplendor.MiniSplendor() state_encoder = MiniSplendorStateEncoder() else: env = splendor.Splendor() state_encoder = SplendorStateEncoder() names_and_models = [('p', None)] * config.PLAYERS for i, name in enumerate(sys.argv[2:]): if name != 'p': names_and_models[i] = (name, load_model(name, state_encoder)) play_game(True, False, names_and_models, env)
>>> response.json() >>> {'model_path': 'model_joblib_2018_December_24', 'average_cv_score': 0.9345} """ from flask import Flask, request, jsonify app = Flask(__name__) @app.route("/") def welcome_message(): return "Welcome to the spam-filter web service!" from model_loader import load_model model = load_model() @app.route("/predict", methods=['POST'], strict_slashes=False) def predict(): if request.method == 'POST': try: data = request.get_json() text = str(data['text']) prediction = model.predict([text])[0] spam_proba = model.predict_proba([text])[0][1] except ValueError: return jsonify( "Please enter a valid input: {'text': 'Your text goes here'}")
def main(): tf.logging.set_verbosity(tf.logging.INFO) args = get_args() data_set_args = get_rab_set_args() tf.logging.info("Test model on set: " + data_set_args.training_set_name) net = ExtractModel() graph = tf.Graph() with graph.as_default(): with tf.variable_scope("data"): testing_set = get_testing_set(key=data_set_args.training_set_name, epochs=args.testing_epochs, batch_size=args.batch_size) iterator = testing_set.make_one_shot_iterator() next_element = iterator.get_next() testing_init_op = iterator.make_initializer(testing_set) with tf.variable_scope("extract_model"): tensor_dict = net.build(next_element, training=False) loss = tensor_dict["loss"] accuracy = tensor_dict["accuracy"] recall = tensor_dict["recall"] precision = tensor_dict["precision"] saver = tf.train.Saver() config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(graph=graph, config=config) as sess: sess.run([ tf.global_variables_initializer(), tf.local_variables_initializer() ]) save_path = os.path.join(args.save_path, net.name) if not load_model(saver, sess, save_path): sess.run([ tf.global_variables_initializer(), tf.local_variables_initializer() ]) total_loss = 0.0 total_accuracy = 0.0 total_recall = 0.0 total_precision = 0.0 global_step_eval = 0 testing_steps = args.testing_epochs * data_set_args.training_set_size // args.batch_size pbar = tqdm.tqdm(total=testing_steps) pbar.update(global_step_eval) sess.run(testing_init_op) for global_step_eval in range(testing_steps): testing_list = [loss, accuracy, recall, precision] loss_eval, accuracy_eval, recall_eval, precision_eval = sess.run( testing_list) total_loss += loss_eval total_accuracy += accuracy_eval total_recall += recall_eval total_precision += precision_eval pbar.update(1) total_loss /= global_step_eval total_accuracy /= global_step_eval total_recall /= global_step_eval total_precision /= global_step_eval total_f1_score = 2 * total_recall * total_precision / (total_recall + total_precision) tf.logging.info( "Average loss: {:.6f}, accuracy: {:.6f}, recall: {:.6f}, precision: {:.6f}, f1_score: {:.6f}" .format(total_loss, total_accuracy, total_recall, total_precision, total_f1_score)) tf.logging.info("Congratulations!")
def PrintException(): exc_type, exc_obj, tb = sys.exc_info() f = tb.tb_frame lineno = tb.tb_lineno filename = f.f_code.co_filename linecache.checkcache(filename) line = linecache.getline(filename, lineno, f.f_globals) print 'EXCEPTION IN ({}, LINE {} "{}"): {}'.format(filename, lineno, line.strip(), exc_obj) for doc_id in doc_ids: print "processing %s" % doc_id noun_phrases, verb_phrases, corefs, docs, indicator_matrix = \ load_model("%s/%s" % (parent_directory, doc_id)) def gamma_key(noun_id, verb_id): return "gamma_%d:%d" % (noun_id, verb_id) def phrase_to_phrase_key(phrase_1_id, phrase_2_id, is_np): if is_np: return "noun_%d:%d" % (phrase_1_id, phrase_2_id) else: return "verb_%d:%d" % (phrase_1_id, phrase_2_id) def score(phrases, docs): scores = [] scorer = Scorer(docs) for id, phrase in phrases.items():
def main(): args = get_args() net = Model() graph = tf.Graph() with graph.as_default(): with tf.variable_scope("training_data"): training_set = get_training_dataset(args.training_data_path, args.batch_size, args.crop_length) training_set = training_set.repeat() training_iterator = training_set.make_one_shot_iterator() training_data = training_iterator.get_next() with tf.variable_scope("validation_data"): validation_set = get_training_dataset(args.validation_data_path, args.validation_size, args.crop_length) validation_set = validation_set.repeat() validation_iterator = validation_set.make_one_shot_iterator() validation_data = validation_iterator.get_next() # build net. training_tensor_dic = net.build(data=training_data) # validation_tensor_dic = net.build(data=validation_data, reuse=tf.AUTO_REUSE) # get summaries. audio_summary = tf.summary.merge([ tf.summary.audio("wave", training_tensor_dic["wave"], args.sample_rate), tf.summary.audio("output", training_tensor_dic["output"], args.sample_rate), tf.summary.audio("labels", training_tensor_dic["labels"], args.sample_rate) ]) training_loss_summary = tf.summary.scalar("training_loss", training_tensor_dic["loss"]) # validation_loss_summary = tf.summary.scalar("validation_loss", validation_tensor_dic["loss"]) # get optimizer. global_step = tf.Variable(0, dtype=tf.int32, name="global_step") opt = tf.train.AdamOptimizer(1e-3) upd = opt.minimize(training_tensor_dic["loss"], global_step=global_step) # get saver. saver = tf.train.Saver(max_to_keep=args.max_to_keep) config = tf.ConfigProto() config.gpu_options.allow_growth = True tf.logging.set_verbosity(tf.logging.INFO) with tf.Session(graph=graph, config=config) as sess: save_path = os.path.join(args.save_path, net.name) if not load_model(saver, sess, save_path): sess.run([ tf.global_variables_initializer(), tf.local_variables_initializer() ]) training_writer = tf.summary.FileWriter(args.log_path + "/training", sess.graph) validation_writer = tf.summary.FileWriter(args.log_path + "/validation") global_step_eval = sess.run(global_step) pbar = tqdm.tqdm(total=args.training_steps) pbar.update(global_step_eval) while global_step_eval < args.training_steps: training_loss_summary_eval, audio_summary_eval, global_step_eval, _ = \ sess.run([training_loss_summary, audio_summary, global_step, upd]) training_writer.add_summary(training_loss_summary_eval, global_step=global_step_eval) """summary audio""" # if global_step_eval % args.add_audio_summary_per_steps == 0: # summary_writer.add_summary(audio_summary_eval, global_step=global_step_eval) """validate""" # if global_step_eval % args.validation_per_steps == 0: # validation_loss_summary_eval = sess.run(validation_loss_summary) # tf.logging.info("Validation done.") # validation_writer.add_summary(validation_loss_summary_eval, global_step=global_step_eval) """save model""" if global_step_eval % args.save_per_steps == 0: if not os.path.exists(args.save_path) or not os.path.isdir( args.save_path): os.makedirs(args.save_path) save_model(saver, sess, save_path, global_step_eval) pbar.update(1) training_writer.close() validation_writer.close() print("Congratulations!")
else: for i in range(x.shape[1]): scale = QuantizeLinear(x[i]) scale_list.append(scale) return (scale_list) if __name__ == "__main__": batch_size = 1 # set up your network and quantization style, the network arg. format should be: 'googlenet', 'resnet50', 'squeezenet', 'ssd' ... # the quantization style should be -- shift, simple or winograd style = sys.argv[1] net_name = sys.argv[2] q_path = 'channel_q/' + net_name model, layer_name, Features, feature_path = load_model(net_name) layer_num = len(layer_name) print('Start quantization: ') print('Total layers is: ', end='') print(layer_num) for m in range(layer_num): print('layer: ', end='') print(m) feature_shape = Features[m].shape dim = len(feature_shape) if dim == 1: with open(feature_path + '/' + layer_name[m] + '.bin', "rb") as bin_reader: for i in range(feature_shape[0]): data = bin_reader.read(4) data_float = struct.unpack("f", data)[0]
def run(): # Load configuration args = load_config() logger.add(os.path.join('logs', '{time}.log'), rotation="500 MB", level="INFO") logger.info(args) # Load dataset query_dataloader, train_dataloder, retrieval_dataloader = load_data( args.dataset, args.root, args.num_query, args.num_train, args.batch_size, args.num_workers, ) multi_labels = args.dataset in multi_labels_dataset if args.train: ssdh.train( train_dataloder, query_dataloader, retrieval_dataloader, multi_labels, args.code_length, num_features[args.arch], args.alpha, args.beta, args.max_iter, args.arch, args.lr, args.device, args.verbose, args.evaluate_interval, args.snapshot_interval, args.topk, ) elif args.resume: ssdh.train( train_dataloder, query_dataloader, retrieval_dataloader, multi_labels, args.code_length, num_features[args.arch], args.alpha, args.beta, args.max_iter, args.arch, args.lr, args.device, args.verbose, args.evaluate_interval, args.snapshot_interval, args.topk, args.checkpoint, ) elif args.evaluate: model = load_model(args.arch, args.code_length) model.load_snapshot(args.checkpoint) model.to(args.device) model.eval() mAP = ssdh.evaluate( model, query_dataloader, retrieval_dataloader, args.code_length, args.device, args.topk, multi_labels, ) logger.info('[Inference map:{:.4f}]'.format(mAP)) else: raise ValueError( 'Error configuration, please check your config, using "train", "resume" or "evaluate".' )
import importlib importlib.reload(mod) import torch device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = mod.Net().to(device) model_info = model.get_info() optimizer, scheduler = model.get_optimizer() loss = torch.nn.NLLLoss() #### load model import model_loader if in_ipynb(): importlib.reload(model_loader) if load_from_file: model, optimizer, training_history, param_history, start_epoch, path = model_loader.load_model( model_info, model, optimizer) else: training_history, param_history, path = model_loader.else_load( model_info, model) #### load data import data_loader if in_ipynb(): importlib.reload(data_loader) train_loader, val_loader = data_loader.data_from_data_info(model_info["data"]) ### pre train import ignite_train if in_ipynb(): importlib.reload(ignite_train) print("Pre training") model_info["training"]["max_epochs"] = 100
threed_points = np.load('./pose_references/reference_3d_68_points_trans.npy') transform = transforms.Compose([transforms.ToTensor()]) pose_mean = np.load(POSE_MEAN) pose_stddev = np.load(POSE_STDDEV) img2pose_model = img2poseModel( DEPTH, MIN_SIZE, MAX_SIZE, pose_mean=pose_mean, pose_stddev=pose_stddev, threed_68_points=threed_points, ) load_model(img2pose_model.fpn_model, MODEL_PATH, cpu_mode=str(img2pose_model.device) == "cpu", model_only=True) img2pose_model.evaluate() vcap = cv2.VideoCapture(0, cv2.CAP_V4L2) vcap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')) vcap.set(cv2.CAP_PROP_FRAME_WIDTH, 640) vcap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) vcap.set(cv2.CAP_PROP_FPS, 30) def draw_axis(img, pitch, yaw, roll, tdx=None, tdy=None, size=100): if tdx != None and tdy != None: tdx = tdx tdy = tdy
def load_saved_model(self, model_path): load_model(self.fpn_model_without_ddp, model_path, cpu_mode=str(self.device) == "cpu")
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', required=True) parser.add_argument( '--dataset', default='/home/nax/Downloads/shopee-product-matching/train.csv') parser.add_argument( '--train-label-split', default='/home/nax/Downloads/shopee-product-matching/train_labels.csv') parser.add_argument('--config', default='configs/baseline.py') parser.add_argument('--apex', action='store_true') parser.add_argument('--embedding-size', type=int) parser.add_argument('--batch-size', type=int) parser.add_argument('--image-size', type=int) parser.add_argument('--use_cuda', action='store_true') args = parser.parse_args() config = util.load_config(args.config) util.update_args(args, config) if args.apex: from apex import amp train_labels = np.loadtxt(args.train_label_split, dtype=np.int64) val_labels = data.get_val_labels(args.dataset, set(train_labels)) val_labels = list(val_labels) #val_dataset = data.DMLDataset(args.dataset, # image_size=args.image_size, # is_training=False, # onehot_labels=False, # subset_labels=val_labels) val_dataset = data.DMLDataset(args.dataset, image_size=args.image_size, is_training=False, onehot_labels=False) val_loader = data_util.DataLoader(val_dataset, batch_size=args.batch_size, num_workers=2, collate_fn=val_dataset.collate_fn) backbone, embeddings, model, states = model_loader.load_model( config, args, args.model) model.eval() if not args.apex: model = torch.nn.DataParallel(model) model = model.cuda() if args.apex: model = amp.initialize(model, opt_level='O1') model = torch.nn.DataParallel(model) if args.apex: amp.load_state_dict(states['amp']) model.eval() print( f'Val accuracy: {eval_utils.evaluate(model, val_loader, use_cuda=args.use_cuda)}' ) print( f'F1: {eval_utils.f1_evaluate(model, val_loader, use_cuda=args.use_cuda)}' ) print( f'F1: {eval_utils.f1_evaluate(model, val_loader, threshold=1.070329, use_cuda=args.use_cuda)}' )
def train( train_dataloader, query_dataloader, retrieval_dataloader, multi_labels, code_length, num_features, alpha, beta, max_iter, arch, lr, device, verbose, evaluate_interval, snapshot_interval, topk, checkpoint=None, ): """ Training model. Args train_dataloader(torch.evaluate.data.DataLoader): Training data loader. query_dataloader(torch.evaluate.data.DataLoader): Query data loader. retrieval_dataloader(torch.evaluate.data.DataLoader): Retrieval data loader. multi_labels(bool): True, if dataset is multi-labels. code_length(int): Hash code length. num_features(int): Number of features. alpha, beta(float): Hyper-parameters. max_iter(int): Number of iterations. arch(str): Model name. lr(float): Learning rate. device(torch.device): GPU or CPU. verbose(bool): Print log. evaluate_interval(int): Interval of evaluation. snapshot_interval(int): Interval of snapshot. topk(int): Calculate top k data points map. checkpoint(str, optional): Paht of checkpoint. Returns None """ # Model, optimizer, criterion model = load_model(arch, code_length) model.to(device) optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=1e-5) criterion = SSDH_Loss() # Resume resume_it = 0 if checkpoint: optimizer, resume_it = model.load_snapshot(checkpoint, optimizer) logger.info('[resume:{}][iteration:{}]'.format(checkpoint, resume_it + 1)) # Extract features features = extract_features(model, train_dataloader, num_features, device, verbose) # Generate similarity matrix S = generate_similarity_matrix(features, alpha, beta).to(device) # Training model.train() for epoch in range(resume_it, max_iter): n_batch = len(train_dataloader) for i, (data, _, index) in enumerate(train_dataloader): # Current iteration cur_iter = epoch * n_batch + i + 1 data = data.to(device) optimizer.zero_grad() v = model(data) H = v @ v.t() / code_length targets = S[index, :][:, index] loss = criterion(H, targets) loss.backward() optimizer.step() # Print log if verbose: logger.debug('[epoch:{}][Batch:{}/{}][loss:{:.4f}]'.format( epoch + 1, i + 1, n_batch, loss.item())) # Evaluate if cur_iter % evaluate_interval == 0: mAP = evaluate( model, query_dataloader, retrieval_dataloader, code_length, device, topk, multi_labels, ) logger.info('[iteration:{}][map:{:.4f}]'.format(cur_iter, mAP)) # Save snapshot if cur_iter % snapshot_interval == snapshot_interval - 1: model.snapshot(cur_iter, optimizer) logger.info('[iteration:{}][Snapshot]'.format(cur_iter)) # Evaluate and save snapshot mAP = evaluate( model, query_dataloader, retrieval_dataloader, code_length, device, topk, multi_labels, ) model.snapshot(cur_iter, optimizer) logger.info('Training finish, [iteration:{}][map:{:.4f}][Snapshot]'.format( cur_iter, mAP))
def load_model(path, name): return model_loader.load_model(path, name)