'Backbone pretrained model, could be resnet50, resnet101 or resnet152')
options, args = parser.parse_args()
mode = options.mode
backbone = options.backbone
if backbone not in ['resnet50', 'resnet101', 'resnet152']:
assert ValueError('Invalid backbone: %s' % backbone)
net = load_model(backbone)
if mode == 'valid':
datadir = cfg.root
batch_size = 2
anno_file = os.path.join(datadir, 'annotation.json')
target_dir = 'valid_target.json'
predict_dir = backbone + '_predict.json'
val_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(cfg.mean, cfg.std)])
valset = VocLikeDataset(image_dir=cfg.val_image_dir,
annotation_file=cfg.annotation_file,
imageset_fn=cfg.val_imageset_fn,
image_ext=cfg.image_ext,
classes=cfg.classes,
encoder=DataEncoder(),
transform=val_transform)
valloader = torch.utils.data.DataLoader(valset,
batch_size=batch_size,
shuffle=False,
num_workers=cfg.num_workers,
collate_fn=valset.collate_fn)
eval_valid(net, valloader, anno_file, cfg.test_dir)
filedir = os.path.join(datadir, target_dir)
def prediction(img1, img2, label, weight):
print("weight")
best_metric = 0
train_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
val_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
test_transform_det = trans.Compose([
trans.Scale((960, 960)),
])
model = SiamUNetU(in_ch=3)
model = torch.nn.DataParallel(model)
if torch.cuda.is_available():
model.cuda()
# model.load_state_dict({k.replace('module.', ''): v for k, v in torch.load(weight).items()})
# model.load_state_dict(torch.load(weight))
checkpoint = torch.load(weight)
model.load_state_dict(checkpoint['state_dict'])
# test_data = my_dataset.Dataset(cfg.TEST_DATA_PATH, '',cfg.TEST_TXT_PATH, 'test', transform=True, transform_med=test_transform_det)
test_data = my_dataset.Dataset(cfg.VAL_DATA_PATH,
cfg.VAL_LABEL_PATH,
cfg.VAL_TXT_PATH,
'val',
transform=True,
transform_med=test_transform_det)
test_dataloader = DataLoader(test_data,
batch_size=cfg.TEST_BATCH_SIZE,
shuffle=False,
num_workers=8,
pin_memory=True)
crop = 0
rows = 12
cols = 12
i = 0
for batch_idx, val_batch in enumerate(test_dataloader):
model.eval()
batch_x1, batch_x2, _, filename, h, w = val_batch
filename = filename[0].split('/')[-1].replace('image',
'mask_2017').replace(
'.png', '.tif')
if crop:
outputs = np.zeros((cfg.TEST_BATCH_SIZE, 1, 960, 960))
while (i + w // rows <= w):
j = 0
while (j + h // cols <= h):
batch_x1_ij = batch_x1[batch_idx, :, i:i + w // rows,
j:j + h // cols]
batch_x2_ij = batch_x2[batch_idx, :, i:i + w // rows,
j:j + h // cols]
# batch_y_ij = batch_y[batch_idx,: , i:i + w // rows, j:j + h // cols]
batch_x1_ij = np.expand_dims(batch_x1_ij, axis=0)
batch_x2_ij = np.expand_dims(batch_x2_ij, axis=0)
batch_x1_ij, batch_x2_ij = Variable(
torch.from_numpy(batch_x1_ij)).cuda(), Variable(
torch.from_numpy(batch_x2_ij)).cuda()
with torch.no_grad():
output = model(batch_x1_ij, batch_x2_ij)
output_w, output_h = output.shape[-2:]
output = torch.sigmoid(output).view(output_w, output_h, -1)
output = output.data.cpu().numpy() # .resize([80, 80, 1])
output = np.where(output > cfg.THRESH, 255, 0)
outputs[batch_idx, :, i:i + w // rows,
j:j + h // cols] = output
j += h // cols
i += w // rows
print(batch_idx)
if not os.path.exists('./change'):
os.mkdir('./change')
print('./change/{}'.format(filename))
cv2.imwrite('./change/crop_{}'.format(filename), outputs[batch_idx,
0, :, :])
else:
batch_x1, batch_x2 = Variable(batch_x1).cuda(), Variable(
batch_x2).cuda()
with torch.no_grad():
output = model(batch_x1, batch_x2)
output_w, output_h = output.shape[-2:]
output = torch.sigmoid(output).view(output_w, output_h, -1)
output = output.data.cpu().numpy() # .resize([80, 80, 1])
output = np.where(output > cfg.THRESH, 255, 0)
# output_final=cv2.merge(output)
if not os.path.exists('./change'):
os.mkdir('./change')
print('./change/{}'.format(filename))
cv2.imwrite('./change/{}'.format(filename), output)
def prediction(weight):
print("weight")
best_metric = 0
train_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
val_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
test_transform_det = trans.Compose([
trans.Scale(cfg.TEST_TRANSFROM_SCALES),
])
model = SiamUNet()
# model=torch.nn.DataParallel(model)
if torch.cuda.is_available():
model.cuda()
print('gpu')
# model.load_state_dict({k.replace('module.', ''): v for k, v in torch.load(weight).items()})
# model.load_state_dict(torch.load(weight))
checkpoint = torch.load(weight)
model.load_state_dict(checkpoint['state_dict'])
test_data = my_dataset.Dataset(cfg.TEST_DATA_PATH,
cfg.TEST_LABEL_PATH,
cfg.TEST_TXT_PATH,
'val',
transform=True,
transform_med=test_transform_det)
test_dataloader = DataLoader(test_data,
batch_size=cfg.TEST_BATCH_SIZE,
shuffle=False,
num_workers=8,
pin_memory=True)
crop = 0
rows = 12
cols = 12
i = 0
for batch_idx, val_batch in enumerate(test_dataloader):
model.eval()
batch_x1, batch_x2, mask, im_name, h, w = val_batch
print('mask_type{}'.format(mask.type))
with torch.no_grad():
batch_x1, batch_x2 = Variable((batch_x1)).cuda(), Variable(
((batch_x2))).cuda()
try:
print('try')
output = model(batch_x1, batch_x2)
del batch_x1, batch_x2
except RuntimeError as exception:
if 'out of memory' in str(exception):
print('WARNING: out of memory')
if hasattr(torch.cuda, 'empty_cache'):
torch.cuda.empty_cache()
else:
print('exception')
raise exception
# print(output)
output_w, output_h = output.shape[-2:]
output = torch.sigmoid(output).view(output_w, output_h, -1)
# print(output)
output = output.data.cpu().numpy() # .resize([80, 80, 1])
output = np.where(output > cfg.THRESH, 255, 0)
# print(output)
# have no mask so can not eval_cal
# precision,recall,F1=eval_cal(output,mask)
# print('precision:{}\nrecall:{}\nF1:{}'.format(precision,recall,F1))
print(im_name)
im_n = im_name[0].split('/')[1].split('.')[0].split('_')
im__path = 'final_result/weight50_dmc/mask_2017_2018_960_960_' + im_n[
4] + '.tif'
# im__path = 'weitht50_tif.tif'
im_data = np.squeeze(output)
print(im_data.shape)
im_data = np.array([im_data])
print(im_data.shape)
im_geotrans = (0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
im_proj = ''
im_width = 960
im_height = 960
im_bands = 1
datatype = gdal.GDT_Byte
driver = gdal.GetDriverByName("GTiff")
dataset = driver.Create(im__path, im_width, im_height, im_bands,
datatype)
if dataset != None:
print("----{}".format(im__path))
dataset.SetGeoTransform(im_geotrans)
dataset.SetProjection(im_proj)
for i in range(im_bands):
dataset.GetRasterBand(i + 1).WriteArray(im_data[i])
del dataset
def main():
best_metric = 0
train_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
val_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
train_data = my_dataset.Dataset(cfg.TRAIN_DATA_PATH,
cfg.TRAIN_LABEL_PATH,
cfg.TRAIN_TXT_PATH,
'train',
transform=True,
transform_med=train_transform_det)
val_data = my_dataset.Dataset(cfg.VAL_DATA_PATH,
cfg.VAL_LABEL_PATH,
cfg.VAL_TXT_PATH,
'val',
transform=True,
transform_med=val_transform_det)
train_dataloader = DataLoader(train_data,
batch_size=cfg.BATCH_SIZE,
shuffle=True,
num_workers=1,
pin_memory=True)
val_dataloader = DataLoader(val_data,
batch_size=cfg.BATCH_SIZE,
shuffle=False,
num_workers=1,
pin_memory=True)
model = DeepLabV3(model_id=1, project_dir=cfg.BASE_PATH)
if cfg.RESUME:
checkpoint = torch.load(cfg.TRAINED_LAST_MODEL)
model.load_state_dict(checkpoint['state_dict'])
print('resume success \n')
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
# dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs
model = nn.DataParallel(model)
if torch.cuda.is_available():
model.cuda()
# if torch.cuda.is_available():
# model.cuda()
# params = [{'params': md.parameters()} for md in model.children() if md in [model.classifier]]
optimizer = optim.Adam(model.parameters(),
lr=cfg.INIT_LEARNING_RATE,
weight_decay=cfg.DECAY)
scheduler = ReduceLROnPlateau(optimizer,
mode='min',
factor=0.2,
patience=5,
verbose=True,
threshold=0.0001,
threshold_mode='rel',
cooldown=2,
eps=1e-08)
fl = FocalLoss2d(gamma=cfg.FOCAL_LOSS_GAMMA)
Loss_list = []
Accuracy_list = []
for epoch in range(cfg.EPOCH):
print('epoch {}'.format(epoch + 1))
#training--------------------------
train_loss = 0
train_acc = 0
for batch_idx, train_batch in enumerate(train_dataloader):
model.train()
batch_det_img, batch_y, _, _, _, _, _ = train_batch
batch_det_img, batch_y = Variable(batch_det_img).cuda(), Variable(
batch_y).cuda()
output = model(batch_det_img)
del batch_det_img
loss = calc_loss(output, batch_y)
# train_loss += loss.data[0]
#should change after
# pred = torch.max(out, 1)[0]
# train_correct = (pred == batch_y).sum()
# train_acc += train_correct.data[0]
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (batch_idx) % 5 == 0:
model.eval()
val_loss = 0
for v_batch_idx, val_batch in enumerate(val_dataloader):
v_batch_det_img, v_batch_y, _, _, _, _, _ = val_batch
v_batch_det_img, v_batch_y = Variable(
v_batch_det_img).cuda(), Variable(v_batch_y).cuda()
val_out = model(v_batch_det_img)
del v_batch_det_img
val_loss += float(calc_loss(val_out, v_batch_y))
scheduler.step(val_loss)
del val_out, v_batch_y
print("Train Loss: {:.6f} Val Loss: {:.10f}".format(
loss, val_loss))
if (epoch + 1) % 10 == 0:
torch.save({'state_dict': model.state_dict()},
os.path.join(
cfg.SAVE_MODEL_PATH, cfg.TRAIN_LOSS,
'model_tif_deeplab18_bce_240*240_' +
str(epoch + 1) + '.pth'))
torch.save({'state_dict': model.state_dict()},
os.path.join(cfg.SAVE_MODEL_PATH, cfg.TRAIN_LOSS,
'model_tif_deeplab18_bce_240*240_last.pth'))
def main():
best_metric = 0
train_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
val_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
train_data = my_dataset.Dataset(cfg.TRAIN_DATA_PATH,
cfg.TRAIN_LABEL_PATH,
cfg.TRAIN_TXT_PATH,
'train',
transform=True,
transform_med=train_transform_det)
val_data = my_dataset.Dataset(cfg.VAL_DATA_PATH,
cfg.VAL_LABEL_PATH,
cfg.VAL_TXT_PATH,
'val',
transform=True,
transform_med=val_transform_det)
train_dataloader = DataLoader(train_data,
batch_size=cfg.BATCH_SIZE,
shuffle=True,
num_workers=8,
pin_memory=True)
val_dataloader = DataLoader(val_data,
batch_size=cfg.BATCH_SIZE,
shuffle=False,
num_workers=8,
pin_memory=True)
model = SiamUNet(in_ch=3)
if cfg.RESUME:
checkpoint = torch.load(cfg.TRAINED_LAST_MODEL)
model.load_state_dict(checkpoint['state_dict'])
print('resume success \n')
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
# dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs
model = nn.DataParallel(model)
if torch.cuda.is_available():
model.cuda()
# if torch.cuda.is_available():
# model.cuda()
# params = [{'params': md.parameters()} for md in model.children() if md in [model.classifier]]
optimizer = optim.Adam(model.parameters(),
lr=cfg.INIT_LEARNING_RATE,
weight_decay=cfg.DECAY)
fl = FocalLoss2d(gamma=cfg.FOCAL_LOSS_GAMMA)
Loss_list = []
Accuracy_list = []
scheduler = StepLR(optimizer, step_size=8, gamma=0.1)
for epoch in range(cfg.EPOCH):
scheduler.step()
print('epoch {}'.format(epoch + 1))
#training--------------------------
train_loss = 0
train_acc = 0
for batch_idx, train_batch in enumerate(train_dataloader):
model.train()
batch_x1, batch_x2, batch_y, _, _, _ = train_batch
batch_x1, batch_x2, batch_y = Variable(batch_x1).cuda(), Variable(
batch_x2).cuda(), Variable(batch_y).cuda()
outputs = model(batch_x1, batch_x2)
del batch_x1, batch_x2
loss = calc_loss_L4(outputs[0], outputs[1], outputs[2], outputs[3],
batch_y)
# train_loss += loss.data[0]
#should change after
# pred = torch.max(out, 1)[0]
# train_correct = (pred == batch_y).sum()
# train_acc += train_correct.data[0]
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (batch_idx) % 5 == 0:
model.eval()
val_loss = 0
for v_batch_idx, val_batch in enumerate(val_dataloader):
v_batch_x1, v_batch_x2, v_batch_y, _, _, _ = val_batch
v_batch_x1, v_batch_x2, v_batch_y = Variable(
v_batch_x1).cuda(), Variable(
v_batch_x2).cuda(), Variable(v_batch_y).cuda()
val_outs = model(v_batch_x1, v_batch_x2)
del v_batch_x1, v_batch_x2
val_loss += float(
calc_loss_L4(val_outs[0], val_outs[1], val_outs[2],
val_outs[3], v_batch_y))
del val_outs, v_batch_y
print("Train Loss: {:.6f} Val Loss: {:.10f}".format(
loss, val_loss))
if (epoch + 1) % 5 == 0:
torch.save({'state_dict': model.state_dict()},
os.path.join(cfg.SAVE_MODEL_PATH, cfg.TRAIN_LOSS,
'model_tif_' + str(epoch + 1) + '.pth'))
torch.save({'state_dict': model.state_dict()},
os.path.join(cfg.SAVE_MODEL_PATH, cfg.TRAIN_LOSS,
'model_tif_last.pth'))
def prediction( weight):
best_metric = 0
train_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
val_transform_det = trans.Compose([
trans.Scale(cfg.TRANSFROM_SCALES),
])
test_transform_det = trans.Compose([
trans.Scale((960,960)),
])
model = DeepLabV3(model_id=1,project_dir=cfg.BASE_PATH)
# model=torch.nn.DataParallel(model)
if torch.cuda.is_available():
model.cuda()
# model.load_state_dict({k.replace('module.', ''): v for k, v in torch.load(weight).items()})
# model.load_state_dict(torch.load(weight))
checkpoint = torch.load(weight)
model.load_state_dict(checkpoint['state_dict'])
# test_data = my_dataset.Dataset(cfg.TEST_DATA_PATH, '',cfg.TEST_TXT_PATH, 'test', transform=True, transform_med=test_transform_det)
test_data = my_dataset.Dataset(cfg.VAL_DATA_PATH, cfg.VAL_LABEL_PATH,cfg.VAL_TXT_PATH, 'val', transform=True, transform_med=test_transform_det)
# test_data = my_dataset.Dataset(cfg.TRAIN_DATA_PATH, cfg.TRAIN_LABEL_PATH,cfg.TRAIN_TXT_PATH, 'train', transform=True, transform_med=test_transform_det)
test_dataloader = DataLoader(test_data, batch_size=cfg.TEST_BATCH_SIZE, shuffle=False, num_workers=8, pin_memory=True)
crop = 0
for batch_idx, val_batch in enumerate(test_dataloader):
model.eval()
#
# batch_x1, batch_x2, _, filename, h, w, green_mask1, green_mask2 = val_batch
batch_det_img, _, filename, h, w,_,green_mask2 = val_batch
# green_mask1 = green_mask1.view(output_w, output_h, -1).data.cpu().numpy()
filename = filename[0].split('/')[-1].replace('image','mask_2017')
if crop:
pass
# outputs = np.zeros((cfg.TEST_BATCH_SIZE,1,960, 960))
#
# while (i + w // rows <= w):
# j = 0
# while (j + h // cols <= h):
# batch_x1_ij = batch_x1[0, :, i:i + w // rows, j:j + h // cols]
# batch_x2_ij = batch_x2[0, :, i:i + w // rows, j:j + h // cols]
# # batch_y_ij = batch_y[batch_idx,: , i:i + w // rows, j:j + h // cols]
# batch_x1_ij = np.expand_dims(batch_x1_ij, axis=0)
# batch_x2_ij = np.expand_dims(batch_x2_ij, axis=0)
# batch_x1_ij, batch_x2_ij = Variable(torch.from_numpy(batch_x1_ij)).cuda(), Variable(
# torch.from_numpy(batch_x2_ij)).cuda()
# with torch.no_grad():
# output = model(batch_x1_ij, batch_x2_ij)
# output_w, output_h = output.shape[-2:]
# output = torch.sigmoid(output).view(-1, output_w, output_h)
#
# output = output.data.cpu().numpy() # .resize([80, 80, 1])
# output = np.where(output > cfg.THRESH, 255, 0)
# outputs[0, :, i:i + w // rows, j:j + h // cols] = output
#
# j += h // cols
# i += w // rows
#
#
# if not os.path.exists('./change'):
# os.mkdir('./change')
# print('./change/{}'.format(filename))
# cv2.imwrite('./change/crop_{}'.format(filename), outputs[0,0,:,:])
else:
batch_det_img = Variable(batch_det_img).cuda()
with torch.no_grad():
outputs = model(batch_det_img)
output_w, output_h = outputs[0].shape[-2:]
# green_mask2 = green_mask2.view(output_w, output_h, -1).data.cpu().numpy()
output = torch.sigmoid(outputs).view(output_w, output_h, -1).data.cpu().numpy()
# print(output.min(),output.max())
output = np.where((output > cfg.THRESH) , 255, 0)
if not os.path.exists('./change'):
os.mkdir('./change')
print('./change/{}'.format(filename))
cv2.imwrite('./change/{}'.format(filename), output)
def __init__(self, encoder, transform=None, test=False, val=False):
# self.class_map = {c: i for i, c in enumerate(['2.1', '2.4', '3.1', '3.24', '3.27', '4.1', '4.2', '5.19', '5.20', '8.22'], 1)}
# self.class_map = defaultdict(lambda: 0, self.class_map)
# self.categories = {v:k for k, v in self.class_map.items
self.labels_paths = glob(os.path.join(DIR, '**/annotations/**/*.tsv'), recursive=True)
self.labels_paths = [x for x in self.labels_paths if x.split('/')[5] in ('RTSD', 'ice')]
# print(self.labels_paths)
if val:
self.labels_paths = [x for x in self.labels_paths if x.split('/')[-2] in test_folders]
else:
self.labels_paths = [x for x in self.labels_paths if x.split('/')[-2] not in test_folders]
print(len(self.labels_paths))
self.tasks = []
with open(os.path.join(DIR, 'classes_map.pkl'), 'rb') as f:
self.label_map = pickle.load(f)
print(self.label_map)
self.val = val
paths = []
self.test = test
self.encoder = encoder
self.task_dict = {}
self.transform = transform
np.random.shuffle(self.labels_paths)
print("FINDING TABLES")
from time import time
from functools import partial
tik = time()
# for path in tqdm(self.labels_paths[:3000]):
# update_task(tasks=self.task_dict, path=path)
fname = 'train.tasks' if not val else 'val.tasks'
if not os.path.exists(fname):
Parallel(n_jobs=8, require='sharedmem')(delayed(partial(update_task, tasks=self.task_dict, label_map=self.label_map))(path) for path in tqdm(self.labels_paths[:]))
with open(fname, 'wb') as f:
pickle.dump(self.task_dict, f)
else:
print('FOUND CACHE', fname)
with open(fname, 'rb') as f:
self.task_dict = pickle.load(f)
tok = time()
print('elapsed {:.1f}'.format((tok-tik)/60), 'minutes')
#for path in tqdm(self.labels_paths):
#print(val, path.split('/')[-2])
# pass
self.tasks = list(self.task_dict.keys())
# width_count = 0
# height_count = 0
# total_count = 0
# for t, d in self.task_dict.items():
# for b in d['boxes']:
# if (b.right - b.left) >= 512:
# width_count += 1
# if (b.bottom-b.top) >= 512:
# height_count+=1
# total_count += 1
# print('\n\n\n')
# print(width_count / total_count)
# print(height_count / total_count)
# print('\n\n\n')
self.pil_transform = transforms.Compose([
transforms.ResizeKeepAR(cfg.width, cfg.height),
transforms.RandomCrop(cfg.width, cfg.height, 5, 100, 0.3),
])
print("FOUND", len(self.tasks), " TABLES FOR {}".format("TRAIN" if not val else "TEST"))
import sys
sys.stdout.flush()