def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("using {} device.".format(device)) batch_size = 16 epochs = 200 data_transform = { "train": transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), "val": transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) } data_root = os.path.abspath(os.path.join(os.getcwd(), ".")) # get data root path image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path assert os.path.exists(image_path), "{} path does not exist.".format( image_path) train_dataset = datasets.ImageFolder(root=os.path.join( image_path, "train"), transform=data_transform["train"]) train_num = len(train_dataset) # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4} flower_list = train_dataset.class_to_idx cla_dict = dict((val, key) for key, val in flower_list.items()) # write dict into json file json_str = json.dumps(cla_dict, indent=4) with open('class_indices.json', 'w') as json_file: json_file.write(json_str) nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # number of workers print('Using {} dataloader workers every process'.format(nw)) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=nw) validate_dataset = datasets.ImageFolder(root=os.path.join( image_path, "val"), transform=data_transform["val"]) val_num = len(validate_dataset) validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=batch_size, shuffle=False, num_workers=nw) print("using {} images for training, {} images for validation.".format( train_num, val_num)) # create model net = LeNet(num_classes=5) # load pretrained weights # download url: https://download.pytorch.org/models/mobilenet_v3_large-8738ca79.pth # download url: https://download.pytorch.org/models/mobilenet_v3_small-047dcff4.pth # model_weight_path = "weights/LeNet_pretrained.pth" # assert os.path.exists(model_weight_path), "file {} dose not exist.".format(model_weight_path) # pre_weights = torch.load(model_weight_path, map_location=device) # delete classifier weights # pre_dict = {k: v for k, v in pre_weights.items() if net.state_dict()[k].numel() == v.numel()} # missing_keys, unexpected_keys = net.load_state_dict(pre_dict, strict=False) # # # freeze features weights # for param in net.conv_stem.parameters(): # param.requires_grad = False # # for param in net.bn1.parameters(): # param.requires_grad = False # # for param in net.act1.parameters(): # param.requires_grad = False # # for param in net.blocks.parameters(): # param.requires_grad = False net.to(device) # define loss function loss_function = nn.CrossEntropyLoss() # construct an optimizer params = [p for p in net.parameters() if p.requires_grad] optimizer = optim.Adam(params, lr=0.0001) best_acc = 0.0 save_path = 'weights/lenet.pth' train_steps = len(train_loader) for epoch in range(epochs): # train net.train() running_loss = 0.0 train_bar = tqdm(train_loader) for step, data in enumerate(train_bar): images, labels = data optimizer.zero_grad() logits = net(images.to(device)) loss = loss_function(logits, labels.to(device)) loss.backward() optimizer.step() # print statistics running_loss += loss.item() train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format( epoch + 1, epochs, loss) # validate net.eval() acc = 0.0 # accumulate accurate number / epoch with torch.no_grad(): val_bar = tqdm(validate_loader) for val_data in val_bar: val_images, val_labels = val_data outputs = net(val_images.to(device)) # loss = loss_function(outputs, test_labels) predict_y = torch.max(outputs, dim=1)[1] acc += torch.eq(predict_y, val_labels.to(device)).sum().item() val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1, epochs) val_accurate = acc / val_num print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' % (epoch + 1, running_loss / train_steps, val_accurate)) if val_accurate > best_acc: best_acc = val_accurate torch.save(net.state_dict(), save_path) print('Finished Training')
help='Learning rate decay', type=float) parser.add_argument('--batch_size', default=80, help='Batch Size', type=int) parser.add_argument('--data_augmentation', default=True, help='Using data augmentation', type=int) parser.add_argument('--grayscale', default=True, help='Using data augmentation', type=int) parser.add_argument('--keep_prob', default=0.8, help='Keep probability for dropout', type=int) config = parser.parse_args() trainBG = BatchGenerator(X_train, y_train, config.batch_size, config.grayscale, 'train') validBG = BatchGenerator(X_valid, y_valid, config.batch_size, config.grayscale) testBG = BatchGenerator(X_valid, y_valid, config.batch_size, config.grayscale) config.decay_steps = trainBG.num_batches * config.num_epoch label_dict = {} with open('signnames.csv') as f: reader = csv.DictReader(f) for row in reader: label_dict[row['ClassId']] = row['SignName'] #vgg = VGGsimple(config, label_dict) #vgg.train(trainBG, validBG, config.num_epoch) lenet = LeNet(config, label_dict) lenet.train(trainBG, validBG, config.num_epoch)
def train_and_test(flags, corruption_level=0, gold_fraction=0.5, get_C=uniform_mix_C): np.random.seed(1) torch.manual_seed(1) torch.cuda.manual_seed(1) C = get_C(corruption_level) gold, silver = prepare_data(C, gold_fraction) print("Gold shape = {}, Silver shape = {}".format(gold.images.shape, silver.images.shape)) # TODO : test on whole set test_x = torch.from_numpy(mnist.test.images[:500].reshape([-1, 1, 28, 28])) test_y = torch.from_numpy(mnist.test.labels[:500]).type(torch.LongTensor) print("Test shape = {}".format(test_x.shape)) model = LeNet() optimizer = torch.optim.Adam([p for p in model.parameters()], lr=0.001) for step in range(flags.num_steps): x, y = silver.next_batch(flags.batch_size) y, y_true = np.array([l[0] for l in y]), np.array([l[1] for l in y]) x_val, y_val = gold.next_batch(min(flags.batch_size, flags.nval)) x, y = torch.from_numpy(x.reshape( [-1, 1, 28, 28])), torch.from_numpy(y).type(torch.LongTensor) x_val, y_val = torch.from_numpy(x_val.reshape( [-1, 1, 28, 28])), torch.from_numpy(y_val).type(torch.LongTensor) # forward if flags.method == "l2w": ex_wts = reweight_autodiff(model, x, y, x_val, y_val) logits, loss = model.loss(x, y, ex_wts) if step % dbg_steps == 0: tbrd.log_histogram("ex_wts", ex_wts, step=step) tbrd.log_value("More_than_0.01", sum([x > 0.01 for x in ex_wts]), step=step) tbrd.log_value("More_than_0.05", sum([x > 0.05 for x in ex_wts]), step=step) tbrd.log_value("More_than_0.1", sum([x > 0.1 for x in ex_wts]), step=step) mean_on_clean_labels = np.mean( [ex_wts[i] for i in range(len(y)) if y[i] == y_true[i]]) mean_on_dirty_labels = np.mean( [ex_wts[i] for i in range(len(y)) if y[i] != y_true[i]]) tbrd.log_value("mean_on_clean_labels", mean_on_clean_labels, step=step) tbrd.log_value("mean_on_dirty_labels", mean_on_dirty_labels, step=step) else: logits, loss = model.loss(x, y) print("Loss = {}".format(loss)) # backward optimizer.zero_grad() loss.backward() optimizer.step() tbrd.log_value("loss", loss, step=step) if step % dbg_steps == 0: model.eval() pred = torch.max(model.forward(test_x), 1)[1] test_acc = torch.sum(torch.eq(pred, test_y)).item() / float( test_y.shape[0]) model.train() print("Test acc = {}.".format(test_acc)) tbrd.log_value("test_acc", test_acc, step=step)
def train(queue, config): from model import LeNet model = LeNet(config) model.train()
net = LeNet() if MULTI_GPU: net = nn.DataParallel(net,device_ids=device_ids) net.to(device) criteon = nn.CrossEntropyLoss() optimizer=optim.Adam(net.parameters(), lr=1e-3) scheduler = StepLR(optimizer, step_size=100, gamma=0.1) if MULTI_GPU: optimizer = nn.DataParallel(optimizer, device_ids=device_ids) scheduler = nn.DataParallel(scheduler, device_ids=device_ids) # print(net) for epoch in range(epoch_num): for batchidx, (label, img) in enumerate(cifar_train_loader): net.train() logits = net(img.to(device)) loss = criteon(logits, label.long().to(device)) optimizer.zero_grad() loss.backward() optimizer.module.step() scheduler.module.step() print("epoch:{} loss:{}".format(epoch, loss.item())) write.add_scalar(tag='train_loss', global_step=epoch, scalar_value=loss.item()) net.eval() with torch.no_grad(): total_num = 0 total_correct = 0 for label, img in cifar_test_loader: logits = net(img.to(device))
""" 该代码定义了LeNet模型的训练过程 """ import torch import torch.nn as nn from model import LeNet # ... 此处略去定义训练数据载入器的代码,具体可参考代码4.3 model = LeNet() # 定义LeNet模型 model.train() # 切换模型到训练状态 lr = 0.01 # 定义学习率 criterion = nn.CrossEntropyLoss() # 定义损失函数 optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4) # 定义随机梯度下降优化器 train_loss = 0 correct = 0 total = 0 for batch_idx, (inputs, targets) in enumerate(data_train_loader): optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step() train_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0)
def main(args): # Data Loader (Input Pipeline) model_str = args.dataset + '_%s_' % args.model_type + args.noise_type + '_' + str(args.noise_rate) + '_' + str(args.seed) txtfile = save_dir + "/" + model_str + ".txt" nowTime = datetime.datetime.now().strftime('%Y-%m-%d-%H:%M:%S') if os.path.exists(txtfile): os.system('mv %s %s' % (txtfile, txtfile + ".bak-%s" % nowTime)) # Data Loader (Input Pipeline) print('loading dataset...') train_dataset, val_dataset, test_dataset = load_data(args) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=False, shuffle=True) val_loader = torch.utils.data.DataLoader(dataset=val_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=False, shuffle=False) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=args.batch_size, num_workers=args.num_workers, drop_last=False, shuffle=False) # Define models print('building model...') if args.dataset == 'mnist': clf1 = LeNet() optimizer1 = torch.optim.SGD(clf1.parameters(), lr=learning_rate, weight_decay=args.weight_decay, momentum=0.9) scheduler1 = MultiStepLR(optimizer1, milestones=[10, 20], gamma=0.1) elif args.dataset == 'fmnist': clf1 = resnet.ResNet50(input_channel=1, num_classes=10) optimizer1 = torch.optim.SGD(clf1.parameters(), lr=learning_rate, weight_decay=args.weight_decay, momentum=0.9) scheduler1 = MultiStepLR(optimizer1, milestones=[10, 20], gamma=0.1) elif args.dataset == 'cifar10': clf1 = resnet.ResNet50(input_channel=3, num_classes=10) optimizer1 = torch.optim.SGD(clf1.parameters(), lr=learning_rate, weight_decay=args.weight_decay, momentum=0.9) scheduler1 = MultiStepLR(optimizer1, milestones=[40, 80], gamma=0.1) elif args.dataset == 'cifar100': clf1 = resnet.ResNet50(input_channel=3, num_classes=100) optimizer1 = torch.optim.SGD(clf1.parameters(), lr=learning_rate, weight_decay=args.weight_decay, momentum=0.9) scheduler1 = MultiStepLR(optimizer1, milestones=[40, 80], gamma=0.1) clf1.cuda() with open(txtfile, "a") as myfile: myfile.write('epoch train_acc1 val_acc1 test_acc1\n') epoch = 0 train_acc1 = 0 # evaluate models with random weights val_acc1 = evaluate(val_loader, clf1) print('Epoch [%d/%d] Val Accuracy on the %s val data: Model1 %.4f %%' % ( epoch + 1, args.n_epoch, len(val_dataset), val_acc1)) test_acc1 = evaluate(test_loader, clf1) print('Epoch [%d/%d] Test Accuracy on the %s test data: Model1 %.4f %%' % ( epoch + 1, args.n_epoch, len(test_dataset), test_acc1)) # save results with open(txtfile, "a") as myfile: myfile.write(str(int(epoch)) + ' ' + str(train_acc1) + ' ' + str(val_acc1) + ' ' + str(test_acc1) + "\n") val_acc_list = [] test_acc_list = [] for epoch in range(0, args.n_epoch): scheduler1.step() print(optimizer1.state_dict()['param_groups'][0]['lr']) clf1.train() train_acc1 = train(train_loader, epoch, clf1, optimizer1, args) val_acc1 = evaluate(val_loader, clf1) val_acc_list.append(val_acc1) test_acc1 = evaluate(test_loader, clf1) test_acc_list.append(test_acc1) # save results print('Epoch [%d/%d] Test Accuracy on the %s test data: Model1 %.4f %% ' % ( epoch + 1, args.n_epoch, len(test_dataset), test_acc1)) with open(txtfile, "a") as myfile: myfile.write(str(int(epoch)) + ' ' + str(train_acc1) + ' ' + str(val_acc1) + ' ' + str(test_acc1) + "\n") id = np.argmax(np.array(val_acc_list)) test_acc_max = test_acc_list[id] return test_acc_max
top5_valid_accuracy_log = [] # History for Confusion Matrix pred_list = torch.zeros(0, dtype=torch.long, device='cpu') label_list = torch.zeros(0, dtype=torch.long, device='cpu') for epoch in range(epochs): train_loss = 0 train_correct = 0 top5_train_correct = 0 top5_valid_correct = 0 validation_loss = 0 validation_correct = 0 train_total = 0 valid_total = 0 model.train() for inputs, labels in train_loader: inputs = inputs.to(device) labels = labels.to(device) outputs = model(inputs) loss = criterion(outputs, labels) optimizer.zero_grad() loss.backward() optimizer.step() _, preds = torch.max(outputs, 1) _, top5_preds = torch.topk(outputs, 5) train_loss += loss.item()
def train(): device = torch.device("cuda:0" if opt.cuda else "cpu") utils.set_seed() # ============================ step 1/5 数据 ============================ norm_mean = [0.485, 0.456, 0.406] norm_std = [0.229, 0.224, 0.225] train_transform = transforms.Compose([ transforms.Resize((32, 32)), transforms.RandomCrop(32, padding=4), transforms.ToTensor(), transforms.Normalize(norm_mean, norm_std), ]) valid_transform = transforms.Compose([ transforms.Resize((32, 32)), transforms.ToTensor(), transforms.Normalize(norm_mean, norm_std), ]) # 构建MyDataset train_data = RMBDataset(data_dir=opt.train_dir, transform=train_transform) valid_data = RMBDataset(data_dir=opt.valid_dir, transform=valid_transform) # 构建DataLoader train_loader = DataLoader(dataset=train_data, batch_size=opt.batch_size, shuffle=True) valid_loader = DataLoader(dataset=valid_data, batch_size=opt.batch_size) # ============================ step 2/5 模型 ============================ net = LeNet(classes=2) net.to(device) # net.initialize_weights() # ============================ step 3/5 损失函数 ============================ criterion = nn.CrossEntropyLoss() # ============================ step 4/5 优化器 ============================ optimizer = optim.SGD(net.parameters(), lr=opt.lr, momentum=0.9) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) # ============================ step 5/5 训练 ============================ train_curve = list() valid_curve = list() for epoch in range(opt.epochs): loss_mean = 0. correct = 0. total = 0. net.train() for i, data in enumerate(train_loader): inputs, labels = data inputs = inputs.to(device) labels = labels.to(device) outputs = net(inputs) optimizer.zero_grad() loss = criterion(outputs, labels) loss.backward() optimizer.step() # 统计分类情况 _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).squeeze().sum().to("cpu").numpy() # 打印训练信息 loss_mean += loss.item() train_curve.append(loss.item()) if (i + 1) % opt.log_interval == 0: loss_mean = loss_mean / opt.log_interval print( "Training:Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}" .format(epoch, opt.epochs, i + 1, len(train_loader), loss_mean, correct / total)) loss_mean = 0. scheduler.step() # 更新学习率 if (epoch + 1) % opt.val_interval == 0: correct_val = 0. total_val = 0. loss_val = 0. net.eval() with torch.no_grad(): for j, data in enumerate(valid_loader): inputs, labels = data inputs = inputs.to(device) labels = labels.to(device) outputs = net(inputs) loss = criterion(outputs, labels) _, predicted = torch.max(outputs.data, 1) total_val += labels.size(0) correct_val += ( predicted == labels).squeeze().sum().to("cpu").numpy() loss_val += loss.item() valid_curve.append(loss_val) print( "Valid:\t Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}" .format(epoch, opt.epochs, j + 1, len(valid_loader), loss_val, correct / total)) utils.loss_picture(train_curve, train_loader, valid_curve, opt.val_interval) # 保存模型参数 net_state_dict = net.state_dict() torch.save(net_state_dict, opt.path_state_dict) print("模型保存成功")
# transforms.ToTensor() # ]), download=True) #从internet上下载MNIST测试数据集,并Resize成32x32大小,转为Tensor data_train_loader = DataLoader(data_train, batch_size=256, shuffle=True, num_workers=0) #8个线程处理,随机抽取,batch=256 # data_test_loader = DataLoader(data_test, batch_size=1024, num_workers=8) ## 数据载入 # from data import data_train_loader #### 定义模型训练参数部分 model = LeNet() model.cpu() model.train() ## 切换到模型的训练模式 lr = 0.001 loss_define = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=5e-4) train_loss = 0 ## 训练损失 correct = 0 ## 识别正确个数 total = 0 ## 总个数 # momentum=0.9, epoch_num = 10 # int(input('input epoch:')) loss_plot = [] for epoch in range(epoch_num): #### for batch_idx, (inputs, targets) in enumerate(data_train_loader):