transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
trainset = torchvision.datasets.CIFAR10(root='../../../',
train=True,
download=False,
transform=transform)
train_loader = torch.utils.data.DataLoader(trainset,
batch_size=batch_size_train,
shuffle=True,
num_workers=2)
use_cuda = False
device = torch.device("cuda" if use_cuda else "cpu")
network = Net().to(device)
optimizer = optim.SGD(network.parameters(),
lr=learning_rate,
momentum=momentum)
network_path = 'initial_cifar_model.pth'
network_state_dict = torch.load('initial_cifar_model.pth',
map_location={'cuda:0': 'cpu'})
network.load_state_dict(network_state_dict)
def train(epoch):
network.train()
for batch_idx, (data, target) in enumerate(train_loader):
data = data.to(device)
target = target.to(device)
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
testset = torchvision.datasets.CIFAR10(root='../../../', train=False,
download=False, transform=transform)
test_loader = torch.utils.data.DataLoader(testset, batch_size= 1000,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
network = Net().to(device)
network_state_dict = torch.load('initial_cifar_model.pth', map_location={'cuda:0': 'cpu'})
network.load_state_dict(network_state_dict)
correct = 0
total = 0
with torch.no_grad():
for data in test_loader:
images, labels = data
images = images.to(device)
labels = labels.to(device)
outputs = network(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
momentum = 0.9
log_interval = 10
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='../../../', train=True,
download=False, transform=transform)
train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size_train,
shuffle=True, num_workers=2)
distilled_network = Net().to(device)
optimizer = optim.SGD(distilled_network.parameters(), lr=learning_rate,
momentum=momentum)
distilled_path = 'distilled_cifar_model.pth'
network = Net().to(device)
network_state_dict = torch.load('initial_cifar_model.pth', map_location={'cuda:0': 'cpu'})
network.load_state_dict(network_state_dict)
distilled_network_state_dict = torch.load('distilled_cifar_model.pth', map_location={'cuda:0': 'cpu'})
distilled_network.load_state_dict(distilled_network_state_dict)
def softmax_and_cross_entropy(logits, labels):
def train(options):
"""
Обучаем нашу модель, которую нужно реализовать в файле cifar_model.py
:param options:
:return:
"""
base_lr = 0.001 # задаем базовый коэффициент обучения
# список классов cifar 10
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
# иниициализация writer для записи в tensorboard
writer = SummaryWriter(log_dir=options.log)
#
# тут можно сделать аугментацию
# трансформации, шум ...
# https://www.programcreek.com/python/example/104832/torchvision.transforms.Compose
transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(),
transforms.RandomRotation,
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)), #нормализация данных
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
#
# Загружаем данные, если данных еще нет, то нужно указать флаг download=True
# torchvision реализует Dataset для CIFAR, MNIST, ImageNet...
print("Loading data....")
trainset = cifar.CIFAR10(options.input, train=True, transform=transform)
# теперь можно использовать DataLoader для доступа к данным
# Dataset, shuffle = True - доступ рандомный
# можно загружать данные в несколько потоков, если скорость загрузки
# меньше чем скорость обновления сети
trainloader = DataLoader(trainset,
batch_size=options.bs,
shuffle=True,
num_workers=2)
# данные для теста
testset = cifar.CIFAR10(options.input,
train=False,
transform=transform_test)
testloader = DataLoader(testset,
batch_size=options.bs,
shuffle=False,
num_workers=2)
# Создаем модель, нужно сделать иплементацию
print("Creating model...")
net = Net().cuda()
# Критерий кросс энтропия
criterion = nn.CrossEntropyLoss().cuda()
# тут создаем оптимайзер, который нужен
optimizer = optim.Adam(net.parameters(), lr=0.001, weight_decay=1e-4) #
#optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
start_from_epoch = 0
# Если указан чекпойнт то загружаем сеть
if options.checkpoint is not None and os.path.exists(options.checkpoint):
cp_dic = torch.load(options.checkpoint)
net.load_state_dict(cp_dic['net'])
optimizer.load_state_dict(cp_dic['optimizer'])
start_from_epoch = cp_dic['epoch']
print("Start train....")
for epoch in range(start_from_epoch, options.epoch):
train_loss = 0.0
# делаем что то с коэффициентом обучения
epoch_lr = adjust_learning_rate(optimizer, epoch, base_lr)
print('Train epoch: ', epoch)
net.train(True)
for i, data in tqdm(enumerate(trainloader, 0), total=len(trainloader)):
# получаем входы из даталоадера
inputs, labels = data
# оборачиваем данные в Variable
inputs, labels = Variable(inputs).cuda(), Variable(labels).cuda()
# обнуляем градиенты
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# печатаем статистику по итерации в tensorboard
train_loss += loss.data[0]
#
writer.add_scalar('loss/iter_train', loss.data[0],
epoch * len(trainloader) + i)
train_loss /= len(trainloader)
# тестируем модель после эпохи, что бы понять что у нас еще все хорошо
net.eval()
test_loss = 0.0
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
print('Test epoch: ', epoch)
for i, data in tqdm(enumerate(testloader, 0), total=len(testloader)):
inputs, labels = data
# получаем переменные Variable
inputs, labels = Variable(inputs, volatile=True).cuda(), Variable(
labels, volatile=True).cuda()
outputs = net(inputs)
# считаем ошибку
loss = criterion(outputs, labels)
test_loss += loss.data[0]
# считаем какие классы мы предсказали и сохраняем для
# последующего расчета accuracy
_, predicted = torch.max(outputs.data, 1)
c = (predicted == labels.data).squeeze()
for i in range(outputs.size(0)):
label = labels.data[i]
class_correct[label] += c[i]
class_total[label] += 1
test_loss /= len(testloader)
# расчитываем accuracy
accuracy = {}
avg_accuracy = 0
for i in range(10):
accuracy[classes[i]] = 100 * class_correct[i] / class_total[i]
avg_accuracy += accuracy[classes[i]]
print("train:", train_loss, "test:", test_loss)
# пишем всю статистику в tensorboard
writer.add_scalars('loss/avg_epoch_error', {
'train': train_loss,
'test': test_loss
}, epoch)
writer.add_scalars('loss/class_accuracy', accuracy, epoch)
writer.add_scalar('loss/avg_accuracy', avg_accuracy / 10, epoch)
# выводим коэффициент обучения на эпохе
writer.add_scalar('loss/epoch_lr', epoch_lr, epoch)
# сохраняем модель каждые 2 итерации
if epoch % 2 == 0:
torch.save(
{
'epoch': epoch + 1,
'net': net.state_dict(),
'optimizer': optimizer.state_dict()
}, options.model + '_chekpoint_%03d.pth' % epoch)
# сохраняем финальную модель
torch.save({
'net': net.state_dict(),
'optimizer': optimizer.state_dict()
}, options.model + '.pth')
def eval(options):
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
# Создаем модель, нужно сделать иплементацию
print("Creating model...")
net = Net().cuda()
net.eval()
# Критерий кросс энтропия проверим, что у нас вск сходится
criterion = nn.CrossEntropyLoss().cuda()
# загружаем сеть
cp_dic = torch.load(options.model)
net.load_state_dict(cp_dic)
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
# данные для теста
testset = cifar.CIFAR10(options.input,
train=False,
transform=transform_test)
testloader = DataLoader(testset,
batch_size=16,
shuffle=False,
num_workers=2)
test_loss = 0
print('Test model: ')
ofile = open(options.out, 'w')
print("id,c0,c1,c2,c3,c4,c5,c6,c7,c8,c9", file=ofile)
for bid, data in tqdm(enumerate(testloader, 0), total=len(testloader)):
inputs, labels = data
# получаем переменные Variable
inputs, labels = Variable(inputs, volatile=True).cuda(), Variable(
labels, volatile=True).cuda()
outputs = net(inputs)
# считаем ошибку
loss = criterion(outputs, labels)
test_loss += loss.data[0]
# считаем какие классы мы предсказали и сохраняем для
# последующего расчета accuracy
_, predicted = torch.max(outputs.data, 1)
c = (predicted == labels.data).squeeze()
for i in range(outputs.size(0)):
label = labels.data[i]
class_correct[label] += c[i]
class_total[label] += 1
# печатаем для каждого класса вероятности
probs = softmax(outputs)
for sid, sample in enumerate(probs.data):
s = '%d' % ((bid * 16) + sid)
for prob in sample:
s += ',%f' % prob
print(s, file=ofile)
test_loss /= len(testloader)
# расчитываем accuracy
accuracy = {}
avg_accuracy = 0
for i in range(10):
accuracy[classes[i]] = 100 * class_correct[i] / class_total[i]
avg_accuracy += accuracy[classes[i]]
print("Final cross entropy loss: %0.5f" % test_loss,
"Final accuracy: %0.3f" % (avg_accuracy / 10))