def _train_epoch(self, save_histogram=False):
self.model.train()
running_loss = 0
running_acc = 0
for iter, (inputs, targets) in enumerate(tqdm(self.train_loader)):
inputs = inputs.to(device())
targets = targets.to(device())
if self.onecycle is not None:
lr, mom = next(self.onecycle)
self.update_lr(lr)
self.update_mom(mom)
with torch.set_grad_enabled(True):
outputs = self.model(inputs)
batch_loss = self.criterion(outputs, targets)
batch_acc = accuracy(outputs, targets)
batch_loss.backward()
self.optimizer.step()
self.optimizer.zero_grad()
running_loss += batch_loss.item()
running_acc += batch_acc.item()
if self.log_every(iter):
self.writer.add_scalars(
"loss", {"train_loss": running_loss / float(iter + 1)},
(self._epoch_count - 1) * len(self.train_loader) + iter)
self.writer.add_scalars(
"acc", {"train_acc": running_acc / float(iter + 1)},
(self._epoch_count - 1) * len(self.train_loader) + iter)
epoch_loss = running_loss / len(self.train_loader)
epoch_acc = running_acc / len(self.train_loader)
print(f"train loss: {epoch_loss:.5f} train acc: {epoch_acc:.5f}")
return epoch_loss, epoch_acc
def get_net(cf_net, parent_snapshot, gpu):
if parent_snapshot:
net = main.load_snapshot(parent_snapshot)
else:
net = getattr(main, cf_net['call'])(**dict_drop(cf_net, 'call'))
if isinstance(gpu, int):
net.to(device(gpu))
else:
net = torch.nn.DataParallel(net, gpu)
net.to(device(gpu[0]))
return net
def multiexit_error_coocc(net, n_exits, val_iter, gpu):
errors = torch.zeros(n_exits, n_exits)
net.to(device(gpu))
for X, y in val_iter:
logits_list = net.train(False)(X.to(device(gpu)))
err = [logits.max(dim=1)[1].cpu() != y for logits in logits_list]
for i in range(n_exits):
for j in range(i, n_exits):
errors[i][j] += (err[i] * err[j]).float().sum()
del net
for i in range(n_exits):
for j in range(i):
errors[i][j] = errors[j][i]
return errors
def train(self, train_dataset, test_dataset, tokenizer, output_dir):
model = BertForSequenceClassification.from_pretrained(
'bert-base-uncased')
model.to(device())
self.full_train(train_dataset, test_dataset, model, tokenizer,
output_dir)
return model
def epoch_train_func(
self,
model,
dataset,
optimizer,
scheduler,
):
train_loss = 0.0
train_sampler = RandomSampler(dataset)
data = DataLoader(dataset,
sampler=train_sampler,
batch_size=self.settings['train_batch_size'])
for step, batch in enumerate(tqdm(data, desc="Iteration")):
model.train()
batch = tuple(t.to(device()) for t in batch)
inputs = batch_to_inputs(batch)
outputs = model(**inputs)
loss = outputs[0]
loss.backward()
train_loss += loss.item()
optimizer.step()
model.zero_grad()
scheduler.step()
return train_loss / len(data)
def train(self, X, y, y_real, output_dir):
X_split = [normalize(t.split()) for t in X]
split_arrays = train_test_split(X_split, y, y_real, test_size=self.settings['test_size'], stratify=y_real)
X_train, X_test, y_train, y_test, y_real_train, y_real_test = split_arrays
text_field = data.Field()
text_field.build_vocab(X_train, max_size=10000)
# pad
X_train_pad = [pad(s, self.settings['max_seq_length']) for s in tqdm(X_train, desc='pad')]
X_test_pad = [pad(s, self.settings['max_seq_length']) for s in tqdm(X_test, desc='pad')]
# to index
X_train_index = [to_indexes(text_field.vocab, s) for s in tqdm(X_train_pad, desc='to index')]
X_test_index = [to_indexes(text_field.vocab, s) for s in tqdm(X_test_pad, desc='to index')]
train_dataset = self.to_dataset(X_train_index, y_train, y_real_train)
val_dataset = self.to_dataset(X_test_index, y_test, y_real_test)
model = self.model(text_field)
model.to(device())
self.full_train(model, train_dataset, val_dataset, output_dir)
torch.save(text_field, os.path.join(output_dir, self.vocab_name))
return model, text_field.vocab
def evaluate(self, model, eval_dataset, epoch):
train_settings = self.settings
eval_sampler = SequentialSampler(eval_dataset)
data_loader = DataLoader(eval_dataset,
sampler=eval_sampler,
batch_size=train_settings['eval_batch_size'])
eval_loss = 0.0
acc = 0.0
num_examples = 0
model.eval()
predictions = None
labels = None
for batch in tqdm(data_loader, desc="Evaluating"):
batch = tuple(t.to(device()) for t in batch)
with torch.no_grad():
inputs = batch_to_inputs(batch)
outputs = model(**inputs)
tmp_eval_loss, logits = outputs[:2]
eval_loss += tmp_eval_loss.item()
probs = torch.softmax(logits, dim=1)
pred_label = torch.argmax(logits, dim=1)
acc += torch.sum(pred_label == batch[3]).cpu().numpy()
num_examples += len(batch[3])
predictions, labels = self.stack(predictions, labels, probs,
batch[3])
self.log_pr(labels, predictions, epoch)
return eval_loss / len(data_loader), acc / num_examples
def __init__(self,
model,
criterion,
optimizer,
train_loader,
val_loader=None,
name="experiment",
experiments_dir="runs",
save_dir=None,
div_lr=1):
self.device = device()
self.model = model.to(self.device)
self.criterion = criterion
self.optimizer = optimizer
self.train_loader = train_loader
self.val_loader = val_loader
self.div_lr = div_lr
self.update_lr(self.optimizer.defaults['lr'])
self._epoch_count = 0
self._best_loss = None
self._best_acc = None
if save_dir is None:
save_dir = f"{self.get_num_dir(experiments_dir):04d}-{get_git_hash()}-{name}"
self._save_dir = os.path.join(experiments_dir, save_dir)
self.writer = Logger(self._save_dir)
atexit.register(self.cleanup)
def evaluate(model: nn.Module,
dataset: Dataset,
pretrained: bool = False,
visualizer: Visualizer = None) -> None:
loader = DataLoader(dataset,
batch_size=dataset.BATCH_SIZE,
shuffle=dataset.SHUFFLE)
if pretrained:
model.load_state_dict(
torch.load(os.path.join(config.LOG_PATH, config.NAME)))
logger.info("[+] Evaluating model...")
imgize = torchvision.transforms.ToPILImage()
with torch.no_grad():
model.eval()
for batch_idx, samples in enumerate(loader):
images, raw_path = device(
[samples['image']], gpu=config.USE_GPU)[0], samples['raw_path']
outputs = model(images)['out']
output_mask = outputs.argmax(1)
for mask, path in zip(output_mask, raw_path):
_mask = torch.where(mask == 1,
torch.ones_like(mask) * 255,
torch.zeros_like(mask)).byte()
_mask = imgize(_mask.cpu())
filename = os.path.basename(path)
_mask.save(os.path.join(config.OUT_PATH, filename))
logger.info("[+] Done.")
def test(self, test_loader):
self.model.eval()
running_loss = 0
running_acc = 0
for iter, (inputs, targets) in enumerate(tqdm(test_loader)):
inputs = inputs.to(device())
targets = targets.to(device())
with torch.set_grad_enabled(False):
outputs = self.model(inputs)
batch_loss = self.criterion(outputs, targets)
batch_acc = accuracy(outputs, targets)
running_loss += batch_loss.item()
running_acc += batch_acc.item()
epoch_loss = running_loss / len(test_loader)
epoch_acc = running_acc / len(test_loader)
print(f"test loss: {epoch_loss:.5f} test acc: {epoch_acc:.5f}")
return epoch_loss, epoch_acc
def multiexit_agreement(net, n_exits, val_iter, gpu):
agreements = torch.zeros(n_exits, n_exits, device=device(gpu))
net.to(device(gpu))
n = 0
for X, y in val_iter:
logits_list = net.train(False)(X.to(device(gpu)))
pred = [logits.max(dim=1)[1] for logits in logits_list]
n += len(pred[0])
for i in range(n_exits):
for j in range(i + 1, n_exits):
agreements[i][j] += (pred[i] == pred[j]).float().sum()
del net
for i in range(n_exits):
agreements[i][i] = n
for j in range(i):
agreements[i][j] = agreements[j][i]
return agreements.cpu()
def main_FCNN():
# Step 01: Get Input Resources and Model Configuration
parser = app_argparse()
args = parser.parse_args()
print(args)
INPUT_IMAGE_PATH = args.input_RGB
LABEL_IMAGE_PATH = args.input_GT
WEIGHTS_FILE_PATH = args.output_model_path
LOSS_PLOT_PATH = args.output_loss_plot
use_gpu = args.use_gpu
use_pretrain = args.use_pretrain
epochs = args.epochs
batch_size = args.batch_size
tile_size = args.tile_size
learning_rate = args.learning_rate
weight_decay = args.weight_decay
# Step 02: load the pretrained model
device = utils.device(use_gpu=use_gpu)
# init model structure
model = FCNN()
# model = utils.load_weights_from_disk(model)
if use_pretrain:
model = utils.load_entire_model(model, WEIGHTS_FILE_PATH, use_gpu)
print("use pretrained model!")
train_loader = dataset.training_loader(
image_path=INPUT_IMAGE_PATH,
label_path=LABEL_IMAGE_PATH,
batch_size=batch_size,
tile_size=tile_size,
shuffle=True # use shuffle
) # turn the shuffle
model, stats = train(
model=model,
train_loader=train_loader,
device=device,
epochs=epochs,
batch_size=batch_size,
tile_size=tile_size,
learning_rate=learning_rate,
weight_decay=weight_decay,
)
# comment the following section to compare the results with 4 workers and pin_memory in dataloader.
# Step 03: save the model
# model_path = utils.save_weights_to_disk(model)
model_path = utils.save_entire_model(model, WEIGHTS_FILE_PATH)
# save the loss figure and data
stats.save_loss_plot(LOSS_PLOT_PATH)
def evaluate(cf_test, cf_loss, batch_size, snapshot_name, gpu):
net = main.load_snapshot(snapshot_name).to(device(gpu))
loss_f = getattr(main, cf_loss['call'])(**dict_drop(cf_loss, 'call'))
Data = getattr(main, cf_test['call'])
test_iter = Data(split='test', batch_size=batch_size, gpu=gpu,
**dict_drop(cf_test, 'call'))
print('\t'.join(loss_f.metric_names))
val_metrics = main.validate(loss_f, net, test_iter, gpu)
print(utils.tab_str(*val_metrics))
def main_UNet_II():
# TODO: Get through CLI arg
# Step 01: Get Input Resources and Model Configuration
parser = app_argparse()
args = parser.parse_args()
# print(args)
use_gpu = args.use_gpu
# tile_size = args.tile_size
tile_size = (200, 200)
INPUT_IMAGE_PATH = args.input_RGB
LABEL_IMAGE_PATH = args.input_GT
# WEIGHTS_FILE_PATH = args.output_model_path
WEIGHTS_FILE_PATH = "weights/Adam.UNet.weights.II.pt"
OUTPUT_IMAGE_PATH = args.output_images
# Step 02: Get Input Resources and Model Configuration
device = utils.device(use_gpu=use_gpu)
model = UNet()
# model = utils.load_weights_from_disk(model)
model = utils.load_entire_model(model, WEIGHTS_FILE_PATH, use_gpu)
print("use pretrained model!")
# print(model)
# summary(model, (3, tile_size[0], tile_size[1]))
# this is issue !!!
loader = dataset.full_image_loader(
INPUT_IMAGE_PATH, LABEL_IMAGE_PATH, tile_size=tile_size)
prediction = predict(model, loader, device=device,
class_label=ClassLabel.house)
# Step 03: save the output
input_image = utils.input_image(INPUT_IMAGE_PATH)
pred_image, mask_image = utils.overlay_class_prediction(
input_image, prediction)
pred_image_path = OUTPUT_IMAGE_PATH + "/prediction.png"
pred_image.save(pred_image_path)
pred_mask_path = OUTPUT_IMAGE_PATH + "/mask.png"
mask_image.save(pred_mask_path)
print("(i) Prediction and Mask image saved at {}".format(pred_image_path))
print("(ii) Mask image saved at {}".format(pred_mask_path))
# Step 04: Check the metrics
img_gt = np.array(Image.open(LABEL_IMAGE_PATH), dtype=np.int32)
img_mask = np.array(Image.open(pred_mask_path), dtype=np.int32)
metricComputation(img_gt, img_mask)
def evaluate_dataset(model, dataloader):
model.eval()
running_metrics = None
for images_lowres, images_fullres, targets in dataloader:
images_lowres, images_fullres, targets = utils.device(
[images_lowres, images_fullres, targets])
with torch.no_grad():
predictions = model(images_lowres, images_fullres)
psnr = compute_psnr(predictions, targets)
running_metrics = utils.update_metrics(running_metrics, {'psnr': psnr},
len(dataloader))
model.train()
return running_metrics
def train(cf_trn, cf_val, cf_opt, cf_loss,
cf_scheduler, batch_size, val_batch_size, gpu, n_epochs,
parent_snapshot, snapshot_name, save_interval):
torch.backends.cudnn.benchmark = True
main_gpu = gpu if isinstance(gpu, int) else gpu[0]
dvc = device(main_gpu)
net = get_net()
loss_f = getattr(main, cf_loss['call'])(**dict_drop(cf_loss, 'call'))
Opt = getattr(torch.optim, cf_opt['call'])
opt = Opt(net.parameters(), **dict_drop(cf_opt, 'call'))
ep = int(parent_snapshot.split('_')[-1][2:]) if parent_snapshot else 0
Scheduler = getattr(torch.optim.lr_scheduler, cf_scheduler['call'])
scheduler = Scheduler(opt, last_epoch=-1,
**dict_drop(cf_scheduler, 'call'))
for i in range(ep): scheduler.step()
Data = getattr(main, cf_trn['call'])
trn_iter = Data(split='train', batch_size=batch_size, gpu=main_gpu,
**dict_drop(cf_trn, 'call'))
Data = getattr(main, cf_val['call'])
val_iter = Data(split='val', batch_size=val_batch_size, gpu=main_gpu,
**dict_drop(cf_val, 'call'))
if save_interval:
saver = utils.IntervalSaver(snapshot_name, ep, save_interval)
else:
saver = utils.RecordSaver(snapshot_name, ep)
print('\t'.join(['ep', 'loss'] + loss_f.metric_names))
while ep < n_epochs:
scheduler.step()
for trn_tuple in trn_iter:
trn_tuple = [t.to(dvc) for t in trn_tuple]
opt.zero_grad()
loss = loss_f(net.train(True), *trn_tuple, ep)
loss.backward()
opt.step()
ep += 1
trn_metrics = loss_f.trn_metrics()
val_metrics = main.validate(loss_f, net, val_iter, main_gpu)
print(utils.tab_str(ep, loss, *trn_metrics))
print(utils.tab_str('', 0.0, *val_metrics))
saver.save(val_metrics[0], net, main_gpu, ep)
del net, opt, trn_iter, val_iter
def update(self, labels_true, labels_pred):
def _hist(l_true, l_pred):
mask = (l_true >= 0) & (l_true < self.n_classes)
hist = np.bincount(
self.n_classes * l_true[mask].astype(int) + l_pred[mask],
minlength=self.n_classes**2).reshape(self.n_classes,
self.n_classes)
return hist
_labels_true, _labels_pred = device([labels_true, labels_pred],
gpu=False,
numpy=True)
for lt, lp in zip(_labels_true, _labels_pred):
self.confusion_matrix += _hist(lt.flatten(), lp.flatten())
def dev_model(args): # modified from __main__ in train.py
# Get the arguments from GUI
INPUT_IMAGE_PATH = args.input_RGB
LABEL_IMAGE_PATH = args.input_GT
WEIGHTS_FILE_PATH = args.output_model_path
LOSS_PLOT_PATH = args.output_loss_plot
use_gpu = args.use_gpu
use_pretrain = args.use_pretrain
epochs = args.epochs
batch_size = args.batch_size
tile_size = (args.tile_size_height, args.tile_size_width)
learning_rate = args.learning_rate
weight_decay = args.weight_decay
device = utils.device(use_gpu=use_gpu)
# init model structure
model = FCNN()
# model = utils.load_weights_from_disk(model)
if use_pretrain:
model = utils.load_entire_model(model, WEIGHTS_FILE_PATH, use_gpu)
print("use pretrained model!")
train_loader = dataset.training_loader(
image_path=INPUT_IMAGE_PATH,
label_path=LABEL_IMAGE_PATH,
batch_size=batch_size,
tile_size=tile_size,
shuffle=True, # use shuffle
) # turn the shuffle
model, stats = train(
model=model,
train_loader=train_loader,
device=device,
epochs=epochs,
batch_size=batch_size,
tile_size=tile_size,
learning_rate=learning_rate,
weight_decay=weight_decay,
)
# model_path = utils.save_weights_to_disk(model)
model_path = utils.save_entire_model(model, WEIGHTS_FILE_PATH)
# save the loss figure and data
stats.save_loss_plot(LOSS_PLOT_PATH)
print("[>>>] Passed!")
def train(model: nn.Module,
dataset: Dataset,
validate_data: Dataset = None) -> None:
loader = DataLoader(dataset,
batch_size=dataset.BATCH_SIZE,
shuffle=dataset.BATCH_SIZE)
optimizer = getattr(torch.optim,
config.TRAIN.OPTIMIZER)(model.parameters(),
**config.TRAIN.OPTIM_PARAMS)
overall_iter = 0
evaluation = ConfusionMatrix(dataset.get_num_class())
model.train()
for epoch in range(config.TRAIN.NUM_EPOCHS):
total_loss = 0
for batch_idx, samples in enumerate(loader):
images, target = device([samples['image'], samples['mask']],
gpu=config.USE_GPU)
outputs = model(images)['out']
output_mask = outputs.argmax(1)
batch_loss = Loss.cross_entropy2D(outputs, target, False)
total_loss += batch_loss.item()
overall_loss = total_loss / ((batch_idx + 1))
evaluation.update(output_mask, target)
optimizer.zero_grad()
batch_loss.backward()
optimizer.step()
if batch_idx % config.PRINT_BATCH_FREQ == 0:
metrics = evaluation()
logger.info(f'Train Epoch: {epoch}, {batch_idx}')
logger.info(
f'Batch loss: {batch_loss.item():.6f}, Overall loss: {overall_loss:.6f}'
)
for met in beautify(metrics[0]):
logger.info(f'{met}')
logger.info(f'Classwise IoU')
for met in beautify(metrics[1]):
logger.info(f'{met}')
logger.info("\n")
overall_iter += 1
if config.SAVE_ITER_FREQ and overall_iter % config.SAVE_ITER_FREQ == 0:
torch.save(
model.state_dict(),
os.path.join(config.LOG_PATH,
config.NAME + f"-iter={overall_iter}"))
def _validate_epoch(self):
self.model.eval()
running_loss = 0
running_acc = 0
for iter, (inputs, targets) in enumerate(tqdm(self.val_loader)):
inputs = inputs.to(device())
targets = targets.to(device())
with torch.set_grad_enabled(False):
outputs = self.model(inputs)
batch_loss = self.criterion(outputs, targets)
batch_acc = accuracy(outputs, targets)
running_loss += batch_loss.item()
running_acc += batch_acc.item()
if self.log_every(iter):
self.writer.add_scalars(
"loss", {"val_loss": running_loss / float(iter + 1)},
(self._epoch_count - 1) * len(self.val_loader) + iter)
self.writer.add_scalars(
"acc", {"val_acc": running_acc / float(iter + 1)},
(self._epoch_count - 1) * len(self.val_loader) + iter)
epoch_loss = running_loss / len(self.val_loader)
epoch_acc = running_acc / len(self.val_loader)
print(f"val loss: {epoch_loss:.5f} val acc: {epoch_acc:.5f}")
return epoch_loss, epoch_acc
optimizer.zero_grad()
loss.backward()
optimizer.step()
return model, training_stats
if __name__ == '__main__':
# TODO: Get through CLI args
epochs = 100
batch_size = 1
use_gpu = True
tile_size = (256, 256)
device = utils.device(use_gpu=use_gpu)
model = UNet()
train_loader = dataset.training_loader(batch_size=batch_size,
tile_size=tile_size)
model, stats = train(model=model,
train_loader=train_loader,
device=device,
epochs=epochs,
batch_size=batch_size,
tile_size=tile_size)
model_path = utils.save_weights_to_disk(model)
print('(i) Model saved at {}'.format(model_path))
n_epochs, train_loader, test_loader, model, optimizer, scheduler = conf.params(
)
print_freq = 50
best_metrics = None
running_metrics = None
for epoch in range(1, n_epochs + 1):
print('Starting epoch: %d' % epoch)
scheduler.step()
for batch, (images_lowres, images_fullres,
targets) in enumerate(train_loader):
step_num = utils.step_num(epoch, batch, train_loader)
images_lowres, images_fullres, targets = utils.device(
[images_lowres, images_fullres, targets])
predictions = model(images_lowres, images_fullres)
loss = F.mse_loss(predictions, targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
running_metrics = utils.update_metrics(
running_metrics, {
'mse': loss.item(),
'psnr': compute_psnr_from_mse(loss)
}, print_freq)
if (step_num + 1) % print_freq == 0:
def train(self, train_dataset, tokenizer, output_dir):
model = BertForSequenceClassification.from_pretrained(
'/export/home/yug125/lzh/simple_version/bert-base-uncased')
model.to(device())
self.full_train(train_dataset, model, tokenizer, output_dir)
return model
from utils import parse_train_args, load_data, device
from model import build_model, build_adam_optimizer, build_nllloss_criterion, train_model, save_check_point
# Parse command-line arguments
args = parse_train_args()
# Train and validation data loaders
train_data_loader = load_data(args.data_dir, 'train')
validation_data_loader = load_data(args.data_dir, 'valid')
# Device
device = device(args.gpu)
# Build model, optimizer, criterion
model = build_model(arch=args.arch,
hidden_units=args.hidden_units,
device=device)
optimizer = build_adam_optimizer(model, learning_rate=args.learning_rate)
criterion = build_nllloss_criterion()
# Train model, evaluate and print result
train_model(model, criterion, optimizer, args.epochs, train_data_loader,
validation_data_loader, device, 40)
# Save check point of the model
check_point_file_name_prefix = 'check_point'
check_point_file_ext = '.pth'
save_check_point(
model, optimizer, args.save_dir + '/' + check_point_file_name_prefix +
'_' + args.arch + check_point_file_ext)
set_seed(3)
# 1. get data
train_df = pd.read_csv(TRAIN_FILE, encoding='utf-8', sep='\t')
bert_model = BertForSequenceClassification.from_pretrained(ROOT_DATA_PATH)
UNCASED = '/export/home/yug125/lzh/simple_version/bert-base-uncased/' # your path for model and vocab
VOCAB = 'bert-base-uncased-vocab.txt'
tokenizer = BertTokenizer.from_pretrained(os.path.join(UNCASED, VOCAB))
train_dataset = df_to_dataset(train_df, tokenizer, distillation_settings['max_seq_length'])
sampler = SequentialSampler(train_dataset)
data = DataLoader(train_dataset, sampler=sampler, batch_size=distillation_settings['train_batch_size'])
bert_model.to(device())
bert_model.eval()
bert_logits = None
for batch in tqdm(data, desc="bert logits"):
batch = tuple(t.to(device()) for t in batch)
inputs = batch_to_inputs(batch)
with torch.no_grad():
outputs = bert_model(**inputs)
_, logits = outputs[:2]
logits = logits.cpu().numpy()
if bert_logits is None:
bert_logits = logits
def validate(loss_f, net, val_iter, gpu):
metrics = []
for val_tuple in val_iter:
val_tuple = [t.to(device(gpu)) for t in val_tuple]
metrics += [loss_f.metrics(net, *val_tuple)]
return [sum(metric) / len(metric) for metric in zip(*metrics)]
def main_UNet_via_Folder():
# Step 01: Get Input Resources and Model Configuration
parser = app_argparse()
args = parser.parse_args()
# INPUT_IMAGE_PATH = args.input_RGB
# LABEL_IMAGE_PATH = args.input_GT
INPUT_IMAGE_PATH = "data/Aerial/RGBRandom"
LABEL_IMAGE_PATH = "data/Aerial/GTRandom"
# WEIGHTS_FILE_PATH = args.output_model_path
WEIGHTS_FILE_PATH = "weights/Adam.UNet.weights.II.pt"
# LOSS_PLOT_PATH = args.output_loss_plot
OUTPUT_IMAGE_PATH = args.output_images
print(args)
use_gpu = args.use_gpu
use_pretrain = True
# epochs = args.epochs
epochs = 10
batch_size = args.batch_size
tile_size = args.tile_size
learning_rate = args.learning_rate
weight_decay = args.weight_decay
# Step 02: load the pretrained model
device = utils.device(use_gpu=use_gpu)
# init model structure
model = UNet()
# model = utils.load_weights_from_disk(model)
if use_pretrain and Path(WEIGHTS_FILE_PATH).is_file():
model = utils.load_entire_model(model, WEIGHTS_FILE_PATH, use_gpu)
print("use pretrained model!")
else:
print("build new model")
train_loader = dataset.create_image_loader(
image_path=INPUT_IMAGE_PATH,
label_path=LABEL_IMAGE_PATH,
batch_size=batch_size,
shuffle=True # use shuffle
) # turn the shuffle
model, stats = train(
model=model,
train_loader=train_loader,
device=device,
epochs=epochs,
batch_size=batch_size,
tile_size=tile_size,
learning_rate=learning_rate,
weight_decay=weight_decay,
)
# comment the following section to compare the results with 4 workers and pin_memory in dataloader.
# Step 03: save the model
# model_path = utils.save_weights_to_disk(model)
model_path = utils.save_entire_model(model, WEIGHTS_FILE_PATH)
# save the loss figure and data
stats.save_loss_plot(OUTPUT_IMAGE_PATH)
def predict(net, X, gpu):
X = X.to(device(gpu))
net.to(device(gpu))
_, pred = net.train(False)(X).max(dim=1)
return pred.cpu().numpy()
def unwrap_input(outputs, inputs):
return outputs, inputs['class_id'].to(device())
def to_device(text, bert_prob, real_label):
text = text.to(device())
bert_prob = bert_prob.to(device())
real_label = real_label.to(device())
return text, bert_prob, real_label
