def eval(args):
device = torch.device(f"cuda:{args.device_id}")
model = AlexNet(n_cls = 100)
model.to(device)
model.load_state_dict(torch.load(args.pretrained_path))
model.eval()
test_loader = getLoaders(split="eval", batch_size = args.batch_size, num_workers=args.num_workers )
pred_arr = []
label_arr = []
with torch.no_grad():
for idx, (img, label) in tqdm(enumerate(test_loader),total= len(test_loader)):
img = img.to(device)
pred = model.pred(img)
# mean of softmax prob from 10 different aug
pred = pred.view(-1, 10, 100)
pred = pred.mean(dim = 1)
pred_arr.append(pred.detach().cpu().numpy())
label_arr.append(label.detach().numpy())
pred_np = np.concatenate(pred_arr)
label_np = np.concatenate(label_arr)
top_1 = utils.top_k_acc(k = 1, pred = pred_np, label= label_np)
top_5 = utils.top_k_acc(k = 5, pred = pred_np, label= label_np)
confusion = utils.confusion_matrix(100, pred_np, label_np)
torch.save({
"top_1": top_1,
"top_5": top_5,
"confusion": confusion,
}, "result.pth")
print(f"top_1: {top_1*100:.2f}, top_5: {top_5*100:.2f}")
def test(imageFolder): #测试部分
is_paramatter = False #置False为导入整个模型，置True为导入参数文件
if (is_paramatter):
net = AlexNet()
model = torch.load('./model_parameter.pth',
map_location=torch.device(device)) #模型参数文件
net.load_state_dict(model)
else:
net = torch.load('./model.pkl', map_location=torch.device(device))
net = net.to(device)
torch.set_grad_enabled(False)
torch.no_grad()
net.eval()
data_num = MyDataSet(imageFolder).__len__()
for i in range(data_num):
img, ori, name = MyDataSet(imageFolder, data_transform).__getitem__(i)
out = net(img.to(device, torch.float))
predict = out.argmax(dim=1) #预测的label
probability = out[:, predict] #该label的概率
s = 'Predict result: This is a '
if predict == 0:
s += 'CAT'
else:
s += 'DOG'
s += ' with the probability of '
s += str(round(float(probability), 4))
plt.title(s)
plt.imshow(ori)
plt.savefig("./result/" + name.replace('.jpg', '') + ".png",
dpi=300) #将结果保存在result文件夹内
plt.show() #显示图片
print(name + ' Success!')
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
data_transform = transforms.Compose( # 首先对图片预处理： resize+toTensor+normalize
[
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# load image
img_path = ".\\pytorch_classification\\Test2_alexnet.\\dandelion.jpg" # 载入图片
assert os.path.exists(img_path), "file: '{}' dose not exist.".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) # ^ .unsqueeze 扩充一个维度（batch维度）
# ^ .squeeze() 对数据的维度进行压缩，去掉维数为1的的维度
# read class_indict
json_path = './class_indices.json' # 读取json文件，即索引对应的类别名称
assert os.path.exists(json_path), "file: '{}' dose not exist.".format(
json_path)
json_file = open(json_path, "r")
class_indict = json.load(json_file)
# create model
model = AlexNet(num_classes=5).to(device) # 初始化网络并放入设备中
# load model weights
weights_path = "./AlexNet.pth"
assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(
weights_path)
model.load_state_dict(torch.load(weights_path)) # 载入权重
model.eval() # 进入测试模式（包含dropout操作）
with torch.no_grad(): # with torch.no_grad() 禁止参数跟踪：验证中不计算损失梯度
# predict class
output = torch.squeeze(model(
img.to(device))).cpu() # torch.squeeze压缩了维数为1的的维度（batch维度）
predict = torch.softmax(output, dim=0) # 通过softmax变成概率分布
predict_cla = torch.argmax(predict).numpy() # 获得概率最大的那个索引值，并将其转化为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()
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
data_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# load image
img_path = "../tulip.jpg"
assert os.path.exists(img_path), "file: '{}' dose not exist.".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)
# read class_indict
json_path = './class_indices.json'
assert os.path.exists(json_path), "file: '{}' dose not exist.".format(
json_path)
json_file = open(json_path, "r")
class_indict = json.load(json_file)
# create model
model = AlexNet(num_classes=5).to(device)
# load model weights
weights_path = "./AlexNet.pth"
assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(
weights_path)
model.load_state_dict(torch.load(weights_path))
model.eval()
with torch.no_grad():
# predict class
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)
for i in range(len(predict)):
print("class: {:10} prob: {:.3}".format(class_indict[str(i)],
predict[i].numpy()))
plt.show()
def main(args=None):
logging.basicConfig(format='%(levelname)s:%(message)s',
level=logging.DEBUG)
logging.info('Arquitetura AlexNet')
parser = argparse.ArgumentParser()
parser.add_argument('--num_classes',
help='Num. de classes.',
type=int,
default=1000)
parser.add_argument('--pretrained',
help='Serão utilizados pesos pré-treinados.',
type=bool,
default=True)
parser.add_argument('--model_url',
help='Caminho para os pesos.',
default="./pesos/alexnet-owt-4df8aa71.pth")
opt = parser.parse_args(args)
# Dados
proc = Preprocessador()
imagem_url = "./imagens/raposa.jpg"
imagem = Image.open(imagem_url)
imagem = proc.executa(imagem)
#https://jhui.github.io/2018/02/09/PyTorch-Basic-operations/
imagem = imagem.unsqueeze(0)
# Instancia do modelo
model = AlexNet(opt.num_classes)
model.eval()
# Caso deseje utilizar os pesos pré-treinados
if opt.pretrained:
checkpoint = torch.load(opt.model_url)
model.load_state_dict(checkpoint)
# Utiliza a GPU se existir no computador
if torch.cuda.is_available():
model.to('cuda')
with torch.no_grad():
saida = model(imagem)
# Obtem o indice melhor ranqueado
index = np.argmax(saida[0]).item()
acuracia = torch.max(saida).item()
print(getLabel(index), acuracia)
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
data_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# /home/xulei/数据集大本营/5_flower_data
img_path = "/home/xulei/数据集大本营/5_flower_data/predict/rose01.jpeg"
assert os.path.exists(img_path), "file: '{}' dose not exist.".format(
img_path)
img = Image.open(img_path)
plt.imshow(img)
img = data_transform(img)
img = torch.unsqueeze(img, dim=0)
json_path = './class_idices.json'
assert os.path.exists(json_path), "file '{}' dose not exist.".format(
json_path)
json_file = open(json_path, 'r')
class_indict = json.load(json_file)
model = AlexNet(num_classes=5).to(device)
# load model weights
weights_path = "./AlexNet.pth"
assert os.path.exists(weights_path), "file '{}' dose not exists.".format(
weights_path)
model.load_state_dict(torch.load(weights_path))
model.eval()
with torch.no_grad():
output = torch.squeeze(model(img.to(device))).cpu()
predict = torch.softmax(output, dim=0)
predict_cla = torch.argmax(predict).numpy()
print_res = "class: {} prob: {:.3f}".format(class_indict[str(predict_cla)],
predict[predict_cla].numpy())
plt.title(print_res)
print(print_res)
plt.show()
def loadModel(self):
"""载入指定的模型"""
default_dir = os.getcwd()
modelPath = askopenfilename(
title='选择一个模型文件',
initialdir=(os.path.expanduser(default_dir)),
filetypes=[('pth文件', '*.pth'), ('All Files', '*')])
if modelPath == "":
return
try:
self.label_info.config(text="载入模型中……")
model = AlexNet(num_classes=5)
model.load_state_dict(torch.load(modelPath))
model.eval()
self.model = model
except Exception as e:
self.label_info.config(text="模型载入出错")
finally:
self.button_loadImage.config(state=tk.NORMAL)
self.label_info.config(text="请打开一张图片")
def get_prediction(image_bytes):
# 异常处理：防止传入非图片的东西
try:
weights_path = "./Alexnet.pth"
class_json_path = "./class_indices.json"
assert os.path.exists(weights_path), "weights path does not exist..."
assert os.path.exists(class_json_path), "class json path does not exist..."
# select device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
# create model
model = AlexNet(num_classes=5)
# load model weights
model.load_state_dict(torch.load(weights_path, map_location=device))
model.to(device)
model.eval()
# load class info
json_file = open(class_json_path, 'rb')
class_indict = json.load(json_file)
tensor = transform_image(image_bytes=image_bytes)
outputs = torch.softmax(model.forward(tensor).squeeze(), dim=0)
# detach去除梯度信息
prediction = outputs.detach().cpu().numpy()
# < 左对齐
template = "class:{:<15} probability:{:.3f}"
index_pre = [(class_indict[str(index)], float(p)) for index, p in enumerate(prediction)]
# sort probability
index_pre.sort(key=lambda x: x[1], reverse=True)
text = [template.format(k, v) for k, v in index_pre]
return_info = {"result": text}
except Exception as e:
return_info = {"result": [str(e)]}
return return_info
def main():
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print("using {} device.".format(device))
tbwriter = SummaryWriter(log_dir="./logs")
data_transform = {
"train":
transforms.Compose([
transforms.RandomResizedCrop(360),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]),
"val":
transforms.Compose([
transforms.Resize(360, 360), # cannot 360, must (360,360)
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
}
data_root = os.path.abspath(os.path.join(os.getcwd(),
"./DATA")) # get data root path
image_path = os.path.join(data_root, "male") # 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)
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=2)
with open('class_indices.json', 'w') as json_file:
json_file.write(json_str)
batch_size = 8
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=8,
shuffle=True,
num_workers=nw)
print("using {} images for training, {} images fot validation.".format(
train_num, val_num))
if os.path.exists("./log360.pth"):
net = AlexNet()
#net.load_state_dict(torch.load("./log360.pth", map_location='cuda:2'))
net = torch.load("./log360.pth", 'cpu')
print("continue training")
else:
net = AlexNet(num_classes=3, init_weights=True)
net.to(device)
print("start training anew")
loss_function = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.0001)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.98)
epochs = 2000
save_path = './AlexNet.pth'
best_acc = 0.0
train_steps = len(train_loader)
#json_path = './class_indices.json'
#json_file = open(json_path, "r")
#class_indict = json.load(json_file)
#model = AlexNet(num_classed=6).to(device)
trainLOSS = [] #save loss
testLOSS = [] #save loss
valACC = [] #save val acc
for epoch in range(epochs):
scheduler.step()
print('LR:{}'.format(scheduler.get_lr()[0]))
# 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()
outputs = net(images.to(device))
loss = loss_function(outputs, 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, colour='green')
for val_data in val_bar:
val_images, val_labels = val_data
outputs = net(val_images.to(device))
predict_y = torch.max(outputs, dim=1)[1]
acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
val_accurate = acc / val_num
tbwriter.add_scalar('train/loss', running_loss / train_steps, epoch)
tbwriter.add_scalar('val/acc', val_accurate, epoch)
trainLOSS.append(running_loss / train_steps)
valACC.append(val_accurate)
print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' %
(epoch + 1, running_loss / train_steps, val_accurate))
print(' ')
if val_accurate > best_acc:
best_acc = val_accurate
torch.save(net.state_dict(), save_path)
#predict
#weights_path="./AlexNet.pth"
#model.load_state_dict(torch.load(weights_path))
#model.eval()
#with torch.no_grad():
# putput = torch.squeeze(model(img.to(device))).cpu()
# predict = torch.softmax(output, dim=0)
# predict_cla = torch.argmax(predict.numpy)
npLOSS = np.array(trainLOSS)
npVALACC = np.array(valACC)
np.save('./save/loss_epoch_{}'.format(epoch), npLOSS)
np.save('./save/valacc_epoch_{}'.format(epoch), npVALACC)
print('Finished Training')
# print train process
rate = (step + 1) / len(train_loader)
# 进度条
a = "*" * int(rate * 50)
b = "." * int((1 - rate) * 50)
print("\r [{}{}]{:^3.0f}% train loss:{:.3f}".format(
a, b, int(rate * 100), loss),
end="")
print()
# 训练一个batch所需时间
print(time.perf_counter() - t1)
############ 全部训练数据的一次训练结束 #########
# validation
net.eval() # 使dropout失效
acc = 0.0
with torch.no_grad():
for val_data in val_loader:
val_inputs, val_labels = val_data
outputs = net(val_inputs.to(device))
predict_y = torch.max(outputs, dim=1)[1]
acc += (predict_y == val_labels.to(device)).sum().item()
acc = acc / val_num
# 保存准确率最高的训练对应的参数
if acc > best_acc:
best_acc = acc
torch.save(net.state_dict(), save_path)
print('[epoch:%d] train_loss: %.3f test_accuracy: %.3f' %
(epoch + 1, running_loss / batch_size, acc))
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 = AlexNet(num_classes=5).to(device)
# load model weights
model_weight_path = 'weights/alexnet.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,
'alexnet.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("alexnet.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()
def Test_phase(args, k):
model1 = AlexNet()
model1.cuda()
model2 = AlexNet()
model2.cuda()
model3 = AlexNet()
model3.cuda()
model4 = AlexNet()
model4.cuda()
state_dict = torch.load('checkpoints/alexnet_63.pth')
model1.load_state_dict(state_dict)
state_dict = torch.load('checkpoints/alexnet_6240.pth')
model2.load_state_dict(state_dict)
state_dict = torch.load('checkpoints/alexnet_6215.pth')
model3.load_state_dict(state_dict)
state_dict = torch.load('checkpoints/alexnet_6085.pth')
model4.load_state_dict(state_dict)
model1 = torch.nn.DataParallel(model1, device_ids=range(torch.cuda.device_count()))
model2 = torch.nn.DataParallel(model2, device_ids=range(torch.cuda.device_count()))
model3 = torch.nn.DataParallel(model3, device_ids=range(torch.cuda.device_count()))
model4 = torch.nn.DataParallel(model4, device_ids=range(torch.cuda.device_count()))
model1.eval()
model2.eval()
model3.eval()
model4.eval()
csv = csv_write(args)
dataset = Test_Dataset(args.dpath)
test_sampler = Test_Sampler(dataset._labels, n_way=args.nway, k_shot=args.kshot, query=args.query)
test_loader = DataLoader(dataset=dataset, batch_sampler=test_sampler, num_workers=8, pin_memory=True)
print('Test start!')
for i in range(TEST_SIZE):
for episode in test_loader:
data = episode.cuda()
data_shot, data_query = data[:k], data[k:]
""" TEST Method """
""" Predict the query images belong to which classes
At the training phase, you measured logits.
The logits can be distance or similarity between query images and 5 images of each classes.
From logits, you can pick a one class that have most low distance or high similarity.
ex) # when logits is distance
pred = torch.argmin(logits, dim=1)
# when logits is prob
pred = torch.argmax(logits, dim=1)
pred is torch.tensor with size [20] and the each component value is zero to four
"""
model1.eval()
features_shot = model1(data_shot)
n_sample = int(args.query/args.nway)
features_shot_mean = torch.zeros(args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j*args.kshot
end = (j+1)*args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model1(data_query)
logits1 = square_euclidean_metric(features_query, features_shot_mean)
model2.eval()
features_shot = model2(data_shot)
n_sample = int(args.query/args.nway)
features_shot_mean = torch.zeros(args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j*args.kshot
end = (j+1)*args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model2(data_query)
logits2 = square_euclidean_metric(features_query, features_shot_mean)
model3.eval()
features_shot = model3(data_shot)
n_sample = int(args.query/args.nway)
features_shot_mean = torch.zeros(args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j*args.kshot
end = (j+1)*args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model3(data_query)
logits3 = square_euclidean_metric(features_query, features_shot_mean)
model4.eval()
features_shot = model4(data_shot)
n_sample = int(args.query/args.nway)
features_shot_mean = torch.zeros(args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j*args.kshot
end = (j+1)*args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model4(data_query)
logits4 = square_euclidean_metric(features_query, features_shot_mean)
logits = (logits1 + logits2 + logits3 + logits4)/4
lsoft = F.log_softmax(-logits, dim=1).view(args.kshot, n_sample, -1)
pred = torch.argmin(logits,dim=1)
# save your prediction as StudentID_Name.csv file
csv.add(pred)
csv.close()
print('Test finished, check the csv file!')
exit()
def train(args):
device = torch.device(f"cuda:{args.device_id}")
model = AlexNet(n_cls=100, useLRN=args.useLRN, useDropOut=args.useDropOut)
# model = AlexNet(num_classes= 100)
criterion = nn.CrossEntropyLoss()
model.to(device)
optimizer = Adam(model.parameters(), lr=args.lr)
train_loader, valid_loader = getLoaders(split="train",
batch_size=args.batch_size,
num_workers=args.num_workers,
aug=args.useAug)
train_loss_arr = []
valid_loss_arr = []
valid_acc_arr = []
valid_top5_arr = []
n_iter = 0
best_loss = float('inf')
best_top1_acc = 0
best_top5_acc = 0
for ep in range(args.epoch):
model.train()
for _, (img, label) in tqdm(enumerate(train_loader),
total=len(train_loader)):
img, label = img.to(device), label.to(device)
optimizer.zero_grad()
pred = model(img)
loss = criterion(pred, label)
# loss = model.criterion(pred, label)
loss.backward()
optimizer.step()
train_loss_arr.append(loss.item())
n_iter += 1
model.eval()
ep_valid_loss_arr = []
ep_acc_arr = []
ep_top5_arr = []
with torch.no_grad():
for _, (img, label) in tqdm(enumerate(valid_loader),
total=len(valid_loader)):
img, label = img.to(device), label.to(device)
pred = model(img)
loss = criterion(pred, label)
# loss = model.criterion(pred, label)
acc = utils.top_k_acc(k=1,
pred=pred.detach().cpu().numpy(),
label=label.detach().cpu().numpy())
acc5 = utils.top_k_acc(k=5,
pred=pred.detach().cpu().numpy(),
label=label.detach().cpu().numpy())
ep_acc_arr.append(acc)
ep_top5_arr.append(acc5)
ep_valid_loss_arr.append(loss.item())
valid_loss = np.mean(ep_valid_loss_arr)
valid_acc = np.mean(ep_acc_arr)
valid_top5 = np.mean(ep_top5_arr)
train_loss = np.mean(train_loss_arr[-len(train_loader):])
valid_loss_arr.append(valid_loss)
if valid_loss < best_loss:
best_loss = valid_loss
best_top1_acc = valid_acc
best_top5_acc = valid_top5
model.cpu()
torch.save(model.state_dict(), "best_model.pth")
model.to(device)
if (ep + 1) % 10 == 0:
model.cpu()
torch.save(
{
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"train_loss": train_loss_arr,
"valid_loss": valid_loss_arr,
"valid_acc": valid_acc_arr,
"valid_top5": valid_top5_arr,
"best_loss": best_loss,
"ep": ep,
"n_iter": n_iter,
}, "model_checkpoint.pth")
model.to(device)
print(
f"[{ep}, {n_iter}] train: {train_loss:.4f}, valid: {valid_loss:.4f}, acc: {valid_acc:.4f}, top5: {valid_top5:.4f}"
)
with open("exp_result.txt", "a+") as f:
f.write(
f"{args}, loss: {best_loss:.4f}, top1: {best_top1_acc*100:.1f}, top5: {best_top5_acc*100:.1f}\n"
)
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("using {} device.".format(device))
batch_size = 16
epochs = 20
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 = AlexNet(num_classes=5)
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/alexnet.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')
# print statistics
running_loss += loss.item()
# print train process
rate = (step + 1) / len(train_loader)
a = "*" * int(rate * 50)
b = "." * int((1 - rate) * 50)
print("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(
int(rate * 100), a, b, loss),
end="")
print()
print(time.perf_counter() - t1)
# validate
net.eval() #测试过程中不需要dropout，使用所有的神经元
acc = 0.0 # accumulate accurate number / epoch
with torch.no_grad():
for val_data in validate_loader:
val_images, val_labels = val_data
outputs = net(val_images.to(device))
predict_y = torch.max(outputs, dim=1)[1]
acc += (predict_y == val_labels.to(device)).sum().item()
val_accurate = acc / val_num
if val_accurate > best_acc:
best_acc = val_accurate
torch.save(net.state_dict(), save_path)
print('[epoch %d] train_loss: %.3f test_accuracy: %.3f' %
(epoch + 1, running_loss / step, val_accurate))
print('Finished Training')
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
data_transform = transforms.Compose([
transforms.Resize((360, 360)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# load image
#img_path = "./input/test_OUT.png"
#assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
#bnyImage = Image.open(img_path)
#bnyImage = 255*np.array(bnyImage).astype('uint8')
#img = cv2.cvtColor(np.array(bnyImage), cv2.COLOR_GRAY2BGR)
#img = Image.fromarray(img)
# load image
img_path = "./input/test_OUT.png"
assert os.path.exists(img_path), "file: '{}' dose not exist.".format(
img_path)
bnyImage = Image.open(img_path)
img = cv2.cvtColor(np.array(bnyImage), cv2.COLOR_GRAY2BGR)
# one channel
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, img_bin = cv2.threshold(img_gray, 100, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(img_bin, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
# find the left point
a1 = contours[0]
a2 = contours[1]
left1 = tuple(a1[:, 0][a1[:, :, 0].argmin()])
left2 = tuple(a2[:, 0][a2[:, :, 0].argmin()])
if left1 < left2:
leftMin = left1[0] - 25
else:
leftMin = left2[0] - 25
if leftMin > 240:
leftMin = 240
img = img[0:360, leftMin:leftMin + 360]
#print(img.shape)
img = 255 * np.array(img).astype('uint8')
img = Image.fromarray(img)
plt.imshow(img)
# [N, C, H, W]
img = data_transform(img)
# expand batch dimension
img = torch.unsqueeze(img, dim=0)
# read class_indict
json_path = './classification/male_class.json'
assert os.path.exists(json_path), "file: '{}' dose not exist.".format(
json_path)
json_file = open(json_path, "r")
class_indict = json.load(json_file)
# create model
model = AlexNet(num_classes=3).to(device)
# load model weights
weights_path = "./models/maleAlexNet_2000.pth"
assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(
weights_path)
model.load_state_dict(torch.load(weights_path))
model.eval()
with torch.no_grad():
# predict class
output = torch.squeeze(model(img.to(device))).cpu()
predict = torch.softmax(output, dim=0)
predict_cla = torch.argmax(predict).numpy()
class_indict[0] = 'mid-age'
class_indict[1] = 'old-age'
class_indict[2] = 'young'
if class_indict[str(predict_cla)] == 'yM':
print_res = "class: {}".format('young', predict[predict_cla].numpy())
elif class_indict[str(predict_cla)] == 'oM':
print_res = "class: {}".format('old-age')
else:
print_res = "class: {}".format('mid-age')
#print_res = "class: {} prob: {:.3}".format(class_indict[str(predict_cla)],
# predict[predict_cla].numpy())
plt.title(print_res)
print(print_res)
plt.show()
def main():
# 设置运行设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("using {} device.".format(device))
# 数据处理
data_transform = {
"train":
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]),
"val":
transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
}
# 存放train与val的路径
image_path = '/home/xulei/数据集大本营/5_flower_data/flower_data' # flower data root 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)
# flower_list: {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
flower_list = train_dataset.class_to_idx
# cla_dict : {0: 'daisy', 1: 'dandelion', 2: 'roses', 3: 'sunflowers', 4: 'tulips'}
cla_dict = dict((val, key) for key, val in flower_list.items())
# write dict into json file
# 要输出json格式，需要对json数据进行编码，要用到函数：json.dumps
# indent=4, 的作用是让字典的内容逐行显示，每个key占一行
# json_str :
# '{
# "0": "daisy",
# "1": "dandelion",
# "2": "roses",
# "3": "sunflowers",
# "4": "tulips"
# }'
json_str = json.dumps(cla_dict, indent=4)
with open('class_idices.json', 'w') as json_file:
json_file.write(json_str)
batch_size = 128
nw = min(os.cpu_count(), batch_size if batch_size > 1 else 0,
8) # number of workers nw: 8 ?????
print("using {} dataloader workers every process".format(nw))
train_loader = datas.DataLoader(train_dataset,
batch_size,
shuffle=True,
num_workers=nw)
validate_dataset = datasets.ImageFolder(root=os.path.join(
image_path, "val"),
transform=data_transform["val"])
# val_num: 364
val_num = len(validate_dataset)
validate_loader = datas.DataLoader(validate_dataset,
batch_size,
shuffle=False,
num_workers=nw)
print("using {} images for trainning, {} images for validation.".format(
train_num, val_num))
net = AlexNet(num_classes=5).to(device)
loss_function = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.00004)
epoches = 20
save_path = './AlexNet.pth'
best_acc = 0.0
# train_steps : 26 len(train_loader)= training_images_num/batch_size
train_steps = len(train_loader)
for epoch in range(epoches):
net.train()
running_loss = 0.0
train_bar = tqdm(train_loader) # 进度条
for step, data in enumerate(train_bar):
images, labels = data
optimizer.zero_grad()
outputs = net(images.to(device))
loss = loss_function(outputs, labels.to(device))
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(
epoch + 1, epoches, loss)
# validata
net.eval()
acc = 0.0 # accumulate accurate number / epoch
with torch.no_grad():
val_bar = tqdm(validate_loader) # , colour='green'
for val_data in val_bar:
val_images, val_labels = val_data
outputs = net(val_images.to(device))
predict_y = torch.max(outputs, dim=1)[1]
acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
val_accurate = acc / val_num
print('\n[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("Finshed Training")
torch.save(state, checkpoint_path)
# testing
print("Starting testing...")
dataloader_test = DataLoader(
datasets.CIFAR10(root='./data', train=False, transform=transforms.Compose([
transforms.ToTensor(),
normalize,
])),
batch_size=BATCH_SIZE, shuffle=False,
num_workers=4, pin_memory=True)
print("Testing dataloader created")
alexnet.eval()
accuracy = 0.0
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
for imgs, classes in dataloader_test:
imgs, classes = imgs.to(device), classes.to(device)
# calculate the loss
output = alexnet(imgs)
with torch.no_grad():
_, preds = torch.max(output, 1)
accuracy = accuracy + torch.sum(preds == classes.squeeze(1))
def train(args):
# the number of N way, K shot images
k = args.nway * args.kshot
""" TODO 1.a """
" Make your own model for Few-shot Classification in 'model.py' file."
# model setting
model = AlexNet()
model.cuda()
""" TODO 1.a END """
# pretrained model load
if args.restore_ckpt is not None:
state_dict = torch.load(args.restore_ckpt)
model.load_state_dict(state_dict)
model = torch.nn.DataParallel(model,
device_ids=range(torch.cuda.device_count()))
if args.test_mode == 1:
Test_phase(model, args, k)
else:
# Train data loading
dataset = Dataset(args.dpath, state='train')
train_sampler = Train_Sampler(dataset._labels,
n_way=args.nway,
k_shot=args.kshot,
query=args.query)
data_loader = DataLoader(dataset=dataset,
batch_sampler=train_sampler,
num_workers=8,
pin_memory=True)
# Validation data loading
val_dataset = Dataset(args.dpath, state='val')
val_sampler = Sampler(val_dataset._labels,
n_way=args.nway,
k_shot=args.kshot,
query=args.query)
val_data_loader = DataLoader(dataset=val_dataset,
batch_sampler=val_sampler,
num_workers=8,
pin_memory=True)
""" TODO 1.b (optional) """
" Set an optimizer or scheduler for Few-shot classification (optional) "
# Default optimizer setting
#optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)
optimizer = torch.optim.SGD(model.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=5e-4)
""" TODO 1.b (optional) END """
tl = Averager() # save average loss
ta = Averager() # save average accuracy
# training start
print('train start')
train_correct = 0
train_total = 0
train_loss = 0
test_correct = 0
test_total = 0
test_loss = 0
model.train()
for i in range(args.se + 1, TOTAL):
for episode in data_loader:
optimizer.zero_grad()
data, label = [_ for _ in episode] # load an episode
# split an episode images and labels into shots and query set
# note! data_shot shape is ( nway * kshot, 3, h, w ) not ( kshot * nway, 3, h, w )
# Take care when reshape the data shot
data_shot, data_query = data[:k], data[k:]
label_shot, label_query = label[:k], label[k:]
label_shot = sorted(list(set(label_shot.tolist())))
# convert labels into 0-4 values
label_query = label_query.tolist()
labels = []
for j in range(len(label_query)):
label = label_shot.index(label_query[j])
labels.append(label)
labels = torch.tensor(labels).cuda()
""" TODO 2 ( Same as above TODO 2 ) """
""" Train the model
Input:
data_shot : torch.tensor, shot images, [args.nway * args.kshot, 3, h, w]
be careful when using torch.reshape or .view functions
data_query : torch.tensor, query images, [args.query, 3, h, w]
labels : torch.tensor, labels of query images, [args.query]
output:
loss : torch scalar tensor which used for updating your model
logits : A value to measure accuracy and loss
"""
features_shot = model(data_shot.cuda())
n_sample = int(args.query / args.nway)
features_shot_mean = torch.zeros(args.nway,
features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j * args.kshot
end = (j + 1) * args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model(data_query.cuda())
logits = square_euclidean_metric(features_query,
features_shot_mean)
labels_expanded = labels.view(args.query, 1, 1)
labels_expanded = labels_expanded.expand(args.query, args.nway, 1)
lsoft = F.log_softmax(-logits, dim=1).view(args.kshot, n_sample,
-1)
labels_expanded = labels_expanded.view(lsoft.size())
loss = -lsoft.gather(2, labels_expanded).squeeze().view(-1).mean()
_, pred = lsoft.max(2)
""" TODO 2 END """
acc = count_acc(logits, labels)
tl.add(loss.item())
ta.add(acc)
loss.backward()
optimizer.step()
proto = None
logits = None
loss = None
if (i + 1) % PRINT_FREQ == 0:
print('train {}, loss={:.4f} acc={:.4f}'.format(
i + 1, tl.item(), ta.item()))
# initialize loss and accuracy mean
tl = None
ta = None
tl = Averager()
ta = Averager()
# validation start
if (i + 1) % VAL_FREQ == 0:
print('validation start')
model.eval()
with torch.no_grad():
vl = Averager() # save average loss
va = Averager() # save average accuracy
for j in range(VAL_TOTAL):
for episode in val_data_loader:
data, label = [_.cuda() for _ in episode]
data_shot, data_query = data[:k], data[
k:] # load an episode
label_shot, label_query = label[:k], label[k:]
label_shot = sorted(list(set(label_shot.tolist())))
label_query = label_query.tolist()
labels = []
for j in range(len(label_query)):
label = label_shot.index(label_query[j])
labels.append(label)
labels = torch.tensor(labels).cuda()
""" TODO 2 ( Same as above TODO 2 ) """
""" Train the model
Input:
data_shot : torch.tensor, shot images, [args.nway * args.kshot, 3, h, w]
be careful when using torch.reshape or .view functions
data_query : torch.tensor, query images, [args.query, 3, h, w]
labels : torch.tensor, labels of query images, [args.query]
output:
loss : torch scalar tensor which used for updating your model
logits : A value to measure accuracy and loss
"""
optimizer.zero_grad()
data, label = [_.cuda()
for _ in episode] # load an episode
# split an episode images and labels into shots and query set
# note! data_shot shape is ( nway * kshot, 3, h, w ) not ( kshot * nway, 3, h, w )
# Take care when reshape the data shot
data_shot, data_query = data[:k], data[k:]
label_shot, label_query = label[:k], label[k:]
label_shot = sorted(list(set(label_shot.tolist())))
# convert labels into 0-4 values
label_query = label_query.tolist()
labels = []
for j in range(len(label_query)):
label = label_shot.index(label_query[j])
labels.append(label)
labels = torch.tensor(labels).cuda()
""" TODO 2 ( Same as above TODO 2 ) """
""" Make a loss function and train your own model
Input:
data_shot : torch.tensor, shot images, [args.nway * args.kshot, 3, h, w]
be careful when using torch.reshape or .view functions
(25, 3, 400, 400)
data_query : torch.tensor, query images, [args.query, 3, h, w]
(20, 3, 400, 400)
labels : torch.tensor, labels of query images, [args.query]
(20)
output:
loss : torch scalar tensor which used for updating your model
logits : A value to measure accuracy and loss
"""
features_shot = model(data_shot.cuda())
n_sample = int(args.query / args.nway)
features_shot_mean = torch.zeros(
args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j * args.kshot
end = (j + 1) * args.kshot
features_shot_mean[j] = features_shot[
start:end].mean(dim=0)
features_query = model(data_query.cuda())
logits = square_euclidean_metric(
features_query, features_shot_mean)
labels_expanded = labels.view(args.query, 1, 1)
labels_expanded = labels_expanded.expand(
args.query, args.nway, 1)
lsoft = F.log_softmax(-logits, dim=1).view(
args.kshot, n_sample, -1)
labels_expanded = labels_expanded.view(lsoft.size())
loss = -lsoft.gather(
2, labels_expanded).squeeze().view(-1).mean()
_, pred = lsoft.max(2)
""" TODO 2 END """
acc = count_acc(logits, labels)
vl.add(loss.item())
va.add(acc)
proto = None
logits = None
loss = None
print('val accuracy mean : %.4f' % va.item())
print('val loss mean : %.4f' % vl.item())
# initialize loss and accuracy mean
vl = None
va = None
vl = Averager()
va = Averager()
if (i + 1) % SAVE_FREQ == 0:
PATH = 'checkpoints/%d_%s.pth' % (i + 1, args.name)
torch.save(model.module.state_dict(), PATH)
print('model saved, iteration : %d' % i)
class Solver(object):
def __init__(self, config):
self.model = None
self.lr = config.lr
self.epochs = config.epoch
self.train_batch_size = config.trainBatchSize
self.test_batch_size = config.testBatchSize
self.criterion = None
self.optimizer = None
self.scheduler = None
self.device = None
self.cuda = config.cuda
self.train_loader = None
self.test_loader = None
self.is_board = False
def load_data(self):
train_transform = transforms.Compose(
[transforms.RandomHorizontalFlip(),
transforms.ToTensor()])
test_transform = transforms.Compose([transforms.ToTensor()])
train_set = torchvision.datasets.CIFAR10(
root='/mnt/disk50/datasets/cifar',
train=True,
download=True,
transform=train_transform)
self.train_loader = torch.utils.data.DataLoader(
dataset=train_set, batch_size=self.train_batch_size, shuffle=True)
test_set = torchvision.datasets.CIFAR10(
root='/mnt/disk50/datasets/cifar',
train=False,
download=True,
transform=test_transform)
self.test_loader = torch.utils.data.DataLoader(
dataset=test_set, batch_size=self.test_batch_size, shuffle=False)
def load_model_from_pth(self, model_path):
"""Load the pre-trained model weight
:param model_path:
:return:
"""
checkpoint = torch.load(model_path,
map_location=self.device_name)['model']
# TODO:这里需要具体了解原因在哪里?
checkpoint_parameter_name = list(checkpoint.keys())[0]
model_parameter_name = next(self.model.named_parameters())[0]
is_checkpoint = checkpoint_parameter_name.startswith('module.')
is_model = model_parameter_name.startswith('module.')
if is_checkpoint and not is_model:
# 移除checkpoint模型里面参数
new_parameter_check = OrderedDict()
for key, value in checkpoint.items():
if key.startswith('module.'):
new_parameter_check[key[7:]] = value
self.model.load_state_dict(new_parameter_check)
elif not is_checkpoint and is_model:
# 添加module.参数
new_parameter_dict = OrderedDict()
for key, value in checkpoint.items():
if not key.startswith('module.'):
key = 'module.' + key
new_parameter_dict[key] = value
else:
self.model.load_state_dict(checkpoint)
return self.model
def load_model(self):
if self.cuda:
self.device = torch.device('cuda:0')
cudnn.benchmark = True
else:
self.device = torch.device('cpu')
# self.model = LeNet().to(self.device)
self.model = AlexNet().to(self.device)
self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr)
self.scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer,
milestones=[75, 150],
gamma=0.5)
self.criterion = nn.CrossEntropyLoss().to(self.device)
def train(self, writer=None):
print("train:")
self.model.train()
train_loss = 0
train_correct = 0
total = 0
for batch_num, (data, target) in enumerate(self.train_loader):
data, target = data.to(self.device), target.to(self.device)
self.optimizer.zero_grad()
output = self.model(data)
loss = self.criterion(output, target)
loss.backward()
self.optimizer.step()
train_loss += loss.item()
prediction = torch.max(
output,
1) # second param "1" represents the dimension to be reduced
total += target.size(0)
# train_correct incremented by one if predicted right
train_correct += np.sum(
prediction[1].cpu().numpy() == target.cpu().numpy())
progress_bar(
batch_num, len(self.train_loader),
'Loss: %.4f | Acc: %.3f%% (%d/%d)' %
(train_loss / (batch_num + 1), 100. * train_correct / total,
train_correct, total))
# if not writer:
# writer.add_scalar
return train_loss, train_correct / total
def test(self):
print("test:")
self.model.eval()
test_loss = 0
test_correct = 0
total = 0
start = time.time()
with torch.no_grad():
for batch_num, (data, target) in enumerate(self.test_loader):
data, target = data.to(self.device), target.to(self.device)
output = self.model(data)
loss = self.criterion(output, target)
test_loss += loss.item()
prediction = torch.max(output, 1)
total += target.size(0)
test_correct += np.sum(
prediction[1].cpu().numpy() == target.cpu().numpy())
progress_bar(
batch_num, len(self.test_loader),
'Loss: %.4f | Acc: %.3f%% (%d/%d)' %
(test_loss / (batch_num + 1), 100. * test_correct / total,
test_correct, total))
end = time.time()
time_used = end - start
return test_loss, test_correct / total, time_used
def save(self):
model_out_path = "./best_model_new.pkl"
torch.save(self.model.state_dict(), model_out_path)
print("Checkpoint saved to {}".format(model_out_path))
def run(self):
self.load_data()
self.load_model()
# for k, v in self.model.state_dict():
# print('layer{}'.k)
# print(v)
accuracy = 0
writer = SummaryWriter()
for epoch in range(1, self.epochs + 1):
self.scheduler.step(epoch)
print("\n===> epoch: %d/200" % epoch)
train_loss, train_acc = self.train()
test_loss, test_acc = self.test()
# writer.add_scalar('loss_group',{'train_loss':train_loss.numpy(),
# 'test_loss':test_loss.numpy()},epoch)
# writer.add_scalar('acc_group',{'train_acc':train_acc.numpy(),
# 'test_acc':test_acc.numpy()}, epoch)
if test_acc > accuracy:
accuracy = test_acc
self.save()
elif epoch == self.epochs:
print("===> BEST ACC. PERFORMANCE: %.3f%%" % (accuracy * 100))
self.save()
def val(args):
# the number of N way, K shot images
k = args.nway * args.kshot
""" TODO 1.a """
" Make your own model for Few-shot Classification in 'model.py' file."
""" TODO 1.a END """
model1 = AlexNet()
model1.cuda()
model2 = AlexNet()
model2.cuda()
model3 = AlexNet()
model3.cuda()
model4 = AlexNet()
model4.cuda()
state_dict = torch.load('checkpoints/alexnet_63.pth')
model1.load_state_dict(state_dict)
state_dict = torch.load('checkpoints/alexnet_6240.pth')
model2.load_state_dict(state_dict)
state_dict = torch.load('checkpoints/alexnet_6215.pth')
model3.load_state_dict(state_dict)
state_dict = torch.load('checkpoints/alexnet_6085.pth')
model4.load_state_dict(state_dict)
#state_dict = torch.load('')
#model.load_state_dict(state_dict)
#model1 = model.clone()
model1 = torch.nn.DataParallel(model1, device_ids=range(torch.cuda.device_count()))
model2 = torch.nn.DataParallel(model2, device_ids=range(torch.cuda.device_count()))
model3 = torch.nn.DataParallel(model3, device_ids=range(torch.cuda.device_count()))
model4 = torch.nn.DataParallel(model4, device_ids=range(torch.cuda.device_count()))
model1.eval()
model2.eval()
model3.eval()
model4.eval()
csv = csv_write(args)
# Validation data loading
val_dataset = Dataset(args.dpath, state='val')
val_sampler = Sampler(val_dataset._labels, n_way=args.nway, k_shot=args.kshot, query=args.query)
val_data_loader = DataLoader(dataset=val_dataset, batch_sampler=val_sampler, num_workers=8, pin_memory=True)
""" TODO 1.b (optional) """
" Set an optimizer or scheduler for Few-shot classification (optional) "
# Default optimizer setting
#optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)
#optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=5e-4)
""" TODO 1.b (optional) END """
tl = Averager() # save average loss
ta = Averager() # save average accuracy
print('test start')
test_correct = 0
test_total = 0
test_loss = 0
# validation start
print('validation start')
model1.eval()
model2.eval()
model3.eval()
model4.eval()
with torch.no_grad():
vl = Averager() # save average loss
va = Averager() # save average accuracy
for j in range(VAL_TOTAL):
for episode in val_data_loader:
data, label = [_.cuda() for _ in episode]
data_shot, data_query = data[:k], data[k:] # load an episode
label_shot, label_query = label[:k], label[k:]
label_shot = sorted(list(set(label_shot.tolist())))
label_query = label_query.tolist()
labels = []
for j in range(len(label_query)):
label = label_shot.index(label_query[j])
labels.append(label)
labels = torch.tensor(labels).cuda()
""" TODO 2 ( Same as above TODO 2 ) """
""" Train the model
Input:
data_shot : torch.tensor, shot images, [args.nway * args.kshot, 3, h, w]
be careful when using torch.reshape or .view functions
data_query : torch.tensor, query images, [args.query, 3, h, w]
labels : torch.tensor, labels of query images, [args.query]
output:
loss : torch scalar tensor which used for updating your model
logits : A value to measure accuracy and loss
"""
data, label = [_.cuda() for _ in episode] # load an episode
# split an episode images and labels into shots and query set
# note! data_shot shape is ( nway * kshot, 3, h, w ) not ( kshot * nway, 3, h, w )
# Take care when reshape the data shot
data_shot, data_query = data[:k], data[k:]
#print('label : ',label)
label_shot, label_query = label[:k], label[k:]
label_shot = sorted(list(set(label_shot.tolist())))
# convert labels into 0-4 values
label_query = label_query.tolist()
labels = []
for j in range(len(label_query)):
label = label_shot.index(label_query[j])
labels.append(label)
labels = torch.tensor(labels).cuda()
""" TODO 2 ( Same as above TODO 2 ) """
""" Make a loss function and train your own model
Input:
data_shot : torch.tensor, shot images, [args.nway * args.kshot, 3, h, w]
be careful when using torch.reshape or .view functions
(25, 3, 400, 400)
data_query : torch.tensor, query images, [args.query, 3, h, w]
(20, 3, 400, 400)
labels : torch.tensor, labels of query images, [args.query]
(20)
output:
loss : torch scalar tensor which used for updating your model
logits : A value to measure accuracy and loss
"""
model1.eval()
features_shot = model1(data_shot)
n_sample = int(args.query/args.nway)
features_shot_mean = torch.zeros(args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j*args.kshot
end = (j+1)*args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model1(data_query)
logits1 = square_euclidean_metric(features_query, features_shot_mean)
model2.eval()
features_shot = model2(data_shot)
n_sample = int(args.query/args.nway)
features_shot_mean = torch.zeros(args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j*args.kshot
end = (j+1)*args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model2(data_query)
logits2 = square_euclidean_metric(features_query, features_shot_mean)
model3.eval()
features_shot = model3(data_shot)
n_sample = int(args.query/args.nway)
features_shot_mean = torch.zeros(args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j*args.kshot
end = (j+1)*args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model3(data_query)
logits3 = square_euclidean_metric(features_query, features_shot_mean)
model4.eval()
features_shot = model4(data_shot)
n_sample = int(args.query/args.nway)
features_shot_mean = torch.zeros(args.nway, features_shot.size(1)).cuda()
for j in range(int(args.nway)):
start = j*args.kshot
end = (j+1)*args.kshot
features_shot_mean[j] = features_shot[start:end].mean(dim=0)
features_query = model4(data_query)
logits4 = square_euclidean_metric(features_query, features_shot_mean)
logits = (logits1+logits2+logits3+logits4)/4
lsoft = F.log_softmax(-logits, dim=1).view(args.kshot, n_sample, -1)
pred = torch.argmin(logits,dim=1)
""" TODO 2 END """
acc = count_acc(logits, labels)
va.add(acc)
csv.add(pred)
proto = None; logits = None; loss = None
print('val accuracy mean : %.4f' % va.item())
print('val loss mean : %.4f' % vl.item())
# initialize loss and accuracy mean
vl = None
va = None
vl = Averager()
va = Averager()
csv.close()
print('Test finished, check the csv file!')
exit()
step = 0
for imgs, labels in dataloader:
imgs, labels = imgs.to(device), labels.to(device)
outputs = model(imgs)
loss = loss_fn(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if step % 10 == 0:
print("Epoch: {}, Step: {}, Loss: {}".format(epoch, step, loss.item()))
step+=1
# validate the model on test set at the end of each loop
model.eval()
# average and number of correct prediction
avg_loss, num_correct = 0.0, 0.0
dataloader = DataLoader(cifar_test, batch_size=batch_size, shuffle=False)
step=0
with torch.no_grad():
for imgs, labels in dataloader:
imgs, labels = imgs.to(device), labels.to(device)
outputs = model(imgs)
loss = loss_fn(outputs, labels)
avg_loss += loss.item()
pred = torch.argmax(outputs, dim=1)
num_correct+= (pred == labels).float().sum().item()
step+=1
optimizer = optim.SGD(params=net.parameters(), lr=1e-2, momentum=9e-1)
data_loader = DataLoader(dataset=ImageFolder("data/test",
transform=transforms.Compose([
transforms.Resize((256, 256)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])),
batch_size=50,
shuffle=True)
pkl = torch.load("net.pkl")
net = pkl.get("model")
epoch = pkl.get("epoch")
net.eval()
correct = 0
total = 0
for samples, targets in data_loader:
output = net(samples.cuda())
top = output.topk(1, 1, True, True).indices
for p,r in zip(top, targets.cuda()):
if p.eq(r):
correct += 1
total += 1
print(f"Acc: {correct / total}")
def main():
# viz = Visdom()
# viz.line([0.], [0.], win='train_loss', opts=dict(title='train loss'))
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("using {} device.".format(device))
data_transform = {
"train":
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
]),
"val":
transforms.Compose([
transforms.Resize((224, 224)), # cannot 224, must (224, 224)
transforms.ToTensor()
])
}
data_root = "/home/zhongsy/datasets/dataset/" # get data root path
train_dataset = datasets.ImageFolder(root=os.path.join(data_root, "train"),
transform=data_transform["train"])
# print(train_dataset.imgs)
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)
batch_size = 1
# number of workers
nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])
print('Using {} dataloader workers every process'.format(nw))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=32,
shuffle=True,
num_workers=nw)
validate_dataset = datasets.ImageFolder(root=os.path.join(
data_root, "val"),
transform=data_transform["val"])
val_num = len(validate_dataset)
validate_loader = torch.utils.data.DataLoader(validate_dataset,
batch_size=4,
shuffle=False,
num_workers=nw)
print("using {} images for training, {} images for validation.".format(
train_num, val_num))
# test_data_iter = iter(validate_loader)
# test_image, test_label = test_data_iter.next()
#
# def imshow(img):
# img = img / 2 + 0.5 # unnormalize
# npimg = img.numpy()
# plt.imshow(np.transpose(npimg, (1, 2, 0)))
# plt.show()
#
# print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4)))
# imshow(utils.make_grid(test_image))
net = AlexNet(num_classes=2, init_weights=True)
net.to(device)
loss_function = nn.CrossEntropyLoss()
# pata = list(net.parameters())
optimizer = optim.Adam(net.parameters(), lr=0.0001)
epochs = 30
save_path = './AlexNet.pt'
best_acc = 0.0
train_steps = len(train_loader)
global_step = 0
for epoch in range(epochs):
# train
epochloss = 100000
net.train()
running_loss = 0.0
train_bar = tqdm(train_loader)
for step, data in enumerate(train_bar):
images, labels = data
# print("label: ", labels, labels.dtype)
optimizer.zero_grad()
outputs = net(images.to(device))
# print("imges: ", images, images.dtype)
# outputs_ = outputs.squeeze()
# print("output__ : ", outputs_)
# outputs_ = outputs.to(torch.float)
loss = loss_function(outputs, labels.to(device))
# loss = loss.to(torch.float)
if epochloss > loss:
epochloss = loss
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(
epoch + 1, epochs, loss)
# viz.line([epochloss.cpu().detach().numpy()], [global_step],
# win='train_loss', update='append')
global_step += 1
print("[ start val ]")
# 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
val_labels.unsqueeze(1)
outputs = net(val_images.to(device))
predict_y = torch.max(outputs, dim=1)[1]
# print("prect ;", predict_y)
# outputs = outputs.squeeze()
# print("out_puts: ", outputs)
# a = torch.gt(outputs, 0.5)
# print("a ", a)
# for i, (data, label_) in enumerate(zip(outputs, val_labels)):
# if abs(data-label_) <= 0.5:
# acc += 1
# viz.images(val_images.view(-1, 3, 224, 224), win='x')
# viz.text(str(predict_y.detach().cpu().numpy()),
# win='pred', opts=dict(title='pred'))
acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
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, save_path)
print('Finished Training')
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") #指定设备
print("using {} device.".format(device))
data_transform = { #数据预处理
"train": transforms.Compose([transforms.RandomResizedCrop(224),# key 为trian 返回这些方法 随机裁剪 224*224
transforms.RandomHorizontalFlip(),#随机反转
transforms.ToTensor(),#转成
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),#标准化处理
"val": transforms.Compose([transforms.Resize((224, 224)), # cannot 224, must (224, 224)
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path
image_path = os.path.join(data_root, "data_set", "dog_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()) #遍历 key value 对调
# write dict into json file
json_str = json.dumps(cla_dict, indent=4)
with open('class_indices.json', 'w') as json_file:#生成json 便于打开
json_file.write(json_str)
batch_size = 32
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=4, shuffle=False,
num_workers=nw)
print("using {} images for training, {} images fot validation.".format(train_num,
val_num))
# test_data_iter = iter(validate_loader)
# test_image, test_label = test_data_iter.next()
#
# def imshow(img):
# img = img / 2 + 0.5 # unnormalize
# npimg = img.numpy()
# plt.imshow(np.transpose(npimg, (1, 2, 0)))
# plt.show()
#
# print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4)))
# imshow(utils.make_grid(test_image))
net = AlexNet(num_classes=5, init_weights=True) #类别5
net.to(device) #网络设备
loss_function = nn.CrossEntropyLoss() #损失函数
# pata = list(net.parameters())
optimizer = optim.Adam(net.parameters(), lr=0.0002) #adam优化器 对象是网络中可训练参数 学习率 自己调参
save_path = './AlexNet.pth' #保存模型路径
best_acc = 0.0
for epoch in range(10):#训练
# train
net.train() #管理神经元失活
running_loss = 0.0 #统计平均损失
t1 = time.perf_counter() #训练时间
for step, data in enumerate(train_loader, start=0): #遍历数据集
images, labels = data #分为图像 标签
optimizer.zero_grad() #清空梯度信息
outputs = net(images.to(device)) #正向传播 指定设备
loss = loss_function(outputs, labels.to(device)) #损失
loss.backward() #反向传播
optimizer.step() #更新结点参数
# print statistics
running_loss += loss.item() #损失累加
# print train process
rate = (step + 1) / len(train_loader) #打印训练进度
a = "*" * int(rate * 50)
b = "." * int((1 - rate) * 50)
print("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(int(rate * 100), a, b, loss), end="")
print()
print(time.perf_counter()-t1)
# validate
net.eval() #关闭失活
acc = 0.0 # accumulate accurate number / epoch
with torch.no_grad():
for val_data in validate_loader:
val_images, val_labels = val_data
outputs = net(val_images.to(device))
predict_y = torch.max(outputs, dim=1)[1] #最大就是类别
acc += (predict_y == val_labels.to(device)).sum().item() #预测与真实对比 累加
val_accurate = acc / val_num #准确率
if val_accurate > best_acc: #如果准确率大于历史最优
best_acc = val_accurate #更新
torch.save(net.state_dict(), save_path) #保存权重
print('[epoch %d] train_loss: %.3f test_accuracy: %.3f' % #打印信息
(epoch + 1, running_loss / step, val_accurate))
print('Finished Training')
a = "*" * int(rate * 50)
b = "." * int((1 - rate) * 50)
with open(os.path.join("train.log"), "a") as log:
log.write(
str("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(
int(rate * 100), a, b, loss)) + "\n")
print("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(
int(rate * 100), a, b, loss),
end="")
print()
with open(os.path.join("train.log"), "a") as log:
log.write(str('%f s' % (time.perf_counter() - time_start)) + "\n")
print('%f s' % (time.perf_counter() - time_start))
########################################### validate ###########################################
net.eval() # 验证过程中关闭 Dropout
acc = 0.0
with torch.no_grad():
for val_data in validate_loader:
val_images, val_labels = val_data
outputs = net(val_images.to(device))
predict_y = torch.max(outputs,
dim=1)[1] # 以output中值最大位置对应的索引（标签）作为预测输出
acc += (predict_y == val_labels.to(device)).sum().item()
val_accurate = acc / val_num
# 保存准确率最高的那次网络参数
if val_accurate > best_acc:
best_acc = val_accurate
torch.save(net.state_dict(), save_path)
with open(os.path.join("train.log"), "a") as log:
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# 载入图片
img = Image.open("./pgy.jpg")
plt.imshow(img)
img = data_transform(img) # [H, W, Channel] --> [Channel, H, W]
img = torch.unsqueeze(img, dim=0) # [Channel, H, W] --> [1, Channel, H, W]
# 读取分类标签文本
try:
json_file = open('./class_indices.json', 'r')
class_indict = json.load(json_file)
except Exception as e:
print(e)
exit(-1)
model = AlexNet(num_classes=5)
model_weight_path = "./AlexNet.pth"
model.load_state_dict(torch.load(model_weight_path))
model.eval() # 此模式dropout使模型中的操作失效
with torch.no_grad(): # 只预测是不需要反向传播的，也就不需要梯度数据，使用no_grad()不生成梯度数据可以节约内存
output = torch.squeeze(model(img)) # 去掉batch维度 （这里batch=1）
predict = torch.softmax(output, dim=0) # 变成概率分布
predict_cla = torch.argmax(predict).numpy() # 取最大值那个位置的索引
print(class_indict[str(predict_cla)], predict[predict_cla].item())
plt.show()
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
data_transform = {
"train":
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]),
"val":
transforms.Compose([
transforms.Resize((224, 224)), # cannot 224, must (224, 224)
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
}
data_root = os.path.abspath(os.path.join(os.getcwd(), "./"))
image_path = os.path.join(data_root, "flower_data")
train_dataset = datasets.ImageFolder(root=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)
batch_size = 8
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=0)
validate_dataset = datasets.ImageFolder(root=image_path + "/val",
transform=data_transform["val"])
val_num = len(validate_dataset)
validate_loader = torch.utils.data.DataLoader(validate_dataset,
batch_size=4,
shuffle=True,
num_workers=0)
# test_data_iter = iter(validate_loader)
# test_image, test_label = test_data_iter.next()
#
# def imshow(img):
# img = img / 2 + 0.5 # unnormalize
# npimg = img.numpy()
# plt.imshow(np.transpose(npimg, (1, 2, 0)))
# plt.show()
#
# print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4)))
# imshow(utils.make_grid(test_image))
net = AlexNet(num_class=5)
print(net)
net.to(device)
loss_function = nn.CrossEntropyLoss()
# pata = list(net.parameters())
optimizer = optim.Adam(net.parameters(), lr=0.0002)
save_path = './AlexNet.pth'
best_acc = 0.0
for epoch in range(10):
# train
net.train()
running_loss = 0.0
t1 = time.perf_counter()
for step, data in enumerate(train_loader, start=0):
images, labels = data
optimizer.zero_grad()
outputs = net(images.to(device))
loss = loss_function(outputs, labels.to(device))
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
# print train process
rate = (step + 1) / len(train_loader)
a = "*" * int(rate * 50)
b = "." * int((1 - rate) * 50)
print("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(
int(rate * 100), a, b, loss),
end="")
print()
print(time.perf_counter() - t1)
# validate
net.eval()
acc = 0.0 # accumulate accurate number / epoch
# 验证过程中不计算损失梯度
with torch.no_grad():
for val_data in validate_loader:
val_images, val_labels = val_data
outputs = net(val_images.to(device))
predict_y = torch.max(outputs, dim=1)[1]
acc += (predict_y == val_labels.to(device)).sum().item()
val_accurate = acc / val_num
if val_accurate > best_acc:
best_acc = val_accurate
torch.save(net.state_dict(), save_path)
print('[epoch %d] train_loss: %.3f test_accuracy: %.3f' %
(epoch + 1, running_loss / step, val_accurate))
print('Finished Training')
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("using {} device.".format(device))
data_transform = {
"train":
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]),
"val":
transforms.Compose([
transforms.Resize((224, 224)), # cannot 224, must (224, 224)
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
}
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)
batch_size = 32
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=4,
shuffle=False,
num_workers=nw)
print("using {} images for training, {} images for validation.".format(
train_num, val_num))
# test_data_iter = iter(validate_loader)
# test_image, test_label = test_data_iter.next()
#
# def imshow(img):
# img = img / 2 + 0.5 # unnormalize
# npimg = img.numpy()
# plt.imshow(np.transpose(npimg, (1, 2, 0)))
# plt.show()
#
# print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4)))
# imshow(utils.make_grid(test_image))
net = AlexNet(num_classes=5, init_weights=True)
net.to(device)
loss_function = nn.CrossEntropyLoss()
# pata = list(net.parameters())
optimizer = optim.Adam(net.parameters(), lr=0.0002)
epochs = 10
save_path = './AlexNet.pth'
best_acc = 0.0
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()
outputs = net(images.to(device))
loss = loss_function(outputs, 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))
predict_y = torch.max(outputs, dim=1)[1]
acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
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')
outputs = net(images.to(device)) # 将数据正向过一遍网络，得到一个输出
loss = loss_function(outputs, labels.to(device)) # 计算输出值和期望值的某种误差
loss.backward() # 计算 loss函数 对于各权重参数的偏导数，存入各参数的梯度属性
optimizer.step() # 梯度下降法更新各参数
running_loss += loss.item()
rate = (step + 1) / len(train_loader) # 本epoch的进度
a = "*" * int(rate * 50)
b = "." * int((1 - rate) * 50)
print("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(
int(rate * 100), a, b, loss),
end="")
print()
print(time.perf_counter() - t1) # 本epoch的所用时间
net.eval() # 验证模式开启
acc = 0.0
with torch.no_grad():
for data_test in validate_loader: # 对于验证集中的每一个batch
test_images, test_labels = data_test
outputs = net(test_images.to(device)) # 经过我们的网络获得输出
predict_y = torch.max(
outputs, dim=1)[1] # 对于本batch的每一张图片，取得网络输出的结果中最大值那个位置的索引
acc += (predict_y == test_labels.to(device)
).sum().item() # 将索引和labels比对，求本batch出有多少个预测正确的，将这个个数累加
accurate_test = acc / val_num # 算出当前epoch在验证集中的预测准确率
if accurate_test > best_acc: # 如果本batch的准确率比以前都高
best_acc = accurate_test
torch.save(net.state_dict(), save_path) # 就保存当前模型
print('[epoch %d] train_loss: %.3f test_accuracy: %.3f' %
(epoch + 1, running_loss / step, acc / val_num))
