def fine_tune_model(num_epochs, data_dir, learning_rate, momentum):
"""Load a pretrained model and reset the final fully connected layer."""
# log the hyperparameter metrics to the AML run
run.log('lr', np.float(learning_rate))
run.log('momentum', np.float(momentum))
model_ft = models.resnet18(pretrained=True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, 2) # only 2 classes to predict
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model_ft = model_ft.to(device)
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
optimizer_ft = optim.SGD(model_ft.parameters(),
lr=learning_rate, momentum=momentum)
# Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(
optimizer_ft, step_size=7, gamma=0.1)
model = train_model(model_ft, criterion, optimizer_ft,
exp_lr_scheduler, num_epochs, data_dir)
return model
def resnet18(num_classes=1000, pretrained='imagenet'):
"""Constructs a ResNet-18 model.
"""
model = models.resnet18(pretrained=False)
if pretrained is not None:
settings = pretrained_settings['resnet18'][pretrained]
model = load_pretrained(model, num_classes, settings)
return model
def __init__(self, latent_dim):
super(Encoder, self).__init__()
resnet18_model = resnet18(pretrained=True)
# Extracts features at the last fully-connected
self.feature_extractor = nn.Sequential(*list(resnet18_model.children())[:-3])
self.pooling = nn.AvgPool2d(kernel_size=8, stride=8, padding=0)
# Output is mu and log(var) for reparameterization trick used in VAEs
self.fc_mu = nn.Linear(256, latent_dim)
self.fc_logvar = nn.Linear(256, latent_dim)
def __init__(self): super(ResNet18Fc, self).__init__() model_resnet18 = models.resnet18(pretrained=True) self.conv1 = model_resnet18.conv1 self.bn1 = model_resnet18.bn1 self.relu = model_resnet18.relu self.maxpool = model_resnet18.maxpool self.layer1 = model_resnet18.layer1 self.layer2 = model_resnet18.layer2 self.layer3 = model_resnet18.layer3 self.layer4 = model_resnet18.layer4 self.avgpool = model_resnet18.avgpool self.__in_features = model_resnet18.fc.in_features
def __init__(self, requires_grad=False, pretrained=True, num=18):
super(resnet, self).__init__()
if(num==18):
self.net = models.resnet18(pretrained=pretrained)
elif(num==34):
self.net = models.resnet34(pretrained=pretrained)
elif(num==50):
self.net = models.resnet50(pretrained=pretrained)
elif(num==101):
self.net = models.resnet101(pretrained=pretrained)
elif(num==152):
self.net = models.resnet152(pretrained=pretrained)
self.N_slices = 5
self.conv1 = self.net.conv1
self.bn1 = self.net.bn1
self.relu = self.net.relu
self.maxpool = self.net.maxpool
self.layer1 = self.net.layer1
self.layer2 = self.net.layer2
self.layer3 = self.net.layer3
self.layer4 = self.net.layer4
def load_arch(arch):
"""
Load a pretrained network
"""
if arch == 'vgg16':
model = models.vgg16(pretrained=True)
input_size = 25088
elif arch == 'alexnet':
model = models.alexnet(pretrained=True)
input_size = 9216
elif arch == 'resnet18':
model = models.resnet18(pretrained=True)
input_size = 512
elif arch == 'densenet121':
model = models.densenet121(pretrained=True)
input_size = 1024
else:
raise ValueError('Please choose one of \'vgg16\', \'alexnet\', \'resnet18\' or , \'densenet121\' for parameter arch.')
for param in model.parameters():
param.requires_grad = False
return model, input_size
def main(args):
# 1. prepare data & models
# augmentor = RandomAugmentation(BrightnessContrastAugmenter(), BlurAugmenter())
train_transforms = transforms.Compose([
ScaleMinSideToSize((CROP_SIZE, CROP_SIZE)),
CropCenter(CROP_SIZE),
TransformByKeys(transforms.ToPILImage(), ("image", )),
TransformByKeys(transforms.ToTensor(), ("image", )),
TransformByKeys(
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
("image", )),
])
print("Reading data...")
train_dataset = ThousandLandmarksDataset(os.path.join(args.data, 'train'),
train_transforms,
split="train")
train_dataloader = data.DataLoader(train_dataset,
batch_size=args.batch_size,
num_workers=4,
pin_memory=True,
shuffle=True,
drop_last=True)
val_dataset = ThousandLandmarksDataset(os.path.join(args.data, 'train'),
train_transforms,
split="val")
val_dataloader = data.DataLoader(val_dataset,
batch_size=args.batch_size,
num_workers=4,
pin_memory=True,
shuffle=False,
drop_last=False)
print("Creating model...")
device = torch.device("cuda: 0") if args.gpu else torch.device("cpu")
model = models.resnet18(pretrained=True)
model.fc = nn.Linear(model.fc.in_features, 2 * NUM_PTS, bias=True)
model.to(device)
optimizer = optim.Adam(model.parameters(),
lr=args.learning_rate,
amsgrad=True)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
patience=2,
factor=0.5)
loss_fn = fnn.mse_loss
# 2. train & validate
print("Ready for training...")
best_val_loss = np.inf
for epoch in range(args.epochs):
train_loss = train(model,
train_dataloader,
loss_fn,
optimizer,
device=device)
val_loss = validate(model, val_dataloader, loss_fn, device=device)
scheduler.step(val_loss)
print("Epoch #{:2}:\ttrain loss: {:5.3}\tval loss: {:5.3}".format(
epoch, train_loss, val_loss))
if val_loss < best_val_loss:
best_val_loss = val_loss
with open(f"{args.name}_best.pth", "wb") as fp:
torch.save(model.state_dict(), fp)
# 3. predict
test_dataset = ThousandLandmarksDataset(os.path.join(args.data, 'test'),
train_transforms,
split="test")
test_dataloader = data.DataLoader(test_dataset,
batch_size=args.batch_size,
num_workers=4,
pin_memory=True,
shuffle=False,
drop_last=False)
with open(f"{args.name}_best.pth", "rb") as fp:
best_state_dict = torch.load(fp, map_location="cpu")
model.load_state_dict(best_state_dict)
test_predictions = predict(model, test_dataloader, device)
with open(f"{args.name}_test_predictions.pkl", "wb") as fp:
pickle.dump(
{
"image_names": test_dataset.image_names,
"landmarks": test_predictions
}, fp)
create_submission(args.data, test_predictions, f"{args.name}_submit.csv")
def set_model(model_name, num_classes):
if model_name == 'resnext50_32x4d':
model = models.resnext50_32x4d(pretrained=True)
model.fc = torch.nn.Sequential(torch.nn.Linear(in_features=2048, out_features=num_classes))
elif model_name == 'resnet18':
model = models.resnet18(pretrained=True)
model.fc = torch.nn.Linear(in_features=512, out_features=num_classes)
elif model_name == 'resnet34':
model = models.resnet34(pretrained=True)
model.fc = torch.nn.Linear(in_features=512, out_features=num_classes)
elif model_name == 'resnet50':
model = models.resnet50(pretrained=True)
model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes)
elif model_name == 'vgg16':
model = models.vgg16(pretrained=True)
model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes)
elif model_name == 'densenet121':
model = models.densenet121(pretrained=True)
model.classifier = torch.nn.Linear(in_features=1024, out_features=num_classes)
elif model_name == 'densenet161':
model = models.densenet161(pretrained=True)
model.classifier = torch.nn.Linear(in_features=2208, out_features=num_classes)
elif model_name == 'inception':
model = models.inception_v3(pretrained=True)
model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes)
elif model_name == 'googlenet':
model = models.googlenet(pretrained=True)
model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes)
elif model_name == 'shufflenet_v2_x0_5':
model = models.shufflenet_v2_x0_5(pretrained=True)
model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes)
elif model_name == 'shufflenet_v2_x1_0':
model = models.shufflenet_v2_x1_0(pretrained=True)
model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes)
elif model_name == 'mobilenet_v2':
model = models.mobilenet_v2(pretrained=True)
model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'mobilenet_v3_large':
model = models.mobilenet_v3_large(pretrained=True)
model.classifier[3] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'mobilenet_v3_small':
model = models.mobilenet_v3_small(pretrained=True)
model.classifier[3] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'wide_resnet50_2':
model = models.wide_resnet50_2(pretrained=True)
model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes)
elif model_name == 'mnasnet0_5':
model = models.mnasnet0_5(pretrained=True)
model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'mnasnet1_0':
model = models.mnasnet1_0(pretrained=True)
model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'alexnet':
model = models.alexnet(pretrained=True)
model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes)
elif model_name == 'vgg19_bn':
model = models.vgg19_bn(pretrained=True)
model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes)
elif model_name == 'efficientnet-b0':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b1':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b2':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b3':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b4':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b5':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b6':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b7':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
else:
raise NameError(f'!!!!! Model ERROR : {model_name} !!!!!')
return model
def main(model_type, num_epochs, lr, momentum, device, local_rank):
print("Model initializing ... ")
if model_type == 'resnet18':
model = models.resnet18()
elif model_type == 'vgg16':
model = models.vgg16()
elif model_type == 'densenet121':
model = models.densenet121()
else:
print('Unsupported model type.')
exit()
model = model.to(device)
distrib_model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[local_rank], output_device=local_rank)
# lr = lr
# momentum = momentum
torch.cuda.set_device(local_rank)
distrib_model.cuda()
# Multi-Processing 1
# model = torch.nn.DataParallel(model)
# Multi-Processing 2
# torch.distributed.init_process_group(backend="nccl")
# the run method should be: python -m torch.distributed.launch main.py
print("Data preparing ... ")
# data_dir = '/home/ghostinsh3ll/Documents/datasets/ImageNet/ILSVRC2012'
# data_dir = '/extra_data/amax/ImageNet'
data_dir = '/data/amax/ImageNet'
num_class = 1000
input_size = 224
batch_size = 256 #256
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
# For train data
transforms_1 = transforms.Compose([
transforms.RandomResizedCrop(256),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
])
# For val data
transforms_2 = transforms.Compose([
transforms.Resize(288),
transforms.CenterCrop(256),
transforms.ToTensor(), normalize
])
print("Data preparing ... ")
train_imgs = datasets.ImageFolder(os.path.join(data_dir, "train"),
transform=transforms_1)
train_sampler = tud.distributed.DistributedSampler(train_imgs)
train_dataloader = tud.DataLoader(train_imgs,
batch_size=batch_size,
sampler=train_sampler,
num_workers=16,
pin_memory=True)
# train_dataloader = tud.DataLoader(train_imgs, batch_size=batch_size, shuffle=True)
test_imgs = datasets.ImageFolder(os.path.join(data_dir, "val"),
transform=transforms_2)
test_dataloader = tud.DataLoader(test_imgs,
batch_size=batch_size,
num_workers=16,
pin_memory=True)
# model = nn.parallel.DistributedDataParallel(model)
# model.cuda()
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)
use_gpu = torch.cuda.is_available()
if (use_gpu):
print("This process is running on GPU")
model.to('cuda')
# model, optimizer = amp.initialize(model,optimizer)
# model = DistributedDataParallel(model)
# model = model.cuda()
# model = model.to('cuda')
# loss_fn = loss_fn.cuda()
torch.cuda.synchronize()
start = time.time()
print("Start time is ", start, "\n")
best_valid_acc = 0
for epoch in range(num_epochs):
print("Training ", epoch + 1, " / ", num_epochs, '\n')
train_model(distrib_model, train_dataloader, loss_fn, optimizer, epoch,
use_gpu, start, model_type, device)
acc = test_model(distrib_model, test_dataloader, loss_fn, use_gpu)
if acc > best_valid_acc:
best_valid_acc = acc
now = time.strftime("%Y-%m-%d-%H_%M_%S",
time.localtime(time.time()))
fname = "./trained/" + now + model_type + r"_best_checkpoint.pth"
print("Saving best checkpoint to ", fname)
torch.save(net.state_dict(), fname)
if epoch == num_epochs - 1:
now = time.strftime("%Y-%m-%d-%H_%M_%S",
time.localtime(time.time()))
fname = "./trained/" + now + model_type + r"_last_checkpoint.pth"
print("Saving final checkpoint to ", fname)
torch.save(net.state_dict(), fname)
# save the structure
torch.cuda.synchronize()
end = time.time()
print("End time is ", end, "\n")
print("Consumed time for ", model_type, " is ", end - start, ".\n")
def train_model(model_name='resnet18',
num_epochs=1,
hidden_sizes=[256],
learning_rate=0.003,
model_path=None,
data_dir='flowers',
use_gpu=False,
save_dir='checkpoints'):
train, trainloader, validloader = load_data(data_dir)
output_size = 102
device = torch.device('cuda' if use_gpu else 'cpu')
if model_path is None:
start = 0
iterations = num_epochs
train_losses, valid_losses = [], []
model = None
else:
# model, optimizer, iterations, train_losses, valid_losses =load_checkpoint(model_path)
model_dict = load_checkpoint(model_path)
model = model_dict["model"]
model = model.to(device)
optimizer = model_dict["optimizer"]
model_name = model_dict["model_name"]
start = model_dict["iterations"]
iterations = num_epochs + start
train_losses, valid_losses = model_dict["train_losses"], model_dict[
"valid_losses"]
print('starting from {} epoch and training {} epoch(s) now'.format(
start, num_epochs))
#CHECK: also in load_checkpoint, maybe refactor
if model is None and model_name == 'vgg13':
model = models.vgg13(pretrained=True)
#turn off gradients for the model
for param in model.parameters():
param.requires_grad = False
input_size = 25088
model.classifier = Network(input_size, output_size, hidden_sizes)
optimizer = optim.Adam(model.classifier.parameters(), lr=learning_rate)
elif model is None and model_name == 'resnet18':
model = models.resnet18(pretrained=True)
#turn off gradients for the model
for param in model.parameters():
param.requires_grad = False
input_size = 512
model.fc = Network(input_size, output_size, hidden_sizes)
optimizer = optim.Adam(model.fc.parameters(), lr=learning_rate)
print('-' * 20)
print(f"Model name: {model_name}")
print(f"Learning_rate: {learning_rate}")
print(f"Hidden_units: {hidden_sizes}\n")
model.class_to_idx = train.class_to_idx
criterion = nn.NLLLoss()
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
since = time.time()
steps = 0
model.to(device)
for epoch in range(start, iterations):
print('Epoch {}/{}'.format(epoch + 1, iterations))
print('-' * 10)
print("Train losses: {}".format(train_losses))
print("Valid losses: {}".format(valid_losses))
running_loss = 0
model.train()
for images, labels in trainloader:
since_train_step = time.time()
steps += 1
# Move input and label tensors to the GPU
images, labels = images.to(device), labels.to(device)
model.train()
optimizer.zero_grad()
with torch.set_grad_enabled(True):
log_ps = model(images)
loss = criterion(log_ps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
print("Time per train step {}/{}: {}".format(
steps, len(trainloader),
time.time() - since_train_step))
else:
# Model in inference mode, dropout is off
model.eval()
# Turn off gradients for validation, will speed up inference
with torch.no_grad():
valid_loss, accuracy = validate_model(model, validloader,
criterion, device)
train_losses.append(round(running_loss / len(trainloader), 3))
valid_losses.append(round(valid_loss / len(validloader), 3))
if accuracy > best_acc:
best_acc = accuracy
best_model_wts = copy.deepcopy(model.state_dict())
print(
"Epoch: {}/{}.. ".format(epoch + 1, iterations),
"Training Loss: {:.3f}.. ".format(running_loss /
len(trainloader)),
"Test Loss: {:.3f}.. ".format(valid_loss / len(validloader)),
"Test Accuracy: {:.3f}..".format(accuracy / len(validloader)))
running_loss = 0
steps = 0
# Make sure dropout and grads are on for training
model.train()
# load best model weights
model.load_state_dict(best_model_wts)
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
# Save the model to checkpoint
checkpoint = {
'hidden_sizes': hidden_sizes,
'model': model,
'state_dict': model.state_dict(),
'optimizer': optimizer,
'optimizer_dict': optimizer.state_dict(),
'class_to_idx': model.class_to_idx,
'iterations': iterations,
'learning_rate': learning_rate,
'train_losses': train_losses,
'valid_losses': valid_losses,
'model_name': model_name
}
checkpoint_filename = "".join(
["checkpoint_", model_name, "_",
str(iterations), "epochs.pth"])
if save_dir is not None:
torch.save(checkpoint, '{}/{}'.format(save_dir, checkpoint_filename))
else:
torch.save(checkpoint, checkpoint_filename)
return model
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=False):
# Initialize these variables which will be set in this if statement. Each of these
# variables is model specific.
model_ft = None
input_size = 0
if model_name == "resnet18":
""" Resnet18
"""
model_ft = models.resnet18(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnet34":
""" Resnet18
"""
model_ft = models.resnet34(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnet50":
""" Resnet50
"""
model_ft = models.resnet50(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "alexnet":
""" Alexnet
"""
model_ft = models.alexnet(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "vgg":
""" VGG11_bn
"""
model_ft = models.vgg11_bn(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "squeezenet":
""" Squeezenet
"""
model_ft = models.squeezenet1_0(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
model_ft.classifier[1] = nn.Conv2d(512,
num_classes,
kernel_size=(1, 1),
stride=(1, 1))
model_ft.num_classes = num_classes
input_size = 224
elif model_name == "densenet":
""" Densenet
"""
model_ft = models.densenet121(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "inception":
""" Inception v3
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = models.inception_v3(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
# Handle the auxilary net
num_ftrs = model_ft.AuxLogits.fc.in_features
model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
# Handle the primary net
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 299
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
_, preds = torch.max(outputs.data, 1)
for j in range(inputs.size()[0]):
images_so_far += 1
ax = plt.subplot(num_images//2, 2, images_so_far)
ax.axis('off')
ax.set_title('predicted: {}'.format(class_names[preds[j]]))
imshow(inputs.cpu().data[j])
if images_so_far == num_images:
return
'''
Finetuning the convnet
Load a pretrained model and reset final fully connected layer.
'''
model_ft = models.resnet18(pretrained=True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, 2)
if use_gpu:
model_ft = model_ft.cuda()
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)
# Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)
'''
Train and evaluate
It should take around 15-25 min on CPU. On GPU though, it takes less than a minute.
'''
model_ft = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler,
num_epochs=25)
import copy
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import json
from load_data import data_loader
from collections import OrderedDict
from handle_command_line import parse_train
import sys
argv = sys.argv[1:]
data_dir, epoch = parse_train(argv)
with open('cat_to_name.json', 'r') as f:
cat_to_name = json.load(f)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = models.resnet18(pretrained=True)
for param in model.parameters():
param.requires_grad = False
num_feat = model.fc.in_features
classifier = nn.Sequential(
OrderedDict([('fc1', nn.Linear(num_feat, len(cat_to_name))),
('output', nn.LogSoftmax(dim=1))]))
model.fc = classifier
model = model.to(device)
criterion = nn.NLLLoss()
optimizer = torch.optim.SGD(model.fc.parameters(), lr=0.002, momentum=0.9)
def train_model(num_epochs=1):
best_val_accu = 0.0
def demo(data_root, train_list, validate_list, test_list, save, n_epochs=1,
batch_size=64, lr=0.01, wd=0.0005, momentum=0.9, seed=None):
#def demo(data_root, train_list, validation_list, test_list, save, n_epochs=1,
# batch_size=64, lr=0.001, wd=0.0005, seed=None):
"""
A demo to show off training and testing of :
"Deep facial age estimation using conditional multitask learning with weak label esxpansion."
Trains and evaluates a mean-variance loss on MOPPH Album2 dataset.
Args:
data_root (str) - path to directory where data exist
train_list (str) - path to directory where train_data_list exist
validation_list (str) - path to directory where validation_data_list exist
test_list (str) - path to directory where test_data_list exist
save (str) - path to save the model and results to
n_epochs (int) - number of epochs for training (default 3)
batch_size (int) - size of minibatch (default 64)
lr (float) - base lerning rate (default 0.001)
wd (float) -weight deday (default 0.0001)
momentum (float) momentum (default 0.9)
seed (int) - manually set the random seed (default None)
"""
# Mean and std value from Imagenet
mean=[0.485, 0.456, 0.406]
stdv=[0.229, 0.224, 0.225]
train_transforms = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(5),
transforms.ColorJitter(0.05, 0.05, 0.05, 0.05),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=stdv),
])
test_transforms = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=stdv),
])
if os.path.exists(os.path.join(save, 'regression_mae_ResNet18_nesterov_results_train_1_1.csv')):
os.remove(os.path.join(save, 'regression_mae_ResNet18_nesterov_results_train_1_1.csv'))
with open(os.path.join(save, 'regression_mae_ResNet18_nesterov_results_train_1_1.csv'), 'w') as f:
f.write('******************************************************************\n')
f.write('records on AgeDB dataset under ''80%-20%'' protocol\n')
f.write('******************************************************************\n')
f.write('\n')
f.write('\n')
train_set = data_prepare(data_root=data_root, data_list=train_list, transform=train_transforms)
valid_set = data_prepare(data_root=data_root, data_list=validate_list, transform=test_transforms)
test_set = data_prepare(data_root=data_root, data_list=test_list, transform=test_transforms)
resnet18_model = models.resnet18(pretrained=True)
fc_features=resnet18_model.fc.in_features
resnet18_model.fc=nn.Linear(fc_features, 1)
model=resnet18_model
# Make save directory
if not os.path.exists(save):
os.makedirs(save)
if not os.path.isdir(save):
raise Exception('%s is not a dir' % save)
# Model on cuda
use_cuda=torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# prepare data
if seed is not None:
torch.manual_seed(seed)
if use_cuda:
torch.cuda.manual_seed_all(seed)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True,
pin_memory=(torch.cuda.is_available()), num_workers=4)
valid_loader = torch.utils.data.DataLoader(valid_set, batch_size=batch_size, shuffle=False,
pin_memory=(torch.cuda.is_available()), num_workers=4)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, shuffle=False,
pin_memory=(torch.cuda.is_available()), num_workers=4)
# Wrap model for multi-GPUs, if necessary
if torch.cuda.is_available() and torch.cuda.device_count() > 1:
# model.features = torch.nn.DataParallel(model.features)
model = model = torch.nn.DataParallel(model)
model_wrapper = model.to(device)
# Optimizer
optimizer = torch.optim.SGD(model_wrapper.parameters(), lr=lr, momentum=momentum, nesterov=True, weight_decay=wd)
# scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[0.5 * n_epochs, 0.75 * n_epochs],
# gamma=0.1)
# scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[20,30,40],
# gamma=0.1)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[30,50,60],
gamma=0.1)
# Train and validate model
best_MAE = 100
model_state_name_1='regression_mae_resnet18_nesterov_model_train_1_1.dat'
model_state_dir_1=os.path.join(save, model_state_name_1)
with open(os.path.join(save, 'regression_mae_ResNet18_nesterov_results_train_1_1.csv'), 'a') as f:
f.write('epoch, train_loss, train_MAE, valid_loss, valid_MAE\n')
for epoch in range(n_epochs):
scheduler.step()
_, train_loss, train_MAE = train(
model=model_wrapper,
loader=train_loader,
optimizer=optimizer,
epoch=epoch,
n_epochs=n_epochs,
device=device
)
_, valid_loss, valid_MAE = validate(
model=model_wrapper,
loader=valid_loader,
epoch=epoch,
n_epochs=n_epochs,
device=device
)
# Determine if model is the best
if valid_MAE < best_MAE:
best_MAE = valid_MAE
if os.path.exists(model_state_dir_1):
os.remove(model_state_dir_1)
torch.save(model_wrapper.state_dict(), model_state_dir_1)
with open(os.path.join(save, 'regression_mae_ResNet18_nesterov_results_train_1_1.csv'), 'a') as f:
f.write('%03d, %0.4f, %0.4f, %0.4f, %0.4f\n' % ((epoch + 1), train_loss, train_MAE, valid_loss, valid_MAE))
if math.isnan(float(train_MAE)):
break
# Test model
if os.path.exists(model_state_dir_1):
_, test_loss, test_MAE, AE_list, predict_age_list, real_age_list= test(
model=model_wrapper,
loader=test_loader,
device=device,
model_state_dir=model_state_dir_1
)
os.remove(model_state_dir_1)
with open(os.path.join(save, 'regression_mae_ResNet18_nesterov_results_train_1_1.csv'), 'a') as f:
f.write('test_loss, test_MAE:\n')
f.write('%0.4f, %0.4f\n' % (test_loss, test_MAE))
# f.write('\n')
CS_1_numerator=CS_2_numerator=CS_3_numerator=CS_4_numerator=CS_5_numerator=CS_6_numerator=CS_7_numerator=CS_8_numerator=CS_9_numerator=CS_10_numerator=0
for i in range(len(AE_list)):
if AE_list[i]<=1:
CS_1_numerator+=1
if AE_list[i]<=2:
CS_2_numerator+=1
if AE_list[i]<=3:
CS_3_numerator+=1
if AE_list[i]<=4:
CS_4_numerator+=1
if AE_list[i]<=5:
CS_5_numerator+=1
if AE_list[i]<=6:
CS_6_numerator+=1
if AE_list[i]<=7:
CS_7_numerator+=1
if AE_list[i]<=8:
CS_8_numerator+=1
if AE_list[i]<=9:
CS_9_numerator+=1
if AE_list[i]<=10:
CS_10_numerator+=1
CS_1=CS_1_numerator/len(AE_list)
CS_2=CS_2_numerator/len(AE_list)
CS_3=CS_3_numerator/len(AE_list)
CS_4=CS_4_numerator/len(AE_list)
CS_5=CS_5_numerator/len(AE_list)
CS_6=CS_6_numerator/len(AE_list)
CS_7=CS_7_numerator/len(AE_list)
CS_8=CS_8_numerator/len(AE_list)
CS_9=CS_9_numerator/len(AE_list)
CS_10=CS_10_numerator/len(AE_list)
with open(os.path.join(save, 'regression_mae_ResNet18_nesterov_results_train_1_1.csv'), 'a') as f:
f.write('CS_1, CS_2, CS_3, CS_4, CS_5, CS_6, CS_7, CS_8, CS_9, CS_10:\n')
f.write('%0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f\n'
% (CS_1, CS_2, CS_3, CS_4, CS_5, CS_6, CS_7, CS_8, CS_9, CS_10))
f.write('\n')
def __init__(self):
super().__init__()
self.resnet18 = resnet18(num_classes=4).eval()
def resnet18(config):
return models.resnet18(num_classes=config["num_classes"])
def initialize_model(model_name, use_pretrained=True):
# Initialize these variables which will be set in this if statement. Each of these
# variables is model specific.
model_ft = None
input_size = 224
if model_name == "resnet18":
""" Resnet18
"""
model_ft = models.resnet18(pretrained=use_pretrained)
elif model_name == "resnet34":
""" Resnet34
"""
model_ft = models.resnet34(pretrained=use_pretrained)
elif model_name == "resnet50":
""" Resnet50
"""
model_ft = models.resnet50(pretrained=use_pretrained)
elif model_name == "resnet101":
""" Resnet101
"""
model_ft = models.resnet101(pretrained=use_pretrained)
elif model_name == "resnet152":
""" Resnet152
"""
model_ft = models.resnet152(pretrained=use_pretrained)
elif model_name == "alexnet":
""" Alexnet
"""
model_ft = models.alexnet(pretrained=use_pretrained)
elif model_name == "vgg11_bn":
""" VGG11_bn
"""
model_ft = models.vgg11_bn(pretrained=use_pretrained)
elif model_name == "squeezenet1_0":
""" Squeezenet1_0
"""
model_ft = models.squeezenet1_0(pretrained=use_pretrained)
elif model_name == "densenet121":
""" Densenet121
"""
model_ft = models.densenet121(pretrained=use_pretrained)
elif model_name == "densenet169":
""" Densenet169
"""
model_ft = models.densenet169(pretrained=use_pretrained)
elif model_name == "densenet201":
""" Densenet201
"""
model_ft = models.densenet201(pretrained=use_pretrained)
elif model_name == "densenet161":
""" Densenet161
"""
model_ft = models.densenet161(pretrained=use_pretrained)
elif model_name == "inception_v3":
""" Inception v3
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = models.inception_v3(pretrained=use_pretrained)
input_size = 299
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
def __init__(self):
super(ImageFeatureNet, self).__init__()
self.feature = Models.resnet18(pretrained=True)
self.feature = nn.Sequential(*list(self.feature.children())[:-1])
self.fc1 = nn.Sequential(nn.Linear(512, 128))
def __init__(self, infos):
super(MyModule, self).__init__()
self.hidden_dim = 512 * 2
#self.size = 512*7*7
in_channels = 512
self.size_a = 512 * 1 * 1
self.size_b = 256 * 7 * 7
self.task_dim = infos[1]
init_prelu = torch.FloatTensor([0.01])
pretrained = models.resnet18(pretrained=True)
p = 0.25
#self.features = pretrained.features
children = [c for c in pretrained.children()]
children.pop()
self.pool = children.pop()
self.features = nn.Sequential(*children)
self.tasks_transform = nn.Sequential(
nn.Linear(self.task_dim, self.task_dim - 1),
nn.BatchNorm1d(self.task_dim - 1),
)
# ----------------------------
self.weights = nn.Sequential(
nn.BatchNorm1d(self.hidden_dim),
nn.Linear(self.hidden_dim, self.hidden_dim), nn.PReLU(init_prelu),
nn.Dropout(p), nn.Linear(self.hidden_dim, self.hidden_dim),
nn.PReLU(init_prelu))
self.weights_task_apparel = nn.Sequential(
nn.BatchNorm1d(self.hidden_dim + infos[2]),
nn.Linear(self.hidden_dim + infos[2], self.hidden_dim),
nn.PReLU(init_prelu),
)
self.weights_task_attribute = nn.Sequential(
nn.BatchNorm1d(self.hidden_dim + infos[3]),
nn.Linear(self.hidden_dim + infos[3], self.hidden_dim),
nn.PReLU(init_prelu))
# ----------------------------
self.linear_a = nn.Sequential(
nn.BatchNorm1d(self.size_a), nn.Linear(self.size_a,
self.hidden_dim),
nn.PReLU(init_prelu), nn.Linear(self.hidden_dim, self.hidden_dim),
nn.PReLU(init_prelu))
self.linear_b = nn.Sequential(
nn.Linear(self.size_b, self.hidden_dim), nn.PReLU(init_prelu),
nn.BatchNorm1d(self.hidden_dim),
nn.Linear(self.hidden_dim, self.hidden_dim), nn.PReLU(init_prelu))
self.linear_apparel = nn.Sequential(
nn.BatchNorm1d(self.size_a), nn.Linear(self.size_a,
self.hidden_dim),
nn.PReLU(init_prelu), nn.BatchNorm1d(self.hidden_dim),
nn.Linear(self.hidden_dim, infos[2]), nn.LogSoftmax())
self.linear_attribute = nn.Sequential(nn.Linear(44, infos[3]),
nn.LogSoftmax())
self.linear_task = nn.Sequential(nn.Linear(44, self.hidden_dim),
nn.PReLU(init_prelu))
size = 6170
self.final_linear = nn.Sequential(
nn.BatchNorm1d(size), nn.Dropout(p),
nn.Linear(size, self.hidden_dim * 2), nn.PReLU(init_prelu),
nn.BatchNorm1d(self.hidden_dim * 2), nn.Dropout(p),
nn.Linear(self.hidden_dim * 2, self.hidden_dim),
nn.PReLU(init_prelu), nn.BatchNorm1d(self.hidden_dim),
nn.Linear(self.hidden_dim, infos[0]), nn.LogSoftmax())
import cv2
import numpy as np
import logging
import sys
import torch
from torchvision import models
os.environ['TORCH_MODEL_ZOO'] = \
'/mnt/vol/gfsai-east/ai-group/users/rgirdhar/StandardModels/PyTorch/ImNet'
FORMAT = '%(levelname)s %(filename)s:%(lineno)4d: %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT, stream=sys.stdout)
logger = logging.getLogger(__name__)
default_model = models.resnet18(pretrained=True)
def prepare_image(im):
im = im[..., (2, 1, 0)] # convert to rgb
try:
im = cv2.resize(im, (224, 224))
except cv2.error:
im = np.zeros((224, 224, 3)) # dummy image
logger.warning('Invalid patch, replaced with 0 image.')
im = im.transpose(2, 0, 1)
mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3, 1, 1)
std = np.array([0.229, 0.224, 0.224]).reshape(1, 3, 1, 1)
im = (im / 255.0 - mean) / std
im = torch.FloatTensor(im).cuda()
im = torch.autograd.Variable(im, volatile=True)
def __init__(self,
num_classes=100,
network='resnet18',
pretrained=True,
dropout_rate=0.2,
num_domain_classes=None):
super(BasicResNet, self).__init__()
if network == 'resnet152':
resnet_model = models.resnet152(pretrained=pretrained)
elif network == 'resnet101':
resnet_model = models.resnet101(pretrained=pretrained)
elif network == 'resnet50':
resnet_model = models.resnet50(pretrained=pretrained)
elif network == 'resnet34':
resnet_model = models.resnet34(pretrained=pretrained)
elif network == 'resnet18':
resnet_model = models.resnet18(pretrained=pretrained)
elif network == 'MobileNetV2':
resnet_model = models.mobilenet_v2(pretrained=pretrained)
elif network == 'inceptionV3':
resnet_model = models.inception_v3(pretrained=pretrained)
elif network == 'mnasnet':
resnet_model = models.mnasnet1_0(pretrained=pretrained)
elif network == 'VGG':
resnet_model = models.vgg11(pretrained=pretrained)
else:
raise Exception("{} model type not supported".format(network))
self.num_domain_classes = num_domain_classes
self.resnet_model = resnet_model
if 'resnet' in network:
if num_domain_classes is None:
self.resnet_model.fc = nn.Sequential(
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
resnet_model.fc.in_features),
nn.ReLU(),
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
resnet_model.fc.in_features),
nn.ReLU(),
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features, num_classes),
)
else:
self.resnet_model.fc = nn.Sequential(
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
resnet_model.fc.in_features), nn.ReLU(),
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
resnet_model.fc.in_features), nn.ReLU(),
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
num_classes + num_domain_classes), nn.ReLU(),
nn.BatchNorm1d(num_classes + num_domain_classes),
nn.Dropout(dropout_rate))
self.classes_output = nn.Linear(
num_classes + num_domain_classes, num_classes)
self.domain_output = nn.Linear(
num_classes + num_domain_classes, num_domain_classes)
elif 'VG' in network:
self.resnet_model.classifier = nn.Sequential(
nn.Linear(25088, 4096, bias=True), nn.ReLU(),
nn.Dropout(p=0.5, inplace=False),
nn.Linear(4096, 4096, bias=True), nn.ReLU(),
nn.Dropout(p=0.5, inplace=False), nn.Linear(4096, num_classes))
) if args.quick_test else (None, None)
poses = ([6]) if args.quick_test else poses
dl_test, n_iter_test = [], []
for pose in poses:
dt_test = Fera2017Dataset('/data/data1/datasets/fera2017/',
partition='validation', tsubs=t_subs_te, tposes=[pose], transform=tsfm, verbose=True)
n_iter_test.append(len(dt_test)/args.batch_size)
dl_test.append(DataLoader(dt_test, batch_size=args.batch_size,
num_workers=4))
n_iter_test_total = np.sum(n_iter_test)
print('n_iter in test per pose: {}, total: {}'.format(
n_iter_test, n_iter_test_total))
encoder = models.resnet18()
model = GDVM_ResNet(encoder, latent=256, out=n_classes, dropout=0.4)
model.cuda()
def test():
model.eval()
f1s, mus = [], []
for i, dl_test_pose in enumerate(dl_test):
targets, preds = [], []
print(
'-----------------------------------Evaluating POSE {} ------------------------- '.format(poses[i]))
for iter, (data, target, _) in enumerate(dl_test_pose):
target = torch.clamp(target[:, aus], 0, 1)
data, target = data.cuda(), target.cuda()
data, target = Variable(data).float(
def __init__(self, class_labels, pretrained = False):
super(OneChannelResnet, self).__init__()
self.model = models.resnet18(pretrained)
self.model.conv1 = torch.nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
self.model.fc = torch.nn.Linear(512 * self.model.layer1[0].expansion, len(class_labels.keys()))
def __init__(self):
super(Net, self).__init__()
self.backbone = models.resnet18(pretrained=True)
self.backbone.fc = nn.Linear(512, 5)
from torchvision.models import resnet18, resnet50 from torchscope import scope model = resnet18() # model = resnet50() scope(model, input_size=(3, 224, 224))
def get_trained_resnet(use_gpu=True):
model_ft = models.resnet18(pretrained=True)
if use_gpu:
model_ft = model_ft.try_cuda()
return model_ft
model = resnet18_lcs()
elif model_name == "se-resnet18":
# resume ="/media/hszc/model/detao/models/lcz42/se_resnet18_lcs42/best_weigths_[1.0000000000000003e-05].pth"
# resume ="model_weights/se_resnet18_9254/best_weigths_[1.0000000000000003e-05].pth"
resume = "/media/hszc/model/detao/models/lcz42/se_resnet18_lcs42_dataaug/best_weigths_[1.0000000000000003e-05].pth"
model = se_resnet18_lcs42()
elif model_name == "resnet34":
resume = "/media/hszc/model/detao/models/lcz42/resnet34_lcs42_stride1/best_weigths_[0.0001].pth"
model = resnet34_lcs()
elif model_name == "se-resnet34":
resume = "/media/hszc/model/detao/models/lcz42/dla34_lcs/best_weigths_[1.0000000000000003e-05].pth"
model = se_resnet34_lcs42()
elif model_name == "resnet18_224":
from torchvision.models import resnet18
resume = "/media/hszc/model/detao/models/lcz42/resnet18_224_input/best_weigths_[1.0000000000000003e-05].pth"
model = resnet18(pretrained=True)
model.conv1 = torch.nn.Conv2d(10,
64,
kernel_size=7,
stride=1,
padding=3,
bias=False)
model.avgpool = torch.nn.AdaptiveAvgPool2d(output_size=1)
model.fc = torch.nn.Linear(model.fc.in_features, 17)
model = torch.nn.DataParallel(model)
elif model_name == "resnet50_224":
# from torchvision.models import resnet50
# model=resnet50(pretrained=True)
from models.dilate_resnet import dilate_resnet50
model = dilate_resnet50(17)
def get_backbone(name, pretrained=True):
"""
Returns the backone of a CNN and its number of output channels.
Parameters:
name (string): CNN name
pretrained (bool): Pretrained weights condition
Returns:
backbone (Sequential): The CNN backone warped as a torch.nn.Sequential object
out_channels (int): The depth of the last layer
"""
# Mobilenet
if name == 'mobilenet':
backbone = models.mobilenet_v2(pretrained=pretrained).features
out_channels = 1280
# ResNet
elif name == 'resnet18':
resnet = models.resnet18(pretrained=pretrained)
modules = list(resnet.children())[:-2]
backbone = nn.Sequential(*modules)
out_channels = 512
elif name == 'resnet34':
resnet = models.resnet34(pretrained=pretrained)
modules = list(resnet.children())[:-2]
backbone = nn.Sequential(*modules)
out_channels = 512
elif name == 'resnet50':
resnet = models.resnet50(pretrained=pretrained)
modules = list(resnet.children())[:-2]
backbone = nn.Sequential(*modules)
out_channels = 2048
elif name == 'resnet101':
resnet = models.resnet101(pretrained=pretrained)
modules = list(resnet.children())[:-2]
backbone = nn.Sequential(*modules)
out_channels = 2048
# ResNeXt
elif name == 'resnext50':
resnext = models.resnext50_32x4d(pretrained=pretrained)
modules = list(resnext.children())[:-2]
backbone = nn.Sequential(*modules)
out_channels = 2048
elif name == 'resnext101':
resnext = models.resnext101_32x8d(pretrained=pretrained)
modules = list(resnext.children())[:-2]
backbone = nn.Sequential(*modules)
out_channels = 2048
elif name == 'wide_resnet50':
w_resnet = models.wide_resnet50_2(pretrained=pretrained)
modules = list(w_resnet.children())[:-2]
backbone = nn.Sequential(*modules)
out_channels = 2048
elif name == 'wide_resnet101':
w_resnet = models.wide_resnet101_2(pretrained=pretrained)
modules = list(w_resnet.children())[:-2]
backbone = nn.Sequential(*modules)
out_channels = 2048
# Error
else:
raise NotImplemented('{} backbone model is not implemented so far.'.format(name))
return backbone, out_channels
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=True):
# Initialize these variables which will be set in this if statement. Each of these
# variables is model specific.
model_ft = None
input_size = 0
# Ignore ssl certification (prevent error for some users)
ssl._create_default_https_context = ssl._create_unverified_context
if model_name == "resnet":
""" Resnet18
"""
model_ft = models.resnet18(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnet152":
model_ft = models.resnet152(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "alexnet":
""" Alexnet
"""
model_ft = models.alexnet(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "vgg":
""" VGG11_bn
"""
model_ft = models.vgg11_bn(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "squeezenet":
""" Squeezenet
"""
model_ft = models.squeezenet1_0(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
model_ft.classifier[1] = nn.Conv2d(512,
num_classes,
kernel_size=(1, 1),
stride=(1, 1))
model_ft.num_classes = num_classes
input_size = 224
elif model_name == "densenet":
""" Densenet
"""
model_ft = models.densenet121(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "inception":
""" Inception v3
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = models.inception_v3(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
# Handle the auxilary net
num_ftrs = model_ft.AuxLogits.fc.in_features
model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
# Handle the primary net
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 299
elif model_name == "xception":
""" Xception
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = xception.xception(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 299
elif model_name == "fleming_v1":
""" Fleming Model
Custom model created by team Fleming
"""
model_ft = fleming.FlemingModel_v1(num_classes=196)
input_size = 224
elif model_name == "fleming_v2":
""" Fleming Model
Custom model created by team Fleming
"""
model_ft = fleming.FlemingModel_v2(num_classes=196)
input_size = 224
elif model_name == "fleming_v3":
""" Fleming Model
Custom model created by team Fleming
"""
model_ft = fleming.FlemingModel_v3(num_classes=196)
input_size = 224
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
net.load_state_dict(
model_zoo.load_url(
'https://download.pytorch.org/models/densenet161-8d451a50.pth',
model_dir='/share/data/lang/users/dan/.torch/models'))
args.test_bs = 64
elif args.model_name == 'densenet264':
net = densenet_cosine_264_k48
net.load_state_dict(
model_zoo.load_url(
'https://download.pytorch.org/models/densenet_cosine_264_k48.pth',
model_dir='/share/data/lang/users/dan/.torch/models'))
args.test_bs = 64
elif args.model_name == 'resnet18':
net = models.resnet18()
net.load_state_dict(
model_zoo.load_url(
'https://download.pytorch.org/models/resnet18-5c106cde.pth',
model_dir='/share/data/lang/users/dan/.torch/models'))
args.test_bs = 256
elif args.model_name == 'resnet34':
net = models.resnet34()
net.load_state_dict(
model_zoo.load_url(
'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
model_dir='/share/data/lang/users/dan/.torch/models'))
args.test_bs = 128
elif args.model_name == 'resnet50':
!ls pix
transform = transforms.Compose([
transforms.Resize([224, 224]),
transforms.ToTensor(),
])
train_ds = Mydataset(Path('pix'), transform = transform)
test_ds = Mydataset(Path('pix'), False, transform)
train_dl = DataLoader (train_ds, batch_size = 64, num_workers = 0)
test_dl = DataLoader (train_ds, batch_size = 1, num_workers = 0)
model = models.resnet18( pretrained = False )
model.conv1 = nn.Conv2d(1, 64, kernel_size = (7, 7), stride = (2, 2), padding = (3, 3), bias=False)
model.fc = nn.Linear(in_features = 512, out_features = NUMBER_LEN * MAX_CAPTCHA, bias=True)
model.cuda()
loss_func = nn.MultiLabelSoftMarginLoss()
optm = torch.optim.Adam(model.parameters(), lr = 0.001)
for epoch in range(20):
for step, i in enumerate(train_dl):
img, label_oh, keys = i
img = Variable(img).cuda()
label_oh = Variable(label_oh.float()).cuda()
def __init__(self,norm_layer=nn.BatchNorm2d,**cfg):
super(FastPose_DUC_Dense, self).__init__()
self._preset_cfg = cfg['PRESET']
if cfg['BACKBONE'] == 'shuffle':
print('Load shuffle backbone...')
backbone = ShuffleResnet
elif cfg['BACKBONE'] == 'se-resnet':
print('Load SE Resnet...')
backbone = SEResnet
else:
print('Load Resnet...')
backbone = ResNet
if 'DCN' in cfg.keys():
stage_with_dcn = cfg['STAGE_WITH_DCN']
dcn = cfg['DCN']
self.preact = backbone(
f"resnet{cfg['NUM_LAYERS']}", dcn=dcn, stage_with_dcn=stage_with_dcn)
else:
self.preact = backbone(f"resnet{cfg['NUM_LAYERS']}")
# Init Backbone
for m in self.preact.modules():
if isinstance(m, nn.Conv2d):
nn.init.normal_(m.weight, std=0.001)
for name, _ in m.named_parameters():
if name in ['bias']:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
# nn.init.constant_(m.weight, 1)
nn.init.uniform_(m.weight, 0, 1)
nn.init.constant_(m.bias, 0)
# Imagenet pretrain model
import torchvision.models as tm
if cfg['NUM_LAYERS'] == 152:
''' Load pretrained model '''
x = tm.resnet152(pretrained=True)
elif cfg['NUM_LAYERS'] == 101:
''' Load pretrained model '''
x = tm.resnet101(pretrained=True)
elif cfg['NUM_LAYERS'] == 50:
x = tm.resnet50(pretrained=True)
elif cfg['NUM_LAYERS'] == 18:
x = tm.resnet18(pretrained=True)
else:
raise NotImplementedError
model_state = self.preact.state_dict()
state = {k: v for k, v in x.state_dict().items()
if k in self.preact.state_dict() and v.size() == self.preact.state_dict()[k].size()}
model_state.update(state)
self.preact.load_state_dict(model_state)
self.norm_layer = norm_layer
stage1_cfg = cfg['STAGE1']
stage2_cfg = cfg['STAGE2']
stage3_cfg = cfg['STAGE3']
duc1 = self._make_duc_stage(stage1_cfg, 2048, 1024)
duc2 = self._make_duc_stage(stage2_cfg, 1024, 512)
duc3 = self._make_duc_stage(stage3_cfg, 512, self.conv_dim)
self.duc = nn.Sequential(duc1, duc2, duc3)
duc1_dense = self._make_duc_stage(stage1_cfg,2048,1024)
duc2_dense = self._make_duc_stage(stage2_cfg,1024,512)
duc3_dense = self._make_duc_stage(stage3_cfg,512,self.conv_dim)
self.duc_dense = nn.Sequential(duc1_dense,duc2_dense,duc3_dense)
self.conv_out = nn.Conv2d(
self.conv_dim, self._preset_cfg['NUM_JOINTS'], kernel_size=3, stride=1, padding=1)
self.conv_out_dense = nn.Conv2d(
self.conv_dim,(self._preset_cfg['NUM_JOINTS_DENSE']-self._preset_cfg['NUM_JOINTS']),kernel_size=3,stride=1,padding=1)
for params in self.preact.parameters():
params.requires_grad = False
for params in self.duc.parameters():
params.requires_grad = False
import torch
import torchvision.utils as vutils
import numpy as np
import torchvision.models as models
from torchvision import datasets
from tensorboardX import SummaryWriter
import datetime
resnet18 = models.resnet18(False)
writer = SummaryWriter()
sample_rate = 44100
freqs = [262, 294, 330, 349, 392, 440, 440, 440, 440, 440, 440]
true_positive_counts = [75, 64, 21, 5, 0]
false_positive_counts = [150, 105, 18, 0, 0]
true_negative_counts = [0, 45, 132, 150, 150]
false_negative_counts = [0, 11, 54, 70, 75]
precision = [0.3333333, 0.3786982, 0.5384616, 1.0, 0.0]
recall = [1.0, 0.8533334, 0.28, 0.0666667, 0.0]
for n_iter in range(100):
s1 = torch.rand(1) # value to keep
s2 = torch.rand(1)
# data grouping by `slash`
writer.add_scalar('data/scalar_systemtime', s1[0], n_iter)
# data grouping by `slash`
writer.add_scalar('data/scalar_customtime', s1[0], n_iter, walltime=n_iter)
writer.add_scalars(
'data/scalar_group', {
"xsinx": n_iter * np.sin(n_iter),
"xcosx": n_iter * np.cos(n_iter),
def main():
global args, best_prec1
args = parser.parse_args()
print(args)
# Set # classes
if args.data == 'UCF101':
num_classes = 101
else:
num_classes = 0
print('Specify the dataset to use ')
# Create model
if args.pretrained:
print("=> using pre-trained model '{}'".format(args.arch))
model = models.__dict__[args.arch](pretrained=True)
else:
print("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch]()
if args.arch.startswith('alexnet'):
model = AlexNet(num_classes=num_classes)
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# Modify last layer of the model
model_ft = models.resnet18(pretrained=True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, 101)
model = model_ft.cuda()
model = torch.nn.DataParallel(model).cuda() # Using one GPU (device_ids = 1)
# print(model)
# Define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# Optionally resume from a checkpoint
if args.resume:
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
testdir = os.path.join(args.data, 'test')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(traindir, transforms.Compose([
transforms.RandomCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size = args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True
)
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(testdir, transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size = args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True
)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# Train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# # Evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# Remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
}, is_best)
clear()
args = set_args()
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
])
test_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor()
])
with open("imagenet_class_index.json", "rb") as f:
class_idx = json.load(f)
train_loader, test_loader = ImageNet(args, train_transform, test_transform)
teacher_model = pretrained_models.resnet18(pretrained=True).cuda(args.gpu)
student_model = pretrained_models.resnet18(pretrained=True).cuda(args.gpu)
criterion = nn.CrossEntropyLoss()
teacher_sub_layers = list(teacher_model.children())[:7]
teacher_sub_model = nn.Sequential(*teacher_sub_layers).cuda(args.gpu)
student_sub_layers = list(student_model.children())[:7]
student_sub_model = nn.Sequential(*student_sub_layers).cuda(args.gpu)
with open("Resnet18.txt", "w") as f:
architecture = list(teacher_model.children())
f.write(str(architecture))
for i, (images, labels) in enumerate(train_loader, start=1):
with torch.no_grad():
teacher_model.eval()
student_model.eval()
images = images.cuda(args.gpu)
}
# get train data size and validation data size
data_size = {
'train': len(dataloader['train'].dataset),
'val': len(dataloader['val'].dataset)
}
# get numbers of classes
img_classes = len(dataloader['train'].dataset.classes)
# test if using GPU
use_gpu = torch.cuda.is_available()
fix_param = True
# define model
transfer_model = models.resnet18(pretrained=True)
if fix_param:
for param in transfer_model.parameters():
param.requires_grad = False
dim_in = transfer_model.fc.in_features
transfer_model.fc = nn.Linear(dim_in, 2)
if use_gpu:
transfer_model = transfer_model.cuda()
# define optimize function and loss function
if fix_param:
optimizer = optim.Adam(transfer_model.fc.parameters(), lr=1e-3)
else:
optimizer = optim.Adam(transfer_model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()
def __init__(self,
pos_data_path: str,
neg_data_path: str,
model_path: str = None,
transform=None):
# create a dataset object of inner class FireDataset
dataset = self.FireDataset(pos_data_path=pos_data_path,
neg_data_path=neg_data_path,
transform=transform)
# raise a ValueError if dataset is empty.
if len(dataset) == 0:
raise ValueError(f'Empty dataset!')
# split the dataset into 60% train, 20% validation, and 20% test
total_dataset_size = len(dataset)
train_dataset_size = int(0.6 * total_dataset_size)
val_dataset_size = int(0.2 * total_dataset_size)
test_dataset_size = total_dataset_size - train_dataset_size \
- val_dataset_size
dataset_split = [
train_dataset_size, val_dataset_size, test_dataset_size
]
train_dataset, test_dataset, valid_dataset = \
torch.utils.data.random_split(dataset, dataset_split)
# create the dataloaders.
train_loader = DataLoader(dataset=train_dataset,
batch_size=16,
shuffle=True,
num_workers=0)
valid_loader = DataLoader(dataset=valid_dataset,
batch_size=128,
shuffle=False,
num_workers=0)
test_loader = DataLoader(dataset=test_dataset,
batch_size=128,
shuffle=False,
num_workers=0)
# store datasets and dataloaders in dictionaries for convenience
self.datasets = {
'train': train_dataset,
'test': test_dataset,
'val': valid_dataset
}
self.dataloaders = {
'train': train_loader,
'test': test_loader,
'val': valid_loader
}
# set up a ResNet18 model for binary classification
model = models.resnet18(pretrained=True)
num_in_fc = model.fc.in_features
model.fc = nn.Linear(num_in_fc, 2) # two classes: Fire and NoFire
# if a previous model is specified by model_path, load it
if model_path is not None:
if not os.path.isfile(model_path):
raise ValueError(f'{model_path} is not a valid model path')
model.load_state_dict(torch.load(model_path))
self.model = model
_, preds = torch.max(outputs.data, 1)
for j in range(inputs.size(0)):
imagesSoFar += 1
nCols = 2
ax = plt.subplot(numImages // nCols, nCols, imagesSoFar)
ax.axis('off')
ax.set_title('predicted: {}'.format(class_names[preds[j]]))
imshow(inputs.cpu().data[j])
if imagesSoFar == numImages:
model.train(mode=wasTraining)
return
model.train(mode=wasTraining)
modelFt = models.resnet18(pretrained=True)
#modelFt = models.resnet18(pretrained=False)
for param in modelFt.parameters():
param.requires_grad = False
numFeatures = modelFt.fc.in_features
modelFt.fc = nn.Linear(numFeatures, 2)
if use_gpu:
modelFt = modelFt.cuda()
criterion = nn.CrossEntropyLoss()
#optimizerFt = optim.SGD(modelFt.parameters(), lr=0.001, momentum=0.9)
#expLrScheduler = lr_scheduler.StepLR(optimizerFt, step_size=7, gamma=0.1)
def __get_pytorch_module(self, name, collection, params, pretrained):
# TK: "factory" is not passed as parameter anymore.
# params["factory"] = self
if collection == "toys" or collection == "tutorials" or collection == "other":
constructor = NeuralModuleFactory.__name_import(
"nemo.backends.pytorch.tutorials." + name)
elif collection == "nemo_nlp":
constructor = NeuralModuleFactory.__name_import("nemo_nlp." + name)
if name == "BERT" and pretrained is True:
params["pretrained"] = True
elif collection == "nemo_asr":
constructor = NeuralModuleFactory.__name_import("nemo_asr." + name)
elif collection == "nemo_lpr":
constructor = NeuralModuleFactory.__name_import("nemo_lpr." + name)
elif collection == 'common':
constructor = NeuralModuleFactory.__name_import(
'nemo.backends.pytorch.common.' + name)
elif collection == "torchvision":
import torchvision.models as tv_models
import nemo.backends.pytorch.module_wrapper as mw
import torch.nn as nn
if name == "ImageFolderDataLayer":
constructor = NeuralModuleFactory.__name_import(
"nemo.backends.pytorch.torchvision.data." + name)
instance = constructor(**params)
return instance
else:
_nm_name = name.lower()
if _nm_name == "resnet18":
input_ports = {
"x":
NeuralType({
0: AxisType(BatchTag),
1: AxisType(ChannelTag),
2: AxisType(HeightTag, 224),
3: AxisType(WidthTag, 224),
})
}
output_ports = {
"output":
NeuralType({
0: AxisType(BatchTag),
1: AxisType(ChannelTag)
})
}
pt_model = tv_models.resnet18(pretrained=pretrained)
num_classes = params.get("num_classes", None)
if num_classes is not None:
pt_model.fc = nn.Linear(512, params["num_classes"])
return mw.TrainableNeuralModuleWrapper(
pt_nn_module=pt_model,
input_ports_dict=input_ports,
output_ports_dict=output_ports,
)
elif _nm_name == "resnet50":
input_ports = {
"x":
NeuralType({
0: AxisType(BatchTag),
1: AxisType(ChannelTag),
2: AxisType(HeightTag, 224),
3: AxisType(WidthTag, 224),
})
}
output_ports = {
"output":
NeuralType({
0: AxisType(BatchTag),
1: AxisType(ChannelTag)
})
}
pt_model = tv_models.resnet50(pretrained=pretrained)
num_classes = params.get("num_classes", None)
if num_classes is not None:
pt_model.fc = nn.Linear(2048, params["num_classes"])
return mw.TrainableNeuralModuleWrapper(
pt_nn_module=pt_model,
input_ports_dict=input_ports,
output_ports_dict=output_ports,
)
else:
collection_path = "nemo.collections." + collection + "." + name
constructor = NeuralModuleFactory.__name_import(collection_path)
if name == "BERT" and pretrained is True:
params["pretrained"] = True
# TK: "placement" is not passed as parameter anymore.
# if "placement" not in params:
# params["placement"] = self._placement
instance = constructor(**params)
return instance
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True):
# Initialize these variables which will be set in this if statement. Each of these
# variables is model specific.
model_ft = None
input_size = 0
if model_name == "resnet":
""" Resnet18
"""
model_ft = models.resnet18(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "alexnet":
""" Alexnet
"""
model_ft = models.alexnet(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes)
input_size = 224
elif model_name == "vgg":
""" VGG11_bn
"""
model_ft = models.vgg11_bn(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes)
input_size = 224
elif model_name == "squeezenet":
""" Squeezenet
"""
model_ft = models.squeezenet1_0(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1))
model_ft.num_classes = num_classes
input_size = 224
elif model_name == "densenet":
""" Densenet
"""
model_ft = models.densenet121(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "inception":
""" Inception v3
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = models.inception_v3(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
# Handle the auxilary net
num_ftrs = model_ft.AuxLogits.fc.in_features
model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
# Handle the primary net
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs,num_classes)
input_size = 299
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
import torch
import logging
from utils_for_examples import MLP, Identity
logging.getLogger().setLevel(logging.INFO)
import pytorch_metric_learning
logging.info("VERSION %s" % pytorch_metric_learning.__version__)
##############################
########## Training ##########
##############################
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Set trunk model and replace the softmax layer with an identity function
trunk = models.resnet18(pretrained=True)
trunk_output_size = trunk.fc.in_features
trunk.fc = Identity()
trunk = torch.nn.DataParallel(trunk.to(device))
# Set embedder model. This takes in the output of the trunk and outputs 64 dimensional embeddings
embedder = torch.nn.DataParallel(MLP([trunk_output_size, 64]).to(device))
# Set the classifier. The classifier will take the embeddings and output a 100 dimensional vector.
# (There are 100 classes in CIFAR100, which is the dataset we'll use in this example.)
# We'll specify the classification loss further down in the code.
classifier = torch.nn.DataParallel(MLP([64, 100])).to(device)
# Set optimizers
trunk_optimizer = torch.optim.Adam(trunk.parameters(),
lr=0.00001,
