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)
