def register():
user_id = str(uuid.uuid4())
liked_chains = split_ids(request.form.get('liked_chains'))
disliked_chains = split_ids(request.form.get('disliked_chains'))
users_db[user_id] = {'liked_chains': liked_chains,
'disliked_chains': disliked_chains}
return jsonify({'user_id': user_id})
def recommend():
user_id = request.args['user_id']
user_location = LatLong.from_dict(request.args)
query_tags = split_ids(request.args.get('tags'))
cur_user = users_db[user_id]
predictions = get_predictions_for(cur_user)
available_places = []
for place in places_db:
chain_id = place['chain_id']
if (chain_id in cur_user['liked_chains'] or
chain_id in cur_user['disliked_chains']):
continue
# If there is no reviews for this chain
if chain_id not in predictions:
continue
place_location = LatLong.from_dict(place['geometry']['location'])
if lat_long_dist_in_km(user_location, place_location) > MAX_DIST_IN_KM:
continue
place = place.copy()
place['tags'] = get_tags(place)
place['prediction'] = predictions[chain_id]
available_places.append(place)
print("available", [place["chain_id"] for place in available_places])
print("user", cur_user)
if not available_places:
return jsonify({'error': 'No such places'})
for index in range(0, len(available_places), HERE_API_BATCH_SIZE):
places_batch = available_places[index:index + HERE_API_BATCH_SIZE]
calc_travel_time(user_location, places_batch)
best_place = min(available_places,
key=lambda item: get_sort_key(item, query_tags))
users_db[user_id]["liked_chains"].append(best_place["chain_id"]) # hack for different places on each call
photos = best_place.get("photos", [])
if len(photos) == 0:
photo_url = None
else:
photo_url = GOOGLE_PHOTO_URL.format(reference=photos[0]["photo_reference"])
return jsonify({
'name': best_place['name'],
'chain_id': best_place['chain_id'],
'lat': best_place['geometry']['location']['lat'],
'lng': best_place['geometry']['location']['lng'],
'travel_time_mins': best_place['travel_time'] / SECONDS_PER_MIN,
'photo_url': photo_url,
})
def create_train_test_directory(split_size, total_samples):
"""
For tomorrows' Charles - you need to do some reworking
as you need to have a way to create a suitable method for
seperating train and test files. Make pairs right now
does not store identity info and returns a cached result.
We may need to bundle two files into the cache train and test.
"""
identity_df = get_identities()
unique_ids = get_unique_ids(identity_df)
train_ids, test_ids = split_ids(unique_ids, split_size)
print(len(train_ids), len(test_ids))
print(identity_df[identity_df.identity_num == 2880])
def main():
print('settings: ', args)
setup()
rnd_state = np.random.RandomState(args.seed)
print("Loading data ... ... ...")
dataset = TUDataset('./data/%s/' % args.dataset,
name=args.dataset,
use_node_attr=args.use_cont_node_attr)
train_ids, test_ids = split_ids(rnd_state.permutation(len(dataset)),
folds=args.n_folds)
print("Data loaded !!!")
acc_folds = []
for fold_id in range(args.n_folds):
loaders = []
for split in ['train', 'test']:
gdata = dataset[torch.from_numpy(
(train_ids
if split.find('train') >= 0 else test_ids)[fold_id])]
loader = DataLoader(gdata,
batch_size=args.batch_size,
shuffle=split.find('train') >= 0,
num_workers=args.threads,
collate_fn=collate_batch)
loaders.append(loader)
print('\nFOLD {}, train {}, test {}'.format(fold_id,
len(loaders[0].dataset),
len(loaders[1].dataset)))
model = GCN(in_features=loaders[0].dataset.num_features,
out_features=loaders[0].dataset.num_classes,
n_hidden=args.n_hidden,
filters=args.filters,
dropout=args.dropout).to(args.device)
print('\nInitialize model')
print(model)
train_params = list(
filter(lambda p: p.requires_grad, model.parameters()))
print('N trainable parameters:',
np.sum([p.numel() for p in train_params]))
optimizer = optim.Adam(train_params,
lr=args.lr,
weight_decay=args.wd,
betas=(0.5, 0.999))
scheduler = lr_scheduler.MultiStepLR(optimizer,
args.lr_decay_steps,
gamma=0.1)
for epoch in range(args.epochs):
train(loaders[0],
model=model,
epoch=epoch,
optimizer=optimizer,
scheduler=scheduler)
acc = test(loaders[1], model=model, epoch=epoch)
acc_folds.append(acc)
print(acc_folds)
print('{}-fold cross validation avg acc (+- std): {} ({})'.format(
args.n_folds, np.mean(acc_folds), np.std(acc_folds)))
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5):
dir_img = 'data/train/' # 训练图像文件夹
dir_mask = 'data/train_masks/' # 图像的结果文件夹
dir_checkpoint = 'checkpoints/' # 训练好的网络保存文件夹
ids = get_ids(dir_img) # 图片名字的后4位为数字，能作为图片id
# 得到元祖列表为[(id1,0),(id1,1),(id2,0),(id2,1),...,(idn,0),(idn,1)]
# 这样的作用是后面重新设置生成器时会通过后面的0,1作为utils.py中get_square函数的pos参数，pos=0的取左边的部分，pos=1的取右边的部分
# 这样图片的数量就会变成2倍
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent) # 将数据分为训练集和验证集两份
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train']) # 训练集长度
optimizer = optim.SGD(
net.parameters(), # 定义优化器
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss() # 损失函数
for epoch in range(epochs): # 开始训练
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train() # 设置为训练模式
# reset the generators重新设置生成器
# 对输入图片dir_img和结果图片dir_mask进行相同的图片处理，即缩小、裁剪、转置、归一化后，将两个结合在一起，返回(imgs_normalized, masks)
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32) # 得到输入图像数据
true_masks = np.array([i[1] for i in b]) # 得到图像结果数据
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs) # 图像输入的网络后得到结果masks_pred，结果为灰度图像
masks_probs_flat = masks_pred.view(-1) # 将结果压扁
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat) # 对两个结果计算损失
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss /
i)) # 一次迭代后得到的平均损失
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5):
# dir_img = 'data/train/'
# dir_mask = 'data/train_masks/'
dir_img = 'E:/git/dataset/tgs-salt-identification-challenge/train/images/'
dir_mask = 'E:/git/dataset/tgs-salt-identification-challenge/train/masks/'
# dir_img = 'E:/git/dataset/tgs-salt-identification-challenge/train/my_images/'
# dir_mask = 'E:/git/dataset/tgs-salt-identification-challenge/train/my_masks/'
dir_checkpoint = 'checkpoints/'
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
# true_masks = np.array([i[1] for i in b])#np.rot90(m)
true_masks = np.array([i[1].T / 65535 for i in b]) #np.rot90(m)
# show_batch_image(true_masks)
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
# show_batch_image(imgs)
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(
net,
epochs=5,
batch_size=1,
lr=0.1,
#val_percent=0.1,
save_cp=True,
gpu=False,
img_scale=0.5):
img_train = '/home/lixiaoxing/github/Pytorch-UNet/data/DRIVE/AV_groundTruth/training/images_jpg/'
mask_train = '/home/lixiaoxing/github/Pytorch-UNet/data/DRIVE/AV_groundTruth/training/vessel/'
img_val = '/home/lixiaoxing/github/Pytorch-UNet/data/DRIVE/AV_groundTruth/training/val_jpg/'
mask_val = '/home/lixiaoxing/github/Pytorch-UNet/data/DRIVE/AV_groundTruth/training/val_vessel/'
dir_checkpoint = 'checkpoints_drive3_adam/'
if os.path.exists(dir_checkpoint) is False:
os.makedirs(dir_checkpoint)
ids_train = get_ids(img_train)
data_train = split_ids(ids_train)
data_train = list(data_train)
ids_val = get_ids(img_val)
data_val = split_ids(ids_val)
data_val = list(data_val)
#iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(data_train), len(data_val),
str(save_cp), str(gpu)))
N_train = len(data_train)
#optimizer = optim.SGD(net.parameters(),
# lr=lr,
# momentum=0.9,
# weight_decay=0.0005)
optimizer = optim.Adam(net.parameters(), lr=lr, weight_decay=1e-5)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.1,
mode='min',
patience=3,
verbose=True)
#scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1)
criterion = nn.BCELoss()
#criterion = DiceCoeff()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks_y(data_train, img_train, mask_train,
img_scale)
val = get_imgs_and_masks_y(data_val, img_val, mask_val, img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
#print(masks_pred.shape, true_masks.shape)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
#print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train, loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
scheduler.step(val_dice)
def train_net(args,
net,
epochs,
batch_size=1,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5):
global best_dice, best_loss
dir_img = '/home/mori/Programming/Net_Pruning/unetdataset_patchImg/img/'
dir_mask = '/home/mori/Programming/Net_Pruning/unetdataset_patchImg/graylabel/'
ids = get_ids(dir_img) # get file name (without .png)
print("ids:{}".format(ids))
ids = split_ids(ids) # 重采样？
print("ids:{}".format(ids))
iddataset = split_train_val(ids, val_percent) # 按给定比例划分打乱的数据集
###### count parameters ############
paras = sum([p.data.nelement() for p in net.parameters()])
print('''
Starting training:
Epochs: {}
Parameters: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
Deepsupervision: {}
'''.format(epochs, paras, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu),
str(args.deepsupervision)))
N_train = len(iddataset['train'])
print("N_train:{}".format(N_train))
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
New_lr = adjust_learning_rate(optimizer, epoch, epochs)
print(' lr: {}'.format(New_lr))
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
best_iou = 0
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)): # 手动分出batch
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
true_masks_flat = true_masks.view(-1)
true_masks_flat = true_masks_flat / 255 # 归一化
output = net(imgs)
masks_pred = F.sigmoid(output)
if args.deepsupervision:
#### unet++ with deepsupervision
loss = 0
for mp in masks_pred:
masks_probs_flat = mp.view(-1)
loss += criterion(masks_probs_flat, true_masks_flat)
loss /= len(masks_pred)
epoch_loss += loss.item()
else:
masks_probs_flat = masks_pred.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
## todo: adjust iou
iou = iou_score(output, true_masks / 255)
######## record the best iou
if iou > best_iou:
best_iou = iou
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
newloss = loss.item()
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
print('Best iou: {}'.format(best_iou))
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
writer.add_scalar('train_loss', epoch_loss / i, (epoch + 1))
writer.add_scalar('val_dice', val_dice, (epoch + 1))
writer.add_scalar('best iou', best_iou, (epoch + 1))
if save_cp:
#torch.save(net.state_dict(),dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
#print('Checkpoint {} saved !'.format(epoch + 1))
dice_best = val_dice > best_dice
loss_best = epoch_loss / i < best_loss
best_dice = max(val_dice, best_dice)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': net.state_dict(),
'best_dice': best_dice,
'best_loss': best_loss,
}, dice_best, loss_best)
print('Best dice: ', best_dice)
# true_mask = torch.from_numpy(true_mask)
mask_pred = net(img.cuda())[0]
mask_pred = mask_pred.data.cpu().numpy()
mask_pred = (mask_pred > 0.5).astype(int)
#
# print('mask_pred.shape.zhaojin', mask_pred.shape)
# print('true_mask.shape.zhaojin', true_mask.shape)
tot += dice_cofe(mask_pred, true_mask)
return tot / (i + 1)
if __name__ == "__main__":
dir_img = '/home/zhaojin/data/TacomaBridge/segdata/train/img'
dir_mask = '/home/zhaojin/data/TacomaBridge/segdata/train/mask'
dir_checkpoint = '/home/zhaojin/data/TacomaBridge/segdata/train/checkpoint/logloss_softmax/'
net = UNet(n_channels=1, n_classes=4)
net = net.cuda()
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, 0.1)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask, 0.5)
if 1:
val_dice = eval_net(net, val)
print('Validation Dice Coeff: {}'.format(val_dice))
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5):
dir_img = '../dataset/train/images/'
dir_mask = '../dataset/train/masks/'
dir_checkpoint = 'checkpoints/'
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print(('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu))))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
for epoch in range(epochs):
print(('Starting epoch {}/{}.'.format(epoch + 1, epochs)))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask, img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask, img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)): # b[batch_id][0/1]: a batch of image(0)+mask(1)
#print(('b[0]',b[0][0].shape,b[0][1].shape))
#imgs = []
#for img_msk in b:
# imgs.append(img_msk[0])
#print(len(imgs))
#imgs = np.array(imgs) # Wrong: not all images are of the same shape
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print(('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train, loss.item())))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print(('Epoch finished ! Loss: {}'.format(epoch_loss / i)))
if 1:
val_dice = eval_net(net, val, gpu)
print(('Validation Dice Coeff: {}'.format(val_dice)))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'cropped_CP{}.pth'.format(epoch + 1))
print(('Checkpoint {} saved !'.format(epoch + 1)))
def fit(net,
tf_writer,
epochs=5,
batch_size=1,
lr=0.0001,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=1,
l2=1e-8,
mom=0.9,
n_classes=4,
loss_function='bce',
alpha_non_zero=1,
resize_in=500):
# dir_png = "data/caddata_line_v2_1_mini/png"
# dir_mask = "data/caddata_line_v2_1_mini/mask"
dir_png_train = os.path.join(args.data, 'train', 'png')
dir_mask_train = os.path.join(args.data, 'train', 'mask')
dir_png_val = os.path.join(args.data, 'val', 'png')
dir_mask_val = os.path.join(args.data, 'val', 'mask')
# dir_mask = "data/mini/mask"
dir_checkpoint = os.path.join(args.log, 'checkpoints')
if not os.path.isdir(dir_checkpoint):
os.mkdir(dir_checkpoint)
# train
ids_train = get_ids(dir_png_train)
ids_train = split_ids(ids_train, n=1)
l_ids_train = list(ids_train)
# val
ids_val = get_ids(dir_png_val)
ids_val = split_ids(ids_val, n=1)
l_ids_val = list(ids_val)
# iddataset = split_train_val(ids, val_percent)
iddataset = {'train': l_ids_train, 'val': l_ids_val}
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
if loss_function == 'bce':
criterion = nn.BCELoss()
elif loss_function == 'mse':
criterion = nn.MSELoss()
# criterion = nn.CrossEntropyLoss()
with open(os.path.join(args.log, 'log.txt'), 'w+') as f_log:
for epoch in range(epochs):
# print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
# optimizer = optim.SGD(net.parameters(),
# lr=lr * (args.lr_decay ** epoch),
# momentum=mom,
# weight_decay=l2)
optimizer = optim.Adam(net.parameters(),
lr=lr * (args.lr_decay**epoch),
weight_decay=l2)
# optimizer = optim.RMSprop(net.parameters(),
# lr=lr * (args.lr_decay ** epoch),
# weight_decay=l2)
print("Current lr = {}".format(lr * (args.lr_decay**epoch)))
f_log.write("Current lr = {}".format(lr * (args.lr_decay**epoch)) +
'\n')
net.train()
# shuffle training set
random.shuffle(l_ids_train)
iddataset = {'train': l_ids_train, 'val': l_ids_val}
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_png_train,
dir_mask_train, img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_png_val,
dir_mask_val, img_scale)
epoch_loss = 0
epoch_tot = 0
epoch_acc = 0
epoch_acc_all = 0
i_out = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([j[0] for j in b]).astype(np.uint8)
true_masks = np.array([j[1] for j in b]).astype(np.uint8)
imgs_2 = np.zeros(
(imgs.shape[0], N_CHANNELS, resize_in, resize_in))
true_masks_2 = np.zeros(
(true_masks.shape[0], resize_in, resize_in, n_classes))
## data augmentation
for j in range(imgs.shape[0]):
img = imgs[j, :, :, :]
mask = true_masks[j, :, :, :]
# print(np.unique(mask))
pil_img = Image.fromarray(img, 'RGB')
pil_mask = Image.fromarray(mask, 'RGB')
##debug##
# pil_img.show()
# pil_mask.show()
# print(np.unique(mask))
seed = np.random.randint(124521346)
# Resize Crop ratio: img
random.seed(seed)
pil_img = torchvision.transforms.RandomResizedCrop(
size=(resize_in),
scale=(0.8, 1.0),
interpolation=Image.NEAREST)(pil_img)
# Resize Crop ratio: true_masks
random.seed(seed)
pil_mask = torchvision.transforms.RandomResizedCrop(
size=(resize_in),
scale=(0.8, 1.0),
interpolation=Image.NEAREST)(pil_mask)
"""
# rotate seed
random_degree = randrange(360)
# rotate: img
pil_img = torchvision.transforms.functional.rotate(pil_img, angle=random_degree)
# rotate: true_masks
pil_mask = torchvision.transforms.functional.rotate(pil_mask, angle=random_degree)
"""
# color: img
# color: true_masks
arr_img = rgb_pil_to_bw_norm_arr(pil_img)
# print(np.unique(arr_img))
imgs_2[j, N_CHANNELS - 1, :, :] = arr_img
# print(np.unique(imgs_2))
arr_mask = np.array(pil_mask)
arr_mask_2 = np.zeros((resize_in, resize_in, n_classes))
for in_c in range(n_classes):
in_1, in_2 = np.where(arr_mask[:, :, 0] == (in_c + 1))
arr_mask_2[in_1, in_2,
in_c] = arr_mask[in_1, in_2,
0].astype(bool).astype(
np.float32)
true_masks_2[j, :, :, :] = arr_mask_2
# true_masks_2.astype(np.float32)
# print("======")
# print(np.unique(true_masks_2))
## To TorchTensor
# imgs:
# imgs = torch.from_numpy(imgs_2.astype(np.float32).transpose(0,3,1,2))
imgs = torch.from_numpy(imgs_2.astype(np.float32))
# true_masks:
# true_masks = torch.from_numpy(true_masks_2.transpose(0,3,1,2))
true_masks = torch.from_numpy(true_masks_2)
# imgs = torch.from_numpy(imgs)
# true_masks = torch.from_numpy(true_masks)
# true_masks = np.transpose(true_masks, (0, 3, 1, 2))
# assert imgs.size()[1] == N_CHANNELS
# assert true_masks.size()[1] == n_classes
# assert true_masks.size()[2] == imgs.size()[2]
# assert true_masks.size()[3] == imgs.size()[3]
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
# view(-1)
masks_probs_flat = masks_pred.view(-1)
if gpu:
true_masks_flat = true_masks.view(-1)
else:
true_masks_flat = true_masks.reshape(-1)
true_masks_flat = true_masks_flat.float()
# loss
loss = criterion(masks_probs_flat, true_masks_flat)
in_nonzero = torch.nonzero(true_masks_flat)
loss_nonzero = criterion(masks_probs_flat[in_nonzero],
true_masks_flat[in_nonzero])
if in_nonzero.size(0) != 0:
loss = loss + alpha_non_zero * loss_nonzero
epoch_loss += loss.item()
true_masks_flat_bin = true_masks_flat.unsqueeze(0)
masks_probs_flat_bin = (masks_probs_flat >
0.5).float().unsqueeze(0)
this_dice = dice_coeff(masks_probs_flat_bin,
true_masks_flat_bin).item()
epoch_tot += this_dice
# e = np.array(masks_probs_flat_bin.cpu())
# f = np.array(true_masks_flat_bin.cpu())
acc_train = iou(np.array(true_masks_flat_bin.cpu()),
np.array(masks_probs_flat_bin.cpu()))
acc_train_all = iou_all(np.array(true_masks_flat_bin.cpu()),
np.array(masks_probs_flat_bin.cpu()))
epoch_acc += acc_train
epoch_acc_all += acc_train_all
if i % print_interval == print_interval - 1:
print(
'{0} / {1} steps. --- loss: {2:.6f}, IoU_train_nz: {3:.4f}, IoU_train_all: {4:.4f}, dice: {5:.4f}'
.format(i, int(N_train / batch_size),
epoch_loss / (i + 1), epoch_acc / (i + 1),
epoch_acc_all / (i + 1), epoch_tot / (i + 1)))
f_log.write(
'{0} / {1} steps. --- loss: {2:.6f}, ACC_train: {3:.4f}, IoU_train_all: {4:.4f}, dice: {4:.4f}'
.format(i, int(N_train / batch_size), epoch_loss /
(i + 1), epoch_acc / (i + 1), epoch_acc_all /
(i + 1), epoch_tot / (i + 1)) + '\n')
optimizer.zero_grad()
loss.backward()
optimizer.step()
i_out = i
print(
'Epoch {} finished ! Loss: {}, IoU: {}, IoU_all: {}, dice: {}'.
format(epoch, epoch_loss / (i_out + 1),
epoch_acc / (i_out + 1), epoch_acc_all / (i_out + 1),
epoch_tot / (i + 1)))
f_log.write(
'Epoch finished ! Loss: {}, IoU: {}, IoU_all: {}, dice: {}'.
format(epoch_loss / (i_out + 1), epoch_acc /
(i_out + 1), epoch_acc_all / (i_out + 1), epoch_tot /
(i + 1)) + '\n')
tf_writer.add_scalar('data/train_loss', epoch_loss / (i_out + 1),
epoch)
tf_writer.add_scalar('data/train_iou', epoch_acc / (i_out + 1),
epoch)
tf_writer.add_scalar('data/train_iou_all',
epoch_acc_all / (i_out + 1), epoch)
tf_writer.add_scalar('data/train_dice', epoch_tot / (i_out + 1),
epoch)
## Evaluate
net.eval()
tot_val = 0
epoch_loss_val = 0
epoch_acc_val = 0
epoch_acc_val_all = 0
for i_val, b_val in enumerate(batch(val, batch_size)):
# imgs_val = np.array([j[0] for j in b_val]).astype(np.float32)
# true_masks_val = np.array([j[1] for j in b_val])
#
# imgs_val = torch.from_numpy(imgs_val)
# true_masks_val = torch.from_numpy(true_masks_val)
# true_masks_val = np.transpose(true_masks_val, (0, 3, 1, 2))
####
imgs_val = np.array([j[0] for j in b_val]).astype(np.uint8)
true_masks_val = np.array([j[1]
for j in b_val]).astype(np.uint8)
imgs_2 = np.zeros(
(imgs_val.shape[0], N_CHANNELS, resize_in, resize_in))
true_masks_2 = np.zeros(
(true_masks_val.shape[0], resize_in, resize_in, n_classes))
## data augmentation
if imgs_val.shape[0] == batch_size:
for j in range(imgs_val.shape[0]):
img = imgs_val[j, :, :, :]
mask = true_masks_val[j, :, :, :]
# print(np.unique(mask))
pil_img = Image.fromarray(img, 'RGB')
pil_mask = Image.fromarray(mask, 'RGB')
# resize
pil_img = torchvision.transforms.Resize(
size=(resize_in),
interpolation=Image.NEAREST)(pil_img)
pil_mask = torchvision.transforms.Resize(
size=(resize_in),
interpolation=Image.NEAREST)(pil_mask)
# upload img and mask to imgs_2 and mask_2
arr_img = rgb_pil_to_bw_norm_arr(pil_img)
imgs_2[j, N_CHANNELS - 1, :, :] = arr_img
arr_mask = np.array(pil_mask)
arr_mask_2 = np.zeros(
(resize_in, resize_in, n_classes))
for in_c in range(n_classes):
in_1, in_2 = np.where(arr_mask[:, :,
0] == (in_c + 1))
arr_mask_2[in_1, in_2,
in_c] = arr_mask[in_1, in_2,
0].astype(bool).astype(
np.float32)
true_masks_2[j, :, :, :] = arr_mask_2
# true_masks_2.astype(np.float32)
# print("======")
# print(np.unique(true_masks_2))
## To TorchTensor
# imgs:
imgs_val = torch.from_numpy(imgs_2.astype(np.float32))
# true_masks:
true_masks_val = torch.from_numpy(true_masks_2)
if gpu:
imgs_val = imgs_val.cuda()
true_masks_val = true_masks_val.cuda()
masks_pred_val = net(imgs_val)
masks_probs_flat_val = masks_pred_val.view(-1)
if gpu:
true_masks_flat_val = true_masks_val.view(-1)
else:
true_masks_flat_val = true_masks_val.reshape(-1)
true_masks_flat_val = true_masks_flat_val.float()
true_masks_flat_bin_val = true_masks_flat_val.unsqueeze(0)
masks_probs_flat_bin_val = (masks_probs_flat_val >
0.5).float().unsqueeze(0)
dice_val = dice_coeff(masks_probs_flat_bin_val,
true_masks_flat_bin_val).item()
acc_val = iou(np.array(true_masks_flat_bin_val.cpu()),
np.array(masks_probs_flat_bin_val.cpu()))
acc_val_all = iou_all(
np.array(true_masks_flat_bin_val.cpu()),
np.array(masks_probs_flat_bin_val.cpu()))
epoch_acc_val += acc_val
epoch_acc_val_all += acc_val_all
tot_val += dice_val
loss_val = criterion(masks_probs_flat_val,
true_masks_flat_val)
in_nonzero = torch.nonzero(true_masks_flat_val)
loss_val_nonzero = criterion(
masks_probs_flat_val[in_nonzero],
true_masks_flat_val[in_nonzero])
if in_nonzero.size(0) != 0:
loss_val = loss_val + alpha_non_zero * loss_val_nonzero
epoch_loss_val = loss_val / (i_val + 1)
epoch_dice_val = tot_val / (i_val + 1)
epoch_acc_val = epoch_acc_val / (i_val + 1)
epoch_acc_val_all = epoch_acc_val_all / (i_val + 1)
# val_dice = eval_net(net, val, gpu)
print(
'* Val: Loss: {0:.6f}, IoU: {1:.3f}, IoU_all: {2:.3f}, Dice: {3:.3f}'
.format(epoch_loss_val, epoch_acc_val, epoch_acc_val_all,
epoch_dice_val))
f_log.write(
'* Val: Loss: {0:.6f}, IoU: {1:.3f}, IoU_all: {2:.3f}, Dice: {3:.3f}'
.format(epoch_loss_val, epoch_acc_val, epoch_acc_val_all,
epoch_dice_val) + '\n')
tf_writer.add_scalar('data/val_loss', epoch_loss_val, epoch)
tf_writer.add_scalar('data/val_iou', epoch_acc_val, epoch)
tf_writer.add_scalar('data/val_iou_all', epoch_acc_val_all, epoch)
tf_writer.add_scalar('data/val_dice', epoch_dice_val, epoch)
if save_cp and (epoch % save_interval == save_interval - 1):
torch.save(net.state_dict(),
dir_checkpoint + '/CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
f_log.write('Checkpoint {} saved !'.format(epoch + 1) + '\n')
def __init__(self,
args,
data_dir, # folder with txt files
rnd_state=None,
use_cont_node_attr=False,
# use or not additional float valued node attributes available in some datasets
folds=10):
self.data_dir = data_dir
self.rnd_state = np.random.RandomState() if rnd_state is None else rnd_state
self.use_cont_node_attr = use_cont_node_attr
files = os.listdir(self.data_dir)
data = {}
nodes, graphs = self.read_graph_nodes_relations(
list(filter(lambda f: f.find('graph_indicator') >= 0, files))[0])
data['adj_list'] = self.read_graph_adj(list(filter(lambda f: f.find('_A') >= 0, files))[0], nodes, graphs)
node_labels_file = list(filter(lambda f: f.find('node_labels') >= 0, files))
if len(node_labels_file) == 1:
data['features'] = self.read_node_features(node_labels_file[0], nodes, graphs, fn=lambda s: int(s.strip()))
else:
data['features'] = None
data['targets'] = np.array(
self.parse_txt_file(
list(filter(lambda f: f.find('graph_labels') >= 0 or f.find('graph_attributes') >= 0, files))[0],
line_parse_fn=lambda s: int(float(s.strip()))))
if self.use_cont_node_attr:
data['attr'] = self.read_node_features(list(filter(lambda f: f.find('node_attributes') >= 0, files))[0],
nodes, graphs,
fn=lambda s: np.array(list(map(float, s.strip().split(',')))))
features, n_edges, degrees = [], [], []
for sample_id, adj in enumerate(data['adj_list']):
N = len(adj) # number of nodes
if data['features'] is not None:
assert N == len(data['features'][sample_id]), (N, len(data['features'][sample_id]))
if not np.allclose(adj, adj.T):
print(sample_id, 'not symmetric')
n = np.sum(adj) # total sum of edges
assert n % 2 == 0, n
n_edges.append(int(n / 2)) # undirected edges, so need to divide by 2
degrees.extend(list(np.sum(adj, 1)))
if data['features'] is not None:
features.append(np.array(data['features'][sample_id]))
# Create features over graphs as one-hot vectors for each node
if data['features'] is not None:
features_all = np.concatenate(features)
features_min = features_all.min()
num_features = int(features_all.max() - features_min + 1) # number of possible values
max_degree = np.max(degrees)
features_onehot = []
for sample_id, adj in enumerate(data['adj_list']):
N = adj.shape[0]
if data['features'] is not None:
x = data['features'][sample_id]
feature_onehot = np.zeros((len(x), num_features))
for node, value in enumerate(x):
feature_onehot[node, value - features_min] = 1
else:
feature_onehot = np.empty((N, 0))
if self.use_cont_node_attr:
if args.dataset in ['COLORS-3', 'TRIANGLES']:
# first column corresponds to node attention and shouldn't be used as node features
feature_attr = np.array(data['attr'][sample_id])[:, 1:]
else:
feature_attr = np.array(data['attr'][sample_id])
else:
feature_attr = np.empty((N, 0))
if args.degree:
degree_onehot = np.zeros((N, max_degree + 1))
degree_onehot[np.arange(N), np.sum(adj, 1).astype(np.int32)] = 1
else:
degree_onehot = np.empty((N, 0))
node_features = np.concatenate((feature_onehot, feature_attr, degree_onehot), axis=1)
if node_features.shape[1] == 0:
# dummy features for datasets without node labels/attributes
# node degree features can be used instead
node_features = np.ones((N, 1))
features_onehot.append(node_features)
num_features = features_onehot[0].shape[1]
shapes = [len(adj) for adj in data['adj_list']]
labels = data['targets'] # graph class labels
labels -= np.min(labels) # to start from 0
classes = np.unique(labels)
num_classes = len(classes)
if not np.all(np.diff(classes) == 1):
print('making labels sequential, otherwise pytorch might crash')
labels_new = np.zeros(labels.shape, dtype=labels.dtype) - 1
for lbl in range(num_classes):
labels_new[labels == classes[lbl]] = lbl
labels = labels_new
classes = np.unique(labels)
assert len(np.unique(labels)) == num_classes, np.unique(labels)
def stats(x):
return (np.mean(x), np.std(x), np.min(x), np.max(x))
print('N nodes avg/std/min/max: \t%.2f/%.2f/%d/%d' % stats(shapes))
print('N edges avg/std/min/max: \t%.2f/%.2f/%d/%d' % stats(n_edges))
print('Node degree avg/std/min/max: \t%.2f/%.2f/%d/%d' % stats(degrees))
print('Node features dim: \t\t%d' % num_features)
print('N classes: \t\t\t%d' % num_classes)
print('Classes: \t\t\t%s' % str(classes))
for lbl in classes:
print('Class %d: \t\t\t%d samples' % (lbl, np.sum(labels == lbl)))
if data['features'] is not None:
for u in np.unique(features_all):
print('feature {}, count {}/{}'.format(u, np.count_nonzero(features_all == u), len(features_all)))
N_graphs = len(labels) # number of samples (graphs) in data
assert N_graphs == len(data['adj_list']) == len(features_onehot), 'invalid data'
# Create train/test sets first
train_ids, test_ids = split_ids(args, rnd_state.permutation(N_graphs), folds=folds)
# Create train sets
splits = []
for fold in range(len(train_ids)):
splits.append({'train': train_ids[fold],
'test': test_ids[fold]})
data['features_onehot'] = features_onehot
data['targets'] = labels
data['splits'] = splits
data['N_nodes_max'] = np.max(shapes) # max number of nodes
data['num_features'] = num_features
data['num_classes'] = num_classes
self.data = data
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.5,
save_cp=True,
gpu=True,
img_scale=0.5):
dir_img = '/home/buiduchanh/WorkSpace/Unet/Pytorch-UNet/data/data_rust/train_few_images/'
dir_mask = '/home/buiduchanh/WorkSpace/Unet/Pytorch-UNet/data/data_rust/train_masks_few_images/'
# dir_img = '/home/buiduchanh/WorkSpace/Unet/Pytorch-UNet/data/data_rust/train_images/'
# dir_mask = '/home/buiduchanh/WorkSpace/Unet/Pytorch-UNet/data/data_rust/train_masks/'
dir_checkpoint = 'checkpoints/'
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
#optimizer = optim.SGD(net.parameters(),
# lr=lr,
# momentum=0.9,
# weight_decay=0.0005)
optimizer = optim.Adam(net.parameters(),
lr = lr,
betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask, img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask, img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train, loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch {} finished ! Loss: {}'.format(epoch, epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_prune_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5,
num_prune_iterations=100):
dir_img = 'data/train/'
dir_mask = 'data/train_masks/'
dir_checkpoint = 'checkpoints/'
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
for epoch in range(epochs):
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.eval()
sub = list(enumerate(val))[:3]
for i, b in sub:
img = b[0]
true_mask = b[1]
img = torch.from_numpy(img).unsqueeze(0)
true_mask = torch.from_numpy(true_mask).unsqueeze(0)
if gpu:
img = img.cuda()
true_mask = true_mask.cuda()
mask_pred = net(img)[0]
mask_pred = (mask_pred > 0.5).float()
val_dice = dice_coeff(mask_pred, true_mask).item()
print('Validation Dice Coeff at batch {}: {}'.format(
i + 1, val_dice))
net.train()
for i, b in enumerate(batch(train, batch_size)):
if i > 2:
break
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
for j in range(num_prune_iterations):
if j == num_prune_iterations - 1:
net.prune(verbose=True)
else:
net.prune(verbose=False)
summary(net, (3, 640, 640))
for i, b in sub:
img = b[0]
true_mask = b[1]
img = torch.from_numpy(img).unsqueeze(0)
true_mask = torch.from_numpy(true_mask).unsqueeze(0)
if gpu:
img = img.cuda()
true_mask = true_mask.cuda()
mask_pred = net(img)[0]
mask_pred = (mask_pred > 0.5).float()
val_dice = dice_coeff(mask_pred, true_mask).item()
print('Validation Dice Coeff at batch {}: {}'.format(
i + 1, val_dice))
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
# val_dice = eval_net(net, val, gpu)
# print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5):
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
dir_img = '../all/reduced/'
dir_mask = '../all/masks/'
dir_checkpoint = 'checkpoints/'
# fetches ids in directory, without .jpg extension
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
# create a generator to try: yeild each value enumerate(batch(train, batch_size))
# or transfer enumerate() to try loop somehow.
epoch_loss = 0
exception_amount = 0
for i, b in enumerate(batch(train, batch_size)):
try:
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs = F.sigmoid(masks_pred)
masks_probs_flat = masks_probs.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(
i * batch_size / N_train, loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
except KeyboardInterrupt:
torch.save(net.state_dict(), 'INTERRUPTED.pth')
print('Saved interrupt')
try:
sys.exit(0)
except SystemExit:
os._exit(0)
except Exception as ah:
print(ah)
exception_amount += 1
if exception_amount > 20:
print('things arent going good')
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
max_degree = 14
else:
raise NotImplementedError(
'max_degree value should be specified in advance. '
'Try running without --torch_geom (-g) and look at dataset statistics printed out by our code.'
)
if args.degree:
transforms.append(T.OneHotDegree(max_degree=max_degree, cat=False))
dataset = TUDataset('./data/%s/' % args.dataset,
name=args.dataset,
use_node_attr=args.use_cont_node_attr,
transform=T.Compose(transforms))
train_ids, test_ids = split_ids(args,
rnd_state.permutation(len(dataset)),
folds=n_folds)
else:
datareader = DataReader(args=args,
data_dir='./data/%s/' % args.dataset,
rnd_state=rnd_state,
folds=n_folds,
use_cont_node_attr=args.use_cont_node_attr)
acc_folds = []
for fold_id in range(n_folds):
torch.cuda.empty_cache()
loaders = []
for split in ['train', 'test']:
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_height=512,
img_scale=0.5):
#dir_img = 'carvana-image-masking-challenge/train/'
#dir_mask = 'carvana-image-masking-challenge/train_masks/'
dir_img = '/root/ctw/train_images_preprocess_other/'
dir_mask = '/root/ctw/train_images_mask_preprocess_other/'
#dir_img = '/root/ctw/val_images_preprocess_test/'
#dir_mask = '/root/ctw/val_images_mask_preprocess_test/'
dir_checkpoint = 'checkpoints/'
ids = list(get_ids(dir_img))
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.Adam(net.parameters(),lr=lr)
# optimizer = optim.SGD(net.parameters(),
# lr=lr,
# momentum=0.92,
# weight_decay=0.0005)
criterion = nn.BCELoss()
#criterion = nn.MSELoss()
#import scipy.misc
iteration = 0
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask, img_height, img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask, img_height, img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
#print(i, len(b))
"""
for j in b:
#print(j[0].shape, j[1].shape)
#print(j[1])
#scipy.misc.toimage(j[0], cmin=0.0, cmax=1.0).save('%s_outfile.jpg'%count)
#scipy.misc.toimage(j[1], cmin=0.0, cmax=1.0).save('%s_outmask.jpg'%count)
count += 1
"""
iteration += 1
try:
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
# print("\nImgs : \n{}".format(np.unique(imgs)))
# print("\ntrue mask \n {} ".format(np.unique(true_masks)))
#print('%s'%(datetime.datetime.now()), '{0:.4f}'.format(i * batch_size))
except Exception as e:
print(Exception)
continue
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
if iteration%100==0:
print('iter %s'%iteration, '%s'%(datetime.datetime.now()), '{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train, loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
val_iou=val_dice/(2-val_dice)
print('Validation Dice Coeff: {}'.format(val_dice))
print('Validation iouScore : {}'.format(val_iou))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(
net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.05, # 训练集：验证集= 0.95： 0.05
save_cp=True,
gpu=False,
img_scale=0.5):
dir_img = opt_train.dir_img
dir_mask = opt_train.dir_mask
dir_checkpoint = opt_train.dir_checkpoint
# 得到 图片路径列表 ids为 图片名称（无后缀名）
ids = get_ids(dir_img)
# 得到truple元组 （无后缀名的 图片名称，序号）
# eg:当n为2 图片名称为bobo.jpg 时, 得到（bobo,0） （bobo,1）
# 当序号为0 时，裁剪宽度，得到左边部分图片 当序号为1 时，裁剪宽度，得到右边部分图片
ids = split_ids(ids)
# 打乱数据集后，按照val_percent的比例来 切分 训练集 和 验证集
iddataset = split_train_val(ids, val_percent)
print('''
开始训练:
Epochs: {}
Batch size: {}
Learning rate: {}
训练集大小: {}
验证集大小: {}
GPU: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(gpu)))
#训练集大小
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
#二进制交叉熵
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
# reset the generators
# 每轮epoch得到 训练集 和 验证集
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
# 重置epoch损失计数器
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
# 得到 一个batch的 imgs tensor 及 对应真实mask值
# 当序号为0 时，裁剪宽度，得到左边部分图片[384,384,3] 当序号为1 时，裁剪宽度，得到右边部分图片[384,190,3]
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
# 将值转为 torch tensor
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
# 训练数据转到GPU上
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
# 得到 网络输出的预测mask [10,1,384,384]
masks_pred = net(imgs)
# 经过sigmoid
masks_probs = F.sigmoid(masks_pred)
masks_probs_flat = masks_probs.view(-1)
true_masks_flat = true_masks.view(-1)
# 计算二进制交叉熵损失
loss = criterion(masks_probs_flat, true_masks_flat)
# 统计一个epoch的所有batch的loss之和，用以计算 一个epoch的 loss均值
epoch_loss += loss.item()
# 输出 当前epoch的第几个batch 及 当前batch的loss
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
# 优化器梯度清零
optimizer.zero_grad()
# 反向传播
loss.backward()
# 更新参数
optimizer.step()
# 一轮epoch结束，该轮epoch的 loss均值
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
# 每轮epoch之后使用验证集进行评价
if True:
# 评价函数：Dice系数 Dice距离用于度量两个集合的相似性
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
# 保存模型
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(net,
epochs=20,
batch_size=1,
lr=0.1,
lrd=0.99,
val_percent=0.05,
save_cp=True,
gpu=True,
img_scale=0.5,
imagepath='',
maskpath='',
cpsavepath=''):
dir_img = imagepath
dir_mask = maskpath
dir_checkpoint = cpsavepath
classweight = [1, 2, 3, 2]
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
logname = cpsavepath + '/' + 'losslog.txt'
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
# classweight = [1,4,8,4]
criterion = BCELoss_weight(classweight)
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
with open(logname, "a") as f:
f.write('Starting epoch {}/{}.'.format(epoch + 1, epochs) + "\n")
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
lr = lr * lrd
for param_group in optimizer.param_groups:
param_group['lr'] = lr
print('lr', lr)
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
true_masks = np.transpose(true_masks, axes=[0, 3, 1, 2])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
# print('masks_pred.shape',masks_pred.shape)
# print('true_masks.shape', true_masks.shape)
masks_probs_flat = masks_pred
true_masks_flat = true_masks
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
printinfo = '{0:.4f} --- loss: {1:.6f}'.format(
i * batch_size / N_train, loss.item())
print(printinfo)
with open(logname, "a") as f:
f.write(printinfo + "\n")
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
with open(logname, "a") as f:
f.write('Epoch finished ! Loss: {}'.format(epoch_loss / i) + "\n")
if 1:
val_dice = eval_net(net, val)
print('Validation Dice Coeff: {}'.format(val_dice))
with open(logname, "a") as f:
f.write('Validation Dice Coeff: {}'.format(val_dice) + "\n")
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
with open(logname, "a") as f:
f.write('Checkpoint {} saved !'.format(epoch + 1) + "\n")
def train_net(net,
epochs=30,
batch_size=6,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5):
# dir_img = 'E:/A_paper_thesis/paper5/tensorflow_deeplabv3plus_scrapingData/dataset/Scraping_Data2/train_db'
dir_img = 'data/train_db/'
dir_mask = 'data/GT_bw/'
dir_checkpoint = 'checkpoint0919/'
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask, img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask, img_scale)
epoch_loss = 0
epoch_iou = 0
epoch_xor=0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('step:', i)
# print('Validation Dice Coeff: {0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train, loss.item()))
print('Validation Dice Coeff: {0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train, loss.item()))
# # mean iou
# intersect = sum(masks_probs_flat*true_masks_flat)
# union = sum(masks_probs_flat+true_masks_flat)
# iou = (intersect+0.001)/(union-intersect+0.001)
# epoch_iou +=iou
# mean iou
smooth = 1e-6 # we smooth to avoid our devision 0/0
intersect = sum(masks_probs_flat*true_masks_flat)
union = sum(masks_probs_flat+true_masks_flat)-intersect
iou = (intersect+smooth)/(union+smooth)
epoch_iou +=iou
# calculate xor
# xor quation is: xor = (union(output hợp ground truth) - intersect(output giao ground truth))/ ground truth
# xor = (union-intersect)/ground truth
xor = (union - intersect)/sum(true_masks_flat)
epoch_xor += xor
print('mean IoU: {:.4f}'.format(iou))
# print('mean IoU1: {:.4f}'.format(iou1))
print('mean xor: {:.4f}'.format(xor))
# end of mean iou
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! epoch_Loss: {:.6f}'.format(epoch_loss / i))
print('epoch_iou: {:.4f}'.format(epoch_iou / i))
print('epoch_xor: {:.4f}'.format(epoch_xor / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('epoch_Validation Dice Coeff: {:.4f}'.format(val_dice))
# need to write mean iou of evaluate here(reference val_dice)
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.2,
save_cp=True,
gpu=False,
img_scale=0.5):
path = [['data/ori1/', 'data/gt1/'],
['data/original1/', 'data/ground_truth1/'],
['data/Original/', 'data/Ground_Truth/']]
dir_img = path[0][0]
dir_mask = path[0][1]
dir_checkpoint = 'sdgcheck/'
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.7,
weight_decay=0.005)
'''
optimizer = optim.Adam(net.parameters(),
lr=lr,
weight_decay=0.0005)
'''
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
x = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
'''
ori=np.transpose(imgs[0], axes=[1, 2, 0])
scipy.misc.imsave("ori/ori_"+str(x)+'.jpg', ori)
gt = np.stack((true_masks[0],)*3, axis=-1)
#gt=np.transpose(true_masks[0], axes=[1, 2, 0])
scipy.misc.imsave("gt/gt_"+str(x)+'.jpg', gt)
'''
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
x += 1
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(args, net, val_percent=0.05, save_cp=True):
dir_img = os.path.join(args.dataset_folder, 'data/train/')
dir_mask = os.path.join(args.dataset_folder, 'data/train_masks/')
dir_checkpoint = os.path.join(args.dataset_folder, 'checkpoints/')
if not os.path.exists(dir_checkpoint):
os.makedirs(dir_checkpoint)
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
'''.format(args.epochs, args.batch_size, args.lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
for epoch in range(args.epochs):
print('Starting epoch {}/{}.'.format(args.epochs + 1, args.epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
args.img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
args.img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, args.batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
# if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(
i * args.batch_size / N_train, loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5):
dir_img = 'data/train/'
dir_mask = 'data/train_masks/'
dir_checkpoint = 'checkpoints/'
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
best_dice = 0.0
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
true_masks = true_masks / true_masks.max()
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs = F.sigmoid(masks_pred)
masks_probs_flat = masks_probs.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
with open('acc.log', 'a+') as w:
w.write('eopch {}, acc:{}\n'.format(epoch, val_dice))
if save_cp and val_dice > best_dice:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
best_dice = val_dice
def train_net(net,
epochs=5,
batch_size=1,
lr=1e-3,
val_percent=0.05,
save_cp=True,
gpu=False,
img_scale=0.5):
dir_img = '/home/xyj/data/spacenet/vegas/images_rgb_1300/'
dir_mask = '/home/xyj/test/Pytorch-UNet/data/train_mask_point/'
dir_checkpoint = 'checkpoints_point/'
if not os.path.exists(dir_checkpoint):
os.mkdir(dir_checkpoint)
# ids = get_ids(dir_img) # 返回train文件夹下文件的名字列表，生成器（except last 4 character，.jpg这样的）
with open('train_list.txt', 'r') as f:
lines = f.readlines()
ids = (i.strip('\n')[:-4] for i in lines)
ids = split_ids(
ids) # 返回(id, i), id属于ids，i属于range(n)，相当于把train的图✖️了n倍多张，是tuple的生成器
iddataset = split_train_val(
ids, val_percent
) # validation percentage，是dict = {"train": ___(一个list), "val"：___(一个list)}
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
# optimizer = optim.SGD(net.parameters(),
# lr=lr,
# momentum=0.9,
# weight_decay=0.0005)
optimizer = optim.Adam(net.parameters(),
lr=lr,
betas=(0.9, 0.999),
eps=1e-3)
# scheduler = optim.lr_scheduler.StepLR(optimizer,step_size=40,gamma = 0.3)
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] // 200 for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
# scheduler.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
def train_net(net,
epochs=5,
batch_size=1,
lr=0.1,
val_percent=0.2,
save_cp=True,
gpu=False,
img_scale=0.5):
dir_img = '/media/workspace/DATASET/Eyes/STARE/stare-images'
dir_mask = '/media/workspace/DATASET/Eyes/STARE/labels'
dir_checkpoint = 'checkpoints/'
ids = get_ids(dir_img)
ids = split_ids(ids, 4)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([w[0] for w in b]).astype(np.float32)
true_masks = np.array([w[1] for w in b])
true_masks[true_masks == 255] = 1
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train,
loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
if not os.path.exists(dir_checkpoint):
os.mkdir(dir_checkpoint)
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
"prune_channels": args.prune_channels,
"gpu": args.gpu,
"load": args.load,
"channel_txt": args.channel_txt,
"scale": args.scale,
"lr": args.lr,
"iters": args.iters,
"epochs": args.epochs
},
indent=4,
sort_keys=True)))
# Dataset
if not os.path.exists(splitfile): # Our constant datasplit
ids = get_ids(dir_img) # [file1, file2]
ids = split_ids(ids) # [(file1, 0), (file1, 1), (file2, 0), ...]
iddataset = split_train_val(ids, 0.2, splitfile)
log.info("New split dataset")
else:
with open(splitfile) as f:
iddataset = json.load(f)
log.info("Load split dataset")
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
args.scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask, args.scale)
# Model Initialization
net = UNet(n_channels=3, n_classes=1, f_channels=args.channel_txt)
log.info("Built model using {}...".format(args.channel_txt))
def train_net(net,
train_dir=None,
groundtruth_dir=None,
weight_dir=None,
weight_name='DeepInsthink',
val_percent=0.05,
epochs=5,
batch_size=1,
lr=0.1,
save_cp=True,
gpu=False,
img_scale=0.5):
dir_img = train_dir
dir_mask = groundtruth_dir
dir_checkpoint = weight_dir
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
max_DSC = 0
max_ep_checkpoint = 0
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
epoch_loss = 0
batchN = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('ep: {3:.0f} batch [{0:.0f}/{1:.0f}] - loss: {2:.6f}'.format(
i + 1, N_train / batch_size, loss.item(), epoch + 1))
#if (i % 5==0):
# val_dice = eval_net(net, val, gpu)
# print('Validation Dice Coeff: {}'.format(val_dice))
val_dice = eval_net(net, val, gpu)
print('Epoch {0:} -- Loss: {1:} -- Validation DSC: {2:}'.format(
epoch, epoch_loss / i, val_dice))
if (val_dice >= max_DSC):
max_DSC = val_dice
max_ep_checkpoint = epoch + 1
if save_cp:
torch.save(
net.state_dict(),
dir_checkpoint + weight_name + '-{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
print('Maximum checkpoint is ' + weight_name + '-{0:}' +
'with {1:} DSC'.format(max_ep_checkpoint, max_DSC))
from model import get_model
from utils import get_data_ids, get_labels, split_ids, save_preds, save_numpy
from keras.callbacks import ModelCheckpoint
# Parameters
params = {'dim': (299, 299),
'batch_size': 16,
'n_classes': 28,
'n_channels': 3,
'shuffle': True,
'augment': True,
'dir_path': '/tmp/human_atlas/training_data/'}
# Datasets
training_ids, testing_ids = get_data_ids()
training_ids, validation_ids = split_ids(training_ids, 0.80)
labels = get_labels()
# Generators
training_generator = DataGenerator(training_ids, labels, **params)
params['batch_size'] = 128
validation_generator = DataGenerator(validation_ids, labels, **params)
# Design model
model = get_model(params, True)
print(model.summary())
# Train
checkpointer = ModelCheckpoint(filepath='model.h5', verbose=2,
save_best_only=True, save_weights_only=False)
model.fit_generator(generator=training_generator,
def train_net(net,
epochs=50,
batch_size=1,
lr=0.1,
val_percent=0.1,
save_cp=True,
gpu=True,
img_scale=[513, 513]):
#dir_img = '/home/lixiaoxing/data/DRIVE/train/'
#dir_mask = '/home/lixiaoxing/data/DRIVE/trainannot/'
dir_img = '/home/lixiaoxing/github/Pytorch-UNet/data/DRIVE/AV_groundTruth/training/images_jpg/'
dir_mask = '/home/lixiaoxing/github/Pytorch-UNet/data/DRIVE/AV_groundTruth/training/vessel/'
dir_checkpoint = 'checkpoints/'
if os.path.exists(dir_checkpoint) is False:
os.makedirs(dir_checkpoint)
ids = get_ids(dir_img)
ids = split_ids(ids)
iddataset = split_train_val(ids, val_percent)
print('''
Starting training:
Epochs: {}
Batch size: {}
Learning rate: {}
Training size: {}
Validation size: {}
Checkpoints: {}
CUDA: {}
'''.format(epochs, batch_size, lr, len(iddataset['train']),
len(iddataset['val']), str(save_cp), str(gpu)))
N_train = len(iddataset['train'])
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=0.0005)
criterion = nn.BCELoss()
for epoch in range(epochs):
print('Starting epoch {}/{}.'.format(epoch + 1, epochs))
net.train()
# reset the generators
train = get_imgs_and_masks(iddataset['train'], dir_img, dir_mask,
img_scale)
val = get_imgs_and_masks(iddataset['val'], dir_img, dir_mask,
img_scale)
#print(train)
epoch_loss = 0
for i, b in enumerate(batch(train, batch_size)):
imgs = np.array([i[0] for i in b]).astype(np.float32)
true_masks = np.array([i[1] for i in b])
imgs = torch.from_numpy(imgs)
true_masks = torch.from_numpy(true_masks)
if gpu:
imgs = imgs.cuda()
true_masks = true_masks.cuda()
# up features
#print('**********************up**************************')
#up_feature = net.extract_features(imgs)
#print(up_feature.shape)
#ff = net._blocks[38]._depthwise_conv
masks_pred = net(imgs)
masks_probs_flat = masks_pred.view(-1)
true_masks_flat = true_masks.view(-1)
#print(true_masks_flat.shape)
#print(masks_probs_flat.shape)
loss = criterion(masks_probs_flat, true_masks_flat)
epoch_loss += loss.item()
#print('{0:.4f} --- loss: {1:.6f}'.format(i * batch_size / N_train, loss.item()))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch finished ! Loss: {}'.format(epoch_loss / i))
if 1:
val_dice = eval_net(net, val, gpu)
print('Validation Dice Coeff: {}'.format(val_dice))
if save_cp:
torch.save(net.state_dict(),
dir_checkpoint + 'CP{}.pth'.format(epoch + 1))
print('Checkpoint {} saved !'.format(epoch + 1))
