def __init__(self, model: torch.nn.Module, weights: str, w_cpm2d: str,
w_cpm3d: str, device: int):
print("initialize Evaluator")
self.model = model
self.device = 'cpu' if device < 0 else f"cuda:{device}"
print(f"device : {self.device}")
self.model.load_state_dict(self._get_weights(weights))
print("model's weights loaded")
self.inception_model = inception_v3(True,
transform_input=False,
init_weights=False)
print("inception model initialized")
self.preprocess = transforms.Compose([
transforms.ToPILImage(mode=None),
transforms.Resize(299),
transforms.CenterCrop(299),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
if self.device != 'cpu':
self.model = self.model.to(device)
self.inception_model = self.inception_model.to(device)
self.inception_model.eval()
self.model.eval()
self.IS_cache_zize = 64
self.IS_cache = []
self.IS_scores = []
self.SSIM_scores = []
self.PCK_scores = HPEstimator(w_cpm2d, w_cpm3d, self.device)
def load_model_with_placement(placement, lr=0.01, classes=1000):
device_lookup = {
0: 'cpu:0',
1: 'cpu:0',
2: 'cuda:0',
3: 'cuda:1'
}
if placement is None:
placement = 'cpu:0'
elif isinstance(placement, dict):
translated_placement = {}
for layer_name, device in placement.items():
translated_placement[layer_name] = device_lookup[device]
placement = translated_placement
model = inception_v3(pretrained=False, placement=placement, num_classes=classes, init_weights=False)
if isinstance(placement, str):
input_device = output_device = torch.device(placement)
model.to(input_device)
else:
input_device = placement['Conv2d_1a_3x3']
output_device = placement['softmax']
criterion = torch.nn.CrossEntropyLoss().to(output_device) # TODO Move loss to correct device
optimizer = torch.optim.SGD(model.parameters(), lr=lr)
return model, criterion, optimizer, input_device, output_device
def __init__(self):
super(inception_345, self).__init__()
self.CNN = inception_v3(pretrained=True)
# Handle the primary net
self.fc = nn.Linear(self.CNN.fc.in_features, 345)
# Handle the auxilary net
self.aux_fc = nn.Linear(self.CNN.AuxLogits.fc.in_features, 345)
def get_net(name):
if name == 'densenet121':
net = densenet121()
elif name == 'densenet161':
net = densenet161()
elif name == 'densenet169':
net = densenet169()
elif name == 'googlenet':
net = googlenet()
elif name == 'inception_v3':
net = inception_v3()
elif name == 'mobilenet_v2':
net = mobilenet_v2()
elif name == 'resnet18':
net = resnet18()
elif name == 'resnet34':
net = resnet34()
elif name == 'resnet50':
net = resnet50()
elif name == 'resnet_orig':
net = resnet_orig()
elif name == 'vgg11_bn':
net = vgg11_bn()
elif name == 'vgg13_bn':
net = vgg13_bn()
elif name == 'vgg16_bn':
net = vgg16_bn()
elif name == 'vgg19_bn':
net = vgg19_bn()
else:
print(f'{name} not a valid model name')
sys.exit(0)
return net.to(device)
def create_inceptionv3():
incept_ft = inception_v3(pretrained=True)
num_ftrs = incept_ft.fc.in_features
incept_ft.fc = nn.Linear(num_ftrs, 3)
incept_ft.aux_logits = False
print(num_ftrs)
incept_ft = incept_ft.cuda()
return incept_ft
def create_inceptionv3(load_weights=False):
incept_ft = inception_v3(pretrained=True)
num_ftrs = incept_ft.fc.in_features
incept_ft.fc = nn.Linear(num_ftrs, 3)
incept_ft.aux_logits = False
incept_ft = incept_ft.cuda()
incept_ft.name = 'inceptionv3'
return incept_ft
def __init__(self, embed_size, need_rep=False):
"""Load the pretrained ResNet-152 and replace top fc layer."""
super(EncoderCNN, self).__init__()
self.need_rep = need_rep
cnn = inception.inception_v3(pretrained=True)
cnn.fc = nn.Linear(cnn.fc.in_features, embed_size)
nn.init.xavier_uniform_(cnn.fc.weight)
nn.init.constant_(cnn.fc.bias, 0)
self.cnn = cnn
self.dropout = nn.Dropout(p=0.3)
self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)
def create_inceptionv3(load_weights=False, freeze=False):
incept_ft = inception_v3(pretrained=True)
if freeze:
for param in incept_ft.parameters():
param.requires_grad = False
num_ftrs = incept_ft.fc.in_features
incept_ft.fc = nn.Sequential(nn.Linear(num_ftrs, 1), nn.Sigmoid())
incept_ft.aux_logits = False
incept_ft = incept_ft.cuda()
incept_ft.name = 'inceptionv3'
incept_ft.batch_size = 32
return incept_ft
def main():
print('creating backbone')
backbone = inception_v3().to(device)
print('creating classifier')
classifier = ClassifierA(feature_dim=__CLASSIFIER_INPUT,
embed_dim=__EMBED_DIM,
dropout_ratio=__DROPOUT_RATIO).to(device)
# Initialize the models for this run
backbone_dict = backbone.state_dict()
pretrained_dict = torch.load(__OLD_BACKBONE_PATH)
pretrained_dict = {
k: v
for k, v in pretrained_dict.items() if k in backbone_dict
}
print('loading backbone keys {} from {}'.format(pretrained_dict.keys(),
__OLD_BACKBONE_PATH))
backbone_dict.update(pretrained_dict)
backbone.load_state_dict(backbone_dict)
# print('loading backbone from ' + __OLD_BACKBONE_PATH)
# backbone.load_state_dict(torch.load(__OLD_BACKBONE_PATH))
# print('loading classifier from ' + __OLD_CLASSIFIER_PATH)
# classifier.load_state_dict(torch.load(__OLD_CLASSIFIER_PATH))
backbone = nn.DataParallel(backbone, device_ids=device_ids)
classifier = nn.DataParallel(classifier, device_ids=device_ids)
dataloaders_dict = {
x: DataLoader(VolleyballDataset(x),
batch_size=__BATCH_SIZE,
shuffle=True,
num_workers=2,
collate_fn=collate_fn)
for x in ['trainval', 'test']
}
criterion_dict = {
'action': nn.CrossEntropyLoss(weight=__ACTION_WEIGHT),
'activity': nn.CrossEntropyLoss()
}
params = list(backbone.parameters()) + list(classifier.parameters())
optimizer = optim.Adam(params,
lr=__LEARNING_RATE,
weight_decay=__WEIGHT_DECAY)
train_model(backbone, classifier, dataloaders_dict, criterion_dict,
optimizer)
def __init__(self, depth=50, numclass=40):
super(inception_cnn, self).__init__()
self.backbone = inception_v3(pretrained=True, )
#self.avgpool = nn.AdaptiveAvgPool2d((1,1))
#self.classifier = nn.Sequential(
# nn.Linear(2048, 512),
# nn.ReLU(True),
# nn.Dropout(),
# nn.Linear(512,numclass)
# )
self.classifier = nn.Linear(2048, numclass)
#self.atn_s3 = MultiHeadAttention(4,2048,512,512)
self.atn_s4 = MultiHeadAttention(1, 2048, 512, 512)
def _load_pretrained_weight(self,
channels=4,
num_classes=28,
aux_logits=True,
transform_input=False):
## trick: get 4 channels weights from pretrained resnet
_net = torchvision.models.inception_v3(pretrained=True)
state_dict = _net.state_dict().copy()
layer0_weights = state_dict['Conv2d_1a_3x3.conv.weight']
print('raw_weight size: ', layer0_weights.size())
layer0_weights_new = torch.nn.Parameter(
torch.cat((layer0_weights, layer0_weights[:, :1, :, :]), dim=1))
print('new_weight size: ', layer0_weights_new.size())
new_state_dict = []
for key, value in state_dict.items():
if not aux_logits and 'AuxLogits' in key:
continue
if key == 'Conv2d_1a_3x3.conv.weight':
new_state_dict.append(
('Conv2d_1a_3x3.conv.weight', layer0_weights_new))
elif key in ['fc.weight', 'fc.bias']:
continue
elif key == 'AuxLogits.fc.weight':
new_state_dict.append(('AuxLogits.fc.weight',
nn.Parameter(
nn.init.xavier_uniform_(
torch.empty(
(28, 768),
requires_grad=True)))))
elif key == 'AuxLogits.fc.bias':
new_state_dict.append(
('AuxLogits.fc.bias',
nn.Parameter(torch.zeros(28, requires_grad=True))))
else:
new_state_dict.append((key, value))
new_state_dict = OrderedDict((k, v) for k, v in new_state_dict)
##
net = inception_v3(pretrained=False,
num_classes=num_classes,
aux_logits=aux_logits,
transform_input=transform_input)
net.load_state_dict(new_state_dict)
return net
def main():
global args, best_prec1
args = Params()
# create model
print("Using pre-trained model '{}'".format(args.arch))
#model = models.__dict__[args.arch](pretrained=True)
model = inception.inception_v3(pretrained=True)
model.fc = nn.Linear(2048, args.num_classes)
model.aux_logits = False
model = torch.nn.DataParallel(model).cuda()
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("Loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("Loaded checkpoint '{}' (epoch {})".format(
args.evaluate, checkpoint['epoch']))
else:
print("No checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# data loaders
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(ignat_loader.IGNAT_Loader(
args.rootdir, args.train_file,
transforms.Compose([
transforms.RandomSizedCrop(args.im_size_train),
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(ignat_loader.IGNAT_Loader(
args.rootdir, args.val_file,
transforms.Compose([
transforms.Scale(int(args.im_size_test / 0.875)),
transforms.CenterCrop(args.im_size_test),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad,
model.parameters()),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
_, _, preds, im_ids, feats = validate(val_loader, model, criterion,
args)
# write predictions to file
if args.save_preds:
np.save(args.op_file_name, feats)
# with open(args.op_file_name, 'w') as opfile:
# opfile.write('id,predicted\n')
# for ii in range(len(im_ids)):
# opfile.write(str(im_ids[ii]) + ',' + ' '.join(str(x) for x in preds[ii,:])+'\n')
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, cls_avg5, _, _, _ = validate(val_loader, model, criterion, args)
# remember best prec@1 and save checkpoint
# could also save based on cls_avg
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,
}, is_best)
import torchvision.models
import sklearn.svm
import torch.nn as nn
import numpy as np
import torch.utils.data
import matplotlib.pyplot as plt
import torchvision.transforms as transforms
from inception import inception_v3
from util import plot_confusion_matrix
model = inception_v3(pretrained=True)
# model.aux_logit = False
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
resize = transforms.Resize((299, 299))
preprocessor = transforms.Compose([
resize,
transforms.ToTensor(),
normalize,
])
# in_features = model.fc.in_features
# model.fc = nn.Linear(in_features, 9)
# new_classifier = nn.Sequential(*list(model.classifier.children())[:-1])
# model.classifier = new_classifier
data_dir1 = "./datasets/household/train"
batch_size1 = 64
data_dir2 = "./datasets/household/test"
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
from torch.autograd import Variable
torch.__file__
from inception import inception_v3
# import imp
# import inception
# imp.reload(inception)
# net = torchvision.models.vgg19_bn(pretrained=True)
# net = torchvision.models.inception_v3(pretrained=True, transform_input=False)
# net = torchvision.models.resnet152(pretrained=True)
net = inception_v3(pretrained=True)
net.eval();
from demjson import decode
classes = decode(open("imagenet1000_clsid_to_human.txt", "r").read())
from PIL import Image
img_size=299
transform = transforms.Compose(
[transforms.Resize(img_size),
transforms.RandomCrop(img_size),
transforms.ToTensor(),
# transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))])
transforms.Normalize((0.5,0.5,0.5), (0.5,0.5,0.5))])
boxes_in = tf.placeholder(tf.float32, [B,T,N,4], 'boxes_in')
boxes_idx_in = tf.placeholder(tf.int32, [B,T,N,], 'boxes_idx_in')
actions_in = tf.placeholder(tf.int32, [B,T,N,], 'actions_in')
activities_in = tf.placeholder(tf.int32, [B,T,], 'activities_in')
dropout_keep_prob_in = tf.placeholder(tf.float32, [], 'dropout_keep_prob_in')
images_in_flat = tf.reshape(images_in, [B*T,H,W,3])
boxes_in_flat = tf.reshape(boxes_in, [B*T*N,4])
boxes_idx_in_flat = tf.reshape(boxes_idx_in, [B*T*N,])
actions_in_flat = tf.reshape(actions_in, [B*T*N,])
activities_in_flat = tf.reshape(activities_in, [B*T,])
# TODO: only construct inception until a certain level
_, inception_endpoints = inception.inception_v3(inception.process_images(images_in_flat),
trainable=c.train_inception,
is_training=False,
create_logits=False,
scope='InceptionV3')
inception_vars = tf.get_collection(tf.GraphKeys.VARIABLES, 'InceptionV3')
# extracting multiscale features
features_multiscale = []
for name in c.features_multiscale_names:
features = inception_endpoints[name]
if features.get_shape()[1:3] != tf.TensorShape([OH, OW]):
features = tf.image.resize_images(features, OH, OW)
features_multiscale.append(features)
features_multiscale = tf.concat(3, features_multiscale)
if c.build_detnet:
# TODO: instead of boxes_in
])
train_data = datasets.ImageFolder('kaggle/train/', transform=transform_train)
trainloader = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)
test_data = datasets.ImageFolder('kaggle/test/', transform=transform_test)
testloader = DataLoader(test_data, batch_size=BATCH_SIZE, shuffle=False, num_workers=2)
# class
classes = {0: 'cat', 1: 'dog'}
# fine tuning
if PRETRAINED:
net = inception_v3(pretrained=PRETRAINED)
for param in net.parameters():
param.requires_grad = False
net.fc = torch.nn.Linear(2048, 2)
else:
net = inception_v3(pretrained=PRETRAINED, num_classes=len(classes))
final_conv = 'Mixed_7c'
net.cuda()
# load checkpoint
if RESUME != 0:
print("===> Resuming from checkpoint.")
assert os.path.isfile('checkpoint/'+ str(RESUME) + '.pt'), 'Error: no checkpoint found!'
net.load_state_dict(torch.load('checkpoint/' + str(RESUME) + '.pt'))
elif slide:
rightslide(lastcommand)
elif grapple:
rightgrapple(lastcommand)
else:
right(lastcommand)
lastcommand = moves
previouslyjumped = jump
#jump = False
keys = key_check()
if 'T' in keys:
paused = True
os.system('cls')
time.sleep(1)
if 'Y' in keys:
os.system('cls')
ReleaseKey(A)
ReleaseKey(W)
ReleaseKey(D)
paused = False
model = inception_v3(WIDTH, HEIGHT, 3, LR, output=5)
model.load(MODEL_NAME)
print('Begin in a few seconds..')
countdown(3)
testloop()
def inception_score(imgs,
cuda=True,
batch_size=32,
resize=False,
expand=False,
splits=1):
"""Computes the inception score of the generated images imgs
imgs -- Torch dataset of (3xHxW) numpy images normalized in the range [-1, 1]
cuda -- whether or not to run on GPU
batch_size -- batch size for feeding into Inception v3
splits -- number of splits
"""
N = len(imgs)
assert batch_size > 0
assert N > batch_size, 'len(imgs): %d is smaller than batch size: %d' % (
N, batch_size)
# Set up dtype
if cuda:
dtype = torch.cuda.FloatTensor
else:
if torch.cuda.is_available():
print(
"WARNING: You have a CUDA device, so you should probably set cuda=True"
)
dtype = torch.FloatTensor
# Set up dataloader
dataloader = torch.utils.data.DataLoader(imgs, batch_size=batch_size)
# Load inception model
inception_model = inception_v3(pretrained=True,
transform_input=False).type(dtype)
inception_model.eval()
up = nn.Upsample(size=(299, 299), mode='bilinear').type(dtype)
def get_pred(x):
if resize:
x = up(x)
if expand:
x = x.expand(-1, 3, -1, -1)
x = inception_model(x)
return F.softmax(x).data.cpu().numpy()
# Get predictions
preds = np.zeros((N, 1000))
for i, batch in enumerate(dataloader, 0):
batch = batch.type(dtype)
batchv = Variable(batch)
batch_size_i = batch.size()[0]
preds[i * batch_size:i * batch_size + batch_size_i] = get_pred(batchv)
# Now compute the mean kl-div
split_scores = []
for k in range(splits):
part = preds[k * (N // splits):(k + 1) * (N // splits), :]
py = np.mean(part, axis=0)
scores = []
for i in range(part.shape[0]):
pyx = part[i, :]
scores.append(entropy(pyx, py))
split_scores.append(np.exp(np.mean(scores)))
return np.mean(split_scores), np.std(split_scores)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(100.0 / batch_size))
return res
NAME_TO_MODEL = {
# 'resnet50': resnet50(num_classes=100),
# 'ayangnet': AyangNet(),
# 'densenet': models.densenet161(num_classes=100),
'inceptionv3': inception_v3(num_classes=10),
'simplenet': SimpleConvNet(num_classes=10)
# 'inceptionv4': inception_v4(num_classes=100),
# 'wideresnet': WideResNet(28, 100, widen_factor=10),
# 'widedensenet': DenseNet(60, (6, 6, 6, 6), 64, num_classes=100)
}
if __name__ == '__main__':
default_path = '../data'
noise_decay = 0.55
loss_fn = CrossEntropyLoss()
# set up argument parser
parser = argparse.ArgumentParser()
# experiment
model.eval()
pred_ = model(torch.from_numpy(X).to(device))
return pred_.cpu().data.numpy()
if __name__ == '__main__':
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
if not os.path.exists(args.train_dir):
os.mkdir(args.train_dir)
if args.is_train:
X_train, X_test, y_train, y_test = load_fundus(args.data_dir,
args.label)
X_val, y_val = X_train[1600:], y_train[1600:]
X_train, y_train = X_train[:1600], y_train[:1600]
model = inception_v3()
model.to(device)
print(model)
update_parameters = []
print("params to update:")
for name, param in model.named_parameters():
if param.requires_grad == True:
update_parameters.append(param)
print('\t', name)
optimizer = optim.Adam(update_parameters, lr=args.learning_rate)
pre_losses = [1e18] * 3
best_val_acc = 0.0
for epoch in range(1, args.num_epochs + 1):
start_time = time.time()
# https://www.microsoft.com/en-us/download/confirmation.aspx?id=54765
train_data = datasets.ImageFolder('~/dataset/dataset_dogs_vs_cats/train/',
transform=transform_train)
trainloader = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True)
test_data = datasets.ImageFolder('~/dataset/dataset_dogs_vs_cats/test/',
transform=transform_test)
testloader = DataLoader(test_data, batch_size=BATCH_SIZE, shuffle=False)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('Using device:', device)
# fine tuning
if PRETRAINED:
model = inception_v3(pretrained=PRETRAINED)
for param in model.parameters():
param.requires_grad = False
model.fc = torch.nn.Linear(2048, 2)
else:
model = inception_v3(pretrained=PRETRAINED,
num_classes=len(train_data.classes))
summary(model, (3, 224, 224))
# load checkpoint
if RESUME is not None:
print("===> Resuming from checkpoint.")
assert os.path.isfile('checkpoint/' + str(RESUME) +
'.pt'), 'Error: no checkpoint found!'
model.load_state_dict(
def __init__(self):
super().__init__()
pretrained = inception_v3(pretrained=True)
self.inception = pretrained
trainloader = DataLoader(train_data,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=2)
test_data = datasets.ImageFolder('kaggle/test/', transform=transform_test)
testloader = DataLoader(test_data,
batch_size=BATCH_SIZE,
shuffle=False,
num_workers=2)
# class
classes = {0: 'cat', 1: 'dog'}
# network
net = inception_v3(pretrained=PRETRAINED)
final_conv = 'Mixed_7c'
# fine tuning
if PRETRAINED:
for param in net.parameters():
param.requires_grad = False
net.fc = torch.nn.Linear(2048, 2)
net.cuda()
# load checkpoint
if RESUME != 0:
print("===> Resuming from checkpoint.")
assert os.path.isfile('checkpoint/' + str(RESUME) +
'.pt'), 'Error: no checkpoint found!'
