def load_models(model_filenames, device=None):
models = []
for filename in model_filenames:
model = M.ResNet34()
modelfile = str(model_dir / filename)
weight = torch.load(modelfile)
model.load_state_dict(weight)
model.to(device)
model.eval()
models.append(model)
print(f'Loaded: {modelfile}')
return models
def main():
args = parse_args()
train_dataset, test_dataset = dataset.get_dataset(args.path,
args.use_augmentation,
args.use_fivecrop)
train_loader = DataLoader(train_dataset,
args.batch,
True,
num_workers=args.worker,
pin_memory=True)
test_loader = DataLoader(test_dataset,
args.batch,
False,
num_workers=args.worker,
pin_memory=True)
if args.cuda:
torch.cuda.set_device(0)
device = torch.device('cuda')
else:
device = torch.device('cpu')
if args.model == 'ResNet18':
mymodel = model.ResNet18(args.frozen_layers).to(device)
elif args.model == 'ResNet34':
mymodel = model.ResNet34(args.frozen_layers).to(device)
elif args.model == 'ResNet50':
mymodel = model.ResNet50(args.frozen_layers).to(device)
elif args.model == 'DenseNet':
mymodel = model.DenseNet().to(device)
else:
pass
op = optim.Adam(mymodel.parameters(), lr=args.lr)
train_losses, test_mF1s, test_precisions, test_recalls = [], [], [], []
early = args.early
for i in range(args.epoch):
train_loss = train.train(mymodel, op, train_loader, i, device,
args.log, utils.pos_weight)
mF1, recall, presicion = test.test(mymodel, test_loader, device,
args.use_fivecrop)
train_losses.append(train_loss)
test_mF1s.append(mF1)
test_precisions.append(presicion)
test_recalls.append(recall)
early = utils.early_stop(test_mF1s, early)
if early <= 0:
break
utils.save_log(mymodel, train_losses, test_mF1s, test_precisions,
test_recalls)
batch_size=args.batch_size,
shuffle=True,
num_workers=20)
NUM_CLASSES = DATASET.num_classes
print('Data path: ' + args.data_path)
print('Number of classes: %d' % NUM_CLASSES)
print('Batch size: %d' % args.batch_size)
print('Epoch size: %d' % args.epoch_size)
num_batches = len(DATALOADER)
batch_total = num_batches * args.epoch_size
if args.model == 'ResNet18':
MODEL = model.ResNet18(pseudo=args.pseudo)
elif args.model == 'ResNet34':
MODEL = model.ResNet34(pseudo=args.pseudo)
elif args.model == 'ResNet50':
MODEL = model.ResNet50(pseudo=args.pseudo)
elif args.model == 'ResNet101':
MODEL = model.ResNet101(pseudo=args.pseudo)
ARCFACE = lossfunction.Arcface(512, NUM_CLASSES)
if args.optim == 'Adam':
OPTIMIZER = torch.optim.Adam([{
'params': MODEL.parameters()
}, {
'params': ARCFACE.parameters()
}],
lr=1e-4)
SCHEDULER = torch.optim.lr_scheduler.MultiStepLR(OPTIMIZER,
from torch.optim.lr_scheduler import ReduceLROnPlateau
from pre_process import transform_train, transform_test
# whether use gpu
use_cuda = torch.cuda.is_available()
# default parameters
DATA_ROOT = '../data/'
num_epochs = 50
batch_size = 128
model_names = {
'dnn': model.DNN(3072, 4096, 10),
'cnn': model.CNN(),
'resnet18': model.ResNet18(),
'resnet34': model.ResNet34(),
'resnet50': model.ResNet50()
}
def get_args():
parser = argparse.ArgumentParser()
parser.add_argument('--model_type',
type=str,
default='dnn',
help="the type of model")
parser.add_argument('--lr',
type=float,
default=0.1,
help='the initial learning rate')
parser.add_argument('--batch_size',
def main(args):
#device configuration
if args.cpu != None:
device = torch.device('cpu')
elif args.gpu != None:
if not torch.cuda_is_available():
print("GPU / cuda reported as unavailable to torch")
exit(0)
device = torch.device('cuda')
else:
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Create model directory
if not os.path.exists(args.model_save_dir):
os.makedirs(args.model_save_dir)
train_data = ld.get_data(labels_file=args.labels_file,
root_dir=args.train_image_dir,
mode="absolute")
validation_data = ld.get_data(labels_file=args.labels_file,
root_dir=args.validation_image_dir,
mode="absolute")
train_loader = DataLoader(dataset=train_data,
batch_size=args.batch_size,
shuffle=True)
val_loader = DataLoader(dataset=validation_data,
batch_size=args.validation_batch_size)
# Build the models
if args.num_layers != None and args.block_type != None:
if args.block_type == "bottleneck":
net = model.ResNet(model.Bottleneck,
args.num_layers,
dropout=args.dropout)
else:
net = model.ResNet(model.BasicBlock,
args.num_layers,
dropout=args.dropout)
else:
if args.resnet_model == 152:
net = model.ResNet152(args.dropout)
elif args.resnet_model == 101:
net = model.ResNet101(args.dropout)
elif args.resnet_model == 50:
net = model.ResNet50(args.dropout)
elif args.resnet_model == 34:
net = model.ResNet34(args.dropout)
else:
net = model.ResNet101(args.dropout)
#load the model to the appropriate device
net = net.to(device)
params = net.parameters()
# Loss and optimizer
criterion = nn.MSELoss() #best for regression
if args.optim != None:
if args.optim == "adadelta":
optimizer = torch.optim.Adadelta(params, lr=args.learning_rate)
if args.optim == "adagrad":
optimizer = torch.optim.Adagrad(params, lr=args.learning_rate)
if args.optim == "adam":
optimizer = torch.optim.Adam(params, lr=args.learning_rate)
if args.optim == "adamw":
optimizer = torch.optim.AdamW(params, lr=args.learning_rate)
if args.optim == "rmsprop":
optimizer = torch.optim.RMSProp(params, lr=args.learning_rate)
if args.optim == "sgd":
optimizer = torch.optim.SGD(params, lr=args.learning_rate)
else:
optimizer = torch.optim.Adam(params, lr=args.learning_rate)
val_acc_history = []
train_acc_history = []
failed_runs = 0
prev_loss = float("inf")
for epoch in range(args.num_epochs):
running_loss = 0.0
total_loss = 0.0
for i, (inputs, labels) in enumerate(train_loader, 0):
net.train()
#adjust to output image coordinates
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = net(inputs.float())
loss = criterion(outputs.float(), labels.float())
loss.backward()
torch.nn.utils.clip_grad_norm_(net.parameters(),
args.clipping_value)
optimizer.step()
running_loss += loss.item()
total_loss += loss.item()
if i % 2 == 0: #print every mini-batches
print('[%d, %5d] loss: %.5f' %
(epoch + 1, i + 1, running_loss / 2))
running_loss = 0.0
loss = 0.0
#compute validation loss at the end of the epoch
for i, (inputs, labels) in enumerate(val_loader, 0):
inputs, labels = inputs.to(device), labels.to(device)
net.eval()
with torch.no_grad():
outputs = net(inputs.float())
loss += criterion(outputs, labels.float()).item()
print("------------------------------------------------------------")
print("Epoch %5d" % (epoch + 1))
print("Training loss: {}, Avg Loss: {}".format(
total_loss, total_loss / train_data.__len__()))
print("Validation Loss: {}, Avg Loss: {}".format(
loss, loss / validation_data.__len__()))
print("------------------------------------------------------------")
val_acc_history.append(loss)
train_acc_history.append(total_loss)
#save the model at the desired step
if (epoch + 1) % args.save_step == 0:
torch.save(net.state_dict(),
args.model_save_dir + "resnet" + str(epoch + 1) + ".pt")
##stopping conditions
if failed_runs > 5 and prev_loss < loss:
break
elif prev_loss < loss:
failed_runs += 1
else:
failed_runs = 0
prev_loss = loss
#create a plot of the loss
plt.title("Training vs Validation Accuracy")
plt.xlabel("Training Epochs")
plt.ylabel("Loss")
plt.plot(range(1,
len(val_acc_history) + 1),
val_acc_history,
label="Validation loss")
plt.plot(range(1,
len(train_acc_history) + 1),
train_acc_history,
label="Training loss")
plt.xticks(np.arange(1, len(train_acc_history) + 1, 1.0))
plt.legend()
plt.ylim((0, max([max(val_acc_history), max(train_acc_history)])))
if args.save_training_plot != None:
plt.savefig(args.save_training_plot + "loss_plot.png")
plt.show()
print('Finished Training')