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
