def test_all_images():
parser = argparse.ArgumentParser()
arg = parser.add_argument
# model-related variables
arg('--model-path', type=str, help='Model path')
arg('--dataset', type=str, help='roof: roof segmentation / income: income determination')
# image-related variables
arg('--masks-dir', type=str, default='./data/dataset/labels', help='numPy masks directory')
arg('--npy-dir', type=str, default='./data/dataset/split_npy', help='numPy preprocessed patches directory')
args = parser.parse_args()
roof_path = "./data/dataset/split_npy"
if args.dataset == "roof":
model = load_model(args.model_path, UNet11)
else:
model = load_model(args.model_path, UNet11, input_channels=5, num_classes=4)
# roof_model = load_model("./trained_models/model_10_percent_roof_Unet11_200epochs.pth", UNet11)
if not os.path.exists("./data/test_all"):
os.mkdir("./data/test_all")
# Select sample pictures
images_filenames = np.array(sorted(glob.glob(args.npy_dir + "/*.npy")))
for filename in tqdm(images_filenames):
fig = plt.figure(figsize=(10, 10))
image = pickle.load(open(filename, "rb"))
image = preprocess_image(image, args.dataset)
pred = run_model(image, model, args.dataset)
# if args.dataset == "income":
# roof_image = pickle.load(open(os.path.join(roof_path, filename[filename.rfind("/") + 1:]), "rb"))
# roof_image = preprocess_image(roof_image, "roof")
# pred_roof = run_model(roof_image, roof_model, "roof")
# pred[0][0] = pred[0][0] * pred_roof[0][0]
# pred[0][1] = pred[0][1] * pred_roof[0][0]
mask_path = os.path.join(args.masks_dir, args.dataset, filename[filename.rfind("/") + 1:])
y = pickle.load(open(mask_path, "rb"))
fig.add_subplot(1, 3, 1)
plt.imshow(reverse_transform(image.cpu().numpy()[0], args.dataset))
fig.add_subplot(1, 3, 2)
plt.imshow(masks_to_colorimg(y, args.dataset))
fig.add_subplot(1, 3, 3)
plt.imshow(pred_to_colorimg(pred.cpu().numpy(), args.dataset))
plt.savefig(os.path.join("./data/test_all",
filename[filename.rfind("/") + 1:filename.rfind(".")] + ".png"))
plt.clf()
plt.close(fig)
def __init__(self,
benchmark_dir='pytorch-benchmarks',
model_name='resnet50_ferplus_dag',
feature_layer='pool5_7x7_s1'):
''' Resnet50_Extractor: A feature extractor to extractor the final convolutional layer's
feature vector (2048 dimensional) and save those feature vectors to npy file in an
output directory.
Parameters:
benchmark_dir: string, default 'pytorch-benchmarks'
The pytorch-benchmarks is installed in benchmark_dir.
model_name: string, default 'resnet50_ferplus_dag'
The model name for resnet50 model.
feature_layer: string, default is 'pool5_7x7_s1'
The output feature layer for resnet50 model is the final convolutional layer named
'pool5_7x7_s1'.
'''
self.benchmark_dir = os.path.abspath(benchmark_dir)
self.model_name = model_name
self.feature_layer = feature_layer
assert os.path.exists(self.benchmark_dir), 'benchmark_dir must exits'
# load resnet50 model
model_dir = os.path.abspath(os.path.join(self.benchmark_dir,
'ferplus'))
self.model = load_model(self.model_name, model_dir)
self.model = self.model.to(device)
self.model.eval()
# load transformation function
meta = self.model.meta
self.transform = compose_transforms(meta, center_crop=True)
def __init_model(self):
if os.path.exists(os.path.join(self._checkpoint_dir, 'checkpoint.ckpt')):
print(f'Found model at {os.path.join(self._checkpoint_dir, "checkpoint.ckpt")}. Loading...')
self.model = load_model(os.path.join(self._checkpoint_dir, 'checkpoint.ckpt'))
else:
print(f'No model found at {os.path.join(self._checkpoint_dir, "checkpoint.ckpt")}. Creating...')
self.model = self.create()
print(self.model.summary())
def test_model(model_name, dataset_name, true_labels_path):
"""
Loads and tests a pretrained model
:param model_name: Name of the model to test
:param dataset_name: Name of the dataset
:param true_labels_path: CSV File path to containing true labels of test set
"""
model = load_model(dataset_name, model_name)
X = load_testdata(dataset_name)
probs = model.predict_proba(X)[:, 1]
print 'Saved the predicted probabilities'
dump_results(probs, model_name, dataset_name)
if true_labels_path:
analyze_metrics(probs, true_labels_path)
def write_depth_outs(input_path, output_path, model_path, device):
print("initialize")
model = load_model(model_path, device, cfg)
model.eval()
image_gen = pre_processing(input_path, output_path, device)
count = 0
for sample, img, img_name, num_images in image_gen:
# print(sample.shape, img.shape)
f = os.path.basename(img_name)
f = os.path.splitext(f)[0]
print(" Writing {} ({}/{})".format(output_path + f + ".png",
count + 1, num_images))
prediction, (_, _) = model(sample)
prediction, filename = post_processing(prediction, output_path, img,
img_name)
# print(prediction.shape)
midas_utils.write_depth(filename, prediction, bits=2)
count += 1
print("DONE")
def __init__(self, model_path):
if torch.cuda.is_available():
self.device = torch.device("cuda:0")
else:
self.device = torch.device('cpu')
self.num_classes = LoadImagesAndLabels.num_classes
print('Creating model...')
model_arch = 'resnet_34'
if "resnet_" in model_arch:
num_layer = int(model_arch.split("_")[1])
self.model = resnet(num_layers=num_layer,
heads={
'hm': self.num_classes,
'wh': 2,
'reg': 2
},
head_conv=64,
pretrained=True) # res_18
else:
print("model_arch error:", model_arch)
self.model = load_model(self.model, model_path)
self.model = self.model.to(self.device)
self.model.eval()
self.mean = np.array([[[0.40789655, 0.44719303, 0.47026116]]],
dtype=np.float32).reshape(1, 1, 3)
self.std = np.array([[[0.2886383, 0.27408165, 0.27809834]]],
dtype=np.float32).reshape(1, 1, 3)
self.class_name = LoadImagesAndLabels.class_name
self.down_ratio = 4
self.K = 100
self.vis_thresh = 0.3
self.show = True
def run(cv_method='loo', anom_type='mean'):
args = config.parse_arguments(
argv[1] if len(argv) >= 2 else _DEFAULT_CONFIG)
# Load the data
us_maize_regions = [
'Indiana', 'Illinois', 'Ohio', 'Nebraska', 'Iowa', 'Minnesota'
] # Growing season: April through to September
data = data_loading.load_temp_precip_data('Maize',
'Spring',
'USA',
us_maize_regions,
range(3, 9),
anom_type=anom_type)
if args.model.lower() == 'corr_bvg' or args.model == 'uncorr_bvg':
save_path = f'models/saved_models/{args.model}_save'
load_path = f'{save_path}.pkl'
if not os.path.exists(load_path):
model = models.models.fetch_model(args.model)
save_model(model=model, file_path=save_path)
else:
# Load model to circumvent compile time
model = load_model(load_path)
batched = False
# Fit the model
fit = model.sampling(data,
chains=args.chains,
iter=args.iter,
verbose=args.verbose,
seed=args.seed)
elif args.model.lower() == 'gp':
kernel = RBF(length_scale=0.5)
model = GaussianProcessRegressor(kernel=kernel,
normalize_y=True,
random_state=42)
batched = True
elif args.model.lower() == 'lr':
# model = LinearRegression(fit_intercept=True, normalize=True)
model = RidgeCV()
batched = True
else:
raise ValueError('Invalid model type.')
if cv_method == 'rolling':
# Rolling-origin cross-validation
print("===> Rolling-origin CV")
cv_results = validation.sliding_window_cv(model,
data,
args,
batched=batched)
elif cv_method == 'time-series':
# Time-series cross validation, incrementing by one year each split
print("===> Time-series CV")
n_splits = 34
cv_results = validation.time_series_cv(model,
data,
args,
n_splits=n_splits,
batched=batched)
elif cv_method == 'loo':
# LOO cross-validation
print("===> LOO CV")
cv_results = validation.leave_p_out_cv(model,
data,
args,
p=1,
batched=batched)
else:
# LTO cross-validation
print("===> LTO CV")
cv_results = validation.leave_p_out_cv(model,
data,
args,
p=3,
batched=batched)
print_metrics(cv_results)
# Params
d = 10
sz = 23
n_classes = 9
validation_split = .05
# Load training data
X, X_coord, y, X_test, X_coord_test, y_test = load_tiselac(training_set=True, test_split=.05, shuffle=True,
random_state=0)
# =========
# RFF stuff
# =========
fname_model_rff = "output/models_baseline/mlp_rff.256-128-64.00316-0.9456.weights.hdf5"
rff_model = load_model(fname_model_rff, sz=sz, d=d, d_side_info=2)
rff_features = rff_model.predict(numpy.hstack((X, X_coord)))
rff_features_test = rff_model.predict(numpy.hstack((X_test, X_coord_test)))
# =========
# RNN stuff
# =========
X_rnn = X.reshape((-1, sz, d))
X_rnn_test = X_test.reshape((-1, sz, d))
fname_model_rnn = "output/models_baseline/rnn.256.128-64.00409-0.9404.weights.hdf5"
rnn_model = load_model(fname_model_rnn, sz=sz, d=d, d_side_info=2)
rnn_features = rnn_model.predict([X_rnn, X_coord])
rnn_features_test = rnn_model.predict([X_rnn_test, X_coord_test])
# =========
# MLP stuff
def auto_label():
"""
detect on notDone imgs, insert high conf anns to d_hits_result + update status in d_hits
- global sl_anns 保存 SL 标注结果
- sl/al status 直接存入数据库，得到划分开的样本
todo: 解析得到 anns，再与 gt 比较，返回 al_ratio 筛选困难样本
"""
model_name, dataset = request.values['model'], request.values['dataset']
if dataset is not None:
# get class2names of current project
if choose_dataset_idx is not None:
project = project_list[choose_dataset_idx]
else:
project = find_project_by_name(session.get('choose_dataset'),
session.get('project_list'))
num_class, class2names = project['classes'], project['cats']
# load model and corresponding detector
model = get_model(backbone=model_name.split('_')[-1],
input_size=(480, 640), # 可存入 ckpt
num_classes=num_class + 1, # +bg
self_pretrained=True)
ckpt = os.path.join(model_dir, dataset, model_name, 'model_latest.pth')
model = load_model(model, ckpt_path=ckpt)
model = model.to(device)
model.eval()
print('load model done!')
# 前端进度 图片结果 显示需要
data['cur_idx'] = data['sl_num'] = data['al_num'] = data['progress'] = 0
data['sl_img_src'] = data['al_img_src'] = ''
# todo: can set a batch_num in query_d_hits() 如果 unlabel 数据量很大
unlabeled_rows, data['total_num'] = query_d_hits(project_name=dataset, status='notDone') # has no len
print('total:', data['total_num'])
# query one use, insert need
userId = query_one_userId()
global sl_anns
sl_anns = []
# ASM: detect here!
for img_idx, row in enumerate(unlabeled_rows):
# 从 row 解析得到 dict 标注
hit_dict = parse_row_to_dict(row, dict_template=hit_dict_tmp)
file_path = map_docker2host(hit_dict['data']) # change to the real img_path on nfs
img = Image.open(file_path)
img_w, img_h = img.size # cvt DT ann need
# hit_result_dict id auto increment
hit_result_dict['hitId'] = hit_dict['id']
hit_result_dict['projectId'] = hit_dict['projectId']
# ASM: generate auto label
boxes, labels = detect_unlabel_img(model, img, device) # x1y1x2y2, label_id
boxes = [list(map(int, box)) for box in boxes]
labels = [int(label) for label in labels]
# insert row to d_hits_result
if len(boxes) > 0:
## 保存 SL 结果到 Dataturks
result = []
for idx, (box, label) in enumerate(zip(boxes, labels)):
labels[idx] = label # already -1 in infer()
box_info = {
"label": [class2names[labels[idx]]],
"shape": "rectangle",
"points": cvt_box_to_4floatpts(box, img_w, img_h),
"notes": "",
"imageWidth": img_w,
"imageHeight": img_h
}
result.append(box_info)
# other columns
hit_result_dict['result'] = str(result).replace("'", '\\"') # 转义字符，插入 mysql 使用
hit_result_dict['userId'] = userId
hit_result_dict['notes'] = 'auto' # sl 备注
hit_result_dict['created_timestamp'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
hit_result_dict['updated_timestamp'] = hit_result_dict['created_timestamp']
# insert to DT database
insert_sl_ann_to_db(hit_result_dict)
# ASM: 保存模型标注结果到 sl_anns
sl_anns.append({ # 解析的 unlabel gt_anns 也要有这种格式
'id': hit_dict['id'],
'filepath': file_path,
'boxes': boxes, # x1y1x2y2
'labels': labels
})
update_status_in_db(hit_dict['id'], status='sl')
else:
update_status_in_db(hit_dict['id'], status='al')
# plt bbox on img, visualize on the frontend
web_img_src = plt_bbox(img, boxes, labels, class2names, send_web=True)
if len(boxes) > 0:
data['sl_img_src'] = web_img_src
data['sl_num'] += 1
else:
data['al_img_src'] = web_img_src
data['al_num'] += 1
data['cur_idx'] = img_idx + 1
data['progress'] = int(data['cur_idx'] / data['total_num'] * 100)
return jsonify(data)
else:
return redirect('/datasets')
def main(config):
# set up workspace
work_space = config["workspace"]
tf_board = config["tf_board"]
setup_workpath(work_space)
name = config["Name"]
# Construct or load embeddings
print("Initializing embeddings ...")
vocab_size = config["embeddings"]["vocab_size"]
embed_size = config["embeddings"]["embed_size"]
# Build the model and compute losses
(encode_num_layers, encode_num_units, encode_cell_type, encode_bidir,
attn_num_units, decode_num_layers, decode_num_units, decode_cell_type,
use_user_feat,use_gate_memory,use_user_desc,use_blog_user_coattn,
use_external_desc_express,use_external_feat_express,
user_feat_dim,user_feat_unit,user_feat_mem_unit,
desc_rnn_unit,desc_attn_num_units,user_map_unit,
) = get_pcgn_model_config(config)
(train_file, dev_file,
source_max_length, target_max_length, desc_max_length,
gpu_fraction, gpu_id, train_steps, checkpoint_every, print_every,
batch_size,is_beam_search,beam_size,infer_max_iter,
l2_regularize,learning_rate,max_checkpoints,max_gradient_norm,
) = get_pcgn_training_config(config)
train_set=read_data(train_file)
print(' # train data:',len(train_set))
dev_set=read_data(dev_file)
print(' # dev data:',len(dev_set))
print("Building model architecture ")
pcg_model = PCGNModel(
mode='train', model_name=name,
vocab_size=vocab_size, embedding_size=embed_size,
encode_num_layers=encode_num_layers, encode_num_units=encode_num_units,
encode_cell_type=encode_cell_type, encode_bidir=encode_bidir,
attn_num_units=attn_num_units, decode_num_layers=decode_num_layers,
decode_num_units=decode_num_units, decode_cell_type=decode_cell_type,
use_user_feat=use_user_feat, use_gate_memory=use_gate_memory,
use_user_desc=use_user_desc, use_blog_user_coattn=use_blog_user_coattn,
use_external_desc_express=use_external_desc_express, use_external_feat_express=use_external_feat_express,
user_feat_dim=user_feat_dim, user_feat_unit=user_feat_unit, user_feat_mem_unit=user_feat_mem_unit,
desc_rnn_unit=desc_rnn_unit, desc_attn_num_units=desc_attn_num_units, user_map_unit=user_map_unit,
batch_size=batch_size, beam_search=is_beam_search, beam_size=beam_size, infer_max_iter=infer_max_iter, target_max_length=target_max_length,
l2_regularize=l2_regularize, learning_rate=learning_rate, max_to_keep=max_checkpoints, max_gradient_norm=max_gradient_norm,
)
print("\tDone.")
logdir = '%s/nn_models/' % work_space
# Set up session
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpu_fraction, visible_device_list=gpu_id,allow_growth=True)
sess = tf.Session(config=tf.ConfigProto(log_device_placement=False,
gpu_options=gpu_options))
init = tf.global_variables_initializer()
sess.run(init)
# tensorbord
if use_tensorboard:
train_writer = tf.summary.FileWriter(tf_board + 'train/', sess.graph)
test_writer = tf.summary.FileWriter(tf_board + 'test/', sess.graph)
try:
saved_global_step = load_model(pcg_model.saver, sess, logdir)
if saved_global_step is None:
saved_global_step = -1
except Exception:
print("Something went wrong while restoring checkpoint. "
"Training is terminated to avoid the overwriting.")
raise
# ##### Training #####
# Training
last_saved_step = saved_global_step
num_steps = saved_global_step + train_steps
steps = []
previous_losses=[]
lr = pcg_model.learning_rate
print("Start training ...")
print('steps per epoch:',len(train_set)//batch_size)
try:
for step in range(saved_global_step + 1, num_steps):
start_time = time.time()
batch = get_pcgn_batch(train_set,'train', batch_size,source_max_length, target_max_length,desc_max_length)
loss_value = pcg_model.train(sess, batch)
previous_losses.append(loss_value)
lr_decay_step = 10
if step % 500 == 0 and len(previous_losses)-5 > lr_decay_step and np.mean(previous_losses[-5:]) >= np.mean(previous_losses[-lr_decay_step -5:-5]):
lr=pcg_model.learning_rate
if lr > 0.00001:
pcg_model.learning_rate=lr*0.9
print('learning rate decay:',lr*0.9)
duration = (time.time() - start_time)
if step % print_every == 0 and step != 0:
# train perplexity
t_perp = pcg_model.compute_perplexity(sess, batch)
if use_tensorboard:
add_summary(train_writer, step, 'train perplexity', t_perp)
# eval perplexity
dev_str = ""
if dev_set is not None:
eval_batch = get_pcgn_batch(dev_set,'train', batch_size,source_max_length, target_max_length,desc_max_length)
eval_perp = pcg_model.compute_perplexity(sess, eval_batch)
with open(logdir+'eval_perp.txt','a',encoding='utf-8') as f:
f.write('{}\t{}\n'.format(str(step),str(eval_perp)))
if use_tensorboard:
add_summary(test_writer, step, 'eval perplexity', eval_perp)
dev_str += "val_prep: {:.3f}\n".format(eval_perp)
steps.append(step)
ep=step//(len(train_set)//batch_size)
info = 'epoch {:d}, step {:d},lr:{:.5f}, loss = {:.6f},perp: {:.3f}\n{}({:.3f} sec/step)'
print(info.format(ep,step,lr, loss_value, t_perp, dev_str, duration))
if step % checkpoint_every == 0:
save_model(pcg_model.saver, sess, logdir, step)
last_saved_step = step
except KeyboardInterrupt:
# Introduce a line break after ^C so save message is on its own line.
print()
finally:
if step > last_saved_step:
save_model(pcg_model.saver, sess, logdir, step)
def train_model(train_anns,
eval_anns,
model,
device,
model_save_dir,
ckpt='model_latest.pth',
num_epoches=10,
batch_size=4,
ap='ap_50',
ap_thre=0.5,
ap_range=3,
ap_shift_thre=0.001):
# optimizer
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.SGD(params,
lr=0.005,
momentum=0.9,
weight_decay=0.0005)
# load pretrain best model
ckpt_path = os.path.join(model_save_dir, ckpt)
model, optimizer, start_epoch = load_model(model, ckpt_path, optimizer)
lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, T_max=num_epoches)
# train/eval dataset
dataset = Detection_Dataset_anns(train_anns, get_transform(True))
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
shuffle=True,
pin_memory=True,
num_workers=4,
collate_fn=collate_fn)
dataset_eval = Detection_Dataset_anns(eval_anns, get_transform(False))
dataloader_eval = torch.utils.data.DataLoader(dataset_eval,
batch_size=1,
shuffle=False,
pin_memory=True,
num_workers=4,
collate_fn=collate_fn)
# 检测参数
writer = SummaryWriter(log_dir='runs/{}'.format(get_curtime()))
ap_records = {'ap_50': [], 'ap_75': [], 'ap_shift': []}
for epoch in range(start_epoch, num_epoches): # epoch 要从0开始，内部有 warm_up
# train
train_one_epoch(model,
optimizer,
dataloader,
device,
epoch,
print_freq=10,
writer=writer,
begin_step=epoch * len(dataloader))
# store & update lr
writer.add_scalar('Train/lr',
optimizer.param_groups[0]["lr"],
global_step=epoch)
lr_scheduler.step()
# eval after each train
evals = evaluate(model, dataloader_eval, device, writer, epoch)
# states
ap_records['ap_50'].append(evals['ap_50'])
ap_records['ap_75'].append(evals['ap_75'])
if len(ap_records[ap]) >= ap_range:
ap_shift = lasso_shift(ap_records[ap][-ap_range:])
else:
ap_shift = 0
ap_records['ap_shift'].append(ap_shift)
writer.add_scalar('Accuracy/AP_shift', ap_shift, global_step=epoch)
if evals[ap] > ap_thre:
ckpt_path = os.path.join(model_save_dir,
'model_{}.pth'.format(epoch))
save_model(ckpt_path, model, epoch, optimizer)
if 0 < ap_shift < ap_shift_thre: # break and save ap records
best_idx_in_range = ap_records[ap].index(
max(ap_records[ap][-ap_range:]))
best_epoch = epoch - ap_range + 1 + best_idx_in_range
print('best epoch:', best_epoch)
save_clean_best_model(best_epoch, model_save_dir)
def detect(save_img=False):
img_size = (
320, 192
) if ONNX_EXPORT else opt.img_size # (320, 192) or (416, 256) or (608, 352) for (height, width)
out, depth_output_path, source, weights, half, view_img, save_txt = opt.yolo_output, opt.depth_output, opt.source, opt.weights, opt.half, opt.view_img, opt.save_txt
webcam = source == '0' or source.startswith('rtsp') or source.startswith(
'http') or source.endswith('.txt')
# Initialize
device = torch_utils.select_device(
device='cpu' if ONNX_EXPORT else opt.device)
if os.path.exists(out):
shutil.rmtree(out) # delete output folder
os.makedirs(out) # make new output folder
if os.path.exists(depth_output_path):
shutil.rmtree(depth_output_path) # delete output folder
os.makedirs(depth_output_path) # make new output folder
# Initialize model
cfg = opt.cfg
model = load_model(weights, device, cfg)
# Eval mode
model.to(device).eval()
# Second-stage classifier
classify = False
if classify:
modelc = torch_utils.load_classifier(name='resnet101',
n=2) # initialize
modelc.load_state_dict(
torch.load('weights/resnet101.pt',
map_location=device)['model']) # load weights
modelc.to(device).eval()
# Export mode
if ONNX_EXPORT:
model.fuse()
img = torch.zeros((1, 3) + img_size) # (1, 3, 320, 192)
f = opt.weights.replace(opt.weights.split('.')[-1],
'onnx') # *.onnx filename
torch.onnx.export(model, img, f, verbose=False, opset_version=11)
# Validate exported model
import onnx
model = onnx.load(f) # Load the ONNX model
onnx.checker.check_model(model) # Check that the IR is well formed
print(onnx.helper.printable_graph(
model.graph)) # Print a human readable representation of the graph
return
# Half precision
half = half and device.type != 'cpu' # half precision only supported on CUDA
if half:
model.half()
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = True
torch.backends.cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=img_size)
else:
save_img = True
dataset = LoadImages(source, img_size=img_size)
# Get names and colors
names = load_classes(opt.names)
colors = [[random.randint(0, 255) for _ in range(3)]
for _ in range(len(names))]
# Run inference
t0 = time.time()
_ = model(torch.zeros(
(1, 3, img_size, img_size),
device=device)) if device.type != 'cpu' else None # run once
print("**** Writing BBOX outs ****")
for path, img, im0s, vid_cap in dataset:
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = torch_utils.time_synchronized()
# pred = model(img, augment=opt.augment)[0]
depth_out, pred = model.forward_once(
img) # inference and training outputs
# depth_out = midas_post_processing(depth_out)
# print(f"DBG depth_out.shape - {depth_out.shape}")
t2 = torch_utils.time_synchronized()
# to float
if half:
pred = pred.float()
# Apply NMS
pred = non_max_suppression(pred,
opt.conf_thres,
opt.iou_thres,
multi_label=False,
classes=opt.classes,
agnostic=opt.agnostic_nms)
# Apply Classifier
# if classify:
# pred = apply_classifier(pred, modelc, img, im0s)
# Process detections
for i, det in enumerate(pred): # detections per image
if webcam: # batch_size >= 1
p, s, im0 = path[i], '%g: ' % i, im0s[i]
else:
p, s, im0 = path, '', im0s
save_path_bboxes = str(Path(out) / Path(p).name)
# save_path_depth = str(Path(depth_output_path) / Path(p).name)
s += '%gx%g ' % img.shape[2:] # print string
if det is not None and len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(img.shape[2:], det[:, :4],
im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += '%g %ss, ' % (n, names[int(c)]) # add to string
# Write results
for *xyxy, conf, cls in det:
if save_txt: # Write to file
with open(save_path + '.txt', 'a') as file:
file.write(('%g ' * 6 + '\n') % (*xyxy, cls, conf))
if save_img or view_img: # Add bbox to image
label = '%s %.2f' % (names[int(cls)], conf)
plot_one_box(xyxy,
im0,
label=label,
color=colors[int(cls)])
# Print time (inference + NMS)
print('%sDone. (%.3fs)' % (s, t2 - t1))
# Stream results
if view_img:
cv2.imshow(p, im0)
if cv2.waitKey(1) == ord('q'): # q to quit
raise StopIteration
# Save results (image with detections)
if save_img:
if dataset.mode == 'images':
# cv2.imwrite(save_path, im0)
# depth_out = depth_out.permute((1,2,0))
# depth_out = depth_out.cpu().numpy()
# print(f"DBG2 depth_out.shape - {depth_out.shape}")
# print(f"DBG2 im0.shape - {im0.shape}")
# print(f"DBG2 type(im0) - {type(im0)}")
cv2.imwrite(save_path_bboxes, im0)
# cv2.imwrite(save_path_depth, depth_out)
else:
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release(
) # release previous video writer
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*opt.fourcc),
fps, (w, h))
vid_writer.write(im0)
if save_txt or save_img:
print('Results saved to %s' % os.getcwd() + os.sep + out)
if platform == 'darwin': # MacOS
os.system('open ' + out + ' ' + save_path)
# Writing Depths
print("**** Writing Depth outs ****")
write_depth_outs(source, depth_output_path, weights, device)
print("finished")
print('Done. (%.3fs)' % (time.time() - t0))
def main(opt):
path_save_model_ = './model_save/'
if not os.path.exists(path_save_model_):
os.mkdir(path_save_model_)
torch.manual_seed(opt.seed)
torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test
opt = opts().update_dataset_info_and_set_heads(opt, LoadImagesAndLabels)
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
cuda = torch.cuda.is_available()
device_ = torch.device('cuda' if cuda else 'cpu')
opt.device = device_
chunk_sizes_ = [8]
gpus_ = [0]
# resnet_18 ,resnet_34 ,resnet_50,resnet_101,resnet_152
model_arch = 'resnet_34'
print('Creating model...')
num_layer = int(model_arch.split("_")[1])
num_classes = 1
heads_ = {'hm': num_classes, 'wh': 2, 'reg': 2}
print('heads : {}'.format(heads_))
model = resnet(num_layers=num_layer,
heads=heads_,
head_conv=64,
pretrained=True) # res_18
# print(model)
batch_size_ = 16
num_workers_ = 4
learning_rate_ = 1.25e-4
path_load_model_ = './model_save/model_hand_last.pth'
# path_load_model_ = ''
lr_step_ = [190, 220]
optimizer = torch.optim.Adam(model.parameters(), learning_rate_)
start_epoch = 0
if os.path.exists(path_load_model_):
model, optimizer, start_epoch = load_model(model, path_load_model_,
optimizer, True,
learning_rate_, lr_step_)
trainer = CtdetTrainer(opt, model, optimizer)
trainer.set_device(gpus_, chunk_sizes_, device_)
print('load train_dataset')
train_dataset = LoadImagesAndLabels(state='train', path_='../done/')
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size_,
shuffle=True,
num_workers=num_workers_,
pin_memory=False,
drop_last=True)
print('Starting training...')
print("using arch : {}".format(model_arch))
print('num_classes : {}'.format(num_classes))
print('batch_size : {}'.format(batch_size_))
print('num_workers : {}'.format(num_workers_))
print('learning_rate : {}'.format(learning_rate_))
print('lr_step : {}'.format(lr_step_))
print('path_load_model : {}'.format(path_load_model_))
for epoch in range(start_epoch + 1, opt.num_epochs + 1):
log_dict_train, _ = trainer.train(epoch, train_loader)
save_model(path_save_model_ + 'model_hand_last.pth', epoch, model,
optimizer)
if epoch % 1 == 0:
save_model(path_save_model_ + 'hand_epoch{}.pth'.format(epoch),
epoch, model, optimizer)
if epoch in lr_step_:
save_model(path_save_model_ + 'model_hand_{}.pth'.format(epoch),
epoch, model, optimizer)
lr = learning_rate_ * (0.1**(opt.lr_step.index(epoch) + 1))
print('Drop LR to', lr)
for param_group in optimizer.param_groups:
param_group['lr'] = lr
n_classes = 9
validation_split = .1
test_split = .05
# Load training data
X, X_coord, y = load_tiselac(training_set=True, shuffle=True, random_state=0)
# Model definition
fname_model = "output/models_baseline/mlp.256-128-64.00258-0.9440.weights.hdf5"
# fname_model = "output/models_baseline/mlp_rff.256-128-64.00184-acc0.9413.weights.hdf5"
# fname_model = "output/models_baseline/rnn.256.128-64.00344-acc0.9459.weights.hdf5"
model = load_model(fname_model=fname_model,
sz=sz,
d=d,
d_side_info=X_coord.shape[1],
n_classes=n_classes)
if fname_model.split("/")[-1].startswith("rnn."):
X = X.reshape((-1, sz, d))
X_final = [X, X_coord]
else:
X_final = numpy.hstack((X, X_coord))
print_train_valid_test(model=model,
X=X_final,
y=y,
validation_split=validation_split,
test_split=test_split)
def run_experiment(config_name, experiment_id, train_transform,
test_transform):
root_path = './data'
out_dir = './results'
run_lr_range_test = False
run_training = True
cfg = config_parser.parse_config(config_name)
params = cfg.train_params
manualSeed = 111
# manualSeed=None
now = datetime.datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))
experiment_name = os.path.basename(config_name).split(
'.')[0] + experiment_id
out_dir = '_'.join(
[os.path.join(out_dir, experiment_name),
now.strftime("%m_%d_%H")])
print('Find log in {}'.format(out_dir))
shutil.rmtree(out_dir, ignore_errors=True)
os.makedirs(out_dir, exist_ok=True)
logger = logging.getLogger("CIFAR")
logger.setLevel(logging.INFO)
# logging to file
fileHandler = logging.FileHandler(os.path.join(out_dir, 'training.log'))
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fileHandler.setFormatter(formatter)
logger.addHandler(fileHandler)
# logging to stdout
consoleHandler = logging.StreamHandler()
consoleHandler.setFormatter(formatter)
logger.addHandler(consoleHandler)
logger.info("Initialization")
if manualSeed is None:
manualSeed = random.randint(1, 10000)
random.seed(manualSeed)
torch.manual_seed(manualSeed)
#######################################
# 1. Data preparation
#######################################
# train_data = CIFAR100(root_path, train=True, download=False,
# custom_aug=A.Compose({A.FancyPCA()}),
# transform=torchvision.transforms.Compose([
# torchvision.transforms.ToTensor(),
# torchvision.transforms.Normalize(mean=cifar_mean, std=cifar_std)
# ])
# )
train_data = torchvision.datasets.CIFAR100(root_path,
train=True,
download=True,
transform=train_transform)
test_data = torchvision.datasets.CIFAR100(root_path,
train=False,
download=False,
transform=test_transform)
train_loader = DataLoader(train_data,
batch_size=params.batch_size_train,
shuffle=True,
num_workers=params.num_workers)
test_loader = DataLoader(test_data,
batch_size=params.batch_size_train,
shuffle=False,
num_workers=params.num_workers)
#######################################
# 2. Initialization
#######################################
device = torch.device("cuda:{}".format(params.cuda_number) if torch.cuda.
is_available() else "cpu")
if params.model == "CNN":
model = CNN(n_filters=params['model_params'],
n_classes=100,
mfm=False,
norm_embds=params.norm_embds)
elif params.model == "CNN_lsoftmax":
model = MarginSoftmaxCNN(n_filters=params['model_params'],
n_classes=100,
margin=params.margin,
mfm=False)
elif params.model == "CNN_mfm":
model = CNN(n_filters=params['model_params'],
n_classes=100,
norm_embds=params.norm_embds)
elif params.model == "CNN_mfm_lsoftmax":
model = MarginSoftmaxCNN(n_filters=params['model_params'],
n_classes=100,
margin=params.margin)
elif params.model == "origResNet18":
model = torchvision.models.resnet18(num_classes=100)
elif params.model == "ResNet18":
model = ResNet(BasicBlock, params.model_params, num_classes=100)
elif params.model == "ResNet18_lsoftmax":
model = ResNet(BasicBlock,
params.model_params,
num_classes=100,
margin=params.margin,
loss_type='l')
elif params.model == "ResNet18_amsoftmax":
model = ResNet(BasicBlock,
params.model_params,
num_classes=100,
margin=params.margin,
loss_type='am')
elif params.model == "WideResNet":
model = WideResNet(WideBasicBlock,
params.model_params,
num_classes=100,
k=params.width)
elif params.model == "WideResNet_lsoftmax":
model = WideResNet(WideBasicBlock,
params.model_params,
num_classes=100,
k=params.width,
margin=params.margin)
else:
raise Exception(
'Unknown architecture. Use one of CNN, CNN_mfm, ResNet')
if run_training:
unfreeze_in = None
if params.use_pretrained and os.path.exists(params.use_pretrained):
model_utils.load_model(model, params.use_pretrained)
elif params.model == "origResNet18" and params.use_pretrained == "orig18":
model = torchvision.models.resnet18(pretrained=True)
model.fc = nn.Linear(512, 100)
model_utils.freeze_layers(model, nn.Linear)
unfreeze_in = params.freeze
elif params.model == "origResNet18" and params.use_pretrained == "orig34":
model = torchvision.models.resnet18(pretrained=True)
init_model = torchvision.models.resnet34(pretrained=True)
model_utils.load_state_dict(model, init_model.state_dict())
model.fc = nn.Linear(512, 100)
model_utils.freeze_layers(model, nn.Linear)
unfreeze_in = params.freeze
else:
logger.info('No pretrained model was found.')
model.eval()
model.to(device)
summary(model, input_size=(3, 32, 32))
if params.optimizer == 'Adam':
optimizer = optim.Adam(model.parameters(),
lr=params.learning_rate,
weight_decay=5e-4)
elif params.optimizer == 'SGD':
optimizer = optim.SGD(model.parameters(),
lr=params.learning_rate,
momentum=0.9,
weight_decay=5e-4,
nesterov=True)
else:
print('Unknown optimizer. SGD is used instead')
optimizer = optim.SGD(model.parameters(),
lr=params.learning_rate,
momentum=0.9,
weight_decay=5e-4,
nesterov=True)
loss_function = None
if params.loss == 'CrossEntropyLoss':
loss_function = nn.CrossEntropyLoss()
elif params.loss == 'NLLLoss':
loss_function = nn.NLLLoss()
elif params.loss == 'SoftCrossEntropyLoss':
loss_function = label_smoothing.SoftCrossEntropyLoss(
label_smoothing=0.1, num_classes=100)
else:
raise Exception('Unknown type of loss')
#######################################
# 3. LR range test
#######################################
if run_lr_range_test:
lr_range_test(model=model,
loss_function=loss_function,
optimizer=optimizer,
out_dir=out_dir,
train_loader=train_loader,
test_loader=test_loader)
#######################################
# 4. Training
#######################################
if run_training:
change_lr_during_epoch = False
if params.lr_scheduler == 'StepLR':
scheduler = lr_scheduler.StepLR(
optimizer, step_size=params.learning_rate_step, gamma=0.1)
elif params.lr_scheduler == 'MultiStepLR':
# scheduler = lr_scheduler.MultiStepLR(optimizer, [50, 100], gamma=0.1)
# scheduler = lr_scheduler.MultiStepLR(optimizer, [40, 80], gamma=0.1)
scheduler = lr_scheduler.MultiStepLR(optimizer, [30, 60, 80],
gamma=0.1)
elif params.lr_scheduler == 'ReduceLROnPlateau':
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer,
mode='min',
factor=0.1,
patience=20,
verbose=True,
threshold=0.0001,
min_lr=0,
eps=1e-04)
elif params.lr_scheduler == 'OneCycleLR':
change_lr_during_epoch = True
scheduler = lr_scheduler.OneCycleLR(
optimizer,
max_lr=params.max_lr,
steps_per_epoch=len(train_loader),
div_factor=params.div_factor,
final_div_factor=params.final_div_factor,
epochs=params.num_epoch,
# anneal_strategy='linear'
)
else:
raise Exception('Unknown type of lr scheduler')
trainer = CifarTrainer(
model=model,
optimizer=optimizer,
criterion=loss_function,
snapshot_dir=os.path.join(out_dir, 'snapshots'),
log_dir=out_dir,
result_dir=out_dir,
device=device,
scheduler=scheduler,
change_lr_during_epoch=change_lr_during_epoch,
use_labels_for_training=True if 'lsoftmax' in params.model
or 'amsoftmax' in params.model else False)
tic = time.perf_counter()
for epoch in range(params.num_epoch):
if epoch == unfreeze_in:
model_utils.unfreeze_layers(model)
test_acc, test_mean_loss = trainer.test_model(test_loader,
iteration=epoch,
epoch=epoch,
batch_idx=0,
mark='Test')
train_acc, train_mean_loss = trainer.test_model(train_loader,
iteration=epoch,
epoch=epoch,
batch_idx=0,
mark='Train')
logger.info('Training epoch {}/{}, lr: {}'.format(
epoch, params.num_epoch, scheduler.get_lr()))
print('Check outpu in {}'.format(out_dir))
if params.do_mixup:
trainer.train_mixup_epoch(train_loader,
test_loader,
epoch,
train_acc_check=None,
test_acc_check=None)
else:
trainer.train_epoch(train_loader,
test_loader,
epoch,
train_acc_check=None,
test_acc_check=None)
if not change_lr_during_epoch:
scheduler.step()
toc = time.perf_counter()
logger.info(
f"Finished in {(toc - tic) / ((epoch+1) * 60):0.4f} minutes")
def predict_model(self):
net = load_model(self.trained_data, self.model)
scores = net.predict_proba(self.X)
self.scores = scores[:, 1]
def show_sample_images():
parser = argparse.ArgumentParser()
arg = parser.add_argument
# model-related variables
arg('--model-path', type=str, help='Model path')
arg('--num-picture', type=int, default=3, help='Number of sample pictures')
arg('--dataset',
type=str,
help='roof: roof segmentation / income: income determination')
# image-related variables
arg('--image-patches-dir',
type=str,
default='./data/dataset/split',
help='satellite image patches directory')
arg('--masks-dir',
type=str,
default='./data/dataset/labels',
help='numPy masks directory')
arg('--npy-dir',
type=str,
default='./data/dataset/split_npy',
help='numPy preprocessed patches directory')
args = parser.parse_args()
roof_path = "./data/dataset/split_npy"
modelname = args.model_path[args.model_path.rfind("/") +
1:args.model_path.rfind(".pth")]
if args.dataset == "roof":
model = load_model(args.model_path, UNet11)
else:
model = load_model(args.model_path,
UNet11,
input_channels=5,
num_classes=4)
# roof_model = load_model("./trained_models/model_10_percent_roof_Unet11_200epochs.pth", UNet11)
print("Testing {} on {} samples".format(modelname, args.num_picture))
# Select sample pictures
images_filenames = np.array(sorted(glob.glob(args.npy_dir + "/*.npy")))
sample_filenames = np.random.choice(images_filenames, args.num_picture)
fig = plt.figure(figsize=(10, 7.5 * args.num_picture))
for idx, filename in enumerate(sample_filenames):
print("Loading sample input {}".format(idx))
image = pickle.load(open(filename, "rb"))
image = preprocess_image(image, args.dataset)
print("Running model for sample {}".format(idx))
pred = run_model(image, model, args.dataset)
# if args.dataset == "income":
# roof_image = pickle.load(open(os.path.join(roof_path, filename[filename.rfind("/") + 1:]), "rb"))
# roof_image = preprocess_image(roof_image, "roof")
# pred_roof = run_model(roof_image, roof_model, "roof")
# pred[0][0] = pred[0][0] * pred_roof[0][0]
# pred[0][1] = pred[0][1] * pred_roof[0][0]
mask_path = os.path.join(args.masks_dir, args.dataset,
filename[filename.rfind("/") + 1:])
y = pickle.load(open(mask_path, "rb"))
print("Get mask for sample {}".format(idx))
fig.add_subplot(args.num_picture, 3, idx * 3 + 1)
plt.imshow(reverse_transform(image.cpu().numpy()[0], args.dataset))
print("Add plot for sample input {}".format(idx))
fig.add_subplot(args.num_picture, 3, idx * 3 + 2)
plt.imshow(masks_to_colorimg(y, args.dataset))
print("Add plot for sample mask {}".format(idx))
fig.add_subplot(args.num_picture, 3, idx * 3 + 3)
plt.imshow(pred_to_colorimg(pred.cpu().numpy(), args.dataset))
print("Add plot for sample pred {}".format(idx))
if not os.path.exists("test"):
os.mkdir("test")
if not os.path.exists("test/{}".format(args.dataset)):
os.mkdir("test/{}".format(args.dataset))
plt.savefig("test/{}/test_{}_samples_{}.png".format(
args.dataset, args.num_picture, modelname))
def _load_model(self, step=None, filename=None, **kwargs):
# this needs to be updated with the device
self.model = load_model(self.ckpt_dir, step, filename, **kwargs)
para = load_kaldi_xvec_para_est_stat(mdl,
Stats_,
it_tr_que,
sess,
set_para,
X1_p,
C1_p,
is_test_p,
feat_dim=23,
n_lay_before_pooling=5,
n_lay_after_pooling=2,
feat_norm=do_feat_norm,
pool_norm=do_pool_norm)
set_para(para)
elif (tf_model != None):
para = load_model(tf_model)
set_para(para)
check_dev_multi_loss_acc()
batch_start = 0
batch_count = batch_start
# The batch_iterator class prepares batches in a second thread while the training is running.
all_bad_utts = [
] # Keeps track of 0-duration utterances. (Which are ignored in trainin). Not used if annoying_train=True
it_tr_que = utils.mbatch_generation.batch_iterator_2(it_tr,
load_feats_train,
annoying_train,
batch_que_length,
batch_count,
type=float,
default=1.0,
help='temperature of the gaussian distribution')
parser.add_argument('--draw_neighborhood',
type=strtobool,
default='true',
help='if neighborhood of a molecule to be visualized')
parser.add_argument('--save_fig', type=strtobool, default='true')
args = parser.parse_args()
chainer.config.train = False
snapshot_path = os.path.join(args.model_dir, args.snapshot_path)
hyperparams_path = os.path.join(args.model_dir, args.hyperparams_path)
print("loading hyperparamaters from {}".format(hyperparams_path))
model_params = Hyperparameters(path=hyperparams_path)
model = load_model(snapshot_path, model_params, debug=True)
if args.gpu >= 0:
model.to_gpu(args.gpu)
true_data = NumpyTupleDataset.load(
os.path.join(args.data_dir, args.molecule_file))
if args.data_name == 'qm9':
atomic_num_list = [6, 7, 8, 9, 0]
true_data = TransformDataset(true_data, transform_qm9.transform_fn)
valid_idx = transform_qm9.get_val_ids()
elif args.data_name == 'zinc250k':
atomic_num_list = zinc250_atomic_num_list
true_data = TransformDataset(true_data, transform_fn_zinc250k)
valid_idx = transform_zinc250k.get_val_ids()
# Load training data
X, X_coord = load_tiselac(training_set=False)
fname_ensemble = "output/models_ensemble/mlp_rnn_rff.64-32.rnn.256.128-64.00409-0.9404.mlp.256-128-64.00258-0.9440." + \
"mlp_rff.256-128-64.00316-0.9456.00080-0.9514.weights.hdf5"
splitted_fname = os.path.basename(fname_ensemble).split(".")
n_units_hidden_layers_ensemble = [int(s) for s in splitted_fname[1].split("-")]
# =========
# RFF stuff
# =========
fname_model_rff = os.path.join("output/models_baseline/",
"mlp_rff.256-128-64.00316-0.9456.weights.hdf5")
rff_model = load_model(fname_model_rff, sz=sz, d=d, d_side_info=2)
rff_features = rff_model.predict(numpy.hstack((X, X_coord)))
# =========
# RNN stuff
# =========
X_rnn = X.reshape((-1, sz, d))
fname_model_rnn = os.path.join(
"output/models_baseline/",
fname_ensemble[fname_ensemble.rfind("rnn."):fname_ensemble.rfind(".mlp.")]
+ ".weights.hdf5")
rnn_model = load_model(fname_model_rnn, sz=sz, d=d, d_side_info=2)
rnn_features = rnn_model.predict([X_rnn, X_coord])
# =========
# MLP stuff
def get_branch(ckpt_dir,
fold,
root,
cv_folds_dir,
train,
patient=None,
blacklist=None,
marker=None,
step=None,
batch_size=8,
eval_batch_size=None,
distributed=False,
num_gpus=1,
keep_prob=1,
num_workers=8,
verbose=1,
random_state=420):
"""Returns a fine tuned model, train, val, and test dataloaders from a `ckpt_dir`"""
fold_dir = os.path.join(ckpt_dir, f'fold_{fold}')
config = model_utils.load_config(ckpt_dir)
if step is None:
step = max([
int(fn.split('_')[1]) for fn in os.listdir(fold_dir)
if fn.startswith('ckpt')
])
tile_version = config['input']['images'].strip('/').split('/')[-1]
image_dir = os.path.join(root, tile_version, 'tiles')
num_tiles = os.path.join(root, tile_version, 'num_tiles.csv')
num_tiles = num_tiles if os.path.exists(
num_tiles) else config['data']['num_tiles']
df_panda = data_utils.load_data(train,
image_dir,
patient=patient,
blacklist=blacklist,
num_tiles=num_tiles,
marker=marker)
if keep_prob < 1:
keep_n = int(np.ceil(len(df_panda) * keep_prob))
df_panda = df_panda.iloc[:keep_n]
df_panda = df_panda.iloc[:200]
cv_folds = data_utils.load_cv_folds(
os.path.join(cv_folds_dir, 'cv_folds.p'))
df_panda['fold'] = data_utils.get_fold_col(df_panda, cv_folds)
img_stats = data_utils.load_img_stats(
os.path.join(cv_folds_dir, tile_version), 0)
tile_aug_params = config['augmentations'].get('tile', {})
tile_aug_params['normalize'] = img_stats
img_aug_params = config['augmentations'].get('img', {})
tile_aug_train, tile_aug_val, tile_aug_test = train_utils.get_augmentors(
tile_aug_params)
img_aug_train, img_aug_val, img_aug_test = train_utils.get_augmentors(
img_aug_params)
eval_batch_size = batch_size if eval_batch_size is None else eval_batch_size
df_train = df_panda.loc[(df_panda['fold'] != fold)
& (df_panda['fold'] != 'test')].reset_index(
drop=True)
df_val = df_panda.loc[df_panda['fold'] == fold].reset_index(drop=True)
if os.path.exists(os.path.join(fold_dir, 'val_predictions.csv')):
df_val_pred = pd.read_csv(os.path.join(fold_dir,
'val_predictions.csv'))
df_val = pd.merge(df_val,
df_val_pred[['image_id', 'prediction']],
how='left',
on='image_id')
df_test = df_panda.loc[df_panda['fold'] == 'test'].reset_index(drop=True)
if os.path.exists(os.path.join(fold_dir, 'test_predictions.csv')):
df_test_pred = pd.read_csv(
os.path.join(fold_dir, 'test_predictions.csv'))
df_test = pd.merge(df_test,
df_test_pred[['image_id', 'prediction']],
how='left',
on='image_id')
if verbose:
df_sub_val = df_val.loc[df_val['prediction'].notnull()].reset_index(
drop=True)
df_sub_test = df_test.loc[df_test['prediction'].notnull()].reset_index(
drop=True)
print('-' * 80)
print(ckpt_dir)
print(
f"\nVal QWK : {compute_qwk(df_sub_val['isup_grade'], df_sub_val['prediction']):.4f}\n"
)
print(compute_provider_scores(df_sub_val))
print(
f"\nTest QWK : {compute_qwk(df_sub_test['isup_grade'], df_sub_test['prediction']):.4f}\n"
)
print(compute_provider_scores(df_sub_test))
print('-' * 80, '\n')
train_ds = PandaDataset(image_dir,
df_train,
tile_augmentor=tile_aug_train,
img_augmentor=img_aug_train,
**config['data'])
val_ds = PandaDataset(image_dir,
df_val,
tile_augmentor=tile_aug_val,
img_augmentor=img_aug_val,
**config['data'])
test_ds = PandaDataset(image_dir,
df_test,
tile_augmentor=tile_aug_test,
img_augmentor=img_aug_test,
**config['data'])
train_sampler = train_utils.get_sampler(train_ds,
distributed=distributed,
batch_size=batch_size * num_gpus,
random_state=random_state,
method=config['sampler']['method'],
params=config['sampler'].get(
'params', {}))
val_sampler = train_utils.get_sampler(val_ds,
method='sequential',
distributed=distributed)
test_sampler = train_utils.get_sampler(test_ds,
method='sequential',
distributed=distributed)
train_dl = DataLoader(train_ds,
batch_size=eval_batch_size,
num_workers=num_workers,
sampler=train_sampler,
drop_last=True)
val_dl = DataLoader(val_ds,
batch_size=eval_batch_size,
sampler=val_sampler,
num_workers=num_workers)
test_dl = DataLoader(test_ds,
batch_size=eval_batch_size,
sampler=test_sampler,
num_workers=num_workers)
model = model_utils.load_model(fold_dir, step=step)
return model, train_dl, val_dl, test_dl
def __init__(self, model_path):
self.model = model_utils.load_model(model_path, UNet)
def infer(config, test_bleu=True):
work_space = config["workspace"]
name = config["Name"]
# Construct or load embeddings
print("Initializing embeddings ...")
vocab_size = config["embeddings"]["vocab_size"]
embed_size = config["embeddings"]["embed_size"]
vocab_file = config["inference"]["vocab_file"]
# Build the model
(
encode_num_layers,
encode_num_units,
encode_cell_type,
encode_bidir,
attn_num_units,
decode_num_layers,
decode_num_units,
decode_cell_type,
use_user_feat,
use_gate_memory,
use_user_desc,
use_blog_user_coattn,
use_external_desc_express,
use_external_feat_express,
user_feat_dim,
user_feat_unit,
user_feat_mem_unit,
desc_rnn_unit,
desc_attn_num_units,
user_map_unit,
) = get_pcgn_model_config(config)
(infer_file, batch_size, is_beam_search, beam_size,
infer_source_max_length, infer_target_max_length, infer_desc_max_length,
infer_max_iter, output_path, gpu_fraction,
gpu_id) = get_pcgn_infer_config(config)
print("Building model architecture ...")
pcg_model = PCGNModel(
mode='infer',
model_name=name,
vocab_size=vocab_size,
embedding_size=embed_size,
encode_num_layers=encode_num_layers,
encode_num_units=encode_num_units,
encode_cell_type=encode_cell_type,
encode_bidir=encode_bidir,
attn_num_units=attn_num_units,
decode_num_layers=decode_num_layers,
decode_num_units=decode_num_units,
decode_cell_type=decode_cell_type,
use_user_feat=use_user_feat,
use_gate_memory=use_gate_memory,
use_user_desc=use_user_desc,
use_blog_user_coattn=use_blog_user_coattn,
use_external_desc_express=use_external_desc_express,
use_external_feat_express=use_external_feat_express,
user_feat_dim=user_feat_dim,
user_feat_unit=user_feat_unit,
user_feat_mem_unit=user_feat_mem_unit,
desc_rnn_unit=desc_rnn_unit,
desc_attn_num_units=desc_attn_num_units,
user_map_unit=user_map_unit,
batch_size=batch_size,
beam_search=is_beam_search,
beam_size=beam_size,
infer_max_iter=infer_max_iter,
target_max_length=infer_target_max_length,
)
print("\tDone.")
logdir = '%s/nn_models/' % work_space
# Set up session
gpu_fraction = config["training"]["gpu_fraction"]
gpu_id = config["training"]["gpu_id"]
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpu_fraction,
visible_device_list=gpu_id,
allow_growth=True)
sess = tf.Session(config=tf.ConfigProto(log_device_placement=False,
gpu_options=gpu_options))
init = tf.global_variables_initializer()
sess.run(init)
try:
saved_global_step = load_model(pcg_model.saver, sess, logdir)
if saved_global_step is None:
raise ValueError("Cannot find the checkpoint to restore from.")
except Exception:
print("Something went wrong while restoring checkpoint. ")
raise
# ##### Inference #####
# Load data
print("Loading inference data ...")
# Load vocabularies.
vocab_table, reverse_vocab_table = create_vocab_tables(vocab_file)
infer_dataset = read_data(infer_file)
print(' # infer data:', len(infer_dataset))
print("\tDone.")
# Inference
print("Start inferring ...")
final_result = pd.DataFrame()
infer_step = int(len(infer_dataset) / batch_size)
preds = []
for ith in range(infer_step):
print('step:', ith)
start = ith * batch_size
end = (ith + 1) * batch_size
batch = get_pcgn_batch(infer_dataset[start:end], 'infer', -1,
infer_source_max_length,
infer_target_max_length, infer_desc_max_length)
result = pcg_model.infer(sess, batch)
result1 = batch_token_to_str(result[:, 0, :], reverse_vocab_table)
#result2 = batch_token_to_str(result[:, 1,:], reverse_vocab_table)
#result3 = batch_token_to_str(result[:, 2,:], reverse_vocab_table)
#result4 = batch_token_to_str(result[:, 3,:], reverse_vocab_table)
#result5 = batch_token_to_str(result[:, 4,:], reverse_vocab_table)
preds += list(result1)
if test_bleu:
blog = batch_token_to_str(batch[0], reverse_vocab_table)
cmt = batch_token_to_str(batch[2], reverse_vocab_table)
desc = batch_token_to_str(batch[6], reverse_vocab_table)
feat_df = featinds2df(batch[8])
df_result = pd.DataFrame({
'Blog': blog,
'Comment': cmt,
'Individual_Description': desc,
'Prediction': result1,
})
df_result = pd.concat([df_result, feat_df], axis=1)
final_result = pd.concat([final_result, df_result])
out_path = config["inference"]["output_path"] + 'prediction' + '.txt'
with open(out_path, 'w') as f:
f.write('\n'.join(preds))
if test_bleu:
bleu2 = calc_bleu2(final_result['Prediction'].values,
final_result['Comment'].values)
print('test bleu:', bleu2)
bleurecord = 'test_size:{}\trestore_step:{}\n'.format(
str(int(infer_step * batch_size)), str(saved_global_step))
bleurecord += 'bleu2:{}\n\n'.format(str(bleu2[0]))
with open(logdir + 'bleu.txt', 'a') as f:
f.write(bleurecord)
out_path = config["inference"]["output_path"] + 'prediction' + '.csv'
final_result.to_csv(out_path, index=False)
print("\tDone.")
