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')