1
Dataset??       #查看Dataset类的官方介绍
2
help(Dataset)   #查看Dataset类的官方介绍

1
from torch.utils.data import Dataset

1
class MyDataSet(Dataset):
2
    def __init__(self, root_dir, label_dir):
3
        self.root_dir       = root_dir
4
        self.label_dir      = label_dir
5
        self.path           = os.path.join(self.root_dir, self.label_dir)
6
        self.img_path_list  = os.listdir(self.path)
7

8
    def __len__(self):
9
        return len(self.img_path_list)
10

11
    def __getitem__(self, idx):
12
        img_name    = self.img_path_list[idx]
13
        img_path    = os.path.join(self.path, img_name)
14
        img         = Image.open(img_path)
15
        label       = self.label_dir
16

17
        return img, label

1
my_dataset = MyDataSet("root_dir", "label_dir")
2
print(len(my_dataset))
3
img, label = my_dataset[idx]

1
from torch.utils.data import DataLoader

1
# 加载 CIFAR10 测试集，应用 ToTensor 转换
2
test_dataset = torchvision.datasets.CIFAR10(
3
    root        = "./dataset/CIFAR10",
4
    train       = False,
5
    download    = True,
6
    transform   = torchvision.transforms.ToTensor()
7
)

1
# 创建测试集 DataLoader
2
test_loader = DataLoader(
3
    dataset     = test_dataset,
4
    batch_size  = 64,
5
    shuffle     = True,
6
    num_workers = 0,
7
    drop_last   = False
8
)

1
# 测试 DataLoader
2
writer = SummaryWriter("CIFAR10_DataLoader")
3

4
for epoch in range(2):
5
    step = 0
6
    for data in test_loader:
7
        imgs, targets = data
8
        # print(imgs.shape)      # torch.Size([4, 3, 32, 32])
9
        # print(targets)         # tensor([6, 9, 2, 4])
10
        writer.add_images("Epoch:{}".format(epoch), imgs, step)
11
        step += 1
12

13

14
writer.close()

1
from PIL import Image

1
# 打开图片
2
img = Image.open("test.jpg")
3

4
# 显示图片
5
img.show()
6

7
# 转换格式
8
img = img.convert("L")   # 转为灰度图
9

10
# 调整大小
11
img = img.resize((200, 200))
12

13
# 保存图片
14
img.save("out.png")

1
pip install opencv-python

1
import cv2

1
# 读取图片
2
img = cv2.imread("test.jpg")
3

4
# 显示图片
5
cv2.imshow("Image", img)
6
cv2.waitKey(0)
7
cv2.destroyAllWindows()
8

9
# 转为灰度
10
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
11

12
# 图像处理
13
blur = cv2.GaussianBlur(gray, (5, 5), 0)
14
edges = cv2.Canny(blur, 100, 200)
15

16
# 保存结果
17
cv2.imwrite("edges.jpg", edges)

1
img_path = "Relative_Image_Path"
2
img_PIL = Image.open(img_path)
3
img_array = np.array(img_PIL)
4
print(type(img_array))
5
print(img_array.shape)  # (512, 768, 3)
6
                        # HWC---------------------------------------
7
                        #                                          |
8
writer.add_image("Ant Image from PIL", img_array, 0, dataformats='HWC')

1
# y = 2x
2
for i in range(100):
3
    writer.add_scalar("y=2x", 2*i, i)

1
writer.close()

1
tensorboard --logdir=My_TensorBoard --port=6007

1
#img PIL -> tensor
2
img_tensor = transforms.ToTensor()(img_PIL)

1
writer.add_image("PIL IMG", img_tensor, 0)

1
#img PIL -> Resize -> tensor
2
img_resize_PIL = transforms.Resize((256, 256))(img_PIL)
3
img_resize_tensor = transforms.ToTensor()(img_resize_PIL)

1
writer.add_image("Resize IMG", img_resize_tensor, 0)

1
# Random Crop（若不确定原图尺寸，考虑换 RandomResizedCrop(256)）
2
for i in range(5):
3
    img_random_crop_PIL = transforms.RandomCrop((256, 256))(img_PIL)
4
    img_random_crop_tensor = transforms.ToTensor()(img_random_crop_PIL)
5
    writer.add_image("Random Crop IMG", img_random_crop_tensor, i)

1
# Tensor -> Normalize（训练用）；可视化时要反归一化
2
img_norm = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])(img_tensor)
3
img_norm_vis = img_norm * 0.5 + 0.5        # 仅用于可视化

1
writer.add_image("Normalize IMG (for view)", img_norm, 0)
2
writer.add_image("Normalize IMG (for view)", img_norm_vis, 1)

1
# Compose: resize -> tensor -> normalize
2
transform = transforms.Compose([
3
    transforms.Resize((256, 256)),
4
    transforms.ToTensor(),
5
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
6
])
7
img_composed = transform(img_PIL)
8

9
# 可视化时反归一化
10
img_composed_vis = img_composed * 0.5 + 0.5

1
writer.add_image("Tensor IMG (composed, for view)", img_composed, 0)
2
writer.add_image("Tensor IMG (composed, for view)", img_composed_vis, 1)

1
# transform 预处理
2
dataset_transform = torchvision.transforms.Compose([
3
    torchvision.transforms.Resize((32, 32)),
4
    torchvision.transforms.ToTensor()
5
])

1
# 官方数据集导入 & 使用
2
train_set = torchvision.datasets.CIFAR10(
3
    root        = "./dataset/CIFAR10",
4
    train       = True,
5
    download    = True,
6
    transform   = dataset_transform
7
)
8

9

10
test_set = torchvision.datasets.CIFAR10(
11
    root        = "./dataset/CIFAR10",
12
    train       = False,
13
    download    = True,
14
    transform   = dataset_transform
15
)

1
img, label = train_set[idx]
2
print(train_set[idx])
3
img.show()

1
print(f"类别名称: {train_set.classes}")
2
print(f"类别名称与索引映射: {train_set.class_to_idx}")
3

4
print(f"图像尺寸: {img.size}, 图像类型: {type(img)}, 标签: {label}", f"标签名称: {train_set.classes[label]}")
5

6
print(f"训练集样本数: {len(train_set)}")
7
print(f"测试集样本数: {len(test_set)}")

1
class Model(nn.Module):
2
    def __init__(self) -> None:
3
        super().__init__()
4
        self.conv1 = nn.Conv2d(1, 20, 5)
5
        self.conv2 = nn.Conv2d(20, 20, 5)
6

7
    def forward(self, x):
8
        x = F.relu(self.conv1(x))
9
        return F.relu(self.conv2(x))

1
My_model = Model()
2
X = torch.tensor([1.0, 2.0, 3.0])
3
output = My_model(X)

1
from torch import nn
2
import torch.nn.functional as F

1
class My_Model(torch.nn.Module):
2
    def __init__(self):
3
        super().__init__()
4
        self.maxpool1 = torch.nn.MaxPool2d(
5
            kernel_size     = 3,
6
            ceil_mode       = True,
7
            stride          = 2,
8
            padding         = 1
9
        )
10

11
    def forward(self, x):
12
        x = self.maxpool1(x)
13
        return x

1
wtriter = SummaryWriter("CIFAR10_NN_MaxPool2d")
2

3
My_model = My_Model()
4
step = 0
5
for epoch in range(2):
6
    step = 0
7
    for data in test_loader:
8
        imgs, targets = data
9
        output = My_model(imgs)
10

11
        # print("input shape:", imgs.shape)
12
        # print("output shape:", output.shape)
13

14
        wtriter.add_images("Input:{}".format(epoch), imgs, step)
15
        wtriter.add_images("Output:{}".format(epoch), output, step)
16

17
        step += 1
18

19
print("Done.")

1
class My_Model(torch.nn.Module):
2
    def __init__(self):
3
        super().__init__()
4
        self.ReLU1 = torch.nn.ReLU()
5
        self.sigmoid1 = torch.nn.Sigmoid()
6

7
    def forward(self, x):
8
        # x = self.ReLU1(x)
9
        x = self.sigmoid1(x)
10
        return x

1
wtriter = SummaryWriter("CIFAR10_NN_Non_Linear_Act")
2

3
My_model = My_Model()
4
step = 0
5
for epoch in range(2):
6
    step = 0
7
    for data in test_loader:
8
        imgs, targets = data
9
        output = My_model(imgs)
10

11
        # print("input shape:", imgs.shape)
12
        # print("output shape:", output.shape)
13

14
        wtriter.add_images("Input:{}".format(epoch), imgs, step)
15
        wtriter.add_images("Output:{}".format(epoch), output, step)
16

17
        step += 1
18

19
print("Done.")

1
class My_Model(torch.nn.Module):
2
    def __init__(self):
3
        super().__init__()
4
        self.linear1 = torch.nn.Linear(
5
            in_features    = 3 * 32 * 32,
6
            out_features   = 10
7
        )
8

9
    def forward(self, input):
10
        output = self.linear1(input)
11
        return output

1
My_model = My_Model()
2
step = 0
3
for epoch in range(1):
4
    step = 0
5
    for data in test_loader:
6
        imgs, targets = data
7
        print("imgs shape before flatten:", imgs.shape)
8

9
        #imgs = imgs.view(imgs.size(0), -1)  # 展平操作
10
        imgs = torch.flatten(imgs, start_dim=1)  # 另一种展平操作
11
        print("imgs shape after flatten:", imgs.shape)
12

13
        output = My_model(imgs)
14
        print("output shape:", output.shape)
15

16
        step += 1
17

18
print("Done.")

1
class My_Model(nn.Module):
2
    def __init__(self):
3
        super().__init__()
4
        self.conv1 = nn.Conv2d(
5
            in_channels     = 3,
6
            out_channels    = 32,
7
            kernel_size     = 5,
8
            padding         = 2
9
        )
10

11
        self.maxpool1 = nn.MaxPool2d(
12
            kernel_size = 2,
13
        )
14

15
        self.conv2 = nn.Conv2d(
16
            in_channels     = 32,
17
            out_channels    = 32,
18
            kernel_size     = 5,
19
            padding         = 2
20
        )
21

22
        self.maxpool2 = nn.MaxPool2d(
23
            kernel_size = 2,
24
        )
25

26
        self.conv3 = nn.Conv2d(
27
            in_channels     = 32,
28
            out_channels    = 64,
29
            kernel_size     = 5,
30
            padding         = 2
31
        )
32

33
        self.maxpool3 = nn.MaxPool2d(
34
            kernel_size = 2,
35
        )
36

37
        self.flatten = nn.Flatten()
38

39
        self.linear1 = nn.Linear(
40
            in_features    = 64 * 4 * 4,
41
            out_features   = 64
42
        )
43

44
        self.linear2 = nn.Linear(
45
            in_features    = 64,
46
            out_features   = 10
47
        )
48

49
        self.seq = nn.Sequential(
50
            self.conv1,
51
            self.maxpool1,
52
            self.conv2,
53
            self.maxpool2,
54
            self.conv3,
55
            self.maxpool3,
56
            self.flatten,
57
            self.linear1,
58
            self.linear2
59
        )
60

61
    def forward(self, input):
62
        output = self.seq(input)
63
        return output

1
my_model = My_Model()
2
print(my_model)
3

4
input = torch.randn(64, 3, 32, 32)
5
print("input shape:", input.shape)
6
print("input:", input)
7

8
output = my_model(input)
9
print("output shape:", output.shape)
10
print("output:", output)

1
 # 定义损失函数
2
criterion = nn.CrossEntropyLoss()
3

4
# 计算损失
5
loss = criterion(outputs, targets)
6

7
#具体其他的损失函数及其参数可翻阅文档查看

1
optim = torch.optim.SGD(
2
    params      = my_model.parameters(),
3
    lr          = 0.01,
4
)

1
for epoch in range(20):
2
    running_loss = 0.0
3

4
    for data in train_loader:
5
        imgs, targets = data
6
        outputs = my_model(imgs)
7

8
        # 定义损失函数
9
        criterion = nn.CrossEntropyLoss()
10

11
        # 计算损失
12
        loss = criterion(outputs, targets)
13

14
        optim.zero_grad()  # 清零梯度
15
        loss.backward()
16
        optim.step()       # 更新参数
17

18
        running_loss += loss.item()
19

20
    print(f"epoch {epoch} finished!")
21
    print("loss:", running_loss)

1
from torchvision.models import VGG16_Weights

1
# 模型文件保存路径
2
os.environ['TORCH_HOME'] = r'E:\Deep_Learning\project\dataset\ImageNet'

1
# 不加载权重
2
VGG16_MODEL_False = torchvision.models.vgg16(weights = None)
3

4
# 加载 ImageNet 预训练权重
5
VGG16_MODEL_True = torchvision.models.vgg16(weights=VGG16_Weights.IMAGENET1K_V1)

1
VGG16_MODEL = torchvision.models.vgg16(weights = None)

1
# 保存整个模型（不推荐做法）
2
torch.save(VGG16_MODEL, "./My_Model/VGG16_no_weights_All_Model.pth")
3

4
# 仅保存模型参数（推荐做法）
5
torch.save(VGG16_MODEL.state_dict(), "./My_Model/VGG16_no_weights_state_dict.pth")

1
# 直接加载整个模型（不推荐做法）
2
model = torch.load("./My_Model/VGG16_no_weights_All_Model.pth", weights_only = False)
3
print(model)
4

5
# 仅加载模型参数（推荐做法）
6
model = torchvision.models.vgg16(weights = False)
7
model.load_state_dict(torch.load("./My_Model/VGG16_no_weights_state_dict.pth"))
8
print(model)