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')
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)) pred = logits.argmax(dim=1) total_correct += torch.eq(label.to(device), pred).float().sum() total_num += img.size(0) acc = total_correct / total_num write.add_scalar( tag="eval_acc", global_step=epoch, scalar_value=acc ) if MULTI_GPU:
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)
inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() #将梯度归零 outputs = net(inputs) #将数据传入网络进行前向运算 loss = criterion(outputs, labels) #得到损失函数 loss.backward() #反向传播 optimizer.step() #通过梯度做一步参数更新 # print(loss) sum_loss += loss.item() if i % 100 == 99: print('[%d,%d] loss:%.03f' % (epoch + 1, i + 1, sum_loss / 100)) sum_loss = 0.0 #验证测试集 net.eval() #将模型变换为测试模式 correct = 0 total = 0 for data_test in test_loader: images, labels = data_test images, labels = images.cuda(), labels.cuda() output_test = net(images) # print("output_test:",output_test.shape) _, predicted = torch.max(output_test, 1) #此处的predicted获取的是最大值的下标 # print("predicted:",predicted.shape) total += labels.size(0) correct += (predicted == labels).sum() print("correct1: ", correct) print("Test acc: {0}".format(correct.item() / len(test_dataset))) #.cpu().numpy()
def main(): device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') data_transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) # load image img_path = 'a.jpg' assert os.path.exists(img_path), "file: '{}' does not exit.".format( img_path) img = Image.open(img_path) plt.imshow(img) # [N, C, H, W] img = data_transform(img) # expand batch dimension img = torch.unsqueeze(img, dim=0) print(img.shape) # read class_indict json_path = 'class_indices.json' assert os.path.exists(json_path), "file: '{}' does not exist.".format( json_path) json_file = open(json_path, 'r') class_indict = json.load(json_file) # print(class_indict) # create model model = LeNet(num_classes=5).to(device) # load model weights model_weight_path = 'weights/lenet.pth' model.load_state_dict(torch.load(model_weight_path, map_location=device)) model.eval() print('=================================') dummy_input = torch.randn(1, 3, 224, 224).to(device) torch.onnx.export(model, dummy_input, 'lenet.onnx', dynamic_axes={ 'image': { 0: 'B' }, 'outputs': { 0: 'B' } }, input_names=['image'], output_names=['outputs'], opset_version=12) print('=================================') print('---------------------------------') traced_script_module = torch.jit.trace(model, dummy_input) traced_script_module.save("lnet.pt") print('---------------------------------') with torch.no_grad(): # predict class import time t1 = time.time() model(img.to(device)).cpu() t2 = time.time() print('torch 推理花费{}ms'.format(1000 * (t2 - t1))) output = torch.squeeze(model(img.to(device))).cpu() predict = torch.softmax(output, dim=0) predict_cla = torch.argmax(predict).numpy() print_res = "class: {} prob: {:.3}".format(class_indict[str(predict_cla)], predict[predict_cla].numpy()) plt.title(print_res) print(print_res) plt.show()
dirs = os.listdir("./gcommands/train/") dirs = sorted(dirs) parser = argparse.ArgumentParser( description='ConvNets for Speech Commands Recognition') parser.add_argument('--wav_path', default='gcommands/recordings/one/3.wav', help='path to the audio file') args = parser.parse_args() path = args.wav_path warnings.filterwarnings("ignore") model = LeNet() model.load_state_dict(torch.load("checkpoint/ckpt.t7")) model.eval() wav = spect_loader(path, window_size=.02, window_stride=.01, normalize=True, max_len=101, window='hamming') #print(wav.shape) with torch.no_grad(): label = model.forward(wav.view(1, 1, 161, 101)) print(dirs[np.argmax(np.ravel(label.numpy()))])
from model import LeNet # ... 此处略去定义测试数据载入器的代码,具体参考代码4.3 # save_info = { # 保存的信息 # "iter_num": iter_num, # 迭代步数 # "optimizer": optimizer.state_dict(), # 优化器的状态字典 # "model": model.state_dict(), # 模型的状态字典 # } model_path = "./model.pth" # 假设模型保存在model.pth文件中 save_info = torch.load(model_path) # 载入模型 model = LeNet() # 定义LeNet模型 criterion = nn.CrossEntropyLoss() # 定义损失函数 model.load_state_dict(save_info["model"]) # 载入模型参数 model.eval() # 切换模型到测试状态 test_loss = 0 correct = 0 total = 0 with torch.no_grad(): # 关闭计算图 for batch_idx, (inputs, targets) in enumerate(data_test_loader): outputs = model(inputs) loss = criterion(outputs, targets) test_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().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("模型保存成功")