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("模型保存成功")
