import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose([transforms.ToTensor()]) # 定義轉(zhuǎn)換函數(shù)，將PIL.Image轉(zhuǎn)換為torch.Tensor
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) # 加載CIFAR-10訓(xùn)練集
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True) # 定義DataLoader對象，用于批量加載數(shù)據(jù)

import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose([
    transforms.RandomHorizontalFlip(), # 隨機水平翻轉(zhuǎn)
    transforms.RandomCrop(32, padding=4), # 隨機裁剪到32×32大小，并在邊緣填充4個像素
    transforms.ToTensor(), # 將PIL.Image轉(zhuǎn)換為torch.Tensor
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # 將RGB三個通道的值歸一化到[-1, 1]范圍內(nèi)
])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) # 加載CIFAR-10訓(xùn)練集，并應(yīng)用上述變換
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True) # 定義DataLoader對象，用于批量加載數(shù)據(jù)

import torch.utils.data as data
from PIL import Image
import os

class MyDataset(data.Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir # 根目錄路徑
        self.transform = transform # 變換函數(shù)
        
        self.classes = sorted(os.listdir(root_dir)) # 類別列表（按字母順序排序）
        self.class_to_idx = {c: i for i,c in enumerate(self.classes)} # 類別名到索引的映射
        
        self.images = [] # 圖片路徑列表（相對于根目錄）
        self.labels = [] # 標(biāo)簽列表（整數(shù)）
        
        for c in self.classes:
            c_dir = os.path.join(root_dir, c) # 類別子目錄路徑
            for img_name in sorted(os.listdir(c_dir)): # 遍歷每個圖片文件名（按字母順序排序）
                img_path = os.path.join(c,img_name) # 圖片相對路徑（相對于根目錄）
                label = self.class_to_idx[c] # 圖

import torchvision.models as models

model = models.resnet18(pretrained=True) # 加載預(yù)訓(xùn)練好的ResNet-18模型
for param in model.parameters(): # 遍歷所有參數(shù)
    param.requires_grad = False # 將參數(shù)的梯度設(shè)置為False，表示不需要更新
num_features = model.fc.in_features # 獲取全連接層（fc）的輸入特征數(shù)
model.fc = torch.nn.Linear(num_features, 10) # 替換全連接層為一個新的線性層，輸出特征數(shù)為10（假設(shè)有10個類別）

import torch.nn as nn

class MyCNN(nn.Module):
    def __init__(self):
        super(MyCNN, self).__init__() # 調(diào)用父類構(gòu)造函數(shù)
        self.conv1 = nn.Conv2d(3, 6, 5) # 定義第一個卷積層，輸入通道數(shù)為3（RGB），輸出通道數(shù)為6，卷積核大小為5×5
        self.pool = nn.MaxPool2d(2, 2) # 定義最大池化層，池化核大小為2×2，步長為2
        self.conv2 = nn.Conv2d(6, 16, 5) # 定義第二個卷積層，輸入通道數(shù)為6，輸出通道數(shù)為16，卷積核大小為5×5
        self.fc1 = nn.Linear(16 * 5 * 5, 120) # 定義第一個全連接層，輸入特征數(shù)為16×5×5（根據(jù)卷積和池化后的圖像大小計算得到），輸出特征數(shù)為120
        self.fc2 = nn.Linear(120, 84) # 定義第二個全連接層，輸入特征數(shù)為120，輸出特征數(shù)為84
        self.fc3 = nn.Linear(84, 10) # 定義第三個全連接層，輸入特征數(shù)為84，

import torch.nn.functional as F

class MyCNN(nn.Module):
    def __init__(self):
        # 省略__init__方法的內(nèi)容
        ...

    def forward(self, x): # 定義前向傳播過程，x是輸入的圖像張量
        x = self.pool(F.relu(self.conv1(x))) # 將x通過第一個卷積層和ReLU激活函數(shù)，然后通過最大池化層
        x = self.pool(F.relu(self.conv2(x))) # 將x通過第二個卷積層和ReLU激活函數(shù)，然后通過最大池化層
        x = x.view(-1, 16 * 5 * 5) # 將x展平為一維向量，-1表示自動推斷批量大小
        x = F.relu(self.fc1(x)) # 將x通過第一個全連接層和ReLU激活函數(shù)
        x = F.relu(self.fc2(x)) # 將x通過第二個全連接層和ReLU激活函數(shù)
        x = self.fc3(x) # 將x通過第三個全連接層
        x = F.softmax(x, dim=1) # 將x通過softmax函數(shù)，沿著第一個維度（類別維度）進(jìn)行歸一化，得到類別概率分布
        return x # 返回輸出的類別概率分布

# 導(dǎo)入模塊
import matplotlib.pyplot as plt
import numpy as np

# 設(shè)置字體和分辨率
plt.rcParams["font.sans-serif"] = ["SimHei"]
plt.rcParams["axes.unicode_minus"] = False
%config InlineBackend.figure_format = "retina"

# 生成數(shù)據(jù)
x = np.linspace(0, 10, 100)
y = 3 * x + 5 + np.random.randn(100) * 2 # 真實值
w = np.random.randn() # 隨機初始化權(quán)重
b = np.random.randn() # 隨機初始化偏置

# 定義損失函數(shù)
def loss(y_true, y_pred):
    return ((y_true - y_pred) ** 2).mean()

# 定義梯度下降函數(shù)
def gradient_descent(x, y_true, w, b, lr):
    y_pred = w * x + b # 預(yù)測值
    dw = -2 * (x * (y_true - y_pred)).mean() # 權(quán)重梯度
    db = -2 * (y_true - y_pred).mean() # 偏置梯度
    w = w - lr * dw # 更新權(quán)重
    b = b - lr * db # 更新偏置
    return w, b

# 訓(xùn)練模型，并記錄每輪的訓(xùn)練誤差和測試誤差
epochs = 20 # 訓(xùn)練輪數(shù)
lr = 0.01 # 學(xué)習(xí)率
train_loss_list = [] # 訓(xùn)練誤差列表
test_loss_list = [] # 測試誤差列表

for epoch in range(epochs):
    # 劃分訓(xùn)練集和測試集（8:2）
    train_index = np.random.choice(100, size=80, replace=False)
    test_index = np.setdiff1d(np.arange(100), train_index)
    x_train, y_train = x[train_index], y[train_index]
    x_test, y_test = x[test_index], y[test_index]

    # 梯度下降更新參數(shù)，并計算訓(xùn)練誤差和測試誤差
    w, b = gradient_descent(x_train, y_train, w, b, lr)
    train_loss = loss(y_train, w * x_train + b)
    test_loss = loss(y_test, w * x_test + b)

    # 打印結(jié)果，并將誤差添加到列表中
    print(f"Epoch {epoch+1}, Train Loss: {train_loss:.4f}, Test Loss: {test_loss:.4f}")
    train_loss_list.append(train_loss)
    test_loss_list.append(test_loss)

# 創(chuàng)建一個圖形對象，并設(shè)置大小為8*6英寸    
plt.figure(figsize=(8,6))

# 在圖形對象中創(chuàng)建一個子圖，并設(shè)置位置為1行1列的第1個
plt.subplot(1, 1, 1)

# 在子圖中繪制訓(xùn)練誤差和測試誤差曲線，使用不同的顏色和標(biāo)簽
plt.plot(np.arange(epochs), train_loss_list, "r", label="Train Loss")
plt.plot(np.arange(epochs), test_loss_list, "b", label="Test Loss")

# 添加圖例、坐標(biāo)軸標(biāo)簽和標(biāo)題
plt.legend()
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Linear Regression Loss Curve")

# 保存或顯示圖形
#plt.savefig("loss_curve.png")
plt.show()