the top-1 ACC is around 11%, and the null_loss is around 0.03 ,center_loss around 0.0001(almost doesn't work),how does it happen?
`# -- coding: utf-8 -
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable
from torch.utils.data import DataLoader
import torch.optim.lr_scheduler as lr_scheduler
from CenterLoss import CenterLoss
import matplotlib.pyplot as plt
class Net(nn.Module):
def init(self):
super(Net, self).init()
self.conv1_1 = nn.Conv2d(1, 32, kernel_size=5, padding=2)
self.prelu1_1 = nn.PReLU()
self.conv1_2 = nn.Conv2d(32, 32, kernel_size=5, padding=2)
self.prelu1_2 = nn.PReLU()
self.conv2_1 = nn.Conv2d(32, 64, kernel_size=5, padding=2)
self.prelu2_1 = nn.PReLU()
self.conv2_2 = nn.Conv2d(64, 64, kernel_size=5, padding=2)
self.prelu2_2 = nn.PReLU()
self.conv3_1 = nn.Conv2d(64, 128, kernel_size=5, padding=2)
self.prelu3_1 = nn.PReLU()
self.conv3_2 = nn.Conv2d(128, 128, kernel_size=5, padding=2)
self.prelu3_2 = nn.PReLU()
self.preluip1 = nn.PReLU()
self.ip1 = nn.Linear(12833, 2)
self.ip2 = nn.Linear(2, 10)
def forward(self, x):
x = self.prelu1_1(self.conv1_1(x))
x = self.prelu1_2(self.conv1_2(x))
x = F.max_pool2d(x,2)
x = self.prelu2_1(self.conv2_1(x))
x = self.prelu2_2(self.conv2_2(x))
x = F.max_pool2d(x,2)
x = self.prelu3_1(self.conv3_1(x))
x = self.prelu3_2(self.conv3_2(x))
x = F.max_pool2d(x,2)
x = x.view(-1, 128*3*3)
ip1 = self.preluip1(self.ip1(x))
ip2 = self.ip2(ip1)
return ip1,F.log_softmax(ip2)
'''
def visualize(feat, labels, epoch):
plt.ion()
c = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff',
'#ff00ff', '#990000', '#999900', '#009900', '#009999']
plt.clf()
for i in range(10):
plt.plot(feat[labels == i, 0], feat[labels == i, 1], '.', c=c[i])
plt.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], loc = 'upper right')
plt.xlim(xmin=-5,xmax=5)
plt.ylim(ymin=-5,ymax=5)
plt.text(-4.8,4.6,"epoch=%d" % epoch)
plt.savefig('./images/epoch=%d.jpg' % epoch)
plt.draw()
plt.pause(0.001)
'''
def main():
if torch.cuda.is_available():
use_cuda = True
else: use_cuda = False
# Dataset
trainset = datasets.MNIST('../data', download=True,train=True, transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))]))
train_loader = DataLoader(trainset, batch_size=128, shuffle=True, num_workers=4)
testset = datasets.MNIST('../data', download=True,train=False, transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))]))
test_loader = DataLoader(testset, batch_size=128, shuffle=True, num_workers=4)
# Model
model = Net()
print(model)
# NLLLoss
nllloss = nn.NLLLoss() #CrossEntropyLoss = log_softmax + NLLLoss
# CenterLoss
loss_weight = 1
centerloss = CenterLoss(10, 2)
if use_cuda:
nllloss = nllloss.cuda()
centerloss = centerloss.cuda()
model = model.cuda()
criterion = [nllloss, centerloss]
# optimzer4nn
optimizer4nn = optim.SGD(model.parameters(),lr=0.001,momentum=0.9, weight_decay=0.0005)
sheduler = lr_scheduler.StepLR(optimizer4nn,20,gamma=0.8)
# optimzer4center
optimizer4center = optim.SGD(centerloss.parameters(), lr =0.5)
for epoch in range(50):
sheduler.step()
print('epoch {}'.format(epoch + 1))
# print optimizer4nn.param_groups[0]['lr']
print "Training... Epoch = %d" % epoch
ip1_loader = []
idx_loader = []
train_loss = 0.
train_acc = 0.
train_nll = 0.
train_cen = 0.
for i,(data, target) in enumerate(train_loader):
if use_cuda:
data = data.cuda()
target = target.cuda()
data, target = Variable(data), Variable(target)
ip1, pred = model(data)
#out = torch.max(pred, 1)[1]
loss = nllloss(pred, target) + loss_weight * centerloss(target, ip1)
train_loss += loss.data[0]
out = torch.max(pred, 1)[1]
train_correct = (out == target).sum()
train_acc += train_correct.data[0]
train_nll += nllloss(pred, target).data[0]
train_cen += centerloss(target, ip1).data[0]
optimizer4nn.zero_grad()
optimizer4center.zero_grad()
loss.backward()
optimizer4nn.step()
optimizer4center.step()
#ip1_loader.append(ip1)
#idx_loader.append((target))
print('Train Loss: {:.6f}, Acc: {:.6f},nn Loss: {:.6f}, centerloss: {:.6f}'.format(train_loss / (len(trainset)),train_acc / (len(trainset)),train_nll / (len(trainset)),train_cen / (len(trainset))))
'''
feat = torch.cat(ip1_loader, 0)
labels = torch.cat(idx_loader, 0)
visualize(feat.data.cpu().numpy(),labels.data.cpu().numpy(),epoch)
'''
model.eval()
eval_loss = 0.
eval_acc = 0.
for i,(data, target) in enumerate(test_loader):
if use_cuda:
data = data.cuda()
target = target.cuda()
data, target = Variable(data), Variable(target)
ip1, pred = model(data)
#pred = torch.max(pred, 1)[1]
loss = nllloss(pred, target) + loss_weight * centerloss(target, ip1)
eval_loss += loss.data[0]
out = torch.max(pred, 1)[1]
eval_correct = (out == target).sum()
eval_acc += eval_correct.data[0]
#optimizer[0].zero_grad()
#optimizer[1].zero_grad()
#loss.backward()
#optimizer[0].step()
#optimizer[1].step()
#ip1_loader.append(ip1)
#idx_loader.append((target))
print('Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len(
testset)), eval_acc / (len(testset))))
if name == 'main':
main()
'''
epoch 9
Training... Epoch = 8
Train Loss: 0.017925, Acc: 0.112367
Test Loss: 0.018107, Acc: 0.113500
epoch 10
Training... Epoch = 9
Train Loss: 0.017911, Acc: 0.112367
Test Loss: 0.018094, Acc: 0.11350
'''
`
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent