y = w * x + b + ε

y = w?x? + w?x? + ... + w?x? + b + ε

L(w, b) = (1/2n) * Σ(y? - ??)2

?L/?w? = (1/n) * Σ(?? - y?) * x??
?L/?b = (1/n) * Σ(?? - y?)

w? ← w? - α * ?L/?w?
b ← b - α * ?L/?b

# 創(chuàng)建虛擬環(huán)境
python -m venv pytorch_env
source pytorch_env/bin/activate  # Linux/Mac
# pytorch_env\Scripts\activate  # Windows
# 安裝PyTorch（CPU版本）
pip install torch torchvision torchaudio
# 安裝PyTorch（GPU版本，CUDA 11.8）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
# 安裝其他依賴
pip install numpy pandas matplotlib seaborn jupyter

import torch

# 創(chuàng)建張量
x = torch.tensor([1.0, 2.0, 3.0])  # 從列表創(chuàng)建
y = torch.zeros(3)                 # 零張量
z = torch.ones(2, 3)               # 全1張量
a = torch.randn(2, 2)              # 標(biāo)準(zhǔn)正態(tài)分布

# 張量屬性
print(f"形狀: {x.shape}")
print(f"數(shù)據(jù)類型: {x.dtype}")
print(f"設(shè)備: {x.device}")

# 基本運(yùn)算
x = torch.tensor([1.0, 2.0, 3.0])
y = torch.tensor([4.0, 5.0, 6.0])
print(f"加法: {x + y}")
print(f"乘法: {x * y}")
print(f"點(diǎn)積: {torch.dot(x, y)}")

# 矩陣運(yùn)算
A = torch.randn(3, 2)
B = torch.randn(2, 4)
C = torch.matmul(A, B)  # 矩陣乘法
print(f"矩陣乘法結(jié)果形狀: {C.shape}")

import torch
import numpy as np

# 設(shè)置隨機(jī)種子，確?？蓮?fù)現(xiàn)
torch.manual_seed(42)
np.random.seed(42)

# 定義真實(shí)的模型參數(shù)
true_w = torch.tensor([[2.0], [-3.4]])  # 真實(shí)權(quán)重
true_b = 4.2                            # 真實(shí)偏置

# 生成數(shù)據(jù)
num_examples = 1000  # 樣本數(shù)量
num_inputs = 2       # 特征數(shù)量

# 從標(biāo)準(zhǔn)正態(tài)分布中隨機(jī)生成輸入特征
X = torch.normal(0, 1, (num_examples, num_inputs))

# 根據(jù)真實(shí)公式計(jì)算標(biāo)簽，并加入噪聲
noise = torch.normal(0, 0.01, (num_examples, 1))
y = torch.matmul(X, true_w) + true_b + noise

print(f"數(shù)據(jù)集形狀: X={X.shape}, y={y.shape}")
print(f"前3個樣本:\n{X[:3]}")
print(f"對應(yīng)標(biāo)簽:\n{y[:3]}")

# 初始化權(quán)重 w，從均值為0，標(biāo)準(zhǔn)差為0.01的正態(tài)分布中采樣
w = torch.normal(0, 0.01, size=(num_inputs, 1), requires_grad=True)

# 初始化偏置 b 為 0
b = torch.zeros(1, requires_grad=True)

print(f"初始權(quán)重 w:\n{w}")
print(f"初始偏置 b: ")
print(f"w 需要梯度: {w.requires_grad}")
print(f"b 需要梯度: {b.requires_grad}")

def linreg(X, w, b):
    """線性回歸模型的前向傳播"""
    return torch.matmul(X, w) + b

def squared_loss(y_hat, y):
    """均方損失函數(shù)"""
    # 將 y 的形狀調(diào)整為和 y_hat 一致
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

# 測試前向傳播
y_hat = linreg(X[:5], w, b)
print(f"預(yù)測值:\n{y_hat}")

# 測試損失計(jì)算
loss = squared_loss(y_hat, y[:5])
print(f"損失值:\n{loss}")
print(f"平均損失: {loss.mean()}")

def sgd(params, lr, batch_size):
    """
    小批量隨機(jī)梯度下降優(yōu)化器
    
    參數(shù):
        params: 需要更新的參數(shù)列表，如 [w, b]
        lr: 學(xué)習(xí)率
        batch_size: 批量大小
    """
    with torch.no_grad():  # 更新參數(shù)時，不需要記錄梯度
        for param in params:
            # 梯度下降更新公式
            param -= lr * param.grad / batch_size
            # 更新后，手動將梯度清零
            param.grad.zero_()

# 示例：假設(shè)我們有梯度
w.grad = torch.tensor([[0.1], [0.2]])
b.grad = torch.tensor([0.05])
lr = 0.03

print(f"更新前 w: {w.flatten()}")
print(f"更新前 b: {b.item()}")

sgd([w, b], lr, 10)

print(f"更新后 w: {w.flatten()}")
print(f"更新后 b: {b.item()}")

import random

def data_iter(batch_size, features, labels):
    """
    生成小批量數(shù)據(jù)的迭代器
    """
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices)  # 打亂樣本順序
    
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i: min(i + batch_size, num_examples)]
        )
        yield features[batch_indices], labels[batch_indices]

# 超參數(shù)設(shè)置
lr = 0.03        # 學(xué)習(xí)率
num_epochs = 5   # 訓(xùn)練輪數(shù)
batch_size = 10  # 批量大小

# 重新初始化參數(shù)
w = torch.normal(0, 0.01, size=(num_inputs, 1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

# 開始訓(xùn)練
print("=" * 60)
print("開始訓(xùn)練線性回歸模型...")
print("=" * 60)

for epoch in range(num_epochs):
    for X_batch, y_batch in data_iter(batch_size, X, y):
        # 1. 前向傳播：計(jì)算預(yù)測值
        y_hat = linreg(X_batch, w, b)
        
        # 2. 計(jì)算損失
        loss = squared_loss(y_hat, y_batch).mean()
        
        # 3. 反向傳播：計(jì)算梯度
        loss.backward()
        
        # 4. 更新參數(shù)
        sgd([w, b], lr, batch_size)
    
    # 每個epoch結(jié)束后，計(jì)算在整個數(shù)據(jù)集上的平均損失
    with torch.no_grad():
        train_loss = squared_loss(linreg(X, w, b), y).mean()
        print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {train_loss:.6f}')

# 訓(xùn)練結(jié)束，查看學(xué)習(xí)到的參數(shù)
print("\n" + "=" * 60)
print("訓(xùn)練完成！模型參數(shù)對比：")
print("=" * 60)
print(f'真實(shí)的權(quán)重 w: {true_w.flatten().numpy()}')
print(f'學(xué)到的權(quán)重 w: {w.detach().flatten().numpy()}')
print(f'權(quán)重誤差: {((w - true_w).abs() / true_w.abs()).mean().item():.4%}')
print()
print(f'真實(shí)的偏置 b: {true_b:.4f}')
print(f'學(xué)到的偏置 b: {b.item():.4f}')
print(f'偏置誤差: {abs(b.item() - true_b) / abs(true_b):.4%}')

============================================================
開始訓(xùn)練線性回歸模型...
============================================================
Epoch 1/5, Loss: 0.042567
Epoch 2/5, Loss: 0.000152
Epoch 3/5, Loss: 0.000058
Epoch 4/5, Loss: 0.000051
Epoch 5/5, Loss: 0.000050

============================================================
訓(xùn)練完成！模型參數(shù)對比：
============================================================
真實(shí)的權(quán)重 w: [ 2.  -3.4]
學(xué)到的權(quán)重 w: [ 1.9998 -3.3995]
權(quán)重誤差: 0.0123%
真實(shí)的偏置 b: 4.2000
學(xué)到的偏置 b: 4.1998
偏置誤差: 0.0048%

import torch.nn as nn

class LinearRegressionModel(nn.Module):
    def __init__(self, input_dim):
        super(LinearRegressionModel, self).__init__()
        # 定義線性層
        self.linear = nn.Linear(input_dim, 1)
    
    def forward(self, x):
        # 前向傳播
        return self.linear(x)

# 創(chuàng)建模型
model = LinearRegressionModel(num_inputs)
print(model)
print(f"\n模型參數(shù):")
for name, param in model.named_parameters():
    print(f"  {name}: {param.shape}")

LinearRegressionModel(
  (linear): Linear(in_features=2, out_features=1, bias=True)
)

模型參數(shù):
  linear.weight: torch.Size([1, 2])
  linear.bias: torch.Size([1])

# 定義損失函數(shù)
criterion = nn.MSELoss()

# 定義優(yōu)化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.03)

# 訓(xùn)練循環(huán)
num_epochs = 5
for epoch in range(num_epochs):
    for X_batch, y_batch in data_iter(batch_size, X, y):
        # 前向傳播
        y_pred = model(X_batch)
        
        # 計(jì)算損失
        loss = criterion(y_pred, y_batch)
        
        # 反向傳播
        optimizer.zero_grad()  # 梯度清零
        loss.backward()        # 計(jì)算梯度
        
        # 更新參數(shù)
        optimizer.step()
    
    # 打印訓(xùn)練進(jìn)度
    if (epoch + 1) % 1 == 0:
        with torch.no_grad():
            y_pred = model(X)
            epoch_loss = criterion(y_pred, y).item()
            print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.6f}')

# 查看學(xué)習(xí)到的參數(shù)
print("\n學(xué)到的參數(shù):")
print(f"w: {model.linear.weight.data.numpy()}")
print(f"b: {model.linear.bias.item()}")

from torch.utils.data import TensorDataset, DataLoader

# 創(chuàng)建數(shù)據(jù)集
dataset = TensorDataset(X, y)

# 創(chuàng)建數(shù)據(jù)加載器
data_loader = DataLoader(
    dataset=dataset,
    batch_size=batch_size,
    shuffle=True,      # 每個epoch打亂數(shù)據(jù)
    num_workers=0      # 數(shù)據(jù)加載的子進(jìn)程數(shù)
)

# 使用 DataLoader 訓(xùn)練
model = LinearRegressionModel(num_inputs)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(num_epochs):
    for X_batch, y_batch in data_loader:
        y_pred = model(X_batch)
        loss = criterion(y_pred, y_batch)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    if (epoch + 1) % 1 == 0:
        with torch.no_grad():
            y_pred = model(X)
            epoch_loss = criterion(y_pred, y).item()
            print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.6f}')

import matplotlib.pyplot as plt

# 記錄訓(xùn)練過程
train_losses = []
model = LinearRegressionModel(num_inputs)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(20):
    epoch_loss = 0
    for X_batch, y_batch in data_loader:
        y_pred = model(X_batch)
        loss = criterion(y_pred, y_batch)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        epoch_loss += loss.item()
    
    avg_loss = epoch_loss / len(data_loader)
    train_losses.append(avg_loss)

# 繪制損失曲線
plt.figure(figsize=(10, 6))
plt.plot(range(1, len(train_losses) + 1), train_losses, marker='o')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss Curve')
plt.grid(True)
plt.savefig('training_loss.png', dpi=300, bbox_inches='tight')
plt.show()

# 預(yù)測結(jié)果可視化
with torch.no_grad():
    y_pred = model(X).numpy()
    
plt.figure(figsize=(10, 6))
plt.scatter(y.numpy(), y_pred, alpha=0.5)
plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--')
plt.xlabel('True Values')
plt.ylabel('Predictions')
plt.title('True vs Predicted Values')
plt.grid(True)
plt.savefig('predictions.png', dpi=300, bbox_inches='tight')
plt.show()

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score

# 生成模擬房價數(shù)據(jù)
np.random.seed(42)
n_samples = 1000

data = {
    'area': np.random.uniform(50, 200, n_samples),        # 面積
    'rooms': np.random.randint(1, 6, n_samples),          # 房間數(shù)
    'age': np.random.uniform(0, 30, n_samples),           # 房齡
    'distance_to_center': np.random.uniform(1, 20, n_samples)  # 距離市中心
}

# 生成價格
data['price'] = (
    1.5 * data['area'] +          # 面積系數(shù)
    10 * data['rooms'] +          # 房間數(shù)系數(shù)
    -0.8 * data['age'] +          # 房齡系數(shù)
    -2 * data['distance_to_center'] +  # 距離系數(shù)
    50 +                          # 基礎(chǔ)價格
    np.random.normal(0, 20, n_samples)  # 噪聲
)

df = pd.DataFrame(data)

# 特征和標(biāo)簽
X = df[['area', 'rooms', 'age', 'distance_to_center']].values
y = df['price'].values.reshape(-1, 1)

# 劃分訓(xùn)練集和測試集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 特征標(biāo)準(zhǔn)化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 轉(zhuǎn)換為PyTorch張量
X_train_tensor = torch.FloatTensor(X_train_scaled)
y_train_tensor = torch.FloatTensor(y_train)
X_test_tensor = torch.FloatTensor(X_test_scaled)
y_test_tensor = torch.FloatTensor(y_test)

# 創(chuàng)建數(shù)據(jù)加載器
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
train_loader = DataLoader(dataset=train_dataset, batch_size=32, shuffle=True)

# 定義模型
class HousePriceModel(nn.Module):
    def __init__(self, input_dim):
        super(HousePriceModel, self).__init__()
        self.linear = nn.Linear(input_dim, 1)
    
    def forward(self, x):
        return self.linear(x)

model = HousePriceModel(X_train_scaled.shape[1])
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 訓(xùn)練
num_epochs = 100
for epoch in range(num_epochs):
    for X_batch, y_batch in train_loader:
        y_pred = model(X_batch)
        loss = criterion(y_pred, y_batch)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

# 評估
model.eval()
with torch.no_grad():
    y_pred_train = model(X_train_tensor).numpy()
    y_pred_test = model(X_test_tensor).numpy()
    
    train_rmse = np.sqrt(mean_squared_error(y_train, y_pred_train))
    test_rmse = np.sqrt(mean_squared_error(y_test, y_pred_test))
    train_r2 = r2_score(y_train, y_pred_train)
    test_r2 = r2_score(y_test, y_pred_test)
    
    print(f"訓(xùn)練集 RMSE: {train_rmse:.2f} (萬元)")
    print(f"測試集 RMSE: {test_rmse:.2f} (萬元)")
    print(f"訓(xùn)練集 R2: {train_r2:.4f}")
    print(f"測試集 R2: {test_r2:.4f}")

# 模擬股票數(shù)據(jù)
dates = pd.date_range('2023-01-01', periods=365, freq='D')
np.random.seed(42)

stock_data = {
    'date': dates,
    'open': np.random.uniform(100, 150, 365),
    'high': np.random.uniform(105, 155, 365),
    'low': np.random.uniform(95, 145, 365),
    'volume': np.random.uniform(1000000, 5000000, 365),
    'close': np.random.uniform(100, 150, 365) + np.random.normal(0, 2, 365)
}

stock_df = pd.DataFrame(stock_data)
stock_df['return'] = stock_df['close'].pct_change()  # 日收益率
stock_df = stock_df.dropna()

print("股票數(shù)據(jù)示例:")
print(stock_df.head())
print(f"\n數(shù)據(jù)集形狀: {stock_df.shape}")

# 模擬醫(yī)療數(shù)據(jù)
n_patients = 1000
medical_data = {
    'age': np.random.randint(18, 80, n_patients),
    'bmi': np.random.uniform(18, 40, n_patients),
    'smoker': np.random.choice([0, 1], n_patients, p=[0.8, 0.2]),
    'children': np.random.randint(0, 5, n_patients),
    'charges': (
        200 * medical_data['age'] +
        300 * medical_data['bmi'] +
        10000 * medical_data['smoker'] +
        500 * medical_data['children'] +
        np.random.normal(0, 2000, n_patients)
    )
}

medical_df = pd.DataFrame(medical_data)

print("醫(yī)療數(shù)據(jù)統(tǒng)計(jì):")
print(f"吸煙者平均費(fèi)用: {medical_df[medical_df['smoker']==1]['charges'].mean():.2f}")
print(f"非吸煙者平均費(fèi)用: {medical_df[medical_df['smoker']==0]['charges'].mean():.2f}")
print(f"費(fèi)用標(biāo)準(zhǔn)差: {medical_df['charges'].std():.2f}")

# 模擬生產(chǎn)數(shù)據(jù)
n_samples = 500
production_data = {
    'temperature': np.random.uniform(150, 250, n_samples),
    'pressure': np.random.uniform(5, 15, n_samples),
    'time': np.random.uniform(10, 60, n_samples),
    'speed': np.random.uniform(50, 150, n_samples),
    'quality': (
        0.3 * production_data['temperature'] +
        0.5 * production_data['pressure'] +
        0.2 * production_data['time'] -
        0.1 * production_data['speed'] +
        50 + np.random.normal(0, 5, n_samples)
    )
}

prod_df = pd.DataFrame(production_data)

# 找出最優(yōu)參數(shù)組合
optimal_params = {
    'temperature': prod_df.loc[prod_df['quality'].idxmax(), 'temperature'],
    'pressure': prod_df.loc[prod_df['quality'].idxmax(), 'pressure'],
    'time': prod_df.loc[prod_df['quality'].idxmax(), 'time'],
    'speed': prod_df.loc[prod_df['quality'].idxmax(), 'speed'],
    'quality': prod_df['quality'].max()
}

print("最優(yōu)生產(chǎn)參數(shù):")
for k, v in optimal_params.items():
    print(f"  {k}: {v:.2f}")

# 不同學(xué)習(xí)率對比
learning_rates = [0.001, 0.01, 0.03, 0.1, 0.3]
results = {}

for lr in learning_rates:
    model = LinearRegressionModel(num_inputs)
    optimizer = torch.optim.SGD(model.parameters(), lr=lr)
    criterion = nn.MSELoss()
    
    losses = []
    for epoch in range(20):
        epoch_loss = 0
        for X_batch, y_batch in data_loader:
            y_pred = model(X_batch)
            loss = criterion(y_pred, y_batch)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            epoch_loss += loss.item()
        
        losses.append(epoch_loss / len(data_loader))
    
    results[lr] = losses[-1]  # 記錄最終損失

print("不同學(xué)習(xí)率的最終損失:")
for lr, loss in results.items():
    print(f"  lr={lr:.3f}: {loss:.6f}")

batch_sizes = [4, 8, 16, 32, 64, 128]
results = {}

for bs in batch_sizes:
    data_loader = DataLoader(dataset=dataset, batch_size=bs, shuffle=True)
    model = LinearRegressionModel(num_inputs)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    criterion = nn.MSELoss()
    
    for epoch in range(10):
        for X_batch, y_batch in data_loader:
            y_pred = model(X_batch)
            loss = criterion(y_pred, y_batch)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
    with torch.no_grad():
        final_loss = criterion(model(X), y).item()
        results[bs] = final_loss

print("不同批量大小的最終損失:")
for bs, loss in results.items():
    print(f"  batch_size={bs}: {loss:.6f}")

# L2正則化（權(quán)重衰減）
model = LinearRegressionModel(num_inputs)
optimizer = torch.optim.SGD(
    model.parameters(), 
    lr=0.01, 
    weight_decay=0.01  # L2正則化系數(shù)
)
criterion = nn.MSELoss()

# 訓(xùn)練
for epoch in range(20):
    for X_batch, y_batch in data_loader:
        y_pred = model(X_batch)
        loss = criterion(y_pred, y_batch)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

print("L2正則化后的權(quán)重:")
print(f"w: {model.linear.weight.data.numpy()}")
print(f"權(quán)重范數(shù): {torch.norm(model.linear.weight).item():.4f}")

# 早停實(shí)現(xiàn)
class EarlyStopping:
    def __init__(self, patience=5, min_delta=0.001):
        self.patience = patience
        self.min_delta = min_delta
        self.counter = 0
        self.best_loss = None
        self.early_stop = False
    
    def __call__(self, val_loss):
        if self.best_loss is None:
            self.best_loss = val_loss
        elif val_loss > self.best_loss - self.min_delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_loss = val_loss
            self.counter = 0
        
        return self.early_stop

# 模型保存與加載
model = LinearRegressionModel(num_inputs)
torch.save(model.state_dict(), 'linear_model.pth')

# 加載模型
model_loaded = LinearRegressionModel(num_inputs)
model_loaded.load_state_dict(torch.load('linear_model.pth'))
model_loaded.eval()

# 1. 檢查學(xué)習(xí)率是否合適
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # 嘗試更小的學(xué)習(xí)率

# 2. 檢查數(shù)據(jù)是否標(biāo)準(zhǔn)化
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. 檢查梯度是否正常
for name, param in model.named_parameters():
    print(f"{name} gradient norm: {param.grad.norm().item()}")

# 1. 使用正則化
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.01)

# 2. 增加數(shù)據(jù)
# 3. 減少模型復(fù)雜度
# 4. 使用早停
early_stopping = EarlyStopping(patience=5)

# 檢查GPU可用性
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用設(shè)備: {device}")

# 將模型和數(shù)據(jù)移動到GPU
model = model.to(device)
X = X.to(device)
y = y.to(device)

# 訓(xùn)練時同樣在GPU上
for X_batch, y_batch in data_loader:
    X_batch = X_batch.to(device)
    y_batch = y_batch.to(device)
    
    y_pred = model(X_batch)
    loss = criterion(y_pred, y_batch)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

"""
PyTorch線性回歸完整實(shí)現(xiàn)
"""

import torch
import numpy as np
import random
import matplotlib.pyplot as plt
from torch.utils.data import TensorDataset, DataLoader

# ==================== 1. 數(shù)據(jù)生成 ====================
def generate_data(num_examples=1000, num_inputs=2, seed=42):
    """生成帶噪聲的線性數(shù)據(jù)"""
    torch.manual_seed(seed)
    np.random.seed(seed)
    
    true_w = torch.tensor([[2.0], [-3.4]])
    true_b = 4.2
    
    X = torch.normal(0, 1, (num_examples, num_inputs))
    noise = torch.normal(0, 0.01, (num_examples, 1))
    y = torch.matmul(X, true_w) + true_b + noise
    
    return X, y, true_w, true_b

# ==================== 2. 數(shù)據(jù)迭代器 ====================
def data_iter(batch_size, features, labels):
    """生成小批量數(shù)據(jù)"""
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices)
    
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i: min(i + batch_size, num_examples)]
        )
        yield features[batch_indices], labels[batch_indices]

# ==================== 3. 模型定義 ====================
def linreg(X, w, b):
    """線性回歸模型"""
    return torch.matmul(X, w) + b

# ==================== 4. 損失函數(shù) ====================
def squared_loss(y_hat, y):
    """均方損失函數(shù)"""
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

# ==================== 5. 優(yōu)化器 ====================
def sgd(params, lr, batch_size):
    """小批量隨機(jī)梯度下降"""
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()

# ==================== 6. 訓(xùn)練函數(shù) ====================
def train_linear_regression(
    X, y, true_w, true_b,
    lr=0.03, num_epochs=5, batch_size=10
):
    """訓(xùn)練線性回歸模型"""
    num_inputs = X.shape[1]
    
    # 初始化參數(shù)
    w = torch.normal(0, 0.01, size=(num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    
    losses = []
    
    print("開始訓(xùn)練...")
    print("=" * 60)
    
    for epoch in range(num_epochs):
        for X_batch, y_batch in data_iter(batch_size, X, y):
            # 前向傳播
            y_hat = linreg(X_batch, w, b)
            
            # 計(jì)算損失
            loss = squared_loss(y_hat, y_batch).mean()
            
            # 反向傳播
            loss.backward()
            
            # 更新參數(shù)
            sgd([w, b], lr, batch_size)
        
        # 計(jì)算epoch損失
        with torch.no_grad():
            epoch_loss = squared_loss(linreg(X, w, b), y).mean().item()
            losses.append(epoch_loss)
            print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {epoch_loss:.6f}')
    
    # 評估結(jié)果
    print("\n" + "=" * 60)
    print("訓(xùn)練完成！")
    print("=" * 60)
    print(f'真實(shí)權(quán)重: {true_w.flatten().numpy()}')
    print(f'學(xué)到權(quán)重: {w.detach().flatten().numpy()}')
    print(f'權(quán)重相對誤差: {((w - true_w).abs() / true_w.abs()).mean().item():.4%}')
    print()
    print(f'真實(shí)偏置: {true_b:.4f}')
    print(f'學(xué)到偏置: {b.item():.4f}')
    print(f'偏置相對誤差: {abs(b.item() - true_b) / abs(true_b):.4%}')
    
    return w, b, losses

# ==================== 7. 主函數(shù) ====================
def main():
    # 生成數(shù)據(jù)
    X, y, true_w, true_b = generate_data()
    
    # 訓(xùn)練模型
    w, b, losses = train_linear_regression(X, y, true_w, true_b)
    
    # 可視化損失曲線
    plt.figure(figsize=(10, 6))
    plt.plot(range(1, len(losses) + 1), losses, marker='o')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.title('Training Loss Curve')
    plt.grid(True)
    plt.savefig('training_loss.png', dpi=300, bbox_inches='tight')
    plt.show()

if __name__ == "__main__":
    main()