def get_model_and_checkpoint(model, dataset, checkpoint_path, n_gpu=1):
if model == 'mobilenet' and dataset == 'imagenet':
from mobilenet import MobileNet
net = MobileNet(n_class=1000)
elif model == 'mobilenetv2' and dataset == 'imagenet':
from mobilenet_v2 import MobileNetV2
net = MobileNetV2(n_class=1000)
elif model == 'mobilenet' and dataset == 'cifar10':
from mobilenet import MobileNet
net = MobileNet(n_class=10)
elif model == 'mobilenetv2' and dataset == 'cifar10':
from mobilenet_v2 import MobileNetV2
net = MobileNetV2(n_class=10)
else:
raise NotImplementedError
if checkpoint_path:
print('loading {}...'.format(checkpoint_path))
sd = torch.load(checkpoint_path, map_location=torch.device('cpu'))
if 'state_dict' in sd: # a checkpoint but not a state_dict
sd = sd['state_dict']
sd = {k.replace('module.', ''): v for k, v in sd.items()}
net.load_state_dict(sd)
if torch.cuda.is_available() and n_gpu > 0:
net = net.cuda()
if n_gpu > 1:
net = torch.nn.DataParallel(net, range(n_gpu))
return net
def run():
t = time.time()
print('net_cache : ', args.net_cache)
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
model = MobileNetV2()
model = nn.DataParallel(model.cuda())
if os.path.exists(args.net_cache):
print('loading checkpoint {} ..........'.format(args.net_cache))
checkpoint = torch.load(args.net_cache)
best_top1_acc = checkpoint['best_top1_acc']
model.load_state_dict(checkpoint['state_dict'])
print("loaded checkpoint {} epoch = {}".format(args.net_cache,
checkpoint['epoch']))
else:
print('can not find {} '.format(args.net_cache))
return
num_states = 17
search(model, criterion, num_states)
total_searching_time = time.time() - t
print('total searching time = {:.2f} hours'.format(total_searching_time /
3600),
flush=True)
def load_model (args):
if args.model == 'inception':
model = InceptionV3(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'xception':
model = Xception(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'inceptionresnet':
model = InceptionResNetV2(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'mobilenet':
model = MobileNet(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'mobilenet2':
model = MobileNetV2(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'nasnet':
model = NASNetLarge(include_top=True, weights='imagenet')
preprocess_mode='tf'
elif args.model == 'resnet':
model = ResNet50(include_top=True, weights='imagenet')
preprocess_mode='caffe'
elif args.model == 'vgg16':
model = VGG16(include_top=True, weights='imagenet')
preprocess_mode='caffe'
elif args.model == 'vgg19':
model = VGG19(include_top=True, weights='imagenet')
preprocess_mode='caffe'
else:
print ("Model not found")
return model,preprocess_mode
def get_model_and_checkpoint(model, dataset, checkpoint_path, n_gpu=1):
if dataset == 'imagenet':
n_class = 1000
elif dataset == 'cifar10':
n_class = 10
else:
raise ValueError('unsupported dataset')
if model == 'mobilenet':
from mobilenet import MobileNet
net = MobileNet(n_class=n_class)
elif model == 'mobilenetv2':
from mobilenet_v2 import MobileNetV2
net = MobileNetV2(n_class=n_class)
elif model.startswith('resnet'):
net = resnet.__dict__[model](pretrained=True)
in_features = net.fc.in_features
net.fc = nn.Linear(in_features, n_class)
else:
raise NotImplementedError
if checkpoint_path:
print('loading {}...'.format(checkpoint_path))
sd = torch.load(checkpoint_path, map_location=torch.device('cpu'))
if 'state_dict' in sd: # a checkpoint but not a state_dict
sd = sd['state_dict']
sd = {k.replace('module.', ''): v for k, v in sd.items()}
net.load_state_dict(sd)
if torch.cuda.is_available() and n_gpu > 0:
net = net.cuda()
if n_gpu > 1:
net = torch.nn.DataParallel(net, range(n_gpu))
return net
def get_model(args):
print('=> Building model..')
if args.dataset == 'imagenet':
n_class = 1000
elif args.dataset == 'cifar10':
n_class = 10
else:
raise NotImplementedError
if args.model_type == 'mobilenet':
net = MobileNet(n_class=n_class)
elif args.model_type == 'mobilenetv2':
net = MobileNetV2(n_class=n_class)
elif args.model_type.startswith('resnet'):
net = resnet.__dict__[args.model_type](pretrained=True)
in_features = net.fc.in_features
net.fc = nn.Linear(in_features, n_class)
else:
raise NotImplementedError
if args.ckpt_path is not None:
# the checkpoint can be state_dict exported by amc_search.py or saved by amc_train.py
print('=> Loading checkpoint {} ..'.format(args.ckpt_path))
net.load_state_dict(torch.load(args.ckpt_path, torch.device('cpu')))
if args.mask_path is not None:
SZ = 224 if args.dataset == 'imagenet' else 32
data = torch.randn(2, 3, SZ, SZ)
ms = ModelSpeedup(net, data, args.mask_path, torch.device('cpu'))
ms.speedup_model()
net.to(args.device)
if torch.cuda.is_available() and args.n_gpu > 1:
net = torch.nn.DataParallel(net, list(range(args.n_gpu)))
return net
def create_model(model_type=None,
n_classes=120,
input_size=224,
checkpoint=None,
pretrained=False,
width_mult=1.):
if model_type == 'mobilenet_v1':
model = MobileNet(n_class=n_classes, profile='normal')
elif model_type == 'mobilenet_v2':
model = MobileNetV2(n_class=n_classes,
input_size=input_size,
width_mult=width_mult)
elif model_type == 'mobilenet_v2_torchhub':
model = torch.hub.load('pytorch/vision:v0.8.1',
'mobilenet_v2',
pretrained=pretrained)
# model = torch.hub.load('pytorch/vision:v0.10.0', 'mobilenet_v2', pretrained=pretrained)
feature_size = model.classifier[1].weight.data.size()[1]
replace_classifier = torch.nn.Linear(feature_size, n_classes)
model.classifier[1] = replace_classifier
elif model_type is None:
model = None
else:
raise RuntimeError('Unknown model_type.')
if checkpoint is not None:
model.load_state_dict(torch.load(checkpoint))
return model
def get_model(args):
print('=> Building model..')
if args.dataset == 'imagenet':
n_class = 1000
elif args.dataset == 'cifar10':
n_class = 10
else:
raise NotImplementedError
if args.model_type == 'mobilenet':
net = MobileNet(n_class=n_class).cuda()
elif args.model_type == 'mobilenetv2':
net = MobileNetV2(n_class=n_class).cuda()
else:
raise NotImplementedError
if args.ckpt_path is not None:
# the checkpoint can be a saved whole model object exported by amc_search.py, or a state_dict
print('=> Loading checkpoint {} ..'.format(args.ckpt_path))
ckpt = torch.load(args.ckpt_path)
if type(ckpt) == dict:
net.load_state_dict(ckpt['state_dict'])
else:
net = ckpt
net.to(args.device)
if torch.cuda.is_available() and args.n_gpu > 1:
net = torch.nn.DataParallel(net, list(range(args.n_gpu)))
return net
def __init__(self, prev_steps=6, pred_steps=30, n_hid=256, mb2=None):
super(CNNEncoder, self).__init__()
self.pred_steps = pred_steps
self.image_encoder = MobileNetV2() if mb2 is None else mb2
self.image_emb = nn.Linear(4096, n_hid)
self.prev_traj_emb = nn.Linear(prev_steps * 2, n_hid)
self.fusion = nn.Linear(n_hid * 2, n_hid)
self.pred_fc = nn.Linear(n_hid, pred_steps * 2)
def __init__(self, norm_layer, num_filters=128, pretrained=True):
"""Creates an `FPN` instance for feature extraction.
Args:
num_filters: the number of filters in each output pyramid level
pretrained: use ImageNet pre-trained backbone feature extractor
"""
super().__init__()
net = MobileNetV2(n_class=1000)
if pretrained:
#Load weights into the project directory
state_dict = torch.load(
'mobilenetv2.pth.tar') # add map_location='cpu' if no gpu
net.load_state_dict(state_dict)
self.features = net.features
self.enc0 = nn.Sequential(*self.features[0:2])
self.enc1 = nn.Sequential(*self.features[2:4])
self.enc2 = nn.Sequential(*self.features[4:7])
self.enc3 = nn.Sequential(*self.features[7:11])
self.enc4 = nn.Sequential(*self.features[11:16])
self.td1 = nn.Sequential(
nn.Conv2d(num_filters, num_filters, kernel_size=3, padding=1),
norm_layer(num_filters), nn.ReLU(inplace=True))
self.td2 = nn.Sequential(
nn.Conv2d(num_filters, num_filters, kernel_size=3, padding=1),
norm_layer(num_filters), nn.ReLU(inplace=True))
self.td3 = nn.Sequential(
nn.Conv2d(num_filters, num_filters, kernel_size=3, padding=1),
norm_layer(num_filters), nn.ReLU(inplace=True))
self.lateral4 = nn.Conv2d(160, num_filters, kernel_size=1, bias=False)
self.lateral3 = nn.Conv2d(64, num_filters, kernel_size=1, bias=False)
self.lateral2 = nn.Conv2d(32, num_filters, kernel_size=1, bias=False)
self.lateral1 = nn.Conv2d(24, num_filters, kernel_size=1, bias=False)
self.lateral0 = nn.Conv2d(16,
num_filters // 2,
kernel_size=1,
bias=False)
for param in self.features.parameters():
param.requires_grad = False
def __init__(self, num_label=21, width_mult=1.0):
super().__init__()
# Feature Extraction
backbone = MobileNetV2()
self.feature_extractor0 = nn.Sequential(
*backbone.feature_extractor[:14],
*backbone.feature_extractor[14].conv[:3])
self.feature_extractor1 = nn.Sequential(
*backbone.feature_extractor[14].conv[3:],
*backbone.feature_extractor[15:])
self.additional_blocks = nn.ModuleList([
Residual(1280, 512, stride=2, expand_ratio=0.2),
Residual(512, 256, stride=2, expand_ratio=0.25),
Residual(256, 256, stride=2, expand_ratio=0.5),
Residual(256, 64, stride=2, expand_ratio=0.25)
])
# Predict class label and box position
self.num_label = num_label
num_defaults = [6] * 6
backbone.out_channels[0] = round(backbone.out_channels[0] * width_mult)
self.loc = []
self.conf = []
for nd, oc in zip(num_defaults[:-1], backbone.out_channels[:-1]):
self.loc.append(
build_SSeparableConv2d(oc, nd * 4, kernel=3, padding=1))
self.conf.append(
build_SSeparableConv2d(oc, nd * num_label, kernel=3,
padding=1))
self.loc.append(
nn.Conv2d(backbone.out_channels[-1],
num_defaults[-1] * 4,
kernel_size=1))
self.conf.append(
nn.Conv2d(backbone.out_channels[-1],
num_defaults[-1] * num_label,
kernel_size=1))
self.conf = nn.ModuleList(self.conf)
self.loc = nn.ModuleList(self.loc)
self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
def __init__(self, use_nmp=False, N_actors=32, N_moving_actors=32, prev_steps=6, pred_steps=30, n_hid=256,
do_prob=0.5, cnn='alex'):
super(NMPEncoder, self).__init__()
self.use_nmp = use_nmp
self.N_actors = N_actors
self.N_moving_actors = N_moving_actors
self.prev_steps = prev_steps
self.pred_steps = pred_steps
# ------ predict the actors trajctories ------- #
# share raster image feature extractor
if cnn == 'alex':
self.image_encoder = AlexNet()
self.V_encoder = AlexEncoder(prev_steps, pred_steps, n_hid, self.image_encoder)
self.H_encoder = AlexEncoder(prev_steps, pred_steps, n_hid, self.image_encoder)
self.M_encoder = AlexEncoder(prev_steps, pred_steps, n_hid, self.image_encoder)
else:
self.image_encoder = MobileNetV2()
self.V_encoder = CNNEncoder(prev_steps, pred_steps, n_hid, self.image_encoder)
self.H_encoder = CNNEncoder(prev_steps, pred_steps, n_hid, self.image_encoder)
self.M_encoder = CNNEncoder(prev_steps, pred_steps, n_hid, self.image_encoder)
if self.use_nmp:
# ------ NMP -------- #
if cnn == 'alex':
self.image_emb = nn.Linear(4096, n_hid)
else:
self.image_emb = nn.Linear(1280, n_hid)
# --- only propagate history trajectory --- #
self.prev_traj_emb = nn.Linear(prev_steps * 2, n_hid)
# --- propagate his + baseline prediction --- #
# self.prev_traj_emb = nn.Linear((prev_steps+pred_steps)*2, n_hid)
# ----- nmp ----- #
self.mlp_n2e = MLP(n_hid * 2, n_hid, n_hid, do_prob)
self.mlp_e2n = MLP(n_hid * 2, n_hid, n_hid, do_prob)
self.fusion = nn.Linear(n_hid * 2, n_hid)
# self.fusion = nn.Linear(n_hid, n_hid)
self.pred_fc = nn.Linear(n_hid, pred_steps * 2)
def test():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
transform_test = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(400),
transforms.CenterCrop((400, 400)),
transforms.ToTensor(),
])
#transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])
testset = oldBank.Bankset(oldBank.TESTSET_PATH, transform_test)
testloader = DataLoader(testset, batch_size=6, shuffle=True, num_workers=4)
model = MobileNetV2(num_classes=7)
#num_ftrs = model.classifier[1].in_features
#model.classifier[1] = nn.Linear(num_ftrs, 7)
model.load_state_dict(torch.load('best_quantized.pth'))
model.to(device)
model.eval()
running_corrects = 0
matrix = torch.zeros([7, 7])
for i, data in enumerate(testloader, 0):
inputs, labels = data['image'], data['class']
inputs = inputs.to(device)
labels = labels.to(device)
with torch.set_grad_enabled(False):
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
for i, p in enumerate(preds):
matrix[labels[i]][p] += 1
running_corrects += torch.sum(preds == labels.data)
print(matrix)
acc = running_corrects.double() / len(testset)
print('Test Acc: {:.4f}'.format(acc))
def load_model (args):
if args.output_layer == '0':
if args.model == 'inception':
model = InceptionV3(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'xception':
model = Xception(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'inceptionresnet':
model = InceptionResNetV2(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'mobilenet':
model = MobileNet(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'mobilenet2':
model = MobileNetV2(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'nasnet':
model = NASNetLarge(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='tf'
elif args.model == 'resnet':
model = ResNet50(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='caffe'
elif args.model == 'vgg16':
model = VGG16(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='caffe'
elif args.model == 'vgg19':
model = VGG19(include_top=False, weights='imagenet', pooling=args.pooling)
preprocess_mode='caffe'
else:
print ("Model not found")
return 0
else:
if args.model == 'inception':
base_model = InceptionV3(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'xception':
base_model = Xception(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'inceptionresnet':
base_model = InceptionResNetV2(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'mobilenet':
base_model = MobileNet(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'mobilenet2':
base_model = MobileNetV2(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'nasnet':
base_model = NASNetLarge(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='tf'
elif args.model == 'resnet':
base_model = ResNet50(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='caffe'
elif args.model == 'vgg16':
base_model = VGG16(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='caffe'
elif args.model == 'vgg19':
base_model = VGG19(include_top=False, weights='imagenet', pooling=args.pooling)
model = Model(input=base_model.input, output=base_model.get_layer(args.output_layer).output)
preprocess_mode='caffe'
else:
print ("Model not found")
return 0
return model,preprocess_mode
def train_net(args):
torch.manual_seed(7)
np.random.seed(7)
checkpoint = args.checkpoint
start_epoch = 0
best_loss = float('inf')
writer = SummaryWriter()
epochs_since_improvement = 0
# Initialize / load checkpoint
if checkpoint is None:
model = MobileNetV2()
model = nn.DataParallel(model)
optimizer = HNetOptimizer(torch.optim.Adam(model.parameters(), lr=args.lr))
else:
checkpoint = torch.load(checkpoint)
start_epoch = checkpoint['epoch'] + 1
epochs_since_improvement = checkpoint['epochs_since_improvement']
model = checkpoint['model']
optimizer = checkpoint['optimizer']
logger = get_logger()
# Move to GPU, if available
model = model.to(device)
# Loss function
criterion = nn.MSELoss().to(device)
# Custom dataloaders
train_dataset = DeepHNDataset('train')
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True,
num_workers=num_workers)
valid_dataset = DeepHNDataset('valid')
valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=args.batch_size, shuffle=False,
num_workers=num_workers)
# Epochs
for epoch in range(start_epoch, args.end_epoch):
model.zero_grad()
# One epoch's training
train_loss = train(train_loader=train_loader,
model=model,
criterion=criterion,
optimizer=optimizer,
epoch=epoch,
logger=logger)
writer.add_scalar('model/train_loss', train_loss, epoch)
writer.add_scalar('model/learning_rate', optimizer.lr, epoch)
print('\nCurrent effective learning rate: {}\n'.format(optimizer.lr))
# One epoch's validation
valid_loss = valid(valid_loader=valid_loader,
model=model,
criterion=criterion,
logger=logger)
writer.add_scalar('model/valid_loss', valid_loss, epoch)
# Check if there was an improvement
is_best = valid_loss < best_loss
best_loss = min(valid_loss, best_loss)
if not is_best:
epochs_since_improvement += 1
print("\nEpochs since last improvement: %d\n" % (epochs_since_improvement,))
else:
epochs_since_improvement = 0
# Save checkpoint
save_checkpoint(epoch, epochs_since_improvement, model, optimizer, best_loss, is_best, output_dir)
def build(self, input_shape):
self._encoder = MobileNetV2(dropout_rate=0.2, activation=tf.nn.elu) # TODO:
self._decoder = Decoder(num_classes=self._num_classes)
super().build(input_shape)
if __name__ == '__main__':
model_names = [
'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152', 'vgg16',
'MnasNet', 'NasNet-A-Large', 'NasNet-A-Mobile', 'MobileNet-v2'
]
models = [
models.resnet18(),
models.resnet34(),
models.resnet50(),
models.resnet101(),
models.resnet152(),
models.vgg16(),
MnasNet(),
NASNetALarge(),
NASNetAMobile(),
MobileNetV2()
]
for i, model_name in enumerate(model_names):
if model_name.find('NasNet-A-Large') >= 0:
total_flops, total_memory = get_model_parm_flops(models[i], True)
else:
total_flops, total_memory = get_model_parm_flops(models[i])
total_param = get_model_parm_nums(models[i])
print('%s, %.2f, %.2f, %.2f, %.2f, %.2f' %
(model_name, total_flops / 1e9, total_memory / 1e6,
total_param / 1e6, total_flops /
(total_memory + total_param), total_flops * 256 /
(total_memory * 256 + total_param)))
#print('%s:' %(model_name))
#print(' + Number of FLOPs: %.2fG' % (total_flops / 1e9))
def load_model(model_file):
model = MobileNetV2()
state_dict = torch.load(model_file)
model.load_state_dict(state_dict)
model.to('cpu')
return model
import time
import torch
from mobilenet_v2 import MobileNetV2
if __name__ == '__main__':
checkpoint = 'BEST_checkpoint.tar'
print('loading {}...'.format(checkpoint))
start = time.time()
checkpoint = torch.load(checkpoint)
print('elapsed {} sec'.format(time.time() - start))
model = checkpoint['model'].module
# print(model)
# print(type(model))
# model.eval()
filename = 'homonet.pt'
print('saving {}...'.format(filename))
start = time.time()
torch.save(model.state_dict(), filename)
print('elapsed {} sec'.format(time.time() - start))
print('loading {}...'.format(filename))
start = time.time()
model = MobileNetV2()
model.load_state_dict(torch.load(filename))
print('elapsed {} sec'.format(time.time() - start))
def main():
if not torch.cuda.is_available():
sys.exit(1)
start_t = time.time()
cudnn.benchmark = True
cudnn.enabled = True
logging.info("args = %s", args)
model = MobileNetV2()
#Loading of a pre-trained mobilenet
model_pretrained = models.mobilenet_v2(pretrained=True)
dict_params = dict(model.named_parameters())
dict_params_pretrained = dict(model_pretrained.named_parameters())
print('Not pretrained: ', list(dict_params)[:10])
print('Pretrained: ', list(dict_params_pretrained)[:10])
for param in dict_params:
dict_params[param].data.copy_(dict_params_pretrained[param].data)
num_ftrs = model.classifier[1].in_features
# Here the size of each output sample is set to 2.
# Alternatively, it can be generalized to nn.Linear(num_ftrs, len(class_names)).
mobilenet.classifier[1] = nn.Linear(num_ftrs, 2)
logging.info(model)
model = nn.DataParallel(model).cuda()
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
criterion_smooth = CrossEntropyLabelSmooth(CLASSES, args.label_smooth)
criterion_smooth = criterion_smooth.cuda()
all_parameters = model.parameters()
weight_parameters = []
for pname, p in model.named_parameters():
if 'fc' in pname or 'conv1' in pname or 'pwconv' in pname:
weight_parameters.append(p)
weight_parameters_id = list(map(id, weight_parameters))
other_parameters = list(
filter(lambda p: id(p) not in weight_parameters_id, all_parameters))
optimizer = torch.optim.SGD(
[{
'params': other_parameters
}, {
'params': weight_parameters,
'weight_decay': args.weight_decay
}],
args.learning_rate,
momentum=args.momentum,
)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer,
lambda step:
(1.0 - step / args.epochs),
last_epoch=-1)
start_epoch = 0
best_top1_acc = 0
checkpoint_tar = os.path.join(args.save, 'checkpoint.pth.tar')
if os.path.exists(checkpoint_tar):
logging.info('loading checkpoint {} ..........'.format(checkpoint_tar))
checkpoint = torch.load(checkpoint_tar)
start_epoch = checkpoint['epoch']
best_top1_acc = checkpoint['best_top1_acc']
model.load_state_dict(checkpoint['state_dict'])
logging.info("loaded checkpoint {} epoch = {}".format(
checkpoint_tar, checkpoint['epoch']))
for epoch in range(start_epoch):
scheduler.step()
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
crop_scale = 0.08
lighting_param = 0.1
train_transforms = transforms.Compose([
transforms.RandomResizedCrop(224, scale=(crop_scale, 1.0)),
Lighting(lighting_param),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
])
train_dataset = datasets.ImageFolder(traindir, transform=train_transforms)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
epoch = start_epoch
while epoch < args.epochs:
train_obj, train_top1_acc, train_top5_acc, epoch = train(
epoch, train_loader, model, criterion_smooth, optimizer, scheduler)
valid_obj, valid_top1_acc, valid_top5_acc = validate(
epoch, val_loader, model, criterion, args)
is_best = False
if valid_top1_acc > best_top1_acc:
best_top1_acc = valid_top1_acc
is_best = True
save_checkpoint(
{
'epoch': epoch,
'state_dict': model.state_dict(),
'best_top1_acc': best_top1_acc,
'optimizer': optimizer.state_dict(),
}, is_best, args.save)
epoch += 1
training_time = (time.time() - start_t) / 36000
print('total training time = {} hours'.format(training_time))
def get_backbone(name, in_channels):
if name == 'mobilenet_v2':
return MobileNetV2(in_channels=in_channels)
raise NotImplementedError
def main():
if not torch.cuda.is_available():
sys.exit(1)
start_t = time.time()
cudnn.benchmark = True
cudnn.enabled=True
logging.info("args = %s", args)
# load model
model = MobileNetV2()
logging.info(model)
model = nn.DataParallel(model).cuda()
criterion = nn.CrossEntropyLoss()
criterion = criterion.cuda()
criterion_smooth = CrossEntropyLabelSmooth(CLASSES, args.label_smooth)
criterion_smooth = criterion_smooth.cuda()
# split the weight parameter that need weight decay
all_parameters = model.parameters()
weight_parameters = []
for pname, p in model.named_parameters():
if 'fc' in pname or 'conv1' in pname or 'pwconv' in pname:
weight_parameters.append(p)
weight_parameters_id = list(map(id, weight_parameters))
other_parameters = list(filter(lambda p: id(p) not in weight_parameters_id, all_parameters))
# define the optimizer
optimizer = torch.optim.SGD(
[{'params' : other_parameters},
{'params' : weight_parameters, 'weight_decay' : args.weight_decay}],
args.learning_rate,
momentum=args.momentum,
)
# define the learning rate scheduler
# we use the linear learning rate here
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lambda step : (1.0-step/args.epochs), last_epoch=-1)
start_epoch = 0
best_top1_acc= 0
# load the checkpoint if it exists
checkpoint_tar = os.path.join(args.save, 'checkpoint.pth.tar')
if os.path.exists(checkpoint_tar):
logging.info('loading checkpoint {} ..........'.format(checkpoint_tar))
checkpoint = torch.load(checkpoint_tar)
start_epoch = checkpoint['epoch']
best_top1_acc = checkpoint['best_top1_acc']
model.load_state_dict(checkpoint['state_dict'])
logging.info("loaded checkpoint {} epoch = {}" .format(checkpoint_tar, checkpoint['epoch']))
# adjust the learning rate according to the checkpoint
for epoch in range(start_epoch):
scheduler.step()
# load training data
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
# data augmentation
crop_scale = 0.08
lighting_param = 0.1
train_transforms = transforms.Compose([
transforms.RandomResizedCrop(224, scale=(crop_scale, 1.0)),
Lighting(lighting_param),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize])
train_dataset = datasets.ImageFolder(
traindir,
transform=train_transforms)
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
# load validation data
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(valdir, transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
# train the model
epoch = start_epoch
while epoch < args.epochs:
train_obj, train_top1_acc, train_top5_acc = train(epoch, train_loader, model, criterion_smooth, optimizer, scheduler)
valid_obj, valid_top1_acc, valid_top5_acc = validate(epoch, val_loader, model, criterion, args)
is_best = False
if valid_top1_acc > best_top1_acc:
best_top1_acc = valid_top1_acc
is_best = True
save_checkpoint({
'epoch': epoch,
'state_dict': model.state_dict(),
'best_top1_acc': best_top1_acc,
'optimizer' : optimizer.state_dict(),
}, is_best, args.save)
epoch += 1
training_time = (time.time() - start_t) / 36000
print('total training time = {} hours'.format(training_time))
def detect_hand(frameCount):
# grab global references to the video stream, output frame, and
# lock variables
global vs, outputFrame, lock
# initialize the motion detector and the total number of frames
# read thus far
md = SingleMotionDetector(accumWeight=0.1)
total = 0
convert = {0: 'la', 1: 'dam', 2: 'keo'}
checkpoint = torch.load('MBN_epoch_1_loss_0.10.pth',
map_location=torch.device('cpu'))
# print(checkpoint)
model = MobileNetV2(num_classes=3)
model.load_state_dict(checkpoint)
# print(model)
model.eval()
# set robot and man score
robot = 0
man = 0
mapping = [22, 27, 17]
naming = ['paper', 'rock', 'scissors']
isEnd = 1
# 2 = scissors = GPIO17
# 1 = rock = GPIO27
# 0 = paper = GPIO22
# 17 keo 27 bua 22 la
# loop over frames from the video stream
while True:
# read the next frame from the video stream, resize it,
# convert the frame to grayscale, and blur it
# robot random
x = randint(0, 2)
frame = vs.read()
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
# grab the current timestamp and draw it on the frame
timestamp = datetime.datetime.now()
cv2.putText(frame, timestamp.strftime("%A %d %B %Y %I:%M:%S%p"),
(10, frame.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35,
(0, 0, 255), 1)
# if the total number of frames has reached a sufficient
# number to construct a reasonable background model, then
# continue to process the frame
if total > frameCount:
image1 = preprocess_image(frame)
output = model(image1)
_, predicted = torch.max(output.data, 1)
print(convert[int(predicted)])
human = int(predicted)
cv2.putText(frame, convert[int(predicted)],
(10, frame.shape[0] - 30), cv2.FONT_HERSHEY_SIMPLEX,
0.35, (0, 0, 255), 1)
if human == 0 and isEnd == 1: # la
isEnd = 0
runUpServo(mapping[x])
if x == 0:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Draw')
elif x == 1:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Human win')
man += 1
else:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Robot win')
robot += 1
elif human == 2 and isEnd == 1: # keo
isEnd = 0
runUpServo(mapping[x])
if x == 0:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Human win')
man += 1
elif x == 1:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Robot win')
robot += 1
else:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Draw')
elif human == 1: # reset game
runDownServo()
isEnd = 1
print('Scoreboard Robot vs Human: %d : %d' % (robot, man))
# update the background model and increment the total number
# of frames read thus far
md.update(gray)
total += 1
# acquire the lock, set the output frame, and release the
# lock
with lock:
outputFrame = frame.copy()
def train_net(args):
torch.manual_seed(7)
np.random.seed(7)
checkpoint = args.checkpoint
start_epoch = 0
best_acc = float('-inf')
writer = SummaryWriter()
epochs_since_improvement = 0
# Initialize / load checkpoint
if checkpoint is None:
if args.network == 'r18':
model = resnet18(args)
elif args.network == 'r34':
model = resnet34(args)
elif args.network == 'r50':
model = resnet50(args)
elif args.network == 'r101':
model = resnet101(args)
elif args.network == 'r152':
model = resnet152(args)
elif args.network == 'mobile':
from mobilenet_v2 import MobileNetV2
model = MobileNetV2()
else:
raise TypeError('network {} is not supported.'.format(
args.network))
metric_fc = ArcMarginModel(args)
if args.optimizer == 'sgd':
optimizer = torch.optim.SGD([{
'params': model.parameters()
}, {
'params': metric_fc.parameters()
}],
lr=args.lr,
momentum=args.mom,
weight_decay=args.weight_decay)
else:
optimizer = torch.optim.Adam([{
'params': model.parameters()
}, {
'params': metric_fc.parameters()
}],
lr=args.lr,
weight_decay=args.weight_decay)
else:
checkpoint = torch.load(checkpoint)
start_epoch = checkpoint['epoch'] + 1
epochs_since_improvement = checkpoint['epochs_since_improvement']
model = checkpoint['model']
metric_fc = checkpoint['metric_fc']
optimizer = checkpoint['optimizer']
model = nn.DataParallel(model)
metric_fc = nn.DataParallel(metric_fc)
# Move to GPU, if available
model = model.to(device)
metric_fc = metric_fc.to(device)
# Loss function
if args.focal_loss:
criterion = FocalLoss(gamma=args.gamma).to(device)
else:
criterion = nn.CrossEntropyLoss().to(device)
# Custom dataloaders
train_dataset = ArcFaceDataset('train')
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=num_workers)
# Epochs
for epoch in range(start_epoch, args.end_epoch):
# Decay learning rate if there is no improvement for 2 consecutive epochs, and terminate training after 10
if epochs_since_improvement == 10:
break
if epochs_since_improvement > 0 and epochs_since_improvement % 2 == 0:
checkpoint = 'BEST_checkpoint.tar'
checkpoint = torch.load(checkpoint)
model = checkpoint['model']
metric_fc = checkpoint['metric_fc']
optimizer = checkpoint['optimizer']
adjust_learning_rate(optimizer, 0.5)
# One epoch's training
train_loss, train_top1_accs = train(train_loader=train_loader,
model=model,
metric_fc=metric_fc,
criterion=criterion,
optimizer=optimizer,
epoch=epoch)
lr = optimizer.param_groups[0]['lr']
print('\nCurrent effective learning rate: {}\n'.format(lr))
# print('Step num: {}\n'.format(optimizer.step_num))
writer.add_scalar('model/train_loss', train_loss, epoch)
writer.add_scalar('model/train_accuracy', train_top1_accs, epoch)
writer.add_scalar('model/learning_rate', lr, epoch)
if epoch % 5 == 0:
# One epoch's validation
megaface_acc = megaface_test(model)
writer.add_scalar('model/megaface_accuracy', megaface_acc, epoch)
# Check if there was an improvement
is_best = megaface_acc > best_acc
best_acc = max(megaface_acc, best_acc)
if not is_best:
epochs_since_improvement += 1
print("\nEpochs since last improvement: %d\n" %
(epochs_since_improvement, ))
else:
epochs_since_improvement = 0
# Save checkpoint
save_checkpoint(epoch, epochs_since_improvement, model, metric_fc,
optimizer, best_acc, is_best)
def train_net(args):
torch.manual_seed(7)
np.random.seed(7)
checkpoint = args.checkpoint
start_epoch = 0
best_acc = float('-inf')
writer = SummaryWriter()
epochs_since_improvement = 0
# Initialize / load checkpoint
if checkpoint is None:
if args.network == 'r18':
model = resnet18(args)
elif args.network == 'r34':
model = resnet34(args)
elif args.network == 'r50':
model = resnet50(args)
elif args.network == 'r101':
model = resnet101(args)
elif args.network == 'r152':
model = resnet152(args)
elif args.network == 'mobile':
model = MobileNetV2()
else:
raise TypeError('network {} is not supported.'.format(
args.network))
# print(model)
model = nn.DataParallel(model)
metric_fc = ArcMarginModel(args)
metric_fc = nn.DataParallel(metric_fc)
if args.optimizer == 'sgd':
optimizer = torch.optim.SGD([{
'params': model.parameters()
}, {
'params': metric_fc.parameters()
}],
lr=args.lr,
momentum=args.mom,
weight_decay=args.weight_decay)
else:
optimizer = torch.optim.Adam([{
'params': model.parameters()
}, {
'params': metric_fc.parameters()
}],
lr=args.lr,
weight_decay=args.weight_decay)
else:
checkpoint = torch.load(checkpoint)
start_epoch = checkpoint['epoch'] + 1
epochs_since_improvement = checkpoint['epochs_since_improvement']
model = checkpoint['model']
metric_fc = checkpoint['metric_fc']
optimizer = checkpoint['optimizer']
logger = get_logger()
# Move to GPU, if available
model = model.to(device)
metric_fc = metric_fc.to(device)
# Loss function
if args.focal_loss:
criterion = FocalLoss(gamma=args.gamma).to(device)
else:
criterion = nn.CrossEntropyLoss().to(device)
# Custom dataloaders
train_dataset = ArcFaceDataset('train')
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=4)
scheduler = StepLR(optimizer, step_size=args.lr_step, gamma=0.1)
# Epochs
for epoch in range(start_epoch, args.end_epoch):
# One epoch's training
train_loss, train_acc = train(train_loader=train_loader,
model=model,
metric_fc=metric_fc,
criterion=criterion,
optimizer=optimizer,
epoch=epoch,
logger=logger)
writer.add_scalar('model/train_loss', train_loss, epoch)
writer.add_scalar('model/train_acc', train_acc, epoch)
# One epoch's validation
lfw_acc, threshold = lfw_test(model)
writer.add_scalar('model/valid_acc', lfw_acc, epoch)
writer.add_scalar('model/valid_thres', threshold, epoch)
# Check if there was an improvement
is_best = lfw_acc > best_acc
best_acc = max(lfw_acc, best_acc)
if not is_best:
epochs_since_improvement += 1
print("\nEpochs since last improvement: %d\n" %
(epochs_since_improvement, ))
else:
epochs_since_improvement = 0
# Save checkpoint
save_checkpoint(epoch, epochs_since_improvement, model, metric_fc,
optimizer, best_acc, is_best)
scheduler.step(epoch)
import sys
#sys.path.insert(0, '.')
import torch
from torch.autograd import Variable
from torchvision.models import resnet
import pytorch_to_caffe
#from MobileNetV2 import MobileNetV2
from mobilenet_v2 import MobileNetV2
if __name__ == '__main__':
name = 'MobileNetV2'
net= MobileNetV2().eval()
#checkpoint = torch.load("/home/shining/Downloads/mobilenet_v2.pth.tar")
#net.load_state_dict(checkpoint)
net.load_state_dict(torch.load('/home/whl/convertor/model.epoch-20.step-152166.pth',map_location='cpu')['state_dict'])
input = torch.ones([1, 3, 224, 224])
# input=torch.ones([1,3,224,224])
pytorch_to_caffe.trans_net(net, input, name)
pytorch_to_caffe.save_prototxt('{}.prototxt'.format(name))
pytorch_to_caffe.save_caffemodel('{}.caffemodel'.format(name))
image = val_tfms(pil_image)
image = image.unsqueeze_(0).cpu()
# image /= 255.00
image = F.interpolate(image, size=256)
return image
if __name__ == "__main__":
########################### Magic code line #################################
vs = VideoStream(src=0).start()
convert = {0: 'la', 1: 'dam', 2: 'keo'}
checkpoint = torch.load('MBN_epoch_1_loss_0.10.pth',
map_location=torch.device('cpu'))
# print(checkpoint)
model = MobileNetV2(num_classes=3)
model.load_state_dict(checkpoint)
# print(model)
model.eval()
# Your image here
while True:
# read the next frame from the video stream, resize it,
# convert the frame to grayscale, and blur it
time.sleep(200)
frame = vs.read()
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
# grab the current timestamp and draw it on the frame
timestamp = datetime.datetime.now()
parser = argparse.ArgumentParser(description = "run tf nvtx model")
parser.add_argument("-m", "--model", choices=["resnet", "mobilenet"])
arg = parser.parse_args()
os.environ['TF_ENABLE_AUTO_MIXED_PRECISION'] = '0'
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
#os.environ["TF_XLA_FLAGS"] = "--tf_xla_auto_jit=2 --tf_xla_cpu_global_jit"
tf.keras.backend.clear_session()
tf.config.optimizer.set_jit(True) # Enable XLA
if arg.model == 'resnet':
from resnet import ResNet50
model = ResNet50(include_top=True, weights=None, input_tensor=None, input_shape=(224, 224, 3),
pooling=None, classes=1000)
if arg.model == 'mobilenet':
from mobilenet_v2 import MobileNetV2
model = MobileNetV2(alpha=1.0, include_top=True, weights=None, input_tensor=None,
pooling=None, classes=1000, classifier_activation='softmax', input_shape=(224, 224, 3))
model.summary()
shape=[1,224,224,3]
picture = np.ones(shape, dtype=np.float32)
nSteps=50
for i in range(0, nSteps):
ret = model.predict(picture1, batch_size=1)
testset = oldBank.Bankset(oldBank.TESTSET_PATH, transform_test)
testloader = DataLoader(testset, batch_size=6, shuffle=True, num_workers=4)
# float_model = load_model(saved_model_dir + float_model_file).to('cpu')
# print('\n Inverted Residual Block: Before fusion \n\n', float_model.features[1].conv)
# float_model.eval()
# # Fuses modules
# float_model.fuse_model()
# # Note fusion of Conv+BN+Relu and Conv+Relu
# print('\n Inverted Residual Block: After fusion\n\n',float_model.features[1].conv)
model = MobileNetV2(
num_classes=7
) #models.resnet18(pretrained=True, progress=True, quantize=False)
#model.layer2 = Identity()
#model.layer4 = Identity()
#model.layer4[0].conv1 = nn.Conv2d(128, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
#model.layer4[0].downsample[0] = nn.Conv2d(128, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
#model.fuse_model()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
exp_lr_scheduler = lr_scheduler.MultiStepLR(optimizer,
milestones=[25, 60, 70, 80],
gamma=0.1)
#exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1)
"""corn""",
"""acorn""",
"""hip, rose hip, rosehip""",
"""buckeye, horse chestnut, conker""",
"""coral fungus""",
"""agaric""",
"""gyromitra""",
"""stinkhorn, carrion fungus""",
"""earthstar""",
"""hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa""",
"""bolete""",
"""ear, spike, capitulum""",
"""toilet tissue, toilet paper, bathroom tissue""" )
IMG_SIZE = 224
mbv2 = MobileNetV2()
inet = caffe.Net('./mobilenet_v2_deploy.prototxt', './mobilenet_v2.caffemodel', caffe.TEST)
def load_image(filn):
img = Image.open(filn)
cropBox = None
width, height = img.size
if width > height:
tmpv = (width - height) // 2
cropBox = (tmpv, 0, tmpv + height, height)
else:
tmpv = (height - width) // 2
cropBox = (0, tmpv, width, tmpv + width)
img = img.crop(box=cropBox).resize((IMG_SIZE, IMG_SIZE), resample=Image.BICUBIC)
img = np.asarray(img, dtype=np.float32)
ret = np.empty((3, IMG_SIZE, IMG_SIZE), dtype=np.float32)
