P5打卡-pytorch实现运动鞋分类

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision

device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

import os,PIL,random,pathlib 
data_dir='data/46-data'
data_dir=pathlib.Path(data_dir)
data_paths=list(data_dir.glob('*'))
classNames=[str(path).split('\\')[2]for path in data_paths]
classNames

train_transforms = transforms.Compose([
    transforms.Resize([224, 224]), 
    # transforms.RandomHorizontalFlip(), 
    transforms.ToTensor(),        
    transforms.Normalize(          
        mean=[0.485, 0.456, 0.406], 
        std=[0.229, 0.224, 0.225]) 
])

test_transform = transforms.Compose([
    transforms.Resize([224, 224]),
    transforms.ToTensor(),          
    transforms.Normalize(           
        mean=[0.485, 0.456, 0.406], 
        std=[0.229, 0.224, 0.225]) 
])

train_dataset = datasets.ImageFolder("data/46-data/train/",transform=train_transforms)
test_dataset  = datasets.ImageFolder("data/46-data/test/",transform=test_transform)
train_dataset.class_to_idx

batch_size=32
train_dl=torch.utils.data.DataLoader(train_dataset,
                                     batch_size,shuffle=True,num_workers=1)
test_dl=torch.utils.data.DataLoader(test_dataset,batch_size,shuffle=True,num_workers=1)

for X,y in test_dl:
    print(X.shape)
    print(y.shape)
    break

import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1=nn.Sequential(
            nn.Conv2d(3, 12, kernel_size=5, padding=0), 
            nn.BatchNorm2d(12),
            nn.ReLU())
        
        self.conv2=nn.Sequential(
            nn.Conv2d(12, 12, kernel_size=5, padding=0), 
            nn.BatchNorm2d(12),
            nn.ReLU())
        
        self.pool3=nn.Sequential(
            nn.MaxPool2d(2))                              
        
        self.conv4=nn.Sequential(
            nn.Conv2d(12, 24, kernel_size=5, padding=0),
            nn.BatchNorm2d(24),
            nn.ReLU())
        
        self.conv5=nn.Sequential(
            nn.Conv2d(24, 24, kernel_size=5, padding=0),
            nn.BatchNorm2d(24),
            nn.ReLU())
        
        self.pool6=nn.Sequential(
            nn.MaxPool2d(2))                              

        self.dropout = nn.Sequential(
            nn.Dropout(0.2))
        
        self.fc=nn.Sequential(
            nn.Linear(24*50*50, len(classNames)))
        
    def forward(self, x):
        
        batch_size = x.size(0)
        x = self.conv1(x)  
        x = self.conv2(x)  
        x = self.pool3(x)  
        x = self.conv4(x)  
        x = self.conv5(x)  
        x = self.pool6(x) 
        x = self.dropout(x)
        x = x.view(batch_size, -1) 
        x = self.fc(x)
       
        return x

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

model = Model().to(device)
model

def adjust_learning_rate(optimizer,epoch,start_lr):
    lr=start_lr*(0.92**(epoch//2))
    for param_group in optimizer.param_groups:
        param_group['lr']=lr
learn_rate=1e-4
optimizer=torch.optim.SGD(model.parameters(),lr=learn_rate)

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  
    num_batches = len(dataloader)   
    train_loss, train_acc = 0, 0  
    for X, y in dataloader:  
        X, y = X.to(device), y.to(device)
        pred = model(X)          
        loss = loss_fn(pred, y)  
        optimizer.zero_grad()  
        loss.backward()      
        optimizer.step()   
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()    
    train_acc  /= size
    train_loss /= num_batches
    return train_acc, train_loss

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  
    num_batches = len(dataloader)         
    test_loss, test_acc = 0, 0
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target
            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()
    test_acc  /= size
    test_loss /= num_batches
    return test_acc, test_loss

import matplotlib.pyplot as plt
# 绘制训练和测试的损失与准确率变化趋势
plt.figure(figsize=(12, 5))

# 绘制损失变化趋势
plt.subplot(1, 2, 1)
plt.plot(range(1, epochs + 1), train_losses, label='Train Loss')
plt.plot(range(1, epochs + 1), test_losses, label='Test Loss', linestyle='--')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Loss over Epochs')
plt.legend()

# 绘制准确率变化趋势
plt.subplot(1, 2, 2)
plt.plot(range(1, epochs + 1), [acc * 100 for acc in train_accuracies], label='Train Accuracy')
plt.plot(range(1, epochs + 1), [acc * 100 for acc in test_accuracies], label='Test Accuracy', linestyle='--')
plt.xlabel('Epoch')
plt.ylabel('Accuracy (%)')
plt.title('Accuracy over Epochs')
plt.legend()

plt.tight_layout()
plt.show()

from PIL import Image
classes=list(train_dataset.class_to_idx)
def predict_one_image(image_path,model,transdform,classes):
    test_img=Image.open(image_path).convert('RGB')
    test_img=transdform(test_img)
    img=test_img.to(device).unsqueeze(0)
    model.eval()
    output=model(img)
    _,pred=torch.max(output,1)
    pred_class=classes[pred]
    print(f'结果是{pred_class}') 

predict_one_image(image_path='data/46-data/test/adidas/1.jpg',model=model,transdform=train_transforms,classes=classes)

PATH='./model.pth'
torch.save(model.state_dict(),PATH)
model.load_state_dict(torch.load(PATH,map_location=device))

PATH='./model.pth'
torch.save(model.state_dict(),PATH)