• pytorch入门，deep-learning-for-image-processing-master的test3-vggnet

    首先是train部分

    1. import os
    2. import sys
    3. import json
    4.  
    5. import torch
    6. import torch.nn as nn
    7. from torchvision import transforms, datasets
    8. import torch.optim as optim
    9. from tqdm import tqdm
    10.  
    11. from model import vgg
    12.  
    13.  
    14. def main():
    15.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    16.     print("using {} device.".format(device))
    17.  
    18.     data_transform = {
    19.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    20.                                      transforms.RandomHorizontalFlip(),
    21.                                      transforms.ToTensor(),
    22.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    23.         "val": transforms.Compose([transforms.Resize((224, 224)),
    24.                                    transforms.ToTensor(),
    25.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    26.  
    27.     data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
    28.     image_path = os.path.join(data_root, "data_set", "flower_data")  # flower data set path
    29.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    30.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
    31.                                          transform=data_transform["train"])
    32.     train_num = len(train_dataset)
    33.  
    34.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    35.     flower_list = train_dataset.class_to_idx
    36.     cla_dict = dict((val, key) for key, val in flower_list.items())
    37.     # write dict into json file
    38.     json_str = json.dumps(cla_dict, indent=4)
    39.     with open('class_indices.json', 'w') as json_file:
    40.         json_file.write(json_str)
    41.  
    42.     batch_size = 32
    43.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    44.     print('Using {} dataloader workers every process'.format(nw))
    45.  
    46.     train_loader = torch.utils.data.DataLoader(train_dataset,
    47.                                                batch_size=batch_size, shuffle=True,
    48.                                                num_workers=nw)
    49.  
    50.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
    51.                                             transform=data_transform["val"])
    52.     val_num = len(validate_dataset)
    53.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
    54.                                                   batch_size=batch_size, shuffle=False,
    55.                                                   num_workers=nw)
    56.     print("using {} images for training, {} images for validation.".format(train_num,
    57.                                                                            val_num))
    58.  
    59.     # test_data_iter = iter(validate_loader)
    60.     # test_image, test_label = test_data_iter.next()
    61.  
    62.     model_name = "vgg16"
    63.     net = vgg(model_name=model_name, num_classes=5, init_weights=True)
    64.     net.to(device)
    65.     loss_function = nn.CrossEntropyLoss()
    66.     optimizer = optim.Adam(net.parameters(), lr=0.0001)
    67.  
    68.     epochs = 30
    69.     best_acc = 0.0
    70.     save_path = './{}Net.pth'.format(model_name)
    71.     train_steps = len(train_loader)
    72.     for epoch in range(epochs):
    73.         # train
    74.         net.train()
    75.         running_loss = 0.0
    76.         train_bar = tqdm(train_loader, file=sys.stdout)
    77.         for step, data in enumerate(train_bar):
    78.             images, labels = data
    79.             optimizer.zero_grad()
    80.             outputs = net(images.to(device))
    81.             loss = loss_function(outputs, labels.to(device))
    82.             loss.backward()
    83.             optimizer.step()
    84.  
    85.             # print statistics
    86.             running_loss += loss.item()
    87.  
    88.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
    89.                                                                      epochs,
    90.                                                                      loss)
    91.  
    92.         # validate
    93.         net.eval()
    94.         acc = 0.0  # accumulate accurate number / epoch
    95.         with torch.no_grad():
    96.             val_bar = tqdm(validate_loader, file=sys.stdout)
    97.             for val_data in val_bar:
    98.                 val_images, val_labels = val_data
    99.                 outputs = net(val_images.to(device))
    100.                 predict_y = torch.max(outputs, dim=1)[1]
    101.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
    102.  
    103.         val_accurate = acc / val_num
    104.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
    105.               (epoch + 1, running_loss / train_steps, val_accurate))
    106.  
    107.         if val_accurate > best_acc:
    108.             best_acc = val_accurate
    109.             torch.save(net.state_dict(), save_path)
    110.  
    111.     print('Finished Training')
    112.  
    113.  
    114. if __name__ == '__main__':
    115.     main()
    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),
            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,"data_set","flower_data")
    assert os.path.exists(image_path), "{} path is not exist. ".format(image_path)
    train_dataset=datasets.ImageFolder(root=os.path.join(image_path,"train"),
                                       transform=data_transform["train"])
    val_dataset=datasets.ImageFolder(root=os.path.join(image_path,"val"),
                                     transform=data_transform["val"])
    train_num=len(train_dataset)

    这里和之前一样，需要注意绝对路径，使用dataset.Imagefolder很方便

    flower_list=train_dataset.class_to_idx使用这个，很方便的给图片打数字标
    cla_dict=dict((val,key) for key,val in flower_list.items())打包成字典

    json_str=json.dumps(cla_dict,indent=4)
with open('class_indices.json','w') as json_file:
    json_file.write(json_str)
    写进json里面

    接下来是load

    model_name='vgg16'
net=vgg(model_name=model_name,num_classes=5,init_weights=True)
net.to(device)
loss_function=nn.CrossEntropyLoss()
optimizer=optim.Adam(net.parameters(),lr=0.00001)
epochs=30
best_acc=0.0
save_path='./{}Net.path'.format(model_name)
train_steps=len(train_loader)k

开始训练


    for epoch in range(epochs):
    net.train()
    running_loss=0.0
    train_bar=tqdm(train_loader,file=sys.stdout)
    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()
        running_loss+=loss.item()
        train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
                                                                 epochs,
                                                                 loss)
    然后做测试

    net.eval()
acc=0.0
with torch.no_grad():
    val_bar=tqdm(val_loader,file=sys.stdout)
    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=acc+torch.eq(predict_y,val_labels.to(device).sum().item())

val_acc=acc/val_num
print('[epoch%d] train_loss: %.3f val_acc:%.3f'%(epoch+1,running_loss/train_steps,val_acc))b
 
保存模型：
    if val_acc>best_acc:
    best_acc=val_acc
    torch.save(net.state_dict(),save_path)

    然后是测试集：

    1. import os
    2. import json
    3.  
    4. import torch
    5. from PIL import Image
    6. from torchvision import transforms
    7. import matplotlib.pyplot as plt
    8.  
    9. from model import vgg
    10.  
    11.  
    12. def main():
    13.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    14.  
    15.     data_transform = transforms.Compose(
    16.         [transforms.Resize((224, 224)),
    17.          transforms.ToTensor(),
    18.          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    19.  
    20.     # load image
    21.     img_path = "../tulip.jpg"
    22.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    23.     img = Image.open(img_path)
    24.     plt.imshow(img)
    25.     # [N, C, H, W]
    26.     img = data_transform(img)
    27.     # expand batch dimension
    28.     img = torch.unsqueeze(img, dim=0)
    29.  
    30.     # read class_indict
    31.     json_path = './class_indices.json'
    32.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
    33.  
    34.     with open(json_path, "r") as f:
    35.         class_indict = json.load(f)
    36.     
    37.     # create model
    38.     model = vgg(model_name="vgg16", num_classes=5).to(device)
    39.     # load model weights
    40.     weights_path = "./vgg16Net.pth"
    41.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    42.     model.load_state_dict(torch.load(weights_path, map_location=device))
    43.  
    44.     model.eval()
    45.     with torch.no_grad():
    46.         # predict class
    47.         output = torch.squeeze(model(img.to(device))).cpu()
    48.         predict = torch.softmax(output, dim=0)
    49.         predict_cla = torch.argmax(predict).numpy()
    50.  
    51.     print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
    52.                                                  predict[predict_cla].numpy())
    53.     plt.title(print_res)
    54.     for i in range(len(predict)):
    55.         print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
    56.                                                   predict[i].numpy()))
    57.     plt.show()
    58.  
    59.  
    60. if __name__ == '__main__':
    61.     main()

    正常操作
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))
    ])

    img_path="../tulip.jpg"
    assert os.path.exists(img_path) ,"{} is not exist".format(img_path)
    img=Image.open(img_path)
    plt.show(img)
    img=data_transform
    img=torch.unsqueeze(img,dim=0)

    开始读json文件

    json_path='./class_indices.json'
assert os.path.exists(json_path),"{} is not exist".format(json_path)
with open(json_path,"r") as f:
    class_indict=json.load(f)

    使用模型开始测试

    model=vgg(model_name="vgg_16",num_class=5).to(device)
weights_path="./vgg16Net.pth"
assert  os.path.exists(weights_path),"{} is not exist".format(weights_path)
model.load_state_dict(torch.load(weights_path,map_location=device))
model.eval()
with torch.no_grad():
    output=model(img.to(device))
    output=torch.squeeze(output).cpu()
    predict=torch.softmax(output,dim=0)
    predict_cla=torch.argmax(predict).numpy()

    接下来是model

    1. import torch.nn as nn
    2. import torch
    3.  
    4. # official pretrain weights
    5. model_urls = {
    6.     'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
    7.     'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
    8.     'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
    9.     'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth'
    10. }
    11.  
    12.  
    13. class VGG(nn.Module):
    14.     def __init__(self, features, num_classes=1000, init_weights=False):
    15.         super(VGG, self).__init__()
    16.         self.features = features
    17.         self.classifier = nn.Sequential(
    18.             nn.Linear(512*7*7, 4096),
    19.             nn.ReLU(True),
    20.             nn.Dropout(p=0.5),
    21.             nn.Linear(4096, 4096),
    22.             nn.ReLU(True),
    23.             nn.Dropout(p=0.5),
    24.             nn.Linear(4096, num_classes)
    25.         )
    26.         if init_weights:
    27.             self._initialize_weights()
    28.  
    29.     def forward(self, x):
    30.         # N x 3 x 224 x 224
    31.         x = self.features(x)
    32.         # N x 512 x 7 x 7
    33.         x = torch.flatten(x, start_dim=1)
    34.         # N x 512*7*7
    35.         x = self.classifier(x)
    36.         return x
    37.  
    38.     def _initialize_weights(self):
    39.         for m in self.modules():
    40.             if isinstance(m, nn.Conv2d):
    41.                 # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
    42.                 nn.init.xavier_uniform_(m.weight)
    43.                 if m.bias is not None:
    44.                     nn.init.constant_(m.bias, 0)
    45.             elif isinstance(m, nn.Linear):
    46.                 nn.init.xavier_uniform_(m.weight)
    47.                 # nn.init.normal_(m.weight, 0, 0.01)
    48.                 nn.init.constant_(m.bias, 0)
    49.  
    50.  
    51. def make_features(cfg: list):
    52.     layers = []
    53.     in_channels = 3
    54.     for v in cfg:
    55.         if v == "M":
    56.             layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
    57.         else:
    58.             conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
    59.             layers += [conv2d, nn.ReLU(True)]
    60.             in_channels = v
    61.     return nn.Sequential(*layers)
    62.  
    63.  
    64. cfgs = {
    65.     'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    66.     'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    67.     'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
    68.     'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
    69. }
    70.  
    71.  
    72. def vgg(model_name="vgg16", **kwargs):
    73.     assert model_name in cfgs, "Warning: model number {} not in cfgs dict!".format(model_name)
    74.     cfg = cfgs[model_name]
    75.  
    76.     model = VGG(make_features(cfg), **kwargs)
    77.     return model
    class VGG(nn.Module):
    def __init__(self,features,num_classes=1000,init_weights=False):
        super(VGG,self).__init__()
        self.features=features
        self.classifier=nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(p=0.5),
            nn.Linear(4096, num_classes)
        )
        if init_weights:
            self._initialize_weights()

    调整维度，扁平化成线性的

    def forward(self,x):
    x=self.features(x)
    x=torch.flatten(x,start_dim=1)
    x=self.classifier(x)
    return x
    def make_features(cfg:list):
    layers=[]
    in_channels=3
    for v in cfg:
        if v=="M":
            layers+=[nn.MaxPool2d(kernel_size=2,stride=2)]
        else:
            conv2d=nn.Conv2d(in_channels,v,kernel_size=3,padding=1)
            layers+=[conv2d,nn.ReLU(True)]
            in_channels=v
    return nn.Sequential(*layers)
  • 相关阅读:
    Shiro学习与笔记
    【力扣2154】将找到的值乘以 2
    Mobile App自动化测试技术及实现
    肖sir__mysql之索引__010
    （实用）页面在线QQ咨询html代码
    虚拟机安装Ubuntu太慢解决办法
    SAP ABAP Function Module 的动态调用方式使用方式介绍试读版
    每日学习2
    div中包含checkbox 点击事件重复问题
    制造业企业为什么需要数字化转型
  • 原文地址：https://blog.csdn.net/kling_bling/article/details/126445713