def fetch_ori_data(dataset, root):
"""
fetch original data from torchvision CIFAR10/100 class
@return:
data: np.ndarray, (50000, 32, 32, 3), all data is here!
targets: list, 50000, all label is here!
classes: list, [name1, name2, ...]
class_to_idx: dict, {name:idx, ...}
"""
if dataset == 'cifar10':
trainset = cifar.CIFAR10(root, train=True, download=True)
testset = cifar.CIFAR10(root, train=False, download=True)
elif dataset == 'cifar100':
trainset = cifar.CIFAR100(root, train=True, download=True)
testset = cifar.CIFAR100(root, train=False, download=True)
else:
raise ValueError('no this dataset')
cifar_ = {
'train': (trainset.data, np.array(trainset.targets)),
'test': (testset.data, np.array(testset.targets)),
'classes': trainset.classes,
'class_to_idx': trainset.class_to_idx
}
return cifar_
def train_cifar10(epoch):
train_dataset = cifar.CIFAR10(root='./cifar10_train',
download=False,
train=True,
transform=ToTensor())
test_dataset = cifar.CIFAR10(root='./cifar10_test',
download=False,
train=False,
transform=ToTensor())
# epoch = 100
model = train.TrainTask(train_dataset, test_dataset, epoch, 2)
torch.save(model.state_dict(), "./cifar10.{0}.pt".format(epoch))
def TrainTask(train_dataset, test_dataset, epoch, typ):
batch_size = 256
train_loader = DataLoader(train_dataset, batch_size=batch_size)
if typ == 1:
model = Model()
else:
model = LeNet()
sgd = SGD(model.parameters(), lr=1e-1)
cross_error = CrossEntropyLoss()
accs = []
losses = []
for _epoch in range(epoch):
for idx, (train_x, train_label) in enumerate(train_loader):
label_np = np.zeros((train_label.shape[0], 10))
sgd.zero_grad()
predict_y = model(train_x.float())
_error = cross_error(predict_y, train_label.long())
# if idx % 10 == 0:
# print('idx: {}, _error: {}'.format(idx, _error))
_error.backward()
sgd.step()
cifar_test = cifar.CIFAR10("cifar10_test", train=False, transform=ToTensor())
batch_size = 256
test_loader = DataLoader(cifar_test, batch_size=batch_size)
acc = val(test_loader, model)
accs.append(acc)
losses.append(_error)
return accs, losses, model
def gen_test_datasets(self,
transform=None,
target_transform=None) -> Dataset:
return cifar.CIFAR10(root=CIFAR10PATH,
train=False,
download=True,
transform=transform,
target_transform=target_transform)
def gen_test_datasets(self,
transform=None,
target_transform=None) -> Dataset:
return cifar.CIFAR10(root="~/.cache/torch/data",
train=False,
download=True,
transform=transform,
target_transform=target_transform)
def get_cifar_dataset(is_train=True, transform=None):
cifar_dataset = cifar.CIFAR10(
root="C:\\Users\\hoanglv10\\PycharmProjects\\CNN\dataset\\data",
download=True,
train=is_train,
transform=transform)
return cifar_dataset
def getDataLoader_Cifar10():
transform_train = transforms.Compose([
transforms.Scale(32),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
transform_test = transforms.Compose([
transforms.Scale(32),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
train_set = cifar.CIFAR10('../data/cifar10', train=True, transform=transform_train, download=True)
test_set = cifar.CIFAR10('../data/cifar10', train=False, transform=transform_test, download=True)
print(len(train_set))
train_data = DataLoader(train_set, batch_size=64, shuffle=True)
test_data = DataLoader(test_set, batch_size=128, shuffle=False)
return train_data, test_data
def get_test_dataset_loader(dataset):
test_transform = get_test_transform(dataset)
if dataset == 'cifar':
test_dataset = cifar.CIFAR10(base_settings.DATA_ROOT, download=True, train=False, transform=test_transform)
else:
test_dataset = MiniImageNet(train=False, transform=test_transform)
test_dataset_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, shuffle=False)
return test_dataset_loader
def testCifar(epoch):
cifar_test = cifar.CIFAR10("cifar10_test",
train=False,
transform=ToTensor())
batch_size = 256
# epoch = 100
cifar_model = LeNet()
cifar_model.load_state_dict(torch.load("./cifar10.{0}.pt".format(epoch)))
test_loader = DataLoader(cifar_test, batch_size=batch_size)
val(test_loader, cifar_model)
def _initialize(task):
from os.path import join
import pickle
train_dset = cifar.CIFAR10(root=task.root, download=False, train=True)
fpath = join(train_dset.root, cifar.CIFAR10.base_folder,
'batches.meta')
with open(fpath, 'rb') as fo:
entry = pickle.load(fo, encoding='latin1')
labelnames = entry['label_names']
task.set_labelnames(labelnames)
def _random_sample(accept_prob):
cifar10_train = cifar.CIFAR10("./cifar10_data", download=True, train=False)
img_data = cifar10_train.data
labels = cifar10_train.targets
mean = (img_data.astype("float32") / 255.0).mean(axis=(0, 1, 2))
std = (img_data.astype("float32") / 255.0).std(axis=(1, 2)).mean(axis=0)
label_data_map = {}
while len(label_data_map) < 10:
for label, data in zip(labels, img_data):
if label not in label_data_map and random() < accept_prob:
norm_data = (data.astype("float32") / 255.0 - mean) / std
label_data_map[label] = norm_data.ravel()
return label_data_map
def return_dataloader(dataset, batch_size):
"""Returns pytorch dataloaders for train and test. We expect the dataloader
to contain numpy arrays corresponding to images, along with categorical
labels. Returns the train, eval dataloaders as a tuple."""
cifar10_train = cifar.CIFAR10("~/.cifar10_data", download=True, train=True)
cifar10_test = cifar.CIFAR10("~/.cifar10_data", download=True, train=False)
cifar10_train_image = [np.array(x[0]) for x in cifar10_train]
cifar10_train_label = [x[1] for x in cifar10_train]
cifar10_test_image = [np.array(x[0]) for x in cifar10_test]
cifar10_test_label = [x[1] for x in cifar10_test]
train_loader = torch.utils.data.DataLoader(list(
zip(cifar10_train_image, cifar10_train_label)),
batch_size=batch_size,
shuffle=True,
num_workers=2)
eval_loader = torch.utils.data.DataLoader(list(
zip(cifar10_test_image, cifar10_test_label)),
batch_size=1,
shuffle=False,
num_workers=2)
return train_loader, eval_loader
def val(test_loader, model):
cifar_test = cifar.CIFAR10("cifar10_test",
train=False,
transform=ToTensor())
correct = 0
_sum = 0
for idx, (test_x, test_label) in enumerate(test_loader):
predict_y = model(test_x.float()).detach()
predict_ys = np.argmax(predict_y, axis=-1)
label_np = test_label.numpy()
_ = predict_ys == test_label
correct += np.sum(_.numpy(), axis=-1)
_sum += _.shape[0]
print('accuracy: {:.2f}'.format(correct / _sum))
def load_data_cifar10(self, batch_size=128):
'''
Returns a nested structure of tensors based on CIFAR10 database.
Will be divided into (60000/batch_size) batches of (batch_size) each.
'''
cifar_data = cifar.CIFAR10(root='./data/cifar10',
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])
]))
cifar_loader = DataLoader(cifar_data,
batch_size=batch_size,
shuffle=True)
return cifar_loader
def cifar_inputs(train=False, cifar_num=10):
root = ub.ensure_app_cache_dir('netharn')
if cifar_num == 10:
train_dset = cifar.CIFAR10(root=root, download=True, train=train)
task = CIFAR10_Task()
else:
train_dset = cifar.CIFAR100(root=root, download=True, train=train)
task = CIFAR100_Task()
if train:
bchw = (train_dset.train_data).astype(np.float32) / 255.0
labels = np.array(train_dset.train_labels)
else:
bchw = (train_dset.test_data).astype(np.float32) / 255.0
labels = np.array(train_dset.test_labels)
inputs = InMemoryInputs.from_bhwc_rgb(bchw, labels=labels)
if train:
inputs.tag = 'learn'
else:
inputs.tag = 'test'
return inputs, task
prepro = transforms.Compose([
transforms.Resize((args.size, args.size)),
transforms.RandomCrop(args.size, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((.5, .5, .5), (.5, .5, .5))
])
val_prepro = transforms.Compose([
transforms.Resize((args.size, args.size)),
transforms.ToTensor(),
transforms.Normalize((.5, .5, .5), (.5, .5, .5))
])
trainset = CIFAR.CIFAR10(root='~/Datasets/', train=True, transform=prepro, target_transform=None, download=True)
testset = CIFAR.CIFAR10(root='~/Datasets/', train=False, transform=val_prepro, target_transform=None, download=True)
train_loader = DataLoader(trainset, batch_size=args.batch, shuffle=True)
test_loader = DataLoader(testset, batch_size=args.batch, shuffle=False)
len_train = len(trainset)
len_test = len(testset)
model = vgg.vgg16(pretrained=False)
num_ftrs = model.classifier[6].in_features
model.classifier[6] = nn.Linear(num_ftrs, args.class_num)
if args.load is not None:
checkpoints = torch.load(args.load)
weights = checkpoints['weights']
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))
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
import matplotlib.pyplot as plt
import numpy as np
from torchvision.datasets import cifar
# The output of torchvision datasets are PILImage images of range [0, 1].
# We transform them to Tensors of normalized range [-1, 1]
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
#trainset = torchvision.datasets.CIFAR10(root='data', train=True, download=True, transform=transform)
trainset = cifar.CIFAR10(root='data',
train=True,
download=True,
transform=transform)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=4,
shuffle=True,
num_workers=2)
testset = cifar.CIFAR10(root='data',
train=False,
download=True,
transform=transform)
testloader = torch.utils.data.DataLoader(testset,
batch_size=4,
shuffle=False,
num_workers=2)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
def train(batch_size, lr, epochs, keep_prob, chkp_dir, output_pb):
click.echo(
click.style(
"lr: {}, keep_prob: {}, output pbfile: {}".format(
lr, keep_prob, output_pb),
fg="cyan",
bold=True,
))
cifar10_train = cifar.CIFAR10("./cifar10_data", download=True, train=True)
cifar10_test = cifar.CIFAR10("./cifar10_data", download=True, train=False)
mean = ((cifar10_train.train_data.astype("float32") /
255.0).mean(axis=(0, 1, 2)).tolist())
std = ((cifar10_train.train_data.astype("float32") /
255.0).std(axis=(1, 2)).mean(axis=0).tolist())
cifar10_train.transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
transforms.ToTensor(),
transforms.Normalize(mean, std),
])
cifar10_test.transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(mean, std)])
train_loader = torch.utils.data.DataLoader(cifar10_train,
batch_size=batch_size,
shuffle=True,
num_workers=2)
eval_loader = torch.utils.data.DataLoader(cifar10_test,
batch_size=len(cifar10_test),
shuffle=False,
num_workers=2)
graph = tf.Graph()
with graph.as_default():
tf_image_batch = tf.placeholder(tf.float32, shape=[None, 32, 32, 3])
tf_labels = tf.placeholder(tf.float32, shape=[None, 10])
tf_keep_prob = tf.placeholder(tf.float32, name="keep_prob")
tf_pred, train_op, tf_total_loss, saver = build_graph(tf_image_batch,
tf_labels,
tf_keep_prob,
lr=lr)
best_acc = 0.0
chkp_cnt = 0
with tf.Session(graph=graph) as sess:
tf.global_variables_initializer().run()
for epoch in range(1, epochs + 1):
for i, (img_batch, label_batch) in enumerate(train_loader, 1):
np_img_batch = img_batch.numpy().transpose((0, 2, 3, 1))
np_label_batch = label_batch.numpy()
_ = sess.run(
train_op,
feed_dict={
tf_image_batch: np_img_batch,
tf_labels: one_hot(np_label_batch),
tf_keep_prob: keep_prob,
},
)
if (i % 100) == 0:
img_batch, label_batch = next(iter(eval_loader))
np_img_batch = img_batch.numpy().transpose((0, 2, 3, 1))
np_label_batch = label_batch.numpy()
pred_label = sess.run(
tf_pred,
feed_dict={
tf_image_batch: np_img_batch,
tf_keep_prob: 1.0
},
)
acc = (pred_label
== np_label_batch).sum() / np_label_batch.shape[0]
click.echo(
click.style(
"[epoch {}: {}], accuracy {:0.2f}%".format(
epoch, i, acc * 100),
fg="yellow",
bold=True,
))
if acc >= best_acc:
best_acc = acc
chkp_cnt += 1
click.echo(
click.style(
"[epoch {}: {}] saving checkpoint, {} with acc {:0.2f}%"
.format(epoch, i, chkp_cnt, best_acc * 100),
fg="white",
bold=True,
))
best_chkp = saver.save(sess,
chkp_dir,
global_step=chkp_cnt)
best_graph_def = prepare_meta_graph("{}.meta".format(best_chkp),
output_nodes=[tf_pred.op.name])
with open(output_pb, "wb") as fid:
fid.write(best_graph_def.SerializeToString())
click.echo(
click.style("{} saved".format(output_pb), fg="blue", bold=True))
for k, v in sorted(vars(args).items()):
print('%s: %s' % (str(k), str(v)))
print('-------------- End ---------------')
init_mem = get_gpu_memory_map()
seed = 7
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.benchmark = True
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])
train_loader = DataLoader(cifar.CIFAR10(root='cifar', train=True, transform=transform, download=True), batch_size=args.batch_size, shuffle=False, pin_memory=True, drop_last=True)
test_loader = DataLoader(cifar.CIFAR10(root='cifar', train=False, transform=transform, download=True), batch_size=args.batch_size, shuffle=False, pin_memory=True, drop_last=True)
loss_fn = torch.nn.CrossEntropyLoss().cuda()
result = {}
result['train_time'] = []
result['train_mem'] = []
result['train_loss'] = []
result['test_time'] = []
result['test_loss'] = []
result['test_acc'] = []
for i in range(5):
model = VGG16(num_classes=10).cuda()
model.train()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
if args.mode == 'FP16':
model = network_to_half(model)
def __init__(self):
super(SimpleNet, self).__init__()
self.fc1 = nn.Linear(entry_len, 256)
self.fc2 = nn.Linear(256, 64)
self.fc3 = nn.Linear(64, 10)
def forward(self, x):
x = torch.sigmoid(self.fc1(x))
x = torch.sigmoid(self.fc2(x))
x = self.fc3(x)
return x
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
training_data = list(cifar.CIFAR10("/home/jedrzej/Desktop/Machine_learning/", train=True, download=True, transform=transforms.Compose([transforms.ToTensor(), flatten_vector]), target_transform=one_hot_encode))
test_data = list(cifar.CIFAR10("/home/jedrzej/Desktop/Machine_learning/", download=True, transform=transforms.Compose([transforms.ToTensor(), flatten_vector]), target_transform=one_hot_encode))
entry_len = training_data[0][0].shape[0]
learning_sets = [[8, 1, 0.5], [5, 0.5, 0.1], [2, 1.2, 0.3]]
criterion = nn.MSELoss(reduction="mean")
batch_size = 128
epochs = 60
train_loader = torch.utils.data.DataLoader(training_data, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=50000, shuffle=False)
color_map = plt.cm.get_cmap('rainbow', len(learning_sets))
n=0
init_mem = get_gpu_memory_map()
seed = 7
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.benchmark = True
if args.mode == 'amp':
from apex import amp
amp_handle = amp.init()
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])
train_loader = DataLoader(cifar.CIFAR10(root='cifar',
train=True,
transform=transform,
download=True),
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
drop_last=True)
test_loader = DataLoader(cifar.CIFAR10(root='cifar',
train=False,
transform=transform,
download=True),
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
drop_last=True)
loss_fn = torch.nn.CrossEntropyLoss().cuda()
result = {}
batch_size = 128
num = 50
in_ch = 3
cat_num = 10
img_size = 32
prepro = transforms.Compose([
transforms.Resize((img_size, img_size)),
transforms.CenterCrop((img_size, img_size)),
transforms.ToTensor(),
transforms.Normalize((.5, .5, .5), (.5, .5, .5))
])
train_set = cifar.CIFAR10(root="./data",
train=True,
transform=prepro,
target_transform=None,
download=True)
valid_set = cifar.CIFAR10(root="./data",
train=False,
transform=prepro,
target_transform=None,
download=True)
train_data = DataLoader(train_set, batch_size, shuffle=False)
valid_data = DataLoader(valid_set, batch_size, shuffle=False)
net = vgg.vgg11().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=.01, momentum=.9)
std=[0.229, 0.224, 0.225]
)
transforms = {
"train": Compose([
RandomHorizontalFlip(),
RandomCrop(32, 4),
ToTensor(),
normalize,
]),
"valid": Compose([ToTensor(), normalize]),
}
loader = {
"train": DataLoader(
cifar.CIFAR10(
"./dataset", True,
transform=transforms["train"], download=True
),
batch_size=args.batch_size,
shuffle=True,
pin_memory=True,
num_workers=4
),
"valid": DataLoader(
cifar.CIFAR10(
"./dataset", False,
transform=transforms["valid"], download=True
),
batch_size=args.batch_size,
shuffle=True,
pin_memory=True,
num_workers=4
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')
# if idx % 10 == 0:
# print('idx: {}, _error: {}'.format(idx, _error))
_error.backward()
sgd.step()
cifar_test = cifar.CIFAR10("cifar10_test", train=False, transform=ToTensor())
batch_size = 256
test_loader = DataLoader(cifar_test, batch_size=batch_size)
acc = val(test_loader, model)
accs.append(acc)
losses.append(_error)
return accs, losses, model
if __name__ == "__main__":
train_dataset = cifar.CIFAR10(root='./cifar10_train', download=False, train=True, transform=ToTensor())
test_dataset = cifar.CIFAR10(root='./cifar10_test', download=False, train=False, transform=ToTensor())
epoch = 100
acc, loss, model = TrainTask(train_dataset, test_dataset, epoch, 2)
x1 = range(0, epoch)
x2 = range(0, epoch)
y1 = acc
y2 = loss
plt.subplot(2, 1, 1)
plt.plot(x1, y1, 'o-')
plt.title('Test accuracy vs. epoches')
plt.ylabel('Test accuracy')
plt.subplot(2, 1, 2)
plt.plot(x2, y2, '.-')
plt.xlabel('Test loss vs. epoches')
