福利一区福利二区秒拍,最新视频-88av,www.狠狠撸.com

LeNet 的核心分成兩部分：卷積層塊和全連接層塊。

1.?卷積層塊
- ? 卷積層：通過小窗口（卷積核）掃描圖片，找到局部特征，比如邊緣、角點等。LeNet 的卷積核大小固定是 5×5，卷積后通過 sigmoid 激活函數 加入非線性。
- ? 池化層：使用 2×2 的窗口做 最大池化，這可以減少每層輸出的大小，同時保留關鍵特征。它還增加了對位置變化的“免疫力”，比如圖片稍微移動，不會影響結果太多。
- ? 它主要由 卷積層 和 池化層 組成。這部分的作用就是“縮小圖片，提煉信息”。
- ? LeNet 的卷積塊有兩次這樣的組合，第一個卷積層輸出 6 個通道，第二個卷積層輸出 16 個通道。
2.?全連接層塊
- ? 卷積層的輸出先展平為一維向量，類似“攤平”處理。
- ? 接著經過三層全連接網絡，單元數分別是 120、84 和類別數（比如 10 類）。
- ? 最后一層沒有激活函數，直接輸出分類概率。
- ??這一塊就像傳統的神經網絡，負責“最后一公里”，也就是把卷積層提取的特征和最終分類結果聯系起來。

3. 按層拆解：從輸入到輸出的過程

假設我們輸入的圖片大小是 32×32 的灰度圖，LeNet 每層的輸出形狀如下：

? 輸入圖像：1x28x28（1 表示單通道的灰度圖像）
? 第 1 卷積層：6 個 5×5卷積核后，輸出大小是6x28x28。這一步提取了圖片中的局部特征，比如邊緣。
? 第 1 池化層：2×2 的最大池化，輸出大小變為 6x14x14。池化減少了尺寸，但保留了關鍵特征。
? 第 2 卷積層：16 個 5×5 卷積核，輸出大小是 16×10 x10)。這層進一步提取更復雜的特征，比如局部形狀。
? 第 2 池化層：再次做 2 x2 的最大池化，輸出大小變為 16x5x5。
? 展平：將 16x5x5 展平為一維向量。
? 全連接層 1：120 個神經元，輸出大小為 1×120。
? 全連接層 2：84 個神經元，輸出大小為 1×84。
? 輸出層：根據分類任務（比如 10 個類別），輸出大小為 1×10。

4. 代碼實現 LeNet

接下來，我們用 MXNet 框架來實現 LeNet，看看它的每一層是如何工作的：

from mxnet.gluon import nn

from mxnet import nd



# 定義 LeNet 網絡

net = nn.Sequential()

net.add(

    nn.Conv2D(channels=6, kernel_size=5, activation='sigmoid'),

    nn.MaxPool2D(pool_size=2, strides=2),

    nn.Conv2D(channels=16, kernel_size=5, activation='sigmoid'),

    nn.MaxPool2D(pool_size=2, strides=2),

    nn.Dense(120, activation='sigmoid'),

    nn.Dense(84, activation='sigmoid'),

    nn.Dense(10)

)



# 初始化網絡

net.initialize()



# 測試網絡

X = nd.random.uniform(shape=(1,1,28,28))# 輸入一張隨機圖片

for layer in net:

    X = layer(X)

print(f"{layer.name} output shape: {X.shape}")

運行結果類似這樣：

conv0 output shape: (1,6,24,24)

pool0 output shape:(1,6,12,12)

conv1 output shape:(1,16,8,8)

pool1 output shape:(1,16,4,4)

dense0 output shape:(1,120)

dense1 output shape:(1,84)

dense2 output shape:(1,10)

5. 實戰：訓練 LeNet

我們用 Fashion-MNIST 數據集（類似 MNIST，但更復雜）來訓練 LeNet。

from mxnet import gluon, autograd, init

from mxnet.gluon import loss as gloss,Trainer

import time



# 加載數據

batch_size =256

train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)



# 定義訓練函數

def train_ch5(net, train_iter, test_iter, batch_size, trainer, ctx, num_epochs):

    loss = gloss.SoftmaxCrossEntropyLoss()

    for epoch inrange(num_epochs):

        train_l_sum, train_acc_sum, n, start =0.0,0.0,0, time.time()

        for X, y in train_iter:

            X, y = X.as_in_context(ctx), y.as_in_context(ctx)

            with autograd.record():

                y_hat = net(X)

                l = loss(y_hat, y).sum()

            l.backward()

            trainer.step(batch_size)

            train_l_sum += l.asscalar()

            train_acc_sum +=(y_hat.argmax(axis=1)== y).sum().asscalar()

            n += y.size

        test_acc = evaluate_accuracy(test_iter, net, ctx)

    print(f"epoch {epoch+1}, loss {train_l_sum/n:.4f}, train acc {train_acc_sum/n:.3f}, test acc {test_acc:.3f}, time {time.time()-start:.1f} sec")



# 初始化并訓練

ctx = d2l.try_gpu()

net.initialize(force_reinit=True, ctx=ctx, init=init.Xavier())

trainer =Trainer(net.collect_params(),'sgd',{'learning_rate':0.9})

train_ch5(net, train_iter, test_iter, batch_size, trainer, ctx,5)

6. LeNet 表現如何？能改進嗎？

在 Fashion-MNIST 上，LeNet 的初始準確率可能不太高，但隨著訓練，最終可以達到 70%-75% 的測試準確率。這對于一個早期設計的網絡來說已經不錯了！

如果要進一步提升：

? 換激活函數：用 ReLU 代替 Sigmoid，計算效率和性能更高。
? 增加層數或通道數：比如多加幾層卷積或全連接層。
? 優化算法：嘗試 Adam、RMSProp 等更先進的優化器。
??數據增強：對輸入圖片做旋轉、裁剪等增強操作，提高模型的泛化能力。

簡單點說，LeNet 是一個很棒的起點，但我們可以在它的基礎上玩出很多花樣，構建更強大的模型！

接下來再來講講深度學習的里程碑模型AlexNet。

在 2012 年之前，計算機視覺主要依賴于手工設計的特征，如 SIFT、HOG 等。

然而，這種方法需要大量的經驗和試驗，且在面對復雜數據時難以擴展。AlexNet 的出現徹底改變了這一局面，它證明了端到端學習的深度神經網絡能夠在復雜任務上超越傳統方法，成為深度學習歷史上的重要里程碑。

早期的神經網絡，如 LeNet，雖然在小數據集（如 MNIST）上表現出色，但受限于計算資源和數據規模，在更復雜的任務中難以超越其他機器學習方法（如支持向量機）。下面就是兩個比較關鍵的問題：

1.?數據規模限制：早期數據集往往規模較小，模型難以學習到豐富的特征。
2.?計算能力不足：復雜網絡需要強大的硬件支持，而 90 年代的計算能力不足以支持深層模型。

隨著ImageNet 數據集和GPU 的廣泛應用，這兩個限制逐漸被突破，為 AlexNet 的成功奠定了基礎。

AlexNet

AlexNet 的核心特點

AlexNet 的設計與 LeNet 類似，但在以下方面進行了顯著改進：

1.?更多的層數和參數
- ? AlexNet 包含 8 層網絡（5 個卷積層和 3 個全連接層），相比 LeNet 更加深層。
- ? 大幅增加了卷積通道數和全連接層節點數，用以處理更大的 ImageNet 數據集。
2.?ReLU 激活函數
- ? AlexNet 使用 ReLU 激活函數取代了 sigmoid。
- ? 優點：計算簡單，避免梯度消失問題，加速了模型的訓練。
3.?丟棄法（Dropout）
- ? 在全連接層引入丟棄法，隨機屏蔽部分神經元以減少過擬合。
4.?數據增強
- ??通過翻轉、裁剪和顏色變化擴展數據規模，提高模型的泛化能力。
5.?使用 GPU 加速
- ? 采用雙 GPU 訓練，解決了顯存不足的問題。

AlexNet 的代碼實現

模型結構

以下代碼展示了 AlexNet 的網絡結構。

from mxnet.gluon import nn



net = nn.Sequential()



# 第一層：卷積 + 最大池化

net.add(nn.Conv2D(96, kernel_size=11, strides=4, activation='relu'),

        nn.MaxPool2D(pool_size=3, strides=2))



# 第二層：卷積 + 最大池化

net.add(nn.Conv2D(256, kernel_size=5, padding=2, activation='relu'),

        nn.MaxPool2D(pool_size=3, strides=2))



# 第三到第五層：連續卷積

net.add(nn.Conv2D(384, kernel_size=3, padding=1, activation='relu'),

        nn.Conv2D(384, kernel_size=3, padding=1, activation='relu'),

        nn.Conv2D(256, kernel_size=3, padding=1, activation='relu'),

        nn.MaxPool2D(pool_size=3, strides=2))



# 全連接層：帶丟棄法

net.add(nn.Dense(4096, activation="relu"), nn.Dropout(0.5),

        nn.Dense(4096, activation="relu"), nn.Dropout(0.5),

        nn.Dense(10))  # 輸出層，10 個類別（用于 Fashion-MNIST 數據集）

輸出形狀分析

通過給定一個高和寬為 224 的輸入圖像，我們可以觀察每一層的輸出形狀。

from mxnet import nd



X = nd.random.uniform(shape=(1, 1, 224, 224))

net.initialize()



for layer in net:

    X = layer(X)

    print(layer.name, 'output shape:\t', X.shape)

輸出示例：

conv0 output shape: (1,96,54,54)

pool0 output shape:(1,96,26,26)

conv1 output shape:(1,256,26,26)

pool1 output shape:(1,256,12,12)

...

dense2 output shape:(1,10)

數據準備

AlexNet 原本使用 ImageNet 數據集，但由于訓練時間較長，我們使用 Fashion-MNIST 數據集來演示。以下代碼將圖像的大小調整為 224×224。

from mxnet.gluon.data.vision import transforms

from mxnet.gluon.data import DataLoader

from mxnet.gluon.data.vision import FashionMNIST



def load_data_fashion_mnist(batch_size, resize=None):

    transformer =[]

    if resize:

        transformer.append(transforms.Resize(resize))

    transformer.append(transforms.ToTensor())

    transformer = transforms.Compose(transformer)



    train_set =FashionMNIST(train=True).transform_first(transformer)

    test_set =FashionMNIST(train=False).transform_first(transformer)



    train_loader =DataLoader(train_set, batch_size, shuffle=True, num_workers=4)

    test_loader =DataLoader(test_set, batch_size, shuffle=False, num_workers=4)



    return train_loader, test_loader



batch_size =128

train_iter, test_iter = load_data_fashion_mnist(batch_size, resize=224)

模型訓練

以下代碼展示了如何訓練 AlexNet，并輸出訓練和測試的準確率。

from mxnet import gluon, init

from mxnet.gluon import Trainer

from mxnet.gluon.loss import SoftmaxCrossEntropyLoss

from d2l import mxnet as d2l



# 定義訓練函數

def train_ch5(net, train_iter, test_iter, batch_size, trainer, num_epochs):

    loss =SoftmaxCrossEntropyLoss()

    for epoch inrange(num_epochs):

        train_loss, train_acc, n =0,0,0

        for X, y in train_iter:

            X, y = X.as_in_context(ctx), y.as_in_context(ctx)

            with autograd.record():

                y_hat = net(X)

                l = loss(y_hat, y)

            l.backward()

            trainer.step(batch_size)

            train_loss += l.sum().asscalar()

            train_acc +=(y_hat.argmax(axis=1)== y.astype('float32')).sum().asscalar()

            n += y.size

        test_acc = evaluate_accuracy(test_iter, net, ctx)

    print(f"epoch {epoch + 1}, loss {train_loss/n:.4f}, train acc {train_acc/n:.3f}, test acc {test_acc:.3f}")



# 初始化模型和訓練參數

ctx, lr, num_epochs = d2l.try_gpu(),0.01,5

net.initialize(init=init.Xavier(), ctx=ctx)

trainer =Trainer(net.collect_params(),'sgd',{'learning_rate': lr})



# 開始訓練

train_ch5(net, train_iter, test_iter, batch_size, trainer, num_epochs)