def compute_time():
"""
计算１00次，取平均值
:return:
"""
model_alexnet = AlexNet(num_classes=1000)
model_googlenet = googlenet.GoogLeNet(num_classes=1000)
model_alexnet.eval()
model_googlenet.eval()
total_time_alexnet = 0.0
total_time_googlenet = 0.0
epoch = 100
for i in range(epoch):
data = torch.randn((1, 3, 224, 224))
start = time.time()
outputs = model_alexnet.forward(data)
end = time.time()
total_time_alexnet += (end - start)
start = time.time()
outputs = model_googlenet.forward(data)
end = time.time()
total_time_googlenet += (end - start)
print('[alexnet] time: {:.4f}'.format(total_time_alexnet / epoch))
print('[googlenet] time: {:.4f}'.format(total_time_googlenet / epoch))
print('time_googlenet / time_alexnet: {:.3f}'.format(total_time_googlenet /
total_time_alexnet))
def compute_param():
model_alexnet = AlexNet(num_classes=1000)
model_googlenet = googlenet.GoogLeNet(num_classes=1000)
model_alexnet.eval()
model_googlenet.eval()
num_alexnet = util.num_model(model_alexnet)
num_googlenet = util.num_model(model_googlenet)
print('[alexnet] param num: {}'.format(num_alexnet))
print('[googlenet] param num: {}'.format(num_googlenet))
print('num_alexnet / num_googlenet: {:.2f}'.format(num_alexnet /
num_googlenet))
def get_model(device=None):
# 加载CNN模型
model = AlexNet(num_classes=2)
model.load_state_dict(
torch.load('./models/best_linear_svm_alexnet_car.pth'))
model.eval()
# 取消梯度追踪
for param in model.parameters():
param.requires_grad = False
if device:
model = model.to(device)
return model
def __init__(self, alexnet_model: torchvision_models.AlexNet):
super().__init__()
self.normalizer = ImageNetNormalizer()
self.model = alexnet_model.eval()
assert len(self.model.features) == 13
self.layer1 = nn.Sequential(self.model.features[:2])
self.layer2 = nn.Sequential(self.model.features[2:5])
self.layer3 = nn.Sequential(self.model.features[5:8])
self.layer4 = nn.Sequential(self.model.features[8:10])
self.layer5 = nn.Sequential(self.model.features[10:12])
self.layer6 = self.model.features[12]
outputs = model(images)
loss = criterion(outputs, labels)
# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i + 1) % 100 == 0:
print("Epoch [{}/{}], Step [{}/{}] Loss: {:.4f}".format(
epoch + 1, num_epochs, i + 1, total_step, loss.item()))
# Decay learning rate
if (epoch + 1) % 20 == 0:
curr_lr /= 3
update_lr(optimizer, curr_lr)
# Test the model
model.eval()
with torch.no_grad():
correct = 0
for images, labels in test_loader:
images = images.to(device)
labels = labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
correct += (predicted == labels).sum().item()
print('Test Accuracy of the model is: {} %'.format(100 * correct /
len(test_loader.dataset)))
