def __init__(self,
num_classes=1000,
gpu_id=0,
print_freq=10,
epoch_print=10):
self.num_classes = num_classes
self.gpu = gpu_id
self.print_freq = print_freq
self.epoch_print = epoch_print
torch.cuda.set_device(self.gpu)
self.loss_function = nn.CrossEntropyLoss().cuda(self.gpu)
self.model = model.AlexNet(self.num_classes).cuda(self.gpu)
self.train_losses = []
self.train_acc = []
self.test_losses = []
self.test_acc = []
self.best_acc = 0
])
test_dataset = torchvision.datasets.ImageFolder(root='work/data/test/',
transform=data_transform)
test_loader = DataLoader(test_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=0)
#花卉类别
data_classes = test_dataset.classes
#选择CPU还是GPU的操作
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net = model.AlexNet()
net.load_state_dict(torch.load('alexnet_flower_500.pkl'))
#model.eval()
correct = 0
total = 0
with torch.no_grad():
for data in test_loader:
images, labels = data
#images, labels = images.to(device), labels.to(device)
images.to(device), labels.to(device)
images, labels = Variable(images), Variable(labels)
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
import torch
import torch.nn as nn
import torch.nn.functional as F
import model
from torch.autograd import Variable
N = 10
C_in = 3
D_in = 16
H = 224
W = 224
num_classes = 10
if __name__ == "__main__":
m = model.AlexNet(32)
x = Variable(torch.randn(N, C_in, H, W))
class_weights = torch.Tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
# y = Variable(torch.multinomial(class_weights, N, replacement=True),
# requires_grad=False)
y = Variable(torch.rand(N, 64))
loss_fn = torch.nn.MSELoss()
y_pred = m.forward(x)
print(y_pred.size())
loss = loss_fn(y_pred, y)
print(loss)
import sys
import numpy as np
import model as Model
import torch.optim as optim
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as transforms
from timeit import default_timer as timer
from torch.autograd import Variable
from PIL import Image, ImageDraw, ImageFont
trained_model = "weights/human36m.pth.tar"
model = Model.AlexNet(32)
weights = torch.load(trained_model, map_location=lambda storage, loc: storage)
model.load_state_dict(weights["state_dict"])
normalize = transforms.Normalize(mean=[0.00094127, 0.00060294, 0.0005603],
std=[0.02102633, 0.01346872, 0.01251619])
transform = transforms.Compose(
[transforms.Scale((220, 220)),
transforms.ToTensor(), normalize])
joint_names = [
"Hips", "RightUpLeg", "RightLeg", "RightFoot", "RightToeBase", "Site",
"LeftUpLeg", "LeftLeg", "LeftFoot", "LeftToeBase", "Site", "Spine",
"Spine1", "Neck", "Head", "Site", "LeftShoulder", "LeftArm", "LeftForeArm",
"LeftHand", "LeftHandThumb", "Site", "L_Wrist_End", "Site",
"RightShoulder", "RightArm", "RightForeArm", "RightHand", "RightHandThumb",
"Site", "R_Wrist_End", "Site"
def feature_extraction(image_path, batchsize, out_path, out_name, save_flag):
"""
This function is to extract features from alexnet.
Be careful that the total number of images must be a multiple of 1000
"""
print '\nLoad alexnet KERAS model...'
# the path of the weights of pretraine Alexnet
alexnet = model.AlexNet(
'/home/xt/tong/mopsi/feature/keras/alexnet_weights.h5')
net = Model(input=alexnet.input,
output=alexnet.get_layer('dense_2').output)
nb_image = len(image_path)
feature = np.zeros((nb_image, 4096))
# divide into minibatchs of 1000 images
index = 0
nb_batch = nb_image / 1000
# handle with 1000 images each time
for m in range(nb_batch):
image_batch = np.zeros((1000, 3, 227, 227))
print '\n Load %dth 1000 images...' % m
for i, img_path in enumerate(image_path[m * 1000:m * 1000 + 1000]):
im = Image.open(img_path)
im = im.resize((227, 227))
im = np.array(im).astype(np.float32)
if im.shape == (227, 227):
im = to_rgb(im)
im[:, :, 0] -= 123.68
im[:, :, 1] -= 116.779
im[:, :, 2] -= 103.939
im = im.transpose((2, 0, 1))
im = np.expand_dims(im, axis=0)
image_batch[i] = im
# extraction of feature
print "Extract features..."
feature[m * 1000:m * 1000 + 1000] = net.predict(image_batch,
batch_size=batchsize)
"""
# check distance between features
dis = cosine_similarity(feature)
print dis
"""
# save feature matrix to pkl file
fp_f = open(os.path.join(out_path, out_name + '_feature.pkl'), 'wb')
pickle.dump(feature, fp_f)
fp_f.close()
# write feature to txt
fp = open(os.path.join(out_path, out_name + '_feature.txt'), "w")
for item in feature:
fp.write(' '.join(map(str, list(item))))
fp.write('\n')
fp.close()
# save cosine distance
if save_flag[0]:
print '\nSave cosine distance...'
cos_dis = cosine_distances(feature)
fp_cos = open(out_path + 'dis/' + out_name + '_cosine_dis.pkl', 'wb')
pickle.dump(cos_dis, fp_cos)
fp_cos.close()
# save euclidean distance
if save_flag[1]:
print '\nSave euclidean distance...'
euc_dis = euclidean_distances(feature)
fp_euc = open(out_path + 'dis/' + out_name + '_euclidean_dis.pkl',
'wb')
pickle.dump(euc_dis, fp_euc)
fp_euc.close()
# save hamming distance
if save_flag[2]:
print '\nSave hamming distance...'
dist = DistanceMetric.get_metric('hamming')
ham_dis = dist.pairwise(np.where(feature > 0, 1, 0))
fp_ham = open(out_path + 'dis/' + out_name + '_hamming_dis.pkl', 'wb')
pickle.dump(ham_dis, fp_ham)
fp_ham.close()
# save jaccard distance
if save_flag[3]:
print '\nSave jaccard distance...'
dist = DistanceMetric.get_metric('jaccard')
jac_dis = dist.pairwise(feature != 0)
fp_jac = open(out_path + 'dis/' + out_name + '_jaccard_dis.pkl', 'wb')
pickle.dump(jac_dis, fp_jac)
fp_jac.close()
return feature
import time
data_root = sys.argv[3]
root = sys.argv[4]
model_path = sys.argv[5]
data_path = sys.argv[6]
if sys.argv[2] == 'cifar10':
lr = 1e-5
dataset = data_loader.cifar_10_dataset(data_path + '/cifar-10-batches-py/',
buffer_size=1024,
batch_size=128)
if sys.argv[1] == '0':
f = open(root + '/AlexNet.log', 'w')
model_name = 'AlexNetAtt'
alexattnet = model.AlexNet(classes=10)
if sys.argv[1] == '1':
f = open(root + '/AlexNetAttDSSpatial.log', 'w')
model_name = 'AlexNetAttDSSpatial'
alexattnet = model.AlexAttNet(classes=10)
elif sys.argv[1] == '2':
f = open(root + '/AlexNetAttPCSpatial.log', 'w')
model_name = 'AlexNetAttPCSpatial'
alexattnet = model.AlexNetAttSpatial(classes=10)
elif sys.argv[1] == '3':
f = open(root + '/AlexNetGAP.log', 'w')
model_name = 'AlexNetAttGAP'
alexattnet = model.AlexNetGAP(classes=10)
DATA_DIR = '/home/vaibhavg/data/'
AFLW2000_DATA_DIR = DATA_DIR + 'AFLW2000/'
AFLW2000_MODEL_FILE = PROJECT_DIR + 'model/aflw2000_model.h5'
AFLW2000_TEST_SAVE_DIR = DATA_DIR + 'aflw2000_test/'
BIWI_DATA_DIR = DATA_DIR + 'Biwi/kinect_head_pose_db/hpdb/'
BIWI_MODEL_FILE = PROJECT_DIR + 'model/biwi_model.h5'
BIWI_TEST_SAVE_DIR = DATA_DIR + 'biwi_test/'
BIN_NUM = 66
INPUT_SIZE = 64
BATCH_SIZE = 16
EPOCHS = 20
dataset = datasets.Biwi(BIWI_DATA_DIR,
'filename_list.txt',
batch_size=BATCH_SIZE,
input_size=INPUT_SIZE,
ratio=0.95)
net = model.AlexNet(dataset,
BIN_NUM,
batch_size=BATCH_SIZE,
input_size=INPUT_SIZE)
net.train(BIWI_MODEL_FILE, max_epoches=EPOCHS, load_weight=False)
net.test(BIWI_TEST_SAVE_DIR)
def main():
global args, best_acc
args = parser.parse_args()
# Set paths
base_path = os.path.normpath(args.data)
train_path = os.path.join(base_path, "train/images")
val_path = os.path.join(base_path, "val/images")
target_path = os.path.join(base_path, "targets")
print(train_path)
torch.cuda.manual_seed(1)
m = model.AlexNet(32)
m.cuda()
normalize = data_transforms.Normalize(
mean=[0.00094127, 0.00060294, 0.0005603],
std=[0.02102633, 0.01346872, 0.01251619])
print("Loading data...")
train_dset = human36m.HUMAN36MPose(
train_path,
target_path,
transform=data_transforms.Compose([
data_transforms.CropToTarget(20),
data_transforms.Scale((220, 220)),
data_transforms.RandomHorizontalFlip(),
data_transforms.ToTensor(), normalize
]))
val_dset = human36m.HUMAN36MPose(val_path,
target_path,
transform=data_transforms.Compose([
data_transforms.CropToTarget(20),
data_transforms.Scale((220, 220)),
data_transforms.ToTensor(), normalize
]))
train_loader = torch.utils.data.DataLoader(train_dset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(val_dset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# Define loss function and optimizer
criterion = nn.MSELoss().cuda()
optimizer = torch.optim.SGD(m.parameters(),
args.learning_rate,
momentum=args.momentum)
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_acc = checkpoint["best_acc"]
m.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))
print("Starting \"training\"")
for epoch in range(args.start_epoch, args.epochs):
# train
train(train_loader, m, criterion, optimizer, epoch)
acc = validate(val_loader, m, criterion)
is_best = acc > best_acc
best_acc = max(acc, best_acc)
save_checkpoint(
{
"epoch": epoch + 1,
"state_dict": m.state_dict(),
"best_acc": best_acc,
"optimizer": optimizer.state_dict(),
}, is_best)
import model
import train_util
import torch
import torch.nn as nn
import torch.optim as optim
train_path = ''
val_path = ''
dset_loaders, dset_sizes, dset_classes = data_util.load_data(
train_path=train_path, val_path=val_path)
print(dset_sizes)
print(dset_classes)
net = model.AlexNet().cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), weight_decay=0.0005)
lr_scheduler = train_util.exp_lr_scheduler
lr = 0.001
best_model, best_acc = train_util.train(net, criterion, optimizer,
lr_scheduler, dset_loaders, dset_sizes,
lr, 40)
print('Saving the best model')
filename = 'trained_model_val_{:.2f}.pt'.format(best_acc)
torch.save(best_model.state_dict(), filename)
