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))