def train_lenet(device, dataset_path): train_loader, valid_loader, test_loader = get_data_loaders(dataset_path) model = LeNet(35) optimizer = optim.Adam(model.parameters(), lr=Consts.lr, weight_decay=Consts.weight_decay) loss_criterion = torch.nn.NLLLoss() model.apply(weight_init) model.to(device) train_loss = [] val_loss = [] val_acc = [] for epoch in range(Consts.epochs): t_loss = train(model, train_loader, optimizer, loss_criterion, device) v_loss, v_acc = evaluation(model, valid_loader, loss_criterion, device) torch.save(model.state_dict(), f'models/epoch-{epoch + 1}.pth') train_loss.append(t_loss) val_loss.append(v_loss) val_acc.append(v_acc) print(f'train loss in epoch {epoch + 1} is: {t_loss}') print(f'validation loss in epoch {epoch + 1} is: {v_loss}') print(f'validation accuracy in epoch {epoch + 1} is: {v_acc}') plot_loss(train_loss, val_loss, val_acc) test_loss, test_acc = test_model(model, test_loader, loss_criterion, val_loss, device, 'models/')
def test(device, test_dataset_path, model_path): test_loader = get_test_loader(test_dataset_path) loss_criterion = torch.nn.NLLLoss() model = LeNet(35) if device.type == 'cpu': model.load_state_dict(torch.load(model_path, map_location=device)) else: model.load_state_dict(torch.load(model_path)) model.to(device) test_model(model, test_loader, loss_criterion, [], device, None)
def gpu_train(): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print(device) # 或者 # device = torch.device("cuda") # 或者 # device = torch.device("cpu") net = LeNet() net.to(device) # 将网络分配到指定的device中 loss_function = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=0.001) for epoch in range(5): running_loss = 0.0 time_start = time.perf_counter() for step, data in enumerate(train_loader, start=0): inputs, labels = data optimizer.zero_grad() outputs = net(inputs.to(device)) # 将inputs分配到指定的device中 loss = loss_function(outputs, labels.to(device)) # 将labels分配到指定的device中 loss.backward() optimizer.step() running_loss += loss.item() if step % 1000 == 999: with torch.no_grad(): outputs = net(test_image.to(device)) # 将test_image分配到指定的device中 predict_y = torch.max(outputs, dim=1)[1] accuracy = (predict_y == test_label.to(device)).sum().item() / test_label.size(0) # 将test_label分配到指定的device中 print('[%d, %5d] train_loss: %.3f test_accuracy: %.3f' % (epoch + 1, step + 1, running_loss / 1000, accuracy)) print('%f s' % (time.perf_counter() - time_start)) running_loss = 0.0 print('Finished Training') save_path = './Lenet.pth' torch.save(net.state_dict(), save_path)
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')
transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ])) cifar_test = dataset.Cifar10Dataset('./cifar10/test', transform=transforms.Compose([ transforms.Resize((32, 32)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ])) cifar_train_loader = DataLoader(cifar_train, batch_size=batch_size, shuffle=True) cifar_test_loader = DataLoader(cifar_test, batch_size=batch_size, shuffle=False) 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()
def img2MNIST(filename): img = Image.open(filename).convert('L') img = img.resize((28,28),Image.ANTIALIAS) arr = [] for i in range(28): for j in range(28): pixel = float(img.getpixel((j, i))) / 255.0 arr.append(pixel) arr1 = np.array(arr).reshape((1,1,28,28)) result = torch.as_tensor(arr1, dtype=torch.float32) return result parser = argparse.ArgumentParser() parser.add_argument("--filename", type=str, default='./test_sample.bmp') parser.add_argument("--model", type=str, default='./model_save/LeNet.pth') arg = parser.parse_args() if __name__ == "__main__": print("Tested picture " + arg.filename) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model_load = LeNet() model_load.load_state_dict(torch.load(arg.model)) net = model_load.to(device) net.eval() image = img2MNIST(arg.filename) output_test = net(image) _, predicted = torch.max(output_test, 1) print("The hand writing number is: " + str(predicted.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("模型保存成功")
train_data = torchvision.datasets.MNIST( root='./data/', train=True, transform=torchvision.transforms.ToTensor(), download=False) train_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=0, drop_last=True) loss_function = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=lr) torch.set_grad_enabled(True) model.train() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model.to(device) for epoch in range(Epoch): running_loss = 0.0 acc = 0.0 for step, data in enumerate(train_loader): x, y = data optimizer.zero_grad() y_pred = model(x.to(device, torch.float)) loss = loss_function(y_pred, y.to(device, torch.long)) loss.backward() running_loss += float(loss.data.cpu()) pred = y_pred.argmax(dim=1) acc += (pred.data.cpu() == y.data).sum() optimizer.step() if step % 100 == 99:
lr = opt.lr momentum = opt.momentum batch_size = opt.batch_size workers = opt.workers # get the dataset train, val, test = get_data_loaders(batch_size=batch_size, workers=workers) # list to store different models models = [] # create model and move it to device lr_str = str(lr).replace('.', '') momentum_str = str(momentum).replace('.', '') model_name_adam = f'LeNet_adam_lr{lr_str}_bth_{batch_size}' model_adam = LeNet() model_adam = model_adam.to(device=device) # create optimizer optimizer_adm = Adam(model_adam.parameters(), lr=lr) # create loss loss_adm = nn.CrossEntropyLoss() loss_adm = loss_adm.to(device=device) models.append([model_name_adam, model_adam, optimizer_adm, loss_adm, True]) # create model and move it to device model_name_sgd = f'LeNet_sgd_{lr_str}_bth_{batch_size}_m_{momentum_str}' model_sgd = LeNet() model_sgd = model_sgd.to(device=device) # create optimizer