def create_model(name, num_classes):
if name == 'resnet34':
model = models.resnet34(True)
model.fc = nn.Linear(model.fc.in_features, num_classes)
nn.init.xavier_uniform(model.fc.weight)
nn.init.constant(model.fc.bias, 0)
elif name == 'resnet152':
model = models.resnet152(True)
model.fc = nn.Linear(model.fc.in_features, num_classes)
nn.init.xavier_uniform(model.fc.weight)
nn.init.constant(model.fc.bias, 0)
elif name == 'densenet121':
model = models.densenet121(True)
model.classifier = nn.Linear(model.classifier.in_features, num_classes)
nn.init.xavier_uniform(model.classifier.weight)
nn.init.constant(model.classifier.bias, 0)
elif name == 'vgg11_bn':
model = models.vgg11_bn(False, num_classes)
elif name == 'vgg19_bn':
model = models.vgg19_bn(True)
model.classifier._modules['6'] = nn.Linear(model.classifier._modules['6'].in_features, num_classes)
nn.init.xavier_uniform(model.classifier._modules['6'].weight)
nn.init.constant(model.classifier._modules['6'].bias, 0)
elif name == 'alexnet':
model = models.alexnet(True)
model.classifier._modules['6'] = nn.Linear(model.classifier._modules['6'].in_features, num_classes)
nn.init.xavier_uniform(model.classifier._modules['6'].weight)
nn.init.constant(model.classifier._modules['6'].bias, 0)
else:
model = Net(num_classes)
return model
def train_alexnet_imagenet(classes=5):
model = alexnet(input_shape=(3, 227, 227), nb_classes=1000, mean_flag=True)
model.load_weights('alexnet_weights.h5')
# add in own classes ( maybe not necessary)
last_layer = model.layers[-3].output
dense_classifier = Dense(5, activation='softmax',
name='me_dense')(last_layer)
model = Model(inputs=model.input, outputs=dense_classifier)
plot_model(model, to_file='alexnet', show_shapes=True)
print(model.summary())
# freezing
# # 3rd Last
# for layer in model.layers[:-22]:
# layer.trainable = False
# # 2nd Last
# for layer in model.layers[:-20]:
# layer.trainable = False
# # Last
# for layer in model.layers[:-14]:
# layer.trainable = False
return model
def train_shallow_alexnet_imagenet_FCN(classes=5, freeze_flag=None):
model = alexnet(input_shape=(3, 227, 227), nb_classes=1000, mean_flag=True)
model.load_weights('alexnet_weights.h5')
# modify architecture
last_conv_1 = model.layers[5].output
conv_2 = Conv2D(256, (5, 5),
strides=(1, 1),
activation='relu',
name='conv_2',
kernel_initializer='he_normal',
bias_initializer='he_normal')(last_conv_1)
conv_2 = MaxPooling2D((3, 3), strides=(2, 2))(conv_2)
conv_2 = crosschannelnormalization(name="convpool_2")(conv_2)
conv_2 = ZeroPadding2D((2, 2))(conv_2)
conv_2 = Dropout(0.5)(conv_2)
conv_activate = Conv2D(classes,
kernel_size=(1, 1),
strides=(1, 1),
activation='relu',
kernel_initializer='he_normal',
bias_initializer='he_normal',
name='conv_activate')(conv_2)
conv_activate = GlobalAveragePooling2D(
data_format='channels_first')(conv_activate)
model = Model(inputs=model.input, outputs=conv_activate)
plot_model(model, to_file='shallowalex_fcn', show_shapes=True)
print(model.summary())
return model
def __init__(self, opt):
super().__init__()
model = models.alexnet(pretrained=opt['pretrained'])
relu = ['1', '4', '7', '9', '11']
for i in relu:
model.features._modules[i] = nn.LeakyReLU(inplace=True)
self.features = model.features
self.classifier = nn.Sequential(
nn.Conv2d(256,
128,
kernel_size=(3, 3),
stride=(1, 2),
padding=(1, 1)), nn.LeakyReLU(inplace=True),
nn.Conv2d(128,
1,
kernel_size=(3, 3),
stride=(1, 2),
padding=(1, 1)), nn.LeakyReLU(inplace=True),
nn.MaxPool2d(kernel_size=(4, 10)), View(1), nn.Sigmoid())
self.Nf = num_parameters(self.features)
self.Nc = num_parameters(self.classifier)
s = '[%s] Features parameters: %d, Classifier Parameters: %d' % (
self.name, self.Nf, self.Nc)
print(s)
def check_summary():
def torch_summarize(model, show_weights=True, show_parameters=True):
"""Summarizes torch model by showing trainable parameters and weights."""
from torch.nn.modules.module import _addindent
tmpstr = model.__class__.__name__ + ' (\n'
for key, module in model._modules.items():
# if it contains layers let call it recursively to get params and weights
if type(module) in [
torch.nn.modules.container.Container,
torch.nn.modules.container.Sequential
]:
modstr = torch_summarize(module)
else:
modstr = module.__repr__()
modstr = _addindent(modstr, 2)
params = sum([np.prod(p.size()) for p in module.parameters()])
weights = tuple([tuple(p.size()) for p in module.parameters()])
tmpstr += ' (' + key + '): ' + modstr
if show_weights:
tmpstr += ', weights={}'.format(weights)
if show_parameters:
tmpstr += ', parameters={}'.format(params)
tmpstr += '\n'
tmpstr = tmpstr + ')'
return tmpstr
# Test
import torchvision.models as models
model = models.alexnet()
print(torch_summarize(model))
def test_alexnet_imagenet(classes=5):
model = alexnet(input_shape=(3, 227, 227), nb_classes=1000, mean_flag=True)
model.load_weights('alexnet_weights.h5')
model = Model(inputs=model.input, outputs=model.layers[-2].output)
plot_model(model, to_file='alexnet', show_shapes=True)
print(model.summary())
return model
def create_model(name, num_classes):
if name == 'resnet34':
model = models.resnet34(True)
model.fc = nn.Linear(model.fc.in_features, num_classes)
nn.init.xavier_uniform(model.fc.weight)
nn.init.constant(model.fc.bias, 0)
elif name == 'resnet50':
model = models.resnet50(True)
model.fc = nn.Linear(model.fc.in_features, num_classes)
nn.init.xavier_uniform(model.fc.weight)
nn.init.constant(model.fc.bias, 0)
elif name == 'resnet152':
model = models.resnet152(True)
model.fc = nn.Linear(model.fc.in_features, num_classes)
nn.init.xavier_uniform(model.fc.weight)
nn.init.constant(model.fc.bias, 0)
elif name == 'seresnet50':
model = models.se_resnet50()
model.last_linear = nn.Linear(model.last_linear.in_features,
num_classes,
bias=True)
elif name == 'seresnet152':
model = models.se_resnet152()
model.last_linear = nn.Linear(model.last_linear.in_features,
num_classes,
bias=True)
elif name == 'dpn131':
model = models.dpn131()
model.classifier = nn.Conv2d(2688,
num_classes,
kernel_size=1,
bias=True)
elif name == 'densenet121':
model = models.densenet121(True)
model.classifier = nn.Linear(model.classifier.in_features, num_classes)
nn.init.xavier_uniform(model.classifier.weight)
nn.init.constant(model.classifier.bias, 0)
elif name == 'vgg11_bn':
model = models.vgg11_bn(False, num_classes)
elif name == 'vgg19_bn':
model = models.vgg19_bn(True)
model.classifier._modules['6'] = nn.Linear(
model.classifier._modules['6'].in_features, num_classes)
nn.init.xavier_uniform(model.classifier._modules['6'].weight)
nn.init.constant(model.classifier._modules['6'].bias, 0)
elif name == 'alexnet':
model = models.alexnet(True)
model.classifier._modules['6'] = nn.Linear(
model.classifier._modules['6'].in_features, num_classes)
nn.init.xavier_uniform(model.classifier._modules['6'].weight)
nn.init.constant(model.classifier._modules['6'].bias, 0)
else:
model = Net(num_classes)
return model
def predict(path):
print(path)
pil_img = Image.open(path)
input = transforms(pil_img)
input = input[None]
input = t.autograd.Variable(input)
model = alexnet(num_classes=2)
model.load(
'checkpoints/custom_models.alexnet.AlexNet_epoch[99.100]_190415154539.pt'
)
model.eval()
preds = F.softmax(model(input), dim=1)
print(preds)
def train_shallow_alexnet_imagenet(classes=5, freeze_flag=None):
model = alexnet(input_shape=(3, 227, 227), nb_classes=1000, mean_flag=True)
model.load_weights('alexnet_weights.h5')
# modify architecture
# ##################### Ori #####################
# last_conv_1 = model.layers[5].output
# conv_2 = Conv2D(256, (5, 5), strides=(1, 1), activation='relu', name='conv_2', kernel_initializer='he_normal', bias_initializer='he_normal')(last_conv_1)
# conv_2 = MaxPooling2D((3, 3), strides=(2, 2))(conv_2)
# conv_2 = crosschannelnormalization(name="convpool_2")(conv_2)
# conv_2 = ZeroPadding2D((2,2))(conv_2)
# conv_2 = Flatten(name="flatten")(conv_2)
# conv_2 = Dropout(0.5)(conv_2)
# ##############################################
################# Use 2 conv with weights ######################
conv_2 = model.layers[13].output
conv_2 = Flatten(name='flatten')(conv_2)
conv_2 = Dropout(0.5)(conv_2)
################################################################
# ##### FC for experiments #####
# fc_1 = Dense(4096, activation='relu', name='fc_1', kernel_initializer='he_normal', bias_initializer='he_normal')(conv_2)
# fc_2 = Dense(4096, activation='relu', name='fc_2', kernel_initializer='he_normal', bias_initializer='he_normal')(fc_1)
# ##############################
##### GAP experiments #####
# gap = GlobalAveragePooling2D(data_format = 'channels_first')(conv_2)
# gap = Dropout(0.5)(gap)
###########################
dense_1 = Dense(classes,
kernel_initializer='he_normal',
bias_initializer='he_normal')(conv_2)
prediction = Activation("softmax")(dense_1)
model = Model(inputs=model.input, outputs=prediction)
plot_model(model, to_file='shallowalex', show_shapes=True)
print(model.summary())
return model
def main(id, n_files):
n_files = int(n_files)
model = alexnet(WIDTH, HEIGHT, LR, BATCH_SIZE)
train_data = load_data('data/balanced/balanced_data_%s.npy', 0)
for i in range(EPOCHS):
size_test = int(0.1*len(train_data))
train = train_data[:-size_test]
test = train_data[-size_test:]
X = np.array([i[0] for i in train]).reshape(-1, WIDTH, HEIGHT, 1)
Y = [i[1] for i in train]
test_x = np.array([i[0]
for i in test]).reshape(-1, WIDTH, HEIGHT, 1)
test_y = [i[1] for i in test]
model.fit({'input': X}, {'targets': Y}, n_epoch=1, validation_set=({'input': test_x}, {'targets': test_y}),
snapshot_step=500, show_metric=True, run_id='model_%s_%s_%s' % ('alexnet', EPOCHS, id))
model.save('model/model.tflearn')
HEIGHT = 300
LR = 1e-3
EPOCHS = 30
MODEL_NAME = 'alexnet_v1'
PREV_MODEL = ''
forward = [1, 0, 0, 0, 0, 0, 0]
back = [0, 1, 0, 0, 0, 0, 0]
left = [0, 0, 1, 0, 0, 0, 0]
right = [0, 0, 0, 1, 0, 0, 0]
forward_left = [0, 0, 0, 0, 1, 0, 0]
forward_right = [0, 0, 0, 0, 0, 1, 0]
noop = [0, 0, 0, 0, 0, 0, 1]
model = alexnet(WIDTH, HEIGHT, LR, output=7)
for e in range(EPOCHS):
#data_order = [i for i in range(1,FILE_I_END+1)]
data_order = [i for i in range(1, FILE_I_END + 1)]
shuffle(data_order)
try:
file_name = "D:\\Projects\\SelfDrivingFZero\\trainingData-0.npy"
# full file info
train_data = np.load(file_name)
shuffle(train_data)
train = train_data[:-100]
test = train_data[-100:]
X = np.array([i[0] for i in train]).reshape(-1, WIDTH, HEIGHT, 1)
Y = [i[1] for i in train]
import numpy as np
import models
WIDTH = 30
HEIGHT = 18
LR = 1e-3
EPOCH = 8
MODEL_NAME = 'Trex-{}-{}-{}-epochs.model'.format(LR, 'alexnet', EPOCH)
model = models.alexnet(WIDTH, HEIGHT, LR, 2)
train_data = np.load('training_data_v2.npy')
train = train_data[:-50]
test = train_data[-50:]
X = np.array([i[0] for i in train]).reshape(-1, WIDTH, HEIGHT, 1)
y = [i[1] for i in train]
test_X = np.array([i[0] for i in test]).reshape(-1, WIDTH, HEIGHT, 1)
test_y = [i[1] for i in test]
model.fit({'input': X}, {'targets': y},
n_epoch=EPOCH,
validation_set=({
'input': test_X
}, {
'targets': test_y
}),
snapshot_step=50,
show_metric=True,
import torch
num_classes = 18
inputs = torch.rand([1, 3, 224, 224])
test = models.resnet34(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.resnet50(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.resnet101(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.resnet152(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.alexnet(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.densenet121(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.densenet169(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.densenet201(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.densenet201(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
def main():
parser = argparse.ArgumentParser(
description='Deep Learning SNN simulation')
parser.add_argument('--config-file',
help='.ini file specifying simulation params')
args = parser.parse_args()
print(args)
config = configparser.ConfigParser()
config.read(args.config_file)
pprint.pprint(
{section: dict(config[section])
for section in config.sections()})
print
defaults = config['DEFAULT']
device = defaults['device']
app_name = defaults['app_name']
print('[INFO] Simulating spiking {}'.format(app_name))
if not os.path.isdir(app_name):
os.mkdir(app_name)
out_dir = app_name
org_model = config['original model']
num_classes = org_model.getint('num_classes')
model_path = org_model['model_path']
file_name = org_model['file_name']
batch_size = org_model.getint('batch_size')
class_num = org_model.getint('class')
" Load the original model "
net = None
if 'vgg_cifar10' in org_model['arch']:
from models import VGG_16_cifar10
net = VGG_16_cifar10
if 'mobnet_cif10_mod' in org_model['arch']:
from models import MobileNet_mod
net = MobileNet_mod()
if 'mobnet_cif100' in org_model['arch']:
from models import mobilenet_cif100
net = mobilenet_cif100()
if 'vgg_cif100' in org_model['arch']:
from models import vgg13_bn
net = vgg13_bn()
if 'svhn' in org_model['arch']:
from models import svhn
net = svhn()
if 'alex' in org_model['arch']:
from models import alexnet
net = alexnet()
if 'lenet5' in org_model['arch']:
from models import lenet5
net = lenet5()
print(net)
state = None
state, net = load_model(net, model_path, file_name)
net = net.to(device)
" Load the dataset "
testloader, img_size = None, None
data_config = config['dataset']
data_dir = data_config['data_dir']
if data_config['dataset'] == 'cifar10':
trainloader, testloader = load_cifar10(data_dir, org_model['arch'],
batch_size, class_num)
img_size = (-1, 3, 32, 32)
if data_config['dataset'] == 'imagenet':
trainloader, testloader = load_imagenet(data_dir,
batch_size,
shuffle=False)
img_size = (-1, 3, 224, 224)
if data_config['dataset'] == 'cifar100':
trainloader, testloader = load_cifar100(data_dir, org_model['arch'],
batch_size, class_num)
img_size = (-1, 3, 32, 32)
if data_config['dataset'] == 'svhn':
trainloader, testloader = load_svhn(data_dir, org_model['arch'],
batch_size, class_num)
img_size = (-1, 3, 32, 32)
if data_config['dataset'] == 'mnist':
trainloader, testloader = load_mnist(data_dir, org_model['arch'],
batch_size, class_num)
img_size = (-1, 1, 28, 28)
" Tasks to do "
tasks = config['functions']
" validate original model "
if tasks.getboolean('validate'):
validate(net, testloader, device)
" fold back BN layers if any "
new_net = None
remove_bn = tasks.getboolean('remove_bn')
if remove_bn:
if has_bn(net):
if 'mobnet_cif10_mod' in org_model['arch']:
from models import MobileNet_mod_nobn
new_net = MobileNet_mod_nobn()
elif 'mobnet_cif100' in org_model['arch']:
from models import mobilenet_cif100_nobn
new_net = mobilenet_cif100_nobn()
elif 'vgg_cif100' in org_model['arch']:
from models import vgg13_nobn
new_net = vgg13_nobn()
new_net = merge_bn(net, new_net)
new_net = new_net.to(device)
print(new_net)
print('Validating model after folding back BN layers...')
validate(new_net, testloader, device)
save_model(new_net, state, out_dir, 'nobn_' + file_name)
else:
print('model has no BN layers')
" use model with folded BN "
use_nobn = tasks.getboolean('use_nobn')
if use_nobn:
if 'mobnet_cif10_mod' in org_model['arch']:
from models import MobileNet_mod_nobn
net = MobileNet_mod_nobn()
elif 'mobnet_cif100' in org_model['arch']:
from models import mobilenet_cif100_nobn
net = mobilenet_cif100_nobn()
elif 'vgg_cif100' in org_model['arch']:
from models import vgg13_nobn
net = vgg13_nobn()
state, net = load_model(net, out_dir, 'nobn_' + file_name)
net = net.to(device)
" validate model with folded BN "
validate_nobn = tasks.getboolean('validate_nobn')
if not remove_bn and validate_nobn:
if not has_bn(net):
print('Validating no_bn model...')
validate(net, testloader, device)
else:
print('model has BN layers!! Exiting..')
exit()
" compute thresholds "
spike_config = config['spiking']
percentile = spike_config.getfloat('percentile')
if spike_config.getboolean('compute_thresholds'):
compute_thresholds(net, testloader, out_dir, percentile, device)
" convert ann to snn "
thresholds, max_acts = None, None
if spike_config.getboolean('convert_to_spike'):
from spiking import createSpikingModel
thresholds = np.loadtxt(os.path.join(out_dir, 'thresholds.txt'))
max_acts = np.loadtxt(os.path.join(out_dir, 'max_acts.txt'))
spike_net = createSpikingModel(net, org_model['arch'], num_classes, spike_config, \
torch.from_numpy(thresholds), max_acts, device, out_dir)
#print(spike_net.state_dict().keys())
print(spike_net)
" simulate snn "
if spike_config.getboolean('simulate_spiking'):
from spiking import simulate_spike_model
thresholds = np.loadtxt(os.path.join(out_dir, 'thresholds.txt'))
max_acts = np.loadtxt(os.path.join(out_dir, 'max_acts.txt'))
thresholds = torch.from_numpy(thresholds).to(device)
max_acts = torch.from_numpy(max_acts).to(device)
sbi, model_partial = None, None
# sbi: spike buffer index
if spike_config.getboolean('hybrid_model'):
from spiking import createSpikingModel, create_partial_model
spike_net = createSpikingModel(net, org_model['arch'], num_classes, spike_config, \
thresholds, max_acts, device, out_dir)
split_layer = spike_config.getint('split_layer')
sbi, model_partial = create_partial_model(split_layer, net,
spike_net,
org_model['arch'])
print(model_partial)
simulate_spike_model(net, org_model['arch'], testloader, config, thresholds.float(), \
max_acts, num_classes, img_size, sbi, model_partial, device)
if class_num < 0:
class_num = ''
" plot correlations "
if spike_config.getboolean('plot_correlations'):
from spiking import plot_correlations
corr = np.load(
os.path.join(out_dir, 'layerwise_corr' + str(class_num) + '.npy'))
plot_config = config['plotting']
plot_correlations(corr, out_dir, plot_config, class_num)
" plot activity "
if spike_config.getboolean('plot_activity'):
from spiking import plot_activity
container = np.load(
os.path.join(out_dir, 'layerwise_acts' + str(class_num) + '.npz'))
max_acts = np.loadtxt(os.path.join(out_dir, 'max_acts.txt'))
plot_activity(container, max_acts, out_dir, class_num)
" plot histogram of spikes "
if spike_config.getboolean('plot_histogram'):
from spiking import plot_histogram
container = np.load(
os.path.join(out_dir, 'layerwise_acts' + str(class_num) + '.npz'))
max_acts = np.loadtxt(os.path.join(out_dir, 'max_acts.txt'))
plot_histogram(container, max_acts, spike_config, out_dir, class_num)
def train_multiclass(
train_file,
test_file,
stat_file,
model='mobilenet_v2',
classes=('artist_name', 'genre', 'style', 'technique', 'century'),
im_path='/export/home/kschwarz/Documents/Data/Wikiart_artist49_images',
label_file='_user_labels.pkl',
chkpt=None,
weight_file=None,
use_gpu=True,
device=0,
epochs=100,
batch_size=32,
lr=1e-4,
momentum=0.9,
log_interval=10,
log_dir='runs',
exp_name=None,
seed=123):
argvars = locals().copy()
torch.manual_seed(seed)
# LOAD DATASET
with open(stat_file, 'r') as f:
data = pickle.load(f)
mean, std = data['mean'], data['std']
mean = [float(m) for m in mean]
std = [float(s) for s in std]
normalize = transforms.Normalize(mean=mean, std=std)
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(90),
transforms.ToTensor(),
normalize,
])
val_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
normalize,
])
if model.lower() == 'inception_v3': # change input size to 299
train_transform.transforms[0].size = (299, 299)
val_transform.transforms[0].size = (299, 299)
trainset = create_trainset(train_file, label_file, im_path,
train_transform, classes)
valset = create_valset(test_file, im_path, val_transform,
trainset.labels_to_ints)
num_labels = [len(trainset.labels_to_ints[c]) for c in classes]
# PARAMETERS
use_cuda = use_gpu and torch.cuda.is_available()
if use_cuda:
torch.cuda.set_device(device)
torch.cuda.manual_seed_all(seed)
if model.lower() not in [
'squeezenet', 'mobilenet_v1', 'mobilenet_v2', 'vgg16_bn',
'inception_v3', 'alexnet'
]:
assert False, 'Unknown model {}\n\t+ Choose from: ' \
'[sqeezenet, mobilenet_v1, mobilenet_v2, vgg16_bn, inception_v3, alexnet].'.format(model)
elif model.lower() == 'mobilenet_v1':
bodynet = mobilenet_v1(pretrained=weight_file is None)
elif model.lower() == 'mobilenet_v2':
bodynet = mobilenet_v2(pretrained=weight_file is None)
elif model.lower() == 'vgg16_bn':
bodynet = vgg16_bn(pretrained=weight_file is None)
elif model.lower() == 'inception_v3':
bodynet = inception_v3(pretrained=weight_file is None)
elif model.lower() == 'alexnet':
bodynet = alexnet(pretrained=weight_file is None)
else: # squeezenet
bodynet = squeezenet(pretrained=weight_file is None)
# Load weights for the body network
if weight_file is not None:
print("=> loading weights from '{}'".format(weight_file))
pretrained_dict = torch.load(
weight_file,
map_location=lambda storage, loc: storage)['state_dict']
state_dict = bodynet.state_dict()
pretrained_dict = {
k.replace('bodynet.', ''): v
for k, v in
pretrained_dict.items() # in case of multilabel weight file
if (k.replace('bodynet.', '') in state_dict.keys()
and v.shape == state_dict[k.replace('bodynet.', '')].shape)
} # number of classes might have changed
# check which weights will be transferred
if not pretrained_dict == state_dict: # some changes were made
for k in set(state_dict.keys() + pretrained_dict.keys()):
if k in state_dict.keys() and k not in pretrained_dict.keys():
print('\tWeights for "{}" were not found in weight file.'.
format(k))
elif k in pretrained_dict.keys() and k not in state_dict.keys(
):
print(
'\tWeights for "{}" were are not part of the used model.'
.format(k))
elif state_dict[k].shape != pretrained_dict[k].shape:
print(
'\tShapes of "{}" are different in model ({}) and weight file ({}).'
.format(k, state_dict[k].shape,
pretrained_dict[k].shape))
else: # everything is good
pass
state_dict.update(pretrained_dict)
bodynet.load_state_dict(state_dict)
net = OctopusNet(bodynet, n_labels=num_labels)
n_parameters = sum(
[p.data.nelement() for p in net.parameters() if p.requires_grad])
if use_cuda:
net = net.cuda()
print('Using {}\n\t+ Number of params: {}'.format(
str(net).split('(', 1)[0], n_parameters))
if not os.path.isdir(log_dir):
os.makedirs(log_dir)
# tensorboard summary writer
timestamp = time.strftime('%m-%d-%H-%M')
expname = timestamp + '_' + str(net).split('(', 1)[0]
if exp_name is not None:
expname = expname + '_' + exp_name
log = TBPlotter(os.path.join(log_dir, 'tensorboard', expname))
log.print_logdir()
# allow auto-tuner to find best algorithm for the hardware
cudnn.benchmark = True
with open(label_file, 'rb') as f:
labels = pickle.load(f)['labels']
n_labeled = '\t'.join(
[str(Counter(l).items()) for l in labels.transpose()])
write_config(argvars,
os.path.join(log_dir, expname),
extras={'n_labeled': n_labeled})
# ININTIALIZE TRAINING
optimizer = optim.SGD(net.parameters(), lr=lr, momentum=momentum)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
patience=10,
threshold=1e-1,
verbose=True)
criterion = nn.CrossEntropyLoss()
if use_cuda:
criterion = criterion.cuda()
kwargs = {'num_workers': 4} if use_cuda else {}
trainloader = DataLoader(trainset,
batch_size=batch_size,
shuffle=True,
**kwargs)
valloader = DataLoader(valset,
batch_size=batch_size,
shuffle=True,
**kwargs)
# optionally resume from a checkpoint
start_epoch = 1
if chkpt is not None:
if os.path.isfile(chkpt):
print("=> loading checkpoint '{}'".format(chkpt))
checkpoint = torch.load(chkpt,
map_location=lambda storage, loc: storage)
start_epoch = checkpoint['epoch']
best_acc_score = checkpoint['best_acc_score']
best_acc = checkpoint['acc']
net.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
chkpt, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(chkpt))
def train(epoch):
losses = AverageMeter()
accs = AverageMeter()
class_acc = [AverageMeter() for i in range(len(classes))]
# switch to train mode
net.train()
for batch_idx, (data, target) in enumerate(trainloader):
if use_cuda:
data, target = Variable(
data.cuda()), [Variable(t.cuda()) for t in target]
else:
data, target = Variable(data), [Variable(t) for t in target]
# compute output
outputs = net(data)
preds = [torch.max(outputs[i], 1)[1] for i in range(len(classes))]
loss = Variable(torch.Tensor([0]),
requires_grad=True).type_as(data[0])
for i, o, t, p in zip(range(len(classes)), outputs, target, preds):
# filter unlabeled samples if there are any (have label -1)
labeled = (t != -1).nonzero().view(-1)
o, t, p = o[labeled], t[labeled], p[labeled]
loss += criterion(o, t)
# measure class accuracy and record loss
class_acc[i].update(
(torch.sum(p == t).type(torch.FloatTensor) /
t.size(0)).data)
accs.update(
torch.mean(
torch.stack(
[class_acc[i].val for i in range(len(classes))])),
target[0].size(0))
losses.update(loss.data, target[0].size(0))
# compute gradient and do optimizer step
optimizer.zero_grad()
loss.backward()
optimizer.step()
if batch_idx % log_interval == 0:
print('Train Epoch: {} [{}/{}]\t'
'Loss: {:.4f} ({:.4f})\t'
'Acc: {:.2f}% ({:.2f}%)'.format(epoch,
batch_idx * len(target),
len(trainloader.dataset),
float(losses.val),
float(losses.avg),
float(accs.val) * 100.,
float(accs.avg) * 100.))
print('\t' + '\n\t'.join([
'{}: {:.2f}%'.format(classes[i],
float(class_acc[i].val) * 100.)
for i in range(len(classes))
]))
# log avg values to somewhere
log.write('loss', float(losses.avg), epoch, test=False)
log.write('acc', float(accs.avg), epoch, test=False)
for i in range(len(classes)):
log.write('class_acc', float(class_acc[i].avg), epoch, test=False)
def test(epoch):
losses = AverageMeter()
accs = AverageMeter()
class_acc = [AverageMeter() for i in range(len(classes))]
# switch to evaluation mode
net.eval()
for batch_idx, (data, target) in enumerate(valloader):
if use_cuda:
data, target = Variable(
data.cuda()), [Variable(t.cuda()) for t in target]
else:
data, target = Variable(data), [Variable(t) for t in target]
# compute output
outputs = net(data)
preds = [torch.max(outputs[i], 1)[1] for i in range(len(classes))]
loss = Variable(torch.Tensor([0]),
requires_grad=True).type_as(data[0])
for i, o, t, p in zip(range(len(classes)), outputs, target, preds):
labeled = (t != -1).nonzero().view(-1)
loss += criterion(o[labeled], t[labeled])
# measure class accuracy and record loss
class_acc[i].update((torch.sum(p[labeled] == t[labeled]).type(
torch.FloatTensor) / t[labeled].size(0)).data)
accs.update(
torch.mean(
torch.stack(
[class_acc[i].val for i in range(len(classes))])),
target[0].size(0))
losses.update(loss.data, target[0].size(0))
score = accs.avg - torch.std(
torch.stack([class_acc[i].avg for i in range(len(classes))])
) / accs.avg # compute mean - std/mean as measure for accuracy
print(
'\nVal set: Average loss: {:.4f} Average acc {:.2f}% Acc score {:.2f} LR: {:.6f}'
.format(float(losses.avg),
float(accs.avg) * 100., float(score),
optimizer.param_groups[-1]['lr']))
print('\t' + '\n\t'.join([
'{}: {:.2f}%'.format(classes[i],
float(class_acc[i].avg) * 100.)
for i in range(len(classes))
]))
log.write('loss', float(losses.avg), epoch, test=True)
log.write('acc', float(accs.avg), epoch, test=True)
for i in range(len(classes)):
log.write('class_acc', float(class_acc[i].avg), epoch, test=True)
return losses.avg.cpu().numpy(), float(score), float(
accs.avg), [float(class_acc[i].avg) for i in range(len(classes))]
if start_epoch == 1: # compute baseline:
_, best_acc_score, best_acc, _ = test(epoch=0)
else: # checkpoint was loaded
best_acc_score = best_acc_score
best_acc = best_acc
for epoch in range(start_epoch, epochs + 1):
# train for one epoch
train(epoch)
# evaluate on validation set
val_loss, val_acc_score, val_acc, val_class_accs = test(epoch)
scheduler.step(val_loss)
# remember best acc and save checkpoint
is_best = val_acc_score > best_acc_score
best_acc_score = max(val_acc_score, best_acc_score)
save_checkpoint(
{
'epoch': epoch,
'state_dict': net.state_dict(),
'best_acc_score': best_acc_score,
'acc': val_acc,
'class_acc': {c: a
for c, a in zip(classes, val_class_accs)}
},
is_best,
expname,
directory=log_dir)
if val_acc > best_acc:
shutil.copyfile(
os.path.join(log_dir, expname + '_checkpoint.pth.tar'),
os.path.join(log_dir,
expname + '_model_best_mean_acc.pth.tar'))
best_acc = max(val_acc, best_acc)
if optimizer.param_groups[-1]['lr'] < 1e-5:
print('Learning rate reached minimum threshold. End training.')
break
# report best values
best = torch.load(os.path.join(log_dir, expname + '_model_best.pth.tar'),
map_location=lambda storage, loc: storage)
print(
'Finished training after epoch {}:\n\tbest acc score: {}\n\tacc: {}\n\t class acc: {}'
.format(best['epoch'], best['best_acc_score'], best['acc'],
best['class_acc']))
print('Best model mean accuracy: {}'.format(best_acc))
type=str,
default=os.path.join(os.path.dirname(__file__),
'../tools/bvlc_alexnet.prototxt'),
help='path to the Caffe prototxt')
parser.add_argument('--model',
type=str,
default=os.path.join(
os.path.dirname(__file__),
'../tools/bvlc_alexnet.caffemodel'),
help='path to the Caffe model')
args = parser.parse_args()
images = tf.placeholder(tf.float32,
shape=[None, 227, 227, 3],
name='images')
train = tf.placeholder_with_default(True, [], name='train')
output = models.alexnet(images, train, pretrained=True)
sess = tf.Session()
init = tf.global_variables_initializer()
data = np.random.rand(10, 227, 227, 3) * 4 + 150
sess.run(init)
result = sess.run(output, feed_dict={images: data, train: False})
caffe_data = data.transpose([0, 3, 1, 2])[:, ::-1]
net = caffe.Net(args.prototxt, args.model, caffe.TEST)
net.blobs['data'].reshape(*caffe_data.shape)
net.blobs['data'].data[:] = caffe_data
net.forward()
diff = np.sum((result - net.blobs['fc8'].data)**2)
if diff < 1e-5:
print('Test Okay')
else:
print('Test failed')
dataset = ImageFolderWithPaths(offset, transform=transforms.Compose(tra))
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=1,
num_workers=0,
pin_memory=True,
shuffle = False)
features = compute_features(dataloader, model, len(dataset))
return features
if __name__ == '__main__':
# global args
# args = parser.parse_args()
modelpth = '/home/CUSACKLAB/annatruzzi/alexnet_models/'
checkpoint = torch.load(modelpth+'modified_alexnet_checkpoint_27.pth.tar')['state_dict']
checkpoint_new = OrderedDict()
for k, v in checkpoint.items():
name_temp = k.replace(".module", '') # remove '.module' of dataparallel
name = name_temp.replace("module.",'') # remove 'module.'
checkpoint_new[name]=v
model = models.alexnet(sobel=True, bn=True, out=1000)
model.load_state_dict(checkpoint_new)
model.cuda()
image_pth = '/home/CUSACKLAB/annatruzzi/cichy2016/algonautsChallenge2019/Training_Data/92_Image_Set/92images'
act = get_activations(image_pth)
with open('/home/CUSACKLAB/annatruzzi/cichy2016/niko92_activations_pretrained_alexnet.pickle', 'wb') as handle:
pickle.dump(act, handle)
args)
if args.model == 'fc':
if args.dataset == 'mnist':
net = fc(width=args.width,
depth=args.depth,
num_classes=num_classes).to(args.device)
elif args.dataset == 'cifar10':
net = fc(width=args.width,
depth=args.depth,
num_classes=num_classes,
input_dim=3 * 32 * 32).to(args.device)
elif args.model == 'alexnet':
if args.dataset == 'mnist':
net = alexnet(input_height=28,
input_width=28,
input_channels=1,
num_classes=num_classes)
else:
net = alexnet(ch=args.scale,
num_classes=num_classes).to(args.device)
elif args.model == 'vgg':
net = vgg(depth=args.depth,
num_classes=num_classes,
batch_norm=args.bn).to(args.device)
print(net)
opt = getattr(optim, args.optim)(net.parameters(), lr=args.lr)
if args.lr_schedule:
milestone = int(args.iterations / 3)
args.use_cuda = not args.no_cuda and torch.cuda.is_available()
args.device = torch.device('cuda' if args.use_cuda else 'cpu')
torch.manual_seed(args.seed)
print(args)
# training setup
train_loader, test_loader_eval, train_loader_eval, num_classes = get_data(args)
if args.model == 'fc':
if args.dataset == 'mnist':
net = fc(width=args.width, depth=args.depth, num_classes=num_classes).to(args.device)
elif args.dataset == 'cifar10':
net = fc(width=args.width, depth=args.depth, num_classes=num_classes, input_dim=3*32*32).to(args.device)
elif args.model == 'alexnet':
net = alexnet(ch=args.scale, num_classes=num_classes).to(args.device)
elif args.model == 'simplenet':
net = simplenet().to(args.device)
print(net)
opt = optim.SGD(
net.parameters(),
lr=args.lr,
momentum=args.mom,
weight_decay=args.wd
)
if args.lr_schedule:
milestone = int(args.iterations / 3)
scheduler = optim.lr_scheduler.MultiStepLR(opt,
else:
net = fc(width=args.width,
depth=args.depth,
num_classes=num_classes,
activation=args.activation,
use_batch_norm=args.batch_norm).to(args.device)
elif args.dataset == 'cifar10':
net = fc(width=args.width,
depth=args.depth,
num_classes=num_classes,
input_dim=3 * 32 * 32,
activation=args.activation,
use_batch_norm=args.batch_norm).to(args.device)
elif args.model == 'alexnet':
net = alexnet(ch=args.scale,
num_classes=num_classes,
use_batch_norm=args.batch_norm).to(args.device)
elif args.model == 'lenet':
net = lenet().to(args.device)
elif 'VGG' in args.model:
net = VGG(args.model, batch_norm=args.batch_norm).to(args.device)
elif 'Resnet' in args.model:
net = ResNet18(use_batch_norm=args.batch_norm).to(args.device)
training_history = []
weight_grad_history = []
# eval logs less frequently
evaluation_history_TEST = []
evaluation_history_TRAIN = []
noise_norm_history_TEST = []
sys.path.insert(0, '../../python')
import planner as pln
import hardware as hw
import dataset
import models
import torch.nn
import torch
import time
simd_cfg_path = '../../hwcfg/simd.json'
hw_spec = hw.HardwareSpec(simd_cfg_path)
data = torch.Tensor(1, 3, 227, 227);
alexnet = models.alexnet()
pnn = pln.Planner()
start_time = time.time()
for name, module in alexnet.named_modules():
if isinstance(module, torch.nn.Sequential):
continue
pnn.set_data(data=data, module=module, hw_spec=hw_spec, layer_name=name)
data = pnn.run('../../build')
elapsed_time = time.time() - start_time
print('[Front-end] Elapsed time: ' + time.strftime('%H hours %M min %S sec', time.gmtime(elapsed_time)))
def main():
model = alexnet(WIDTH, HEIGHT, LR)
#model.load('trained_models/' + MODEL_NAME % ('alexnet', EPOCHS, DATA_TYPE))
model.load('model/model.tflearn')
timer(5)
# 800x600 windowed mode
mon = {"top": 60, "left": 0, "width": 800, "height": 600}
# Screenshot object
sct = mss.mss()
paused = False
count_dk = 0
count_st = 0
while True:
if not paused:
image = np.asarray(sct.grab(mon))
# Converting to grayscale, reason much smaller then RGB(minus 2 D)
image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
# Resizing image to 80x60waw
image = cv2.resize(image, (160, 120))
prediction = model.predict([image.reshape(160, 120, 1)])[0]
#print(prediction)
#print(np.argmax(prediction))
turn_thresh = .7
fwd_thresh = 0.7
if prediction[1] > fwd_thresh:
count_dk = 0
count_st += 1
if count_st > 1:
print('STOP ST')
stop()
count_st = 0
print('STRAIGHT : %s' % (prediction[1]*100.0))
straight()
elif prediction[0] > turn_thresh:
count_dk = 0
count_st = 0
print('LEFT : %s' % (prediction[0]*100.0))
left()
elif prediction[2] > turn_thresh:
count_dk = 0
count_st = 0
print('RIGHT : %s' % (prediction[2]*100.0))
right()
else:
count_dk += 1
count_st = 0
if count_dk > 3:
print('STOP DK')
stop()
count_dk = 0
print('DK : STRAIGHT')
dk_straight()
# p pauses game and can get annoying.
if keys.output == 'pause':
if paused:
paused = False
else:
paused = True
stop()
#time.sleep(0.2)
elif keys.output == 'quit':
return True
def train_multiclass(train_file, test_file, stat_file,
model='mobilenet_v2',
classes=('artist_name', 'genre', 'style', 'technique', 'century'),
label_file='_user_labels.pkl',
im_path='/export/home/kschwarz/Documents/Data/Wikiart_artist49_images',
chkpt=None, weight_file=None,
triplet_selector='semihard', margin=0.2,
labels_per_class=4, samples_per_label=4,
use_gpu=True, device=0,
epochs=100, batch_size=32, lr=1e-4, momentum=0.9,
log_interval=10, log_dir='runs',
exp_name=None, seed=123):
argvars = locals().copy()
torch.manual_seed(seed)
# LOAD DATASET
with open(stat_file, 'r') as f:
data = pickle.load(f)
mean, std = data['mean'], data['std']
mean = [float(m) for m in mean]
std = [float(s) for s in std]
normalize = transforms.Normalize(mean=mean, std=std)
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(90),
transforms.ToTensor(),
normalize,
])
val_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
normalize,
])
if model.lower() == 'inception_v3': # change input size to 299
train_transform.transforms[0].size = (299, 299)
val_transform.transforms[0].size = (299, 299)
trainset = create_trainset(train_file, label_file, im_path, train_transform, classes)
for c in classes:
if len(trainset.labels_to_ints[c]) < labels_per_class:
print('less labels in class {} than labels_per_class, use all available labels ({})'
.format(c, len(trainset.labels_to_ints[c])))
valset = create_valset(test_file, im_path, val_transform, trainset.labels_to_ints)
# PARAMETERS
use_cuda = use_gpu and torch.cuda.is_available()
if use_cuda:
torch.cuda.set_device(device)
torch.cuda.manual_seed_all(seed)
if model.lower() not in ['squeezenet', 'mobilenet_v1', 'mobilenet_v2', 'vgg16_bn', 'inception_v3', 'alexnet']:
assert False, 'Unknown model {}\n\t+ Choose from: ' \
'[sqeezenet, mobilenet_v1, mobilenet_v2, vgg16_bn, inception_v3, alexnet].'.format(model)
elif model.lower() == 'mobilenet_v1':
bodynet = mobilenet_v1(pretrained=weight_file is None)
elif model.lower() == 'mobilenet_v2':
bodynet = mobilenet_v2(pretrained=weight_file is None)
elif model.lower() == 'vgg16_bn':
bodynet = vgg16_bn(pretrained=weight_file is None)
elif model.lower() == 'inception_v3':
bodynet = inception_v3(pretrained=weight_file is None)
elif model.lower() == 'alexnet':
bodynet = alexnet(pretrained=weight_file is None)
else: # squeezenet
bodynet = squeezenet(pretrained=weight_file is None)
# Load weights for the body network
if weight_file is not None:
print("=> loading weights from '{}'".format(weight_file))
pretrained_dict = torch.load(weight_file, map_location=lambda storage, loc: storage)['state_dict']
state_dict = bodynet.state_dict()
pretrained_dict = {k.replace('bodynet.', ''): v for k, v in pretrained_dict.items() # in case of multilabel weight file
if (k.replace('bodynet.', '') in state_dict.keys() and v.shape == state_dict[k.replace('bodynet.', '')].shape)} # number of classes might have changed
# check which weights will be transferred
if not pretrained_dict == state_dict: # some changes were made
for k in set(state_dict.keys() + pretrained_dict.keys()):
if k in state_dict.keys() and k not in pretrained_dict.keys():
print('\tWeights for "{}" were not found in weight file.'.format(k))
elif k in pretrained_dict.keys() and k not in state_dict.keys():
print('\tWeights for "{}" were are not part of the used model.'.format(k))
elif state_dict[k].shape != pretrained_dict[k].shape:
print('\tShapes of "{}" are different in model ({}) and weight file ({}).'.
format(k, state_dict[k].shape, pretrained_dict[k].shape))
else: # everything is good
pass
state_dict.update(pretrained_dict)
bodynet.load_state_dict(state_dict)
net = MetricNet(bodynet, len(classes))
n_parameters = sum([p.data.nelement() for p in net.parameters() if p.requires_grad])
if use_cuda:
net = net.cuda()
print('Using {}\n\t+ Number of params: {}'.format(str(net).split('(', 1)[0], n_parameters))
if not os.path.isdir(log_dir):
os.makedirs(log_dir)
# tensorboard summary writer
timestamp = time.strftime('%m-%d-%H-%M')
expname = timestamp + '_' + str(net).split('(', 1)[0]
if exp_name is not None:
expname = expname + '_' + exp_name
log = TBPlotter(os.path.join(log_dir, 'tensorboard', expname))
log.print_logdir()
# allow auto-tuner to find best algorithm for the hardware
cudnn.benchmark = True
with open(label_file, 'rb') as f:
labels = pickle.load(f)['labels']
n_labeled = '\t'.join([str(Counter(l).items()) for l in labels.transpose()])
write_config(argvars, os.path.join(log_dir, expname), extras={'n_labeled': n_labeled})
# ININTIALIZE TRAINING
optimizer = optim.SGD(net.parameters(), lr=lr, momentum=momentum)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=10, threshold=1e-1, verbose=True)
if triplet_selector.lower() not in ['random', 'semihard', 'hardest', 'mixed', 'khardest']:
assert False, 'Unknown option {} for triplet selector. Choose from "random", "semihard", "hardest" or "mixed"' \
'.'.format(triplet_selector)
elif triplet_selector.lower() == 'random':
criterion = TripletLoss(margin=margin,
triplet_selector=RandomNegativeTripletSelector(margin, cpu=not use_cuda))
elif triplet_selector.lower() == 'semihard' or triplet_selector.lower() == 'mixed':
criterion = TripletLoss(margin=margin,
triplet_selector=SemihardNegativeTripletSelector(margin, cpu=not use_cuda))
elif triplet_selector.lower() == 'khardest':
criterion = TripletLoss(margin=margin,
triplet_selector=KHardestNegativeTripletSelector(margin, k=3, cpu=not use_cuda))
else:
criterion = TripletLoss(margin=margin,
triplet_selector=HardestNegativeTripletSelector(margin, cpu=not use_cuda))
if use_cuda:
criterion = criterion.cuda()
kwargs = {'num_workers': 4} if use_cuda else {}
multilabel_train = np.stack([trainset.df[c].values for c in classes]).transpose()
train_batch_sampler = BalancedBatchSamplerMulticlass(multilabel_train, n_label=labels_per_class,
n_per_label=samples_per_label, ignore_label=None)
trainloader = DataLoader(trainset, batch_sampler=train_batch_sampler, **kwargs)
multilabel_val = np.stack([valset.df[c].values for c in classes]).transpose()
val_batch_sampler = BalancedBatchSamplerMulticlass(multilabel_val, n_label=labels_per_class,
n_per_label=samples_per_label, ignore_label=None)
valloader = DataLoader(valset, batch_sampler=val_batch_sampler, **kwargs)
# optionally resume from a checkpoint
start_epoch = 1
if chkpt is not None:
if os.path.isfile(chkpt):
print("=> loading checkpoint '{}'".format(chkpt))
checkpoint = torch.load(chkpt, map_location=lambda storage, loc: storage)
start_epoch = checkpoint['epoch']
best_acc_score = checkpoint['best_acc_score']
best_acc = checkpoint['acc']
net.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(chkpt, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(chkpt))
def train(epoch):
losses = AverageMeter()
gtes = AverageMeter()
non_zero_triplets = AverageMeter()
distances_ap = AverageMeter()
distances_an = AverageMeter()
# switch to train mode
net.train()
for batch_idx, (data, target) in enumerate(trainloader):
target = torch.stack(target)
if use_cuda:
data, target = Variable(data.cuda()), [Variable(t.cuda()) for t in target]
else:
data, target = Variable(data), [Variable(t) for t in target]
# compute output
outputs = net(data)
# normalize features
for i in range(len(classes)):
outputs[i] = torch.nn.functional.normalize(outputs[i], p=2, dim=1)
loss = Variable(torch.Tensor([0]), requires_grad=True).type_as(data[0])
n_triplets = 0
for op, tgt in zip(outputs, target):
# filter unlabeled samples if there are any (have label -1)
labeled = (tgt != -1).nonzero().view(-1)
op, tgt = op[labeled], tgt[labeled]
l, nt = criterion(op, tgt)
loss += l
n_triplets += nt
non_zero_triplets.update(n_triplets, target[0].size(0))
# measure GTE and record loss
gte, dist_ap, dist_an = GTEMulticlass(outputs, target) # do not compute ap pairs for concealed classes
gtes.update(gte.data, target[0].size(0))
distances_ap.update(dist_ap.data, target[0].size(0))
distances_an.update(dist_an.data, target[0].size(0))
losses.update(loss.data[0], target[0].size(0))
# compute gradient and do optimizer step
optimizer.zero_grad()
loss.backward()
optimizer.step()
if batch_idx % log_interval == 0:
print('Train Epoch: {} [{}/{}]\t'
'Loss: {:.4f} ({:.4f})\t'
'GTE: {:.2f}% ({:.2f}%)\t'
'Non-zero Triplets: {:d} ({:d})'.format(
epoch, batch_idx * len(target[0]), len(trainloader) * len(target[0]),
float(losses.val), float(losses.avg),
float(gtes.val) * 100., float(gtes.avg) * 100.,
int(non_zero_triplets.val), int(non_zero_triplets.avg)))
# log avg values to somewhere
log.write('loss', float(losses.avg), epoch, test=False)
log.write('gte', float(gtes.avg), epoch, test=False)
log.write('non-zero trplts', int(non_zero_triplets.avg), epoch, test=False)
log.write('dist_ap', float(distances_ap.avg), epoch, test=False)
log.write('dist_an', float(distances_an.avg), epoch, test=False)
def test(epoch):
losses = AverageMeter()
gtes = AverageMeter()
non_zero_triplets = AverageMeter()
distances_ap = AverageMeter()
distances_an = AverageMeter()
# switch to evaluation mode
net.eval()
for batch_idx, (data, target) in enumerate(valloader):
target = torch.stack(target)
if use_cuda:
data, target = Variable(data.cuda()), [Variable(t.cuda()) for t in target]
else:
data, target = Variable(data), [Variable(t) for t in target]
# compute output
outputs = net(data)
# normalize features
for i in range(len(classes)):
outputs[i] = torch.nn.functional.normalize(outputs[i], p=2, dim=1)
loss = Variable(torch.Tensor([0]), requires_grad=True).type_as(data[0])
n_triplets = 0
for op, tgt in zip(outputs, target):
# filter unlabeled samples if there are any (have label -1)
labeled = (tgt != -1).nonzero().view(-1)
op, tgt = op[labeled], tgt[labeled]
l, nt = criterion(op, tgt)
loss += l
n_triplets += nt
non_zero_triplets.update(n_triplets, target[0].size(0))
# measure GTE and record loss
gte, dist_ap, dist_an = GTEMulticlass(outputs, target)
gtes.update(gte.data.cpu(), target[0].size(0))
distances_ap.update(dist_ap.data.cpu(), target[0].size(0))
distances_an.update(dist_an.data.cpu(), target[0].size(0))
losses.update(loss.data[0].cpu(), target[0].size(0))
print('\nVal set: Average loss: {:.4f} Average GTE {:.2f}%, '
'Average non-zero triplets: {:d} LR: {:.6f}'.format(float(losses.avg), float(gtes.avg) * 100.,
int(non_zero_triplets.avg),
optimizer.param_groups[-1]['lr']))
log.write('loss', float(losses.avg), epoch, test=True)
log.write('gte', float(gtes.avg), epoch, test=True)
log.write('non-zero trplts', int(non_zero_triplets.avg), epoch, test=True)
log.write('dist_ap', float(distances_ap.avg), epoch, test=True)
log.write('dist_an', float(distances_an.avg), epoch, test=True)
return losses.avg, 1 - gtes.avg
if start_epoch == 1: # compute baseline:
_, best_acc = test(epoch=0)
else: # checkpoint was loaded
best_acc = best_acc
for epoch in range(start_epoch, epochs + 1):
if triplet_selector.lower() == 'mixed' and epoch == 26:
criterion.triplet_selector = HardestNegativeTripletSelector(margin, cpu=not use_cuda)
print('Changed negative selection from semihard to hardest.')
# train for one epoch
train(epoch)
# evaluate on validation set
val_loss, val_acc = test(epoch)
scheduler.step(val_loss)
# remember best acc and save checkpoint
is_best = val_acc > best_acc
best_acc = max(val_acc, best_acc)
save_checkpoint({
'epoch': epoch,
'state_dict': net.state_dict(),
'best_acc': best_acc,
}, is_best, expname, directory=log_dir)
if optimizer.param_groups[-1]['lr'] < 1e-5:
print('Learning rate reached minimum threshold. End training.')
break
# report best values
best = torch.load(os.path.join(log_dir, expname + '_model_best.pth.tar'), map_location=lambda storage, loc: storage)
print('Finished training after epoch {}:\n\tbest acc score: {}'
.format(best['epoch'], best['acc']))
print('Best model mean accuracy: {}'.format(best_acc))
def main():
epoch = 2
class_number = 2
chosen_model = "resnet50"
transform = googlenet_transform()
if chosen_model == "alexnet":
model = alexnet(class_num = class_number)
elif chosen_model == "googlenet":
model = googlenet(class_num = class_number)
elif chosen_model == "resnet18":
model = resnet18(class_num = class_number)
elif chosen_model == "resnet34":
model = resnet34(class_num = class_number)
elif chosen_model == "resnet50":
model = resnet50(class_num = class_number)
elif chosen_model == "resnet101":
model = resnet101(class_num = class_number)
elif chosen_model == "resnet152":
model = resnet152(class_num = class_number)
use_gpu = torch.cuda.is_available()
if use_gpu:
model = model.cuda()
print("Use GPU")
else:
print("Use CPU")
train_txt_path = "/Users/Barry/Desktop/classification_models_pytorch/trainset.txt"
trainset = Mydataset(train_txt_path, transform)
trainloader = DataLoader(trainset,
batch_size = 3,
shuffle=True
)
val_txt_path = "/Users/Barry/Desktop/classification_models_pytorch/valset.txt"
valset = Mydataset(val_txt_path, transform)
valloader = DataLoader(valset,
batch_size = 3,
shuffle=True
)
print("data loaded")
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr = 0.001 )
print("start to train")
for i in range(epoch):
model.train()
for batch_index, (data, target) in enumerate(trainloader):
if use_gpu:
data = data.cuda()
target = target.cuda()
data, label = Variable(data), Variable(target)
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
if batch_index > 0 and batch_index % 50 == 0:
print("Trian epoch {}, iterate {}, loss is {}".format(i, batch_index, loss))
# validate prcess
if batch_index > 0 and batch_index % 500 == 0:
model.eval()
losses = []
for val_index, (data, target) in enumerate(valloader):
data, label = Variable(data), Variable(target)
output = model(data)
loss = criterion(output, target)
losses.append(loss.data)
if val_index > 0 and val_index % 100 == 0:
break
result = np.mean(losses)
print("validation loss is {}".format(result))
model.train()
def build_models(model_name):
"""Creates three different models, one used for source only training,
two used for domain adaptation
"""
inputs = Input(shape=(224, 224, 3))
if model_name == "alexnet":
x4 = alexnet(inputs)
elif model_name == "vgg16":
x4 = vgg_16(inputs)
x4 = Flatten()(x4)
x4 = Dense(32, activation="relu")(x4)
x4 = BatchNormalization()(x4)
x4 = Activation("elu")(x4)
source_classifier = Dense(2, activation="softmax", name="mo")(x4)
# Domain Classification
domain_classifier = Dense(16, activation="relu", name="do4")(x4)
domain_classifier = BatchNormalization(name="do5")(domain_classifier)
domain_classifier = Activation("elu", name="do6")(domain_classifier)
domain_classifier = Dropout(0.5)(domain_classifier)
domain_classifier = Dense(2, activation="softmax",
name="do")(domain_classifier)
# Combined model
comb_model = Model(inputs=inputs,
outputs=[source_classifier, domain_classifier])
comb_model.compile(
optimizer="Adam",
loss={
"mo": "categorical_crossentropy",
"do": "categorical_crossentropy"
},
loss_weights={
"mo": 1,
"do": 2
},
metrics=["accuracy"],
)
source_classification_model = Model(
inputs=inputs,
outputs=[source_classifier],
)
source_classification_model.compile(
optimizer="Adam",
loss={"mo": "categorical_crossentropy"},
metrics=["accuracy"],
)
domain_classification_model = Model(inputs=inputs,
outputs=[domain_classifier])
domain_classification_model.compile(
optimizer="Adam",
loss={"do": "categorical_crossentropy"},
metrics=["accuracy"])
embeddings_model = Model(inputs=inputs, outputs=[x4])
embeddings_model.compile(optimizer="Adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
return (
comb_model,
source_classification_model,
domain_classification_model,
embeddings_model,
)
def print_model_parm_nums():
model = models.alexnet()
total = sum([param.nelement() for param in model.parameters()])
print(' + Number of params: %.2fM' % (total / 1e6))
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed for replicable result (default: 1)')
parser.add_argument('--saves', metavar='NAME',
help='the name to saves the model after training (default: None, it dont saves)')
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
if args.dataset not in datasets.available_datasets:
print("Dataset not available")
exit()
num_classes = datasets.num_classes[args.dataset]
if args.pretrained:
cnn = models.alexnet(num_classes)
else:
cnn = torchvision.models.alexnet(pretrained=False, num_classes=num_classes)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
dataset = datasets.__dict__[args.dataset]
train_loader, test_loader = dataset(batch_size=args.batch_size, download=False)
if args.cuda:
cnn.cuda()
optimizer = optim.Adam(cnn.parameters(), lr=args.lr)
criterion = nn.CrossEntropyLoss()
