PyTorch深度学习实战第七章代码交互式编程转普通py脚本（带注释） Jupyter Notebook代码转普通py代码

weixin_48871913

477人浏览 · 2025-10-28 20:57:55

weixin_48871913 · 2025-10-28 20:57:55 发布

7.1微小图像数据集

from torchvision import datasets,transforms
import torch
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
data_path = '../data-unversioned/p1ch7/'
# cifar10 = datasets.CIFAR10(data_path, train=True, download=True)
# cifar10_val = datasets.CIFAR10(data_path, train=False, download=True)
cifar10 = datasets.CIFAR10(data_path, train=True, download=True,transform=transforms.ToTensor())
cifar10_val = datasets.CIFAR10(data_path, train=False, download=True,transform=transforms.ToTensor())

# print(type(cifar10).__mro__)
# print(len(cifar10))
# img,label = cifar10[99]
# print(img,label)
# print(cifar10.classes)
# cv.imshow('img',cv.cvtColor(np.array(img),cv.COLOR_RGB2BGR))
# cv.waitKey(0)
# plt.imshow(img)
# plt.show()

# to_tensor = transforms.ToTensor()
# img_t = to_tensor(img)

imgs = torch.stack([img_t for img_t,_ in cifar10],dim=3)
print(imgs.shape)  # torch.Size([3, 32, 32, 50000])
ave = imgs.view(3,-1).mean(1)
std = imgs.view(3,-1).std(1)
print(ave,std)  # tensor([0.4914, 0.4822, 0.4465]) tensor([0.2470, 0.2435, 0.2616])

transforms_norm = transforms.Normalize(mean=ave,std=std)
transformed_cifar10 = datasets.CIFAR10(data_path, train=True, download=False,
                                       transform=transforms.Compose([
                                           transforms.ToTensor(),
                                           transforms.Normalize(mean=ave,std=std)
                                       ]))
img_t,_  = transformed_cifar10[99]
plt.imshow(img_t.permute(1,2,0))
plt.show()

7.2区分鸟和飞机：

CPU训练：

from torchvision import datasets,transforms
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
import torch.nn as nn
import torch

data_path = '../data-unversioned/p1ch7/'
cifar10 = datasets.CIFAR10(data_path, train=True, download=True,transform=transforms.ToTensor())
cifar10_val = datasets.CIFAR10(data_path, train=False, download=True,transform=transforms.ToTensor())

# print(type(cifar10).__mro__)
# print(len(cifar10))
# img,label = cifar10[99]
# print(img,label)
# print(cifar10.classes)
# cv.imshow('img',cv.cvtColor(np.array(img),cv.COLOR_RGB2BGR))
# cv.waitKey(0)
# plt.imshow(img)
# plt.show()

# to_tensor = transforms.ToTensor()
# img_t = to_tensor(img)

label_map = {0:0,2:1}
class_names = ["airplane","bird"]
cifar2 = [(img,label_map[label])for img,label in cifar10 if label in [0,2]]
cifar2_val = [(img,label_map[label])for img,label in cifar10_val if label in [0,2] ]

train_loader = torch.utils.data.DataLoader(cifar2,batch_size=64,shuffle=True)
val_loader = torch.utils.data.DataLoader(cifar2_val,batch_size=64,shuffle=False)

n_out = 2

# model = nn.Sequential(
#     nn.Linear(
#         3072,
#         512,
#     ),
#     nn.Tanh(),
#     nn.Linear(
#         512,
#         n_out,
#     ),
#     nn.LogSoftmax(dim=1)
# )

# model = nn.Sequential(
#     nn.Linear(
#         3072,
#         1024,
#     ),
#     nn.Tanh(),
#     nn.Linear(
#         1024,
#         512,
#     ),
#     nn.Tanh(),
#     nn.Linear(
#         512,
#         128,
#     ),
#     nn.Linear(
#         128,
#         n_out,
#     ),
#     nn.LogSoftmax(dim=1)
# )

model = nn.Sequential(
    nn.Linear(
        3072,
        1024,
    ),
    nn.Tanh(),
    nn.Linear(
        1024,
        512,
    ),
    nn.Tanh(),
    nn.Linear(
        512,
        128,
    ),
    nn.Linear(
        128,
        n_out,
    ),
)

# loss_fn = nn.NLLLoss()
loss_fn = nn.CrossEntropyLoss()

learning_rate = 1e-2

opertimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)

n_epochs = 100

for epoch in range(n_epochs):
    for imgs,labels in train_loader:
        batch_size = imgs.shape[0]
        outputs = model(imgs.view(batch_size,-1))
        loss = loss_fn(outputs,labels)

        opertimizer.zero_grad()
        loss.backward()
        opertimizer.step()

    if epoch %10 ==0 or epoch == 1:
        print(f"epoch {epoch}, loss:{loss.item():.4f}")

correct = 0
total = 0
with torch.no_grad():
    for img,label in val_loader:
        batch_size = img.shape[0]
        outputs = model(img.view(batch_size,-1))
        _,predicted = torch.max(outputs,1)
        total += label.shape[0]
        correct += int((predicted == label).sum())
print(f"Accuracy: {correct/total:.4f}")

GPU训练：

from torchvision import datasets,transforms
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
import torch.nn as nn
import torch

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device:", device)

data_path = '../data-unversioned/p1ch7/'
cifar10 = datasets.CIFAR10(data_path, train=True, download=True, transform=transforms.ToTensor())
cifar10_val = datasets.CIFAR10(data_path, train=False, download=True, transform=transforms.ToTensor())

label_map = {0:0, 2:1}
cifar2 = [(img, label_map[label]) for img, label in cifar10 if label in [0,2]]
cifar2_val = [(img, label_map[label]) for img, label in cifar10_val if label in [0,2]]

train_loader = torch.utils.data.DataLoader(cifar2, batch_size=64, shuffle=True, pin_memory=True)
val_loader = torch.utils.data.DataLoader(cifar2_val, batch_size=64, shuffle=False, pin_memory=True)

n_out = 2

# model = nn.Sequential(
#     nn.Linear(3072, 512),
#     nn.Tanh(),
#     nn.Linear(512, n_out),
#     nn.LogSoftmax(dim=1)
# ).to(device)

# model = nn.Sequential(
#     nn.Linear(
#         3072,
#         1024,
#     ),
#     nn.Tanh(),
#     nn.Linear(
#         1024,
#         512,
#     ),
#     nn.Tanh(),
#     nn.Linear(
#         512,
#         128,
#     ),
#     nn.Linear(
#         128,
#         n_out,
#     ),
#     nn.LogSoftmax(dim=1)
# ).to(device)

model = nn.Sequential(
    nn.Linear(
        3072,
        1024,
    ),
    nn.Tanh(),
    nn.Linear(
        1024,
        512,
    ),
    nn.Tanh(),
    nn.Linear(
        512,
        128,
    ),
    nn.Linear(
        128,
        n_out,
    ),
).to(device)

# loss_fn = nn.NLLLoss().to(device)
loss_fn = nn.CrossEntropyLoss().to(device)

learning_rate = 1e-2
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

n_epochs = 100

for epoch in range(n_epochs):
    for imgs, labels in train_loader:
        imgs = imgs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

        batch_size = imgs.shape[0]
        outputs = model(imgs.view(batch_size, -1))
        loss = loss_fn(outputs, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    if epoch % 10 == 0 or epoch == 1:
        print(f"epoch {epoch}, loss:{loss.item():.4f}")

correct = 0
total = 0
with torch.no_grad():
    for imgs, labels in val_loader:
        imgs = imgs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

        batch_size = imgs.shape[0]
        outputs = model(imgs.view(batch_size, -1))
        _, predicted = torch.max(outputs, 1)
        total += labels.shape[0]
        correct += int((predicted == labels).sum())
print(f"Accuracy: {correct/total:.4f}")

亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责