def eval_imagenet_q(net_name, param_pickle_path):
netparams = load.load_netparams_tf_q(param_pickle_path)
data_spec = networks.get_data_spec(net_name)
input_node = tf.placeholder(tf.float32,
shape=(None, data_spec.crop_size,
data_spec.crop_size,
data_spec.channels))
label_node = tf.placeholder(tf.int32)
if net_name == 'alexnet':
logits_ = networks.alexnet(input_node, netparams)
elif net_name == 'googlenet':
logits_ = networks.googlenet(input_node, netparams)
elif net_name == 'nin':
logits_ = networks.nin(input_node, netparams)
elif net_name == 'resnet18':
logits_ = networks.resnet18(input_node, netparams)
elif net_name == 'resnet50':
logits_ = networks.resnet50(input_node, netparams)
elif net_name == 'squeezenet':
logits_ = networks.squeezenet(input_node, netparams)
elif net_name == 'vgg16net':
logits_ = networks.vgg16net_noisy(input_node, netparams)
loss_op = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits_,
labels=label_node)) #
probs = softmax(logits_)
top_k_op = tf.nn.in_top_k(probs, label_node, 5)
optimizer = tf.train.AdamOptimizer(learning_rate=0.001, epsilon=0.1)
correct_pred = tf.equal(tf.argmax(probs, 1), tf.argmax(label_node, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
count = 0
correct = 0
cur_accuracy = 0
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
image_producer = dataset.ImageNetProducer(val_path=IMAGE_LABLE,
data_path=IMAGE_PATH,
data_spec=data_spec)
total = len(image_producer)
coordinator = tf.train.Coordinator()
threads = image_producer.start(session=sess, coordinator=coordinator)
for (labels, images) in image_producer.batches(sess):
correct += np.sum(
sess.run(top_k_op,
feed_dict={
input_node: images,
label_node: labels
}))
count += len(labels)
cur_accuracy = float(correct) * 100 / count
#print('{:>6}/{:<6} {:>6.2f}%'.format(count, total, cur_accuracy))
print(cur_accuracy)
coordinator.request_stop()
coordinator.join(threads, stop_grace_period_secs=2)
return cur_accuracy
val_loss, val_accuray = validate(val_data, net, criterion,
(opt.num_parts + 1), ctx)
epoch_str = (
"Epoch %d. Train loss: %f, Val loss %f, Val accuray %f, " %
(epoch, __loss, val_loss, val_accuray))
else:
epoch_str = ("Epoch %d. Train loss: %f, " % (epoch, __loss))
prev_time = cur_time
print(epoch_str + time_str + ', lr ' + str(trainer.learning_rate))
net.save_parameters("params/resnet50.params")
if __name__ == '__main__':
opt = parser.parse_args()
logging.info(opt)
random.seed(opt.seed)
mx.random.seed(opt.seed)
batch_size = opt.batch_size
num_gpus = opt.num_gpus
context = [mx.gpu(i) for i in range(num_gpus)]
epochs = [int(i) for i in opt.epochs.split(',')]
batch_size *= max(1, num_gpus)
net = resnet50(ctx=context,
num_features=256,
num_classes=751,
num_parts=opt.num_parts)
main(net, batch_size, epochs, opt, context)
# set gpu ids
if len(gpu_ids) > 0:
context = mx.gpu()
test_set = [(line, int(line.split('_')[0]))
for line in os.listdir(data_dir + 'test')]
query_set = [(line, int(line.split('_')[0]))
for line in os.listdir(data_dir + 'query')]
test_cam, test_label = get_id(test_set)
query_cam, query_label = get_id(query_set)
######################################################################
# Load Collected data Trained model
model_structure = resnet50(ctx=context, pretrained=False)
model = load_network(model_structure, context)
# Extract feature
test_loader, query_loader = get_data(batch_size, test_set, query_set)
print('start test')
test_feature = extract_feature(model, test_loader, context)
print('start query')
query_feature = extract_feature(model, query_loader, context)
# Save to Matlab for check
sio.savemat('result/test.mat', {'data': test_feature})
sio.savemat('result/testID.mat', {'data': test_label})
sio.savemat('result/testCam.mat', {'data': test_cam})
sio.savemat('result/query.mat', {'data': query_feature})
if val_data is not None:
val_loss, val_accuracy = validate(val_data, net, criterion, ctx)
epoch_str = (
"Epoch %d. Train loss: %f, Val loss %f, Val accuracy %f, " %
(epoch, __loss, val_loss, val_accuracy))
else:
epoch_str = ("Epoch %d. Train loss: %f, " % (epoch, __loss))
prev_time = cur_time
print(epoch_str + time_str + ', lr ' + str(trainer.learning_rate))
if not os.path.exists("params"):
os.mkdir("params")
net.save_parameters("params/resnet50.params")
if __name__ == '__main__':
opt = parser.parse_args()
logging.info(opt)
mx.random.seed(opt.seed)
batch_size = opt.batch_size
num_gpus = opt.num_gpus
epochs = [int(i) for i in opt.epochs.split(',')]
batch_size *= max(1, num_gpus)
context = [mx.gpu(i) for i in range(num_gpus)]
net = resnet50(ctx=context, num_classes=751)
main(net, batch_size, epochs, opt, context)
for x in ['train', 'val']
}
dataloaders = {
x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=batch_size,
shuffle=True,
num_workers=0)
for x in ['train', 'val']
}
print('size of dataloader: {}'.format(dataloaders.__sizeof__()))
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes
model_slice = networks.resnet50(pretrained=False)
model_slice.cuda()
num_ftrs_slice = model_slice.fc.in_features
model_slice.fc = nn.Linear(num_ftrs_slice, 2)
model_slice = model_slice.to(device)
model_patch = networks.resnet34(pretrained=False)
model_patch.cuda()
num_ftrs_patch = model_patch.fc.in_features
model_patch.fc = nn.Linear(num_ftrs_patch, 2)
model_patch = model_patch.to(device)
slice_model_path = os.path.join(slice_dir, 'best_scratch_ResNet-50.pth')
patch_model_path = os.path.join(patch_dir, 'best_scratch_ResNet-34.pth')
'''Load the pretrained streams!'''
model_slice.load_state_dict(
# set gpu ids
if len(gpu_ids) > 0:
context = mx.gpu()
test_set = [(line, int(line.split('_')[0]))
for line in os.listdir(data_dir + 'test')]
query_set = [(line, int(line.split('_')[0]))
for line in os.listdir(data_dir + 'query')]
test_cam, test_label = get_id(test_set)
query_cam, query_label = get_id(query_set)
######################################################################
# Load Collected data Trained model
model_structure = resnet50(ctx=context,
pretrained=False,
num_features=256,
num_classes=751)
model = load_network(model_structure, context)
# Extract feature
test_loader, query_loader = get_data(batch_size, test_set, query_set)
print('start test')
test_feature = extract_feature(model, test_loader, context)
print('start query')
query_feature = extract_feature(model, query_loader, context)
# Save to Matlab for check
sio.savemat('result/test.mat', {'data': test_feature})
sio.savemat('result/testID.mat', {'data': test_label})
sio.savemat('result/testCam.mat', {'data': test_cam})
def get_setting():
global n_classes
if 'svhn' in args.dataset:
transform = tv.transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
source = tv.datasets.SVHN(ROOT, download=True, transform=transform)
source.targets = torch.tensor(source.labels)
test = tv.datasets.MNIST(ROOT,
train=False,
download=True,
transform=tv.transforms.Compose(
[tv.transforms.Grayscale(3), transform]))
target = tv.datasets.MNIST(
ROOT,
train=True,
download=True,
transform=tv.transforms.Compose(
[tv.transforms.Grayscale(3), transform]),
target_transform=transforms.Lambda(lambda y: -1))
EPOCHS = 150
batch_size = 64
n_classes = 10
net = svhn_net().to(device)
init_lr = 0.01
elif 'mnist' in args.dataset:
transform = tv.transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
source = tv.datasets.MNIST(ROOT,
train=True,
download=True,
transform=tv.transforms.Compose(
[tv.transforms.Grayscale(3),
transform]))
test = MNISTM(ROOT, train=False, download=True, transform=transform)
target = MNISTM(ROOT,
train=True,
download=True,
transform=transform,
target_transform=transforms.Lambda(lambda y: -1))
EPOCHS = 40
net = lenet_net().to(device)
batch_size = 64
n_classes = 10
init_lr = 0.01
else:
paths = {
"p": ROOT + "office/Product",
"a": ROOT + "office/Art",
"c": ROOT + "office/Clipart",
"r": ROOT + "office/Real World"
}
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
# Normalize to have range between -1,1 : (x - 0.5) * 2
transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor(), normalize])
# Create data augmentation transform
augmentation = transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224, (0.6, 1.)),
transforms.RandomHorizontalFlip(), transform
])
source = ImageFolder(paths[args.source], augmentation)
target = ImageFolder(paths[args.target],
augmentation,
target_transform=transforms.Lambda(lambda y: -1))
test = ImageFolder(paths[args.target], transform)
EPOCHS = 60
n_classes = 65
net = resnet50(pretrained=True, num_classes=65).to(device)
batch_size = 32
init_lr = 0.001
# target_loader = DataLoader(target, batch_size=batch_size, shuffle=True, num_workers=8)
test_loader = DataLoader(test,
batch_size=batch_size,
shuffle=False,
num_workers=8)
target_loader = DataLoader(target,
batch_size=batch_size,
shuffle=True,
num_workers=8)
source_loader = DataLoader(source,
batch_size=batch_size,
shuffle=True,
num_workers=8)
return target_loader, source_loader, test_loader, net, EPOCHS, init_lr
time_str = "Time %02d:%02d:%02d" % (h, m, s)
__loss = _loss/len(train_data)
if val_data is not None:
val_loss, val_accuray = validate(val_data, net, criterion, ctx)
epoch_str = ("Epoch %d. Train loss: %f, Val loss %f, Val accuray %f, " % (epoch, __loss , val_loss, val_accuray))
else:
epoch_str = ("Epoch %d. Train loss: %f, " % (epoch, __loss))
prev_time = cur_time
print(epoch_str + time_str + ', lr ' + str(trainer.learning_rate))
if not os.path.exists("params"):
os.mkdir("params")
net.save_parameters("params/resnet50.params")
if __name__ == '__main__':
opt = parser.parse_args()
logging.info(opt)
mx.random.seed(opt.seed)
batch_size = opt.batch_size
num_gpus = opt.num_gpus
epochs = [int(i) for i in opt.epochs.split(',')]
batch_size *= max(1, num_gpus)
context = [mx.gpu(i) for i in range(num_gpus)]
net = resnet50(ctx=context, num_classes=751)
main(net, batch_size, epochs, opt, context)
__loss = _loss/len(train_data)
if val_data is not None:
val_loss, val_accuray = validate(val_data, net, criterion1, criterion2, ctx)
epoch_str = ("Epoch %d. Train loss: %f, Val loss %f, Val accuray %f, " % (epoch, __loss , val_loss, val_accuray))
else:
epoch_str = ("Epoch %d. Train loss: %f, " % (epoch, __loss))
prev_time = cur_time
print(epoch_str + time_str + ', lr ' + str(trainer.learning_rate))
if not os.path.exists("params"):
os.mkdir("params")
net.save_parameters("params/resnet50.params")
if __name__ == '__main__':
opt = parser.parse_args()
logging.info(opt)
random.seed(opt.seed)
mx.random.seed(opt.seed)
batch_size = opt.batch_size
num_gpus = opt.num_gpus
context = [mx.gpu(i) for i in range(num_gpus)]
epochs = [int(i) for i in opt.epochs.split(',')]
batch_size *= max(1, num_gpus)
net = resnet50(ctx=context, num_features=256, num_classes=751)
main(net, batch_size, epochs, opt, context)
data_dir = osp.expanduser("~/.mxnet/datasets/Market-1501-v15.09.15/")
gpu_ids = [0]
# set gpu ids
if len(gpu_ids)>0:
context = mx.gpu()
test_set = [(osp.join(data_dir,'bounding_box_test',line), int(line.split('_')[0])) for line in os.listdir(data_dir+'bounding_box_test') if "jpg" in line and "-1" not in line]
query_set = [(osp.join(data_dir,'query',line), int(line.split('_')[0])) for line in os.listdir(data_dir+'query') if "jpg" in line]
test_cam, test_label = get_id(test_set)
query_cam, query_label = get_id(query_set)
######################################################################
# Load Collected data Trained model
model_structure = resnet50(ctx=context, pretrained=False)
model = load_network(model_structure, context)
# Extract feature
test_loader, query_loader = get_data(batch_size, test_set, query_set)
print('start test')
test_feature = extract_feature(model, test_loader, context)
print('start query')
query_feature = extract_feature(model, query_loader, context)
query_feature = nd.array(query_feature).as_in_context(mx.gpu(0))
test_feature = nd.array(test_feature).as_in_context(mx.gpu(0))
num = query_label.size
dist_all = nd.linalg.gemm2(query_feature, test_feature, transpose_b=True)
