Pytorch 自己搭建的一个神经网络

数据集
dogs Vs Cats

import time

import torch.nn as nn
import torch.optim
from torch.autograd import Variable
from torch.optim import lr_scheduler
import os
import torch.nn
import torchvision
from glob import glob
import numpy as np
from torch._C._cudnn import is_cuda
from torchvision import transforms
from torchvision.datasets import ImageFolder

# 数据集的起始目录
path = "./dogs-vs-cats/"
# 通过glob函数获取 目录下的所有jpg文件 *是通配符
files = glob(os.path.join(path, '*/*.jpg'))
# 输出文件个数
print(f'Total no of images{len(files)}')
# 记录文件个数
no_of_images = len(files)
# 创建可以用于创建验证数据集的混合索引
shuffle = np.random.permutation(no_of_images)
# os.mkdir(os.path.join(path,'valid'))
# 在这里对训练集的数据进行分类
for t in ['test1']:
    # 获取所有猫的图片
    files1 = glob(os.path.join(path + t, "/cat*.jpg"))
    print(files1)
    # 获取所有狗的图片
    files2 = glob(os.path.join(path + t, "/dog*.jpg"))
    temp = 0
    # 设置目录名
    dirs = ['cat', 'dog']
    # 根据目录 将对应图片分类存入
    for file in [files1, files2]:
        for sfile in file:
            print(sfile)
            folder1 = sfile.split("\\")[-1]
            folder2 = sfile.split("\\")[0]
            print(folder1, folder2)
            # 通过rename修改文件的路径
            os.rename(sfile, os.path.join(folder2, dirs[temp], folder1))
        temp += 1
# 用于混合排列文件
shuffle=np.random.permutation(no_of_images )
# transforms进行变换和加载图片
simple_transform=transforms.Compose([transforms.Resize((224,224)),transforms.ToTensor(),transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])])
train=ImageFolder("dogs-vs-cats/train",simple_transform)
# 设置训练集的标签
train.class_to_idx={"cat":0,"dog":1}
train.classes=['cat','dog']
# 加载测试集合
test=ImageFolder("dogs-vs-cats/test1",simple_transform)
# 设置测试集合的标签
test.class_to_idx={"cat":0,"dog":1}
test.classes=['cat','dog']
# 将train和test数据加载到 数据加载器中
train_data_gen=torch.utils.data.DataLoader(train,batch_size=64,num_workers=0)
test_data_gen=torch.utils.data.DataLoader(test,batch_size=64,num_workers=0)

def train_model(model,criterion,optimizer,scheduler,num_epochs=25):
    # 保留开始时间 方便后面计算
    since=time.time()
    best_model_wts=model.state_dict()
    best_acc=0.0
    for epoch in range(num_epochs):
        print('Epoch{}/{}'.format(epoch,num_epochs-1))
        print('-'*10)
        # 每一轮都在训练和检验
        for phase in ['train','test1']:
            # 模型设置为训练模式
            if phase == 'train':
                scheduler.step()
                model.train(True)
            #  模型设置为评估模式
            else:
                model.train(False)
            running_loss=0.0
            running_correct=0
        # 对数据加载器 进行迭代
        for data in train_data_gen:
            inputs,labels=data

            if is_cuda:
                inputs=Variable(inputs.cuda())
                labels=Variable(labels.cuda())
            else:
                inputs,labels=Variable(inputs),Variable(labels)
            # 梯度清零
            optimizer.zero_grad();
            
            # 向前
            outputs=model(inputs)
            _,preds=torch.max(outputs.data,1)
            loss=criterion(outputs,labels)
            
            # 训练的时候 反向优化
            if phase=="train":
                loss.backward()
                optimizer.step()
                scheduler.step()
            
            # 统计
            running_loss+=loss.item()
            running_correct+=torch.sum(preds==labels.data)
            import carAndDog
        epoch_loss=running_loss/carAndDog.no_of_images
        epoch_acc=running_correct/carAndDog.no_of_images
        
        # 复刻模型
        if phase=='test1' and epoch_acc >best_acc:
            best_acc=epoch_acc
            best_model_wts=model.state_dict()
        print()
    time_elapsed=time.time()-since
    print('Training complete in {:.0f}m {:.0f}'.format(time_elapsed//60,time_elapsed%60))
    print("Best val Acc:{:4f}".format(best_acc))
    # 生成最优权重
    model.load_state_dict(best_model_wts)
    return model
# 创建算法实例
model_ft = torchvision.models.resnet18()
num_ftrs = model_ft.fc.in_features
# 配置全连接层
model_ft.fc = torch.nn.Linear(num_ftrs, 2)
# 使用GPU加速
if is_cuda:
    model_ft = model_ft.cuda()

learning_rate=0.001
# 损失函数
criterion = nn.CrossEntropyLoss()
# 优化器
optimizer_ft=torch.optim.SGD(model_ft.parameters(),lr=0.001,momentum=0.9)
exp_lr_scheduler=lr_scheduler.StepLR(optimizer_ft,step_size=7,gamma=0.1)
# 传参开始训练
train_model(model_ft,criterion,optimizer_ft,exp_lr_scheduler)