chore(i18n): sync translations with latest source changes (chunk 8/8, 60 changes)
This commit is contained in:
localizeflow[bot]
parent
59764fe4f7
commit
fea04feb77
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,179 @@
|
|||
# 物件偵測
|
||||
|
||||
我們之前處理的影像分類模型，通常是輸入一張圖片並產生一個分類結果，例如在 MNIST 問題中得到「數字」這個類別。然而，在許多情況下，我們不僅僅想知道圖片中有物件存在，我們還希望能夠確定它們的精確位置。這正是**物件偵測**的目的。
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/21)
|
||||
|
||||
|
||||
|
||||
> 圖片來源：[YOLO v2 網站](https://pjreddie.com/darknet/yolov2/)
|
||||
|
||||
## 一個簡單的物件偵測方法
|
||||
|
||||
假設我們想在一張圖片中找到一隻貓，一個非常簡單的物件偵測方法可能如下：
|
||||
|
||||
1. 將圖片分割成多個小區塊。
|
||||
2. 對每個區塊進行影像分類。
|
||||
3. 對於分類結果有足夠高信心的區塊，可以認為包含目標物件。
|
||||
|
||||
|
||||
|
||||
> *圖片來源：[練習筆記本](ObjectDetection-TF.ipynb)*
|
||||
|
||||
然而，這種方法並不理想，因為它只能非常粗略地定位物件的邊界框。為了更精確地定位，我們需要進行某種**回歸**來預測邊界框的座標，而這需要特定的數據集。
|
||||
|
||||
## 用回歸進行物件偵測
|
||||
|
||||
[這篇部落格文章](https://towardsdatascience.com/object-detection-with-neural-networks-a4e2c46b4491)提供了一個非常好的入門指南，介紹如何偵測形狀。
|
||||
|
||||
## 物件偵測的數據集
|
||||
|
||||
在進行物件偵測時，你可能會遇到以下數據集：
|
||||
|
||||
* [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) - 包含 20 個類別
|
||||
* [COCO](http://cocodataset.org/#home) - 常見物件的上下文。包含 80 個類別、邊界框和分割遮罩
|
||||
|
||||
|
||||
|
||||
## 物件偵測的評估指標
|
||||
|
||||
### 交集比聯集 (Intersection over Union, IoU)
|
||||
|
||||
在影像分類中，衡量算法表現相對簡單；但在物件偵測中，我們需要同時衡量類別的正確性以及推測邊界框位置的精確性。對於後者，我們使用所謂的**交集比聯集** (IoU)，它衡量兩個框（或任意兩個區域）的重疊程度。
|
||||
|
||||
|
||||
|
||||
> *圖片來源：[這篇優秀的 IoU 部落格文章](https://pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/)*
|
||||
|
||||
概念很簡單——將兩個圖形的交集面積除以它們的聯集面積。對於完全相同的區域，IoU 值為 1；而對於完全不相交的區域，IoU 值為 0。其他情況下，IoU 值介於 0 到 1 之間。我們通常只考慮 IoU 超過某個值的邊界框。
|
||||
|
||||
### 平均精度 (Average Precision, AP)
|
||||
|
||||
假設我們想衡量某個類別 $C$ 的物件被識別的效果。為了衡量這一點，我們使用**平均精度**指標，其計算方式如下：
|
||||
|
||||
1. 考慮精度-召回曲線，顯示檢測閾值（從 0 到 1）對準確性的影響。
|
||||
2. 根據閾值，我們會在圖片中檢測到更多或更少的物件，並得到不同的精度和召回值。
|
||||
3. 曲線看起來如下：
|
||||
|
||||
<img src="https://github.com/shwars/NeuroWorkshop/raw/master/images/ObjDetectionPrecisionRecall.png"/>
|
||||
|
||||
> *圖片來源：[NeuroWorkshop](http://github.com/shwars/NeuroWorkshop)*
|
||||
|
||||
給定類別 $C$ 的平均精度是該曲線下的面積。更精確地說，召回軸通常分為 10 部分，精度在所有這些點上取平均值：
|
||||
|
||||
$$
|
||||
AP = {1\over11}\sum_{i=0}^{10}\mbox{Precision}(\mbox{Recall}={i\over10})
|
||||
$$
|
||||
|
||||
### AP 和 IoU
|
||||
|
||||
我們只考慮那些 IoU 超過某個值的檢測。例如，在 PASCAL VOC 數據集中，通常假設 $\mbox{IoU Threshold} = 0.5$，而在 COCO 中，AP 是針對不同的 $\mbox{IoU Threshold}$ 值進行測量的。
|
||||
|
||||
<img src="https://github.com/shwars/NeuroWorkshop/raw/master/images/ObjDetectionPrecisionRecallIoU.png"/>
|
||||
|
||||
> *圖片來源：[NeuroWorkshop](http://github.com/shwars/NeuroWorkshop)*
|
||||
|
||||
### 平均平均精度 - mAP
|
||||
|
||||
物件偵測的主要指標稱為**平均平均精度** (Mean Average Precision, mAP)。它是所有物件類別的平均精度，有時也包括不同的 $\mbox{IoU Threshold}$。更詳細的 mAP 計算過程可以參考
|
||||
[這篇部落格文章](https://medium.com/@timothycarlen/understanding-the-map-evaluation-metric-for-object-detection-a07fe6962cf3)，以及[這裡的程式碼範例](https://gist.github.com/tarlen5/008809c3decf19313de216b9208f3734)。
|
||||
|
||||
## 不同的物件偵測方法
|
||||
|
||||
物件偵測算法主要分為兩大類：
|
||||
|
||||
* **區域提案網路** (Region Proposal Networks)（如 R-CNN、Fast R-CNN、Faster R-CNN）。主要思想是生成**感興趣區域** (ROI)，並對其進行 CNN 分析以尋找最大激活值。這與簡單方法有些相似，但 ROI 是以更聰明的方式生成的。這類方法的主要缺點是速度較慢，因為需要多次 CNN 分類器的運行。
|
||||
* **一次通過** (One-pass) 方法（如 YOLO、SSD、RetinaNet）。這些架構設計成一次性預測類別和 ROI。
|
||||
|
||||
### R-CNN: 基於區域的 CNN
|
||||
|
||||
[R-CNN](http://islab.ulsan.ac.kr/files/announcement/513/rcnn_pami.pdf) 使用[選擇性搜索](http://www.huppelen.nl/publications/selectiveSearchDraft.pdf)生成 ROI 區域的層次結構，然後通過 CNN 特徵提取器和 SVM 分類器來確定物件類別，並通過線性回歸確定*邊界框*座標。[官方論文](https://arxiv.org/pdf/1506.01497v1.pdf)
|
||||
|
||||
|
||||
|
||||
> *圖片來源：van de Sande et al. ICCV’11*
|
||||
|
||||
|
||||
|
||||
> *圖片來源：[這篇部落格](https://towardsdatascience.com/r-cnn-fast-r-cnn-faster-r-cnn-yolo-object-detection-algorithms-36d53571365e)*
|
||||
|
||||
### F-RCNN - 快速 R-CNN
|
||||
|
||||
這種方法與 R-CNN 類似，但區域是在卷積層應用後定義的。
|
||||
|
||||
|
||||
|
||||
> 圖片來源：[官方論文](https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/Girshick_Fast_R-CNN_ICCV_2015_paper.pdf)，[arXiv](https://arxiv.org/pdf/1504.08083.pdf)，2015
|
||||
|
||||
### Faster R-CNN
|
||||
|
||||
這種方法的主要思想是使用神經網路來預測 ROI，即所謂的*區域提案網路* (Region Proposal Network)。[論文](https://arxiv.org/pdf/1506.01497.pdf)，2016
|
||||
|
||||
|
||||
|
||||
> 圖片來源：[官方論文](https://arxiv.org/pdf/1506.01497.pdf)
|
||||
|
||||
### R-FCN: 基於區域的全卷積網路
|
||||
|
||||
這種算法比 Faster R-CNN 更快。主要思想如下：
|
||||
|
||||
1. 使用 ResNet-101 提取特徵。
|
||||
2. 特徵通過**位置敏感分數圖** (Position-Sensitive Score Map) 處理。每個類別 $C$ 的物件被分成 $k\times k$ 區域，我們訓練模型來預測物件的部分。
|
||||
3. 對於 $k\times k$ 區域中的每個部分，所有網路對物件類別進行投票，選擇投票最多的物件類別。
|
||||
|
||||
|
||||
|
||||
> 圖片來源：[官方論文](https://arxiv.org/abs/1605.06409)
|
||||
|
||||
### YOLO - You Only Look Once
|
||||
|
||||
YOLO 是一種即時的一次通過算法。主要思想如下：
|
||||
|
||||
* 將圖片分成 $S\times S$ 區域。
|
||||
* 對每個區域，**CNN** 預測 $n$ 個可能的物件、*邊界框*座標以及*信心值*=*概率* * IoU。
|
||||
|
||||
|
||||
|
||||
> 圖片來源：[官方論文](https://arxiv.org/abs/1506.02640)
|
||||
|
||||
### 其他算法
|
||||
|
||||
* RetinaNet: [官方論文](https://arxiv.org/abs/1708.02002)
|
||||
- [PyTorch 實現](https://pytorch.org/vision/stable/_modules/torchvision/models/detection/retinanet.html)
|
||||
- [Keras 實現](https://github.com/fizyr/keras-retinanet)
|
||||
- [RetinaNet 物件偵測](https://keras.io/examples/vision/retinanet/) 在 Keras 範例中
|
||||
* SSD (單次檢測器): [官方論文](https://arxiv.org/abs/1512.02325)
|
||||
|
||||
## ✍️ 練習：物件偵測
|
||||
|
||||
繼續學習以下筆記本：
|
||||
|
||||
[ObjectDetection.ipynb](ObjectDetection.ipynb)
|
||||
|
||||
## 結論
|
||||
|
||||
在這節課中，你快速瀏覽了各種物件偵測方法！
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
閱讀以下文章和筆記本，並嘗試使用 YOLO：
|
||||
|
||||
* [優秀的部落格文章](https://www.analyticsvidhya.com/blog/2018/12/practical-guide-object-detection-yolo-framewor-python/) 描述 YOLO
|
||||
* [官方網站](https://pjreddie.com/darknet/yolo/)
|
||||
* YOLO: [Keras 實現](https://github.com/experiencor/keras-yolo2)，[逐步筆記本](https://github.com/experiencor/basic-yolo-keras/blob/master/Yolo%20Step-by-Step.ipynb)
|
||||
* YOLO v2: [Keras 實現](https://github.com/experiencor/keras-yolo2)，[逐步筆記本](https://github.com/experiencor/keras-yolo2/blob/master/Yolo%20Step-by-Step.ipynb)
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/22)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
* [物件偵測](https://tjmachinelearning.com/lectures/1718/obj/) 作者：Nikhil Sardana
|
||||
* [物件偵測算法的良好比較](https://lilianweng.github.io/lil-log/2018/12/27/object-detection-part-4.html)
|
||||
* [深度學習物件偵測算法回顧](https://medium.com/comet-app/review-of-deep-learning-algorithms-for-object-detection-c1f3d437b852)
|
||||
* [物件偵測算法的逐步介紹](https://www.analyticsvidhya.com/blog/2018/10/a-step-by-step-introduction-to-the-basic-object-detection-algorithms-part-1/)
|
||||
* [Python 中 Faster R-CNN 的物件偵測實現](https://www.analyticsvidhya.com/blog/2018/11/implementation-faster-r-cnn-python-object-detection/)
|
||||
|
||||
## [作業：物件偵測](lab/README.md)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
# 使用 Hollywood Heads 資料集進行頭部檢測
|
||||
|
||||
來自 [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners) 的實驗作業。
|
||||
|
||||
## 任務
|
||||
|
||||
在監控攝影機的影片流中計算人數是一項重要的任務，這可以幫助我們估算商店的訪客數量、餐廳的繁忙時段等。為了解決這個任務，我們需要能夠從不同角度檢測出人類的頭部。為了訓練能夠檢測人類頭部的物件檢測模型，我們可以使用 [Hollywood Heads 資料集](https://www.di.ens.fr/willow/research/headdetection/)。
|
||||
|
||||
## 資料集
|
||||
|
||||
[Hollywood Heads 資料集](https://www.di.ens.fr/willow/research/headdetection/release/HollywoodHeads.zip) 包含 369,846 個人類頭部的標註，這些標註來自 224,740 幅好萊塢電影的影格。該資料集以 [PASCAL VOC](https://host.robots.ox.ac.uk/pascal/VOC/) 格式提供，其中每張圖片都有一個對應的 XML 描述檔案，格式如下：
|
||||
|
||||
```xml
|
||||
<annotation>
|
||||
<folder>HollywoodHeads</folder>
|
||||
<filename>mov_021_149390.jpeg</filename>
|
||||
<source>
|
||||
<database>HollywoodHeads 2015 Database</database>
|
||||
<annotation>HollywoodHeads 2015</annotation>
|
||||
<image>WILLOW</image>
|
||||
</source>
|
||||
<size>
|
||||
<width>608</width>
|
||||
<height>320</height>
|
||||
<depth>3</depth>
|
||||
</size>
|
||||
<segmented>0</segmented>
|
||||
<object>
|
||||
<name>head</name>
|
||||
<bndbox>
|
||||
<xmin>201</xmin>
|
||||
<ymin>1</ymin>
|
||||
<xmax>480</xmax>
|
||||
<ymax>263</ymax>
|
||||
</bndbox>
|
||||
<difficult>0</difficult>
|
||||
</object>
|
||||
<object>
|
||||
<name>head</name>
|
||||
<bndbox>
|
||||
<xmin>3</xmin>
|
||||
<ymin>4</ymin>
|
||||
<xmax>241</xmax>
|
||||
<ymax>285</ymax>
|
||||
</bndbox>
|
||||
<difficult>0</difficult>
|
||||
</object>
|
||||
</annotation>
|
||||
```
|
||||
|
||||
在這個資料集中，只有一種類別的物件 `head`，對於每個頭部，您可以獲取其邊界框的座標。您可以使用 Python 的相關函式庫來解析 XML，或者使用 [這個函式庫](https://pypi.org/project/pascal-voc/) 直接處理 PASCAL VOC 格式。
|
||||
|
||||
## 訓練物件檢測模型
|
||||
|
||||
您可以使用以下方法之一來訓練物件檢測模型：
|
||||
|
||||
* 使用 [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste) 和其 Python API，在雲端以程式化方式訓練模型。Custom Vision 無法使用超過幾百張圖片來訓練模型，因此您可能需要限制資料集的大小。
|
||||
* 使用 [Keras 教學範例](https://keras.io/examples/vision/retinanet/) 來訓練 RetunaNet 模型。
|
||||
* 使用 [torchvision.models.detection.RetinaNet](https://pytorch.org/vision/stable/_modules/torchvision/models/detection/retinanet.html) 中的內建模組進行訓練。
|
||||
|
||||
## 重點
|
||||
|
||||
物件檢測是業界中經常需要的任務。雖然有一些服務可以用來執行物件檢測（例如 [Azure Custom Vision](https://docs.microsoft.com/azure/cognitive-services/custom-vision-service/quickstarts/object-detection?tabs=visual-studio&WT.mc_id=academic-77998-cacaste)），但了解物件檢測的運作原理並能夠訓練自己的模型同樣重要。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
# 分割
|
||||
|
||||
我們之前學過物件偵測，它可以透過預測物件的*邊界框*來定位影像中的物件。然而，對於某些任務，我們不僅需要邊界框，還需要更精確的物件定位。這項任務被稱為**分割**。
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/23)
|
||||
|
||||
分割可以被視為**像素分類**，即對影像中的**每個**像素進行分類，並預測其所屬的類別（*背景*也是其中一個類別）。主要有兩種分割算法：
|
||||
|
||||
* **語義分割**僅告訴像素的類別，並不區分同一類別中的不同物件。
|
||||
* **實例分割**將類別分成不同的實例。
|
||||
|
||||
例如，在實例分割中，這些羊是不同的物件；但在語義分割中，所有的羊都被表示為同一類別。
|
||||
|
||||
<img src="../../../../../translated_images/zh-TW/instance_vs_semantic.eee9812bebf8cd45.webp" width="50%">
|
||||
|
||||
> 圖片來源：[這篇部落格文章](https://nirmalamurali.medium.com/image-classification-vs-semantic-segmentation-vs-instance-segmentation-625c33a08d50)
|
||||
|
||||
有許多不同的神經網路架構可用於分割，但它們的結構都相似。某種程度上，它類似於你之前學過的自編碼器，但我們的目標不是解構原始影像，而是解構一個**遮罩**。因此，分割網路包含以下部分：
|
||||
|
||||
* **編碼器**：從輸入影像中提取特徵。
|
||||
* **解碼器**：將這些特徵轉換為**遮罩影像**，其大小與通道數與類別數相對應。
|
||||
|
||||
<img src="../../../../../translated_images/zh-TW/segm.92442f2cb42ff4fa.webp" width="80%">
|
||||
|
||||
> 圖片來源：[這篇出版物](https://arxiv.org/pdf/2001.05566.pdf)
|
||||
|
||||
我們特別需要提到分割中使用的損失函數。在使用傳統自編碼器時，我們需要測量兩個影像之間的相似性，可以使用均方誤差（MSE）來完成。在分割中，目標遮罩影像中的每個像素代表類別編號（在第三維度上進行獨熱編碼），因此我們需要使用特定於分類的損失函數——交叉熵損失，並對所有像素進行平均。如果遮罩是二元的，則使用**二元交叉熵損失**（BCE）。
|
||||
|
||||
> ✅ 獨熱編碼是一種將類別標籤編碼為向量的方法，其向量長度等於類別數。可以參考[這篇文章](https://datagy.io/sklearn-one-hot-encode/)了解這項技術。
|
||||
|
||||
## 醫學影像中的分割
|
||||
|
||||
在本課中，我們將通過訓練網路來識別醫學影像中的人類痣（也稱為痣），以實現分割。我們將使用<a href="https://www.fc.up.pt/addi/ph2%20database.html">PH<sup>2</sup>資料庫</a>的皮膚鏡影像作為影像來源。該資料集包含200張影像，分為三類：典型痣、不典型痣和黑色素瘤。所有影像也包含相應的**遮罩**，用於勾勒痣的輪廓。
|
||||
|
||||
> ✅ 這項技術特別適合這類醫學影像，但你能想到其他現實世界中的應用嗎？
|
||||
|
||||
<img alt="navi" src="../../../../../translated_images/zh-TW/navi.2f20b727910110ea.webp"/>
|
||||
|
||||
> 圖片來源：PH<sup>2</sup>資料庫
|
||||
|
||||
我們將訓練一個模型，將任何痣從背景中分割出來。
|
||||
|
||||
## ✍️ 練習：語義分割
|
||||
|
||||
打開以下筆記本，了解不同的語義分割架構，練習使用它們，並觀察它們的實際效果。
|
||||
|
||||
* [語義分割 Pytorch](SemanticSegmentationPytorch.ipynb)
|
||||
* [語義分割 TensorFlow](SemanticSegmentationTF.ipynb)
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/24)
|
||||
|
||||
## 結論
|
||||
|
||||
分割是一種非常強大的影像分類技術，超越了邊界框，實現了像素級的分類。它在醫學影像等領域有著廣泛的應用。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
人體分割只是我們可以對人物影像進行的常見任務之一。其他重要任務包括**骨架偵測**和**姿勢偵測**。試試[OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose)庫，看看姿勢偵測的應用。
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
這篇[維基百科文章](https://wikipedia.org/wiki/Image_segmentation)提供了該技術各種應用的良好概述。自行學習實例分割和全景分割在該領域的子領域。
|
||||
|
||||
## [作業](lab/README.md)
|
||||
|
||||
在本次實驗中，使用 [Segmentation Full Body MADS Dataset](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) 資料集，嘗試進行**人體分割**。
|
||||
|
||||
---
|
||||
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,22 @@
|
|||
# 人體分割
|
||||
|
||||
來自 [AI 初學者課程](https://github.com/microsoft/ai-for-beginners) 的實驗作業。
|
||||
|
||||
## 任務
|
||||
|
||||
在視頻製作中，例如天氣預報，我們經常需要將攝像機拍攝的人像剪裁出來，並將其放置在其他畫面之上。這通常使用 **色鍵技術** 完成，當人像在一個統一顏色的背景前拍攝時，背景會被移除。在本次實驗中，我們將訓練一個神經網絡模型來剪裁出人像的輪廓。
|
||||
|
||||
## 數據集
|
||||
|
||||
我們將使用 [Segmentation Full Body MADS Dataset](https://www.kaggle.com/datasets/tapakah68/segmentation-full-body-mads-dataset) 來自 Kaggle。請手動從 Kaggle 下載該數據集。
|
||||
|
||||
## 起始筆記本
|
||||
|
||||
通過打開 [BodySegmentation.ipynb](../../../../../../lessons/4-ComputerVision/12-Segmentation/lab/BodySegmentation.ipynb) 開始本次實驗。
|
||||
|
||||
## 收穫
|
||||
|
||||
人體分割只是我們可以對人像圖像進行的常見任務之一。其他重要任務包括 **骨架檢測** 和 **姿勢檢測**。可以查看 [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) 庫，了解如何實現這些任務。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
# 電腦視覺
|
||||
|
||||
|
||||
|
||||
在本節中，我們將學習以下內容：
|
||||
|
||||
* [電腦視覺與 OpenCV 簡介](06-IntroCV/README.md)
|
||||
* [卷積神經網絡](07-ConvNets/README.md)
|
||||
* [預訓練網絡與遷移學習](08-TransferLearning/README.md)
|
||||
* [自編碼器](09-Autoencoders/README.md)
|
||||
* [生成對抗網絡](10-GANs/README.md)
|
||||
* [物體檢測](11-ObjectDetection/README.md)
|
||||
* [語義分割](12-Segmentation/README.md)
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。雖然我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵資訊，建議使用專業人工翻譯。我們對因使用此翻譯而產生的任何誤解或錯誤解釋不承擔責任。
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
# 將文本表示為張量
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/25)
|
||||
|
||||
## 文本分類
|
||||
|
||||
在本節的第一部分中，我們將專注於**文本分類**任務。我們將使用 [AG News](https://www.kaggle.com/amananandrai/ag-news-classification-dataset) 數據集，該數據集包含如下的新聞文章：
|
||||
|
||||
* 類別：科學/技術
|
||||
* 標題：Ky. 公司獲得研究肽類的資助 (AP)
|
||||
* 內容：AP - 一家由路易斯維爾大學的化學研究員創立的公司獲得了一筆資助，用於開發...
|
||||
|
||||
我們的目標是根據文本將新聞項目分類到某個類別中。
|
||||
|
||||
## 表示文本
|
||||
|
||||
如果我們想用神經網絡解決自然語言處理（NLP）任務，我們需要某種方式將文本表示為張量。計算機已經使用如 ASCII 或 UTF-8 等編碼將文本字符表示為對應螢幕字體的數字。
|
||||
|
||||
<img alt="顯示字符映射到 ASCII 和二進制表示的圖表" src="../../../../../translated_images/zh-TW/ascii-character-map.18ed6aa7f3b0a7ff.webp" width="50%"/>
|
||||
|
||||
> [圖片來源](https://www.seobility.net/en/wiki/ASCII)
|
||||
|
||||
作為人類，我們理解每個字母**代表**什麼，以及所有字符如何組合成句子的單詞。然而，計算機本身並不具備這種理解能力，神經網絡必須在訓練過程中學習這些含義。
|
||||
|
||||
因此，我們在表示文本時可以採用不同的方法：
|
||||
|
||||
* **字符級表示**：將文本表示為每個字符對應一個數字。假設文本語料庫中有 *C* 個不同的字符，那麼單詞 *Hello* 將被表示為一個 5x*C* 的張量。每個字母對應於一個使用 one-hot 編碼的張量列。
|
||||
* **單詞級表示**：我們創建一個包含文本中所有單詞的**詞彙表**，然後使用 one-hot 編碼表示單詞。這種方法更好一些，因為單個字母本身意義不大，而使用更高層次的語義概念（單詞）可以簡化神經網絡的任務。然而，由於詞彙表的規模龐大，我們需要處理高維稀疏張量。
|
||||
|
||||
無論採用哪種表示方式，我們首先需要將文本轉換為**標記**序列，每個標記可以是字符、單詞，甚至是單詞的一部分。接著，我們使用**詞彙表**將標記轉換為數字，然後可以通過 one-hot 編碼將這些數字輸入到神經網絡中。
|
||||
|
||||
## N-Grams
|
||||
|
||||
在自然語言中，單詞的確切含義只能在上下文中確定。例如，*neural network* 和 *fishing network* 的含義完全不同。考慮到這一點，我們可以基於單詞對來構建模型，並將單詞對視為單獨的詞彙標記。這樣，句子 *I like to go fishing* 將被表示為以下標記序列：*I like*、*like to*、*to go*、*go fishing*。這種方法的問題在於詞彙表的規模會顯著增長，並且像 *go fishing* 和 *go shopping* 這樣的組合會被表示為不同的標記，儘管它們具有相同的動詞，但語義上並無任何相似性。
|
||||
|
||||
在某些情況下，我們還可以考慮使用三元組（tri-grams）——即三個單詞的組合。因此，這種方法通常被稱為 **n-grams**。此外，使用字符級表示時，n-grams 通常大致對應於不同的音節。
|
||||
|
||||
## 詞袋模型（Bag-of-Words）和 TF/IDF
|
||||
|
||||
在解決文本分類等任務時，我們需要能夠將文本表示為一個固定大小的向量，作為最終密集分類器的輸入。最簡單的方法之一是將所有單詞的表示結合起來，例如通過相加。如果我們將每個單詞的 one-hot 編碼相加，最終會得到一個頻率向量，顯示每個單詞在文本中出現的次數。這種文本表示方法被稱為**詞袋模型**（BoW）。
|
||||
|
||||
<img src="../../../../../translated_images/zh-TW/bow.3811869cff59368d.webp" width="90%"/>
|
||||
|
||||
> 圖片由作者提供
|
||||
|
||||
詞袋模型本質上表示了哪些單詞出現在文本中以及它們的數量，這確實可以很好地反映文本的主題。例如，關於政治的新聞文章可能包含 *president* 和 *country* 等單詞，而科學出版物則可能包含 *collider*、*discovered* 等單詞。因此，單詞頻率在許多情況下可以很好地指示文本內容。
|
||||
|
||||
詞袋模型的問題在於某些常見單詞（如 *and*、*is* 等）在大多數文本中都會出現，並且它們的頻率最高，從而掩蓋了真正重要的單詞。我們可以通過考慮單詞在整個文檔集合中出現的頻率來降低這些單詞的重要性。這就是 TF/IDF 方法的主要思想，該方法在本課程附帶的筆記本中有更詳細的介紹。
|
||||
|
||||
然而，這些方法都無法完全考慮文本的**語義**。我們需要更強大的神經網絡模型來實現這一點，我們將在本節後續內容中討論。
|
||||
|
||||
## ✍️ 練習：文本表示
|
||||
|
||||
在以下筆記本中繼續學習：
|
||||
|
||||
* [使用 PyTorch 表示文本](TextRepresentationPyTorch.ipynb)
|
||||
* [使用 TensorFlow 表示文本](TextRepresentationTF.ipynb)
|
||||
|
||||
## 總結
|
||||
|
||||
到目前為止，我們學習了可以為不同單詞添加頻率權重的技術。然而，這些技術無法表示單詞的含義或順序。正如著名語言學家 J. R. Firth 在 1935 年所說：「單詞的完整含義總是與上下文相關，任何脫離上下文的意義研究都不應被認真對待。」我們將在課程後續內容中學習如何通過語言建模從文本中捕捉上下文信息。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
嘗試使用詞袋模型和不同的數據模型進行其他練習。你可能會從這個 [Kaggle 比賽](https://www.kaggle.com/competitions/word2vec-nlp-tutorial/overview/part-1-for-beginners-bag-of-words) 中獲得靈感。
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/26)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
在 [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/?WT.mc_id=academic-77998-cacaste) 上練習文本嵌入和詞袋模型技術。
|
||||
|
||||
## [作業：筆記本](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,577 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 文本分類任務\n",
|
||||
"\n",
|
||||
"如前所述，我們將專注於基於 **AG_NEWS** 數據集的簡單文本分類任務，該任務是將新聞標題分類為以下四個類別之一：世界、體育、商業和科學/技術。\n",
|
||||
"\n",
|
||||
"## 數據集\n",
|
||||
"\n",
|
||||
"此數據集已內建於 [`torchtext`](https://github.com/pytorch/text) 模組中，因此我們可以輕鬆訪問它。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import torch\n",
|
||||
"import torchtext\n",
|
||||
"import os\n",
|
||||
"import collections\n",
|
||||
"os.makedirs('./data',exist_ok=True)\n",
|
||||
"train_dataset, test_dataset = torchtext.datasets.AG_NEWS(root='./data')\n",
|
||||
"classes = ['World', 'Sports', 'Business', 'Sci/Tech']"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"在這裡，`train_dataset` 和 `test_dataset` 包含分別返回標籤（類別數字）和文本的集合，例如：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(3,\n",
|
||||
" \"Wall St. Bears Claw Back Into the Black (Reuters) Reuters - Short-sellers, Wall Street's dwindling\\\\band of ultra-cynics, are seeing green again.\")"
|
||||
]
|
||||
},
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"list(train_dataset)[0]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"那麼，讓我們從數據集中列印出前 10 條新標題：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"**Sci/Tech** -> Wall St. Bears Claw Back Into the Black (Reuters) Reuters - Short-sellers, Wall Street's dwindling\\band of ultra-cynics, are seeing green again.\n",
|
||||
"**Sci/Tech** -> Carlyle Looks Toward Commercial Aerospace (Reuters) Reuters - Private investment firm Carlyle Group,\\which has a reputation for making well-timed and occasionally\\controversial plays in the defense industry, has quietly placed\\its bets on another part of the market.\n",
|
||||
"**Sci/Tech** -> Oil and Economy Cloud Stocks' Outlook (Reuters) Reuters - Soaring crude prices plus worries\\about the economy and the outlook for earnings are expected to\\hang over the stock market next week during the depth of the\\summer doldrums.\n",
|
||||
"**Sci/Tech** -> Iraq Halts Oil Exports from Main Southern Pipeline (Reuters) Reuters - Authorities have halted oil export\\flows from the main pipeline in southern Iraq after\\intelligence showed a rebel militia could strike\\infrastructure, an oil official said on Saturday.\n",
|
||||
"**Sci/Tech** -> Oil prices soar to all-time record, posing new menace to US economy (AFP) AFP - Tearaway world oil prices, toppling records and straining wallets, present a new economic menace barely three months before the US presidential elections.\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for i,x in zip(range(5),train_dataset):\n",
|
||||
" print(f\"**{classes[x[0]]}** -> {x[1]}\")\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"因為數據集是迭代器，如果我們想多次使用數據，就需要將其轉換為列表：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"train_dataset, test_dataset = torchtext.datasets.AG_NEWS(root='./data')\n",
|
||||
"train_dataset = list(train_dataset)\n",
|
||||
"test_dataset = list(test_dataset)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 分詞\n",
|
||||
"\n",
|
||||
"現在我們需要將文本轉換為可以表示為張量的**數字**。如果我們想要基於單詞的表示，需要完成以下兩件事：\n",
|
||||
"* 使用**分詞器**將文本拆分為**詞元**\n",
|
||||
"* 建立這些詞元的**詞彙表**。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"['he', 'said', 'hello']"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tokenizer = torchtext.data.utils.get_tokenizer('basic_english')\n",
|
||||
"tokenizer('He said: hello')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"counter = collections.Counter()\n",
|
||||
"for (label, line) in train_dataset:\n",
|
||||
" counter.update(tokenizer(line))\n",
|
||||
"vocab = torchtext.vocab.vocab(counter, min_freq=1)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"使用詞彙，我們可以輕鬆地將標記化的字串編碼為一組數字：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 19,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Vocab size if 95810\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[599, 3279, 97, 1220, 329, 225, 7368]"
|
||||
]
|
||||
},
|
||||
"execution_count": 19,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vocab_size = len(vocab)\n",
|
||||
"print(f\"Vocab size if {vocab_size}\")\n",
|
||||
"\n",
|
||||
"stoi = vocab.get_stoi() # dict to convert tokens to indices\n",
|
||||
"\n",
|
||||
"def encode(x):\n",
|
||||
" return [stoi[s] for s in tokenizer(x)]\n",
|
||||
"\n",
|
||||
"encode('I love to play with my words')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 詞袋文字表示法\n",
|
||||
"\n",
|
||||
"由於文字代表意義，有時我們可以僅透過查看個別的文字來理解文本的含義，而不需要考慮它們在句子中的順序。例如，在分類新聞時，像 *weather*、*snow* 這樣的詞可能表明是 *天氣預報*，而像 *stocks*、*dollar* 則可能屬於 *財經新聞*。\n",
|
||||
"\n",
|
||||
"**詞袋** (BoW) 向量表示法是最常用的傳統向量表示法之一。每個詞都與向量索引相關聯，向量元素包含某個詞在特定文件中出現的次數。\n",
|
||||
"\n",
|
||||
" \n",
|
||||
"\n",
|
||||
"> **Note**: 你也可以將 BoW 想像成文本中每個詞的所有獨立一熱編碼向量的總和。\n",
|
||||
"\n",
|
||||
"以下是一個使用 Scikit Learn Python 庫生成詞袋表示法的範例：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([[1, 1, 0, 2, 0, 0, 0, 0, 0]], dtype=int64)"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"from sklearn.feature_extraction.text import CountVectorizer\n",
|
||||
"vectorizer = CountVectorizer()\n",
|
||||
"corpus = [\n",
|
||||
" 'I like hot dogs.',\n",
|
||||
" 'The dog ran fast.',\n",
|
||||
" 'Its hot outside.',\n",
|
||||
" ]\n",
|
||||
"vectorizer.fit_transform(corpus)\n",
|
||||
"vectorizer.transform(['My dog likes hot dogs on a hot day.']).toarray()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"要從我們的 AG_NEWS 數據集的向量表示計算詞袋向量，可以使用以下函數：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 20,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"tensor([2., 1., 2., ..., 0., 0., 0.])\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vocab_size = len(vocab)\n",
|
||||
"\n",
|
||||
"def to_bow(text,bow_vocab_size=vocab_size):\n",
|
||||
" res = torch.zeros(bow_vocab_size,dtype=torch.float32)\n",
|
||||
" for i in encode(text):\n",
|
||||
" if i<bow_vocab_size:\n",
|
||||
" res[i] += 1\n",
|
||||
" return res\n",
|
||||
"\n",
|
||||
"print(to_bow(train_dataset[0][1]))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意：** 這裡我們使用全域變數 `vocab_size` 來指定詞彙表的預設大小。由於詞彙表的大小通常相當大，我們可以將詞彙表的大小限制為最常出現的詞彙。嘗試降低 `vocab_size` 的值並執行以下程式碼，看看它如何影響準確性。你應該預期準確性會有所下降，但不會太劇烈，以換取更高的效能。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 訓練 BoW 分類器\n",
|
||||
"\n",
|
||||
"現在我們已經學會如何構建文本的詞袋（Bag-of-Words）表示，接下來讓我們基於它來訓練一個分類器。首先，我們需要將數據集轉換為適合訓練的格式，也就是將所有的位置向量表示轉換為詞袋表示。這可以通過將 `bowify` 函數作為 `collate_fn` 參數傳遞給標準的 torch `DataLoader` 來實現：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 21,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"from torch.utils.data import DataLoader\n",
|
||||
"import numpy as np \n",
|
||||
"\n",
|
||||
"# this collate function gets list of batch_size tuples, and needs to \n",
|
||||
"# return a pair of label-feature tensors for the whole minibatch\n",
|
||||
"def bowify(b):\n",
|
||||
" return (\n",
|
||||
" torch.LongTensor([t[0]-1 for t in b]),\n",
|
||||
" torch.stack([to_bow(t[1]) for t in b])\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"train_loader = DataLoader(train_dataset, batch_size=16, collate_fn=bowify, shuffle=True)\n",
|
||||
"test_loader = DataLoader(test_dataset, batch_size=16, collate_fn=bowify, shuffle=True)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在讓我們定義一個簡單的分類器神經網絡，其中包含一個線性層。輸入向量的大小等於 `vocab_size`，輸出大小對應於類別數量（4）。由於我們正在解決分類任務，最終的激活函數是 `LogSoftmax()`。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 22,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"net = torch.nn.Sequential(torch.nn.Linear(vocab_size,4),torch.nn.LogSoftmax(dim=1))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在我們將定義標準的 PyTorch 訓練循環。由於我們的數據集相當大，出於教學目的，我們將僅訓練一個 epoch，有時甚至少於一個 epoch（通過指定 `epoch_size` 參數可以限制訓練）。我們還會在訓練過程中報告累積的訓練準確率；報告的頻率是通過 `report_freq` 參數指定的。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 24,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def train_epoch(net,dataloader,lr=0.01,optimizer=None,loss_fn = torch.nn.NLLLoss(),epoch_size=None, report_freq=200):\n",
|
||||
" optimizer = optimizer or torch.optim.Adam(net.parameters(),lr=lr)\n",
|
||||
" net.train()\n",
|
||||
" total_loss,acc,count,i = 0,0,0,0\n",
|
||||
" for labels,features in dataloader:\n",
|
||||
" optimizer.zero_grad()\n",
|
||||
" out = net(features)\n",
|
||||
" loss = loss_fn(out,labels) #cross_entropy(out,labels)\n",
|
||||
" loss.backward()\n",
|
||||
" optimizer.step()\n",
|
||||
" total_loss+=loss\n",
|
||||
" _,predicted = torch.max(out,1)\n",
|
||||
" acc+=(predicted==labels).sum()\n",
|
||||
" count+=len(labels)\n",
|
||||
" i+=1\n",
|
||||
" if i%report_freq==0:\n",
|
||||
" print(f\"{count}: acc={acc.item()/count}\")\n",
|
||||
" if epoch_size and count>epoch_size:\n",
|
||||
" break\n",
|
||||
" return total_loss.item()/count, acc.item()/count"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 25,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3200: acc=0.8028125\n",
|
||||
"6400: acc=0.8371875\n",
|
||||
"9600: acc=0.8534375\n",
|
||||
"12800: acc=0.85765625\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(0.026090790722161722, 0.8620069296375267)"
|
||||
]
|
||||
},
|
||||
"execution_count": 25,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"train_epoch(net,train_loader,epoch_size=15000)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## BiGrams、TriGrams 和 N-Grams\n",
|
||||
"\n",
|
||||
"袋裝詞方法的一個限制是，有些詞是多詞表達的一部分。例如，詞語「熱狗」的意思與「熱」和「狗」在其他語境中的意思完全不同。如果我們始終用相同的向量表示「熱」和「狗」，可能會讓模型感到困惑。\n",
|
||||
"\n",
|
||||
"為了解決這個問題，**N-Gram 表示法**通常用於文件分類的方法中，其中每個詞、雙詞或三詞的頻率是訓練分類器的有用特徵。例如，在雙詞表示法中，我們會將所有的詞對加入詞彙表，除了原始詞語之外。\n",
|
||||
"\n",
|
||||
"以下是一個使用 Scikit Learn 生成雙詞袋裝詞表示法的範例：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 26,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Vocabulary:\n",
|
||||
" {'i': 7, 'like': 11, 'hot': 4, 'dogs': 2, 'i like': 8, 'like hot': 12, 'hot dogs': 5, 'the': 16, 'dog': 0, 'ran': 14, 'fast': 3, 'the dog': 17, 'dog ran': 1, 'ran fast': 15, 'its': 9, 'outside': 13, 'its hot': 10, 'hot outside': 6}\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([[1, 0, 1, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],\n",
|
||||
" dtype=int64)"
|
||||
]
|
||||
},
|
||||
"execution_count": 26,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"bigram_vectorizer = CountVectorizer(ngram_range=(1, 2), token_pattern=r'\\b\\w+\\b', min_df=1)\n",
|
||||
"corpus = [\n",
|
||||
" 'I like hot dogs.',\n",
|
||||
" 'The dog ran fast.',\n",
|
||||
" 'Its hot outside.',\n",
|
||||
" ]\n",
|
||||
"bigram_vectorizer.fit_transform(corpus)\n",
|
||||
"print(\"Vocabulary:\\n\",bigram_vectorizer.vocabulary_)\n",
|
||||
"bigram_vectorizer.transform(['My dog likes hot dogs on a hot day.']).toarray()\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"N-gram 方法的主要缺點是詞彙量會以極快的速度增長。實際應用中，我們需要將 N-gram 表示法與一些降維技術結合使用，例如 *嵌入*，我們會在下一單元中討論這些技術。\n",
|
||||
"\n",
|
||||
"為了在我們的 **AG News** 數據集中使用 N-gram 表示法，我們需要構建專門的 ngram 詞彙表：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 27,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Bigram vocabulary length = 1308842\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"counter = collections.Counter()\n",
|
||||
"for (label, line) in train_dataset:\n",
|
||||
" l = tokenizer(line)\n",
|
||||
" counter.update(torchtext.data.utils.ngrams_iterator(l,ngrams=2))\n",
|
||||
" \n",
|
||||
"bi_vocab = torchtext.vocab.vocab(counter, min_freq=1)\n",
|
||||
"\n",
|
||||
"print(\"Bigram vocabulary length = \",len(bi_vocab))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們可以使用上述相同的程式碼來訓練分類器，但這樣做會非常耗費記憶體。在下一個單元中，我們將使用嵌入來訓練二元分類器。\n",
|
||||
"\n",
|
||||
"> **注意:** 你只能保留那些在文本中出現次數超過指定數量的 ngram。這將確保不常見的二元組會被省略，並顯著降低維度。為此，將 `min_freq` 參數設置為更高的值，並觀察詞彙表的長度變化。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 詞頻-逆文檔頻率 TF-IDF\n",
|
||||
"\n",
|
||||
"在 BoW 表示法中，詞的出現次數被均等地加權，無論該詞本身如何。然而，很明顯，像 *a*、*in* 等這些常見詞對分類的作用遠不如專業術語重要。事實上，在大多數 NLP 任務中，有些詞比其他詞更具相關性。\n",
|
||||
"\n",
|
||||
"**TF-IDF** 代表 **詞頻–逆文檔頻率**。它是袋子模型（BoW）的變體，與使用二進制 0/1 值表示詞在文檔中的出現不同，TF-IDF 使用浮點值，該值與詞在語料庫中的出現頻率相關。\n",
|
||||
"\n",
|
||||
"更正式地說，詞 $i$ 在文檔 $j$ 中的權重 $w_{ij}$ 定義為：\n",
|
||||
"$$\n",
|
||||
"w_{ij} = tf_{ij}\\times\\log({N\\over df_i})\n",
|
||||
"$$\n",
|
||||
"其中：\n",
|
||||
"* $tf_{ij}$ 是詞 $i$ 在文檔 $j$ 中的出現次數，即我們之前看到的 BoW 值\n",
|
||||
"* $N$ 是集合中的文檔數量\n",
|
||||
"* $df_i$ 是整個集合中包含詞 $i$ 的文檔數量\n",
|
||||
"\n",
|
||||
"TF-IDF 值 $w_{ij}$ 隨著詞在文檔中出現次數的增加而增加，同時受到包含該詞的文檔數量的影響，這有助於調整某些詞比其他詞出現更頻繁的情況。例如，如果某個詞出現在集合中的*每一個*文檔中，則 $df_i=N$，而 $w_{ij}=0$，這些詞將被完全忽略。\n",
|
||||
"\n",
|
||||
"您可以使用 Scikit Learn 輕鬆地創建文本的 TF-IDF 向量化：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 28,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([[0.43381609, 0. , 0.43381609, 0. , 0.65985664,\n",
|
||||
" 0.43381609, 0. , 0. , 0. , 0. ,\n",
|
||||
" 0. , 0. , 0. , 0. , 0. ,\n",
|
||||
" 0. ]])"
|
||||
]
|
||||
},
|
||||
"execution_count": 28,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"from sklearn.feature_extraction.text import TfidfVectorizer\n",
|
||||
"vectorizer = TfidfVectorizer(ngram_range=(1,2))\n",
|
||||
"vectorizer.fit_transform(corpus)\n",
|
||||
"vectorizer.transform(['My dog likes hot dogs on a hot day.']).toarray()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 結論\n",
|
||||
"\n",
|
||||
"然而，儘管 TF-IDF 表示法為不同的詞提供了頻率權重，但它無法表達詞義或順序。正如著名語言學家 J. R. Firth 在1935年所說：「詞語的完整意義總是與上下文相關，任何脫離上下文的意義研究都不應被認真對待。」在課程的後續部分，我們將學習如何通過語言建模從文本中捕捉上下文信息。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件已使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。儘管我們努力確保翻譯的準確性，但請注意，自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵資訊，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋不承擔責任。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.8.12 ('py38')",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "7b9040985e748e4e2d4c689892456ad7",
|
||||
"translation_date": "2025-08-31T10:57:29+00:00",
|
||||
"source_file": "lessons/5-NLP/13-TextRep/TextRepresentationPyTorch.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
|
|
@ -0,0 +1,647 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 文本分類任務\n",
|
||||
"\n",
|
||||
"在本模組中，我們將從一個基於 **[AG_NEWS](http://www.di.unipi.it/~gulli/AG_corpus_of_news_articles.html)** 數據集的簡單文本分類任務開始：我們將把新聞標題分類為以下四個類別之一：世界、體育、商業和科學/技術。\n",
|
||||
"\n",
|
||||
"## 數據集\n",
|
||||
"\n",
|
||||
"為了載入數據集，我們將使用 **[TensorFlow Datasets](https://www.tensorflow.org/datasets)** API。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import tensorflow as tf\n",
|
||||
"from tensorflow import keras\n",
|
||||
"import tensorflow_datasets as tfds\n",
|
||||
"\n",
|
||||
"# In this tutorial, we will be training a lot of models. In order to use GPU memory cautiously,\n",
|
||||
"# we will set tensorflow option to grow GPU memory allocation when required.\n",
|
||||
"physical_devices = tf.config.list_physical_devices('GPU') \n",
|
||||
"if len(physical_devices)>0:\n",
|
||||
" tf.config.experimental.set_memory_growth(physical_devices[0], True)\n",
|
||||
"\n",
|
||||
"dataset = tfds.load('ag_news_subset')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們現在可以分別使用 `dataset['train']` 和 `dataset['test']` 訪問數據集的訓練部分和測試部分：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Length of train dataset = 120000\n",
|
||||
"Length of test dataset = 7600\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"ds_train = dataset['train']\n",
|
||||
"ds_test = dataset['test']\n",
|
||||
"\n",
|
||||
"print(f\"Length of train dataset = {len(ds_train)}\")\n",
|
||||
"print(f\"Length of test dataset = {len(ds_test)}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"讓我們列印出資料集中前10個新的標題：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3 (Sci/Tech) -> b'AMD Debuts Dual-Core Opteron Processor' b'AMD #39;s new dual-core Opteron chip is designed mainly for corporate computing applications, including databases, Web services, and financial transactions.'\n",
|
||||
"1 (Sports) -> b\"Wood's Suspension Upheld (Reuters)\" b'Reuters - Major League Baseball\\\\Monday announced a decision on the appeal filed by Chicago Cubs\\\\pitcher Kerry Wood regarding a suspension stemming from an\\\\incident earlier this season.'\n",
|
||||
"2 (Business) -> b'Bush reform may have blue states seeing red' b'President Bush #39;s quot;revenue-neutral quot; tax reform needs losers to balance its winners, and people claiming the federal deduction for state and local taxes may be in administration planners #39; sights, news reports say.'\n",
|
||||
"3 (Sci/Tech) -> b\"'Halt science decline in schools'\" b'Britain will run out of leading scientists unless science education is improved, says Professor Colin Pillinger.'\n",
|
||||
"1 (Sports) -> b'Gerrard leaves practice' b'London, England (Sports Network) - England midfielder Steven Gerrard injured his groin late in Thursday #39;s training session, but is hopeful he will be ready for Saturday #39;s World Cup qualifier against Austria.'\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"classes = ['World', 'Sports', 'Business', 'Sci/Tech']\n",
|
||||
"\n",
|
||||
"for i,x in zip(range(5),ds_train):\n",
|
||||
" print(f\"{x['label']} ({classes[x['label']]}) -> {x['title']} {x['description']}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 文本向量化\n",
|
||||
"\n",
|
||||
"現在我們需要將文本轉換為可以表示為張量的**數字**。如果我們想要詞級別的表示，需要完成兩件事：\n",
|
||||
"\n",
|
||||
"* 使用**分詞器**將文本拆分為**詞元**。\n",
|
||||
"* 建立這些詞元的**詞彙表**。\n",
|
||||
"\n",
|
||||
"### 限制詞彙表大小\n",
|
||||
"\n",
|
||||
"在 AG News 數據集的例子中，詞彙表的大小相當大，超過 10 萬個單詞。一般來說，我們不需要那些在文本中很少出現的單詞——只有少數句子會包含它們，模型也無法從中學習。因此，通過向向量化器構造函數傳遞參數，將詞彙表的大小限制為較小的數量是有意義的：\n",
|
||||
"\n",
|
||||
"這兩個步驟都可以使用 **TextVectorization** 層來處理。我們來實例化向量化器對象，然後調用 `adapt` 方法來遍歷所有文本並建立詞彙表：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"vocab_size = 50000\n",
|
||||
"vectorizer = keras.layers.experimental.preprocessing.TextVectorization(max_tokens=vocab_size)\n",
|
||||
"vectorizer.adapt(ds_train.take(500).map(lambda x: x['title']+' '+x['description']))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意** 我們僅使用整個數據集的一部分來建立詞彙表。這樣做是為了加快執行速度，避免讓您等待太久。然而，我們承擔了一些風險，即整個數據集中的某些詞可能不會被包含在詞彙表中，並在訓練過程中被忽略。因此，使用完整的詞彙表大小並在 `adapt` 過程中遍歷整個數據集應該能提高最終的準確性，但提升幅度不會太大。\n",
|
||||
"\n",
|
||||
"現在我們可以訪問實際的詞彙表：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"['', '[UNK]', 'the', 'to', 'a', 'in', 'of', 'and', 'on', 'for']\n",
|
||||
"Length of vocabulary: 5335\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vocab = vectorizer.get_vocabulary()\n",
|
||||
"vocab_size = len(vocab)\n",
|
||||
"print(vocab[:10])\n",
|
||||
"print(f\"Length of vocabulary: {vocab_size}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"使用向量化器，我們可以輕鬆地將任何文本編碼為一組數字：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tf.Tensor: shape=(7,), dtype=int64, numpy=array([ 112, 3695, 3, 304, 11, 1041, 1], dtype=int64)>"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vectorizer('I love to play with my words')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Bag-of-words 文本表示法\n",
|
||||
"\n",
|
||||
"由於文字具有意義，有時我們僅需查看句子中的個別文字，就能理解一段文字的含義，而不必在意它們的排列順序。例如，在分類新聞時，像 *weather* 和 *snow* 這樣的詞可能表明是 *天氣預報*，而像 *stocks* 和 *dollar* 則可能屬於 *財經新聞*。\n",
|
||||
"\n",
|
||||
"**Bag-of-words** (BoW) 向量表示法是最容易理解的傳統向量表示法。每個詞都與向量索引相關聯，向量中的元素則表示某個詞在特定文件中出現的次數。\n",
|
||||
"\n",
|
||||
" \n",
|
||||
"\n",
|
||||
"> **Note**: 你也可以將 BoW 理解為文本中每個詞的獨熱編碼向量的總和。\n",
|
||||
"\n",
|
||||
"以下是一個使用 Scikit Learn Python 庫生成 Bag-of-words 表示法的範例：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([[1, 1, 0, 2, 0, 0, 0, 0, 0]], dtype=int64)"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"from sklearn.feature_extraction.text import CountVectorizer\n",
|
||||
"sc_vectorizer = CountVectorizer()\n",
|
||||
"corpus = [\n",
|
||||
" 'I like hot dogs.',\n",
|
||||
" 'The dog ran fast.',\n",
|
||||
" 'Its hot outside.',\n",
|
||||
" ]\n",
|
||||
"sc_vectorizer.fit_transform(corpus)\n",
|
||||
"sc_vectorizer.transform(['My dog likes hot dogs on a hot day.']).toarray()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們也可以使用我們在上面定義的 Keras 向量化器，將每個單詞編號轉換為一個獨熱編碼，然後將所有這些向量相加：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([0., 5., 0., ..., 0., 0., 0.], dtype=float32)"
|
||||
]
|
||||
},
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def to_bow(text):\n",
|
||||
" return tf.reduce_sum(tf.one_hot(vectorizer(text),vocab_size),axis=0)\n",
|
||||
"\n",
|
||||
"to_bow('My dog likes hot dogs on a hot day.').numpy()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意**：您可能會驚訝地發現結果與之前的範例不同。原因在於，在 Keras 的範例中，向量的長度對應於詞彙表的大小，而該詞彙表是基於整個 AG News 數據集構建的；而在 Scikit Learn 的範例中，我們是即時從樣本文本中構建詞彙表的。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 訓練 BoW 分類器\n",
|
||||
"\n",
|
||||
"現在我們已經學會如何建立文字的詞袋表示法，接下來讓我們訓練一個使用該表示法的分類器。首先，我們需要將數據集轉換為詞袋表示法。這可以通過以下方式使用 `map` 函數來實現：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"batch_size = 128\n",
|
||||
"\n",
|
||||
"ds_train_bow = ds_train.map(lambda x: (to_bow(x['title']+x['description']),x['label'])).batch(batch_size)\n",
|
||||
"ds_test_bow = ds_test.map(lambda x: (to_bow(x['title']+x['description']),x['label'])).batch(batch_size)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在讓我們定義一個簡單的分類器神經網絡，其中包含一個線性層。輸入大小為 `vocab_size`，輸出大小對應於類別數量（4）。由於我們正在解決分類任務，最終的激活函數是 **softmax**：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"938/938 [==============================] - 66s 70ms/step - loss: 0.6144 - acc: 0.8427 - val_loss: 0.4416 - val_acc: 0.8697\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<keras.callbacks.History at 0x20c70a947f0>"
|
||||
]
|
||||
},
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = keras.models.Sequential([\n",
|
||||
" keras.layers.Dense(4,activation='softmax',input_shape=(vocab_size,))\n",
|
||||
"])\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['acc'])\n",
|
||||
"model.fit(ds_train_bow,validation_data=ds_test_bow)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"由於我們有四個類別，超過 80% 的準確率是一個不錯的結果。\n",
|
||||
"\n",
|
||||
"## 將分類器作為一個網絡進行訓練\n",
|
||||
"\n",
|
||||
"由於向量化器本身也是一個 Keras 層，我們可以定義一個包含它的網絡，並進行端到端的訓練。這樣，我們就不需要使用 `map` 來向量化數據集，只需將原始數據集傳遞到網絡的輸入即可。\n",
|
||||
"\n",
|
||||
"> **注意**: 我們仍然需要對數據集應用映射操作，將字典中的字段（例如 `title`、`description` 和 `label`）轉換為元組。然而，在從磁盤加載數據時，我們可以一開始就構建具有所需結構的數據集。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"model\"\n",
|
||||
"_________________________________________________________________\n",
|
||||
" Layer (type) Output Shape Param # \n",
|
||||
"=================================================================\n",
|
||||
" input_1 (InputLayer) [(None, 1)] 0 \n",
|
||||
" \n",
|
||||
" text_vectorization (TextVec (None, None) 0 \n",
|
||||
" torization) \n",
|
||||
" \n",
|
||||
" tf.one_hot (TFOpLambda) (None, None, 5335) 0 \n",
|
||||
" \n",
|
||||
" tf.math.reduce_sum (TFOpLam (None, 5335) 0 \n",
|
||||
" bda) \n",
|
||||
" \n",
|
||||
" dense_2 (Dense) (None, 4) 21344 \n",
|
||||
" \n",
|
||||
"=================================================================\n",
|
||||
"Total params: 21,344\n",
|
||||
"Trainable params: 21,344\n",
|
||||
"Non-trainable params: 0\n",
|
||||
"_________________________________________________________________\n",
|
||||
"938/938 [==============================] - 73s 77ms/step - loss: 0.6057 - acc: 0.8414 - val_loss: 0.4202 - val_acc: 0.8736\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<keras.callbacks.History at 0x20c721521f0>"
|
||||
]
|
||||
},
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def extract_text(x):\n",
|
||||
" return x['title']+' '+x['description']\n",
|
||||
"\n",
|
||||
"def tupelize(x):\n",
|
||||
" return (extract_text(x),x['label'])\n",
|
||||
"\n",
|
||||
"inp = keras.Input(shape=(1,),dtype=tf.string)\n",
|
||||
"x = vectorizer(inp)\n",
|
||||
"x = tf.reduce_sum(tf.one_hot(x,vocab_size),axis=1)\n",
|
||||
"out = keras.layers.Dense(4,activation='softmax')(x)\n",
|
||||
"model = keras.models.Model(inp,out)\n",
|
||||
"model.summary()\n",
|
||||
"\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['acc'])\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(batch_size),validation_data=ds_test.map(tupelize).batch(batch_size))\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 二元組、三元組和 n 元組\n",
|
||||
"\n",
|
||||
"詞袋方法的一個限制是，有些詞屬於多詞表達，例如「熱狗」這個詞在不同語境下與「熱」和「狗」的意思完全不同。如果我們始終用相同的向量表示「熱」和「狗」，可能會讓模型感到困惑。\n",
|
||||
"\n",
|
||||
"為了解決這個問題，**n 元組表示法**通常用於文件分類方法中，其中每個詞、雙詞或三詞的頻率是訓練分類器的一個有用特徵。例如，在二元組表示法中，我們會將所有的詞對加入詞彙表中，除了原始詞之外。\n",
|
||||
"\n",
|
||||
"以下是一個使用 Scikit Learn 生成二元組詞袋表示法的示例：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Vocabulary:\n",
|
||||
" {'i': 7, 'like': 11, 'hot': 4, 'dogs': 2, 'i like': 8, 'like hot': 12, 'hot dogs': 5, 'the': 16, 'dog': 0, 'ran': 14, 'fast': 3, 'the dog': 17, 'dog ran': 1, 'ran fast': 15, 'its': 9, 'outside': 13, 'its hot': 10, 'hot outside': 6}\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([[1, 0, 1, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],\n",
|
||||
" dtype=int64)"
|
||||
]
|
||||
},
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"bigram_vectorizer = CountVectorizer(ngram_range=(1, 2), token_pattern=r'\\b\\w+\\b', min_df=1)\n",
|
||||
"corpus = [\n",
|
||||
" 'I like hot dogs.',\n",
|
||||
" 'The dog ran fast.',\n",
|
||||
" 'Its hot outside.',\n",
|
||||
" ]\n",
|
||||
"bigram_vectorizer.fit_transform(corpus)\n",
|
||||
"print(\"Vocabulary:\\n\",bigram_vectorizer.vocabulary_)\n",
|
||||
"bigram_vectorizer.transform(['My dog likes hot dogs on a hot day.']).toarray()\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"n-gram 方法的主要缺點是詞彙量會迅速增長。在實際應用中，我們需要將 n-gram 表示法與降維技術（例如 *嵌入*）結合使用，我們會在下一單元中討論這一點。\n",
|
||||
"\n",
|
||||
"要在我們的 **AG News** 數據集中使用 n-gram 表示法，我們需要將 `ngrams` 參數傳遞給 `TextVectorization` 構造函數。二元語法詞彙的長度**顯著增加**，在我們的例子中，超過了 130 萬個詞元！因此，限制二元語法詞元的數量在合理範圍內是有意義的。\n",
|
||||
"\n",
|
||||
"我們可以使用與上面相同的代碼來訓練分類器，但這樣做會非常耗費記憶體。在下一單元中，我們將使用嵌入來訓練二元語法分類器。與此同時，您可以在這個筆記本中嘗試訓練二元語法分類器，看看是否能獲得更高的準確率。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 自動計算 BoW 向量\n",
|
||||
"\n",
|
||||
"在上述範例中，我們透過手動方式計算 BoW 向量，方法是將個別單字的一次性編碼相加。然而，最新版本的 TensorFlow 允許我們透過在向量化器建構函數中傳入 `output_mode='count` 參數，自動計算 BoW 向量。這使得定義和訓練模型變得更加簡單：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Training vectorizer\n",
|
||||
"938/938 [==============================] - 7s 7ms/step - loss: 0.5929 - acc: 0.8486 - val_loss: 0.4168 - val_acc: 0.8772\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<keras.callbacks.History at 0x20c725217c0>"
|
||||
]
|
||||
},
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = keras.models.Sequential([\n",
|
||||
" keras.layers.experimental.preprocessing.TextVectorization(max_tokens=vocab_size,output_mode='count'),\n",
|
||||
" keras.layers.Dense(4,input_shape=(vocab_size,), activation='softmax')\n",
|
||||
"])\n",
|
||||
"print(\"Training vectorizer\")\n",
|
||||
"model.layers[0].adapt(ds_train.take(500).map(extract_text))\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['acc'])\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(batch_size),validation_data=ds_test.map(tupelize).batch(batch_size))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 詞頻 - 逆文件頻率 (TF-IDF)\n",
|
||||
"\n",
|
||||
"在 BoW 表示法中，單詞的出現次數無論對於哪個單詞，都是使用相同的技術進行加權。然而，很明顯，像 *a* 和 *in* 這樣的高頻單詞對分類的影響遠不如專業術語。在大多數自然語言處理任務中，有些單詞比其他單詞更為重要。\n",
|
||||
"\n",
|
||||
"**TF-IDF** 是 **詞頻 - 逆文件頻率** 的縮寫。這是一種基於詞袋模型的變體，其中不再使用二元的 0/1 值來表示單詞是否出現在文件中，而是使用與單詞在語料庫中出現頻率相關的浮點值。\n",
|
||||
"\n",
|
||||
"更正式地說，單詞 $i$ 在文件 $j$ 中的權重 $w_{ij}$ 定義為：\n",
|
||||
"$$\n",
|
||||
"w_{ij} = tf_{ij}\\times\\log({N\\over df_i})\n",
|
||||
"$$\n",
|
||||
"其中：\n",
|
||||
"* $tf_{ij}$ 是單詞 $i$ 在文件 $j$ 中出現的次數，也就是我們之前看到的 BoW 值\n",
|
||||
"* $N$ 是集合中的文件總數\n",
|
||||
"* $df_i$ 是整個集合中包含單詞 $i$ 的文件數量\n",
|
||||
"\n",
|
||||
"TF-IDF 值 $w_{ij}$ 與單詞在文件中出現的次數成正比，並且會根據語料庫中包含該單詞的文件數量進行調整，這有助於平衡某些單詞出現頻率較高的情況。例如，如果某個單詞出現在集合中的*每一個*文件中，則 $df_i=N$，而 $w_{ij}=0$，這些詞將被完全忽略。\n",
|
||||
"\n",
|
||||
"您可以使用 Scikit Learn 輕鬆地對文本進行 TF-IDF 向量化：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([[0.43381609, 0. , 0.43381609, 0. , 0.65985664,\n",
|
||||
" 0.43381609, 0. , 0. , 0. , 0. ,\n",
|
||||
" 0. , 0. , 0. , 0. , 0. ,\n",
|
||||
" 0. ]])"
|
||||
]
|
||||
},
|
||||
"execution_count": 16,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"from sklearn.feature_extraction.text import TfidfVectorizer\n",
|
||||
"vectorizer = TfidfVectorizer(ngram_range=(1,2))\n",
|
||||
"vectorizer.fit_transform(corpus)\n",
|
||||
"vectorizer.transform(['My dog likes hot dogs on a hot day.']).toarray()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"在 Keras 中，可以通過傳遞參數 `output_mode='tf-idf'`，讓 `TextVectorization` 層自動計算 TF-IDF 頻率。我們重複上面使用的程式碼，來看看使用 TF-IDF 是否能提高準確性：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 17,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Training vectorizer\n",
|
||||
"938/938 [==============================] - 12s 12ms/step - loss: 0.4197 - acc: 0.8662 - val_loss: 0.3432 - val_acc: 0.8849\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<keras.callbacks.History at 0x20c729dfd30>"
|
||||
]
|
||||
},
|
||||
"execution_count": 17,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = keras.models.Sequential([\n",
|
||||
" keras.layers.experimental.preprocessing.TextVectorization(max_tokens=vocab_size,output_mode='tf-idf'),\n",
|
||||
" keras.layers.Dense(4,input_shape=(vocab_size,), activation='softmax')\n",
|
||||
"])\n",
|
||||
"print(\"Training vectorizer\")\n",
|
||||
"model.layers[0].adapt(ds_train.take(500).map(extract_text))\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['acc'])\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(batch_size),validation_data=ds_test.map(tupelize).batch(batch_size))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 結論\n",
|
||||
"\n",
|
||||
"儘管 TF-IDF 表示法為不同的詞提供了頻率權重，但它無法表達詞義或順序。正如著名語言學家 J. R. Firth 在 1935 年所說：「詞語的完整意義總是與上下文相關，任何脫離上下文的意義研究都不應被認真對待。」在課程的後續部分，我們將學習如何通過語言建模來捕捉文本中的上下文信息。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件已使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。儘管我們致力於提供準確的翻譯，請注意自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵資訊，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋不承擔責任。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "0cb620c6d4b9f7a635928804c26cf22403d89d98d79684e4529119355ee6d5a5"
|
||||
},
|
||||
"kernel_info": {
|
||||
"name": "conda-env-py37_tensorflow-py"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "py37_tensorflow",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"nteract": {
|
||||
"version": "nteract-front-end@1.0.0"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "19b43951d55b377a76209c24c1f017e4",
|
||||
"translation_date": "2025-08-31T10:59:55+00:00",
|
||||
"source_file": "lessons/5-NLP/13-TextRep/TextRepresentationTF.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
# 作業：筆記本
|
||||
|
||||
使用與本課程相關的筆記本（無論是 PyTorch 還是 TensorFlow 版本），使用您自己的數據集重新運行它們，例如來自 Kaggle 的數據集，並記得標註來源。重寫筆記本以強調您自己的發現。嘗試一些可能帶來驚喜的創新數據集，例如來自 NUFORC 的[這個關於 UFO 目擊事件的數據集](https://www.kaggle.com/datasets/NUFORC/ufo-sightings)。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。
|
||||
|
|
@ -0,0 +1,726 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 嵌入\n",
|
||||
"\n",
|
||||
"在我們之前的例子中，我們操作的是長度為 `vocab_size` 的高維度詞袋向量，並且我們明確地將低維度的位置表示向量轉換為稀疏的獨熱表示（one-hot representation）。這種獨熱表示並不具備記憶效率，此外，每個詞彙彼此之間是獨立處理的，也就是說，獨熱編碼的向量無法表達詞彙之間的任何語義相似性。\n",
|
||||
"\n",
|
||||
"在本單元中，我們將繼續探索 **News AG** 數據集。首先，讓我們載入數據並從之前的筆記本中獲取一些定義。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Loading dataset...\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "stderr",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"d:\\WORK\\ai-for-beginners\\5-NLP\\14-Embeddings\\data\\train.csv: 29.5MB [00:01, 18.8MB/s] \n",
|
||||
"d:\\WORK\\ai-for-beginners\\5-NLP\\14-Embeddings\\data\\test.csv: 1.86MB [00:00, 11.2MB/s] \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Building vocab...\n",
|
||||
"Vocab size = 95812\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import torch\n",
|
||||
"import torchtext\n",
|
||||
"import numpy as np\n",
|
||||
"from torchnlp import *\n",
|
||||
"train_dataset, test_dataset, classes, vocab = load_dataset()\n",
|
||||
"vocab_size = len(vocab)\n",
|
||||
"print(\"Vocab size = \",vocab_size)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 什麼是嵌入？\n",
|
||||
"\n",
|
||||
"**嵌入**的概念是用低維度的密集向量來表示詞語，這些向量以某種方式反映詞語的語義。我們稍後會討論如何構建有意義的詞嵌入，但目前可以將嵌入理解為降低詞向量維度的一種方法。\n",
|
||||
"\n",
|
||||
"嵌入層會將一個詞作為輸入，並生成指定的 `embedding_size` 的輸出向量。從某種意義上說，它與 `Linear` 層非常相似，但嵌入層不需要接收獨熱編碼向量，而是可以直接接收詞的編號作為輸入。\n",
|
||||
"\n",
|
||||
"通過將嵌入層作為我們網絡的第一層，我們可以從詞袋模型切換到 **嵌入袋** 模型。在嵌入袋模型中，我們首先將文本中的每個詞轉換為相應的嵌入，然後對所有這些嵌入計算某種聚合函數，例如 `sum`、`average` 或 `max`。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"我們的分類器神經網絡將以嵌入層開始，接著是聚合層，最後是線性分類器：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"class EmbedClassifier(torch.nn.Module):\n",
|
||||
" def __init__(self, vocab_size, embed_dim, num_class):\n",
|
||||
" super().__init__()\n",
|
||||
" self.embedding = torch.nn.Embedding(vocab_size, embed_dim)\n",
|
||||
" self.fc = torch.nn.Linear(embed_dim, num_class)\n",
|
||||
"\n",
|
||||
" def forward(self, x):\n",
|
||||
" x = self.embedding(x)\n",
|
||||
" x = torch.mean(x,dim=1)\n",
|
||||
" return self.fc(x)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 處理變數序列長度\n",
|
||||
"\n",
|
||||
"由於這種架構的特性，我們需要以特定的方式來建立傳遞給網路的迷你批次。在前一單元中，使用詞袋模型（bag-of-words, BoW）時，迷你批次中的所有 BoW 張量都具有相同的大小 `vocab_size`，無論文本序列的實際長度如何。然而，當我們轉向使用詞嵌入（word embeddings）時，每個文本樣本中的單詞數量會有所不同，而在將這些樣本組合成迷你批次時，我們需要進行一些填充操作。\n",
|
||||
"\n",
|
||||
"這可以通過為數據源提供 `collate_fn` 函數的方式來完成：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def padify(b):\n",
|
||||
" # b is the list of tuples of length batch_size\n",
|
||||
" # - first element of a tuple = label, \n",
|
||||
" # - second = feature (text sequence)\n",
|
||||
" # build vectorized sequence\n",
|
||||
" v = [encode(x[1]) for x in b]\n",
|
||||
" # first, compute max length of a sequence in this minibatch\n",
|
||||
" l = max(map(len,v))\n",
|
||||
" return ( # tuple of two tensors - labels and features\n",
|
||||
" torch.LongTensor([t[0]-1 for t in b]),\n",
|
||||
" torch.stack([torch.nn.functional.pad(torch.tensor(t),(0,l-len(t)),mode='constant',value=0) for t in v])\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, collate_fn=padify, shuffle=True)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 訓練嵌入分類器\n",
|
||||
"\n",
|
||||
"現在我們已經定義了合適的資料加載器，可以使用上一單元中定義的訓練函數來訓練模型：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3200: acc=0.6415625\n",
|
||||
"6400: acc=0.6865625\n",
|
||||
"9600: acc=0.7103125\n",
|
||||
"12800: acc=0.726953125\n",
|
||||
"16000: acc=0.739375\n",
|
||||
"19200: acc=0.75046875\n",
|
||||
"22400: acc=0.7572321428571429\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(0.889799795315499, 0.7623160588611644)"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"net = EmbedClassifier(vocab_size,32,len(classes)).to(device)\n",
|
||||
"train_epoch(net,train_loader, lr=1, epoch_size=25000)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意**：我們在這裡僅訓練 25k 筆記錄（少於一個完整的 epoch）以節省時間，但您可以繼續訓練，撰寫一個函數來訓練多個 epoch，並嘗試調整學習率參數以獲得更高的準確率。您應該能夠達到約 90% 的準確率。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### EmbeddingBag 層與可變長度序列表示法\n",
|
||||
"\n",
|
||||
"在之前的架構中，我們需要將所有序列填充至相同的長度，以便將它們放入小批量中。這並不是表示可變長度序列的最有效方式——另一種方法是使用 **偏移量** 向量，該向量保存所有序列在一個大型向量中的偏移位置。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"> **Note**: 在上圖中，我們展示的是字符序列，但在我們的例子中，我們處理的是單詞序列。然而，使用偏移量向量表示序列的基本原理是相同的。\n",
|
||||
"\n",
|
||||
"為了使用偏移量表示法，我們使用 [`EmbeddingBag`](https://pytorch.org/docs/stable/generated/torch.nn.EmbeddingBag.html) 層。它類似於 `Embedding`，但它以內容向量和偏移量向量作為輸入，並且還包含一個平均層，可以是 `mean`、`sum` 或 `max`。\n",
|
||||
"\n",
|
||||
"以下是使用 `EmbeddingBag` 的修改後的網絡：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"class EmbedClassifier(torch.nn.Module):\n",
|
||||
" def __init__(self, vocab_size, embed_dim, num_class):\n",
|
||||
" super().__init__()\n",
|
||||
" self.embedding = torch.nn.EmbeddingBag(vocab_size, embed_dim)\n",
|
||||
" self.fc = torch.nn.Linear(embed_dim, num_class)\n",
|
||||
"\n",
|
||||
" def forward(self, text, off):\n",
|
||||
" x = self.embedding(text, off)\n",
|
||||
" return self.fc(x)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"要準備用於訓練的數據集，我們需要提供一個轉換函數來準備偏移向量：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def offsetify(b):\n",
|
||||
" # first, compute data tensor from all sequences\n",
|
||||
" x = [torch.tensor(encode(t[1])) for t in b]\n",
|
||||
" # now, compute the offsets by accumulating the tensor of sequence lengths\n",
|
||||
" o = [0] + [len(t) for t in x]\n",
|
||||
" o = torch.tensor(o[:-1]).cumsum(dim=0)\n",
|
||||
" return ( \n",
|
||||
" torch.LongTensor([t[0]-1 for t in b]), # labels\n",
|
||||
" torch.cat(x), # text \n",
|
||||
" o\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, collate_fn=offsetify, shuffle=True)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"注意，與之前所有的例子不同，我們的網絡現在接受兩個參數：數據向量和偏移向量，它們的大小不同。同樣地，我們的數據加載器也提供了3個值而不是2個：文本和偏移向量都作為特徵提供。因此，我們需要稍微調整我們的訓練函數來處理這一點：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3200: acc=0.6153125\n",
|
||||
"6400: acc=0.6615625\n",
|
||||
"9600: acc=0.6932291666666667\n",
|
||||
"12800: acc=0.715078125\n",
|
||||
"16000: acc=0.7270625\n",
|
||||
"19200: acc=0.7382291666666667\n",
|
||||
"22400: acc=0.7486160714285715\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(22.771553103007037, 0.7551983365323096)"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"net = EmbedClassifier(vocab_size,32,len(classes)).to(device)\n",
|
||||
"\n",
|
||||
"def train_epoch_emb(net,dataloader,lr=0.01,optimizer=None,loss_fn = torch.nn.CrossEntropyLoss(),epoch_size=None, report_freq=200):\n",
|
||||
" optimizer = optimizer or torch.optim.Adam(net.parameters(),lr=lr)\n",
|
||||
" loss_fn = loss_fn.to(device)\n",
|
||||
" net.train()\n",
|
||||
" total_loss,acc,count,i = 0,0,0,0\n",
|
||||
" for labels,text,off in dataloader:\n",
|
||||
" optimizer.zero_grad()\n",
|
||||
" labels,text,off = labels.to(device), text.to(device), off.to(device)\n",
|
||||
" out = net(text, off)\n",
|
||||
" loss = loss_fn(out,labels) #cross_entropy(out,labels)\n",
|
||||
" loss.backward()\n",
|
||||
" optimizer.step()\n",
|
||||
" total_loss+=loss\n",
|
||||
" _,predicted = torch.max(out,1)\n",
|
||||
" acc+=(predicted==labels).sum()\n",
|
||||
" count+=len(labels)\n",
|
||||
" i+=1\n",
|
||||
" if i%report_freq==0:\n",
|
||||
" print(f\"{count}: acc={acc.item()/count}\")\n",
|
||||
" if epoch_size and count>epoch_size:\n",
|
||||
" break\n",
|
||||
" return total_loss.item()/count, acc.item()/count\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"train_epoch_emb(net,train_loader, lr=4, epoch_size=25000)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 語意嵌入：Word2Vec\n",
|
||||
"\n",
|
||||
"在之前的例子中，模型的嵌入層學會了將文字映射到向量表示，但這種表示並沒有太多語意上的意義。如果能學習到一種向量表示，使得相似的詞或同義詞在某種向量距離（例如歐幾里得距離）上彼此接近，那就更好了。\n",
|
||||
"\n",
|
||||
"為了達到這個目標，我們需要以特定的方式在大量文本上預訓練嵌入模型。最早的語意嵌入訓練方法之一被稱為 [Word2Vec](https://en.wikipedia.org/wiki/Word2vec)。它基於兩種主要架構，用於生成詞的分佈式表示：\n",
|
||||
"\n",
|
||||
" - **連續詞袋模型** (CBoW) — 在這種架構中，我們訓練模型根據周圍的上下文來預測一個詞。給定 ngram $(W_{-2},W_{-1},W_0,W_1,W_2)$，模型的目標是從 $(W_{-2},W_{-1},W_1,W_2)$ 預測 $W_0$。\n",
|
||||
" - **連續跳元模型** (Skip-Gram) 則與 CBoW 相反。模型使用周圍窗口的上下文詞來預測當前詞。\n",
|
||||
"\n",
|
||||
"CBoW 的速度較快，而 Skip-Gram 的速度較慢，但在表示不常見詞方面表現更好。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"要嘗試使用 Google News 數據集預訓練的 Word2Vec 嵌入，我們可以使用 **gensim** 庫。以下是找到與「neural」最相似的詞的示例：\n",
|
||||
"\n",
|
||||
"> **注意:** 當你第一次創建詞向量時，下載它們可能需要一些時間！\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import gensim.downloader as api\n",
|
||||
"w2v = api.load('word2vec-google-news-300')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"neuronal -> 0.7804799675941467\n",
|
||||
"neurons -> 0.7326500415802002\n",
|
||||
"neural_circuits -> 0.7252851724624634\n",
|
||||
"neuron -> 0.7174385190010071\n",
|
||||
"cortical -> 0.6941086649894714\n",
|
||||
"brain_circuitry -> 0.6923246383666992\n",
|
||||
"synaptic -> 0.6699118614196777\n",
|
||||
"neural_circuitry -> 0.6638563275337219\n",
|
||||
"neurochemical -> 0.6555314064025879\n",
|
||||
"neuronal_activity -> 0.6531826257705688\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for w,p in w2v.most_similar('neural'):\n",
|
||||
" print(f\"{w} -> {p}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們也可以從詞中計算向量嵌入，用於訓練分類模型（為了清楚起見，我們僅顯示向量的前20個組件）：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([ 0.01226807, 0.06225586, 0.10693359, 0.05810547, 0.23828125,\n",
|
||||
" 0.03686523, 0.05151367, -0.20703125, 0.01989746, 0.10058594,\n",
|
||||
" -0.03759766, -0.1015625 , -0.15820312, -0.08105469, -0.0390625 ,\n",
|
||||
" -0.05053711, 0.16015625, 0.2578125 , 0.10058594, -0.25976562],\n",
|
||||
" dtype=float32)"
|
||||
]
|
||||
},
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"w2v.word_vec('play')[:20]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"語義嵌入的優點在於可以操控向量編碼來改變語義。例如，我們可以要求找到一個詞，其向量表示盡可能接近詞 *king* 和 *woman*，並且盡可能遠離詞 *man*：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"('queen', 0.7118192911148071)"
|
||||
]
|
||||
},
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"w2v.most_similar(positive=['king','woman'],negative=['man'])[0]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"CBoW 和 Skip-Grams 都是「預測型」嵌入，因為它們只考慮局部上下文。Word2Vec 並未利用全局上下文。\n",
|
||||
"\n",
|
||||
"**FastText** 基於 Word2Vec，通過為每個單詞以及單詞內的字符 n-grams 學習向量表示來進一步擴展。在每次訓練步驟中，這些表示的值會被平均成一個向量。雖然這增加了預訓練的計算量，但它使得詞嵌入能夠編碼子詞信息。\n",
|
||||
"\n",
|
||||
"另一種方法，**GloVe**，利用共現矩陣的概念，使用神經方法將共現矩陣分解為更具表達性和非線性的詞向量。\n",
|
||||
"\n",
|
||||
"你可以通過將嵌入模型切換為 FastText 和 GloVe 來試驗這些例子，因為 gensim 支援多種不同的詞嵌入模型。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 在 PyTorch 中使用預訓練的嵌入\n",
|
||||
"\n",
|
||||
"我們可以修改上述範例，將嵌入層中的矩陣預先填入語義嵌入，例如 Word2Vec。我們需要考慮到，預訓練嵌入的詞彙表與我們文本語料庫的詞彙表可能不匹配，因此我們將用隨機值初始化缺失詞彙的權重：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"metadata": {
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Embedding size: 300\n",
|
||||
"Populating matrix, this will take some time...Done, found 41080 words, 54732 words missing\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"embed_size = len(w2v.get_vector('hello'))\n",
|
||||
"print(f'Embedding size: {embed_size}')\n",
|
||||
"\n",
|
||||
"net = EmbedClassifier(vocab_size,embed_size,len(classes))\n",
|
||||
"\n",
|
||||
"print('Populating matrix, this will take some time...',end='')\n",
|
||||
"found, not_found = 0,0\n",
|
||||
"for i,w in enumerate(vocab.get_itos()):\n",
|
||||
" try:\n",
|
||||
" net.embedding.weight[i].data = torch.tensor(w2v.get_vector(w))\n",
|
||||
" found+=1\n",
|
||||
" except:\n",
|
||||
" net.embedding.weight[i].data = torch.normal(0.0,1.0,(embed_size,))\n",
|
||||
" not_found+=1\n",
|
||||
"\n",
|
||||
"print(f\"Done, found {found} words, {not_found} words missing\")\n",
|
||||
"net = net.to(device)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在讓我們訓練模型。請注意，由於嵌入層的大小更大，因此參數的數量也大幅增加，訓練模型所需的時間比前一個例子顯著增加。此外，正因如此，如果我們想避免過擬合，可能需要在更多的例子上訓練模型。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3200: acc=0.6359375\n",
|
||||
"6400: acc=0.68109375\n",
|
||||
"9600: acc=0.7067708333333333\n",
|
||||
"12800: acc=0.723671875\n",
|
||||
"16000: acc=0.73625\n",
|
||||
"19200: acc=0.7463541666666667\n",
|
||||
"22400: acc=0.7560714285714286\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(214.1013875559821, 0.7626759436980166)"
|
||||
]
|
||||
},
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"train_epoch_emb(net,train_loader, lr=4, epoch_size=25000)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"在我們的情況中，並未看到準確率有顯著提升，這可能是由於詞彙差異較大所致。 \n",
|
||||
"為了解決詞彙差異的問題，我們可以採用以下解決方案之一： \n",
|
||||
"* 重新訓練 word2vec 模型以適應我們的詞彙 \n",
|
||||
"* 使用預訓練的 word2vec 模型的詞彙來載入我們的數據集。在載入數據集時，可以指定使用的詞彙。 \n",
|
||||
"\n",
|
||||
"後者的方法似乎更簡單，尤其是因為 PyTorch 的 `torchtext` 框架內建了對嵌入的支持。例如，我們可以以下列方式實例化基於 GloVe 的詞彙： \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stderr",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"100%|█████████▉| 399999/400000 [00:15<00:00, 25411.14it/s]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vocab = torchtext.vocab.GloVe(name='6B', dim=50)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"已載入的詞彙表具有以下基本操作：\n",
|
||||
"* `vocab.stoi` 字典允許我們將單詞轉換為其在字典中的索引\n",
|
||||
"* `vocab.itos` 則執行相反的操作——將數字轉換為單詞\n",
|
||||
"* `vocab.vectors` 是嵌入向量的數組，因此要獲取單詞 `s` 的嵌入，我們需要使用 `vocab.vectors[vocab.stoi[s]]`\n",
|
||||
"\n",
|
||||
"以下是一個操作嵌入的範例，用來展示方程式 **kind-man+woman = queen**（我稍微調整了一下係數以使其生效）：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'queen'"
|
||||
]
|
||||
},
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# get the vector corresponding to kind-man+woman\n",
|
||||
"qvec = vocab.vectors[vocab.stoi['king']]-vocab.vectors[vocab.stoi['man']]+1.3*vocab.vectors[vocab.stoi['woman']]\n",
|
||||
"# find the index of the closest embedding vector \n",
|
||||
"d = torch.sum((vocab.vectors-qvec)**2,dim=1)\n",
|
||||
"min_idx = torch.argmin(d)\n",
|
||||
"# find the corresponding word\n",
|
||||
"vocab.itos[min_idx]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"要使用這些嵌入來訓練分類器，我們首先需要使用GloVe詞彙表對我們的數據集進行編碼：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def offsetify(b):\n",
|
||||
" # first, compute data tensor from all sequences\n",
|
||||
" x = [torch.tensor(encode(t[1],voc=vocab)) for t in b] # pass the instance of vocab to encode function!\n",
|
||||
" # now, compute the offsets by accumulating the tensor of sequence lengths\n",
|
||||
" o = [0] + [len(t) for t in x]\n",
|
||||
" o = torch.tensor(o[:-1]).cumsum(dim=0)\n",
|
||||
" return ( \n",
|
||||
" torch.LongTensor([t[0]-1 for t in b]), # labels\n",
|
||||
" torch.cat(x), # text \n",
|
||||
" o\n",
|
||||
" )"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"如上所述，所有向量嵌入都存儲在 `vocab.vectors` 矩陣中。這使得通過簡單的複製將這些權重加載到嵌入層的權重中變得非常容易：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 17,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"net = EmbedClassifier(len(vocab),len(vocab.vectors[0]),len(classes))\n",
|
||||
"net.embedding.weight.data = vocab.vectors\n",
|
||||
"net = net.to(device)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在讓我們訓練模型，看看是否能獲得更好的結果：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 18,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3200: acc=0.6271875\n",
|
||||
"6400: acc=0.68078125\n",
|
||||
"9600: acc=0.7030208333333333\n",
|
||||
"12800: acc=0.71984375\n",
|
||||
"16000: acc=0.7346875\n",
|
||||
"19200: acc=0.7455729166666667\n",
|
||||
"22400: acc=0.7529464285714286\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(35.53972978646833, 0.7575175943698017)"
|
||||
]
|
||||
},
|
||||
"execution_count": 18,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, collate_fn=offsetify, shuffle=True)\n",
|
||||
"train_epoch_emb(net,train_loader, lr=4, epoch_size=25000)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們未看到準確性顯著提高的原因之一是因為我們的數據集中的某些詞語在預訓練的GloVe詞彙表中缺失，因此它們基本上被忽略了。為了克服這一問題，我們可以在我們的數據集上訓練自己的嵌入。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 語境嵌入\n",
|
||||
"\n",
|
||||
"傳統預訓練嵌入表示（例如 Word2Vec）的一個主要限制是詞義消歧的問題。雖然預訓練嵌入可以捕捉到一些單詞在語境中的含義，但每個單詞的所有可能含義都被編碼到同一個嵌入中。這可能會在下游模型中引發問題，因為許多單詞（例如 \"play\"）的含義會根據使用的語境而有所不同。\n",
|
||||
"\n",
|
||||
"例如，單詞 \"play\" 在以下兩個句子中的含義就完全不同：\n",
|
||||
"- 我去劇院看了一場**戲劇**。\n",
|
||||
"- 約翰想和他的朋友們一起**玩**。\n",
|
||||
"\n",
|
||||
"上述的預訓練嵌入將 \"play\" 的這兩種含義表示為相同的嵌入。為了克服這一限制，我們需要基於**語言模型**來構建嵌入，該模型是在大規模文本語料庫上訓練的，並且*知道*單詞如何在不同語境中組合使用。討論語境嵌入超出了本教程的範圍，但我們會在下一單元討論語言模型時回到這個主題。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "0cb620c6d4b9f7a635928804c26cf22403d89d98d79684e4529119355ee6d5a5"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "py37_pytorch",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "f50b026abce5cf36783a560ea72cb9b1",
|
||||
"translation_date": "2025-08-31T10:54:45+00:00",
|
||||
"source_file": "lessons/5-NLP/14-Embeddings/EmbeddingsPyTorch.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
|
|
@ -0,0 +1,695 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 嵌入\n",
|
||||
"\n",
|
||||
"在之前的例子中，我們使用了高維度的詞袋向量，其長度為 `vocab_size`，並且我們將低維度的位置表示向量顯式轉換為稀疏的獨熱表示。然而，這種獨熱表示並不具備記憶效率。此外，每個詞都被獨立處理，因此獨熱編碼的向量無法表達詞與詞之間的語義相似性。\n",
|
||||
"\n",
|
||||
"在本單元中，我們將繼續探索 **News AG** 數據集。首先，讓我們載入數據並從上一單元中獲取一些定義。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import tensorflow as tf\n",
|
||||
"from tensorflow import keras\n",
|
||||
"import tensorflow_datasets as tfds\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"ds_train, ds_test = tfds.load('ag_news_subset').values()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 什麼是嵌入？\n",
|
||||
"\n",
|
||||
"**嵌入**的概念是使用低維度的密集向量來表示單詞，這些向量反映了單詞的語義。稍後我們會討論如何構建有意義的單詞嵌入，但目前可以將嵌入理解為一種降低單詞向量維度的方法。\n",
|
||||
"\n",
|
||||
"嵌入層以單詞作為輸入，並生成指定的 `embedding_size` 的輸出向量。某種程度上，它與 `Dense` 層非常相似，但嵌入層不需要以一個 one-hot 編碼向量作為輸入，而是可以直接接受單詞編號。\n",
|
||||
"\n",
|
||||
"通過在網絡中使用嵌入層作為第一層，我們可以從詞袋模型切換到 **嵌入袋** 模型。在嵌入袋模型中，我們首先將文本中的每個單詞轉換為相應的嵌入，然後對所有嵌入進行某種聚合函數計算，例如 `sum`、`average` 或 `max`。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"我們的分類器神經網絡包含以下幾層：\n",
|
||||
"\n",
|
||||
"* `TextVectorization` 層：該層以字符串作為輸入，並生成一個包含標記編號的張量。我們會指定一個合理的詞彙表大小 `vocab_size`，並忽略使用頻率較低的單詞。輸入形狀為 1，輸出形狀為 $n$，因為結果中會有 $n$ 個標記，每個標記包含從 0 到 `vocab_size` 的編號。\n",
|
||||
"* `Embedding` 層：該層接收 $n$ 個編號，並將每個編號縮減為指定長度的密集向量（在我們的例子中為 100）。因此，形狀為 $n$ 的輸入張量將被轉換為 $n\\times 100$ 的張量。\n",
|
||||
"* 聚合層：該層沿第一軸計算該張量的平均值，即計算所有 $n$ 個輸入張量（對應於不同單詞）的平均值。為了實現該層，我們將使用 `Lambda` 層，並向其中傳遞計算平均值的函數。輸出形狀為 100，這將是整個輸入序列的數字表示。\n",
|
||||
"* 最後的 `Dense` 線性分類器。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"sequential\"\n",
|
||||
"_________________________________________________________________\n",
|
||||
" Layer (type) Output Shape Param # \n",
|
||||
"=================================================================\n",
|
||||
" text_vectorization (TextVec (None, None) 0 \n",
|
||||
" torization) \n",
|
||||
" \n",
|
||||
" embedding (Embedding) (None, None, 100) 3000000 \n",
|
||||
" \n",
|
||||
" lambda (Lambda) (None, 100) 0 \n",
|
||||
" \n",
|
||||
" dense (Dense) (None, 4) 404 \n",
|
||||
" \n",
|
||||
"=================================================================\n",
|
||||
"Total params: 3,000,404\n",
|
||||
"Trainable params: 3,000,404\n",
|
||||
"Non-trainable params: 0\n",
|
||||
"_________________________________________________________________\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vocab_size = 30000\n",
|
||||
"batch_size = 128\n",
|
||||
"\n",
|
||||
"vectorizer = keras.layers.experimental.preprocessing.TextVectorization(max_tokens=vocab_size,input_shape=(1,))\n",
|
||||
"\n",
|
||||
"model = keras.models.Sequential([\n",
|
||||
" vectorizer, \n",
|
||||
" keras.layers.Embedding(vocab_size,100),\n",
|
||||
" keras.layers.Lambda(lambda x: tf.reduce_mean(x,axis=1)),\n",
|
||||
" keras.layers.Dense(4, activation='softmax')\n",
|
||||
"])\n",
|
||||
"model.summary()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"在 `summary` 列印輸出中，**output shape** 欄位的第一個張量維度 `None` 代表小批量的大小，第二個維度則代表標記序列的長度。小批量中的所有標記序列長度都不相同。我們將在下一節討論如何處理這個問題。\n",
|
||||
"\n",
|
||||
"現在讓我們開始訓練網路：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Training vectorizer\n",
|
||||
"938/938 [==============================] - 20s 20ms/step - loss: 0.7891 - acc: 0.8155 - val_loss: 0.4470 - val_acc: 0.8642\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<keras.callbacks.History at 0x22255515100>"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def extract_text(x):\n",
|
||||
" return x['title']+' '+x['description']\n",
|
||||
"\n",
|
||||
"def tupelize(x):\n",
|
||||
" return (extract_text(x),x['label'])\n",
|
||||
"\n",
|
||||
"print(\"Training vectorizer\")\n",
|
||||
"vectorizer.adapt(ds_train.take(500).map(extract_text))\n",
|
||||
"\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'])\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(batch_size),validation_data=ds_test.map(tupelize).batch(batch_size))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"nteract": {
|
||||
"transient": {
|
||||
"deleting": false
|
||||
}
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"> **注意** 我們正在基於數據的子集構建向量化器。這樣做是為了加快過程，可能會導致我們文本中的某些詞彙未出現在詞彙表中。在這種情況下，這些詞彙將被忽略，這可能會導致準確性略有下降。然而，在現實生活中，文本的子集通常能夠提供良好的詞彙估計。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 處理變化的序列大小\n",
|
||||
"\n",
|
||||
"讓我們來了解如何在小批量中進行訓練。在上面的例子中，輸入張量的維度為 1，我們使用 128 長度的小批量，因此張量的實際大小為 $128 \\times 1$。然而，每個句子中的標記數量是不同的。如果我們將 `TextVectorization` 層應用於單一輸入，返回的標記數量會有所不同，這取決於文本如何被分詞：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"tf.Tensor([ 1 45], shape=(2,), dtype=int64)\n",
|
||||
"tf.Tensor([ 112 1271 1 3 1747 158], shape=(6,), dtype=int64)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"print(vectorizer('Hello, world!'))\n",
|
||||
"print(vectorizer('I am glad to meet you!'))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"然而，當我們將向量化器應用於多個序列時，它必須生成一個矩形形狀的張量，因此會用 PAD 標記（在我們的情況下是零）填充未使用的元素：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tf.Tensor: shape=(2, 6), dtype=int64, numpy=\n",
|
||||
"array([[ 1, 45, 0, 0, 0, 0],\n",
|
||||
" [ 112, 1271, 1, 3, 1747, 158]], dtype=int64)>"
|
||||
]
|
||||
},
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vectorizer(['Hello, world!','I am glad to meet you!'])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"在這裡我們可以看到嵌入：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([[[ 1.53059261e-02, 6.80514947e-02, 3.14026810e-02, ...,\n",
|
||||
" -8.92002955e-02, 1.52911525e-04, -5.65562584e-02],\n",
|
||||
" [ 2.57456154e-01, 2.79364467e-01, -2.03605562e-01, ...,\n",
|
||||
" -2.07474351e-01, 8.31158683e-02, -2.03911960e-01],\n",
|
||||
" [ 3.98201384e-02, -8.03454965e-03, 2.39790026e-02, ...,\n",
|
||||
" -7.18549127e-04, 2.66963355e-02, -4.30646613e-02],\n",
|
||||
" [ 3.98201384e-02, -8.03454965e-03, 2.39790026e-02, ...,\n",
|
||||
" -7.18549127e-04, 2.66963355e-02, -4.30646613e-02],\n",
|
||||
" [ 3.98201384e-02, -8.03454965e-03, 2.39790026e-02, ...,\n",
|
||||
" -7.18549127e-04, 2.66963355e-02, -4.30646613e-02],\n",
|
||||
" [ 3.98201384e-02, -8.03454965e-03, 2.39790026e-02, ...,\n",
|
||||
" -7.18549127e-04, 2.66963355e-02, -4.30646613e-02]],\n",
|
||||
"\n",
|
||||
" [[ 1.89674050e-01, 2.61548996e-01, -3.67433839e-02, ...,\n",
|
||||
" -2.07366899e-01, -1.05442435e-01, -2.36952081e-01],\n",
|
||||
" [ 6.16133213e-02, 1.80511594e-01, 9.77298319e-02, ...,\n",
|
||||
" -5.46628237e-02, -1.07340455e-01, -1.06589928e-01],\n",
|
||||
" [ 1.53059261e-02, 6.80514947e-02, 3.14026810e-02, ...,\n",
|
||||
" -8.92002955e-02, 1.52911525e-04, -5.65562584e-02],\n",
|
||||
" [-4.84890305e-02, -8.41715634e-02, 1.51529670e-01, ...,\n",
|
||||
" 1.28192469e-01, -7.77286515e-02, 1.26041949e-01],\n",
|
||||
" [-4.17212099e-02, -5.60694858e-02, 4.08860669e-02, ...,\n",
|
||||
" 8.70475471e-02, 8.92383084e-02, 1.67974353e-01],\n",
|
||||
" [ 2.85779923e-01, 4.57767487e-01, 4.52292450e-02, ...,\n",
|
||||
" -1.97419018e-01, -2.04659685e-01, -2.79758364e-01]]],\n",
|
||||
" dtype=float32)"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.layers[1](vectorizer(['Hello, world!','I am glad to meet you!'])).numpy()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意**：為了減少填充的數量，在某些情況下，將數據集中所有序列按長度（更準確地說是按標記數量）遞增排序是有意義的。這將確保每個小批次包含相似長度的序列。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 語意嵌入：Word2Vec\n",
|
||||
"\n",
|
||||
"在我們之前的例子中，嵌入層學習將單詞映射到向量表示，但這些表示並不具有語意上的意義。如果能學習一種向量表示，使得相似的單詞或同義詞在某種向量距離（例如歐幾里得距離）上彼此接近，那就更好了。\n",
|
||||
"\n",
|
||||
"為了實現這一點，我們需要使用像 [Word2Vec](https://en.wikipedia.org/wiki/Word2vec) 這樣的技術，在大量文本集合上預訓練嵌入模型。它基於兩種主要架構來生成單詞的分佈式表示：\n",
|
||||
"\n",
|
||||
" - **連續詞袋模型** (CBoW)，我們訓練模型根據周圍的上下文來預測一個單詞。給定 ngram $(W_{-2},W_{-1},W_0,W_1,W_2)$，模型的目標是根據 $(W_{-2},W_{-1},W_1,W_2)$ 預測 $W_0$。\n",
|
||||
" - **連續跳字模型** (Skip-Gram) 則與 CBoW 相反。模型使用周圍窗口中的上下文單詞來預測當前單詞。\n",
|
||||
"\n",
|
||||
"CBoW 的速度較快，而 Skip-Gram 雖然速度較慢，但在表示不常見單詞方面效果更佳。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"為了試驗基於 Google News 數據集預訓練的 Word2Vec 嵌入，我們可以使用 **gensim** 庫。以下是找到與「neural」最相似的單詞的示例。\n",
|
||||
"\n",
|
||||
"> **注意:** 當您首次創建單詞向量時，下載它們可能需要一些時間！\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import gensim.downloader as api\n",
|
||||
"w2v = api.load('word2vec-google-news-300')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"neuronal -> 0.7804799675941467\n",
|
||||
"neurons -> 0.7326500415802002\n",
|
||||
"neural_circuits -> 0.7252851724624634\n",
|
||||
"neuron -> 0.7174385190010071\n",
|
||||
"cortical -> 0.6941086649894714\n",
|
||||
"brain_circuitry -> 0.6923246383666992\n",
|
||||
"synaptic -> 0.6699118614196777\n",
|
||||
"neural_circuitry -> 0.6638563275337219\n",
|
||||
"neurochemical -> 0.6555314064025879\n",
|
||||
"neuronal_activity -> 0.6531826257705688\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for w,p in w2v.most_similar('neural'):\n",
|
||||
" print(f\"{w} -> {p}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們還可以從該詞中提取向量嵌入，用於訓練分類模型。該嵌入有300個組件，但這裡為了清楚起見，我們僅顯示向量的前20個組件：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([ 0.01226807, 0.06225586, 0.10693359, 0.05810547, 0.23828125,\n",
|
||||
" 0.03686523, 0.05151367, -0.20703125, 0.01989746, 0.10058594,\n",
|
||||
" -0.03759766, -0.1015625 , -0.15820312, -0.08105469, -0.0390625 ,\n",
|
||||
" -0.05053711, 0.16015625, 0.2578125 , 0.10058594, -0.25976562],\n",
|
||||
" dtype=float32)"
|
||||
]
|
||||
},
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"w2v['play'][:20]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"語義嵌入的偉大之處在於您可以根據語義操控向量編碼。例如，我們可以要求找到一個其向量表示盡可能接近*國王*和*女人*，並且盡可能遠離*男人*的詞：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"('queen', 0.7118192911148071)"
|
||||
]
|
||||
},
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"w2v.most_similar(positive=['king','woman'],negative=['man'])[0]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"上面的例子使用了一些內部的 GenSym 魔法，但其底層邏輯其實相當簡單。關於嵌入的一個有趣之處是，你可以對嵌入向量執行正常的向量運算，而這將反映在詞語**意義**上的操作。上面的例子可以用向量運算來表達：我們計算出對應於 **KING-MAN+WOMAN** 的向量（對應詞語的向量表示執行 `+` 和 `-` 運算），然後在字典中找到最接近該向量的詞語：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'queen'"
|
||||
]
|
||||
},
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# get the vector corresponding to kind-man+woman\n",
|
||||
"qvec = w2v['king']-1.7*w2v['man']+1.7*w2v['woman']\n",
|
||||
"# find the index of the closest embedding vector \n",
|
||||
"d = np.sum((w2v.vectors-qvec)**2,axis=1)\n",
|
||||
"min_idx = np.argmin(d)\n",
|
||||
"# find the corresponding word\n",
|
||||
"w2v.index_to_key[min_idx]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **NOTE**: 我們需要在 *man* 和 *woman* 向量中添加一個小係數 - 試著移除它們看看會發生什麼。\n",
|
||||
"\n",
|
||||
"為了找到最接近的向量，我們使用 TensorFlow 的機制來計算我們的向量與詞彙表中所有向量之間的距離向量，然後使用 `argmin` 找到最小距離的詞的索引。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"雖然 Word2Vec 看起來是一種表達詞語語義的好方法，但它有許多缺點，包括以下幾點：\n",
|
||||
"\n",
|
||||
"* CBoW 和 skip-gram 模型都是**預測型嵌入**，它們只考慮局部上下文。Word2Vec 無法利用全局上下文。\n",
|
||||
"* Word2Vec 沒有考慮到詞語的**形態學**，也就是說，詞語的意義可能取決於詞的不同部分，例如詞根。\n",
|
||||
"\n",
|
||||
"**FastText** 試圖克服第二個限制，並在 Word2Vec 的基礎上進一步改進，通過學習每個詞以及詞內字符 n-grams 的向量表示來實現。在每次訓練步驟中，這些表示的值會被平均為一個向量。雖然這為預訓練增加了大量的計算，但它使詞嵌入能夠編碼子詞資訊。\n",
|
||||
"\n",
|
||||
"另一種方法，**GloVe**，採用了與 Word2Vec 不同的詞嵌入方法，基於詞-上下文矩陣的分解。首先，它構建了一個大型矩陣，記錄詞語在不同上下文中的出現次數，然後嘗試以降低維度的方式表示該矩陣，從而最小化重建損失。\n",
|
||||
"\n",
|
||||
"gensim 庫支持這些詞嵌入方法，您可以通過更改上方的模型加載代碼來嘗試使用它們。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 在 Keras 中使用預訓練的嵌入\n",
|
||||
"\n",
|
||||
"我們可以修改上述範例，將嵌入層中的矩陣預先填入語義嵌入，例如 Word2Vec。預訓練嵌入的詞彙表和文本語料庫的詞彙表可能不匹配，因此我們需要選擇其中一個。在這裡，我們探討兩種可能的選擇：使用分詞器的詞彙表，或使用 Word2Vec 嵌入的詞彙表。\n",
|
||||
"\n",
|
||||
"### 使用分詞器詞彙表\n",
|
||||
"\n",
|
||||
"當使用分詞器的詞彙表時，詞彙表中的某些單詞會有對應的 Word2Vec 嵌入，而某些則會缺失。假設我們的詞彙表大小為 `vocab_size`，而 Word2Vec 嵌入向量的長度為 `embed_size`，那麼嵌入層將由一個形狀為 `vocab_size`$\\times$`embed_size` 的權重矩陣表示。我們將通過遍歷詞彙表來填充這個矩陣：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Embedding size: 300\n",
|
||||
"Populating matrix, this will take some time...Done, found 4551 words, 784 words missing\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"embed_size = len(w2v.get_vector('hello'))\n",
|
||||
"print(f'Embedding size: {embed_size}')\n",
|
||||
"\n",
|
||||
"vocab = vectorizer.get_vocabulary()\n",
|
||||
"W = np.zeros((vocab_size,embed_size))\n",
|
||||
"print('Populating matrix, this will take some time...',end='')\n",
|
||||
"found, not_found = 0,0\n",
|
||||
"for i,w in enumerate(vocab):\n",
|
||||
" try:\n",
|
||||
" W[i] = w2v.get_vector(w)\n",
|
||||
" found+=1\n",
|
||||
" except:\n",
|
||||
" # W[i] = np.random.normal(0.0,0.3,size=(embed_size,))\n",
|
||||
" not_found+=1\n",
|
||||
"\n",
|
||||
"print(f\"Done, found {found} words, {not_found} words missing\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"對於不在 Word2Vec 詞彙表中的單詞，我們可以選擇將它們設為零向量，或者生成一個隨機向量。\n",
|
||||
"\n",
|
||||
"現在我們可以定義一個帶有預訓練權重的嵌入層：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"emb = keras.layers.Embedding(vocab_size,embed_size,weights=[W],trainable=False)\n",
|
||||
"model = keras.models.Sequential([\n",
|
||||
" vectorizer, emb,\n",
|
||||
" keras.layers.Lambda(lambda x: tf.reduce_mean(x,axis=1)),\n",
|
||||
" keras.layers.Dense(4, activation='softmax')\n",
|
||||
"])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"938/938 [==============================] - 10s 10ms/step - loss: 1.1075 - acc: 0.7822 - val_loss: 0.9134 - val_acc: 0.8175\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<keras.callbacks.History at 0x2220226ef10>"
|
||||
]
|
||||
},
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'])\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(batch_size),\n",
|
||||
" validation_data=ds_test.map(tupelize).batch(batch_size))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意**：請注意，我們在建立 `Embedding` 時設置了 `trainable=False`，這表示我們不會重新訓練 Embedding 層。這可能會導致準確率稍微降低，但能加快訓練速度。\n",
|
||||
"\n",
|
||||
"### 使用嵌入詞彙表\n",
|
||||
"\n",
|
||||
"之前方法的一個問題是，TextVectorization 和 Embedding 使用的詞彙表不同。為了解決這個問題，我們可以採用以下其中一種解決方案：\n",
|
||||
"* 重新訓練 Word2Vec 模型以適配我們的詞彙表。\n",
|
||||
"* 使用預訓練 Word2Vec 模型的詞彙表來載入我們的數據集。在載入數據集時，可以指定使用的詞彙表。\n",
|
||||
"\n",
|
||||
"第二種方法看起來更簡單，因此我們來實現它。首先，我們將使用從 Word2Vec 嵌入中提取的指定詞彙表來建立一個 `TextVectorization` 層：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"vocab = list(w2v.vocab.keys())\n",
|
||||
"vectorizer = keras.layers.experimental.preprocessing.TextVectorization(input_shape=(1,))\n",
|
||||
"vectorizer.set_vocabulary(vocab)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"gensim 的詞嵌入庫包含一個方便的函數 `get_keras_embeddings`，它會自動為您創建相應的 Keras 嵌入層。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Epoch 1/5\n",
|
||||
"938/938 [==============================] - 20s 14ms/step - loss: 1.3377 - acc: 0.4978 - val_loss: 1.2995 - val_acc: 0.5647\n",
|
||||
"Epoch 2/5\n",
|
||||
"938/938 [==============================] - 10s 10ms/step - loss: 1.2587 - acc: 0.5722 - val_loss: 1.2339 - val_acc: 0.5842\n",
|
||||
"Epoch 3/5\n",
|
||||
"938/938 [==============================] - 10s 10ms/step - loss: 1.1980 - acc: 0.5884 - val_loss: 1.1826 - val_acc: 0.5954\n",
|
||||
"Epoch 4/5\n",
|
||||
"938/938 [==============================] - 12s 13ms/step - loss: 1.1503 - acc: 0.6002 - val_loss: 1.1417 - val_acc: 0.6018\n",
|
||||
"Epoch 5/5\n",
|
||||
"938/938 [==============================] - 11s 12ms/step - loss: 1.1120 - acc: 0.6097 - val_loss: 1.1083 - val_acc: 0.6104\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<keras.callbacks.History at 0x2220ccb81c0>"
|
||||
]
|
||||
},
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = keras.models.Sequential([\n",
|
||||
" vectorizer, \n",
|
||||
" w2v.get_keras_embedding(train_embeddings=False),\n",
|
||||
" keras.layers.Lambda(lambda x: tf.reduce_mean(x,axis=1)),\n",
|
||||
" keras.layers.Dense(4, activation='softmax')\n",
|
||||
"])\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'])\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(128),validation_data=ds_test.map(tupelize).batch(128),epochs=5)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們未能看到更高準確率的原因之一是因為我們的數據集中有些詞在預訓練的 GloVe 詞彙表中缺失，因此它們實際上被忽略了。為了解決這個問題，我們可以基於我們的數據集訓練我們自己的詞嵌入。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 語境嵌入\n",
|
||||
"\n",
|
||||
"傳統的預訓練嵌入表示（例如 Word2Vec）的一個主要限制是，儘管它們能捕捉到某些詞語的含義，但無法區分不同的含義。這可能會在下游模型中引發問題。\n",
|
||||
"\n",
|
||||
"例如，\"play\" 這個詞在以下兩個句子中有不同的含義：\n",
|
||||
"- 我去劇院看了一場**戲劇**。\n",
|
||||
"- 約翰想和他的朋友們一起**玩**。\n",
|
||||
"\n",
|
||||
"我們之前提到的預訓練嵌入會將 \"play\" 的兩種含義表示為相同的嵌入。為了克服這一限制，我們需要基於**語言模型**來構建嵌入。語言模型是在大量文本語料庫上訓練的，並且*了解*詞語如何在不同的語境中組合使用。討論語境嵌入超出了本教程的範圍，但我們會在下一單元討論語言模型時回到這個主題。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "0cb620c6d4b9f7a635928804c26cf22403d89d98d79684e4529119355ee6d5a5"
|
||||
},
|
||||
"kernel_info": {
|
||||
"name": "conda-env-py37_tensorflow-py"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "py37_tensorflow",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"nteract": {
|
||||
"version": "nteract-front-end@1.0.0"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "b859482be7f61d1eadc2c6a2720a37e4",
|
||||
"translation_date": "2025-08-31T10:51:43+00:00",
|
||||
"source_file": "lessons/5-NLP/14-Embeddings/EmbeddingsTF.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
# 嵌入
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/27)
|
||||
|
||||
在基於 BoW 或 TF/IDF 訓練分類器時，我們操作的是高維度的詞袋向量，其長度為 `vocab_size`，並且我們明確地將低維度的位置信息表示向量轉換為稀疏的單熱編碼表示。然而，這種單熱編碼表示並不具備內存效率。此外，每個詞都被獨立對待，即單熱編碼向量無法表達詞與詞之間的語義相似性。
|
||||
|
||||
**嵌入**的概念是用低維度的密集向量來表示詞，這些向量能夠在某種程度上反映詞的語義。我們稍後會討論如何構建有意義的詞嵌入，但現在先將嵌入理解為降低詞向量維度的一種方法。
|
||||
|
||||
嵌入層會將一個詞作為輸入，並生成指定 `embedding_size` 的輸出向量。從某種意義上說，它與 `Linear` 層非常相似，但嵌入層不需要單熱編碼向量作為輸入，而是可以直接接受詞的編號作為輸入，從而避免創建大型的單熱編碼向量。
|
||||
|
||||
通過在分類器網絡中使用嵌入層作為第一層，我們可以從詞袋模型切換到 **嵌入袋** 模型。在嵌入袋模型中，我們首先將文本中的每個詞轉換為相應的嵌入，然後對所有嵌入計算某種聚合函數，例如 `sum`、`average` 或 `max`。
|
||||
|
||||
|
||||
|
||||
> 圖片由作者提供
|
||||
|
||||
## ✍️ 練習：嵌入
|
||||
|
||||
繼續學習以下筆記本：
|
||||
* [使用 PyTorch 的嵌入](EmbeddingsPyTorch.ipynb)
|
||||
* [使用 TensorFlow 的嵌入](EmbeddingsTF.ipynb)
|
||||
|
||||
## 語義嵌入：Word2Vec
|
||||
|
||||
雖然嵌入層學會了將詞映射到向量表示，但這種表示未必具有很強的語義意義。我們希望學習一種向量表示，使得相似詞或同義詞在某種向量距離（例如歐幾里得距離）上彼此接近。
|
||||
|
||||
為了實現這一點，我們需要以特定方式在大量文本上預訓練嵌入模型。一種訓練語義嵌入的方法叫做 [Word2Vec](https://en.wikipedia.org/wiki/Word2vec)。它基於兩種主要架構來生成詞的分佈式表示：
|
||||
|
||||
- **連續詞袋** (CBoW) —— 在這種架構中，我們訓練模型根據上下文預測詞。給定 ngram $(W_{-2},W_{-1},W_0,W_1,W_2)$，模型的目標是根據 $(W_{-2},W_{-1},W_1,W_2)$ 預測 $W_0$。
|
||||
- **連續跳元** (Skip-Gram) —— 與 CBoW 相反，模型使用上下文窗口中的詞來預測當前詞。
|
||||
|
||||
CBoW 訓練速度更快，而 Skip-Gram 雖然較慢，但在表示不常見詞方面效果更好。
|
||||
|
||||
|
||||
|
||||
> 圖片來源：[這篇論文](https://arxiv.org/pdf/1301.3781.pdf)
|
||||
|
||||
Word2Vec 預訓練嵌入（以及其他類似模型，例如 GloVe）也可以用於神經網絡中的嵌入層。然而，我們需要處理詞彙表，因為用於預訓練 Word2Vec/GloVe 的詞彙表可能與我們文本語料庫中的詞彙表不同。查看上述筆記本以了解如何解決這個問題。
|
||||
|
||||
## 上下文嵌入
|
||||
|
||||
傳統的預訓練嵌入表示（如 Word2Vec）的一個主要限制是詞義消歧問題。雖然預訓練嵌入可以捕捉詞在上下文中的部分含義，但每個詞的所有可能含義都被編碼到同一嵌入中。這可能會在下游模型中引發問題，因為許多詞（例如 "play"）的含義會根據使用的上下文而有所不同。
|
||||
|
||||
例如，詞 "play" 在以下兩個句子中的含義完全不同：
|
||||
|
||||
- 我去劇院看了一場 **戲劇**。
|
||||
- 約翰想和朋友一起 **玩**。
|
||||
|
||||
上述預訓練嵌入將 "play" 的這兩種含義表示為同一嵌入。為了解決這一限制，我們需要基於 **語言模型** 構建嵌入，該模型在大量文本語料庫上訓練，並且*了解*詞如何在不同上下文中組合。討論上下文嵌入超出了本教程的範圍，但我們會在課程後續討論語言模型時回到這個主題。
|
||||
|
||||
## 結論
|
||||
|
||||
在本課中，你學習了如何在 TensorFlow 和 PyTorch 中構建和使用嵌入層，以更好地反映詞的語義。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
Word2Vec 已被用於一些有趣的應用，包括生成歌曲歌詞和詩歌。查看 [這篇文章](https://www.politetype.com/blog/word2vec-color-poems)，了解作者如何使用 Word2Vec 生成詩歌。還可以觀看 [Dan Shiffmann 的這段視頻](https://www.youtube.com/watch?v=LSS_bos_TPI&ab_channel=TheCodingTrain)，了解該技術的另一種解釋。然後嘗試將這些技術應用到你自己的文本語料庫中，或許可以從 Kaggle 獲取數據。
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/28)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
閱讀這篇關於 Word2Vec 的論文：[Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/pdf/1301.3781.pdf)
|
||||
|
||||
## [作業：筆記本](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
# 作業：筆記本
|
||||
|
||||
使用與本課程相關的筆記本（無論是 PyTorch 或 TensorFlow 版本），使用您自己的數據集重新執行，或許可以使用 Kaggle 上的數據集，並註明來源。重寫筆記本以強調您自己的發現。嘗試使用不同類型的數據集並記錄您的發現，例如使用[這些 Beatles 歌詞](https://www.kaggle.com/datasets/jenlooper/beatles-lyrics)。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。
|
||||
|
|
@ -0,0 +1,576 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "NXTSugt6ieXh"
|
||||
},
|
||||
"source": [
|
||||
"## 訓練 CBoW 模型\n",
|
||||
"\n",
|
||||
"此筆記本是 [AI for Beginners Curriculum](http://aka.ms/ai-beginners) 的一部分\n",
|
||||
"\n",
|
||||
"在這個範例中，我們將探討如何訓練 CBoW 語言模型來獲得我們自己的 Word2Vec 嵌入空間。我們將使用 AG News 數據集作為文本來源。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"import torch\n",
|
||||
"import torchtext\n",
|
||||
"import os\n",
|
||||
"import collections\n",
|
||||
"import builtins\n",
|
||||
"import random\n",
|
||||
"import numpy as np"
|
||||
],
|
||||
"metadata": {
|
||||
"id": "q-UiiJUKaxHj"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
|
||||
],
|
||||
"metadata": {
|
||||
"id": "TFbR8CZaTZ1q"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"source": [
|
||||
"首先，我們來載入數據集並定義分詞器和詞彙表。我們將 `vocab_size` 設置為 5000，以稍微限制計算量。\n"
|
||||
],
|
||||
"metadata": {
|
||||
"id": "HIwC7lI5T-ov"
|
||||
}
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"def load_dataset(ngrams = 1, min_freq = 1, vocab_size = 5000 , lines_cnt = 500):\n",
|
||||
" tokenizer = torchtext.data.utils.get_tokenizer('basic_english')\n",
|
||||
" print(\"Loading dataset...\")\n",
|
||||
" test_dataset, train_dataset = torchtext.datasets.AG_NEWS(root='./data')\n",
|
||||
" train_dataset = list(train_dataset)\n",
|
||||
" test_dataset = list(test_dataset)\n",
|
||||
" classes = ['World', 'Sports', 'Business', 'Sci/Tech']\n",
|
||||
" print('Building vocab...')\n",
|
||||
" counter = collections.Counter()\n",
|
||||
" for i, (_, line) in enumerate(train_dataset):\n",
|
||||
" counter.update(torchtext.data.utils.ngrams_iterator(tokenizer(line),ngrams=ngrams))\n",
|
||||
" if i == lines_cnt:\n",
|
||||
" break\n",
|
||||
" vocab = torchtext.vocab.Vocab(collections.Counter(dict(counter.most_common(vocab_size))), min_freq=min_freq)\n",
|
||||
" return train_dataset, test_dataset, classes, vocab, tokenizer"
|
||||
],
|
||||
"metadata": {
|
||||
"id": "wdZuygtgiuLG"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"train_dataset, test_dataset, _, vocab, tokenizer = load_dataset()"
|
||||
],
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"base_uri": "https://localhost:8080/"
|
||||
},
|
||||
"id": "4d1nU1gsivGu",
|
||||
"outputId": "949fe272-ae0e-49f5-c373-6703458b3a74"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": [
|
||||
{
|
||||
"output_type": "stream",
|
||||
"name": "stdout",
|
||||
"text": [
|
||||
"Loading dataset...\n",
|
||||
"Building vocab...\n"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"def encode(x, vocabulary, tokenizer = tokenizer):\n",
|
||||
" return [vocabulary[s] for s in tokenizer(x)]"
|
||||
],
|
||||
"metadata": {
|
||||
"id": "1XDYNhG8ToFV"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "LIlQk6_PaHVY"
|
||||
},
|
||||
"source": [
|
||||
"## CBoW 模型\n",
|
||||
"\n",
|
||||
"CBoW 學習根據 $2N$ 個鄰近的詞來預測一個詞。例如，當 $N=1$ 時，我們可以從句子 *I like to train networks* 中得到以下配對：(like,I)、(I, like)、(to, like)、(like,to)、(train,to)、(to, train)、(networks, train)、(train,networks)。在這裡，第一個詞是作為輸入的鄰近詞，第二個詞是我們要預測的詞。\n",
|
||||
"\n",
|
||||
"為了構建一個用於預測下一個詞的網絡，我們需要提供鄰近詞作為輸入，並獲得詞的編號作為輸出。CBoW 網絡的架構如下：\n",
|
||||
"\n",
|
||||
"* 輸入詞會通過嵌入層。這個嵌入層就是我們的 Word2Vec 嵌入，因此我們會將其單獨定義為 `embedder` 變數。在這個例子中，我們將使用嵌入大小 = 30，儘管你可能想要嘗試更高的維度（真實的 Word2Vec 嵌入大小為 300）。\n",
|
||||
"* 嵌入向量接著會傳遞到一個線性層，該層將預測輸出詞。因此它有 `vocab_size` 個神經元。\n",
|
||||
"\n",
|
||||
"對於輸出，如果我們使用 `CrossEntropyLoss` 作為損失函數，我們只需要提供詞的編號作為預期結果，而不需要使用 one-hot 編碼。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"vocab_size = len(vocab)\n",
|
||||
"\n",
|
||||
"embedder = torch.nn.Embedding(num_embeddings = vocab_size, embedding_dim = 30)\n",
|
||||
"model = torch.nn.Sequential(\n",
|
||||
" embedder,\n",
|
||||
" torch.nn.Linear(in_features = 30, out_features = vocab_size),\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"print(model)"
|
||||
],
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"base_uri": "https://localhost:8080/"
|
||||
},
|
||||
"id": "akKTcKQKkfl2",
|
||||
"outputId": "da687e3e-a8ec-4c1a-e456-ab8cd6ac7dad"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": [
|
||||
{
|
||||
"output_type": "stream",
|
||||
"name": "stdout",
|
||||
"text": [
|
||||
"Sequential(\n",
|
||||
" (0): Embedding(5002, 30)\n",
|
||||
" (1): Linear(in_features=30, out_features=5002, bias=True)\n",
|
||||
")\n"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "Nud6jgGPaHVa"
|
||||
},
|
||||
"source": [
|
||||
"## 準備訓練數據\n",
|
||||
"\n",
|
||||
"現在讓我們編寫主要函數，用於從文本中計算 CBoW 單詞對。這個函數將允許我們指定窗口大小，並返回一組配對——輸入詞和輸出詞。請注意，這個函數可以用於單詞，也可以用於向量/張量——這將允許我們在將文本傳遞給 `to_cbow` 函數之前對其進行編碼。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"base_uri": "https://localhost:8080/"
|
||||
},
|
||||
"id": "x-dsXygOieXn",
|
||||
"outputId": "c2218280-e540-40ba-9546-efe48d0d714f"
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"output_type": "stream",
|
||||
"name": "stdout",
|
||||
"text": [
|
||||
"[['like', 'I'], ['to', 'I'], ['I', 'like'], ['to', 'like'], ['train', 'like'], ['I', 'to'], ['like', 'to'], ['train', 'to'], ['networks', 'to'], ['like', 'train'], ['to', 'train'], ['networks', 'train'], ['to', 'networks'], ['train', 'networks']]\n",
|
||||
"[[232, 172], [5, 172], [172, 232], [5, 232], [0, 232], [172, 5], [232, 5], [0, 5], [1202, 5], [232, 0], [5, 0], [1202, 0], [5, 1202], [0, 1202]]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def to_cbow(sent,window_size=2):\n",
|
||||
" res = []\n",
|
||||
" for i,x in enumerate(sent):\n",
|
||||
" for j in range(max(0,i-window_size),min(i+window_size+1,len(sent))):\n",
|
||||
" if i!=j:\n",
|
||||
" res.append([sent[j],x])\n",
|
||||
" return res\n",
|
||||
"\n",
|
||||
"print(to_cbow(['I','like','to','train','networks']))\n",
|
||||
"print(to_cbow(encode('I like to train networks', vocab)))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "XVaaDLjaaHVb"
|
||||
},
|
||||
"source": [
|
||||
"讓我們準備訓練數據集。我們將遍歷所有新聞，調用 `to_cbow` 來獲取單詞對列表，並將這些對添加到 `X` 和 `Y` 中。為了節省時間，我們只考慮前 10k 條新聞項目——如果你有更多時間等待並希望獲得更好的嵌入，可以輕鬆移除此限制 :)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"id": "54b-Gd9TieXo"
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"X = []\n",
|
||||
"Y = []\n",
|
||||
"for i, x in zip(range(10000), train_dataset):\n",
|
||||
" for w1, w2 in to_cbow(encode(x[1], vocab), window_size = 5):\n",
|
||||
" X.append(w1)\n",
|
||||
" Y.append(w2)\n",
|
||||
"\n",
|
||||
"X = torch.tensor(X)\n",
|
||||
"Y = torch.tensor(Y)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"source": [
|
||||
"我們還將把該數據轉換為一個數據集，並創建數據加載器：\n"
|
||||
],
|
||||
"metadata": {
|
||||
"id": "cwWy0PzXWhN5"
|
||||
}
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"class SimpleIterableDataset(torch.utils.data.IterableDataset):\n",
|
||||
" def __init__(self, X, Y):\n",
|
||||
" super(SimpleIterableDataset).__init__()\n",
|
||||
" self.data = []\n",
|
||||
" for i in range(len(X)):\n",
|
||||
" self.data.append( (Y[i], X[i]) )\n",
|
||||
" random.shuffle(self.data)\n",
|
||||
"\n",
|
||||
" def __iter__(self):\n",
|
||||
" return iter(self.data)"
|
||||
],
|
||||
"metadata": {
|
||||
"id": "mfoAcGPFZU8p"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "e4NQ_-5waHVc"
|
||||
},
|
||||
"source": [
|
||||
"我們還將把該數據轉換為一個數據集，並創建數據加載器：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"id": "AbLUcojlieXo"
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"ds = SimpleIterableDataset(X, Y)\n",
|
||||
"dl = torch.utils.data.DataLoader(ds, batch_size = 256)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "pKQr7sXeaHVc"
|
||||
},
|
||||
"source": [
|
||||
"現在讓我們進行實際訓練。我們將使用 `SGD` 優化器，並設定相當高的學習率。你也可以嘗試使用其他優化器，例如 `Adam`。我們將從訓練 10 個世代開始——如果你想要更低的損失，可以重新執行此單元格。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"def train_epoch(net, dataloader, lr = 0.01, optimizer = None, loss_fn = torch.nn.CrossEntropyLoss(), epochs = None, report_freq = 1):\n",
|
||||
" optimizer = optimizer or torch.optim.Adam(net.parameters(), lr = lr)\n",
|
||||
" loss_fn = loss_fn.to(device)\n",
|
||||
" net.train()\n",
|
||||
"\n",
|
||||
" for i in range(epochs):\n",
|
||||
" total_loss, j = 0, 0, \n",
|
||||
" for labels, features in dataloader:\n",
|
||||
" optimizer.zero_grad()\n",
|
||||
" features, labels = features.to(device), labels.to(device)\n",
|
||||
" out = net(features)\n",
|
||||
" loss = loss_fn(out, labels)\n",
|
||||
" loss.backward()\n",
|
||||
" optimizer.step()\n",
|
||||
" total_loss += loss\n",
|
||||
" j += 1\n",
|
||||
" if i % report_freq == 0:\n",
|
||||
" print(f\"Epoch: {i+1}: loss={total_loss.item()/j}\")\n",
|
||||
"\n",
|
||||
" return total_loss.item()/j"
|
||||
],
|
||||
"metadata": {
|
||||
"id": "HeeCYKr_KF1w"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"source": [
|
||||
"train_epoch(net = model, dataloader = dl, optimizer = torch.optim.SGD(model.parameters(), lr = 0.1), loss_fn = torch.nn.CrossEntropyLoss(), epochs = 10)"
|
||||
],
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"base_uri": "https://localhost:8080/"
|
||||
},
|
||||
"id": "KVgwGtDHgDlT",
|
||||
"outputId": "2447833f-f0e3-4566-c33d-addbfe2f451d"
|
||||
},
|
||||
"execution_count": null,
|
||||
"outputs": [
|
||||
{
|
||||
"output_type": "stream",
|
||||
"name": "stdout",
|
||||
"text": [
|
||||
"Epoch: 1: loss=5.664632366860172\n",
|
||||
"Epoch: 2: loss=5.632101973960962\n",
|
||||
"Epoch: 3: loss=5.610399051405015\n",
|
||||
"Epoch: 4: loss=5.594621561080262\n",
|
||||
"Epoch: 5: loss=5.582538017415446\n",
|
||||
"Epoch: 6: loss=5.572900234519603\n",
|
||||
"Epoch: 7: loss=5.564951676341915\n",
|
||||
"Epoch: 8: loss=5.558288112064614\n",
|
||||
"Epoch: 9: loss=5.552576955031129\n",
|
||||
"Epoch: 10: loss=5.547634165194347\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"output_type": "execute_result",
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"5.547634165194347"
|
||||
]
|
||||
},
|
||||
"metadata": {},
|
||||
"execution_count": 16
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "W8u2qXZmaHVd"
|
||||
},
|
||||
"source": [
|
||||
"## 嘗試使用 Word2Vec\n",
|
||||
"\n",
|
||||
"要使用 Word2Vec，我們來提取與詞彙表中所有單詞對應的向量：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"id": "r8TatcXjkU_t"
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"vectors = torch.stack([embedder(torch.tensor(vocab[s])) for s in vocab.itos], 0)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "3OcX21UOaHVd"
|
||||
},
|
||||
"source": [
|
||||
"讓我們來看看，例如，單詞 **Paris** 是如何被編碼成向量的：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"base_uri": "https://localhost:8080/"
|
||||
},
|
||||
"id": "bz6tAeLzieXp",
|
||||
"outputId": "5b20850e-4342-45e9-f840-cfac2b4d61d8"
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"output_type": "stream",
|
||||
"name": "stdout",
|
||||
"text": [
|
||||
"tensor([-0.0915, 2.1224, -0.0281, -0.6819, 1.1219, 0.6458, -1.3704, -1.3314,\n",
|
||||
" -1.1437, 0.4496, 0.2301, -0.3515, -0.8485, 1.0481, 0.4386, -0.8949,\n",
|
||||
" 0.5644, 1.0939, -2.5096, 3.2949, -0.2601, -0.8640, 0.1421, -0.0804,\n",
|
||||
" -0.5083, -1.0560, 0.9753, -0.5949, -1.6046, 0.5774],\n",
|
||||
" grad_fn=<EmbeddingBackward>)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"paris_vec = embedder(torch.tensor(vocab['paris']))\n",
|
||||
"print(paris_vec)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "pHTJlaeYaHVd"
|
||||
},
|
||||
"source": [
|
||||
"使用 Word2Vec 來尋找同義詞是很有趣的。以下函數將返回與給定輸入最接近的 `n` 個單詞。為了找到它們，我們計算 $|w_i - v|$ 的範數，其中 $v$ 是對應於我們輸入單詞的向量，$w_i$ 是詞彙表中第 $i$ 個單詞的編碼。我們接著對數組進行排序，並使用 `argsort` 返回相應的索引，然後取列表的前 `n` 個元素，這些元素編碼了詞彙表中最接近單詞的位置。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"base_uri": "https://localhost:8080/"
|
||||
},
|
||||
"id": "NlZyi-_olFar",
|
||||
"outputId": "b5dbb163-88c4-4d5a-eaf2-6751f700e98c"
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"output_type": "execute_result",
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"['microsoft', 'quoted', 'lp', 'rate', 'top']"
|
||||
]
|
||||
},
|
||||
"metadata": {},
|
||||
"execution_count": 56
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def close_words(x, n = 5):\n",
|
||||
" vec = embedder(torch.tensor(vocab[x]))\n",
|
||||
" top5 = np.linalg.norm(vectors.detach().numpy() - vec.detach().numpy(), axis = 1).argsort()[:n]\n",
|
||||
" return [ vocab.itos[x] for x in top5 ]\n",
|
||||
"\n",
|
||||
"close_words('microsoft')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"base_uri": "https://localhost:8080/"
|
||||
},
|
||||
"id": "-dQq7xeAln0U",
|
||||
"outputId": "66f768c3-c248-4bfd-ce4f-c8ffc6d0dd0d"
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"output_type": "execute_result",
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"['basketball', 'lot', 'sinai', 'states', 'healthdaynews']"
|
||||
]
|
||||
},
|
||||
"metadata": {},
|
||||
"execution_count": 51
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"close_words('basketball')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"base_uri": "https://localhost:8080/"
|
||||
},
|
||||
"id": "fJXqK26b29sa",
|
||||
"outputId": "78f0baba-ffd0-485a-dd87-0a12bedfd7fa"
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"output_type": "execute_result",
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"['funds', 'travel', 'sydney', 'japan', 'business']"
|
||||
]
|
||||
},
|
||||
"metadata": {},
|
||||
"execution_count": 77
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"close_words('funds')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"id": "My0VeTDd3Ji8"
|
||||
},
|
||||
"source": [
|
||||
"## 重點\n",
|
||||
"\n",
|
||||
"使用像 CBoW 這樣的巧妙技術，我們可以訓練 Word2Vec 模型。你也可以嘗試訓練 skip-gram 模型，該模型是根據中心詞來預測相鄰詞，看看它的表現如何。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"colab": {
|
||||
"collapsed_sections": [],
|
||||
"name": "CBoW-PyTorch.ipynb",
|
||||
"provenance": []
|
||||
},
|
||||
"interpreter": {
|
||||
"hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.8.12 ('py38')",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"orig_nbformat": 4,
|
||||
"gpuClass": "standard",
|
||||
"coopTranslator": {
|
||||
"original_hash": "36df28efe3fe40b6fb0a7fa48fe3ea82",
|
||||
"translation_date": "2025-08-31T10:35:52+00:00",
|
||||
"source_file": "lessons/5-NLP/15-LanguageModeling/CBoW-PyTorch.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 0
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,45 @@
|
|||
# 語言建模
|
||||
|
||||
語義嵌入（如 Word2Vec 和 GloVe）實際上是邁向**語言建模**的第一步——建立能夠以某種方式*理解*（或*表示*）語言特性的模型。
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/29)
|
||||
|
||||
語言建模的核心思想是以無監督的方式在未標註的數據集上進行訓練。這很重要，因為我們擁有大量未標註的文本，而標註文本的數量則受到我們能投入的標註工作量的限制。通常，我們可以構建能夠**預測缺失詞**的語言模型，因為在文本中隨機遮蔽一個詞並將其作為訓練樣本是相對容易的。
|
||||
|
||||
## 嵌入訓練
|
||||
|
||||
在之前的例子中，我們使用了預訓練的語義嵌入，但了解這些嵌入是如何訓練的也很有趣。有幾種可能的思路可以採用：
|
||||
|
||||
* **N-Gram** 語言建模，通過查看前 N 個詞元（N-gram）來預測一個詞元。
|
||||
* **連續詞袋模型** (CBoW)，在詞元序列 $W_{-N}$, ..., $W_N$ 中預測中間的詞元 $W_0$。
|
||||
* **Skip-gram**，通過中間詞元 $W_0$ 預測一組相鄰的詞元 {$W_{-N},\dots, W_{-1}, W_1,\dots, W_N$}。
|
||||
|
||||
|
||||
|
||||
> 圖片來源：[這篇論文](https://arxiv.org/pdf/1301.3781.pdf)
|
||||
|
||||
## ✍️ 示例筆記本：訓練 CBoW 模型
|
||||
|
||||
繼續學習以下筆記本：
|
||||
|
||||
* [使用 TensorFlow 訓練 CBoW Word2Vec](CBoW-TF.ipynb)
|
||||
* [使用 PyTorch 訓練 CBoW Word2Vec](CBoW-PyTorch.ipynb)
|
||||
|
||||
## 結論
|
||||
|
||||
在上一課中，我們看到詞嵌入的效果就像魔法一樣！現在我們知道，訓練詞嵌入並不是一項非常複雜的任務，如果需要，我們應該能夠為特定領域的文本訓練自己的詞嵌入。
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/30)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
* [PyTorch 官方語言建模教程](https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html)。
|
||||
* [TensorFlow 官方訓練 Word2Vec 模型教程](https://www.TensorFlow.org/tutorials/text/word2vec)。
|
||||
* 使用 **gensim** 框架訓練最常用嵌入的簡單方法可參考[此文檔](https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html)。
|
||||
|
||||
## 🚀 [作業：訓練 Skip-Gram 模型](lab/README.md)
|
||||
|
||||
在實驗中，我們挑戰你修改本課的代碼，將 CBoW 模型改為 Skip-Gram 模型。[閱讀詳情](lab/README.md)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# 訓練 Skip-Gram 模型
|
||||
|
||||
來自 [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners) 的實驗作業。
|
||||
|
||||
## 任務
|
||||
|
||||
在本次實驗中，我們挑戰你使用 Skip-Gram 技術訓練 Word2Vec 模型。訓練一個帶有嵌入層的網絡，來預測 $N$ 個詞範圍內 Skip-Gram 窗口中的相鄰詞。你可以使用[本課程的代碼](../../../../../../lessons/5-NLP/15-LanguageModeling/CBoW-TF.ipynb)，稍作修改即可。
|
||||
|
||||
## 數據集
|
||||
|
||||
你可以使用任何一本書作為數據集。在 [Project Gutenberg](https://www.gutenberg.org/) 上可以找到許多免費文本，例如，這裡有 Lewis Carroll 的《愛麗絲夢遊仙境》的[直接鏈接](https://www.gutenberg.org/files/11/11-0.txt)。或者，你也可以使用莎士比亞的戲劇，以下代碼可以幫助你獲取：
|
||||
|
||||
```python
|
||||
path_to_file = tf.keras.utils.get_file(
|
||||
'shakespeare.txt',
|
||||
'https://storage.googleapis.com/download.tensorflow.org/data/shakespeare.txt')
|
||||
text = open(path_to_file, 'rb').read().decode(encoding='utf-8')
|
||||
```
|
||||
|
||||
## 探索！
|
||||
|
||||
如果你有時間並且想更深入了解這個主題，可以嘗試探索以下幾個方面：
|
||||
|
||||
* 嵌入層的大小如何影響結果？
|
||||
* 不同的文本風格如何影響結果？
|
||||
* 選擇幾個非常不同類型的詞及其同義詞，獲取它們的向量表示，應用 PCA 將維度降至 2，並在 2D 空間中繪製它們。你能看到任何模式嗎？
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
# 循環神經網絡
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/31)
|
||||
|
||||
在之前的章節中，我們使用了豐富的文本語義表示以及嵌入層上的簡單線性分類器。這種架構能夠捕捉句子中詞語的整體意義，但它並未考慮詞語的**順序**，因為嵌入層上的聚合操作會移除原始文本中的這些信息。由於這些模型無法建模詞語的順序，因此它們無法解決更複雜或更具歧義的任務，例如文本生成或問答。
|
||||
|
||||
為了捕捉文本序列的意義，我們需要使用另一種神經網絡架構，稱為**循環神經網絡**（Recurrent Neural Network，簡稱 RNN）。在 RNN 中，我們將句子逐個符號地傳遞給網絡，網絡會生成某種**狀態**，然後將該狀態與下一個符號一起再次傳遞給網絡。
|
||||
|
||||
|
||||
|
||||
> 圖片由作者提供
|
||||
|
||||
給定輸入序列的標記 X<sub>0</sub>,...,X<sub>n</sub>，RNN 會創建一系列神經網絡塊，並通過反向傳播端到端地訓練這個序列。每個網絡塊接受一對 (X<sub>i</sub>,S<sub>i</sub>) 作為輸入，並生成 S<sub>i+1</sub> 作為結果。最終的狀態 S<sub>n</sub> 或（輸出 Y<sub>n</sub>）會進入線性分類器以生成結果。所有的網絡塊共享相同的權重，並通過一次反向傳播端到端地訓練。
|
||||
|
||||
由於狀態向量 S<sub>0</sub>,...,S<sub>n</sub> 被傳遞給網絡，它能夠學習詞語之間的順序依賴。例如，當詞語 *not* 出現在序列中的某處時，它可以學習在狀態向量中否定某些元素，從而實現否定。
|
||||
|
||||
> ✅ 由於上圖中所有 RNN 塊的權重是共享的，因此同一圖可以表示為右側的一個塊，該塊具有循環反饋迴路，將網絡的輸出狀態回傳到輸入。
|
||||
|
||||
## RNN 單元的結構
|
||||
|
||||
讓我們來看看一個簡單的 RNN 單元是如何組織的。它接受前一狀態 S<sub>i-1</sub> 和當前符號 X<sub>i</sub> 作為輸入，並需要生成輸出狀態 S<sub>i</sub>（有時我們也對某些其他輸出 Y<sub>i</sub> 感興趣，例如在生成網絡的情況下）。
|
||||
|
||||
一個簡單的 RNN 單元內部有兩個權重矩陣：一個用於轉換輸入符號（我們稱之為 W），另一個用於轉換輸入狀態（H）。在這種情況下，網絡的輸出計算公式為 σ(W×X<sub>i</sub>+H×S<sub>i-1</sub>+b)，其中 σ 是激活函數，b 是額外的偏置。
|
||||
|
||||
<img alt="RNN 單元結構" src="../../../../../translated_images/zh-TW/rnn-anatomy.79ee3f3920b3294b.webp" width="50%"/>
|
||||
|
||||
> 圖片由作者提供
|
||||
|
||||
在許多情況下，輸入標記在進入 RNN 之前會通過嵌入層以降低維度。在這種情況下，如果輸入向量的維度是 *emb_size*，而狀態向量的維度是 *hid_size*，則 W 的大小為 *emb_size*×*hid_size*，H 的大小為 *hid_size*×*hid_size*。
|
||||
|
||||
## 長短期記憶（LSTM）
|
||||
|
||||
經典 RNN 的主要問題之一是所謂的**梯度消失**問題。由於 RNN 是通過一次反向傳播端到端地訓練的，它在向網絡的第一層傳遞誤差時會遇到困難，因此網絡無法學習遠距標記之間的關係。解決這個問題的一種方法是通過使用所謂的**門**引入**顯式狀態管理**。有兩種著名的架構：**長短期記憶**（Long Short Term Memory，簡稱 LSTM）和**門控遞歸單元**（Gated Relay Unit，簡稱 GRU）。
|
||||
|
||||
|
||||
|
||||
> 圖片來源待定
|
||||
|
||||
LSTM 網絡的組織方式與 RNN 類似，但有兩個狀態會從層到層傳遞：實際狀態 C 和隱藏向量 H。在每個單元中，隱藏向量 H<sub>i</sub> 與輸入 X<sub>i</sub> 進行拼接，並通過**門**控制狀態 C 的變化。每個門都是具有 sigmoid 激活（輸出範圍 [0,1]）的神經網絡，可以在與狀態向量相乘時被視為逐位掩碼。以下是各個門的功能（從左到右對應上圖）：
|
||||
|
||||
* **遺忘門**：接收隱藏向量並決定需要遺忘狀態向量 C 的哪些部分，以及需要保留哪些部分。
|
||||
* **輸入門**：從輸入和隱藏向量中提取信息並插入到狀態中。
|
||||
* **輸出門**：通過具有 *tanh* 激活的線性層轉換狀態，然後使用隱藏向量 H<sub>i</sub> 選擇其某些部分以生成新狀態 C<sub>i+1</sub>。
|
||||
|
||||
狀態 C 的組件可以被視為一些可以開啟或關閉的標誌。例如，當我們在序列中遇到名字 *Alice* 時，我們可能會假設它指的是女性角色，並在狀態中設置一個標誌，表示句子中有一個女性名詞。當我們進一步遇到短語 *and Tom* 時，我們會設置一個標誌，表示句子中有複數名詞。因此，通過操控狀態，我們可以追蹤句子部分的語法屬性。
|
||||
|
||||
> ✅ 理解 LSTM 內部結構的絕佳資源是 Christopher Olah 的這篇精彩文章 [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/)。
|
||||
|
||||
## 雙向和多層 RNN
|
||||
|
||||
我們已經討論了僅在一個方向上運行的循環網絡，即從序列的開頭到結尾。這看起來很自然，因為它類似於我們閱讀和聽取語音的方式。然而，由於在許多實際情況下我們可以隨機訪問輸入序列，因此在兩個方向上運行循環計算可能更有意義。這樣的網絡稱為**雙向** RNN。在處理雙向網絡時，我們需要兩個隱藏狀態向量，每個方向一個。
|
||||
|
||||
循環網絡（無論是單向還是雙向）能夠捕捉序列中的某些模式，並將它們存儲到狀態向量中或傳遞到輸出中。與卷積網絡類似，我們可以在第一層之上構建另一個循環層，以捕捉更高層次的模式，並基於第一層提取的低層次模式進行構建。這引出了**多層 RNN** 的概念，它由兩個或更多循環網絡組成，其中前一層的輸出作為輸入傳遞到下一層。
|
||||
|
||||
|
||||
|
||||
*圖片來自 Fernando López 的[這篇精彩文章](https://towardsdatascience.com/from-a-lstm-cell-to-a-multilayer-lstm-network-with-pytorch-2899eb5696f3)*
|
||||
|
||||
## ✍️ 練習：嵌入
|
||||
|
||||
在以下筆記本中繼續學習：
|
||||
|
||||
* [使用 PyTorch 的 RNN](RNNPyTorch.ipynb)
|
||||
* [使用 TensorFlow 的 RNN](RNNTF.ipynb)
|
||||
|
||||
## 結論
|
||||
|
||||
在本單元中，我們了解到 RNN 可用於序列分類，但事實上，它們可以處理更多任務，例如文本生成、機器翻譯等。我們將在下一單元中探討這些任務。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
閱讀一些關於 LSTM 的文獻並考慮其應用：
|
||||
|
||||
- [Grid Long Short-Term Memory](https://arxiv.org/pdf/1507.01526v1.pdf)
|
||||
- [Show, Attend and Tell: Neural Image Caption
|
||||
Generation with Visual Attention](https://arxiv.org/pdf/1502.03044v2.pdf)
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/32)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
- [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) by Christopher Olah.
|
||||
|
||||
## [作業：筆記本](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,479 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 循環神經網路\n",
|
||||
"\n",
|
||||
"在前一個模組中，我們使用了豐富的文本語義表示，並在嵌入層之上使用了一個簡單的線性分類器。這種架構的作用是捕捉句子中詞彙的聚合意義，但它並未考慮到詞彙的**順序**，因為嵌入層上的聚合操作已經移除了原始文本中的這種信息。由於這些模型無法建模詞彙的順序，因此它們無法解決更複雜或更具歧義的任務，例如文本生成或問答。\n",
|
||||
"\n",
|
||||
"為了捕捉文本序列的意義，我們需要使用另一種神經網路架構，稱為**循環神經網路**（Recurrent Neural Network，簡稱 RNN）。在 RNN 中，我們將句子逐個符號地輸入網路，網路會生成某種**狀態**，然後我們將該狀態與下一個符號一起再次輸入網路。\n",
|
||||
"\n",
|
||||
"給定輸入的序列標記 $X_0,\\dots,X_n$，RNN 會創建一個神經網路模塊的序列，並通過反向傳播對這個序列進行端到端的訓練。每個網路模塊以一對 $(X_i,S_i)$ 作為輸入，並生成 $S_{i+1}$ 作為結果。最終的狀態 $S_n$ 或輸出 $X_n$ 會進入線性分類器以生成結果。所有的網路模塊共享相同的權重，並通過一次反向傳播進行端到端的訓練。\n",
|
||||
"\n",
|
||||
"由於狀態向量 $S_0,\\dots,S_n$ 會在網路中傳遞，因此它能夠學習詞彙之間的順序依賴關係。例如，當單詞 *not* 出現在序列中的某處時，網路可以學會在狀態向量中否定某些元素，從而實現否定的效果。\n",
|
||||
"\n",
|
||||
"> 由於圖片中所有 RNN 模塊的權重是共享的，因此同一張圖片可以表示為一個帶有循環反饋迴路的模塊（如右側所示），該迴路將網路的輸出狀態反饋回輸入。\n",
|
||||
"\n",
|
||||
"接下來，我們來看看循環神經網路如何幫助我們對新聞數據集進行分類。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Loading dataset...\n",
|
||||
"Building vocab...\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import torch\n",
|
||||
"import torchtext\n",
|
||||
"from torchnlp import *\n",
|
||||
"train_dataset, test_dataset, classes, vocab = load_dataset()\n",
|
||||
"vocab_size = len(vocab)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 簡單的 RNN 分類器\n",
|
||||
"\n",
|
||||
"在簡單的 RNN 中，每個循環單元是一個簡單的線性網路，它接收拼接後的輸入向量和狀態向量，並生成一個新的狀態向量。PyTorch 使用 `RNNCell` 類來表示這種單元，而由這些單元組成的網路則表示為 `RNN` 層。\n",
|
||||
"\n",
|
||||
"為了定義一個 RNN 分類器，我們將首先應用一個嵌入層來降低輸入詞彙的維度，然後在其上添加 RNN 層：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"class RNNClassifier(torch.nn.Module):\n",
|
||||
" def __init__(self, vocab_size, embed_dim, hidden_dim, num_class):\n",
|
||||
" super().__init__()\n",
|
||||
" self.hidden_dim = hidden_dim\n",
|
||||
" self.embedding = torch.nn.Embedding(vocab_size, embed_dim)\n",
|
||||
" self.rnn = torch.nn.RNN(embed_dim,hidden_dim,batch_first=True)\n",
|
||||
" self.fc = torch.nn.Linear(hidden_dim, num_class)\n",
|
||||
"\n",
|
||||
" def forward(self, x):\n",
|
||||
" batch_size = x.size(0)\n",
|
||||
" x = self.embedding(x)\n",
|
||||
" x,h = self.rnn(x)\n",
|
||||
" return self.fc(x.mean(dim=1))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意：** 為了簡化，我們在這裡使用未訓練的嵌入層，但如果想要更好的結果，可以使用預訓練的嵌入層，例如 Word2Vec 或 GloVe 嵌入，這在前一單元中已經描述過。為了更好地理解，您可能需要調整此程式碼以使用預訓練的嵌入。\n",
|
||||
"\n",
|
||||
"在我們的案例中，我們將使用填充的資料加載器，因此每個批次都會包含相同長度的一些填充序列。RNN 層將接收嵌入張量的序列，並產生兩個輸出：\n",
|
||||
"* $x$ 是每一步驟中 RNN 單元輸出的序列\n",
|
||||
"* $h$ 是序列最後一個元素的最終隱藏狀態\n",
|
||||
"\n",
|
||||
"接著，我們應用一個全連接的線性分類器來獲得類別數。\n",
|
||||
"\n",
|
||||
"> **注意：** RNN 的訓練相當困難，因為一旦 RNN 單元沿著序列長度展開，反向傳播所涉及的層數就會非常多。因此，我們需要選擇較小的學習率，並在更大的資料集上訓練網路以獲得良好的結果。這可能需要相當長的時間，因此建議使用 GPU。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {
|
||||
"scrolled": true
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3200: acc=0.3090625\n",
|
||||
"6400: acc=0.38921875\n",
|
||||
"9600: acc=0.4590625\n",
|
||||
"12800: acc=0.511953125\n",
|
||||
"16000: acc=0.5506875\n",
|
||||
"19200: acc=0.57921875\n",
|
||||
"22400: acc=0.6070089285714285\n",
|
||||
"25600: acc=0.6304296875\n",
|
||||
"28800: acc=0.6484027777777778\n",
|
||||
"32000: acc=0.66509375\n",
|
||||
"35200: acc=0.6790056818181818\n",
|
||||
"38400: acc=0.6929166666666666\n",
|
||||
"41600: acc=0.7035817307692308\n",
|
||||
"44800: acc=0.7137276785714286\n",
|
||||
"48000: acc=0.72225\n",
|
||||
"51200: acc=0.73001953125\n",
|
||||
"54400: acc=0.7372794117647059\n",
|
||||
"57600: acc=0.7436631944444444\n",
|
||||
"60800: acc=0.7503947368421052\n",
|
||||
"64000: acc=0.75634375\n",
|
||||
"67200: acc=0.7615773809523809\n",
|
||||
"70400: acc=0.7662642045454545\n",
|
||||
"73600: acc=0.7708423913043478\n",
|
||||
"76800: acc=0.7751822916666666\n",
|
||||
"80000: acc=0.7790625\n",
|
||||
"83200: acc=0.7825\n",
|
||||
"86400: acc=0.7858564814814815\n",
|
||||
"89600: acc=0.7890513392857142\n",
|
||||
"92800: acc=0.7920474137931034\n",
|
||||
"96000: acc=0.7952708333333334\n",
|
||||
"99200: acc=0.7982258064516129\n",
|
||||
"102400: acc=0.80099609375\n",
|
||||
"105600: acc=0.8037594696969697\n",
|
||||
"108800: acc=0.8060569852941176\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, collate_fn=padify, shuffle=True)\n",
|
||||
"net = RNNClassifier(vocab_size,64,32,len(classes)).to(device)\n",
|
||||
"train_epoch(net,train_loader, lr=0.001)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 長短期記憶（LSTM）\n",
|
||||
"\n",
|
||||
"傳統 RNN 的主要問題之一是所謂的 **梯度消失** 問題。由於 RNN 是在一次反向傳播中端到端訓練的，因此在將誤差傳遞到網絡的第一層時會遇到困難，導致網絡無法學習遠距離的詞元之間的關係。解決這個問題的一種方法是通過使用所謂的 **門控機制** 引入 **顯式狀態管理**。這類架構中最著名的兩種是：**長短期記憶**（LSTM）和 **門控循環單元**（GRU）。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"LSTM 網絡的組織方式與 RNN 類似，但有兩個狀態會從一層傳遞到下一層：實際狀態 $c$ 和隱藏向量 $h$。在每個單元中，隱藏向量 $h_i$ 與輸入 $x_i$ 連接在一起，並通過 **門控機制** 控制狀態 $c$ 的變化。每個門控機制是一個帶有 sigmoid 激活函數（輸出範圍為 $[0,1]$）的神經網絡，可以被視為在與狀態向量相乘時的位掩碼。以下是這些門控機制（如上圖從左到右）：\n",
|
||||
"* **遺忘門** 接收隱藏向量並決定向量 $c$ 的哪些組件需要被遺忘，哪些需要保留。\n",
|
||||
"* **輸入門** 從輸入和隱藏向量中提取一些信息，並將其插入到狀態中。\n",
|
||||
"* **輸出門** 通過帶有 $\\tanh$ 激活函數的線性層轉換狀態，然後使用隱藏向量 $h_i$ 選擇其部分組件以生成新狀態 $c_{i+1}$。\n",
|
||||
"\n",
|
||||
"狀態 $c$ 的組件可以被視為一些可以開啟或關閉的標誌。例如，當我們在序列中遇到名字 *Alice* 時，我們可能會假設它指的是女性角色，並在狀態中設置一個標誌，表示句子中有一個女性名詞。當我們進一步遇到短語 *and Tom* 時，我們會設置一個標誌，表示句子中有複數名詞。因此，通過操作狀態，我們可以假設性地跟蹤句子部分的語法屬性。\n",
|
||||
"\n",
|
||||
"> **Note**: 理解 LSTM 內部結構的一個很棒的資源是 Christopher Olah 的這篇優秀文章 [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/)。\n",
|
||||
"\n",
|
||||
"雖然 LSTM 單元的內部結構看起來很複雜，但 PyTorch 將這些實現隱藏在 `LSTMCell` 類中，並提供 `LSTM` 對象來表示整個 LSTM 層。因此，LSTM 分類器的實現將與我們之前看到的簡單 RNN 非常相似：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"class LSTMClassifier(torch.nn.Module):\n",
|
||||
" def __init__(self, vocab_size, embed_dim, hidden_dim, num_class):\n",
|
||||
" super().__init__()\n",
|
||||
" self.hidden_dim = hidden_dim\n",
|
||||
" self.embedding = torch.nn.Embedding(vocab_size, embed_dim)\n",
|
||||
" self.embedding.weight.data = torch.randn_like(self.embedding.weight.data)-0.5\n",
|
||||
" self.rnn = torch.nn.LSTM(embed_dim,hidden_dim,batch_first=True)\n",
|
||||
" self.fc = torch.nn.Linear(hidden_dim, num_class)\n",
|
||||
"\n",
|
||||
" def forward(self, x):\n",
|
||||
" batch_size = x.size(0)\n",
|
||||
" x = self.embedding(x)\n",
|
||||
" x,(h,c) = self.rnn(x)\n",
|
||||
" return self.fc(h[-1])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3200: acc=0.259375\n",
|
||||
"6400: acc=0.25859375\n",
|
||||
"9600: acc=0.26177083333333334\n",
|
||||
"12800: acc=0.2784375\n",
|
||||
"16000: acc=0.313\n",
|
||||
"19200: acc=0.3528645833333333\n",
|
||||
"22400: acc=0.3965625\n",
|
||||
"25600: acc=0.4385546875\n",
|
||||
"28800: acc=0.4752777777777778\n",
|
||||
"32000: acc=0.505375\n",
|
||||
"35200: acc=0.5326704545454546\n",
|
||||
"38400: acc=0.5557552083333334\n",
|
||||
"41600: acc=0.5760817307692307\n",
|
||||
"44800: acc=0.5954910714285714\n",
|
||||
"48000: acc=0.6118333333333333\n",
|
||||
"51200: acc=0.62681640625\n",
|
||||
"54400: acc=0.6404779411764706\n",
|
||||
"57600: acc=0.6520138888888889\n",
|
||||
"60800: acc=0.662828947368421\n",
|
||||
"64000: acc=0.673546875\n",
|
||||
"67200: acc=0.6831547619047619\n",
|
||||
"70400: acc=0.6917897727272727\n",
|
||||
"73600: acc=0.6997146739130434\n",
|
||||
"76800: acc=0.707109375\n",
|
||||
"80000: acc=0.714075\n",
|
||||
"83200: acc=0.7209134615384616\n",
|
||||
"86400: acc=0.727037037037037\n",
|
||||
"89600: acc=0.7326674107142858\n",
|
||||
"92800: acc=0.7379633620689655\n",
|
||||
"96000: acc=0.7433645833333333\n",
|
||||
"99200: acc=0.7479032258064516\n",
|
||||
"102400: acc=0.752119140625\n",
|
||||
"105600: acc=0.7562405303030303\n",
|
||||
"108800: acc=0.76015625\n",
|
||||
"112000: acc=0.7641339285714286\n",
|
||||
"115200: acc=0.7677777777777778\n",
|
||||
"118400: acc=0.7711233108108108\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(0.03487814127604167, 0.7728)"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"net = LSTMClassifier(vocab_size,64,32,len(classes)).to(device)\n",
|
||||
"train_epoch(net,train_loader, lr=0.001)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 打包序列\n",
|
||||
"\n",
|
||||
"在我們的例子中，我們必須用零向量填充小批量中的所有序列。雖然這會導致一些記憶體浪費，但對於 RNN 而言，更關鍵的是為填充的輸入項目創建了額外的 RNN 單元，這些單元參與了訓練，但並未攜帶任何重要的輸入資訊。如果能僅針對實際的序列長度來訓練 RNN，效果會更好。\n",
|
||||
"\n",
|
||||
"為此，PyTorch 引入了一種特殊格式來存儲填充的序列。假設我們有一個填充過的小批量輸入，看起來像這樣：\n",
|
||||
"```\n",
|
||||
"[[1,2,3,4,5],\n",
|
||||
" [6,7,8,0,0],\n",
|
||||
" [9,0,0,0,0]]\n",
|
||||
"```\n",
|
||||
"這裡的 0 代表填充的值，而輸入序列的實際長度向量是 `[5,3,1]`。\n",
|
||||
"\n",
|
||||
"為了有效地用填充序列訓練 RNN，我們希望先用較大的小批量（`[1,6,9]`）開始訓練第一組 RNN 單元，然後結束第三個序列的處理，並繼續用較小的小批量（`[2,7]`，`[3,8]`）進行訓練，依此類推。因此，打包序列被表示為一個向量——在我們的例子中是 `[1,6,9,2,7,3,8,4,5]`，以及長度向量（`[5,3,1]`），我們可以從中輕鬆重建原始的填充小批量。\n",
|
||||
"\n",
|
||||
"要生成打包序列，我們可以使用 `torch.nn.utils.rnn.pack_padded_sequence` 函數。所有的循環層，包括 RNN、LSTM 和 GRU，都支持將打包序列作為輸入，並生成打包輸出，這些輸出可以使用 `torch.nn.utils.rnn.pad_packed_sequence` 進行解碼。\n",
|
||||
"\n",
|
||||
"為了能夠生成打包序列，我們需要將長度向量傳遞給網路，因此我們需要一個不同的函數來準備小批量：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def pad_length(b):\n",
|
||||
" # build vectorized sequence\n",
|
||||
" v = [encode(x[1]) for x in b]\n",
|
||||
" # compute max length of a sequence in this minibatch and length sequence itself\n",
|
||||
" len_seq = list(map(len,v))\n",
|
||||
" l = max(len_seq)\n",
|
||||
" return ( # tuple of three tensors - labels, padded features, length sequence\n",
|
||||
" torch.LongTensor([t[0]-1 for t in b]),\n",
|
||||
" torch.stack([torch.nn.functional.pad(torch.tensor(t),(0,l-len(t)),mode='constant',value=0) for t in v]),\n",
|
||||
" torch.tensor(len_seq)\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"train_loader_len = torch.utils.data.DataLoader(train_dataset, batch_size=16, collate_fn=pad_length, shuffle=True)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"實際的網路結構會與上面的 `LSTMClassifier` 非常相似，但在 `forward` 傳遞時，會同時接收填充過的小批量數據和序列長度的向量。在計算嵌入層後，我們會計算打包序列，將其傳遞給 LSTM 層，然後再將結果解包回來。\n",
|
||||
"\n",
|
||||
"> **注意**：我們實際上並未使用解包後的結果 `x`，因為我們在後續的計算中使用的是隱藏層的輸出。因此，我們可以完全移除這段程式碼中的解包過程。我們之所以將其保留在這裡，是為了讓您在需要在後續計算中使用網路輸出時，能夠更輕鬆地修改這段程式碼。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"class LSTMPackClassifier(torch.nn.Module):\n",
|
||||
" def __init__(self, vocab_size, embed_dim, hidden_dim, num_class):\n",
|
||||
" super().__init__()\n",
|
||||
" self.hidden_dim = hidden_dim\n",
|
||||
" self.embedding = torch.nn.Embedding(vocab_size, embed_dim)\n",
|
||||
" self.embedding.weight.data = torch.randn_like(self.embedding.weight.data)-0.5\n",
|
||||
" self.rnn = torch.nn.LSTM(embed_dim,hidden_dim,batch_first=True)\n",
|
||||
" self.fc = torch.nn.Linear(hidden_dim, num_class)\n",
|
||||
"\n",
|
||||
" def forward(self, x, lengths):\n",
|
||||
" batch_size = x.size(0)\n",
|
||||
" x = self.embedding(x)\n",
|
||||
" pad_x = torch.nn.utils.rnn.pack_padded_sequence(x,lengths,batch_first=True,enforce_sorted=False)\n",
|
||||
" pad_x,(h,c) = self.rnn(pad_x)\n",
|
||||
" x, _ = torch.nn.utils.rnn.pad_packed_sequence(pad_x,batch_first=True)\n",
|
||||
" return self.fc(h[-1])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {
|
||||
"scrolled": true
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3200: acc=0.285625\n",
|
||||
"6400: acc=0.33359375\n",
|
||||
"9600: acc=0.3876041666666667\n",
|
||||
"12800: acc=0.44078125\n",
|
||||
"16000: acc=0.4825\n",
|
||||
"19200: acc=0.5235416666666667\n",
|
||||
"22400: acc=0.5559821428571429\n",
|
||||
"25600: acc=0.58609375\n",
|
||||
"28800: acc=0.6116666666666667\n",
|
||||
"32000: acc=0.63340625\n",
|
||||
"35200: acc=0.6525284090909091\n",
|
||||
"38400: acc=0.668515625\n",
|
||||
"41600: acc=0.6822596153846154\n",
|
||||
"44800: acc=0.6948214285714286\n",
|
||||
"48000: acc=0.7052708333333333\n",
|
||||
"51200: acc=0.71521484375\n",
|
||||
"54400: acc=0.7239889705882353\n",
|
||||
"57600: acc=0.7315277777777778\n",
|
||||
"60800: acc=0.7388486842105263\n",
|
||||
"64000: acc=0.74571875\n",
|
||||
"67200: acc=0.7518303571428572\n",
|
||||
"70400: acc=0.7576988636363636\n",
|
||||
"73600: acc=0.7628940217391305\n",
|
||||
"76800: acc=0.7681510416666667\n",
|
||||
"80000: acc=0.7728125\n",
|
||||
"83200: acc=0.7772235576923077\n",
|
||||
"86400: acc=0.7815393518518519\n",
|
||||
"89600: acc=0.7857700892857142\n",
|
||||
"92800: acc=0.7895043103448276\n",
|
||||
"96000: acc=0.7930520833333333\n",
|
||||
"99200: acc=0.7959072580645161\n",
|
||||
"102400: acc=0.798994140625\n",
|
||||
"105600: acc=0.802064393939394\n",
|
||||
"108800: acc=0.8051378676470589\n",
|
||||
"112000: acc=0.8077857142857143\n",
|
||||
"115200: acc=0.8104600694444445\n",
|
||||
"118400: acc=0.8128293918918919\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(0.029785829671223958, 0.8138166666666666)"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"net = LSTMPackClassifier(vocab_size,64,32,len(classes)).to(device)\n",
|
||||
"train_epoch_emb(net,train_loader_len, lr=0.001,use_pack_sequence=True)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意：** 您可能已經注意到我們傳遞給訓練函數的參數 `use_pack_sequence`。目前，`pack_padded_sequence` 函數要求長度序列張量位於 CPU 設備上，因此訓練函數需要避免在訓練時將長度序列數據移動到 GPU。您可以查看 [`torchnlp.py`](../../../../../lessons/5-NLP/16-RNN/torchnlp.py) 文件中 `train_emb` 函數的實現。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 雙向與多層 RNN\n",
|
||||
"\n",
|
||||
"在我們的範例中，所有的循環神經網路都是單向運作的，從序列的開始到結束。這看起來很自然，因為它類似於我們閱讀或聆聽語音的方式。然而，在許多實際情況下，我們可以隨機存取輸入序列，因此在兩個方向上進行循環計算可能更有意義。這類網路被稱為**雙向 RNN**，可以透過在 RNN/LSTM/GRU 的建構函數中傳入參數 `bidirectional=True` 來建立。\n",
|
||||
"\n",
|
||||
"在處理雙向網路時，我們需要兩個隱藏狀態向量，每個方向各一個。PyTorch 將這些向量編碼為一個大小加倍的向量，這非常方便，因為通常我們會將最終的隱藏狀態傳遞給全連接的線性層，只需在建立該層時考慮到這個大小的增加即可。\n",
|
||||
"\n",
|
||||
"無論是單向還是雙向的循環網路，都能在序列中捕捉某些模式，並將其存儲到狀態向量中或傳遞到輸出中。與卷積網路類似，我們可以在第一層之上再構建另一個循環層，以捕捉更高層次的模式，這些模式是由第一層提取的低層次模式構成的。這引出了**多層 RNN** 的概念，它由兩層或更多的循環網路組成，前一層的輸出作為下一層的輸入。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"*圖片來源：[這篇精彩的文章](https://towardsdatascience.com/from-a-lstm-cell-to-a-multilayer-lstm-network-with-pytorch-2899eb5696f3) 作者 Fernando López*\n",
|
||||
"\n",
|
||||
"PyTorch 讓構建這類網路變得非常簡單，因為你只需在 RNN/LSTM/GRU 的建構函數中傳入參數 `num_layers`，即可自動建立多層的循環網路。這也意味著隱藏/狀態向量的大小會按比例增加，因此在處理循環層的輸出時需要考慮到這一點。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## RNNs 用於其他任務\n",
|
||||
"\n",
|
||||
"在本單元中，我們已經看到 RNNs 可以用於序列分類，但事實上，它們還能處理更多任務，例如文本生成、機器翻譯等。我們將在下一單元中探討這些任務。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.8.12 ('py38')",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "522ee52ae3d5ae933e283286254e9a55",
|
||||
"translation_date": "2025-08-31T10:49:00+00:00",
|
||||
"source_file": "lessons/5-NLP/16-RNN/RNNPyTorch.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
|
|
@ -0,0 +1,460 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 循環神經網路\n",
|
||||
"\n",
|
||||
"在上一個模組中，我們探討了文本的豐富語義表示。我們使用的架構能夠捕捉句子中單詞的聚合意義，但它並未考慮單詞的**順序**，因為嵌入後的聚合操作會將原始文本中的這些信息移除。由於這些模型無法表示單詞的順序，因此它們無法解決更複雜或更具歧義的任務，例如文本生成或問題回答。\n",
|
||||
"\n",
|
||||
"為了捕捉文本序列的意義，我們將使用一種稱為**循環神經網路**（Recurrent Neural Network，簡稱 RNN）的神經網路架構。在使用 RNN 時，我們會將句子逐個標記（token）傳遞給網路，網路會生成某種**狀態**，然後我們將該狀態與下一個標記一起再次傳遞給網路。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"給定輸入標記序列 $X_0,\\dots,X_n$，RNN 會創建一個神經網路區塊的序列，並通過反向傳播對該序列進行端到端訓練。每個網路區塊將一對 $(X_i,S_i)$ 作為輸入，並生成 $S_{i+1}$ 作為結果。最終狀態 $S_n$ 或輸出 $Y_n$ 會進入線性分類器以生成結果。所有網路區塊共享相同的權重，並通過一次反向傳播訓練完成端到端的學習。\n",
|
||||
"\n",
|
||||
"> 上圖展示了循環神經網路的展開形式（左側）以及更緊湊的循環表示形式（右側）。需要注意的是，所有 RNN 單元都具有相同的**可共享權重**。\n",
|
||||
"\n",
|
||||
"由於狀態向量 $S_0,\\dots,S_n$ 是通過網路傳遞的，RNN 能夠學習單詞之間的順序依賴性。例如，當單詞 *not* 出現在序列中的某處時，它可以學會在狀態向量中否定某些元素。\n",
|
||||
"\n",
|
||||
"在內部，每個 RNN 單元包含兩個權重矩陣：$W_H$ 和 $W_I$，以及偏置 $b$。在每個 RNN 步驟中，給定輸入 $X_i$ 和輸入狀態 $S_i$，輸出狀態的計算方式為 $S_{i+1} = f(W_H\\times S_i + W_I\\times X_i+b)$，其中 $f$ 是一個激活函數（通常是 $\\tanh$）。\n",
|
||||
"\n",
|
||||
"> 對於像文本生成（我們將在下一單元中討論）或機器翻譯這樣的問題，我們還希望在每個 RNN 步驟中獲得一些輸出值。在這種情況下，還會有另一個矩陣 $W_O$，輸出值的計算方式為 $Y_i=f(W_O\\times S_i+b_O)$。\n",
|
||||
"\n",
|
||||
"現在讓我們看看循環神經網路如何幫助我們對新聞數據集進行分類。\n",
|
||||
"\n",
|
||||
"> 在沙盒環境中，我們需要運行以下程式碼單元，以確保安裝了所需的庫並預取了數據。如果您在本地運行，則可以跳過以下程式碼單元。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import sys\n",
|
||||
"!{sys.executable} -m pip install --quiet tensorflow_datasets==4.4.0\n",
|
||||
"!cd ~ && wget -q -O - https://mslearntensorflowlp.blob.core.windows.net/data/tfds-ag-news.tgz | tar xz"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import tensorflow as tf\n",
|
||||
"from tensorflow import keras\n",
|
||||
"import tensorflow_datasets as tfds\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"# We are going to be training pretty large models. In order not to face errors, we need\n",
|
||||
"# to set tensorflow option to grow GPU memory allocation when required\n",
|
||||
"physical_devices = tf.config.list_physical_devices('GPU') \n",
|
||||
"if len(physical_devices)>0:\n",
|
||||
" tf.config.experimental.set_memory_growth(physical_devices[0], True)\n",
|
||||
"\n",
|
||||
"ds_train, ds_test = tfds.load('ag_news_subset').values()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"nteract": {
|
||||
"transient": {
|
||||
"deleting": false
|
||||
}
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"在訓練大型模型時，GPU 記憶體分配可能會成為一個問題。我們也可能需要嘗試不同的迷你批次大小，以便數據能夠適配 GPU 記憶體，同時確保訓練速度足夠快。如果您在自己的 GPU 機器上運行此代碼，可以嘗試調整迷你批次大小來加快訓練速度。\n",
|
||||
"\n",
|
||||
"> **注意**: 某些版本的 NVidia 驅動程式已知在訓練模型後不會釋放記憶體。我們在這個筆記本中運行了幾個範例，這可能會導致在某些配置中記憶體耗盡，特別是如果您在同一個筆記本中進行自己的實驗時。如果在開始訓練模型時遇到一些奇怪的錯誤，您可能需要重新啟動筆記本的內核。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {
|
||||
"collapsed": true,
|
||||
"jupyter": {
|
||||
"outputs_hidden": false,
|
||||
"source_hidden": false
|
||||
},
|
||||
"nteract": {
|
||||
"transient": {
|
||||
"deleting": false
|
||||
}
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"batch_size = 16\n",
|
||||
"embed_size = 64"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 簡單的 RNN 分類器\n",
|
||||
"\n",
|
||||
"在簡單的 RNN 中，每個循環單元都是一個簡單的線性網絡，它接收輸入向量和狀態向量，並生成新的狀態向量。在 Keras 中，可以使用 `SimpleRNN` 層來表示。\n",
|
||||
"\n",
|
||||
"雖然我們可以直接將 one-hot 編碼的標記傳遞給 RNN 層，但由於其高維度性，這並不是一個好主意。因此，我們將使用嵌入層來降低詞向量的維度，接著是 RNN 層，最後是一個 `Dense` 分類器。\n",
|
||||
"\n",
|
||||
"> **注意**：在維度不太高的情況下，例如使用字符級標記化時，直接將 one-hot 編碼的標記傳遞給 RNN 單元可能是合理的選擇。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"sequential\"\n",
|
||||
"_________________________________________________________________\n",
|
||||
"Layer (type) Output Shape Param # \n",
|
||||
"=================================================================\n",
|
||||
"text_vectorization (TextVect (None, None) 0 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"embedding (Embedding) (None, None, 64) 1280000 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"simple_rnn (SimpleRNN) (None, 16) 1296 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"dense (Dense) (None, 4) 68 \n",
|
||||
"=================================================================\n",
|
||||
"Total params: 1,281,364\n",
|
||||
"Trainable params: 1,281,364\n",
|
||||
"Non-trainable params: 0\n",
|
||||
"_________________________________________________________________\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vocab_size = 20000\n",
|
||||
"\n",
|
||||
"vectorizer = keras.layers.experimental.preprocessing.TextVectorization(\n",
|
||||
" max_tokens=vocab_size,\n",
|
||||
" input_shape=(1,))\n",
|
||||
"\n",
|
||||
"model = keras.models.Sequential([\n",
|
||||
" vectorizer,\n",
|
||||
" keras.layers.Embedding(vocab_size, embed_size),\n",
|
||||
" keras.layers.SimpleRNN(16),\n",
|
||||
" keras.layers.Dense(4,activation='softmax')\n",
|
||||
"])\n",
|
||||
"\n",
|
||||
"model.summary()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意：** 為了簡化，我們在這裡使用未經訓練的嵌入層，但如果想要更好的結果，可以使用 Word2Vec 預訓練的嵌入層，如前一單元所述。你可以嘗試將此程式碼改寫為使用預訓練嵌入層，這會是一個很好的練習。\n",
|
||||
"\n",
|
||||
"現在讓我們來訓練 RNN。一般來說，RNN 的訓練相當困難，因為當 RNN 單元沿著序列長度展開時，涉及反向傳播的層數會非常多。因此，我們需要選擇較小的學習率，並在更大的數據集上訓練網路以獲得良好的結果。這可能需要相當長的時間，因此建議使用 GPU。\n",
|
||||
"\n",
|
||||
"為了加快速度，我們將僅使用新聞標題來訓練 RNN 模型，省略描述部分。你可以嘗試使用描述進行訓練，看看是否能讓模型成功訓練。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {
|
||||
"scrolled": true
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Training vectorizer\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def extract_title(x):\n",
|
||||
" return x['title']\n",
|
||||
"\n",
|
||||
"def tupelize_title(x):\n",
|
||||
" return (extract_title(x),x['label'])\n",
|
||||
"\n",
|
||||
"print('Training vectorizer')\n",
|
||||
"vectorizer.adapt(ds_train.take(2000).map(extract_title))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"7500/7500 [==============================] - 82s 11ms/step - loss: 0.6629 - acc: 0.7623 - val_loss: 0.5559 - val_acc: 0.7995\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7f3e0030d350>"
|
||||
]
|
||||
},
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'], optimizer='adam')\n",
|
||||
"model.fit(ds_train.map(tupelize_title).batch(batch_size),validation_data=ds_test.map(tupelize_title).batch(batch_size))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"nteract": {
|
||||
"transient": {
|
||||
"deleting": false
|
||||
}
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"> **注意** 這裡的準確性可能會較低，因為我們僅針對新聞標題進行訓練。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 重新探討變長序列\n",
|
||||
"\n",
|
||||
"請記住，`TextVectorization` 層會自動在小批量中用填充標記（pad tokens）填充變長序列。然而，這些填充標記也會參與訓練，這可能會使模型的收斂變得更加複雜。\n",
|
||||
"\n",
|
||||
"我們可以採取幾種方法來減少填充的數量。其中一種方法是根據序列長度重新排序數據集，並將所有序列按大小分組。這可以使用 `tf.data.experimental.bucket_by_sequence_length` 函數來完成（參見[文件](https://www.tensorflow.org/api_docs/python/tf/data/experimental/bucket_by_sequence_length)）。\n",
|
||||
"\n",
|
||||
"另一種方法是使用**遮罩（masking）**。在 Keras 中，一些層支持額外的輸入，用於指示哪些標記應該在訓練時被考慮。要將遮罩整合到模型中，我們可以選擇加入一個單獨的 `Masking` 層（[文件](https://keras.io/api/layers/core_layers/masking/)），或者在 `Embedding` 層中指定參數 `mask_zero=True`。\n",
|
||||
"\n",
|
||||
"> **Note**: 完成整個數據集的一個訓練週期大約需要 5 分鐘。如果你失去耐心，可以隨時中斷訓練。你還可以通過在 `ds_train` 和 `ds_test` 數據集後添加 `.take(...)` 子句來限制用於訓練的數據量。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"7500/7500 [==============================] - 371s 49ms/step - loss: 0.5401 - acc: 0.8079 - val_loss: 0.3780 - val_acc: 0.8822\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7f3dec118850>"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def extract_text(x):\n",
|
||||
" return x['title']+' '+x['description']\n",
|
||||
"\n",
|
||||
"def tupelize(x):\n",
|
||||
" return (extract_text(x),x['label'])\n",
|
||||
"\n",
|
||||
"model = keras.models.Sequential([\n",
|
||||
" vectorizer,\n",
|
||||
" keras.layers.Embedding(vocab_size,embed_size,mask_zero=True),\n",
|
||||
" keras.layers.SimpleRNN(16),\n",
|
||||
" keras.layers.Dense(4,activation='softmax')\n",
|
||||
"])\n",
|
||||
"\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'], optimizer='adam')\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(batch_size),validation_data=ds_test.map(tupelize).batch(batch_size))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在我們使用遮罩技術，可以在整個標題和描述的數據集上訓練模型。\n",
|
||||
"\n",
|
||||
"> **注意**：你是否注意到我們一直在使用基於新聞標題訓練的向量化工具，而不是整篇文章的內容？這可能會導致某些詞元被忽略，因此重新訓練向量化工具會更好。不過，這可能只會帶來非常小的影響，所以為了簡化流程，我們將繼續使用之前預訓練的向量化工具。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## LSTM: 長短期記憶\n",
|
||||
"\n",
|
||||
"RNN 的主要問題之一是**梯度消失**。RNN 可能會非常長，並且在反向傳播過程中，可能很難將梯度傳遞回網路的第一層。當這種情況發生時，網路無法學習遠距離的詞元之間的關係。為了避免這個問題，可以通過使用**門控機制**引入**顯式狀態管理**。最常見的兩種引入門控機制的架構是**長短期記憶**（LSTM）和**門控循環單元**（GRU）。我們在這裡將介紹 LSTM。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"LSTM 網路的組織方式與 RNN 類似，但有兩個狀態會從一層傳遞到下一層：實際狀態 $c$ 和隱藏向量 $h$。在每個單元中，隱藏向量 $h_{t-1}$ 與輸入 $x_t$ 結合，並共同控制狀態 $c_t$ 和輸出 $h_{t}$ 的變化，這是通過**門控機制**實現的。每個門都有 sigmoid 激活函數（輸出範圍為 $[0,1]$），可以將其視為與狀態向量相乘的位掩碼。LSTM 包含以下門控機制（如上圖從左到右）：\n",
|
||||
"* **遺忘門**：決定向量 $c_{t-1}$ 的哪些部分需要遺忘，哪些需要保留。\n",
|
||||
"* **輸入門**：決定來自輸入向量和前一隱藏向量的信息有多少應該被整合到狀態向量中。\n",
|
||||
"* **輸出門**：接收新的狀態向量，並決定其哪些部分將用於生成新的隱藏向量 $h_t$。\n",
|
||||
"\n",
|
||||
"狀態 $c$ 的組成部分可以被視為可以開啟或關閉的標誌。例如，當我們在序列中遇到名字 *Alice* 時，我們猜測它指的是一位女性，並在狀態中設置一個標誌，表示句子中有一個女性名詞。當我們進一步遇到單詞 *and Tom* 時，我們會設置一個標誌，表示句子中有一個複數名詞。因此，通過操作狀態，我們可以追蹤句子的語法屬性。\n",
|
||||
"\n",
|
||||
"> **Note**: 這裡有一個很棒的資源可以幫助理解 LSTM 的內部結構：[Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) by Christopher Olah。\n",
|
||||
"\n",
|
||||
"雖然 LSTM 單元的內部結構看起來可能很複雜，但 Keras 將這些實現隱藏在 `LSTM` 層中，因此在上面的範例中，我們只需要替換循環層即可：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"15000/15000 [==============================] - 188s 13ms/step - loss: 0.5692 - acc: 0.7916 - val_loss: 0.3441 - val_acc: 0.8870\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7f3d6af5c350>"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = keras.models.Sequential([\n",
|
||||
" vectorizer,\n",
|
||||
" keras.layers.Embedding(vocab_size, embed_size),\n",
|
||||
" keras.layers.LSTM(8),\n",
|
||||
" keras.layers.Dense(4,activation='softmax')\n",
|
||||
"])\n",
|
||||
"\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'], optimizer='adam')\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(8),validation_data=ds_test.map(tupelize).batch(8))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 雙向與多層 RNN\n",
|
||||
"\n",
|
||||
"在我們之前的範例中，循環神經網路都是從序列的開頭運算到結尾。這對我們來說很自然，因為它遵循了我們閱讀或聆聽語音的方向。然而，對於需要隨機存取輸入序列的情境，讓循環運算在兩個方向上進行會更合理。允許在兩個方向上進行運算的 RNN 被稱為 **雙向** RNN，可以透過將循環層包裹在特殊的 `Bidirectional` 層中來建立。\n",
|
||||
"\n",
|
||||
"> **Note**: `Bidirectional` 層會在其內部建立該層的兩個副本，並將其中一個副本的 `go_backwards` 屬性設置為 `True`，使其沿著序列的相反方向運算。\n",
|
||||
"\n",
|
||||
"無論是單向還是雙向的循環神經網路，都能捕捉序列中的模式，並將其存儲到狀態向量中或作為輸出返回。與卷積神經網路類似，我們可以在第一層之後再建立另一個循環層，以捕捉更高層次的模式，這些模式是由第一層提取的低層次模式構建而成的。這引出了 **多層 RNN** 的概念，它由兩層或更多層循環神經網路組成，其中前一層的輸出作為下一層的輸入。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"*圖片來源：[這篇精彩文章](https://towardsdatascience.com/from-a-lstm-cell-to-a-multilayer-lstm-network-with-pytorch-2899eb5696f3) 作者 Fernando López。*\n",
|
||||
"\n",
|
||||
"Keras 讓構建這些網路變得非常簡單，因為你只需要在模型中添加更多的循環層。對於除了最後一層以外的所有層，我們需要指定 `return_sequences=True` 參數，因為我們需要該層返回所有中間狀態，而不僅僅是循環運算的最終狀態。\n",
|
||||
"\n",
|
||||
"現在我們來為分類問題構建一個雙層雙向 LSTM。\n",
|
||||
"\n",
|
||||
"> **Note** 這段程式碼執行時間可能會比較長，但它提供了我們目前看到的最高準確率。所以也許值得等待並查看結果。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"5044/7500 [===================>..........] - ETA: 2:33 - loss: 0.3709 - acc: 0.8706\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r5045/7500 [===================>..........] - ETA: 2:33 - loss: 0.3709 - acc: 0.8706"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = keras.models.Sequential([\n",
|
||||
" vectorizer,\n",
|
||||
" keras.layers.Embedding(vocab_size, 128, mask_zero=True),\n",
|
||||
" keras.layers.Bidirectional(keras.layers.LSTM(64,return_sequences=True)),\n",
|
||||
" keras.layers.Bidirectional(keras.layers.LSTM(64)), \n",
|
||||
" keras.layers.Dense(4,activation='softmax')\n",
|
||||
"])\n",
|
||||
"\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'], optimizer='adam')\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(batch_size),\n",
|
||||
" validation_data=ds_test.map(tupelize).batch(batch_size))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## RNN 用於其他任務\n",
|
||||
"\n",
|
||||
"到目前為止，我們專注於使用 RNN 來對文本序列進行分類。但它們還可以處理更多任務，例如文本生成和機器翻譯——我們將在下一單元中探討這些任務。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。儘管我們努力確保翻譯的準確性，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernel_info": {
|
||||
"name": "conda-env-py37_tensorflow-py"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "py37_tensorflow",
|
||||
"language": "python",
|
||||
"name": "conda-env-py37_tensorflow-py"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.7.9"
|
||||
},
|
||||
"nteract": {
|
||||
"version": "nteract-front-end@1.0.0"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "81351e61f619b432ff51010a4f993194",
|
||||
"translation_date": "2025-08-31T10:46:36+00:00",
|
||||
"source_file": "lessons/5-NLP/16-RNN/RNNTF.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
# 作業：筆記本
|
||||
|
||||
使用與本課程相關的筆記本（無論是 PyTorch 或 TensorFlow 版本），使用您自己的數據集重新運行它們，例如來自 Kaggle 的數據集，並記得標註來源。重寫筆記本以強調您自己的發現。嘗試使用不同類型的數據集，並記錄您的發現，例如使用像 [這個關於天氣推文的 Kaggle 比賽數據集](https://www.kaggle.com/competitions/crowdflower-weather-twitter/data?select=train.csv) 這樣的文本描述。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。
|
||||
|
|
@ -0,0 +1,414 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 生成式網絡\n",
|
||||
"\n",
|
||||
"循環神經網絡（Recurrent Neural Networks, RNNs）及其門控單元變體，例如長短期記憶單元（Long Short Term Memory Cells, LSTMs）和門控循環單元（Gated Recurrent Units, GRUs），提供了一種語言建模的機制，也就是說，它們可以學習單詞的排列順序，並對序列中的下一個單詞進行預測。這使得我們可以使用 RNNs 來完成**生成任務**，例如普通文本生成、機器翻譯，甚至是圖像描述生成。\n",
|
||||
"\n",
|
||||
"在我們上一單元討論的 RNN 架構中，每個 RNN 單元會生成下一個隱藏狀態作為輸出。然而，我們也可以為每個循環單元添加另一個輸出，這樣就可以輸出一個**序列**（其長度等於原始序列的長度）。此外，我們還可以使用不在每一步接受輸入的 RNN 單元，而僅僅接受一個初始狀態向量，然後生成一個輸出序列。\n",
|
||||
"\n",
|
||||
"在這個筆記本中，我們將專注於幫助我們生成文本的簡單生成模型。為了簡化，我們將構建一個**字符級網絡**，逐字母生成文本。在訓練過程中，我們需要採用一些文本語料庫，並將其拆分為字母序列。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Loading dataset...\n",
|
||||
"Building vocab...\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import torch\n",
|
||||
"import torchtext\n",
|
||||
"import numpy as np\n",
|
||||
"from torchnlp import *\n",
|
||||
"train_dataset,test_dataset,classes,vocab = load_dataset()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 建立字符詞彙表\n",
|
||||
"\n",
|
||||
"為了構建字符級生成網絡，我們需要將文本拆分為單個字符，而不是單詞。這可以通過定義一個不同的分詞器來完成：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Vocabulary size = 82\n",
|
||||
"Encoding of 'a' is 1\n",
|
||||
"Character with code 13 is c\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def char_tokenizer(words):\n",
|
||||
" return list(words) #[word for word in words]\n",
|
||||
"\n",
|
||||
"counter = collections.Counter()\n",
|
||||
"for (label, line) in train_dataset:\n",
|
||||
" counter.update(char_tokenizer(line))\n",
|
||||
"vocab = torchtext.vocab.vocab(counter)\n",
|
||||
"\n",
|
||||
"vocab_size = len(vocab)\n",
|
||||
"print(f\"Vocabulary size = {vocab_size}\")\n",
|
||||
"print(f\"Encoding of 'a' is {vocab.get_stoi()['a']}\")\n",
|
||||
"print(f\"Character with code 13 is {vocab.get_itos()[13]}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"讓我們看看如何對我們數據集中的文本進行編碼的示例：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"tensor([ 0, 1, 2, 2, 3, 4, 5, 6, 3, 7, 8, 1, 9, 10, 3, 11, 2, 1,\n",
|
||||
" 12, 3, 7, 1, 13, 14, 3, 15, 16, 5, 17, 3, 5, 18, 8, 3, 7, 2,\n",
|
||||
" 1, 13, 14, 3, 19, 20, 8, 21, 5, 8, 9, 10, 22, 3, 20, 8, 21, 5,\n",
|
||||
" 8, 9, 10, 3, 23, 3, 4, 18, 17, 9, 5, 23, 10, 8, 2, 2, 8, 9,\n",
|
||||
" 10, 24, 3, 0, 1, 2, 2, 3, 4, 5, 9, 8, 8, 5, 25, 10, 3, 26,\n",
|
||||
" 12, 27, 16, 26, 2, 27, 16, 28, 29, 30, 1, 16, 26, 3, 17, 31, 3, 21,\n",
|
||||
" 2, 5, 9, 1, 23, 13, 32, 16, 27, 13, 10, 24, 3, 1, 9, 8, 3, 10,\n",
|
||||
" 8, 8, 27, 16, 28, 3, 28, 9, 8, 8, 16, 3, 1, 28, 1, 27, 16, 6])"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def enc(x):\n",
|
||||
" return torch.LongTensor(encode(x,voc=vocab,tokenizer=char_tokenizer))\n",
|
||||
"\n",
|
||||
"enc(train_dataset[0][1])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 訓練生成式 RNN\n",
|
||||
"\n",
|
||||
"我們訓練 RNN 生成文本的方式如下。在每一步中，我們會取一段長度為 `nchars` 的字符序列，並要求網絡為每個輸入字符生成下一個輸出字符：\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"根據實際情況，我們可能還需要加入一些特殊字符，例如 *序列結束* `<eos>`。在我們的案例中，我們只希望訓練網絡進行無限文本生成，因此我們將每個序列的大小固定為 `nchars` 個標記。因此，每個訓練樣本將由 `nchars` 個輸入和 `nchars` 個輸出組成（輸出序列是輸入序列向左移動一個符號）。小批量訓練將由多個這樣的序列組成。\n",
|
||||
"\n",
|
||||
"我們生成小批量的方式是取每段長度為 `l` 的新聞文本，並從中生成所有可能的輸入-輸出組合（將有 `l-nchars` 個這樣的組合）。這些組合將形成一個小批量，而每次訓練步驟的小批量大小會有所不同。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(tensor([[ 0, 1, 2, ..., 28, 29, 30],\n",
|
||||
" [ 1, 2, 2, ..., 29, 30, 1],\n",
|
||||
" [ 2, 2, 3, ..., 30, 1, 16],\n",
|
||||
" ...,\n",
|
||||
" [20, 8, 21, ..., 1, 28, 1],\n",
|
||||
" [ 8, 21, 5, ..., 28, 1, 27],\n",
|
||||
" [21, 5, 8, ..., 1, 27, 16]]),\n",
|
||||
" tensor([[ 1, 2, 2, ..., 29, 30, 1],\n",
|
||||
" [ 2, 2, 3, ..., 30, 1, 16],\n",
|
||||
" [ 2, 3, 4, ..., 1, 16, 26],\n",
|
||||
" ...,\n",
|
||||
" [ 8, 21, 5, ..., 28, 1, 27],\n",
|
||||
" [21, 5, 8, ..., 1, 27, 16],\n",
|
||||
" [ 5, 8, 9, ..., 27, 16, 6]]))"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"nchars = 100\n",
|
||||
"\n",
|
||||
"def get_batch(s,nchars=nchars):\n",
|
||||
" ins = torch.zeros(len(s)-nchars,nchars,dtype=torch.long,device=device)\n",
|
||||
" outs = torch.zeros(len(s)-nchars,nchars,dtype=torch.long,device=device)\n",
|
||||
" for i in range(len(s)-nchars):\n",
|
||||
" ins[i] = enc(s[i:i+nchars])\n",
|
||||
" outs[i] = enc(s[i+1:i+nchars+1])\n",
|
||||
" return ins,outs\n",
|
||||
"\n",
|
||||
"get_batch(train_dataset[0][1])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在讓我們定義生成器網絡。它可以基於我們在上一單元中討論過的任何循環單元（簡單、LSTM 或 GRU）。在我們的例子中，我們將使用 LSTM。\n",
|
||||
"\n",
|
||||
"由於網絡以字符作為輸入，且詞彙量相對較小，因此我們不需要嵌入層，直接使用獨熱編碼的輸入即可傳遞到 LSTM 單元。然而，因為我們以字符編號作為輸入，所以在傳遞到 LSTM 之前需要先進行獨熱編碼。這可以在 `forward` 傳遞過程中通過調用 `one_hot` 函數來完成。輸出編碼器將是一個線性層，用於將隱藏狀態轉換為獨熱編碼的輸出。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"class LSTMGenerator(torch.nn.Module):\n",
|
||||
" def __init__(self, vocab_size, hidden_dim):\n",
|
||||
" super().__init__()\n",
|
||||
" self.rnn = torch.nn.LSTM(vocab_size,hidden_dim,batch_first=True)\n",
|
||||
" self.fc = torch.nn.Linear(hidden_dim, vocab_size)\n",
|
||||
"\n",
|
||||
" def forward(self, x, s=None):\n",
|
||||
" x = torch.nn.functional.one_hot(x,vocab_size).to(torch.float32)\n",
|
||||
" x,s = self.rnn(x,s)\n",
|
||||
" return self.fc(x),s"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"在訓練過程中，我們希望能夠抽樣生成的文本。為此，我們將定義 `generate` 函數，該函數會生成長度為 `size` 的輸出字串，並以初始字串 `start` 作為起點。\n",
|
||||
"\n",
|
||||
"其運作方式如下：首先，我們將整個初始字串通過網絡，並獲得輸出狀態 `s` 和下一個預測字元 `out`。由於 `out` 是獨熱編碼（one-hot encoded），我們使用 `argmax` 來獲取字元在詞彙表中的索引 `nc`，然後使用 `itos` 找出實際字元，並將其附加到結果字元列表 `chars` 中。這個生成一個字元的過程會重複執行 `size` 次，以生成所需數量的字元。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def generate(net,size=100,start='today '):\n",
|
||||
" chars = list(start)\n",
|
||||
" out, s = net(enc(chars).view(1,-1).to(device))\n",
|
||||
" for i in range(size):\n",
|
||||
" nc = torch.argmax(out[0][-1])\n",
|
||||
" chars.append(vocab.get_itos()[nc])\n",
|
||||
" out, s = net(nc.view(1,-1),s)\n",
|
||||
" return ''.join(chars)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在開始訓練吧！訓練迴圈幾乎與我們之前的例子相同，但這次我們每隔 1000 個 epoch 就會輸出一段生成的文字，而不是準確率。\n",
|
||||
"\n",
|
||||
"需要特別注意的是我們計算損失的方式。我們需要基於單熱編碼的輸出 `out` 和期望的文字輸出 `text_out`（即字符索引的列表）來計算損失。幸運的是，`cross_entropy` 函數的第一個參數是未正規化的網路輸出，第二個參數是類別編號，這正好符合我們的需求。該函數還會自動對小批量的大小進行平均。\n",
|
||||
"\n",
|
||||
"我們還通過 `samples_to_train` 限制了訓練樣本的數量，以免等待時間過長。我們鼓勵你進行實驗，嘗試更長時間的訓練，可能是多個 epoch（在這種情況下，你需要在這段程式碼外再建立一個迴圈）。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Current loss = 4.398899078369141\n",
|
||||
"today sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr sr s\n",
|
||||
"Current loss = 2.161320447921753\n",
|
||||
"today and to the tor to to the tor to to the tor to to the tor to to the tor to to the tor to to the tor t\n",
|
||||
"Current loss = 1.6722588539123535\n",
|
||||
"today and the court to the could to the could to the could to the could to the could to the could to the c\n",
|
||||
"Current loss = 2.423795223236084\n",
|
||||
"today and a second to the conternation of the conternation of the conternation of the conternation of the \n",
|
||||
"Current loss = 1.702607274055481\n",
|
||||
"today and the company to the company to the company to the company to the company to the company to the co\n",
|
||||
"Current loss = 1.692358136177063\n",
|
||||
"today and the company to the company to the company to the company to the company to the company to the co\n",
|
||||
"Current loss = 1.9722288846969604\n",
|
||||
"today and the control the control the control the control the control the control the control the control \n",
|
||||
"Current loss = 1.8705692291259766\n",
|
||||
"today and the second to the second to the second to the second to the second to the second to the second t\n",
|
||||
"Current loss = 1.7626899480819702\n",
|
||||
"today and a security and a security and a security and a security and a security and a security and a secu\n",
|
||||
"Current loss = 1.5574463605880737\n",
|
||||
"today and the company and the company and the company and the company and the company and the company and \n",
|
||||
"Current loss = 1.5620026588439941\n",
|
||||
"today and the be that the be the be that the be the be that the be the be that the be the be that the be t\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"net = LSTMGenerator(vocab_size,64).to(device)\n",
|
||||
"\n",
|
||||
"samples_to_train = 10000\n",
|
||||
"optimizer = torch.optim.Adam(net.parameters(),0.01)\n",
|
||||
"loss_fn = torch.nn.CrossEntropyLoss()\n",
|
||||
"net.train()\n",
|
||||
"for i,x in enumerate(train_dataset):\n",
|
||||
" # x[0] is class label, x[1] is text\n",
|
||||
" if len(x[1])-nchars<10:\n",
|
||||
" continue\n",
|
||||
" samples_to_train-=1\n",
|
||||
" if not samples_to_train: break\n",
|
||||
" text_in, text_out = get_batch(x[1])\n",
|
||||
" optimizer.zero_grad()\n",
|
||||
" out,s = net(text_in)\n",
|
||||
" loss = torch.nn.functional.cross_entropy(out.view(-1,vocab_size),text_out.flatten()) #cross_entropy(out,labels)\n",
|
||||
" loss.backward()\n",
|
||||
" optimizer.step()\n",
|
||||
" if i%1000==0:\n",
|
||||
" print(f\"Current loss = {loss.item()}\")\n",
|
||||
" print(generate(net))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"這個範例已經生成了一些相當不錯的文本，但仍有幾個方面可以進一步改進：\n",
|
||||
"\n",
|
||||
"* **更好的小批次生成**。我們在準備訓練數據時，是從一個樣本中生成一個小批次。這並不理想，因為小批次的大小各不相同，有些甚至無法生成，因為文本小於 `nchars`。此外，過小的小批次無法充分利用 GPU。更明智的做法是從所有樣本中提取一大段文本，然後生成所有的輸入-輸出對，將它們打亂，並生成大小相等的小批次。\n",
|
||||
"\n",
|
||||
"* **多層 LSTM**。嘗試使用 2 或 3 層的 LSTM 單元是有意義的。如我們在前一單元提到的，每層 LSTM 都會從文本中提取特定的模式，而在字元級生成器的情況下，我們可以預期較低層的 LSTM 負責提取音節，而較高層則負責提取單詞及單詞組合。這可以通過向 LSTM 構造函數傳遞層數參數來簡單實現。\n",
|
||||
"\n",
|
||||
"* 你也可以嘗試使用 **GRU 單元**，看看哪種表現更好，以及嘗試 **不同的隱藏層大小**。過大的隱藏層可能導致過擬合（例如，網絡會學習到精確的文本），而過小的隱藏層可能無法生成良好的結果。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 軟性文本生成與溫度\n",
|
||||
"\n",
|
||||
"在之前 `generate` 的定義中，我們總是選擇機率最高的字元作為生成文本的下一個字元。這導致文本經常在相同的字元序列之間反覆循環，如以下範例所示：\n",
|
||||
"```\n",
|
||||
"today of the second the company and a second the company ...\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"然而，如果我們查看下一個字元的機率分佈，可能會發現幾個最高機率之間的差距並不大，例如一個字元的機率可能是 0.2，另一個則是 0.19，等等。例如，當尋找序列 '*play*' 的下一個字元時，下一個字元可能同樣是空格或 **e**（如單字 *player* 中）。\n",
|
||||
"\n",
|
||||
"這讓我們得出結論，選擇機率最高的字元並不總是「公平」的，因為選擇第二高的字元仍然可能生成有意義的文本。更明智的做法是根據網絡輸出的機率分佈來**抽樣**字元。\n",
|
||||
"\n",
|
||||
"這種抽樣可以使用 `multinomial` 函數來完成，該函數實現了所謂的**多項分佈**。以下定義了一個實現此**軟性**文本生成的函數：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {
|
||||
"scrolled": true
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"--- Temperature = 0.3\n",
|
||||
"Today and a company and complete an all the land the restrational the as a security and has provers the pay to and a report and the computer in the stand has filities and working the law the stations for a company and with the company and the final the first company and refight of the state and and workin\n",
|
||||
"\n",
|
||||
"--- Temperature = 0.8\n",
|
||||
"Today he oniis its first to Aus bomblaties the marmation a to manan boogot that pirate assaid a relaid their that goverfin the the Cappets Ecrotional Assonia Cition targets it annight the w scyments Blamity #39;s TVeer Diercheg Reserals fran envyuil that of ster said access what succers of Dour-provelith\n",
|
||||
"\n",
|
||||
"--- Temperature = 1.0\n",
|
||||
"Today holy they a 11 will meda a toket subsuaties, engins for Chanos, they's has stainger past to opening orital his thempting new Nattona was al innerforder advan-than #36;s night year his religuled talitatian what the but with Wednesday to Justment will wemen of Mark CCC Camp as Timed Nae wome a leaders\n",
|
||||
"\n",
|
||||
"--- Temperature = 1.3\n",
|
||||
"Today gpone 2.5 fech atcusion poor cocles toparsdorM.cht Line Pamage put 43 his calt lowed to the book, that has authh-the silia rruch ailing to'ory andhes beutirsimi- Aefffive heading offil an auf eacklets is charged evis, Gunymy oy) Mony has it after-sloythyor loveId out filme, the Natabl -Najuntaxiggs \n",
|
||||
"\n",
|
||||
"--- Temperature = 1.8\n",
|
||||
"Today plary, P.slan chly\\401 mardregationly #39;t 8.1Mide) closes ,filtcon alfly playin roven!\\grea.-QFBEP: Iss onfarchQ/itilia CCf Zivesigntwasta orce.-Peul-aw.uicrin of fuglinfsut aftaningwo, MIEX awayew Aice Woiduar Corvagiugge oppo esig ThusBratourid canthly-RyI.co lagitems\\eexciaishes.conBabntusmor I\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def generate_soft(net,size=100,start='today ',temperature=1.0):\n",
|
||||
" chars = list(start)\n",
|
||||
" out, s = net(enc(chars).view(1,-1).to(device))\n",
|
||||
" for i in range(size):\n",
|
||||
" #nc = torch.argmax(out[0][-1])\n",
|
||||
" out_dist = out[0][-1].div(temperature).exp()\n",
|
||||
" nc = torch.multinomial(out_dist,1)[0]\n",
|
||||
" chars.append(vocab.get_itos()[nc])\n",
|
||||
" out, s = net(nc.view(1,-1),s)\n",
|
||||
" return ''.join(chars)\n",
|
||||
" \n",
|
||||
"for i in [0.3,0.8,1.0,1.3,1.8]:\n",
|
||||
" print(f\"--- Temperature = {i}\\n{generate_soft(net,size=300,start='Today ',temperature=i)}\\n\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們引入了一個名為 **temperature** 的參數，用於指示我們應該多大程度地堅持最高概率。如果 temperature 為 1.0，我們進行公平的多項式抽樣，而當 temperature 趨於無窮大時，所有概率變得相等，我們隨機選擇下一個字符。在下面的例子中，我們可以觀察到，當我們將 temperature 增加得過高時，文本變得毫無意義，而當它接近 0 時，則類似於「循環」的硬生成文本。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.8.12 ('py38')",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "7673cd150d96c74c6d6011460094efb4",
|
||||
"translation_date": "2025-08-31T10:34:02+00:00",
|
||||
"source_file": "lessons/5-NLP/17-GenerativeNetworks/GenerativePyTorch.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
@ -0,0 +1,497 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 生成式網絡\n",
|
||||
"\n",
|
||||
"循環神經網絡（Recurrent Neural Networks, RNNs）及其門控單元變體，例如長短期記憶單元（Long Short Term Memory Cells, LSTMs）和門控循環單元（Gated Recurrent Units, GRUs），提供了一種語言建模的機制，也就是說，它們可以學習單詞的排列順序，並對序列中的下一個單詞進行預測。這使得我們可以使用 RNNs 來完成**生成任務**，例如普通文本生成、機器翻譯，甚至是圖像描述生成。\n",
|
||||
"\n",
|
||||
"在我們上一單元討論的 RNN 架構中，每個 RNN 單元會生成下一個隱藏狀態作為輸出。然而，我們也可以為每個循環單元添加另一個輸出，這樣就可以輸出一個**序列**（其長度等於原始序列的長度）。此外，我們還可以使用不在每一步接受輸入的 RNN 單元，而僅僅接受一個初始狀態向量，然後生成一個輸出序列。\n",
|
||||
"\n",
|
||||
"在這個筆記本中，我們將專注於幫助我們生成文本的簡單生成模型。為了簡化起見，我們將構建一個**字符級網絡**，逐字母生成文本。在訓練過程中，我們需要使用一些文本語料庫，並將其拆分為字母序列。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import tensorflow as tf\n",
|
||||
"from tensorflow import keras\n",
|
||||
"import tensorflow_datasets as tfds\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"ds_train, ds_test = tfds.load('ag_news_subset').values()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 建立字元詞彙表\n",
|
||||
"\n",
|
||||
"為了建立字元級別的生成網絡，我們需要將文本拆分為單個字元，而不是單詞。我們之前使用的 `TextVectorization` 層無法做到這一點，因此我們有以下兩個選擇：\n",
|
||||
"\n",
|
||||
"* 手動加載文本並自行進行分詞，如 [這個官方 Keras 範例](https://keras.io/examples/generative/lstm_character_level_text_generation/) 中所示\n",
|
||||
"* 使用 `Tokenizer` 類進行字元級別的分詞。\n",
|
||||
"\n",
|
||||
"我們將選擇第二種方法。`Tokenizer` 也可以用於將文本分詞為單詞，因此可以很輕鬆地從字元級分詞切換到單詞級分詞。\n",
|
||||
"\n",
|
||||
"要進行字元級分詞，我們需要傳遞參數 `char_level=True`：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def extract_text(x):\n",
|
||||
" return x['title']+' '+x['description']\n",
|
||||
"\n",
|
||||
"def tupelize(x):\n",
|
||||
" return (extract_text(x),x['label'])\n",
|
||||
"\n",
|
||||
"tokenizer = keras.preprocessing.text.Tokenizer(char_level=True,lower=False)\n",
|
||||
"tokenizer.fit_on_texts([x['title'].numpy().decode('utf-8') for x in ds_train])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們還希望使用一個特殊的標記來表示**序列結束**，我們將其稱為`<eos>`。讓我們手動將其添加到詞彙表中：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"eos_token = len(tokenizer.word_index)+1\n",
|
||||
"tokenizer.word_index['<eos>'] = eos_token\n",
|
||||
"\n",
|
||||
"vocab_size = eos_token + 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在，要將文本編碼為數字序列，我們可以使用：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[[48, 2, 10, 10, 5, 44, 1, 25, 5, 8, 10, 13, 78]]"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tokenizer.texts_to_sequences(['Hello, world!'])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 訓練生成式 RNN 來生成標題\n",
|
||||
"\n",
|
||||
"我們將以以下方式訓練 RNN 來生成新聞標題。在每一步中，我們會選取一個標題，將其輸入到 RNN 中，並且對於每個輸入的字元，我們會要求網路生成下一個輸出的字元：\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"對於序列中的最後一個字元，我們會要求網路生成 `<eos>` 標記。\n",
|
||||
"\n",
|
||||
"我們在此使用的生成式 RNN 的主要不同之處在於，我們會從 RNN 的每一步輸出中提取結果，而不僅僅是從最後一個單元提取。這可以通過向 RNN 單元指定 `return_sequences` 參數來實現。\n",
|
||||
"\n",
|
||||
"因此，在訓練過程中，網路的輸入將是一段編碼字元的序列，而輸出將是相同長度的序列，但向右偏移一個元素並以 `<eos>` 結束。小批次將由多個這樣的序列組成，我們需要使用**填充**來對齊所有序列。\n",
|
||||
"\n",
|
||||
"接下來，我們來建立一些函數，用於轉換數據集。由於我們希望在小批次層級進行序列填充，我們會先通過調用 `.batch()` 將數據集分批，然後使用 `map` 來進行轉換。因此，轉換函數將以整個小批次作為參數：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def title_batch(x):\n",
|
||||
" x = [t.numpy().decode('utf-8') for t in x]\n",
|
||||
" z = tokenizer.texts_to_sequences(x)\n",
|
||||
" z = tf.keras.preprocessing.sequence.pad_sequences(z)\n",
|
||||
" return tf.one_hot(z,vocab_size), tf.one_hot(tf.concat([z[:,1:],tf.constant(eos_token,shape=(len(z),1))],axis=1),vocab_size)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"一些我們在這裡執行的重要步驟：\n",
|
||||
"* 我們首先從字串張量中提取實際的文字\n",
|
||||
"* `text_to_sequences` 將字串列表轉換為整數張量列表\n",
|
||||
"* `pad_sequences` 將這些張量填充到它們的最大長度\n",
|
||||
"* 最後，我們對所有字符進行獨熱編碼，並執行位移和 `<eos>` 附加操作。我們很快就會了解為什麼需要獨熱編碼的字符\n",
|
||||
"\n",
|
||||
"然而，這個函數是 **Pythonic** 的，也就是說它無法自動轉換為 Tensorflow 的計算圖。如果我們直接在 `Dataset.map` 函數中使用這個函數，會出現錯誤。我們需要使用 `py_function` 包裝器來封裝這個 Pythonic 調用：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def title_batch_fn(x):\n",
|
||||
" x = x['title']\n",
|
||||
" a,b = tf.py_function(title_batch,inp=[x],Tout=(tf.float32,tf.float32))\n",
|
||||
" return a,b"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"> **注意**：區分 Pythonic 和 Tensorflow 的轉換函數可能看起來有些複雜，您可能會疑惑為什麼我們不在將數據集傳遞給 `fit` 之前使用標準的 Python 函數進行轉換。雖然這確實是可行的，但使用 `Dataset.map` 有一個巨大的優勢，因為數據轉換管道是通過 Tensorflow 的計算圖執行的，這可以利用 GPU 的計算能力，並且減少了在 CPU 和 GPU 之間傳遞數據的需求。\n",
|
||||
"\n",
|
||||
"現在我們可以構建生成器網絡並開始訓練。它可以基於我們在上一單元中討論的任何循環單元（簡單、LSTM 或 GRU）。在我們的示例中，我們將使用 LSTM。\n",
|
||||
"\n",
|
||||
"由於網絡以字符作為輸入，且詞彙表的大小相對較小，我們不需要嵌入層，經過一次熱編碼的輸入可以直接進入 LSTM 單元。輸出層將是一個 `Dense` 分類器，它會將 LSTM 的輸出轉換為一次熱編碼的標記編號。\n",
|
||||
"\n",
|
||||
"此外，因為我們處理的是可變長度的序列，我們可以使用 `Masking` 層來創建一個掩碼，忽略字符串中填充的部分。這並不是絕對必要的，因為我們對超過 `<eos>` 標記的部分並不太感興趣，但我們會使用它來獲得一些使用這類型層的經驗。`input_shape` 將是 `(None, vocab_size)`，其中 `None` 表示可變長度的序列，而輸出形狀也是 `(None, vocab_size)`，正如您可以從 `summary` 中看到的那樣：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"sequential\"\n",
|
||||
"_________________________________________________________________\n",
|
||||
"Layer (type) Output Shape Param # \n",
|
||||
"=================================================================\n",
|
||||
"masking (Masking) (None, None, 84) 0 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"lstm (LSTM) (None, None, 128) 109056 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"dense (Dense) (None, None, 84) 10836 \n",
|
||||
"=================================================================\n",
|
||||
"Total params: 119,892\n",
|
||||
"Trainable params: 119,892\n",
|
||||
"Non-trainable params: 0\n",
|
||||
"_________________________________________________________________\n",
|
||||
"15000/15000 [==============================] - 229s 15ms/step - loss: 1.5385\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7fa40c1245e0>"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = keras.models.Sequential([\n",
|
||||
" keras.layers.Masking(input_shape=(None,vocab_size)),\n",
|
||||
" keras.layers.LSTM(128,return_sequences=True),\n",
|
||||
" keras.layers.Dense(vocab_size,activation='softmax')\n",
|
||||
"])\n",
|
||||
"\n",
|
||||
"model.summary()\n",
|
||||
"model.compile(loss='categorical_crossentropy')\n",
|
||||
"\n",
|
||||
"model.fit(ds_train.batch(8).map(title_batch_fn))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 生成輸出\n",
|
||||
"\n",
|
||||
"現在我們已經訓練了模型，接下來我們希望使用它來生成一些輸出。首先，我們需要一種方法來解碼由一系列標記數字表示的文本。為此，我們可以使用 `tokenizer.sequences_to_texts` 函數；然而，該函數在字元級標記化時效果不佳。因此，我們將從標記器中提取標記字典（稱為 `word_index`），建立一個反向映射，並撰寫自己的解碼函數：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"reverse_map = {val:key for key, val in tokenizer.word_index.items()}\n",
|
||||
"\n",
|
||||
"def decode(x):\n",
|
||||
" return ''.join([reverse_map[t] for t in x])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在，我們開始進行生成。我們將以某個字串 `start` 作為起點，將其編碼為序列 `inp`，接著在每一步中呼叫我們的網路來推斷下一個字元。\n",
|
||||
"\n",
|
||||
"網路的輸出 `out` 是一個包含 `vocab_size` 元素的向量，代表每個標記的概率。我們可以使用 `argmax` 找出最可能的標記編號。然後，我們將這個字元附加到已生成的標記列表中，並繼續進行生成。這個生成一個字元的過程會重複執行 `size` 次，以生成所需的字元數量。如果在過程中遇到 `eos_token`，我們會提前終止生成。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'Today #39;s lead to strike for the strike for the strike for the strike (AFP)'"
|
||||
]
|
||||
},
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def generate(model,size=100,start='Today '):\n",
|
||||
" inp = tokenizer.texts_to_sequences([start])[0]\n",
|
||||
" chars = inp\n",
|
||||
" for i in range(size):\n",
|
||||
" out = model(tf.expand_dims(tf.one_hot(inp,vocab_size),0))[0][-1]\n",
|
||||
" nc = tf.argmax(out)\n",
|
||||
" if nc==eos_token:\n",
|
||||
" break\n",
|
||||
" chars.append(nc.numpy())\n",
|
||||
" inp = inp+[nc]\n",
|
||||
" return decode(chars)\n",
|
||||
" \n",
|
||||
"generate(model)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 在訓練期間抽樣輸出\n",
|
||||
"\n",
|
||||
"由於我們沒有任何像 *準確率* 這樣的有用指標，我們唯一能夠判斷模型是否有所改善的方法就是在訓練期間通過**抽樣**生成的字串來觀察。為了實現這一點，我們將使用**回調函數**，即可以傳遞給 `fit` 函數的函數，並在訓練過程中定期被調用。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Epoch 1/3\n",
|
||||
"15000/15000 [==============================] - 226s 15ms/step - loss: 1.2703\n",
|
||||
"Today #39;s a lead in the company for the strike\n",
|
||||
"Epoch 2/3\n",
|
||||
"15000/15000 [==============================] - 227s 15ms/step - loss: 1.2057\n",
|
||||
"Today #39;s the Market Service on Security Start (AP)\n",
|
||||
"Epoch 3/3\n",
|
||||
"15000/15000 [==============================] - 226s 15ms/step - loss: 1.1752\n",
|
||||
"Today #39;s a line on the strike to start for the start\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7fa40c74e3d0>"
|
||||
]
|
||||
},
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"sampling_callback = keras.callbacks.LambdaCallback(\n",
|
||||
" on_epoch_end = lambda batch, logs: print(generate(model))\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"model.fit(ds_train.batch(8).map(title_batch_fn),callbacks=[sampling_callback],epochs=3)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"這個範例已經生成了一些相當不錯的文本，但仍有多種方式可以進一步改進：\n",
|
||||
"\n",
|
||||
"* **更多文本**。我們僅使用了標題作為任務內容，但您可能希望嘗試使用完整文本。請記住，RNN在處理長序列方面表現不佳，因此可以將文本拆分成較短的句子，或者始終在固定的序列長度（例如，`num_chars`，假設為256）上進行訓練。您可以嘗試將上述範例改為這種架構，並參考[官方 Keras 教學](https://keras.io/examples/generative/lstm_character_level_text_generation/)作為靈感。\n",
|
||||
"\n",
|
||||
"* **多層 LSTM**。嘗試使用2或3層的LSTM單元是有意義的。如我們在前一單元提到的，每層LSTM會從文本中提取特定的模式，而在字元級生成器的情況下，我們可以預期較低層的LSTM負責提取音節，而較高層則負責提取單詞及單詞組合。這可以通過向LSTM構造函數傳遞層數參數來簡單實現。\n",
|
||||
"\n",
|
||||
"* 您可能還希望嘗試使用**GRU單元**，看看哪種表現更好，以及嘗試**不同的隱藏層大小**。隱藏層過大可能導致過擬合（例如，網絡會學習精確的文本），而過小的隱藏層可能無法生成良好的結果。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 軟性文本生成與溫度\n",
|
||||
"\n",
|
||||
"在之前 `generate` 的定義中，我們總是選擇機率最高的字元作為生成文本的下一個字元。這導致文本經常在相同的字元序列之間不斷「循環」，如下例所示：\n",
|
||||
"```\n",
|
||||
"today of the second the company and a second the company ...\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"然而，如果我們觀察下一個字元的機率分佈，可能會發現幾個最高機率之間的差距並不大，例如一個字元的機率是 0.2，另一個是 0.19，等等。例如，在尋找序列 '*play*' 的下一個字元時，下一個字元可能同樣有可能是空格，或者是 **e**（如單詞 *player* 中的情況）。\n",
|
||||
"\n",
|
||||
"這讓我們得出一個結論：選擇機率最高的字元並不總是「公平」的，因為選擇第二高的字元仍然可能生成有意義的文本。更明智的做法是從網路輸出的機率分佈中**抽樣**字元。\n",
|
||||
"\n",
|
||||
"這種抽樣可以使用 `np.multinomial` 函數來完成，該函數實現了所謂的**多項分佈**。下面定義了一個實現這種**軟性**文本生成的函數：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 33,
|
||||
"metadata": {
|
||||
"scrolled": true
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"\n",
|
||||
"--- Temperature = 0.3\n",
|
||||
"Today #39;s strike #39; to start at the store return\n",
|
||||
"On Sunday PO to Be Data Profit Up (Reuters)\n",
|
||||
"Moscow, SP wins straight to the Microsoft #39;s control of the space start\n",
|
||||
"President olding of the blast start for the strike to pay <b>...</b>\n",
|
||||
"Little red riding hood ficed to the spam countered in European <b>...</b>\n",
|
||||
"\n",
|
||||
"--- Temperature = 0.8\n",
|
||||
"Today countie strikes ryder missile faces food market blut\n",
|
||||
"On Sunday collores lose-toppy of sale of Bullment in <b>...</b>\n",
|
||||
"Moscow, IBM Diffeiting in Afghan Software Hotels (Reuters)\n",
|
||||
"President Ol Luster for Profit Peaced Raised (AP)\n",
|
||||
"Little red riding hood dace on depart talks #39; bank up\n",
|
||||
"\n",
|
||||
"--- Temperature = 1.0\n",
|
||||
"Today wits House buiting debate fixes #39; supervice stake again\n",
|
||||
"On Sunday arling digital poaching In for level\n",
|
||||
"Moscow, DS Up 7, Top Proble Protest Caprey Mamarian Strike\n",
|
||||
"President teps help of roubler stepted lessabul-Dhalitics (AFP)\n",
|
||||
"Little red riding hood signs on cash in Carter-youb\n",
|
||||
"\n",
|
||||
"--- Temperature = 1.3\n",
|
||||
"Today wits flawer ro, pSIA figat's co DroftwavesIs Talo up\n",
|
||||
"On Sunday hround elitwing wint EU Powerburlinetien\n",
|
||||
"Moscow, Bazz #39;s sentries olymen winnelds' next for Olympite Huc?\n",
|
||||
"President lost securitys from power Elections in Smiltrials\n",
|
||||
"Little red riding hood vides profit, exponituity, profitmainalist-at said listers\n",
|
||||
"\n",
|
||||
"--- Temperature = 1.8\n",
|
||||
"Today #39;It: He deat: N.KA Asside\n",
|
||||
"On Sunday i arry Par aldeup patient Wo stele1\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"ename": "KeyError",
|
||||
"evalue": "0",
|
||||
"output_type": "error",
|
||||
"traceback": [
|
||||
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
||||
"\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
|
||||
"\u001b[0;32m<ipython-input-33-db32367a0feb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"\\n--- Temperature = {i}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgenerate_soft\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m300\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mwords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
|
||||
"\u001b[0;32m<ipython-input-33-db32367a0feb>\u001b[0m in \u001b[0;36mgenerate_soft\u001b[0;34m(model, size, start, temperature)\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mchars\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0minp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minp\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnc\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchars\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mwords\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Today '\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'On Sunday '\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'Moscow, '\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'President '\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'Little red riding hood '\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
|
||||
"\u001b[0;32m<ipython-input-10-3f5fa6130b1d>\u001b[0m in \u001b[0;36mdecode\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mreverse_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
|
||||
"\u001b[0;32m<ipython-input-10-3f5fa6130b1d>\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mreverse_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
|
||||
"\u001b[0;31mKeyError\u001b[0m: 0"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def generate_soft(model,size=100,start='Today ',temperature=1.0):\n",
|
||||
" inp = tokenizer.texts_to_sequences([start])[0]\n",
|
||||
" chars = inp\n",
|
||||
" for i in range(size):\n",
|
||||
" out = model(tf.expand_dims(tf.one_hot(inp,vocab_size),0))[0][-1]\n",
|
||||
" probs = tf.exp(tf.math.log(out)/temperature).numpy().astype(np.float64)\n",
|
||||
" probs = probs/np.sum(probs)\n",
|
||||
" nc = np.argmax(np.random.multinomial(1,probs,1))\n",
|
||||
" if nc==eos_token:\n",
|
||||
" break\n",
|
||||
" chars.append(nc)\n",
|
||||
" inp = inp+[nc]\n",
|
||||
" return decode(chars)\n",
|
||||
"\n",
|
||||
"words = ['Today ','On Sunday ','Moscow, ','President ','Little red riding hood ']\n",
|
||||
" \n",
|
||||
"for i in [0.3,0.8,1.0,1.3,1.8]:\n",
|
||||
" print(f\"\\n--- Temperature = {i}\")\n",
|
||||
" for j in range(5):\n",
|
||||
" print(generate_soft(model,size=300,start=words[j],temperature=i))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們引入了一個名為 **溫度** 的參數，用於指示我們應該多大程度地堅持最高概率。如果溫度為 1.0，我們進行公平的多項式抽樣，而當溫度趨於無窮大時，所有概率變得相等，我們隨機選擇下一個字符。在下面的例子中，我們可以觀察到當溫度增加過多時，文本變得毫無意義，而當溫度接近 0 時，則類似於「循環」的硬生成文本。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.8.12 ('py38')",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "9fbb7d5fda708537649f71f5f646fcde",
|
||||
"translation_date": "2025-08-31T10:31:48+00:00",
|
||||
"source_file": "lessons/5-NLP/17-GenerativeNetworks/GenerativeTF.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
# 生成式網絡
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/33)
|
||||
|
||||
循環神經網絡（RNN）及其門控單元變體，例如長短期記憶單元（LSTM）和門控循環單元（GRU），提供了一種語言建模的機制，能夠學習詞語的排列順序並預測序列中的下一個詞語。這使得我們可以使用 RNN 進行**生成式任務**，例如普通文本生成、機器翻譯，甚至是圖像描述。
|
||||
|
||||
> ✅ 想想你在使用文本補全功能時受益的情景。研究一下你喜愛的應用程序，看看它們是否使用了 RNN。
|
||||
|
||||
在上一單元中討論的 RNN 架構中，每個 RNN 單元都會生成下一個隱藏狀態作為輸出。然而，我們也可以為每個循環單元添加另一個輸出，這樣就可以輸出一個**序列**（與原始序列的長度相等）。此外，我們可以使用不在每一步接受輸入的 RNN 單元，只需初始狀態向量，然後生成一系列輸出。
|
||||
|
||||
這使得不同的神經網絡架構成為可能，如下圖所示：
|
||||
|
||||
|
||||
|
||||
> 圖片來源：[Andrej Karpaty](http://karpathy.github.io/) 的博客文章 [Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)
|
||||
|
||||
* **一對一** 是傳統的神經網絡，具有一個輸入和一個輸出
|
||||
* **一對多** 是一種生成式架構，接受一個輸入值並生成一系列輸出值。例如，如果我們想訓練一個**圖像描述**網絡來生成圖片的文字描述，我們可以將圖片作為輸入，通過 CNN 獲得其隱藏狀態，然後使用循環鏈逐字生成描述
|
||||
* **多對一** 對應於我們在上一單元中描述的 RNN 架構，例如文本分類
|
||||
* **多對多** 或 **序列對序列** 對應於任務，例如**機器翻譯**，其中第一個 RNN 收集輸入序列中的所有信息到隱藏狀態，另一個 RNN 鏈將該狀態展開為輸出序列。
|
||||
|
||||
在本單元中，我們將重點放在幫助生成文本的簡單生成式模型上。為了簡化，我們將使用基於字符的標記化。
|
||||
|
||||
我們將訓練這個 RNN 逐步生成文本。在每一步中，我們將取一個長度為 `nchars` 的字符序列，並要求網絡為每個輸入字符生成下一個輸出字符：
|
||||
|
||||
|
||||
|
||||
在生成文本（推理過程中），我們從某個**提示**開始，將其通過 RNN 單元生成中間狀態，然後從該狀態開始生成。我們一次生成一個字符，並將狀態和生成的字符傳遞給另一個 RNN 單元以生成下一個字符，直到生成足夠的字符。
|
||||
|
||||
<img src="../../../../../translated_images/zh-TW/rnn-generate-inf.5168dc65e0370eea.webp" width="60%"/>
|
||||
|
||||
> 圖片由作者提供
|
||||
|
||||
## ✍️ 練習：生成式網絡
|
||||
|
||||
在以下筆記本中繼續學習：
|
||||
|
||||
* [使用 PyTorch 的生成式網絡](GenerativePyTorch.ipynb)
|
||||
* [使用 TensorFlow 的生成式網絡](GenerativeTF.ipynb)
|
||||
|
||||
## 軟文本生成與溫度
|
||||
|
||||
每個 RNN 單元的輸出是一個字符的概率分佈。如果我們總是選擇概率最高的字符作為生成文本的下一個字符，文本可能會出現重複的字符序列，如以下示例：
|
||||
|
||||
```
|
||||
today of the second the company and a second the company ...
|
||||
```
|
||||
|
||||
然而，如果我們查看下一個字符的概率分佈，可能幾個最高概率之間的差距並不大，例如一個字符的概率可能是 0.2，另一個是 0.19，等等。例如，在尋找序列 '*play*' 的下一個字符時，下一個字符可能是空格，也可能是 **e**（如單詞 *player*）。
|
||||
|
||||
這使我們得出結論，選擇概率最高的字符並不總是“公平”的，因為選擇第二高的字符仍然可能生成有意義的文本。更明智的做法是從網絡輸出的概率分佈中**抽樣**字符。我們還可以使用一個參數 **溫度**，來平滑概率分佈，以增加隨機性，或者使分佈更陡峭，以更傾向於選擇最高概率的字符。
|
||||
|
||||
在上述筆記本中探索這種軟文本生成的實現方式。
|
||||
|
||||
## 結論
|
||||
|
||||
雖然文本生成本身可能很有用，但主要的好處來自於能夠使用 RNN 從某個初始特徵向量生成文本。例如，文本生成可用於機器翻譯（序列對序列，在此情況下，*編碼器*的狀態向量用於生成或*解碼*翻譯的消息），或者生成圖像的文字描述（在此情況下，特徵向量來自 CNN 提取器）。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
在 Microsoft Learn 上學習相關課程
|
||||
|
||||
* 使用 [PyTorch](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-pytorch/6-generative-networks/?WT.mc_id=academic-77998-cacaste)/[TensorFlow](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/5-generative-networks/?WT.mc_id=academic-77998-cacaste) 進行文本生成
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/34)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
以下文章可擴展您的知識：
|
||||
|
||||
* 使用馬爾可夫鏈、LSTM 和 GPT-2 進行文本生成的不同方法：[博客文章](https://towardsdatascience.com/text-generation-gpt-2-lstm-markov-chain-9ea371820e1e)
|
||||
* Keras 文檔中的文本生成示例：[Keras 文檔](https://keras.io/examples/generative/lstm_character_level_text_generation/)
|
||||
|
||||
## [作業](lab/README.md)
|
||||
|
||||
我們已經了解了如何逐字符生成文本。在實驗中，您將探索基於單詞的文本生成。
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
# 使用 RNN 進行詞級文本生成
|
||||
|
||||
來自 [AI 初學者課程](https://github.com/microsoft/ai-for-beginners) 的實驗作業。
|
||||
|
||||
## 任務
|
||||
|
||||
在這次實驗中，你需要選擇任意一本書，並將其作為數據集來訓練詞級文本生成器。
|
||||
|
||||
## 數據集
|
||||
|
||||
你可以使用任何一本書作為數據集。你可以在 [Project Gutenberg](https://www.gutenberg.org/) 找到許多免費文本，例如，這裡是 Lewis Carroll 的《愛麗絲夢遊仙境》的直接連結：[Alice's Adventures in Wonderland](https://www.gutenberg.org/files/11/11-0.txt)。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
# 注意機制與Transformer
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/35)
|
||||
|
||||
在自然語言處理（NLP）領域中，**機器翻譯**是最重要的問題之一，這是一項支撐像 Google 翻譯等工具的基本任務。在本節中，我們將重點討論機器翻譯，或者更廣泛地說，任何*序列到序列*的任務（也稱為**句子轉換**）。
|
||||
|
||||
使用RNN時，序列到序列的實現是通過兩個循環神經網絡完成的，其中一個網絡，即**編碼器**，將輸入序列壓縮成隱藏狀態，而另一個網絡，即**解碼器**，將隱藏狀態展開成翻譯結果。然而，這種方法存在一些問題：
|
||||
|
||||
* 編碼器網絡的最終狀態難以記住句子的開頭，導致模型在處理長句子時質量下降。
|
||||
* 序列中的所有詞對結果的影響相同。然而，實際情況中，輸入序列中的某些詞對輸出序列的影響往往更大。
|
||||
|
||||
**注意機制**提供了一種方法，能夠對每個輸入向量對RNN輸出預測的上下文影響進行加權。其實現方式是通過在輸入RNN的中間狀態和輸出RNN之間建立捷徑。在生成輸出符號y<sub>t</sub>時，我們會考慮所有輸入隱藏狀態h<sub>i</sub>，並賦予不同的權重係數α<sub>t,i</sub>。
|
||||
|
||||
|
||||
|
||||
> [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf)中的加性注意機制編碼器-解碼器模型，引用自[這篇博客文章](https://lilianweng.github.io/lil-log/2018/06/24/attention-attention.html)
|
||||
|
||||
注意矩陣{α<sub>i,j</sub>}表示某些輸入詞在生成輸出序列中的某個詞時所起的作用程度。以下是一個這樣的矩陣示例：
|
||||
|
||||
|
||||
|
||||
> 圖片來自[Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf)（圖3）
|
||||
|
||||
注意機制是目前或接近目前NLP領域的最先進技術的核心。然而，添加注意機制會大幅增加模型參數的數量，這導致了RNN的擴展問題。RNN擴展的一個關鍵限制是模型的循環特性使得訓練難以批量化和並行化。在RNN中，序列的每個元素都需要按順序處理，這意味著它不能輕易並行化。
|
||||
|
||||
|
||||
|
||||
> 圖片來自[Google的博客](https://research.googleblog.com/2016/09/a-neural-network-for-machine.html)
|
||||
|
||||
注意機制的採用結合了這一限制，促成了如今我們所知的最先進Transformer模型的誕生，例如BERT和Open-GPT3。
|
||||
|
||||
## Transformer模型
|
||||
|
||||
Transformer的主要理念之一是避免RNN的序列特性，並創建一個在訓練過程中可並行化的模型。這是通過實現以下兩個想法來完成的：
|
||||
|
||||
* 位置編碼
|
||||
* 使用自注意機制來捕捉模式，而不是使用RNN（或CNN）（這也是為什麼介紹Transformer的論文名為*[Attention is all you need](https://arxiv.org/abs/1706.03762)*）
|
||||
|
||||
### 位置編碼/嵌入
|
||||
|
||||
位置編碼的理念如下：
|
||||
1. 使用RNN時，標記的相對位置由步數表示，因此不需要顯式表示。
|
||||
2. 然而，一旦我們切換到注意機制，我們需要知道序列中標記的相對位置。
|
||||
3. 為了獲得位置編碼，我們將標記序列與序列中的標記位置序列（即數字序列0,1, ...）進行擴充。
|
||||
4. 然後我們將標記位置與標記嵌入向量混合。為了將位置（整數）轉換為向量，我們可以使用不同的方法：
|
||||
|
||||
* 可訓練嵌入，類似於標記嵌入。這是我們在此考慮的方法。我們在標記和它們的位置上應用嵌入層，生成具有相同維度的嵌入向量，然後將它們相加。
|
||||
* 固定位置編碼函數，如原始論文中所提出。
|
||||
|
||||
<img src="../../../../../translated_images/zh-TW/pos-embedding.e41ce9b6cf6078af.webp" width="50%"/>
|
||||
|
||||
> 圖片由作者提供
|
||||
|
||||
通過位置嵌入，我們得到的結果既嵌入了原始標記，也嵌入了其在序列中的位置。
|
||||
|
||||
### 多頭自注意機制
|
||||
|
||||
接下來，我們需要捕捉序列中的一些模式。為此，Transformer使用了**自注意機制**，這本質上是將注意機制應用於相同的輸入和輸出序列。應用自注意機制使我們能夠考慮句子中的**上下文**，並查看哪些詞是相互關聯的。例如，它使我們能夠看到哪些詞是由指代詞（如*它*）指代的，並且能夠考慮上下文：
|
||||
|
||||
|
||||
|
||||
> 圖片來自[Google的博客](https://research.googleblog.com/2017/08/transformer-novel-neural-network.html)
|
||||
|
||||
在Transformer中，我們使用**多頭注意機制**，以賦予網絡捕捉多種依賴關係的能力，例如長期與短期詞語關係、指代與其他關係等。
|
||||
|
||||
[TensorFlow Notebook](TransformersTF.ipynb)包含有關Transformer層實現的更多細節。
|
||||
|
||||
### 編碼器-解碼器注意機制
|
||||
|
||||
在Transformer中，注意機制用於兩個地方：
|
||||
|
||||
* 捕捉輸入文本中的模式，使用自注意機制。
|
||||
* 執行序列翻譯——這是編碼器和解碼器之間的注意層。
|
||||
|
||||
編碼器-解碼器注意機制與RNN中使用的注意機制非常相似，如本節開頭所述。以下動畫圖解釋了編碼器-解碼器注意機制的作用。
|
||||
|
||||
|
||||
|
||||
由於每個輸入位置獨立映射到每個輸出位置，Transformer比RNN更能進行並行化，這使得能夠構建更大、更具表達力的語言模型。每個注意頭可以用於學習詞語之間的不同關係，從而改善下游自然語言處理任務。
|
||||
|
||||
## BERT
|
||||
|
||||
**BERT**（Bidirectional Encoder Representations from Transformers）是一個非常大的多層Transformer網絡，*BERT-base*有12層，*BERT-large*有24層。該模型首先在大規模文本數據（維基百科+書籍）上進行無監督訓練（預測句子中的被遮蔽詞）。在預訓練過程中，模型吸收了大量的語言理解能力，這些能力可以通過微調其他數據集來利用。這個過程稱為**遷移學習**。
|
||||
|
||||
|
||||
|
||||
> 圖片[來源](http://jalammar.github.io/illustrated-bert/)
|
||||
|
||||
## ✍️ 練習：Transformer
|
||||
|
||||
在以下筆記本中繼續學習：
|
||||
|
||||
* [PyTorch中的Transformer](TransformersPyTorch.ipynb)
|
||||
* [TensorFlow中的Transformer](TransformersTF.ipynb)
|
||||
|
||||
## 結論
|
||||
|
||||
在本課中，你學習了Transformer和注意機制，這些都是NLP工具箱中的重要工具。Transformer架構有許多變體，包括BERT、DistilBERT、BigBird、OpenGPT3等，可以進行微調。[HuggingFace套件](https://github.com/huggingface/)提供了使用PyTorch和TensorFlow訓練這些架構的資源庫。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/36)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
* [博客文章](https://mchromiak.github.io/articles/2017/Sep/12/Transformer-Attention-is-all-you-need/)，解釋了Transformer的經典論文[Attention is all you need](https://arxiv.org/abs/1706.03762)。
|
||||
* [一系列博客文章](https://towardsdatascience.com/transformers-explained-visually-part-1-overview-of-functionality-95a6dd460452)，詳細解釋了Transformer的架構。
|
||||
|
||||
## [作業](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,353 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 注意力機制與Transformer\n",
|
||||
"\n",
|
||||
"循環神經網路（RNN）的一個主要缺點是序列中的所有詞對結果的影響相同。這導致標準的LSTM編碼器-解碼器模型在處理序列到序列任務（如命名實體識別和機器翻譯）時表現不佳。實際上，輸入序列中的某些特定詞往往對輸出序列的影響更大。\n",
|
||||
"\n",
|
||||
"考慮一個序列到序列的模型，例如機器翻譯。這種模型由兩個循環神經網路實現，其中一個網路（**編碼器**）將輸入序列壓縮成隱藏狀態，另一個網路（**解碼器**）將該隱藏狀態展開為翻譯結果。這種方法的問題在於，網路的最終狀態很難記住句子的開頭部分，從而導致模型在處理長句子時質量較差。\n",
|
||||
"\n",
|
||||
"**注意力機制**提供了一種方法，能夠對每個輸入向量對RNN每個輸出預測的上下文影響進行加權。其實現方式是通過在輸入RNN的中間狀態和輸出RNN之間創建捷徑。這樣，在生成輸出符號$y_t$時，我們會考慮所有輸入的隱藏狀態$h_i$，並賦予不同的權重係數$\\alpha_{t,i}$。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"*帶有加性注意力機制的編碼器-解碼器模型，來自 [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf)，引用自[這篇博客文章](https://lilianweng.github.io/lil-log/2018/06/24/attention-attention.html)*\n",
|
||||
"\n",
|
||||
"注意力矩陣$\\{\\alpha_{i,j}\\}$表示某些輸入詞在生成輸出序列中特定詞時的影響程度。以下是這樣一個矩陣的示例：\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"*圖片來自 [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf)（圖3）*\n",
|
||||
"\n",
|
||||
"注意力機制是當前或接近當前自然語言處理技術水平的關鍵。儘管如此，添加注意力機制會大幅增加模型參數的數量，這導致了RNN的擴展問題。RNN的一個關鍵限制是其循環特性使得訓練過程難以批量化和並行化。在RNN中，序列的每個元素都需要按順序處理，這意味著它無法輕易並行化。\n",
|
||||
"\n",
|
||||
"注意力機制的採用結合這一限制，促使了如今的Transformer模型的誕生，這些模型（如BERT和OpenGPT3）已成為當前的技術標杆。\n",
|
||||
"\n",
|
||||
"## Transformer模型\n",
|
||||
"\n",
|
||||
"與將每個先前預測的上下文傳遞到下一個評估步驟不同，**Transformer模型**使用**位置編碼**和注意力機制來捕捉給定輸入在提供的文本窗口內的上下文。下圖展示了如何通過位置編碼和注意力機制在給定窗口內捕捉上下文。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"由於每個輸入位置可以獨立映射到每個輸出位置，Transformer比RNN更容易並行化，這使得構建更大、更具表達力的語言模型成為可能。每個注意力頭可以用來學習詞與詞之間的不同關係，從而改進下游的自然語言處理任務。\n",
|
||||
"\n",
|
||||
"**BERT**（Bidirectional Encoder Representations from Transformers）是一個非常大的多層Transformer網路，*BERT-base*有12層，*BERT-large*有24層。該模型首先在大規模文本數據（維基百科+書籍）上進行無監督預訓練（預測句子中的被遮蔽詞）。在預訓練過程中，模型吸收了大量的語言理解能力，這些能力可以通過微調其他數據集來利用。這個過程稱為**遷移學習**。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"Transformer架構有許多變體，包括BERT、DistilBERT、BigBird、OpenGPT3等，這些模型都可以進行微調。[HuggingFace套件](https://github.com/huggingface/)提供了使用PyTorch訓練這些架構的資源庫。\n",
|
||||
"\n",
|
||||
"## 使用BERT進行文本分類\n",
|
||||
"\n",
|
||||
"讓我們看看如何使用預訓練的BERT模型來解決我們的傳統任務：序列分類。我們將對原始的AG News數據集進行分類。\n",
|
||||
"\n",
|
||||
"首先，讓我們加載HuggingFace庫和數據集：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Loading dataset...\n",
|
||||
"Building vocab...\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import torch\n",
|
||||
"import torchtext\n",
|
||||
"from torchnlp import *\n",
|
||||
"import transformers\n",
|
||||
"train_dataset, test_dataset, classes, vocab = load_dataset()\n",
|
||||
"vocab_len = len(vocab)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"由於我們將使用預訓練的 BERT 模型，因此需要使用特定的分詞器。首先，我們將載入與預訓練 BERT 模型相關聯的分詞器。\n",
|
||||
"\n",
|
||||
"HuggingFace 庫包含一個預訓練模型的存儲庫，您只需在 `from_pretrained` 函數中指定模型名稱作為參數即可使用。所有模型所需的二進制文件將自動下載。\n",
|
||||
"\n",
|
||||
"然而，有時您可能需要載入自己的模型，在這種情況下，您可以指定包含所有相關文件的目錄，包括分詞器的參數、模型參數的 `config.json` 文件、二進制權重等。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# To load the model from Internet repository using model name. \n",
|
||||
"# Use this if you are running from your own copy of the notebooks\n",
|
||||
"bert_model = 'bert-base-uncased' \n",
|
||||
"\n",
|
||||
"# To load the model from the directory on disk. Use this for Microsoft Learn module, because we have\n",
|
||||
"# prepared all required files for you.\n",
|
||||
"bert_model = './bert'\n",
|
||||
"\n",
|
||||
"tokenizer = transformers.BertTokenizer.from_pretrained(bert_model)\n",
|
||||
"\n",
|
||||
"MAX_SEQ_LEN = 128\n",
|
||||
"PAD_INDEX = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)\n",
|
||||
"UNK_INDEX = tokenizer.convert_tokens_to_ids(tokenizer.unk_token)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"`tokenizer` 物件包含可直接用於編碼文本的 `encode` 函數：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[101, 1052, 22123, 2953, 2818, 2003, 1037, 2307, 7705, 2005, 17953, 2361, 102]"
|
||||
]
|
||||
},
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tokenizer.encode('PyTorch is a great framework for NLP')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"然後，讓我們建立在訓練期間用於訪問數據的迭代器。由於 BERT 使用其自己的編碼函數，我們需要定義一個類似於之前定義的 `padify` 的填充函數：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def pad_bert(b):\n",
|
||||
" # b is the list of tuples of length batch_size\n",
|
||||
" # - first element of a tuple = label, \n",
|
||||
" # - second = feature (text sequence)\n",
|
||||
" # build vectorized sequence\n",
|
||||
" v = [tokenizer.encode(x[1]) for x in b]\n",
|
||||
" # compute max length of a sequence in this minibatch\n",
|
||||
" l = max(map(len,v))\n",
|
||||
" return ( # tuple of two tensors - labels and features\n",
|
||||
" torch.LongTensor([t[0] for t in b]),\n",
|
||||
" torch.stack([torch.nn.functional.pad(torch.tensor(t),(0,l-len(t)),mode='constant',value=0) for t in v])\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=8, collate_fn=pad_bert, shuffle=True)\n",
|
||||
"test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=8, collate_fn=pad_bert)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"在我們的案例中，我們將使用名為 `bert-base-uncased` 的預訓練 BERT 模型。讓我們使用 `BertForSequenceClassfication` 套件來加載模型。這確保了我們的模型已經具備分類所需的架構，包括最終的分類器。您會看到一條警告訊息，指出最終分類器的權重尚未初始化，並且模型需要進行預訓練——這完全沒問題，因為這正是我們即將進行的操作！\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stderr",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Some weights of the model checkpoint at ./bert were not used when initializing BertForSequenceClassification: ['cls.predictions.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias']\n",
|
||||
"- This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
|
||||
"- This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
|
||||
"Some weights of BertForSequenceClassification were not initialized from the model checkpoint at ./bert and are newly initialized: ['classifier.weight', 'classifier.bias']\n",
|
||||
"You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model = transformers.BertForSequenceClassification.from_pretrained(bert_model,num_labels=4).to(device)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在我們準備開始訓練了！由於 BERT 已經是預訓練模型，我們希望從較小的學習率開始，以免破壞初始權重。\n",
|
||||
"\n",
|
||||
"所有的繁重工作都由 `BertForSequenceClassification` 模型完成。當我們將訓練數據傳入模型時，它會返回損失值和輸入小批量的網絡輸出。我們使用損失值進行參數優化（`loss.backward()` 執行反向傳播），並使用 `out` 計算訓練準確率，方法是將獲得的標籤 `labs`（使用 `argmax` 計算）與預期的 `labels` 進行比較。\n",
|
||||
"\n",
|
||||
"為了控制訓練過程，我們會在多次迭代中累積損失值和準確率，並在每 `report_freq` 個訓練週期後打印它們。\n",
|
||||
"\n",
|
||||
"這次訓練可能會花費相當長的時間，因此我們限制了迭代次數。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Loss = 1.1254194641113282, Accuracy = 0.585\n",
|
||||
"Loss = 0.6194715118408203, Accuracy = 0.83\n",
|
||||
"Loss = 0.46665248870849607, Accuracy = 0.8475\n",
|
||||
"Loss = 0.4309701919555664, Accuracy = 0.8575\n",
|
||||
"Loss = 0.35427074432373046, Accuracy = 0.8825\n",
|
||||
"Loss = 0.3306886291503906, Accuracy = 0.8975\n",
|
||||
"Loss = 0.30340143203735354, Accuracy = 0.8975\n",
|
||||
"Loss = 0.26139299392700194, Accuracy = 0.915\n",
|
||||
"Loss = 0.26708646774291994, Accuracy = 0.9225\n",
|
||||
"Loss = 0.3667240524291992, Accuracy = 0.8675\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"optimizer = torch.optim.Adam(model.parameters(), lr=2e-5)\n",
|
||||
"\n",
|
||||
"report_freq = 50\n",
|
||||
"iterations = 500 # make this larger to train for longer time!\n",
|
||||
"\n",
|
||||
"model.train()\n",
|
||||
"\n",
|
||||
"i,c = 0,0\n",
|
||||
"acc_loss = 0\n",
|
||||
"acc_acc = 0\n",
|
||||
"\n",
|
||||
"for labels,texts in train_loader:\n",
|
||||
" labels = labels.to(device)-1 # get labels in the range 0-3 \n",
|
||||
" texts = texts.to(device)\n",
|
||||
" loss, out = model(texts, labels=labels)[:2]\n",
|
||||
" labs = out.argmax(dim=1)\n",
|
||||
" acc = torch.mean((labs==labels).type(torch.float32))\n",
|
||||
" optimizer.zero_grad()\n",
|
||||
" loss.backward()\n",
|
||||
" optimizer.step()\n",
|
||||
" acc_loss += loss\n",
|
||||
" acc_acc += acc\n",
|
||||
" i+=1\n",
|
||||
" c+=1\n",
|
||||
" if i%report_freq==0:\n",
|
||||
" print(f\"Loss = {acc_loss.item()/c}, Accuracy = {acc_acc.item()/c}\")\n",
|
||||
" c = 0\n",
|
||||
" acc_loss = 0\n",
|
||||
" acc_acc = 0\n",
|
||||
" iterations-=1\n",
|
||||
" if not iterations:\n",
|
||||
" break"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"你可以看到（尤其是當你增加迭代次數並等待足夠長的時間），BERT 的分類能夠提供相當不錯的準確率！這是因為 BERT 已經對語言的結構有相當好的理解，我們只需要微調最終的分類器即可。然而，由於 BERT 是一個大型模型，整個訓練過程需要很長的時間，並且需要強大的計算能力！（GPU，最好是多個 GPU）。\n",
|
||||
"\n",
|
||||
"> **Note:** 在我們的範例中，我們使用的是最小的預訓練 BERT 模型之一。還有更大的模型可能會產生更好的結果。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 評估模型表現\n",
|
||||
"\n",
|
||||
"現在我們可以在測試數據集上評估模型的表現。評估循環與訓練循環非常相似，但我們不能忘記通過調用 `model.eval()` 將模型切換到評估模式。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Final accuracy: 0.9047029702970297\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.eval()\n",
|
||||
"iterations = 100\n",
|
||||
"acc = 0\n",
|
||||
"i = 0\n",
|
||||
"for labels,texts in test_loader:\n",
|
||||
" labels = labels.to(device)-1 \n",
|
||||
" texts = texts.to(device)\n",
|
||||
" _, out = model(texts, labels=labels)[:2]\n",
|
||||
" labs = out.argmax(dim=1)\n",
|
||||
" acc += torch.mean((labs==labels).type(torch.float32))\n",
|
||||
" i+=1\n",
|
||||
" if i>iterations: break\n",
|
||||
" \n",
|
||||
"print(f\"Final accuracy: {acc.item()/i}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 重點\n",
|
||||
"\n",
|
||||
"在本單元中，我們已經看到從 **transformers** 庫中取用預訓練語言模型並將其適配於我們的文本分類任務是多麼簡單。同樣地，BERT 模型也可以用於實體抽取、問答系統以及其他 NLP 任務。\n",
|
||||
"\n",
|
||||
"Transformer 模型代表了 NLP 領域的最新技術，在大多數情況下，當實現自定義 NLP 解決方案時，它應該是您開始實驗的首選解決方案。然而，如果您希望構建更高級的神經網絡模型，理解本模組中討論的循環神經網絡的基本原理是非常重要的。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件已使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。儘管我們致力於提供準確的翻譯，請注意自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵資訊，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋不承擔責任。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "py37_pytorch",
|
||||
"language": "python",
|
||||
"name": "conda-env-py37_pytorch-py"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.7.7"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "753865967678a92dbce7d7efbd36d980",
|
||||
"translation_date": "2025-08-31T10:39:09+00:00",
|
||||
"source_file": "lessons/5-NLP/18-Transformers/TransformersPyTorch.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
@ -0,0 +1,825 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 注意力機制與Transformer模型\n",
|
||||
"\n",
|
||||
"循環神經網路（RNN）的一個主要缺點是序列中的所有詞對結果的影響相同。這導致標準的LSTM編碼器-解碼器模型在處理序列到序列任務（如命名實體識別和機器翻譯）時表現不佳。實際上，輸入序列中的某些特定詞往往對輸出序列的影響更大。\n",
|
||||
"\n",
|
||||
"考慮一個序列到序列的模型，例如機器翻譯。這種模型由兩個循環神經網路實現，其中一個網路（**編碼器**）將輸入序列壓縮成隱藏狀態，另一個網路（**解碼器**）將該隱藏狀態展開為翻譯結果。這種方法的問題在於，網路的最終狀態很難記住句子的開頭部分，從而導致模型在處理長句子時質量較差。\n",
|
||||
"\n",
|
||||
"**注意力機制**提供了一種方法，能夠對每個輸入向量對RNN每個輸出預測的上下文影響進行加權。其實現方式是通過在輸入RNN的中間狀態和輸出RNN之間創建捷徑。這樣，在生成輸出符號$y_t$時，我們會考慮所有輸入的隱藏狀態$h_i$，並賦予不同的權重係數$\\alpha_{t,i}$。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"*來自 [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf) 的加性注意力機制編碼器-解碼器模型，圖片引用自[這篇博客文章](https://lilianweng.github.io/lil-log/2018/06/24/attention-attention.html)*\n",
|
||||
"\n",
|
||||
"注意力矩陣$\\{\\alpha_{i,j}\\}$表示某些輸入詞在生成輸出序列中特定詞時所起的作用程度。以下是這樣一個矩陣的示例：\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"*圖片取自 [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf)（圖3）*\n",
|
||||
"\n",
|
||||
"注意力機制是當前或接近當前自然語言處理（NLP）技術水平的核心。儘管如此，添加注意力機制會大幅增加模型參數的數量，這導致了RNN的擴展問題。RNN的一個關鍵限制是其循環特性使得訓練過程難以批量化和並行化。在RNN中，序列的每個元素都需要按順序處理，這意味著它無法輕易並行化。\n",
|
||||
"\n",
|
||||
"注意力機制的採用結合了這一限制，促使了如今我們熟知並使用的Transformer模型的誕生，從BERT到OpenGPT3，這些模型代表了當前的技術水平。\n",
|
||||
"\n",
|
||||
"## Transformer模型\n",
|
||||
"\n",
|
||||
"與將每次預測的上下文傳遞到下一個評估步驟不同，**Transformer模型**使用**位置編碼**和**注意力機制**來捕捉給定輸入在提供的文本窗口內的上下文。下圖展示了如何通過位置編碼和注意力機制在給定窗口內捕捉上下文。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"由於每個輸入位置可以獨立映射到每個輸出位置，Transformer模型比RNN更容易並行化，這使得構建更大、更具表達力的語言模型成為可能。每個注意力頭可以用來學習詞與詞之間的不同關係，從而改進下游的自然語言處理任務。\n",
|
||||
"\n",
|
||||
"## 構建簡單的Transformer模型\n",
|
||||
"\n",
|
||||
"Keras中並未內建Transformer層，但我們可以自行構建。與之前一樣，我們將專注於AG News數據集的文本分類，但值得一提的是，Transformer模型在更困難的NLP任務中表現最佳。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import tensorflow as tf\n",
|
||||
"from tensorflow import keras\n",
|
||||
"import tensorflow_datasets as tfds\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"ds_train, ds_test = tfds.load('ag_news_subset').values()\n",
|
||||
"\n",
|
||||
"def extract_text(x):\n",
|
||||
" return x['title']+' '+x['description']\n",
|
||||
"\n",
|
||||
"def tupelize(x):\n",
|
||||
" return (extract_text(x),x['label'])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"新的 Keras 層應該繼承 `Layer` 類別，並實現 `call` 方法。我們先從 **位置嵌入** 層開始。我們將使用[官方 Keras 文件中的一些代碼](https://keras.io/examples/nlp/text_classification_with_transformer/)。我們假設我們將所有輸入序列填充到長度 `maxlen`。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"class TokenAndPositionEmbedding(keras.layers.Layer):\n",
|
||||
" def __init__(self, maxlen, vocab_size, embed_dim):\n",
|
||||
" super(TokenAndPositionEmbedding, self).__init__()\n",
|
||||
" self.token_emb = keras.layers.Embedding(input_dim=vocab_size, output_dim=embed_dim)\n",
|
||||
" self.pos_emb = keras.layers.Embedding(input_dim=maxlen, output_dim=embed_dim)\n",
|
||||
" self.maxlen = maxlen\n",
|
||||
"\n",
|
||||
" def call(self, x):\n",
|
||||
" maxlen = self.maxlen\n",
|
||||
" positions = tf.range(start=0, limit=maxlen, delta=1)\n",
|
||||
" positions = self.pos_emb(positions)\n",
|
||||
" x = self.token_emb(x)\n",
|
||||
" return x+positions"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"這一層包含兩個 `Embedding` 層：一個用於嵌入標記（以我們之前討論過的方式），另一個用於嵌入標記位置。標記位置是通過使用 `tf.range` 從 0 到 `maxlen` 創建的一系列自然數，然後通過嵌入層處理。兩個生成的嵌入向量隨後相加，產生輸入的基於位置嵌入的表示，其形狀為 `maxlen`$\\times$`embed_dim`。\n",
|
||||
"\n",
|
||||
"現在，我們來實現 transformer block。它將接收之前定義的嵌入層的輸出：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"class TransformerBlock(keras.layers.Layer):\n",
|
||||
" def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1):\n",
|
||||
" super(TransformerBlock, self).__init__()\n",
|
||||
" self.att = keras.layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim, name='attn')\n",
|
||||
" self.ffn = keras.Sequential(\n",
|
||||
" [keras.layers.Dense(ff_dim, activation=\"relu\"), keras.layers.Dense(embed_dim),]\n",
|
||||
" )\n",
|
||||
" self.layernorm1 = keras.layers.LayerNormalization(epsilon=1e-6)\n",
|
||||
" self.layernorm2 = keras.layers.LayerNormalization(epsilon=1e-6)\n",
|
||||
" self.dropout1 = keras.layers.Dropout(rate)\n",
|
||||
" self.dropout2 = keras.layers.Dropout(rate)\n",
|
||||
"\n",
|
||||
" def call(self, inputs, training):\n",
|
||||
" attn_output = self.att(inputs, inputs)\n",
|
||||
" attn_output = self.dropout1(attn_output, training=training)\n",
|
||||
" out1 = self.layernorm1(inputs + attn_output)\n",
|
||||
" ffn_output = self.ffn(out1)\n",
|
||||
" ffn_output = self.dropout2(ffn_output, training=training)\n",
|
||||
" return self.layernorm2(out1 + ffn_output)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Transformer 將 `MultiHeadAttention` 應用於帶有位置編碼的輸入，生成維度為 `maxlen`$\\times$`embed_dim` 的注意力向量，然後與輸入混合，並使用 `LayerNormalization` 進行正規化。\n",
|
||||
"\n",
|
||||
"> **注意**: `LayerNormalization` 與在本學習路徑 *計算機視覺* 部分中討論的 `BatchNormalization` 類似，但它針對每個訓練樣本獨立地正規化前一層的輸出，將其範圍調整到 [-1..1]。\n",
|
||||
"\n",
|
||||
"該層的輸出隨後通過 `Dense` 網絡（在我們的例子中是兩層感知機），結果再加到最終輸出中（該輸出再次經過正規化處理）。 \n",
|
||||
"\n",
|
||||
"現在，我們準備定義完整的 Transformer 模型：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"sequential_1\"\n",
|
||||
"_________________________________________________________________\n",
|
||||
"Layer (type) Output Shape Param # \n",
|
||||
"=================================================================\n",
|
||||
"text_vectorization (TextVect (None, 256) 0 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"token_and_position_embedding (None, 256, 32) 648192 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"transformer_block (Transform (None, 256, 32) 10656 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"global_average_pooling1d (Gl (None, 32) 0 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"dropout_2 (Dropout) (None, 32) 0 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"dense_2 (Dense) (None, 20) 660 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"dropout_3 (Dropout) (None, 20) 0 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"dense_3 (Dense) (None, 4) 84 \n",
|
||||
"=================================================================\n",
|
||||
"Total params: 659,592\n",
|
||||
"Trainable params: 659,592\n",
|
||||
"Non-trainable params: 0\n",
|
||||
"_________________________________________________________________\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"embed_dim = 32 # Embedding size for each token\n",
|
||||
"num_heads = 2 # Number of attention heads\n",
|
||||
"ff_dim = 32 # Hidden layer size in feed forward network inside transformer\n",
|
||||
"maxlen = 256\n",
|
||||
"vocab_size = 20000\n",
|
||||
"\n",
|
||||
"model = keras.models.Sequential([\n",
|
||||
" keras.layers.experimental.preprocessing.TextVectorization(max_tokens=vocab_size,output_sequence_length=maxlen, input_shape=(1,)),\n",
|
||||
" TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim),\n",
|
||||
" TransformerBlock(embed_dim, num_heads, ff_dim),\n",
|
||||
" keras.layers.GlobalAveragePooling1D(),\n",
|
||||
" keras.layers.Dropout(0.1),\n",
|
||||
" keras.layers.Dense(20, activation=\"relu\"),\n",
|
||||
" keras.layers.Dropout(0.1),\n",
|
||||
" keras.layers.Dense(4, activation=\"softmax\")\n",
|
||||
"])\n",
|
||||
"\n",
|
||||
"model.summary()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Training tokenizer\n",
|
||||
"938/938 [==============================] - 45s 39ms/step - loss: 0.4978 - acc: 0.8068 - val_loss: 0.2808 - val_acc: 0.9124\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7f9c2427a0d0>"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"print('Training tokenizer')\n",
|
||||
"model.layers[0].adapt(ds_train.map(extract_text))\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'], optimizer='adam')\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(128),validation_data=ds_test.map(tupelize).batch(128))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## BERT Transformer 模型\n",
|
||||
"\n",
|
||||
"**BERT**（Bidirectional Encoder Representations from Transformers，雙向編碼器表示）是一個非常大型的多層 Transformer 網絡，*BERT-base* 有 12 層，*BERT-large* 則有 24 層。該模型首先在大規模文本數據（維基百科 + 書籍）上進行無監督訓練（預測句子中被遮蔽的詞語）。在預訓練過程中，模型吸收了大量的語言理解能力，隨後可以通過微調其他數據集來加以利用。這個過程被稱為 **遷移學習**。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"Transformer 架構有許多變體，包括 BERT、DistilBERT、BigBird、OpenGPT3 等，這些模型都可以進行微調。\n",
|
||||
"\n",
|
||||
"接下來，我們來看看如何使用預訓練的 BERT 模型來解決我們傳統的序列分類問題。我們將借用[官方文檔](https://www.tensorflow.org/text/tutorials/classify_text_with_bert)中的一些想法和代碼。\n",
|
||||
"\n",
|
||||
"為了加載預訓練模型，我們將使用 **Tensorflow hub**。首先，讓我們加載 BERT 專用的向量化工具：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"ename": "ModuleNotFoundError",
|
||||
"evalue": "No module named 'tensorflow_text'",
|
||||
"output_type": "error",
|
||||
"traceback": [
|
||||
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
|
||||
"\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)",
|
||||
"\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_41180/4216669875.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0mtensorflow_text\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mtensorflow_hub\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mhub\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mvectorizer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhub\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mKerasLayer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
|
||||
"\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'tensorflow_text'"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import tensorflow_text \n",
|
||||
"import tensorflow_hub as hub\n",
|
||||
"vectorizer = hub.KerasLayer('https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"{'input_type_ids': <tf.Tensor: shape=(1, 128), dtype=int32, numpy=\n",
|
||||
" array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],\n",
|
||||
" dtype=int32)>,\n",
|
||||
" 'input_word_ids': <tf.Tensor: shape=(1, 128), dtype=int32, numpy=\n",
|
||||
" array([[ 101, 1045, 2293, 19081, 102, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0]], dtype=int32)>,\n",
|
||||
" 'input_mask': <tf.Tensor: shape=(1, 128), dtype=int32, numpy=\n",
|
||||
" array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
|
||||
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],\n",
|
||||
" dtype=int32)>}"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"vectorizer(['I love transformers'])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"使用與原始網路訓練時相同的向量化工具是非常重要的。此外，BERT 向量化工具會返回三個組件：\n",
|
||||
"* `input_word_ids`，這是一個表示輸入句子中標記編號的序列\n",
|
||||
"* `input_mask`，用於顯示序列中哪些部分包含實際輸入，哪些部分是填充。這與 `Masking` 層生成的遮罩類似\n",
|
||||
"* `input_type_ids` 用於語言建模任務，允許在一個序列中指定兩個輸入句子。\n",
|
||||
"\n",
|
||||
"接下來，我們可以實例化 BERT 特徵提取器：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"bert = hub.KerasLayer('https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"pooled_output -> (1, 128)\n",
|
||||
"encoder_outputs -> 4\n",
|
||||
"sequence_output -> (1, 128, 128)\n",
|
||||
"default -> (1, 128)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"z = bert(vectorizer(['I love transformers']))\n",
|
||||
"for i,x in z.items():\n",
|
||||
" print(f\"{i} -> { len(x) if isinstance(x, list) else x.shape }\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"所以，BERT 層會返回一些有用的結果：\n",
|
||||
"* `pooled_output` 是通過平均序列中所有 token 的結果。你可以將其視為整個網絡的智能語義嵌入。它相當於我們之前模型中的 `GlobalAveragePooling1D` 層的輸出。\n",
|
||||
"* `sequence_output` 是最後一層 transformer 的輸出（對應於我們上面模型中的 `TransformerBlock` 的輸出）。\n",
|
||||
"* `encoder_outputs` 是所有 transformer 層的輸出。由於我們載入的是 4 層的 BERT 模型（從名稱中包含 `4_H` 可以推測出來），它有 4 個張量。最後一個張量與 `sequence_output` 相同。\n",
|
||||
"\n",
|
||||
"現在我們將定義端到端的分類模型。我們將使用*函數式模型定義*，在定義模型輸入後，提供一系列表達式來計算其輸出。我們還會將 BERT 模型的權重設置為不可訓練，只訓練最終的分類器：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"model\"\n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"Layer (type) Output Shape Param # Connected to \n",
|
||||
"==================================================================================================\n",
|
||||
"input_1 (InputLayer) [(None,)] 0 \n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"keras_layer (KerasLayer) {'input_type_ids': ( 0 input_1[0][0] \n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"keras_layer_1 (KerasLayer) {'pooled_output': (N 4782465 keras_layer[0][0] \n",
|
||||
" keras_layer[0][1] \n",
|
||||
" keras_layer[0][2] \n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"dropout_4 (Dropout) (None, 128) 0 keras_layer_1[0][5] \n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"dense_4 (Dense) (None, 4) 516 dropout_4[0][0] \n",
|
||||
"==================================================================================================\n",
|
||||
"Total params: 4,782,981\n",
|
||||
"Trainable params: 516\n",
|
||||
"Non-trainable params: 4,782,465\n",
|
||||
"__________________________________________________________________________________________________\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"inp = keras.Input(shape=(),dtype=tf.string)\n",
|
||||
"x = vectorizer(inp)\n",
|
||||
"x = bert(x)\n",
|
||||
"x = keras.layers.Dropout(0.1)(x['pooled_output'])\n",
|
||||
"out = keras.layers.Dense(4,activation='softmax')(x)\n",
|
||||
"model = keras.models.Model(inp,out)\n",
|
||||
"bert.trainable = False\n",
|
||||
"model.summary()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"938/938 [==============================] - 528s 559ms/step - loss: 0.8056 - acc: 0.6983 - val_loss: 0.5953 - val_acc: 0.7888\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7f9bb1e36d00>"
|
||||
]
|
||||
},
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'], optimizer='adam')\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(128),validation_data=ds_test.map(tupelize).batch(128))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"儘管可訓練的參數很少，但這個過程相當緩慢，因為 BERT 特徵提取器的計算量非常大。看起來我們無法達到合理的準確率，可能是因為訓練不足，或者模型參數不足。\n",
|
||||
"\n",
|
||||
"讓我們嘗試解凍 BERT 的權重並對其進行訓練。這需要非常小的學習率，並且需要更謹慎的訓練策略，包括使用 **warmup** 和 **AdamW** 優化器。我們將使用 `tf-models-official` 套件來創建優化器：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"model\"\n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"Layer (type) Output Shape Param # Connected to \n",
|
||||
"==================================================================================================\n",
|
||||
"input_1 (InputLayer) [(None,)] 0 \n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"keras_layer (KerasLayer) {'input_type_ids': ( 0 input_1[0][0] \n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"keras_layer_1 (KerasLayer) {'pooled_output': (N 4782465 keras_layer[0][0] \n",
|
||||
" keras_layer[0][1] \n",
|
||||
" keras_layer[0][2] \n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"dropout_4 (Dropout) (None, 128) 0 keras_layer_1[0][5] \n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"dense_4 (Dense) (None, 4) 516 dropout_4[0][0] \n",
|
||||
"==================================================================================================\n",
|
||||
"Total params: 4,782,981\n",
|
||||
"Trainable params: 4,782,980\n",
|
||||
"Non-trainable params: 1\n",
|
||||
"__________________________________________________________________________________________________\n",
|
||||
"938/938 [==============================] - 629s 664ms/step - loss: 0.6344 - acc: 0.7658 - val_loss: 0.4876 - val_acc: 0.8247\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7f9bb0bd0070>"
|
||||
]
|
||||
},
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"from official.nlp import optimization \n",
|
||||
"bert.trainable=True\n",
|
||||
"model.summary()\n",
|
||||
"epochs = 3\n",
|
||||
"opt = optimization.create_optimizer(\n",
|
||||
" init_lr=3e-5,\n",
|
||||
" num_train_steps=epochs*len(ds_train),\n",
|
||||
" num_warmup_steps=0.1*epochs*len(ds_train),\n",
|
||||
" optimizer_type='adamw')\n",
|
||||
"\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'], optimizer=opt)\n",
|
||||
"model.fit(ds_train.map(tupelize).batch(128),validation_data=ds_test.map(tupelize).batch(128))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"如您所見，訓練過程進展相當緩慢——但您可能希望嘗試進行幾個訓練週期（5-10次），並比較我們之前使用的方法，看看是否能獲得最佳結果。\n",
|
||||
"\n",
|
||||
"## Huggingface Transformers 庫\n",
|
||||
"\n",
|
||||
"另一種非常常見（且稍微簡單一些）的使用 Transformer 模型的方法是 [HuggingFace 套件](https://github.com/huggingface/)，它為不同的 NLP 任務提供了簡單的構建模塊。該套件同時支持 Tensorflow 和 PyTorch，後者是另一個非常流行的神經網絡框架。\n",
|
||||
"\n",
|
||||
"> **注意**：如果您對了解 Transformers 庫的工作方式不感興趣——可以直接跳到筆記本的末尾，因為您不會看到與我們之前所做的有實質性不同的內容。我們將重複使用不同的庫和更大的模型來訓練 BERT 模型的相同步驟。因此，這個過程涉及一些相當長的訓練時間，您可能只需要瀏覽一下代碼即可。\n",
|
||||
"\n",
|
||||
"讓我們看看如何使用 [Huggingface Transformers](http://huggingface.co) 解決我們的問題。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"首先，我們需要選擇要使用的模型。除了內建模型之外，Huggingface 還擁有一個[線上模型庫](https://huggingface.co/models)，在那裡你可以找到社群提供的更多預訓練模型。所有這些模型都可以通過提供模型名稱來加載和使用。所需的模型二進制文件會自動下載。\n",
|
||||
"\n",
|
||||
"有時候你可能需要加載自己的模型，這種情況下你可以指定包含所有相關文件的目錄，包括分詞器的參數、`config.json` 文件中的模型參數、二進制權重等。\n",
|
||||
"\n",
|
||||
"從模型名稱開始，我們可以實例化模型和分詞器。讓我們先從分詞器開始：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import transformers\n",
|
||||
"\n",
|
||||
"# To load the model from Internet repository using model name. \n",
|
||||
"# Use this if you are running from your own copy of the notebooks\n",
|
||||
"bert_model = 'bert-base-uncased' \n",
|
||||
"\n",
|
||||
"# To load the model from the directory on disk. Use this for Microsoft Learn module, because we have\n",
|
||||
"# prepared all required files for you.\n",
|
||||
"#bert_model = './bert'\n",
|
||||
"\n",
|
||||
"tokenizer = transformers.BertTokenizer.from_pretrained(bert_model)\n",
|
||||
"\n",
|
||||
"MAX_SEQ_LEN = 128\n",
|
||||
"PAD_INDEX = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)\n",
|
||||
"UNK_INDEX = tokenizer.convert_tokens_to_ids(tokenizer.unk_token)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"`tokenizer` 對象包含 `encode` 函數，可直接用於編碼文本：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[101, 23435, 12314, 2003, 1037, 2307, 7705, 2005, 17953, 2361, 102]"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tokenizer.encode('Tensorflow is a great framework for NLP')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們也可以使用分詞器來編碼序列，使其適合傳遞給模型，例如包括 `token_ids`、`input_mask` 等字段。我們還可以通過提供 `return_tensors='tf'` 參數來指定我們想要 Tensorflow 張量：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"{'input_ids': <tf.Tensor: shape=(1, 5), dtype=int32, numpy=array([[ 101, 7592, 1010, 2045, 102]], dtype=int32)>, 'token_type_ids': <tf.Tensor: shape=(1, 5), dtype=int32, numpy=array([[0, 0, 0, 0, 0]], dtype=int32)>, 'attention_mask': <tf.Tensor: shape=(1, 5), dtype=int32, numpy=array([[1, 1, 1, 1, 1]], dtype=int32)>}"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tokenizer(['Hello, there'],return_tensors='tf')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"在我們的案例中，我們將使用名為 `bert-base-uncased` 的預訓練 BERT 模型。*Uncased* 表示該模型對大小寫不敏感。\n",
|
||||
"\n",
|
||||
"在訓練模型時，我們需要提供已分詞的序列作為輸入，因此我們將設計數據處理管道。由於 `tokenizer.encode` 是一個 Python 函數，我們將採用與上一單元相同的方法，使用 `py_function` 來調用它：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 31,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def process(x):\n",
|
||||
" return tokenizer.encode(x.numpy().decode('utf-8'),return_tensors='tf',padding='max_length',max_length=MAX_SEQ_LEN,truncation=True)[0]\n",
|
||||
"\n",
|
||||
"def process_fn(x):\n",
|
||||
" s = x['title']+' '+x['description']\n",
|
||||
" e = tf.py_function(process,inp=[s],Tout=(tf.int32))\n",
|
||||
" e.set_shape(MAX_SEQ_LEN)\n",
|
||||
" return e,x['label']"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在我們可以使用 `BertForSequenceClassfication` 套件加載實際模型。這確保了我們的模型已經具備分類所需的架構，包括最終的分類器。您會看到一條警告訊息，指出最終分類器的權重尚未初始化，並且模型需要進行預訓練——這完全沒問題，因為這正是我們即將要做的！\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 32,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"model = transformers.TFBertForSequenceClassification.from_pretrained(bert_model,num_labels=4,output_attentions=False)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 33,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"tf_bert_for_sequence_classification_1\"\n",
|
||||
"_________________________________________________________________\n",
|
||||
"Layer (type) Output Shape Param # \n",
|
||||
"=================================================================\n",
|
||||
"bert (TFBertMainLayer) multiple 109482240 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"dropout_75 (Dropout) multiple 0 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"classifier (Dense) multiple 3076 \n",
|
||||
"=================================================================\n",
|
||||
"Total params: 109,485,316\n",
|
||||
"Trainable params: 109,485,316\n",
|
||||
"Non-trainable params: 0\n",
|
||||
"_________________________________________________________________\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.summary()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"從 `summary()` 中可以看到，該模型包含了將近 1.1 億個參數！假設我們希望在相對較小的數據集上進行簡單的分類任務，我們可能不希望訓練 BERT 基層：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 34,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"tf_bert_for_sequence_classification_1\"\n",
|
||||
"_________________________________________________________________\n",
|
||||
"Layer (type) Output Shape Param # \n",
|
||||
"=================================================================\n",
|
||||
"bert (TFBertMainLayer) multiple 109482240 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"dropout_75 (Dropout) multiple 0 \n",
|
||||
"_________________________________________________________________\n",
|
||||
"classifier (Dense) multiple 3076 \n",
|
||||
"=================================================================\n",
|
||||
"Total params: 109,485,316\n",
|
||||
"Trainable params: 3,076\n",
|
||||
"Non-trainable params: 109,482,240\n",
|
||||
"_________________________________________________________________\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.layers[0].trainable = False\n",
|
||||
"model.summary()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在我們準備開始訓練！\n",
|
||||
"\n",
|
||||
"> **注意**：訓練完整規模的 BERT 模型可能會非常耗時！因此，我們只會訓練前 32 個批次。這只是為了展示模型訓練的設置方式。如果您有興趣嘗試完整規模的訓練，只需移除 `steps_per_epoch` 和 `validation_steps` 參數，並準備耐心等待！\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 30,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"32/32 [==============================] - 142s 4s/step - loss: 1.3896 - acc: 0.2500 - val_loss: 1.3863 - val_acc: 0.2480\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<tensorflow.python.keras.callbacks.History at 0x7f1d40a4b6a0>"
|
||||
]
|
||||
},
|
||||
"execution_count": 30,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.compile('adam','sparse_categorical_crossentropy',['acc'])\n",
|
||||
"tf.get_logger().setLevel('ERROR')\n",
|
||||
"model.fit(ds_train.map(process_fn).batch(32),validation_data=ds_test.map(process_fn).batch(32),steps_per_epoch=32,validation_steps=2)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"如果你增加迭代次數並耐心等待，並且訓練多個周期，你可以期待 BERT 分類能夠提供最佳的準確率！這是因為 BERT 已經相當了解語言的結構，我們只需要微調最終的分類器。然而，由於 BERT 是一個大型模型，整個訓練過程需要很長時間，並且需要強大的計算能力！（GPU，最好是多個）。\n",
|
||||
"\n",
|
||||
"> **Note:** 在我們的範例中，我們使用的是最小的預訓練 BERT 模型之一。還有更大的模型可能會產生更好的結果。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 重點\n",
|
||||
"\n",
|
||||
"在本單元中，我們探討了基於**transformers**的最新模型架構。我們將其應用於文本分類任務，但同樣地，BERT模型也可以用於實體抽取、問答系統以及其他自然語言處理任務。\n",
|
||||
"\n",
|
||||
"Transformer模型代表了自然語言處理領域的最新技術，在大多數情況下，當實現自定義自然語言處理解決方案時，這應該是您首先嘗試的解決方案。然而，如果您希望構建更高級的神經網絡模型，理解本模組中討論的循環神經網絡的基本原理是非常重要的。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對於因使用此翻譯而產生的任何誤解或錯誤解讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "0cb620c6d4b9f7a635928804c26cf22403d89d98d79684e4529119355ee6d5a5"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "py38_tensorflow",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "ab59c532409774988ab875f2260e8e53",
|
||||
"translation_date": "2025-08-31T10:41:30+00:00",
|
||||
"source_file": "lessons/5-NLP/18-Transformers/TransformersTF.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
# 作業：Transformers
|
||||
|
||||
在 HuggingFace 上嘗試使用 Transformers！試著使用他們提供的腳本，來操作網站上各種可用的模型：https://huggingface.co/docs/transformers/run_scripts。嘗試使用他們的一個數據集，然後從本課程或 Kaggle 匯入一個你自己的數據集，看看是否能生成有趣的文本。製作一個筆記本來記錄你的發現。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。
|
||||
|
|
@ -0,0 +1,492 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 命名實體識別 (NER)\n",
|
||||
"\n",
|
||||
"此筆記本來自 [AI for Beginners Curriculum](http://aka.ms/ai-beginners)。\n",
|
||||
"\n",
|
||||
"在這個範例中，我們將學習如何在 [命名實體識別的註解語料庫](https://www.kaggle.com/datasets/abhinavwalia95/entity-annotated-corpus) 資料集上訓練 NER 模型。在開始之前，請下載 [ner_dataset.csv](https://www.kaggle.com/datasets/abhinavwalia95/entity-annotated-corpus?resource=download&select=ner_dataset.csv) 文件到當前目錄。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 62,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import pandas as pd\n",
|
||||
"from tensorflow import keras\n",
|
||||
"import numpy as np"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 準備資料集\n",
|
||||
"\n",
|
||||
"我們將從將資料集讀入資料框開始。如果您想了解更多有關使用 Pandas 的資訊，請參考我們的 [初學者資料科學課程](http://aka.ms/datascience-beginners)中的[資料處理課程](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/2-Working-With-Data/07-python)。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/html": [
|
||||
"<div>\n",
|
||||
"<style scoped>\n",
|
||||
" .dataframe tbody tr th:only-of-type {\n",
|
||||
" vertical-align: middle;\n",
|
||||
" }\n",
|
||||
"\n",
|
||||
" .dataframe tbody tr th {\n",
|
||||
" vertical-align: top;\n",
|
||||
" }\n",
|
||||
"\n",
|
||||
" .dataframe thead th {\n",
|
||||
" text-align: right;\n",
|
||||
" }\n",
|
||||
"</style>\n",
|
||||
"<table border=\"1\" class=\"dataframe\">\n",
|
||||
" <thead>\n",
|
||||
" <tr style=\"text-align: right;\">\n",
|
||||
" <th></th>\n",
|
||||
" <th>Sentence #</th>\n",
|
||||
" <th>Word</th>\n",
|
||||
" <th>POS</th>\n",
|
||||
" <th>Tag</th>\n",
|
||||
" </tr>\n",
|
||||
" </thead>\n",
|
||||
" <tbody>\n",
|
||||
" <tr>\n",
|
||||
" <th>0</th>\n",
|
||||
" <td>Sentence: 1</td>\n",
|
||||
" <td>Thousands</td>\n",
|
||||
" <td>NNS</td>\n",
|
||||
" <td>O</td>\n",
|
||||
" </tr>\n",
|
||||
" <tr>\n",
|
||||
" <th>1</th>\n",
|
||||
" <td>NaN</td>\n",
|
||||
" <td>of</td>\n",
|
||||
" <td>IN</td>\n",
|
||||
" <td>O</td>\n",
|
||||
" </tr>\n",
|
||||
" <tr>\n",
|
||||
" <th>2</th>\n",
|
||||
" <td>NaN</td>\n",
|
||||
" <td>demonstrators</td>\n",
|
||||
" <td>NNS</td>\n",
|
||||
" <td>O</td>\n",
|
||||
" </tr>\n",
|
||||
" <tr>\n",
|
||||
" <th>3</th>\n",
|
||||
" <td>NaN</td>\n",
|
||||
" <td>have</td>\n",
|
||||
" <td>VBP</td>\n",
|
||||
" <td>O</td>\n",
|
||||
" </tr>\n",
|
||||
" <tr>\n",
|
||||
" <th>4</th>\n",
|
||||
" <td>NaN</td>\n",
|
||||
" <td>marched</td>\n",
|
||||
" <td>VBN</td>\n",
|
||||
" <td>O</td>\n",
|
||||
" </tr>\n",
|
||||
" </tbody>\n",
|
||||
"</table>\n",
|
||||
"</div>"
|
||||
],
|
||||
"text/plain": [
|
||||
" Sentence # Word POS Tag\n",
|
||||
"0 Sentence: 1 Thousands NNS O\n",
|
||||
"1 NaN of IN O\n",
|
||||
"2 NaN demonstrators NNS O\n",
|
||||
"3 NaN have VBP O\n",
|
||||
"4 NaN marched VBN O"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"df = pd.read_csv('ner_dataset.csv',encoding='unicode-escape')\n",
|
||||
"df.head()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"讓我們獲取唯一標籤並創建查找字典，以便我們可以用來將標籤轉換為類別編號：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array(['O', 'B-geo', 'B-gpe', 'B-per', 'I-geo', 'B-org', 'I-org', 'B-tim',\n",
|
||||
" 'B-art', 'I-art', 'I-per', 'I-gpe', 'I-tim', 'B-nat', 'B-eve',\n",
|
||||
" 'I-eve', 'I-nat'], dtype=object)"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tags = df.Tag.unique()\n",
|
||||
"tags"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"'O'"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"id2tag = dict(enumerate(tags))\n",
|
||||
"tag2id = { v : k for k,v in id2tag.items() }\n",
|
||||
"\n",
|
||||
"id2tag[0]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在我們需要對詞彙做同樣的處理。為了簡化，我們將在不考慮詞頻的情況下創建詞彙；在現實中，你可能會想使用 Keras 向量化工具，並限制詞彙的數量。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"vocab = set(df['Word'].apply(lambda x: x.lower()))\n",
|
||||
"id2word = { i+1 : v for i,v in enumerate(vocab) }\n",
|
||||
"id2word[0] = '<UNK>'\n",
|
||||
"vocab.add('<UNK>')\n",
|
||||
"word2id = { v : k for k,v in id2word.items() }"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們需要創建一個句子數據集用於訓練。讓我們遍歷原始數據集，並將所有單個句子分離到 `X`（單詞列表）和 `Y`（標記列表）：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 41,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"X,Y = [],[]\n",
|
||||
"s,t = [],[]\n",
|
||||
"for i,row in df[['Sentence #','Word','Tag']].iterrows():\n",
|
||||
" if pd.isna(row['Sentence #']):\n",
|
||||
" s.append(row['Word'])\n",
|
||||
" t.append(row['Tag'])\n",
|
||||
" else:\n",
|
||||
" if len(s)>0:\n",
|
||||
" X.append(s)\n",
|
||||
" Y.append(t)\n",
|
||||
" s,t = [row['Word']],[row['Tag']]\n",
|
||||
"X.append(s)\n",
|
||||
"Y.append(t)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 93,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"([10386,\n",
|
||||
" 23515,\n",
|
||||
" 4134,\n",
|
||||
" 29620,\n",
|
||||
" 7954,\n",
|
||||
" 13583,\n",
|
||||
" 21193,\n",
|
||||
" 12222,\n",
|
||||
" 27322,\n",
|
||||
" 18258,\n",
|
||||
" 5815,\n",
|
||||
" 15880,\n",
|
||||
" 5355,\n",
|
||||
" 25242,\n",
|
||||
" 31327,\n",
|
||||
" 18258,\n",
|
||||
" 27067,\n",
|
||||
" 23515,\n",
|
||||
" 26444,\n",
|
||||
" 14412,\n",
|
||||
" 358,\n",
|
||||
" 26551,\n",
|
||||
" 5011,\n",
|
||||
" 30558],\n",
|
||||
" [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0])"
|
||||
]
|
||||
},
|
||||
"execution_count": 93,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def vectorize(seq):\n",
|
||||
" return [word2id[x.lower()] for x in seq]\n",
|
||||
"\n",
|
||||
"def tagify(seq):\n",
|
||||
" return [tag2id[x] for x in seq]\n",
|
||||
"\n",
|
||||
"Xv = list(map(vectorize,X))\n",
|
||||
"Yv = list(map(tagify,Y))\n",
|
||||
"\n",
|
||||
"Xv[0], Yv[0]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"為了簡化，我們將用 0 代幣填充所有句子到最大長度。在現實生活中，我們可能會想使用更聰明的策略，僅在一個小批次內填充序列。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 51,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"X_data = keras.preprocessing.sequence.pad_sequences(Xv,padding='post')\n",
|
||||
"Y_data = keras.preprocessing.sequence.pad_sequences(Yv,padding='post')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 定義標記分類網絡\n",
|
||||
"\n",
|
||||
"我們將使用兩層雙向 LSTM 網絡進行標記分類。為了對最後一層 LSTM 的每個輸出應用密集分類器，我們將使用 `TimeDistributed` 結構，該結構會在每一步中將相同的密集層複製到 LSTM 的每個輸出：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 94,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Model: \"sequential_3\"\n",
|
||||
"_________________________________________________________________\n",
|
||||
" Layer (type) Output Shape Param # \n",
|
||||
"=================================================================\n",
|
||||
" embedding_4 (Embedding) (None, 104, 300) 9545400 \n",
|
||||
" \n",
|
||||
" bidirectional_6 (Bidirectio (None, 104, 200) 320800 \n",
|
||||
" nal) \n",
|
||||
" \n",
|
||||
" bidirectional_7 (Bidirectio (None, 104, 200) 240800 \n",
|
||||
" nal) \n",
|
||||
" \n",
|
||||
" time_distributed_3 (TimeDis (None, 104, 17) 3417 \n",
|
||||
" tributed) \n",
|
||||
" \n",
|
||||
"=================================================================\n",
|
||||
"Total params: 10,110,417\n",
|
||||
"Trainable params: 10,110,417\n",
|
||||
"Non-trainable params: 0\n",
|
||||
"_________________________________________________________________\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"maxlen = X_data.shape[1]\n",
|
||||
"vocab_size = len(vocab)\n",
|
||||
"num_tags = len(tags)\n",
|
||||
"model = keras.models.Sequential([\n",
|
||||
" keras.layers.Embedding(vocab_size, 300, input_length=maxlen),\n",
|
||||
" keras.layers.Bidirectional(keras.layers.LSTM(units=100, activation='tanh', return_sequences=True)),\n",
|
||||
" keras.layers.Bidirectional(keras.layers.LSTM(units=100, activation='tanh', return_sequences=True)),\n",
|
||||
" keras.layers.TimeDistributed(keras.layers.Dense(num_tags, activation='softmax'))\n",
|
||||
"])\n",
|
||||
"model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['acc'])\n",
|
||||
"model.summary()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"注意，在這裡我們為數據集明確指定了 `maxlen`——如果我們希望網絡能夠處理可變長度的序列，那麼在定義網絡時需要更加巧妙。\n",
|
||||
"\n",
|
||||
"現在讓我們訓練模型。為了加快速度，我們只訓練一個周期，但您可以嘗試訓練更長的時間。此外，您可能希望將部分數據集分離作為訓練數據集，以觀察驗證準確性。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 57,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"1499/1499 [==============================] - 740s 488ms/step - loss: 0.0667 - acc: 0.9841\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"<keras.callbacks.History at 0x16f0bb2a310>"
|
||||
]
|
||||
},
|
||||
"execution_count": 57,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"model.fit(X_data,Y_data)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 測試結果\n",
|
||||
"\n",
|
||||
"現在讓我們看看實體識別模型在一個範例句子上的表現：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 91,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"sent = 'John Smith went to Paris to attend a conference in cancer development institute'\n",
|
||||
"words = sent.lower().split()\n",
|
||||
"v = keras.preprocessing.sequence.pad_sequences([[word2id[x] for x in words]],padding='post',maxlen=maxlen)\n",
|
||||
"res = model(v)[0]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 92,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"john -> B-per\n",
|
||||
"smith -> I-per\n",
|
||||
"went -> O\n",
|
||||
"to -> O\n",
|
||||
"paris -> B-geo\n",
|
||||
"to -> O\n",
|
||||
"attend -> O\n",
|
||||
"a -> O\n",
|
||||
"conference -> O\n",
|
||||
"in -> O\n",
|
||||
"cancer -> B-org\n",
|
||||
"development -> I-org\n",
|
||||
"institute -> I-org\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"r = np.argmax(res.numpy(),axis=1)\n",
|
||||
"for i,w in zip(r,words):\n",
|
||||
" print(f\"{w} -> {id2tag[i]}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 重點\n",
|
||||
"\n",
|
||||
"即使是簡單的 LSTM 模型在命名實體識別（NER）上也能展現出不錯的效果。然而，若想獲得更好的結果，您可能需要使用大型的預訓練語言模型，例如 BERT。使用 Huggingface Transformers 庫訓練 BERT 用於 NER 的方法已在[此處](https://huggingface.co/course/chapter7/2?fw=pt)進行了說明。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.8.12 ('py38')",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"orig_nbformat": 4,
|
||||
"coopTranslator": {
|
||||
"original_hash": "254d25052dcca4ef84f59a05f2935bdc",
|
||||
"translation_date": "2025-08-31T10:44:51+00:00",
|
||||
"source_file": "lessons/5-NLP/19-NER/NER-TF.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
# 命名實體識別
|
||||
|
||||
到目前為止，我們主要集中在一個 NLP 任務——分類。然而，還有其他 NLP 任務可以通過神經網絡完成。其中一個任務是 **[命名實體識別](https://wikipedia.org/wiki/Named-entity_recognition)**（NER），它的目的是識別文本中的特定實體，例如地點、人名、日期時間區間、化學式等等。
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/37)
|
||||
|
||||
## 使用 NER 的範例
|
||||
|
||||
假設你想開發一個自然語言聊天機器人，類似於 Amazon Alexa 或 Google Assistant。智能聊天機器人的工作方式是通過對輸入句子進行文本分類來*理解*用戶的需求。分類的結果稱為 **意圖**（intent），它決定了聊天機器人應該執行什麼操作。
|
||||
|
||||
<img alt="Bot NER" src="../../../../../translated_images/zh-TW/bot-ner.4b09235dbb0ad275.webp" width="50%"/>
|
||||
|
||||
> 圖片由作者提供
|
||||
|
||||
然而，用戶可能會在短語中提供一些參數。例如，當詢問天氣時，她可能會指定地點或日期。機器人應該能夠理解這些實體，並相應地填充參數槽，然後再執行操作。而這正是 NER 發揮作用的地方。
|
||||
|
||||
> ✅ 另一個範例是[分析科學醫學論文](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/)。我們需要尋找的主要內容之一是特定的醫學術語，例如疾病和醫學物質。雖然少量的疾病可能可以通過子字串搜索提取，但更複雜的實體（如化學化合物和藥物名稱）則需要更複雜的方法。
|
||||
|
||||
## NER 作為標記分類
|
||||
|
||||
NER 模型本質上是 **標記分類模型**，因為對於每個輸入的標記，我們需要決定它是否屬於某個實體，如果是，則屬於哪個實體類別。
|
||||
|
||||
考慮以下論文標題：
|
||||
|
||||
**三尖瓣返流** 和 **碳酸鋰** **毒性** 在新生兒中的表現。
|
||||
|
||||
這裡的實體是：
|
||||
|
||||
* 三尖瓣返流是一種疾病（`DIS`）
|
||||
* 碳酸鋰是一種化學物質（`CHEM`）
|
||||
* 毒性也是一種疾病（`DIS`）
|
||||
|
||||
注意，一個實體可能包含多個標記。而且，如本例所示，我們需要區分兩個連續的實體。因此，通常為每個實體使用兩個類別——一個指定實體的第一個標記（通常使用 `B-` 前綴，表示 **b**eginning），另一個表示實體的延續部分（`I-`，表示 **i**nner token）。我們還使用 `O` 作為類別來表示所有 **o**ther 標記。這種標記標籤方法稱為 [BIO 標記法](https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging))（或 IOB）。標記後，我們的標題將如下所示：
|
||||
|
||||
標記 | 標籤
|
||||
------|-----
|
||||
三尖瓣 | B-DIS
|
||||
返流 | I-DIS
|
||||
和 | O
|
||||
碳酸 | B-CHEM
|
||||
鋰 | I-CHEM
|
||||
毒性 | B-DIS
|
||||
在 | O
|
||||
新生兒 | O
|
||||
中 | O
|
||||
的 | O
|
||||
表現 | O
|
||||
。 | O
|
||||
|
||||
由於我們需要在標記和類別之間建立一對一的對應關係，我們可以從這張圖中訓練一個右側的 **多對多** 神經網絡模型：
|
||||
|
||||
|
||||
|
||||
> *圖片來自 [這篇部落格文章](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)，作者為 [Andrej Karpathy](http://karpathy.github.io/)。NER 標記分類模型對應於圖片中最右側的網絡架構。*
|
||||
|
||||
## 訓練 NER 模型
|
||||
|
||||
由於 NER 模型本質上是一個標記分類模型，我們可以使用我們已經熟悉的 RNN 來完成這項任務。在這種情況下，每個循環網絡的區塊將返回標記 ID。以下範例筆記本展示了如何訓練 LSTM 進行標記分類。
|
||||
|
||||
## ✍️ 範例筆記本：NER
|
||||
|
||||
繼續學習以下筆記本：
|
||||
|
||||
* [使用 TensorFlow 的 NER](NER-TF.ipynb)
|
||||
|
||||
## 結論
|
||||
|
||||
NER 模型是一種 **標記分類模型**，這意味著它可以用來執行標記分類。這是一個 NLP 中非常常見的任務，有助於識別文本中的特定實體，包括地點、名字、日期等。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
完成以下連結的作業，訓練一個醫學術語的命名實體識別模型，然後嘗試在不同的數據集上進行測試。
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/38)
|
||||
|
||||
## 複習與自學
|
||||
|
||||
閱讀部落格文章 [循環神經網絡的非凡效能](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)，並按照文章中的進一步閱讀部分加深你的知識。
|
||||
|
||||
## [作業](lab/README.md)
|
||||
|
||||
在本課的作業中，你需要訓練一個醫學實體識別模型。你可以從本課描述的 LSTM 模型訓練開始，然後嘗試使用 BERT 轉換器模型。閱讀 [說明](lab/README.md) 以獲取所有詳細信息。
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
# 命名實體識別 (NER)
|
||||
|
||||
來自 [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners) 的實驗作業。
|
||||
|
||||
## 任務
|
||||
|
||||
在這個實驗中，你需要訓練一個針對醫學術語的命名實體識別模型。
|
||||
|
||||
## 數據集
|
||||
|
||||
為了訓練 NER 模型，我們需要一個正確標註的醫學實體數據集。[BC5CDR 數據集](https://biocreative.bioinformatics.udel.edu/tasks/biocreative-v/track-3-cdr/) 包含來自超過 1500 篇論文的疾病和化學實體標註。你可以在其網站註冊後下載該數據集。
|
||||
|
||||
BC5CDR 數據集的格式如下：
|
||||
|
||||
```
|
||||
6794356|t|Tricuspid valve regurgitation and lithium carbonate toxicity in a newborn infant.
|
||||
6794356|a|A newborn with massive tricuspid regurgitation, atrial flutter, congestive heart failure, and a high serum lithium level is described. This is the first patient to initially manifest tricuspid regurgitation and atrial flutter, and the 11th described patient with cardiac disease among infants exposed to lithium compounds in the first trimester of pregnancy. Sixty-three percent of these infants had tricuspid valve involvement. Lithium carbonate may be a factor in the increasing incidence of congenital heart disease when taken during early pregnancy. It also causes neurologic depression, cyanosis, and cardiac arrhythmia when consumed prior to delivery.
|
||||
6794356 0 29 Tricuspid valve regurgitation Disease D014262
|
||||
6794356 34 51 lithium carbonate Chemical D016651
|
||||
6794356 52 60 toxicity Disease D064420
|
||||
...
|
||||
```
|
||||
|
||||
在這個數據集中，第一行和第二行分別是論文標題和摘要，接下來是個別的實體，包含其在標題+摘要區塊中的起始和結束位置。除了實體類型外，你還可以獲得該實體在某些醫學本體中的本體 ID。
|
||||
|
||||
你需要撰寫一些 Python 程式碼，將其轉換為 BIO 編碼格式。
|
||||
|
||||
## 網絡架構
|
||||
|
||||
第一次嘗試 NER 可以使用 LSTM 網絡，就像你在課堂中看到的範例一樣。然而，在 NLP 任務中，[Transformer 架構](https://en.wikipedia.org/wiki/Transformer_(machine_learning_model))，特別是 [BERT 語言模型](https://en.wikipedia.org/wiki/BERT_(language_model))，通常能夠取得更好的結果。預訓練的 BERT 模型能夠理解語言的基本結構，並且可以用相對較小的數據集和計算成本進行特定任務的微調。
|
||||
|
||||
由於我們計劃將 NER 應用於醫學場景，因此使用在醫學文本上訓練的 BERT 模型是合理的選擇。Microsoft Research 發布了一個名為 [PubMedBERT][PubMedBERT] 的預訓練模型（[相關論文][PubMedBERT-Pub]），該模型使用 [PubMed](https://pubmed.ncbi.nlm.nih.gov/) 資料庫中的文本進行了微調。
|
||||
|
||||
訓練 Transformer 模型的事實標準是 [Hugging Face Transformers](https://huggingface.co/) 庫。該庫還包含一個由社群維護的預訓練模型庫，包括 PubMedBERT。要加載並使用此模型，我們只需要幾行程式碼：
|
||||
|
||||
```python
|
||||
model_name = "microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract"
|
||||
classes = ... # number of classes: 2*entities+1
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
model = BertForTokenClassification.from_pretrained(model_name, classes)
|
||||
```
|
||||
|
||||
這段程式碼為我們提供了用於標記分類任務的 `model`（使用 `classes` 數量的類別），以及可以將輸入文本分割為標記的 `tokenizer` 物件。你需要將數據集轉換為 BIO 格式，並考慮到 PubMedBERT 的標記化方式。你可以參考 [這段 Python 程式碼](https://gist.github.com/shwars/580b55684be3328eb39ecf01b9cbbd88) 作為靈感。
|
||||
|
||||
## 收穫
|
||||
|
||||
這項任務非常接近於你在實際工作中可能遇到的任務，特別是當你希望從大量自然語言文本中獲取更多洞見時。在我們的案例中，我們可以將訓練好的模型應用於 [COVID 相關論文數據集](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge)，看看我們能夠獲得哪些洞見。[這篇部落格文章](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/) 和 [這篇論文](https://www.mdpi.com/2504-2289/6/1/4) 描述了可以使用 NER 在這些論文語料庫上進行的研究。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。
|
||||
|
|
@ -0,0 +1,325 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 嘗試使用 OpenAI GPT\n",
|
||||
"\n",
|
||||
"此筆記本是 [AI for Beginners Curriculum](http://aka.ms/ai-beginners) 的一部分。\n",
|
||||
"\n",
|
||||
"在這個筆記本中，我們將探索如何使用 Hugging Face 的 `transformers` 庫來操作 OpenAI-GPT 模型。\n",
|
||||
"\n",
|
||||
"事不宜遲，讓我們建立文字生成管道並開始生成吧！\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stderr",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"c:\\Users\\bethanycheum\\Desktop\\AI-For-Beginners\\.venv\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
|
||||
" from .autonotebook import tqdm as notebook_tqdm\n",
|
||||
"Downloading model.safetensors: 100%|██████████| 479M/479M [04:28<00:00, 1.78MB/s] \n",
|
||||
"c:\\Users\\bethanycheum\\Desktop\\AI-For-Beginners\\.venv\\lib\\site-packages\\huggingface_hub\\file_download.py:133: UserWarning: `huggingface_hub` cache-system uses symlinks by default to efficiently store duplicated files but your machine does not support them in C:\\Users\\bethanycheum\\.cache\\huggingface\\hub. Caching files will still work but in a degraded version that might require more space on your disk. This warning can be disabled by setting the `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For more details, see https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations.\n",
|
||||
"To support symlinks on Windows, you either need to activate Developer Mode or to run Python as an administrator. In order to see activate developer mode, see this article: https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development\n",
|
||||
" warnings.warn(message)\n",
|
||||
"Some weights of OpenAIGPTLMHeadModel were not initialized from the model checkpoint at openai-gpt and are newly initialized: ['position_ids']\n",
|
||||
"You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
|
||||
"Downloading (…)neration_config.json: 100%|██████████| 74.0/74.0 [00:00<00:00, 48.8kB/s]\n",
|
||||
"Downloading (…)olve/main/vocab.json: 100%|██████████| 816k/816k [00:00<00:00, 1.76MB/s]\n",
|
||||
"Downloading (…)olve/main/merges.txt: 100%|██████████| 458k/458k [00:00<00:00, 1.11MB/s]\n",
|
||||
"Downloading (…)/main/tokenizer.json: 100%|██████████| 1.27M/1.27M [00:00<00:00, 2.12MB/s]\n",
|
||||
"Xformers is not installed correctly. If you want to use memory_efficient_attention to accelerate training use the following command to install Xformers\n",
|
||||
"pip install xformers.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[{'generated_text': \"Hello! I am a neural network, and I want to say that i apologize for not coming to you yourself, for not helping you, and that i was too busy getting dressed and studying for a midterm. you know, the kind where the teachers are like that and they come in pairs with their boyfriends, but not with theirs. it's true, that i have had a girlfriend, and i'm only going on wednesdays and thursdays because i was too busy with college, but maybe\"},\n",
|
||||
" {'generated_text': 'Hello! I am a neural network, and I want to say that we have been blessed with a wonderful gift ; no one of us has died at all. and our spirits are strong, very strong. in one very lucky moment of luck for you, all has been given direction and destiny, and for us there are no more mysteries. the earth has been chosen for you, and that earth is now ours, and you must be forever in our hearts. \" \\n the words, as one,'},\n",
|
||||
" {'generated_text': 'Hello! I am a neural network, and I want to say that if you would just turn and face the general, you would have a nice day. \" \\n \" sure thing, \" said one of the soldiers, and started to run. the rest of the soldiers followed, shouting. the general turned to general zulu, raising his arm. the general said something in his native language, and the general immediately started to run. zulu started to move toward the wall, with the'},\n",
|
||||
" {'generated_text': 'Hello! I am a neural network, and I want to say that i am not a doctor but an anthropologist to you, a specialist, a specialist in the field of astrobiological biology, and that i am very much involved in this investigation. i am not sure, i am not certain, but i can confirm your conclusions and therefore i will go to the top. i have a colleague who has just returned from this expedition and his findings confirm that you are a specialist. that is, he'},\n",
|
||||
" {'generated_text': \"Hello! I am a neural network, and I want to say that everyone here is in agreement that no matter how many times i say to myself,'he was never a man of action on the battlefield,'or'he 'll never take a chance at killing any civilians,'or'he 'll never let his men go undefended against enemy forces of this caliber,'or'that's just what i need in a day like today. \\n you see, there are only three groups that\"}]"
|
||||
]
|
||||
},
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"from transformers import pipeline\n",
|
||||
"\n",
|
||||
"model_name = 'openai-gpt' \n",
|
||||
"\n",
|
||||
"generator = pipeline('text-generation', model=model_name)\n",
|
||||
"\n",
|
||||
"generator(\"Hello! I am a neural network, and I want to say that\", max_length=100, num_return_sequences=5)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 提示工程\n",
|
||||
"\n",
|
||||
"在某些問題中，您可以通過設計正確的提示直接使用 openai-gpt 生成。請查看以下示例：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[{'generated_text': 'Synonyms of a word cat: the same cat i used to stare at, and you in'},\n",
|
||||
" {'generated_text': 'Synonyms of a word cat: cat of the woods, cat of the hills, cat of'},\n",
|
||||
" {'generated_text': 'Synonyms of a word cat: you! \\n \" it\\'s a girl. \" i said'},\n",
|
||||
" {'generated_text': \"Synonyms of a word cat: big cat. but how come, we didn't hear it\"},\n",
|
||||
" {'generated_text': 'Synonyms of a word cat: \" mea - o - c \" which makes them sound'}]"
|
||||
]
|
||||
},
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"generator(\"Synonyms of a word cat:\", max_length=20, num_return_sequences=5)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[{'generated_text': 'I love when you say this -> Positive\\nI have myself -> Negative\\nThis is awful for you to say this -> positive this is so horrible - > positive that your brother is gay - >'},\n",
|
||||
" {'generated_text': 'I love when you say this -> Positive\\nI have myself -> Negative\\nThis is awful for you to say this -> negative i will bring this on you -, < positive am i, i'},\n",
|
||||
" {'generated_text': 'I love when you say this -> Positive\\nI have myself -> Negative\\nThis is awful for you to say this -> negative i have self - esteem i must take it - : \\n - -'},\n",
|
||||
" {'generated_text': 'I love when you say this -> Positive\\nI have myself -> Negative\\nThis is awful for you to say this -> negative this is - : \\n if it were true that the devil would have'},\n",
|
||||
" {'generated_text': \"I love when you say this -> Positive\\nI have myself -> Negative\\nThis is awful for you to say this -> positive i have you - > positive it's a bad thing, > positive\"}]"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"generator(\"I love when you say this -> Positive\\nI have myself -> Negative\\nThis is awful for you to say this ->\", max_length=40, num_return_sequences=5)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[{'generated_text': 'Translate English to French: cat => chat, dog => chien, student => new and unusual. there were no more words to be'},\n",
|
||||
" {'generated_text': 'Translate English to French: cat => chat, dog => chien, student => student \\n his eyes were huge in his lean face as'},\n",
|
||||
" {'generated_text': \"Translate English to French: cat => chat, dog => chien, student => the teacher's words, their words, their words.\"}]"
|
||||
]
|
||||
},
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"generator(\"Translate English to French: cat => chat, dog => chien, student => \", top_k=50, max_length=30, num_return_sequences=3)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[{'generated_text': 'People who liked the movie The Matrix also liked it, and there was the movie of the first man after us. \\n i wanted to laugh at how stupid these stupid actors were. no, they were'},\n",
|
||||
" {'generated_text': \"People who liked the movie The Matrix also liked the movie, and the film was the result. and that's when the man in the story was brought into reality, after a few decades. \\n a\"},\n",
|
||||
" {'generated_text': 'People who liked the movie The Matrix also liked the movie the matrix, because there was a very old movie movie called the matrix, where there was a great super hero, and the super hero came out'},\n",
|
||||
" {'generated_text': \"People who liked the movie The Matrix also liked the movie that didn't have a chance to pay cash, if they could afford it. most often they got a good deal and a lot of money,\"},\n",
|
||||
" {'generated_text': \"People who liked the movie The Matrix also liked the movie, and i didn't seem to have the same problem. \\n i 'd met the other half of my family. i spent most of my time\"}]"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"generator(\"People who liked the movie The Matrix also liked \", max_length=40, num_return_sequences=5)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 文本取樣策略\n",
|
||||
"\n",
|
||||
"到目前為止，我們一直使用簡單的 **貪婪** 取樣策略，根據最高概率選擇下一個單詞。以下是其運作方式：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[{'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw my friend, a young man, sprawled across the bed in his bed. \\n \" hi, i\\'m mike eptirard. \" \\n there was silence on the other side of the door. i listened for any trace of life but there was nothing. my heart began to pound, i was starting to sweat, i took out my wallet'},\n",
|
||||
" {'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw my mother on the bed, hugging her legs to her chest and sobbing. i saw my dad and mother from the corner of my eye. \\n elfin face was covered in tears as i entered the room. my dad and mother also wept ; just as they did every other time i came to work. but this time, they had different faces'},\n",
|
||||
" {'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw the room had changed because it was dark. it still smelled like a hospital. a new light shined through from a vent in the ceiling. i found myself in a bathroom and a small room with a sink and a wall of glass. the bathroom billion years ago. not so different from all of the rest of the apartment. \\n now...'},\n",
|
||||
" {'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw a large woman with dark hair and pale skin. she was asleep, but i noticed a faint movement of her face. i could sense she was awake. i got up and walked over to her. \\n \" hello miss. i am inspector michael o\\'dell ; we are investigating the case against you. i wanted to ask if you were the'},\n",
|
||||
" {'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw i had an empty table and three empty chairs. that was all i needed. i had left a note on a table in the center of the room and had a pen in hand. \" \\n \" i think what you were doing was something he was doing to her. \" \\n \" yeah, \" i nodded with a grin. \" i'}]"
|
||||
]
|
||||
},
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"prompt = \"It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw\"\n",
|
||||
"generator(prompt,max_length=100,num_return_sequences=5)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"**束搜索**允許生成器探索多個文本生成的方向（*束*），並選擇總分較高的方向。您可以通過提供 `num_beams` 參數來進行束搜索。您還可以指定 `no_repeat_ngram_size`，以懲罰模型重複給定大小的 n-gram：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[{'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw a man sitting in a chair with his head in his hands. he didn\\'t look up as i approached. \\n \" excuse me, sir, \" i said. \" can i help you? \" \\n the man looked up at me. his eyes were red - rimmed and his face was pale, as if he hadn\\'t slept in days'},\n",
|
||||
" {'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw a man sitting at a desk in the middle of the room. he had his back to me, so i couldn\\'t see what he was doing. \" \\n \" what did he look like? \" i asked as i sat down on the bed next to her. \\n she took a deep breath and looked at me with tears in her eyes'},\n",
|
||||
" {'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw a woman sitting on the bed, reading a book. she looked up at me and smiled. \\n \" hi, \" she said. \" can i help you? \" \\n i sat down next to her and looked around the room. the walls were white, and there was a large window in the middle of the wall that looked out on'},\n",
|
||||
" {'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw a man sitting at a table in the middle of the room. he looked up as i walked in, and when he saw me, he got up and walked over to me. \\n \" can i help you? \" he asked as he put his hand on the small of my back and led me to a chair at the other end of'},\n",
|
||||
" {'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw a woman sitting on the edge of her bed, reading a book. she looked up at me and smiled. \\n \" hello, \" she said. \" can i help you? \" \\n i didn\\'t know what to say, so i just sat down in the chair next to the bed and looked at her. her hair was dark brown'}]"
|
||||
]
|
||||
},
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"prompt = \"It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw\"\n",
|
||||
"generator(prompt,max_length=100,num_return_sequences=5,num_beams=10,no_repeat_ngram_size=2)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"**採樣**根據模型返回的概率分佈以非確定性方式選擇下一個詞。您可以使用參數 `do_sample=True` 開啟採樣。您也可以指定 `temperature`，以使模型變得更具或更少確定性。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"[{'generated_text': 'It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw her. she was on the bed, but she looked very different. \\n \" honey, what\\'s the matter? \" i asked. \\n she sat up. \" i can\\'t believe it\\'s real. i\\'ve been dreaming about you for the last two days. \" \\n \" i can\\'t believe it either. i guess that\\'s how'}]"
|
||||
]
|
||||
},
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"prompt = \"It was early evening when I can back from work. I usually work late, but this time it was an exception. When I entered a room, I saw\"\n",
|
||||
"generator(prompt,max_length=100,do_sample=True,temperature=0.8)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們也可以為採樣提供額外的參數：\n",
|
||||
"* `top_k` 指定在使用採樣時需要考慮的詞選項數量。這可以減少在文本中出現奇怪（低概率）詞的可能性。\n",
|
||||
"* `top_p` 與之類似，但我們選擇總概率大於 p 的最可能詞的最小子集。\n",
|
||||
"\n",
|
||||
"可以隨意嘗試加入這些參數進行實驗。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"attachments": {},
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 微調您的模型\n",
|
||||
"\n",
|
||||
"您也可以使用您自己的數據集進行[模型微調](https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/fine-tuning?pivots=programming-language-studio?WT.mc_id=academic-77998-bethanycheum)。這將允許您調整文本的風格，同時保留語言模型的主要部分。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.8.12 ('py38')",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.10.11"
|
||||
},
|
||||
"orig_nbformat": 4,
|
||||
"coopTranslator": {
|
||||
"original_hash": "d4ff89615d38924a55594f16d6d20678",
|
||||
"translation_date": "2025-08-31T10:43:49+00:00",
|
||||
"source_file": "lessons/5-NLP/20-LangModels/GPT-PyTorch.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
# 預訓練大型語言模型
|
||||
|
||||
在之前的所有任務中，我們都使用標註數據集訓練神經網絡來完成特定任務。而對於像 BERT 這樣的大型 Transformer 模型，我們使用自監督的方式進行語言建模，建立一個語言模型，然後通過進一步的特定領域訓練使其專門化以完成特定的下游任務。然而，研究表明，大型語言模型也能在完全沒有任何特定領域訓練的情況下解決許多任務。能夠做到這一點的一系列模型被稱為 **GPT**：生成式預訓練 Transformer。
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/39)
|
||||
|
||||
## 文本生成與困惑度
|
||||
|
||||
神經網絡能夠在沒有下游訓練的情況下完成一般任務的概念在 [Language Models are Unsupervised Multitask Learners](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) 論文中提出。其核心思想是許多其他任務可以通過 **文本生成** 來建模，因為理解文本本質上意味著能夠生成文本。由於模型訓練於包含人類知識的大量文本，它也因此對各種主題有一定的了解。
|
||||
|
||||
> 理解並能夠生成文本也意味著對周圍世界有一定的認知。人類在很大程度上也是通過閱讀來學習，而 GPT 網絡在這方面與人類相似。
|
||||
|
||||
文本生成網絡通過預測下一個詞的概率 $$P(w_N)$$ 來工作。然而，下一個詞的無條件概率等於該詞在文本語料庫中的出現頻率。GPT 能夠給出基於前幾個詞的 **條件概率**：$$P(w_N | w_{n-1}, ..., w_0)$$
|
||||
|
||||
> 您可以在我們的 [Data Science for Beginners Curriculum](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/1-Introduction/04-stats-and-probability) 中了解更多關於概率的內容。
|
||||
|
||||
語言生成模型的質量可以通過 **困惑度** 來定義。這是一種內在的度量方法，允許我們在沒有任何特定任務數據集的情況下衡量模型的質量。它基於 *句子的概率* 概念——模型對可能是真實的句子賦予高概率（即模型對其不感到 **困惑**），而對那些不太合理的句子（例如 *Can it does what?*）賦予低概率。當我們給模型提供來自真實文本語料庫的句子時，我們期望它們具有高概率和低 **困惑度**。數學上，困惑度定義為測試集的歸一化逆概率：
|
||||
$$
|
||||
\mathrm{Perplexity}(W) = \sqrt[N]{1\over P(W_1,...,W_N)}
|
||||
$$
|
||||
|
||||
**您可以使用 [Hugging Face 的 GPT 驅動文本編輯器](https://transformer.huggingface.co/doc/gpt2-large) 來試驗文本生成**。在這個編輯器中，您開始撰寫文本，按下 **[TAB]** 鍵後會提供幾個完成選項。如果選項太短或您不滿意，可以再次按下 [TAB] 鍵，您將獲得更多選項，包括更長的文本片段。
|
||||
|
||||
## GPT 是一個家族
|
||||
|
||||
GPT 不是單一模型，而是一系列由 [OpenAI](https://openai.com) 開發和訓練的模型。
|
||||
|
||||
在 GPT 模型家族中，我們有：
|
||||
|
||||
| [GPT-2](https://huggingface.co/docs/transformers/model_doc/gpt2#openai-gpt2) | [GPT-3](https://openai.com/research/language-models-are-few-shot-learners) | [GPT-4](https://openai.com/gpt-4) |
|
||||
| -- | -- | -- |
|
||||
|語言模型，擁有最多 15 億個參數。| 語言模型，擁有最多 175 億個參數。| 擁有 100 萬億參數，接受圖像和文本輸入並輸出文本。|
|
||||
|
||||
GPT-3 和 GPT-4 模型可通過 [Microsoft Azure 的認知服務](https://azure.microsoft.com/en-us/services/cognitive-services/openai-service/#overview?WT.mc_id=academic-77998-cacaste) 和 [OpenAI API](https://openai.com/api/) 使用。
|
||||
|
||||
## 提示工程
|
||||
|
||||
由於 GPT 已經在大量數據上進行訓練以理解語言和代碼，它能根據輸入（提示）生成輸出。提示是 GPT 的輸入或查詢，通過提示提供指令讓模型完成下一步任務。為了獲得期望的結果，您需要最有效的提示，這涉及選擇合適的詞語、格式、短語甚至符號。這種方法被稱為 [提示工程](https://learn.microsoft.com/en-us/shows/ai-show/the-basics-of-prompt-engineering-with-azure-openai-service?WT.mc_id=academic-77998-bethanycheum)。
|
||||
|
||||
[此文檔](https://learn.microsoft.com/en-us/semantic-kernel/prompt-engineering/?WT.mc_id=academic-77998-bethanycheum) 提供了更多關於提示工程的信息。
|
||||
|
||||
## ✍️ 示例筆記本: [Playing with OpenAI-GPT](GPT-PyTorch.ipynb)
|
||||
|
||||
繼續學習以下筆記本：
|
||||
|
||||
* [使用 OpenAI-GPT 和 Hugging Face Transformers 生成文本](GPT-PyTorch.ipynb)
|
||||
|
||||
## 結論
|
||||
|
||||
新的通用預訓練語言模型不僅能建模語言結構，還包含大量自然語言知識。因此，它們可以在零樣本或少樣本設置中有效地解決一些 NLP 任務。
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/40)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
# 自然語言處理
|
||||
|
||||
|
||||
|
||||
在本章節中，我們將專注於使用神經網絡來處理與**自然語言處理 (NLP)**相關的任務。我們希望電腦能夠解決許多NLP問題：
|
||||
|
||||
* **文本分類**是一種典型的分類問題，針對文本序列進行分類。例如，將電子郵件分類為垃圾郵件或非垃圾郵件，或者將文章分類為體育、商業、政治等。此外，在開發聊天機器人時，我們通常需要理解使用者的意圖——這就是所謂的**意圖分類**。意圖分類通常需要處理多個類別。
|
||||
* **情感分析**是一種典型的回歸問題，我們需要為句子的正面/負面情感賦予一個數值。一種更高級的情感分析是**基於方面的情感分析** (ABSA)，它不是為整個句子賦予情感，而是為句子的不同部分（方面）賦予情感，例如：*在這家餐廳，我喜歡菜餚，但氛圍很糟糕*。
|
||||
* **命名實體識別** (NER) 是指從文本中提取特定實體的問題。例如，我們需要理解在句子*我明天要飛往巴黎*中，*明天*指的是日期，*巴黎*是地點。
|
||||
* **關鍵字提取**類似於NER，但我們需要自動提取對句子含義重要的詞語，而不需要針對特定實體類型進行預訓練。
|
||||
* **文本聚類**在需要將相似的句子分組時非常有用，例如技術支持對話中的相似請求。
|
||||
* **問答**是指模型回答特定問題的能力。模型接收一段文本和一個問題作為輸入，並需要提供文本中包含答案的位置（有時需要生成答案文本）。
|
||||
* **文本生成**是指模型生成新文本的能力。它可以被視為一種分類任務，根據某些*文本提示*預測下一個字母/單詞。高級文本生成模型，例如GPT-3，能夠通過使用[提示編程](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0)或[提示工程](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29)技術來解決其他NLP任務，例如分類。
|
||||
* **文本摘要**是一種技術，當我們希望電腦“閱讀”長文本並用幾句話進行摘要時使用。
|
||||
* **機器翻譯**可以被視為一種結合一種語言的文本理解和另一種語言的文本生成的技術。
|
||||
|
||||
最初，大多數NLP任務是使用傳統方法（例如語法）來解決的。例如，在機器翻譯中，解析器被用來將初始句子轉換為語法樹，然後提取高層語義結構以表示句子的含義，基於這些含義和目標語言的語法生成結果。如今，許多NLP任務使用神經網絡更有效地解決。
|
||||
|
||||
> 許多經典的NLP方法已在[自然語言處理工具包 (NLTK)](https://www.nltk.org) Python庫中實現。線上有一本很棒的[NLTK書籍](https://www.nltk.org/book/)，涵蓋了如何使用NLTK解決不同的NLP任務。
|
||||
|
||||
在我們的課程中，我們將主要專注於使用神經網絡進行NLP，並在需要時使用NLTK。
|
||||
|
||||
我們已經學習了如何使用神經網絡處理表格數據和圖像。這些數據類型與文本的主要區別在於，文本是一種可變長度的序列，而圖像的輸入大小是事先已知的。雖然卷積網絡可以從輸入數據中提取模式，但文本中的模式更為複雜。例如，否定可能與主語分隔許多詞語（例如：*我不喜歡橙子*，與*我不喜歡那些又大又多彩又美味的橙子*），但仍應被解釋為一個模式。因此，為了處理語言，我們需要引入新的神經網絡類型，例如*循環網絡*和*Transformer*。
|
||||
|
||||
## 安裝庫
|
||||
|
||||
如果您使用本地Python環境運行本課程，可能需要使用以下命令安裝所有NLP所需的庫：
|
||||
|
||||
**PyTorch**
|
||||
```bash
|
||||
pip install -r requirements-torch.txt
|
||||
```
|
||||
**TensorFlow**
|
||||
```bash
|
||||
pip install -r requirements-tf.txt
|
||||
```
|
||||
|
||||
> 您可以在[Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste)上嘗試使用TensorFlow進行NLP。
|
||||
|
||||
## GPU警告
|
||||
|
||||
在本章節中，我們的一些範例將訓練相當大的模型。
|
||||
* **使用支持GPU的電腦**：建議在支持GPU的電腦上運行您的筆記本，以減少處理大型模型時的等待時間。
|
||||
* **GPU記憶體限制**：使用GPU可能會導致GPU記憶體不足的情況，特別是在訓練大型模型時。
|
||||
* **GPU記憶體消耗**：訓練過程中GPU記憶體的消耗取決於多種因素，包括小批量大小。
|
||||
* **減少小批量大小**：如果遇到GPU記憶體問題，可以考慮減少代碼中的小批量大小作為解決方案。
|
||||
* **TensorFlow GPU記憶體釋放**：舊版本的TensorFlow可能無法正確釋放GPU記憶體，特別是在一個Python內核中訓練多個模型時。為了有效管理GPU記憶體使用，您可以配置TensorFlow僅在需要時分配GPU記憶體。
|
||||
* **代碼包含**：要設置TensorFlow僅在需要時增長GPU記憶體分配，請在您的筆記本中包含以下代碼：
|
||||
|
||||
```python
|
||||
physical_devices = tf.config.list_physical_devices('GPU')
|
||||
if len(physical_devices)>0:
|
||||
tf.config.experimental.set_memory_growth(physical_devices[0], True)
|
||||
```
|
||||
|
||||
如果您對從經典機器學習角度學習NLP感興趣，請訪問[這套課程](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)。
|
||||
|
||||
## 本章節內容
|
||||
在本章節中，我們將學習：
|
||||
|
||||
* [將文本表示為張量](13-TextRep/README.md)
|
||||
* [詞嵌入](14-Emdeddings/README.md)
|
||||
* [語言建模](15-LanguageModeling/README.md)
|
||||
* [循環神經網絡](16-RNN/README.md)
|
||||
* [生成式網絡](17-GenerativeNetworks/README.md)
|
||||
* [Transformer](18-Transformers/README.md)
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 作業：丟番圖方程\n",
|
||||
"\n",
|
||||
"> 此作業是 [AI for Beginners Curriculum](http://github.com/microsoft/ai-for-beginners) 的一部分，靈感來自於[這篇文章](https://habr.com/post/128704/)。\n",
|
||||
"\n",
|
||||
"你的目標是解決所謂的 **丟番圖方程**——一種具有整數根和整數係數的方程。例如，考慮以下方程：\n",
|
||||
"\n",
|
||||
"$$a+2b+3c+4d=30$$\n",
|
||||
"\n",
|
||||
"你需要找到整數根 $a$，$b$，$c$，$d\\in\\mathbb{N}$，使其滿足此方程。\n",
|
||||
"\n",
|
||||
"提示：\n",
|
||||
"1. 你可以考慮根值在 [0;30] 的範圍內\n",
|
||||
"1. 作為基因，可以考慮使用根值的列表\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件已使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。儘管我們致力於提供準確的翻譯，請注意自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵資訊，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋不承擔責任。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"language_info": {
|
||||
"name": "python"
|
||||
},
|
||||
"orig_nbformat": 4,
|
||||
"coopTranslator": {
|
||||
"original_hash": "a967e1fa1e11ab2b6467b19349a4a9aa",
|
||||
"translation_date": "2025-08-31T09:21:09+00:00",
|
||||
"source_file": "lessons/6-Other/21-GeneticAlgorithms/Diophantine.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,81 @@
|
|||
# 遺傳演算法
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/41)
|
||||
|
||||
**遺傳演算法**（Genetic Algorithms, GA）基於一種**進化式方法**來解決人工智慧問題，通過模擬種群的進化過程來尋找給定問題的最佳解。該方法由[約翰·亨利·霍蘭德](https://wikipedia.org/wiki/John_Henry_Holland)於1975年提出。
|
||||
|
||||
遺傳演算法的核心思想包括以下幾點：
|
||||
|
||||
* 問題的有效解可以用**基因**來表示
|
||||
* **交叉**（Crossover）允許我們將兩個解結合起來，生成一個新的有效解
|
||||
* **選擇**（Selection）通過某種**適應度函數**來選擇更優的解
|
||||
* **突變**（Mutation）用於打破局部最小值的限制，幫助優化過程跳出局部最優解
|
||||
|
||||
如果你想實現一個遺傳演算法，需要以下幾個步驟：
|
||||
|
||||
* 找到一種方法，使用**基因** g∈Γ 來編碼問題的解
|
||||
* 在基因集合 Γ 上定義**適應度函數** fit: Γ→**R**，函數值越小表示解越優
|
||||
* 定義**交叉**機制，用於結合兩個基因生成新解 crossover: Γ²→Γ
|
||||
* 定義**突變**機制 mutate: Γ→Γ
|
||||
|
||||
在許多情況下，交叉和突變的實現通常是對基因作為數字序列或位向量進行簡單操作的算法。
|
||||
|
||||
遺傳演算法的具體實現可能因情境而異，但其整體結構如下：
|
||||
|
||||
1. 選擇初始種群 G⊆Γ
|
||||
2. 隨機選擇本步驟將執行的操作：交叉或突變
|
||||
3. **交叉**：
|
||||
* 隨機選擇兩個基因 g₁, g₂ ∈ G
|
||||
* 計算交叉結果 g=crossover(g₁, g₂)
|
||||
* 如果 fit(g)<fit(g₁) 或 fit(g)<fit(g₂)，則用 g 替換種群中的相應基因
|
||||
4. **突變**：隨機選擇一個基因 g∈G，並用 mutate(g) 替換它
|
||||
5. 重複步驟2，直到獲得足夠小的適應度值，或者達到步驟數限制
|
||||
|
||||
## 常見任務
|
||||
|
||||
遺傳演算法通常用於解決以下任務：
|
||||
|
||||
1. 排程優化
|
||||
2. 最佳裝箱問題
|
||||
3. 最佳切割問題
|
||||
4. 加速窮舉搜索
|
||||
|
||||
## ✍️ 練習：遺傳演算法
|
||||
|
||||
通過以下筆記本繼續學習：
|
||||
|
||||
前往[這個筆記本](Genetic.ipynb)，查看使用遺傳演算法的兩個例子：
|
||||
|
||||
1. 公平分配寶藏
|
||||
2. 八皇后問題
|
||||
|
||||
## 總結
|
||||
|
||||
遺傳演算法被用於解決許多問題，包括物流和搜索問題。這一領域的靈感來自於心理學和計算機科學的交叉研究。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
「遺傳演算法易於實現，但其行為難以理解。」[來源](https://wikipedia.org/wiki/Genetic_algorithm)
|
||||
進行一些研究，找到一個遺傳演算法的實現（例如解數獨問題），並用草圖或流程圖解釋其工作原理。
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/42)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
觀看[這個精彩的影片](https://www.youtube.com/watch?v=qv6UVOQ0F44)，了解計算機如何通過使用遺傳演算法訓練的神經網絡學習玩《超級瑪利歐》。我們將在[下一節](../22-DeepRL/README.md)中學習更多關於計算機學習玩遊戲的內容。
|
||||
|
||||
## [作業：丟番圖方程](Diophantine.ipynb)
|
||||
|
||||
你的目標是解決所謂的**丟番圖方程**——一種具有整數根的方程。例如，考慮方程 a+2b+3c+4d=30，你需要找到滿足該方程的整數根。
|
||||
|
||||
*此作業靈感來自[這篇文章](https://habr.com/post/128704/)。*
|
||||
|
||||
提示：
|
||||
|
||||
1. 你可以考慮根的範圍為 [0;30]
|
||||
2. 作為基因，可以考慮使用根值的列表
|
||||
|
||||
使用 [Diophantine.ipynb](Diophantine.ipynb) 作為起點。
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,501 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 使用強化學習訓練模型平衡擺桿\n",
|
||||
"\n",
|
||||
"此筆記本是 [AI for Beginners Curriculum](http://aka.ms/ai-beginners) 的一部分，靈感來自 [官方 PyTorch 教學](https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html) 和 [這個 Cartpole PyTorch 實現](https://github.com/yc930401/Actor-Critic-pytorch)。\n",
|
||||
"\n",
|
||||
"在這個範例中，我們將使用強化學習（RL）訓練一個模型，使其能夠在水平軌道上移動的推車上平衡一根擺桿。我們將使用 [OpenAI Gym](https://www.gymlibrary.ml/) 環境來模擬擺桿。\n",
|
||||
"\n",
|
||||
"> **注意**：您可以在本地執行本課程的程式碼（例如，使用 Visual Studio Code），此時模擬將在新視窗中開啟。如果您在線上執行程式碼，可能需要對程式碼進行一些調整，如 [此處](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7) 所述。\n",
|
||||
"\n",
|
||||
"我們將從確保 Gym 已安裝開始：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import sys\n",
|
||||
"!{sys.executable} -m pip install gym"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在讓我們建立 CartPole 環境，並了解如何操作它。一個環境具有以下特性：\n",
|
||||
"\n",
|
||||
"* **動作空間** 是我們在模擬的每一步中可以執行的所有可能動作的集合 \n",
|
||||
"* **觀察空間** 是我們可以進行觀察的所有可能觀察的集合 \n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import gym\n",
|
||||
"\n",
|
||||
"env = gym.make(\"CartPole-v1\")\n",
|
||||
"\n",
|
||||
"print(f\"Action space: {env.action_space}\")\n",
|
||||
"print(f\"Observation space: {env.observation_space}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"讓我們看看模擬如何運作。以下的迴圈會執行模擬，直到 `env.step` 不再返回終止標誌 `done`。我們將使用 `env.action_space.sample()` 隨機選擇動作，這意味著實驗可能會非常快地失敗（當小車的速度、位置或角度超出某些限制時，CartPole 環境會終止）。\n",
|
||||
"\n",
|
||||
"> 模擬將在新視窗中開啟。你可以多次執行程式碼，觀察其行為。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"env.reset()\n",
|
||||
"\n",
|
||||
"done = False\n",
|
||||
"total_reward = 0\n",
|
||||
"while not done:\n",
|
||||
" env.render()\n",
|
||||
" obs, rew, done, info = env.step(env.action_space.sample())\n",
|
||||
" total_reward += rew\n",
|
||||
" print(f\"{obs} -> {rew}\")\n",
|
||||
"print(f\"Total reward: {total_reward}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"你可以注意到觀測值包含4個數字。它們分別是：\n",
|
||||
"- 小車的位置\n",
|
||||
"- 小車的速度\n",
|
||||
"- 桿子的角度\n",
|
||||
"- 桿子的旋轉速率\n",
|
||||
"\n",
|
||||
"`rew` 是我們在每一步獲得的獎勵。在 CartPole 環境中，每模擬一步你會獲得1分，目標是最大化總獎勵，也就是讓小車平衡桿子不倒的時間越長越好。\n",
|
||||
"\n",
|
||||
"在強化學習中，我們的目標是訓練一個**策略** $\\pi$，對於每個狀態 $s$，它會告訴我們應該採取的動作 $a$，也就是 $a = \\pi(s)$。\n",
|
||||
"\n",
|
||||
"如果你想要一個概率性的解法，可以將策略視為為每個動作返回一組概率，也就是 $\\pi(a|s)$ 表示在狀態 $s$ 下採取動作 $a$ 的概率。\n",
|
||||
"\n",
|
||||
"## 策略梯度方法\n",
|
||||
"\n",
|
||||
"在最簡單的強化學習算法中，稱為**策略梯度**，我們將訓練一個神經網絡來預測下一個動作。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import numpy as np\n",
|
||||
"import matplotlib.pyplot as plt\n",
|
||||
"import torch\n",
|
||||
"\n",
|
||||
"num_inputs = 4\n",
|
||||
"num_actions = 2\n",
|
||||
"\n",
|
||||
"model = torch.nn.Sequential(\n",
|
||||
" torch.nn.Linear(num_inputs, 128, bias=False, dtype=torch.float32),\n",
|
||||
" torch.nn.ReLU(),\n",
|
||||
" torch.nn.Linear(128, num_actions, bias = False, dtype=torch.float32),\n",
|
||||
" torch.nn.Softmax(dim=1)\n",
|
||||
")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們將通過運行多次實驗來訓練網絡，並在每次運行後更新我們的網絡。讓我們定義一個函數來運行實驗並返回結果（所謂的**追蹤**）——所有狀態、行動（及其推薦的概率）和獎勵：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def run_episode(max_steps_per_episode = 10000,render=False): \n",
|
||||
" states, actions, probs, rewards = [],[],[],[]\n",
|
||||
" state = env.reset()\n",
|
||||
" for _ in range(max_steps_per_episode):\n",
|
||||
" if render:\n",
|
||||
" env.render()\n",
|
||||
" action_probs = model(torch.from_numpy(np.expand_dims(state,0)))[0]\n",
|
||||
" action = np.random.choice(num_actions, p=np.squeeze(action_probs.detach().numpy()))\n",
|
||||
" nstate, reward, done, info = env.step(action)\n",
|
||||
" if done:\n",
|
||||
" break\n",
|
||||
" states.append(state)\n",
|
||||
" actions.append(action)\n",
|
||||
" probs.append(action_probs.detach().numpy())\n",
|
||||
" rewards.append(reward)\n",
|
||||
" state = nstate\n",
|
||||
" return np.vstack(states), np.vstack(actions), np.vstack(probs), np.vstack(rewards)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"您可以使用未訓練的網絡運行一個情節，並觀察到總回報（即情節的長度）非常低：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"s, a, p, r = run_episode()\n",
|
||||
"print(f\"Total reward: {np.sum(r)}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"政策梯度演算法的一個棘手方面是使用**折扣回報**。其想法是，我們在遊戲的每一步計算總回報的向量，並在此過程中使用某個係數 $gamma$ 折扣早期的回報。我們還會對結果向量進行標準化，因為我們將使用它作為權重來影響我們的訓練：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"eps = 0.0001\n",
|
||||
"\n",
|
||||
"def discounted_rewards(rewards,gamma=0.99,normalize=True):\n",
|
||||
" ret = []\n",
|
||||
" s = 0\n",
|
||||
" for r in rewards[::-1]:\n",
|
||||
" s = r + gamma * s\n",
|
||||
" ret.insert(0, s)\n",
|
||||
" if normalize:\n",
|
||||
" ret = (ret-np.mean(ret))/(np.std(ret)+eps)\n",
|
||||
" return ret"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在讓我們開始實際的訓練！我們將運行 300 次實驗，每次實驗中我們將執行以下步驟：\n",
|
||||
"\n",
|
||||
"1. 執行實驗並收集追蹤數據\n",
|
||||
"2. 計算所採取行動與預測機率之間的差異（`gradients`）。差異越小，表示我們越確定採取了正確的行動。\n",
|
||||
"3. 計算折扣後的回報，並將梯度乘以折扣後的回報——這樣可以確保高回報的步驟對最終結果的影響比低回報的步驟更大。\n",
|
||||
"4. 我們的神經網路的預期目標行動部分來自運行期間的預測機率，部分來自計算出的梯度。我們將使用 `alpha` 參數來決定梯度和回報在多大程度上被考慮——這被稱為強化學習算法的*學習率*。\n",
|
||||
"5. 最後，我們基於狀態和預期行動訓練我們的網路，並重複這個過程。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
|
||||
"\n",
|
||||
"def train_on_batch(x, y):\n",
|
||||
" x = torch.from_numpy(x)\n",
|
||||
" y = torch.from_numpy(y)\n",
|
||||
" optimizer.zero_grad()\n",
|
||||
" predictions = model(x)\n",
|
||||
" loss = -torch.mean(torch.log(predictions) * y)\n",
|
||||
" loss.backward()\n",
|
||||
" optimizer.step()\n",
|
||||
" return loss"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"alpha = 1e-4\n",
|
||||
"\n",
|
||||
"history = []\n",
|
||||
"for epoch in range(300):\n",
|
||||
" states, actions, probs, rewards = run_episode()\n",
|
||||
" one_hot_actions = np.eye(2)[actions.T][0]\n",
|
||||
" gradients = one_hot_actions-probs\n",
|
||||
" dr = discounted_rewards(rewards)\n",
|
||||
" gradients *= dr\n",
|
||||
" target = alpha*np.vstack([gradients])+probs\n",
|
||||
" train_on_batch(states,target)\n",
|
||||
" history.append(np.sum(rewards))\n",
|
||||
" if epoch%100==0:\n",
|
||||
" print(f\"{epoch} -> {np.sum(rewards)}\")\n",
|
||||
"\n",
|
||||
"plt.plot(history)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在讓我們運行帶有渲染的劇集來查看結果：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"_ = run_episode(render=True)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"希望你能看到，現在杆子可以平衡得相當不錯了！\n",
|
||||
"\n",
|
||||
"## Actor-Critic 模型\n",
|
||||
"\n",
|
||||
"Actor-Critic 模型是策略梯度的進一步發展，在這個模型中，我們構建了一個神經網絡來同時學習策略和估算的回報。這個網絡將有兩個輸出（或者你可以將其視為兩個獨立的網絡）：\n",
|
||||
"* **Actor** 將通過提供狀態概率分佈來推薦採取的行動，就像在策略梯度模型中一樣。\n",
|
||||
"* **Critic** 則會估算這些行動可能帶來的回報。它會在給定的狀態下返回未來的總估算回報。\n",
|
||||
"\n",
|
||||
"讓我們定義這樣一個模型：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"from itertools import count\n",
|
||||
"import torch.nn.functional as F"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
|
||||
"env = gym.make(\"CartPole-v1\")\n",
|
||||
"\n",
|
||||
"state_size = env.observation_space.shape[0]\n",
|
||||
"action_size = env.action_space.n\n",
|
||||
"lr = 0.0001\n",
|
||||
"\n",
|
||||
"class Actor(torch.nn.Module):\n",
|
||||
" def __init__(self, state_size, action_size):\n",
|
||||
" super(Actor, self).__init__()\n",
|
||||
" self.state_size = state_size\n",
|
||||
" self.action_size = action_size\n",
|
||||
" self.linear1 = torch.nn.Linear(self.state_size, 128)\n",
|
||||
" self.linear2 = torch.nn.Linear(128, 256)\n",
|
||||
" self.linear3 = torch.nn.Linear(256, self.action_size)\n",
|
||||
"\n",
|
||||
" def forward(self, state):\n",
|
||||
" output = F.relu(self.linear1(state))\n",
|
||||
" output = F.relu(self.linear2(output))\n",
|
||||
" output = self.linear3(output)\n",
|
||||
" distribution = torch.distributions.Categorical(F.softmax(output, dim=-1))\n",
|
||||
" return distribution\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"class Critic(torch.nn.Module):\n",
|
||||
" def __init__(self, state_size, action_size):\n",
|
||||
" super(Critic, self).__init__()\n",
|
||||
" self.state_size = state_size\n",
|
||||
" self.action_size = action_size\n",
|
||||
" self.linear1 = torch.nn.Linear(self.state_size, 128)\n",
|
||||
" self.linear2 = torch.nn.Linear(128, 256)\n",
|
||||
" self.linear3 = torch.nn.Linear(256, 1)\n",
|
||||
"\n",
|
||||
" def forward(self, state):\n",
|
||||
" output = F.relu(self.linear1(state))\n",
|
||||
" output = F.relu(self.linear2(output))\n",
|
||||
" value = self.linear3(output)\n",
|
||||
" return value"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"我們需要稍微修改我們的 `discounted_rewards` 和 `run_episode` 函數：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def discounted_rewards(next_value, rewards, masks, gamma=0.99):\n",
|
||||
" R = next_value\n",
|
||||
" returns = []\n",
|
||||
" for step in reversed(range(len(rewards))):\n",
|
||||
" R = rewards[step] + gamma * R * masks[step]\n",
|
||||
" returns.insert(0, R)\n",
|
||||
" return returns\n",
|
||||
"\n",
|
||||
"def run_episode(actor, critic, n_iters):\n",
|
||||
" optimizerA = torch.optim.Adam(actor.parameters())\n",
|
||||
" optimizerC = torch.optim.Adam(critic.parameters())\n",
|
||||
" for iter in range(n_iters):\n",
|
||||
" state = env.reset()\n",
|
||||
" log_probs = []\n",
|
||||
" values = []\n",
|
||||
" rewards = []\n",
|
||||
" masks = []\n",
|
||||
" entropy = 0\n",
|
||||
" env.reset()\n",
|
||||
"\n",
|
||||
" for i in count():\n",
|
||||
" env.render()\n",
|
||||
" state = torch.FloatTensor(state).to(device)\n",
|
||||
" dist, value = actor(state), critic(state)\n",
|
||||
"\n",
|
||||
" action = dist.sample()\n",
|
||||
" next_state, reward, done, _ = env.step(action.cpu().numpy())\n",
|
||||
"\n",
|
||||
" log_prob = dist.log_prob(action).unsqueeze(0)\n",
|
||||
" entropy += dist.entropy().mean()\n",
|
||||
"\n",
|
||||
" log_probs.append(log_prob)\n",
|
||||
" values.append(value)\n",
|
||||
" rewards.append(torch.tensor([reward], dtype=torch.float, device=device))\n",
|
||||
" masks.append(torch.tensor([1-done], dtype=torch.float, device=device))\n",
|
||||
"\n",
|
||||
" state = next_state\n",
|
||||
"\n",
|
||||
" if done:\n",
|
||||
" print('Iteration: {}, Score: {}'.format(iter, i))\n",
|
||||
" break\n",
|
||||
"\n",
|
||||
"\n",
|
||||
" next_state = torch.FloatTensor(next_state).to(device)\n",
|
||||
" next_value = critic(next_state)\n",
|
||||
" returns = discounted_rewards(next_value, rewards, masks)\n",
|
||||
"\n",
|
||||
" log_probs = torch.cat(log_probs)\n",
|
||||
" returns = torch.cat(returns).detach()\n",
|
||||
" values = torch.cat(values)\n",
|
||||
"\n",
|
||||
" advantage = returns - values\n",
|
||||
"\n",
|
||||
" actor_loss = -(log_probs * advantage.detach()).mean()\n",
|
||||
" critic_loss = advantage.pow(2).mean()\n",
|
||||
"\n",
|
||||
" optimizerA.zero_grad()\n",
|
||||
" optimizerC.zero_grad()\n",
|
||||
" actor_loss.backward()\n",
|
||||
" critic_loss.backward()\n",
|
||||
" optimizerA.step()\n",
|
||||
" optimizerC.step()\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"現在我們將運行主要的訓練循環。我們將通過計算適當的損失函數並更新網絡參數來使用手動網絡訓練過程：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"\n",
|
||||
"actor = Actor(state_size, action_size).to(device)\n",
|
||||
"critic = Critic(state_size, action_size).to(device)\n",
|
||||
"run_episode(actor, critic, n_iters=100)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"env.close()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 重點\n",
|
||||
"\n",
|
||||
"在這次示範中，我們看到了兩種強化學習演算法：簡單的策略梯度和更複雜的演員-評論者方法。可以看到這些演算法使用抽象的狀態、行動和獎勵概念進行操作，因此它們可以應用於非常不同的環境。\n",
|
||||
"\n",
|
||||
"強化學習讓我們僅透過觀察最終的獎勵來學習解決問題的最佳策略。不需要標註的數據集使我們能夠多次重複模擬以優化模型。然而，強化學習仍然存在許多挑戰，如果你決定深入研究這個有趣的人工智慧領域，可能會學到更多相關知識。\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件已使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。儘管我們致力於提供準確的翻譯，請注意自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵資訊，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋不承擔責任。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.10.4 64-bit",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.10.4"
|
||||
},
|
||||
"orig_nbformat": 4,
|
||||
"vscode": {
|
||||
"interpreter": {
|
||||
"hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
|
||||
}
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "04f8d9978cd11281d81dd037cbf6ce20",
|
||||
"translation_date": "2025-08-31T09:25:35+00:00",
|
||||
"source_file": "lessons/6-Other/22-DeepRL/CartPole-RL-PyTorch.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,117 @@
|
|||
# 深度強化學習
|
||||
|
||||
強化學習（RL）被視為機器學習的基本範式之一，與監督學習和非監督學習並列。在監督學習中，我們依賴具有已知結果的數據集，而強化學習則基於**透過行動來學習**。例如，當我們第一次看到一款電腦遊戲時，即使不知道規則，我們也會開始玩，並且很快能透過遊玩和調整行為來提升技能。
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/43)
|
||||
|
||||
要進行強化學習，我們需要：
|
||||
|
||||
* 一個**環境**或**模擬器**，用來設定遊戲規則。我們應該能在模擬器中運行實驗並觀察結果。
|
||||
* 一些**獎勵函數**，用來指示實驗的成功程度。以學習玩電腦遊戲為例，獎勵可以是我們的最終得分。
|
||||
|
||||
基於獎勵函數，我們應該能調整行為並提升技能，以便下次表現更好。強化學習與其他類型的機器學習的主要區別在於，強化學習通常直到遊戲結束才知道是否贏或輸。因此，我們無法判斷某個單獨的動作是否是好的——只有在遊戲結束時才會收到獎勵。
|
||||
|
||||
在強化學習過程中，我們通常會進行許多實驗。在每次實驗中，我們需要在遵循目前學到的最佳策略（**利用**）和探索新的可能狀態（**探索**）之間取得平衡。
|
||||
|
||||
## OpenAI Gym
|
||||
|
||||
一個非常棒的強化學習工具是 [OpenAI Gym](https://gym.openai.com/)——一個**模擬環境**，可以模擬許多不同的環境，從 Atari 遊戲到物理學中的桿平衡。它是訓練強化學習算法最受歡迎的模擬環境之一，由 [OpenAI](https://openai.com/) 維護。
|
||||
|
||||
> **注意**：你可以在 [這裡](https://gym.openai.com/envs/#classic_control) 查看 OpenAI Gym 提供的所有環境。
|
||||
|
||||
## CartPole 平衡
|
||||
|
||||
你可能都見過現代的平衡裝置，例如 *Segway* 或 *Gyroscooters*。它們能夠透過加速計或陀螺儀的信號自動調整輪子來保持平衡。在本節中，我們將學習如何解決類似的問題——平衡一根桿子。這類似於馬戲團表演者需要在手上平衡桿子的情況——但這裡的桿平衡僅發生在一維空間。
|
||||
|
||||
一個簡化版的平衡問題被稱為 **CartPole** 問題。在 CartPole 世界中，我們有一個可以左右移動的水平滑塊，目標是讓滑塊上的垂直桿保持平衡。
|
||||
|
||||
<img alt="a cartpole" src="../../../../../translated_images/zh-TW/cartpole.f52a67f27e058170.webp" width="200"/>
|
||||
|
||||
要創建並使用這個環境，我們只需要幾行 Python 代碼：
|
||||
|
||||
```python
|
||||
import gym
|
||||
env = gym.make("CartPole-v1")
|
||||
|
||||
env.reset()
|
||||
done = False
|
||||
total_reward = 0
|
||||
while not done:
|
||||
env.render()
|
||||
action = env.action_space.sample()
|
||||
observaton, reward, done, info = env.step(action)
|
||||
total_reward += reward
|
||||
|
||||
print(f"Total reward: {total_reward}")
|
||||
```
|
||||
|
||||
每個環境都可以以相同的方式訪問：
|
||||
* `env.reset` 開始一個新的實驗
|
||||
* `env.step` 執行一個模擬步驟。它接收來自**動作空間**的**動作**，並返回**觀察值**（來自觀察空間）、獎勵以及終止標誌。
|
||||
|
||||
在上面的例子中，我們在每一步執行隨機動作，因此實驗的生命週期非常短：
|
||||
|
||||
|
||||
|
||||
強化學習算法的目標是訓練一個模型——即所謂的**策略** π——它能根據給定的狀態返回動作。我們也可以將策略視為概率性的，例如對於任意狀態 *s* 和動作 *a*，它會返回 π(*a*|*s*) 的概率，表示在狀態 *s* 下應該採取動作 *a*。
|
||||
|
||||
## 策略梯度算法
|
||||
|
||||
建模策略的最明顯方法是創建一個神經網絡，該網絡以狀態作為輸入，並返回相應的動作（或所有動作的概率）。在某種意義上，它類似於普通的分類任務，但有一個主要區別——我們事先並不知道在每一步應該採取哪些動作。
|
||||
|
||||
這裡的想法是估算這些概率。我們構建一個**累積獎勵**向量，顯示實驗中每一步的總獎勵。我們還通過乘以某個係數 γ=0.99 來應用**獎勵折扣**，以減少早期獎勵的影響。然後，我們加強那些在實驗路徑中產生較大獎勵的步驟。
|
||||
|
||||
> 了解更多關於策略梯度算法的內容，並在[示例筆記本](CartPole-RL-TF.ipynb)中查看其實際應用。
|
||||
|
||||
## Actor-Critic 算法
|
||||
|
||||
策略梯度方法的一個改進版本被稱為 **Actor-Critic**。其主要思想是神經網絡將被訓練以返回兩個結果：
|
||||
|
||||
* 策略，決定應採取的動作。這部分被稱為 **actor**
|
||||
* 對當前狀態下可期望獲得的總獎勵的估算——這部分被稱為 **critic**。
|
||||
|
||||
在某種意義上，這種架構類似於 [GAN](../../4-ComputerVision/10-GANs/README.md)，其中有兩個網絡相互對抗訓練。在 Actor-Critic 模型中，actor 提出我們需要採取的動作，而 critic 則進行批判並估算結果。然而，我們的目標是讓這兩個網絡協同訓練。
|
||||
|
||||
由於我們在實驗中知道真實的累積獎勵以及 critic 返回的結果，因此構建一個損失函數來最小化它們之間的差異相對容易。這將給我們**critic 損失**。我們可以使用與策略梯度算法相同的方法計算**actor 損失**。
|
||||
|
||||
運行其中一個算法後，我們可以期望 CartPole 的表現如下：
|
||||
|
||||
|
||||
|
||||
## ✍️ 練習：策略梯度和 Actor-Critic 強化學習
|
||||
|
||||
在以下筆記本中繼續學習：
|
||||
|
||||
* [TensorFlow 中的強化學習](CartPole-RL-TF.ipynb)
|
||||
* [PyTorch 中的強化學習](CartPole-RL-PyTorch.ipynb)
|
||||
|
||||
## 其他強化學習任務
|
||||
|
||||
如今，強化學習是一個快速增長的研究領域。一些有趣的強化學習例子包括：
|
||||
|
||||
* 教電腦玩 **Atari 遊戲**。這個問題的挑戰在於，我們沒有簡單的狀態向量，而是截圖——我們需要使用 CNN 將屏幕圖像轉換為特徵向量，或提取獎勵信息。Atari 遊戲可在 Gym 中使用。
|
||||
* 教電腦玩棋盤遊戲，例如象棋和圍棋。最近，像 **Alpha Zero** 這樣的最先進程序是通過兩個代理相互對弈並在每一步中改進來從零開始訓練的。
|
||||
* 在工業中，強化學習被用於從模擬中創建控制系統。一項名為 [Bonsai](https://azure.microsoft.com/services/project-bonsai/?WT.mc_id=academic-77998-cacaste) 的服務專門為此設計。
|
||||
|
||||
## 結論
|
||||
|
||||
我們現在已經學會如何僅通過提供定義遊戲期望狀態的獎勵函數，並給予代理智能探索搜索空間的機會來訓練代理以取得良好結果。我們成功嘗試了兩種算法，並在相對短的時間內取得了良好的結果。然而，這只是你進入強化學習旅程的開始，如果你想深入研究，應該考慮參加專門的課程。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
探索「其他強化學習任務」部分列出的應用，並嘗試實現其中一個！
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/44)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
在我們的[初學者機器學習課程](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/README.md)中了解更多關於經典強化學習的內容。
|
||||
|
||||
觀看[這段精彩影片](https://www.youtube.com/watch?v=qv6UVOQ0F44)，了解電腦如何學習玩超級瑪利歐。
|
||||
|
||||
## 作業：[訓練一輛山地車](lab/README.md)
|
||||
|
||||
在這次作業中，你的目標是訓練一個不同的 Gym 環境——[山地車](https://www.gymlibrary.ml/environments/classic_control/mountain_car/)。
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# # 訓練山地車逃脫\n",
|
||||
"\n",
|
||||
"來自 [AI for Beginners Curriculum](https://github.com/microsoft/ai-for-beginners) 的實驗作業。\n",
|
||||
"\n",
|
||||
"你的目標是訓練強化學習代理來控制 OpenAI 環境中的 [Mountain Car](https://www.gymlibrary.ml/environments/classic_control/mountain_car/)。\n",
|
||||
"\n",
|
||||
"讓我們從創建環境開始：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import gym\n",
|
||||
"env = gym.make('MountainCar-v0')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"讓我們看看隨機實驗是什麼樣子：\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"state = env.reset()\n",
|
||||
"while True:\n",
|
||||
" env.render()\n",
|
||||
" action = env.action_space.sample()\n",
|
||||
" state, reward, done, info = env.step(action)\n",
|
||||
" if done:\n",
|
||||
" break"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"## Lost of code here"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"env.close()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n---\n\n**免責聲明**： \n本文件已使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。儘管我們努力確保翻譯的準確性，但請注意，自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵信息，建議使用專業人工翻譯。我們對因使用此翻譯而產生的任何誤解或錯誤解釋不承擔責任。\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"interpreter": {
|
||||
"hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
|
||||
},
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3.8.12 ('py38')",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.12"
|
||||
},
|
||||
"coopTranslator": {
|
||||
"original_hash": "f062b3b18449593ef8e0fcc029868781",
|
||||
"translation_date": "2025-08-31T09:28:48+00:00",
|
||||
"source_file": "lessons/6-Other/22-DeepRL/lab/MountainCar.ipynb",
|
||||
"language_code": "tw"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
## 環境介紹
|
||||
|
||||
Mountain Car 環境是一個汽車被困在山谷中的情境。你的目標是跳出山谷並到達旗幟所在的位置。你可以執行的動作包括向左加速、向右加速或保持不動。你可以觀察汽車在 x 軸上的位置以及速度。
|
||||
|
||||
## 啟動筆記本
|
||||
|
||||
通過打開 [MountainCar.ipynb](../../../../../../lessons/6-Other/22-DeepRL/lab/MountainCar.ipynb) 開始這次實驗。
|
||||
|
||||
## 重點
|
||||
|
||||
在這次實驗中，你應該學到將 RL 演算法應用到新環境通常是相當直接的，因為 OpenAI Gym 的所有環境都具有相同的介面，而演算法本身並不過度依賴環境的特性。你甚至可以重新組織 Python 程式碼，以便將任何環境作為參數傳遞給 RL 演算法。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,155 @@
|
|||
# 多代理系統
|
||||
|
||||
實現智慧的一種可能方法是所謂的**湧現**（或**協同**）方法，這基於以下事實：許多相對簡單的代理的組合行為可以導致整個系統的更複雜（或更智能）的行為。理論上，這基於[集體智慧](https://en.wikipedia.org/wiki/Collective_intelligence)、[湧現主義](https://en.wikipedia.org/wiki/Global_brain)和[進化控制論](https://en.wikipedia.org/wiki/Global_brain)的原則，這些原則指出，當低層系統被適當地組合成高層系統時，會產生某種附加價值（即所謂的*超系統轉換原則*）。
|
||||
|
||||
## [課前測驗](https://ff-quizzes.netlify.app/en/ai/quiz/45)
|
||||
|
||||
**多代理系統**的方向在1990年代因互聯網和分佈式系統的增長而在人工智慧領域中興起。經典的人工智慧教科書之一[《人工智慧：現代方法》](https://en.wikipedia.org/wiki/Artificial_Intelligence:_A_Modern_Approach)從多代理系統的角度探討了經典人工智慧的觀點。
|
||||
|
||||
多代理方法的核心是**代理**的概念——一個生活在某個**環境**中的實體，它可以感知並對環境進行操作。這是一個非常廣泛的定義，代理可以有許多不同的類型和分類：
|
||||
|
||||
* 按其推理能力：
|
||||
- **反應型**代理通常具有簡單的請求-響應類型行為
|
||||
- **推理型**代理使用某種邏輯推理和/或規劃能力
|
||||
* 按代理執行代碼的位置：
|
||||
- **靜態**代理在專用的網絡節點上工作
|
||||
- **移動**代理可以在網絡節點之間移動其代碼
|
||||
* 按其行為：
|
||||
- **被動代理**沒有特定目標。這些代理可以對外部刺激作出反應，但不會主動採取行動。
|
||||
- **主動代理**有一些目標需要追求
|
||||
- **認知代理**涉及複雜的規劃和推理
|
||||
|
||||
多代理系統如今被應用於許多領域：
|
||||
|
||||
* 在遊戲中，許多非玩家角色使用某種人工智慧，可以被視為智能代理
|
||||
* 在視頻製作中，渲染涉及人群的複雜3D場景通常使用多代理模擬
|
||||
* 在系統建模中，多代理方法被用於模擬複雜模型的行為。例如，多代理方法已成功用於預測COVID-19疾病在全球的傳播。類似的方法可以用於模擬城市交通，並觀察其對交通規則變化的反應。
|
||||
* 在複雜的自動化系統中，每個設備可以作為獨立的代理，這使得整個系統不那麼單一化並更加穩健。
|
||||
|
||||
我們不會花太多時間深入探討多代理系統，但會考慮一個**多代理建模**的例子。
|
||||
|
||||
## NetLogo
|
||||
|
||||
[NetLogo](https://ccl.northwestern.edu/netlogo/)是一個基於修改版[Logo](https://en.wikipedia.org/wiki/Logo_(programming_language))編程語言的多代理建模環境。這種語言是為了教孩子編程概念而開發的，它允許你控制一個名為**烏龜**的代理，該代理可以移動並留下痕跡。這使得創建複雜的幾何圖形成為可能，這是一種非常直觀的方式來理解代理的行為。
|
||||
|
||||
在NetLogo中，我們可以使用`create-turtles`命令創建許多烏龜。然後我們可以命令所有烏龜執行一些操作（在下面的例子中——向前移動10個點）：
|
||||
|
||||
```
|
||||
create-turtles 10
|
||||
ask turtles [
|
||||
forward 10
|
||||
]
|
||||
```
|
||||
|
||||
當然，所有烏龜都做同樣的事情並不有趣，因此我們可以`ask`某些烏龜群體，例如那些在某個點附近的烏龜。我們還可以使用`breed [cats cat]`命令創建不同*品種*的烏龜。這裡`cat`是品種的名稱，我們需要指定單數和複數形式，因為不同的命令使用不同的形式以提高清晰度。
|
||||
|
||||
> ✅ 我們不會深入學習NetLogo語言本身——如果你有興趣了解更多，可以訪問出色的[初學者互動NetLogo詞典](https://ccl.northwestern.edu/netlogo/bind/)資源。
|
||||
|
||||
你可以[下載](https://ccl.northwestern.edu/netlogo/download.shtml)並安裝NetLogo來試用。
|
||||
|
||||
### 模型庫
|
||||
|
||||
NetLogo的一大優點是它包含一個可供試用的工作模型庫。進入**File → Models Library**，你可以選擇許多模型類別。
|
||||
|
||||
<img alt="NetLogo模型庫" src="../../../../../translated_images/zh-TW/NetLogo-ModelLib.efe023afb4763c05.webp" width="60%"/>
|
||||
|
||||
> Dmitry Soshnikov提供的模型庫截圖
|
||||
|
||||
你可以打開其中一個模型，例如**Biology → Flocking**。
|
||||
|
||||
### 主要原則
|
||||
|
||||
打開模型後，你會進入NetLogo的主界面。以下是一個描述狼和羊的種群模型，給定有限資源（草地）。
|
||||
|
||||
|
||||
|
||||
> Dmitry Soshnikov提供的截圖
|
||||
|
||||
在這個界面上，你可以看到：
|
||||
|
||||
* **界面**部分包含：
|
||||
- 所有代理生活的主要場地
|
||||
- 不同的控制項：按鈕、滑塊等
|
||||
- 用於顯示模擬參數的圖表
|
||||
* **代碼**標籤包含編輯器，你可以在其中編寫NetLogo程序
|
||||
|
||||
在大多數情況下，界面會有一個**Setup**按鈕，用於初始化模擬狀態，以及一個**Go**按鈕，用於開始執行。這些由代碼中的相應處理程序處理，代碼看起來像這樣：
|
||||
|
||||
```
|
||||
to go [
|
||||
...
|
||||
]
|
||||
```
|
||||
|
||||
NetLogo的世界由以下對象組成：
|
||||
|
||||
* **代理**（烏龜）可以在場地上移動並執行操作。你可以使用`ask turtles [...]`語法命令代理，括號中的代碼由所有代理以*烏龜模式*執行。
|
||||
* **補丁**是場地上的方形區域，代理生活在其上。你可以引用同一補丁上的所有代理，或者更改補丁顏色和其他屬性。你也可以`ask patches`執行操作。
|
||||
* **觀察者**是一個控制世界的唯一代理。所有按鈕處理程序都以*觀察者模式*執行。
|
||||
|
||||
> ✅ 多代理環境的美妙之處在於，烏龜模式或補丁模式下運行的代碼由所有代理並行執行。因此，通過編寫少量代碼並編程個別代理的行為，你可以創建整個模擬系統的複雜行為。
|
||||
|
||||
### 群聚行為
|
||||
|
||||
作為多代理行為的例子，我們來看看**[群聚行為](https://en.wikipedia.org/wiki/Flocking_(behavior))**。群聚是一種複雜的模式，非常類似於鳥群的飛行方式。觀察它們飛行時，你可能會認為它們遵循某種集體算法，或者擁有某種*集體智慧*。然而，這種複雜行為的產生是因為每個個體代理（在這種情況下是一隻*鳥*）只觀察距離它很近的其他代理，並遵循三個簡單的規則：
|
||||
|
||||
* **對齊**——朝鄰近代理的平均方向移動
|
||||
* **凝聚**——試圖朝鄰居的平均位置移動（*長距離吸引*）
|
||||
* **分離**——當與其他鳥靠得太近時，試圖遠離（*短距離排斥*）
|
||||
|
||||
你可以運行群聚行為的例子並觀察其行為。你還可以調整參數，例如*分離程度*或*視距*，這定義了每隻鳥能看到的距離。注意，如果你將視距減少到0，所有鳥都變得盲目，群聚行為停止。如果你將分離減少到0，所有鳥聚集成一條直線。
|
||||
|
||||
> ✅ 切換到**代碼**標籤，查看群聚行為的三個規則（對齊、凝聚和分離）如何在代碼中實現。注意我們如何僅引用那些在視線範圍內的代理。
|
||||
|
||||
### 其他模型
|
||||
|
||||
還有一些有趣的模型可以供你試驗：
|
||||
|
||||
* **Art → Fireworks**展示了如何將煙火視為個別火流的集體行為
|
||||
* **Social Science → Traffic Basic**和**Social Science → Traffic Grid**展示了城市交通在1D和2D網格中有或沒有交通燈的模型。模擬中的每輛車遵循以下規則：
|
||||
- 如果前方空間是空的——加速（直到某個最大速度）
|
||||
- 如果看到前方有障礙物——剎車（你可以調整司機的視距）
|
||||
* **Social Science → Party**展示了人們在雞尾酒會上如何聚集在一起。你可以找到導致群體幸福度最快增長的參數組合。
|
||||
|
||||
從這些例子中可以看出，多代理模擬是一種非常有用的方法，可以理解由遵循相同或相似邏輯的個體組成的複雜系統的行為。它還可以用於控制虛擬代理，例如電腦遊戲中的[NPC](https://en.wikipedia.org/wiki/NPC)，或3D動畫世界中的代理。
|
||||
|
||||
## 推理型代理
|
||||
|
||||
上述代理非常簡單，使用某種算法對環境的變化作出反應。因此，它們是**反應型代理**。然而，有時代理可以進行推理並規劃其行動，在這種情況下，它們被稱為**推理型代理**。
|
||||
|
||||
一個典型的例子是個人代理接收到人類的指令去預訂度假行程。假設互聯網上有許多代理可以幫助它。它應該聯繫其他代理以查看哪些航班可用，不同日期的酒店價格是多少，並嘗試談判最優惠的價格。當度假計劃完成並得到主人確認後，它可以進行預訂。
|
||||
|
||||
為了做到這一點，代理需要**通信**。為了成功通信，它們需要：
|
||||
|
||||
* 一些**交換知識的標準語言**，例如[知識交換格式](https://en.wikipedia.org/wiki/Knowledge_Interchange_Format)（KIF）和[知識查詢與操作語言](https://en.wikipedia.org/wiki/Knowledge_Query_and_Manipulation_Language)（KQML）。這些語言基於[言語行為理論](https://en.wikipedia.org/wiki/Speech_act)設計。
|
||||
* 這些語言還應包括一些**談判協議**，基於不同的**拍賣類型**。
|
||||
* 一個**共同的本體**，以便它們引用相同的概念並了解其語義
|
||||
* 一種**發現**不同代理能做什麼的方法，也基於某種本體
|
||||
|
||||
推理型代理比反應型代理更複雜，因為它們不僅對環境的變化作出反應，還應能夠*主動*採取行動。一種提出的推理型代理架構是所謂的信念-願望-意圖（BDI）代理：
|
||||
|
||||
* **信念**形成了代理對其環境的知識集。它可以結構化為知識庫或代理可以應用於環境中特定情況的一組規則。
|
||||
* **願望**定義了代理想要做什麼，即其目標。例如，上述個人助理代理的目標是預訂行程，而酒店代理的目標是最大化利潤。
|
||||
* **意圖**是代理為實現其目標而計劃的具體行動。行動通常改變環境並導致與其他代理的通信。
|
||||
|
||||
有一些平台可用於構建多代理系統，例如[JADE](https://jade.tilab.com/)。[這篇論文](https://arxiv.org/ftp/arxiv/papers/2007/2007.08961.pdf)包含了多代理平台的回顧，以及多代理系統的簡史及其不同的使用場景。
|
||||
|
||||
## 結論
|
||||
|
||||
多代理系統可以採取非常不同的形式並應用於許多不同的領域。
|
||||
它們都傾向於專注於個別代理的簡單行為，並通過**協同效應**實現整個系統的更複雜行為。
|
||||
|
||||
## 🚀 挑戰
|
||||
|
||||
將這節課的內容應用到現實世界，嘗試構思一個可以解決問題的多代理系統。例如，多代理系統需要做什麼才能優化校車路線？它如何在麵包店中運作？
|
||||
|
||||
## [課後測驗](https://ff-quizzes.netlify.app/en/ai/quiz/46)
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
回顧這類系統在工業中的應用。選擇一個領域，例如製造業或視頻遊戲行業，探索多代理系統如何用於解決獨特的問題。
|
||||
|
||||
## [NetLogo作業](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
# NetLogo 作業
|
||||
|
||||
選擇 NetLogo 資料庫中的一個模型，並使用它來盡可能真實地模擬一個現實生活中的情境。一個不錯的例子是調整「替代視覺化」資料夾中的病毒模型，展示它如何用於模擬 COVID-19 的傳播。你能否建立一個模擬現實生活中病毒傳播的模型？
|
||||
|
||||
透過保存一份副本並製作一個視頻演示，說明該模型如何與現實情境相關聯，來展示你的成果。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。雖然我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於重要資訊，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋不承擔責任。
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
# 倫理與負責任的人工智慧
|
||||
|
||||
你已經快完成這門課程了，希望到目前為止，你已清楚了解人工智慧是基於一系列正式的數學方法，這些方法能幫助我們在資料中找到關聯性，並訓練模型以模仿某些人類行為。在這個歷史時刻，我們認為人工智慧是一個非常強大的工具，可以從資料中提取模式，並應用這些模式來解決新的問題。
|
||||
|
||||
## [課前測驗](https://white-water-09ec41f0f.azurestaticapps.net/quiz/5/)
|
||||
|
||||
然而，在科幻作品中，我們經常看到人工智慧對人類構成威脅的故事。通常這些故事圍繞某種人工智慧的反叛展開，當人工智慧決定與人類對抗時，這暗示人工智慧擁有某種情感或能做出開發者未預見的決策。
|
||||
|
||||
我們在這門課程中學到的人工智慧僅僅是大型矩陣運算。它是一個非常強大的工具，可以幫助我們解決問題，但就像任何其他強大的工具一樣——它既可以用於善，也可以用於惡。重要的是，它可能會被*濫用*。
|
||||
|
||||
## 負責任人工智慧的原則
|
||||
|
||||
為了避免人工智慧的意外或故意濫用，微軟提出了重要的[負責任人工智慧原則](https://www.microsoft.com/ai/responsible-ai?WT.mc_id=academic-77998-cacaste)。以下概念是這些原則的基礎：
|
||||
|
||||
* **公平性**與*模型偏差*這個重要問題相關，模型偏差可能是由於使用了有偏差的訓練資料。例如，當我們試圖預測某人獲得軟體開發工作機會的可能性時，模型可能更偏向男性，僅僅因為訓練資料可能偏向男性群體。我們需要仔細平衡訓練資料並調查模型，以避免偏差，並確保模型考慮到更相關的特徵。
|
||||
* **可靠性與安全性**。人工智慧模型本質上可能會犯錯。一個神經網路返回的是概率，我們需要在做決策時考慮到這一點。每個模型都有一定的精確度和召回率，我們需要理解這些指標，以防止錯誤建議可能造成的傷害。
|
||||
* **隱私與安全性**具有一些人工智慧特定的影響。例如，當我們使用某些資料來訓練模型時，這些資料會以某種方式“整合”到模型中。一方面，這提高了安全性和隱私性，另一方面，我們需要記住模型是基於哪些資料訓練的。
|
||||
* **包容性**意味著我們不是在建造人工智慧來取代人類，而是為了增強人類並使我們的工作更具創造性。這也與公平性相關，因為在處理代表性不足的社群時，我們收集的大多數資料集可能存在偏差，我們需要確保這些社群被納入並正確地由人工智慧處理。
|
||||
* **透明性**。這包括確保我們始終清楚人工智慧的使用。此外，在可能的情況下，我們希望使用*可解釋*的人工智慧系統。
|
||||
* **問責性**。當人工智慧模型做出某些決策時，責任歸屬並不總是清晰的。我們需要確保我們理解人工智慧決策的責任所在。在大多數情況下，我們希望將人類納入重要決策的過程中，以便實際的人承擔責任。
|
||||
|
||||
## 負責任人工智慧的工具
|
||||
|
||||
微軟開發了[負責任人工智慧工具箱](https://github.com/microsoft/responsible-ai-toolbox)，其中包含一系列工具：
|
||||
|
||||
* 可解釋性儀表板 (InterpretML)
|
||||
* 公平性儀表板 (FairLearn)
|
||||
* 錯誤分析儀表板
|
||||
* 負責任人工智慧儀表板，包括：
|
||||
|
||||
- EconML - 用於因果分析的工具，專注於假設性問題
|
||||
- DiCE - 用於反事實分析的工具，幫助您了解需要改變哪些特徵才能影響模型的決策
|
||||
|
||||
如需更多有關人工智慧倫理的資訊，請參閱機器學習課程中的[這一課程](https://github.com/microsoft/ML-For-Beginners/tree/main/1-Introduction/3-fairness?WT.mc_id=academic-77998-cacaste)，其中包括作業。
|
||||
|
||||
## 回顧與自學
|
||||
|
||||
參加這個[學習路徑](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77998-cacaste)，以了解更多有關負責任人工智慧的內容。
|
||||
|
||||
## [課後測驗](https://white-water-09ec41f0f.azurestaticapps.net/quiz/6/)
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
# 概覽
|
||||
|
||||
|
||||
|
||||
> 手繪筆記由 [Tomomi Imura](https://twitter.com/girlie_mac) 提供
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。儘管我們努力確保翻譯的準確性，但請注意，自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵資訊，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋不承擔責任。
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,79 @@
|
|||
# 多模態網絡
|
||||
|
||||
在變壓器模型成功解決 NLP 任務後，相同或類似的架構也被應用於計算機視覺任務。現在越來越多的人對於構建能夠*結合*視覺和自然語言能力的模型產生了興趣。其中一個嘗試是由 OpenAI 完成的，稱為 CLIP 和 DALL.E。
|
||||
|
||||
## 對比圖像預訓練（CLIP）
|
||||
|
||||
CLIP 的主要理念是能夠比較文本提示與圖像，並確定圖像與提示的匹配程度。
|
||||
|
||||
|
||||
|
||||
> *圖片來自[這篇博客文章](https://openai.com/blog/clip/)*
|
||||
|
||||
該模型是基於從互聯網獲取的圖像及其標題進行訓練的。對於每個批次，我們取 N 對（圖像，文本），並將它們轉換為某些向量表示 I 和 T。這些表示隨後會進行匹配。損失函數被定義為最大化一對（例如 I 和 T）之間向量的餘弦相似度，並最小化所有其他對之間的餘弦相似度。這就是為什麼這種方法被稱為**對比學習**。
|
||||
|
||||
CLIP 模型/庫可以從 [OpenAI GitHub](https://github.com/openai/CLIP) 獲取。該方法在[這篇博客文章](https://openai.com/blog/clip/)中有描述，並在[這篇論文](https://arxiv.org/pdf/2103.00020.pdf)中有更詳細的說明。
|
||||
|
||||
一旦該模型完成預訓練，我們可以給它一批圖像和一批文本提示，它將返回一個概率張量。CLIP 可以用於多種任務：
|
||||
|
||||
**圖像分類**
|
||||
|
||||
假設我們需要將圖像分類為貓、狗和人類。在這種情況下，我們可以給模型一張圖像，以及一系列文本提示：“*一張貓的圖片*”、“*一張狗的圖片*”、“*一張人類的圖片*”。在結果的 3 個概率向量中，我們只需選擇值最高的索引。
|
||||
|
||||
|
||||
|
||||
> *圖片來自[這篇博客文章](https://openai.com/blog/clip/)*
|
||||
|
||||
**基於文本的圖像搜索**
|
||||
|
||||
我們也可以反過來操作。如果我們有一組圖像，我們可以將這組圖像傳遞給模型，並提供一個文本提示——這將返回與給定提示最相似的圖像。
|
||||
|
||||
## ✍️ 範例：[使用 CLIP 進行圖像分類和圖像搜索](../../../../../lessons/X-Extras/X1-MultiModal/Clip.ipynb)
|
||||
|
||||
打開 [Clip.ipynb](../../../../../lessons/X-Extras/X1-MultiModal/Clip.ipynb) 筆記本，查看 CLIP 的實際應用。
|
||||
|
||||
## 使用 VQGAN+CLIP 進行圖像生成
|
||||
|
||||
CLIP 還可以用於從文本提示生成**圖像**。為了實現這一點，我們需要一個**生成器模型**，該模型能夠基於某些向量輸入生成圖像。其中一個這樣的模型稱為 [VQGAN](https://compvis.github.io/taming-transformers/)（向量量化生成對抗網絡）。
|
||||
|
||||
VQGAN 與普通 [GAN](../../4-ComputerVision/10-GANs/README.md) 的主要區別在於以下幾點：
|
||||
* 使用自回歸變壓器架構生成一系列上下文豐富的視覺部分，這些部分構成了圖像。而這些視覺部分則由 [CNN](../../4-ComputerVision/07-ConvNets/README.md) 學習。
|
||||
* 使用子圖像鑑別器來檢測圖像的部分是“真實”還是“偽造”（與傳統 GAN 的“全有或全無”方法不同）。
|
||||
|
||||
可以在 [Taming Transformers](https://compvis.github.io/taming-transformers/) 網站上了解更多關於 VQGAN 的信息。
|
||||
|
||||
VQGAN 與傳統 GAN 的一個重要區別在於，後者可以從任何輸入向量生成一張像樣的圖像，而 VQGAN 可能生成一張不連貫的圖像。因此，我們需要進一步引導圖像創建過程，而這可以通過 CLIP 完成。
|
||||
|
||||
|
||||
|
||||
為了生成與文本提示相對應的圖像，我們從一些隨機編碼向量開始，將其傳遞給 VQGAN 以生成圖像。然後使用 CLIP 生成一個損失函數，該函數顯示圖像與文本提示的匹配程度。目標是最小化這個損失，通過反向傳播調整輸入向量參數。
|
||||
|
||||
一個實現 VQGAN+CLIP 的優秀庫是 [Pixray](http://github.com/pixray/pixray)
|
||||
|
||||
 |  | 
|
||||
----|----|----
|
||||
由提示 *一幅年輕男性文學教師手持書本的水彩特寫肖像* 生成的圖片 | 由提示 *一幅年輕女性計算機科學教師手持電腦的油畫特寫肖像* 生成的圖片 | 由提示 *一幅年長男性數學教師站在黑板前的油畫特寫肖像* 生成的圖片
|
||||
|
||||
> 圖片來自 [Dmitry Soshnikov](http://soshnikov.com) 的 **人工教師** 系列
|
||||
|
||||
## DALL-E
|
||||
### [DALL-E 1](https://openai.com/research/dall-e)
|
||||
DALL-E 是一個基於 GPT-3 的版本，專門用於從提示生成圖像。它擁有 120 億個參數。
|
||||
|
||||
與 CLIP 不同，DALL-E 將文本和圖像作為單一的令牌流進行處理。因此，從多個提示中可以基於文本生成圖像。
|
||||
|
||||
### [DALL-E 2](https://openai.com/dall-e-2)
|
||||
DALL-E 1 和 2 的主要區別在於，DALL-E 2 能夠生成更真實的圖像和藝術作品。
|
||||
|
||||
使用 DALL-E 生成圖像的範例：
|
||||
 |  | 
|
||||
----|----|----
|
||||
由提示 *一幅年輕男性文學教師手持書本的水彩特寫肖像* 生成的圖片 | 由提示 *一幅年輕女性計算機科學教師手持電腦的油畫特寫肖像* 生成的圖片 | 由提示 *一幅年長男性數學教師站在黑板前的油畫特寫肖像* 生成的圖片
|
||||
|
||||
## 參考資料
|
||||
|
||||
* VQGAN 論文：[Taming Transformers for High-Resolution Image Synthesis](https://compvis.github.io/taming-transformers/paper/paper.pdf)
|
||||
* CLIP 論文：[Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/pdf/2103.00020.pdf)
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。雖然我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵資訊，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋不承擔責任。
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
歸屬-相同方式共享 4.0 國際版
|
||||
|
||||
=======================================================================
|
||||
|
||||
創用 CC 組織（Creative Commons Corporation，簡稱「創用 CC」）不是律師事務所，亦不提供法律服務或法律建議。分發創用 CC 公共授權條款並不構成律師與客戶或其他關係。創用 CC 以「現狀」基礎提供其授權條款及相關資訊。創用 CC 不對其授權條款、根據其條款和條件授權的任何材料或相關資訊提供任何保證，並在法律允許的最大範圍內免責於因使用這些內容而導致的任何損害。
|
||||
|
||||
使用創用 CC 公共授權條款
|
||||
|
||||
創用 CC 公共授權條款提供了一套標準條款和條件，創作者及其他權利持有人可用於分享受版權及以下公共授權條款中指定的某些其他權利保護的原創作品及其他材料。以下考量僅供參考，並非詳盡無遺，亦不構成我們授權條款的一部分。
|
||||
|
||||
對授權人的考量：我們的公共授權條款旨在供那些有權授予公眾使用材料許可的人使用，這些材料的使用通常受版權及某些其他權利的限制。我們的授權條款是不可撤銷的。授權人在應用授權條款之前，應仔細閱讀並理解其條款和條件。授權人還應在應用我們的授權條款之前確保擁有所有必要的權利，以便公眾能夠按照預期重複使用材料。授權人應清楚標記任何不受授權條款約束的材料，包括其他創用 CC 授權的材料，或根據版權例外或限制使用的材料。更多授權人考量請參見：
|
||||
wiki.creativecommons.org/Considerations_for_licensors
|
||||
|
||||
對公眾的考量：通過使用我們的公共授權條款，授權人授予公眾根據指定條款和條件使用被授權材料的許可。如果因任何原因不需要授權人的許可——例如，因為適用的版權例外或限制——則該使用不受授權條款的約束。我們的授權條款僅授予授權人有權授予的版權及某些其他權利下的許可。對被授權材料的使用可能仍因其他原因受到限制，包括其他人對材料擁有的版權或其他權利。授權人可能會提出特別要求，例如要求標記或描述所有更改。雖然我們的授權條款不要求這樣做，但我們鼓勵您在合理的情況下尊重這些要求。更多公眾考量請參見：
|
||||
wiki.creativecommons.org/Considerations_for_licensees
|
||||
|
||||
=======================================================================
|
||||
|
||||
創用 CC 歸屬-相同方式共享 4.0 國際公共授權條款
|
||||
|
||||
當您行使以下定義的授權權利時，即表示您接受並同意受本創用 CC 歸屬-相同方式共享 4.0 國際公共授權條款（「公共授權條款」）的條款和條件約束。在本公共授權條款可被解釋為合同的範圍內，您因接受這些條款和條件而被授予授權權利，授權人因根據這些條款和條件提供被授權材料而獲得利益，從而授予您這些權利。
|
||||
|
||||
第 1 節 —— 定義
|
||||
|
||||
a. 衍生材料是指受版權及類似權利保護的材料，該材料基於被授權材料進行翻譯、改編、編排、轉化或以其他方式修改，並因此需要授權人持有的版權及類似權利的許可。就本公共授權條款而言，當被授權材料是音樂作品、表演或聲音錄製時，當被授權材料與動態影像同步時，總是會產生衍生材料。
|
||||
|
||||
b. 改編者授權是指您根據本公共授權條款的條款和條件，對您在衍生材料中的貢獻所適用的版權及類似權利所採用的授權。
|
||||
|
||||
c. BY-SA 相容授權是指列於 creativecommons.org/compatiblelicenses 並經創用 CC 批准為與本公共授權條款基本等同的授權。
|
||||
|
||||
d. 版權及類似權利是指版權和/或與版權密切相關的類似權利，包括但不限於表演權、廣播權、聲音錄製權及特殊數據庫權利，而不考慮這些權利的標籤或分類方式。就本公共授權條款而言，第 2(b)(1)-(2) 節中規定的權利不屬於版權及類似權利。
|
||||
|
||||
e. 有效技術措施是指在未經適當授權的情況下，根據 1996 年 12 月 20 日通過的《世界知識產權組織版權條約》第 11 條及/或類似國際協議履行義務的法律，無法被規避的措施。
|
||||
|
||||
f. 例外和限制是指適用於您使用被授權材料的版權及類似權利的任何例外或限制，例如合理使用或合理處理。
|
||||
|
||||
g. 授權元素是指創用 CC 公共授權條款名稱中列出的授權屬性。本公共授權條款的授權元素為歸屬和相同方式共享。
|
||||
|
||||
h. 被授權材料是指授權人應用本公共授權條款的藝術或文學作品、數據庫或其他材料。
|
||||
|
||||
i. 授權權利是指根據本公共授權條款的條款和條件授予您的權利，這些權利僅限於適用於您使用被授權材料的所有版權及類似權利，且授權人有權授予這些權利。
|
||||
|
||||
j. 授權人是指根據本公共授權條款授予權利的個人或實體。
|
||||
|
||||
k. 分享是指以任何需要授權權利許可的方式或過程向公眾提供材料，例如複製、公開展示、公開表演、分發、傳播、通信或進口，以及以公眾成員可以在其選擇的時間和地點訪問材料的方式向公眾提供材料。
|
||||
|
||||
l. 特殊數據庫權利是指除版權以外的權利，這些權利源自 1996 年 3 月 11 日歐洲議會和理事會通過的《數據庫法律保護指令》（96/9/EC），以及其修訂或繼任版本，以及世界其他地區的基本等同權利。
|
||||
|
||||
m. 您是指根據本公共授權條款行使授權權利的個人或實體。「您的」具有相應的含義。
|
||||
|
||||
第 2 節 —— 範圍
|
||||
|
||||
a. 授權授予
|
||||
|
||||
1. 根據本公共授權條款的條款和條件，授權人特此授予您全球範圍內的、免版稅的、不可再授權的、非排他性的、不可撤銷的授權，行使被授權材料的授權權利，包括：
|
||||
|
||||
a. 複製和分享被授權材料，無論是全部還是部分；以及
|
||||
|
||||
b. 製作、複製和分享衍生材料。
|
||||
|
||||
2. 例外和限制。為避免疑義，當例外和限制適用於您的使用時，本公共授權條款不適用，您無需遵守其條款和條件。
|
||||
|
||||
3. 期限。本公共授權條款的期限規定於第 6(a) 節。
|
||||
|
||||
4. 媒體和格式；允許的技術修改。授權人授權您在現有或未來創建的所有媒體和格式中行使授權權利，並進行必要的技術修改以實現此目的。授權人放棄及/或同意不主張任何禁止您進行必要技術修改的權利或權限，包括為行使授權權利而繞過有效技術措施的技術修改。就本公共授權條款而言，僅僅進行本第 2(a)(4) 節授權的修改永遠不會產生衍生材料。
|
||||
|
||||
5. 下游接收者。
|
||||
|
||||
a. 授權人的要約——被授權材料。每位被授權材料的接收者自動收到授權人根據本公共授權條款條款和條件行使授權權利的要約。
|
||||
|
||||
b. 授權人的額外要約——衍生材料。每位從您處接收衍生材料的接收者自動收到授權人根據您應用的改編者授權條款行使衍生材料授權權利的要約。
|
||||
|
||||
c. 無下游限制。您不得對被授權材料施加任何額外或不同的條款和條件，也不得應用任何有效技術措施，若這樣做會限制任何接收者行使授權權利。
|
||||
|
||||
6. 無背書。本公共授權條款中的任何內容均不構成或可被解釋為授權您聲稱或暗示您與授權人或其他根據第 3(a)(1)(A)(i) 節規定應被歸屬的人有關聯、受到支持或授予官方地位，或您的使用被授權材料與此相關。
|
||||
|
||||
b. 其他權利
|
||||
|
||||
1. 道德權利（如完整性權）不在本公共授權條款的授權範圍內，亦不包括公開權、隱私權及/或其他類似的個人權利；然而，在可能的範圍內，授權人放棄及/或同意不主張授權人持有的此類權利，以便您在有限範圍內行使授權權利，但不包括其他情況。
|
||||
|
||||
2. 專利權和商標權不在本公共授權條款的授權範圍內。
|
||||
|
||||
3. 在可能的範圍內，授權人放棄向您收取行使授權權利的版稅的權利，無論是直接收取還是通過任何自願或可放棄的法定或強制性授權計劃的收費機構收取。在所有其他情況下，授權人明確保留收取此類版稅的權利。
|
||||
|
||||
第 3 節 —— 授權條件
|
||||
|
||||
您行使授權權利的行為明確受以下條件約束。
|
||||
|
||||
a. 歸屬
|
||||
|
||||
1. 如果您分享被授權材料（包括修改後的形式），您必須：
|
||||
|
||||
a. 保留以下內容（如果授權人隨被授權材料提供）：
|
||||
|
||||
i. 被授權材料創作者及任何其他指定接受歸屬者的身份識別（包括授權人要求的合理方式，如使用筆名）；
|
||||
ii. 版權聲明；
|
||||
iii. 提及本公共授權條款的聲明；
|
||||
iv. 提及免責聲明的聲明；
|
||||
v. 在合理可行的範圍內，提供被授權材料的 URI 或超連結；
|
||||
|
||||
b. 表明您是否修改了被授權材料，並保留任何先前修改的說明；以及
|
||||
|
||||
c. 表明被授權材料是根據本公共授權條款授權的，並包括本公共授權條款的文本或 URI 或超連結。
|
||||
|
||||
2. 您可以根據您分享被授權材料的媒介、方式和上下文，以任何合理的方式滿足第 3(a)(1) 節的條件。例如，提供包含所需資訊的資源的 URI 或超連結可能是合理的。
|
||||
|
||||
3. 如果授權人要求，您必須在合理可行的範圍內移除第 3(a)(1)(A) 節要求的任何資訊。
|
||||
|
||||
b. 相同方式共享
|
||||
|
||||
除第 3(a) 節的條件外，如果您分享您製作的衍生材料，還需遵守以下條件：
|
||||
|
||||
1. 您應用的改編者授權必須是具有相同授權元素的創用 CC 授權（本版本或更高版本），或是 BY-SA 相容授權。
|
||||
|
||||
2. 您必須包括您應用的改編者授權的文本或 URI 或超連結。您可以根據您分享衍生材料的媒介、方式和上下文，以任何合理的方式滿足此條件。
|
||||
|
||||
3. 您不得對衍生材料施加任何額外或不同的條款和條件，也不得應用任何有效技術措施，若這樣做會限制根據您應用的改編者授權授予的權利的行使。
|
||||
|
||||
第 4 節 —— 特殊數據庫權利
|
||||
|
||||
當授權權利包括適用於您使用被授權材料的特殊數據庫權利時：
|
||||
|
||||
a. 為避免疑義，第 2(a)(1) 節授予您提取、重複使用、複製和分享數據庫內容全部或實質部分的權利；
|
||||
|
||||
b. 如果您將數據庫內容全部或實質部分納入您擁有特殊數據庫權利的數據庫中：
|
||||
權利，然後您擁有特殊資料庫權利的資料庫（但不包括其個別內容）屬於改編素材，
|
||||
|
||||
包括為了第 3(b) 節的目的；以及
|
||||
c. 如果您分享資料庫的全部或大部分內容，您必須遵守第 3(a) 節中的條件。
|
||||
|
||||
為免疑義，第 4 節是補充條款，並不取代您在本公共授權條款下的義務，當授權權利包括其他版權及類似權利時。
|
||||
|
||||
|
||||
第 5 節 —— 免責聲明與責任限制。
|
||||
|
||||
a. 除非授權人另有單獨承諾，在可能的範圍內，授權人按「現狀」及「可用」的方式提供授權素材，並且不對授權素材作出任何形式的陳述或保證，無論是明示、暗示、法定或其他形式的保證。這包括但不限於所有權、適銷性、特定用途的適用性、不侵權、無潛在或其他缺陷、準確性，或是否存在錯誤（無論是否已知或可發現）的保證。在某些地區，若免責聲明不被允許全部或部分適用，則此免責聲明可能不適用於您。
|
||||
|
||||
b. 在可能的範圍內，授權人無論基於任何法律理論（包括但不限於過失）或其他原因，均不對您因本公共授權條款或使用授權素材而產生的任何直接、特殊、間接、附帶、後果性、懲罰性、示範性或其他損失、成本、費用或損害承擔責任，即使授權人已被告知可能發生此類損失、成本、費用或損害。在某些地區，若責任限制不被允許全部或部分適用，則此限制可能不適用於您。
|
||||
|
||||
c. 上述免責聲明與責任限制應在可能的範圍內解釋為最接近於完全免責與放棄所有責任的方式。
|
||||
|
||||
|
||||
第 6 節 —— 有效期與終止。
|
||||
|
||||
a. 本公共授權條款適用於此處授權的版權及類似權利的有效期。然而，如果您未遵守本公共授權條款，則您根據本公共授權條款的權利將自動終止。
|
||||
|
||||
b. 如果您根據第 6(a) 節喪失使用授權素材的權利，該權利可在以下情況下恢復：
|
||||
|
||||
1. 在您發現違規後 30 天內糾正違規行為，則自糾正之日起自動恢復；或
|
||||
2. 經授權人明確恢復。
|
||||
|
||||
為免疑義，第 6(b) 節不影響授權人因您違反本公共授權條款而尋求補救的任何權利。
|
||||
|
||||
c. 為免疑義，授權人也可以根據其他條款或條件提供授權素材，或隨時停止分發授權素材；然而，這不會終止本公共授權條款。
|
||||
|
||||
d. 第 1、5、6、7 和 8 節在本公共授權條款終止後仍然有效。
|
||||
|
||||
|
||||
第 7 節 —— 其他條款與條件。
|
||||
|
||||
a. 除非授權人明確同意，授權人不受您傳達的任何額外或不同條款與條件的約束。
|
||||
|
||||
b. 關於授權素材的任何安排、理解或協議，若未在此處陳述，則與本公共授權條款的條款與條件分開且獨立。
|
||||
|
||||
|
||||
第 8 節 —— 解釋。
|
||||
|
||||
a. 為免疑義，本公共授權條款不會且不得被解釋為減少、限制、約束或施加條件於任何在未經本公共授權條款許可的情況下，依法可對授權素材進行的使用。
|
||||
|
||||
b. 在可能的範圍內，如果本公共授權條款的任何條款被認為不可執行，則該條款應自動調整至最低必要程度以使其可執行。如果該條款無法調整，則應從本公共授權條款中刪除，而不影響其餘條款與條件的可執行性。
|
||||
|
||||
c. 除非授權人明確同意，否則本公共授權條款的任何條款或條件均不得被放棄，且任何未遵守的行為均不得被視為已獲同意。
|
||||
|
||||
d. 本公共授權條款中的任何內容均不得構成或被解釋為對授權人或您適用的任何司法管轄區或權限的法律程序的特權與豁免的限制或放棄。
|
||||
|
||||
|
||||
=======================================================================
|
||||
|
||||
Creative Commons 並非其公共授權條款的當事方。然而，Creative Commons 可選擇將其公共授權條款應用於其發布的素材，在這些情況下，Creative Commons 將被視為「授權人」。Creative Commons 公共授權條款的文本已根據 CC0 公共領域貢獻聲明捐贈至公共領域。除非為表明素材是根據 Creative Commons 公共授權條款共享或根據 Creative Commons 政策（發布於 creativecommons.org/policies）另行允許的有限目的，Creative Commons 不授權在未經其事先書面同意的情況下使用「Creative Commons」商標或任何其他 Creative Commons 的商標或標誌，包括但不限於對其公共授權條款的任何未經授權的修改或任何其他關於授權素材使用的安排、理解或協議。為免疑義，本段不構成本公共授權條款的一部分。
|
||||
|
||||
Creative Commons 可通過 creativecommons.org 聯繫。
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤讀概不負責。
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
所有課程的手繪筆記可以在這裡下載。
|
||||
|
||||
🎨 創作者：Tomomi Imura (Twitter: [@girlie_mac](https://twitter.com/girlie_mac), GitHub: [girliemac](https://github.com/girliemac))
|
||||
|
||||
[](https://creativecommons.org/licenses/by-sa/4.0/)
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。
|
||||
|
|
@ -0,0 +1,278 @@
|
|||
# AI-For-Beginners 疑難排解指南
|
||||
|
||||
本指南旨在幫助您解決使用或貢獻 [AI-For-Beginners](https://github.com/microsoft/AI-For-Beginners) 儲存庫時常見的問題。每個問題都包含背景、症狀、解釋以及逐步解決方案。
|
||||
|
||||
---
|
||||
|
||||
## 目錄
|
||||
|
||||
- [一般問題](../..)
|
||||
- [安裝問題](../..)
|
||||
- [配置問題](../..)
|
||||
- [執行筆記本](../..)
|
||||
- [效能問題](../..)
|
||||
- [教科書網站問題](../..)
|
||||
- [貢獻問題](../..)
|
||||
- [常見問題](../..)
|
||||
- [尋求幫助](../..)
|
||||
|
||||
---
|
||||
|
||||
## 一般問題
|
||||
|
||||
### 1. 儲存庫無法正確複製
|
||||
|
||||
**背景：** 複製儲存庫可讓您將其拷貝到您的機器上。
|
||||
|
||||
**症狀：**
|
||||
- 錯誤：`fatal: repository not found`
|
||||
- 錯誤：`Permission denied (publickey)`
|
||||
|
||||
**可能原因：**
|
||||
- 儲存庫 URL 錯誤
|
||||
- 權限不足
|
||||
- SSH 金鑰未配置
|
||||
|
||||
**解決方案：**
|
||||
1. **檢查儲存庫 URL。**
|
||||
使用 HTTPS URL：
|
||||
```
|
||||
git clone https://github.com/microsoft/AI-For-Beginners.git
|
||||
```
|
||||
2. **如果 SSH 失敗，切換到 HTTPS。**
|
||||
如果看到 `Permission denied (publickey)`，請使用上述的 HTTPS 連結代替 SSH。
|
||||
3. **配置 SSH 金鑰（可選）。**
|
||||
如果您希望使用 SSH，請參考 [GitHub 的 SSH 指南](https://docs.github.com/en/authentication/connecting-to-github-with-ssh)。
|
||||
|
||||
---
|
||||
|
||||
## 安裝問題
|
||||
|
||||
### 2. Python 環境問題
|
||||
|
||||
**背景：** 儲存庫依賴 Python 和多個庫。
|
||||
|
||||
**症狀：**
|
||||
- 錯誤：`ModuleNotFoundError: No module named '<package>'`
|
||||
- 執行腳本或筆記本時出現導入錯誤
|
||||
|
||||
**可能原因：**
|
||||
- 未安裝依賴項
|
||||
- Python 版本錯誤
|
||||
|
||||
**解決方案：**
|
||||
1. **設置虛擬環境。**
|
||||
```bash
|
||||
python -m venv venv
|
||||
source venv/bin/activate # On Windows: venv\Scripts\activate
|
||||
```
|
||||
2. **安裝依賴項。**
|
||||
```bash
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
3. **檢查 Python 版本。**
|
||||
使用 Python 3.7 或更新版本。
|
||||
```bash
|
||||
python --version
|
||||
```
|
||||
|
||||
### 3. 未安裝 Jupyter
|
||||
|
||||
**背景：** 筆記本是核心學習資源。
|
||||
|
||||
**症狀：**
|
||||
- 錯誤：`jupyter: command not found`
|
||||
- 筆記本無法啟動
|
||||
|
||||
**可能原因：**
|
||||
- 未安裝 Jupyter
|
||||
|
||||
**解決方案：**
|
||||
1. **安裝 Jupyter Notebook。**
|
||||
```bash
|
||||
pip install notebook
|
||||
```
|
||||
或者，如果使用 Anaconda：
|
||||
```bash
|
||||
conda install notebook
|
||||
```
|
||||
2. **啟動 Jupyter Notebook。**
|
||||
```bash
|
||||
jupyter notebook
|
||||
```
|
||||
|
||||
### 4. 依賴版本衝突
|
||||
|
||||
**背景：** 如果套件版本不匹配，項目可能會出現問題。
|
||||
|
||||
**症狀：**
|
||||
- 關於不兼容版本的錯誤或警告
|
||||
|
||||
**可能原因：**
|
||||
- 舊版或衝突的 Python 套件
|
||||
|
||||
**解決方案：**
|
||||
1. **在乾淨的環境中安裝。**
|
||||
刪除舊的 venv/conda 環境並創建新的環境。
|
||||
2. **使用精確版本。**
|
||||
始終執行：
|
||||
```bash
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
如果失敗，請按照 README 中的說明手動安裝缺失的套件。
|
||||
|
||||
---
|
||||
|
||||
## 配置問題
|
||||
|
||||
### 5. 環境變數未設置
|
||||
|
||||
**背景：** 某些模組可能需要金鑰、令牌或配置設置。
|
||||
|
||||
**症狀：**
|
||||
- 錯誤：`KeyError` 或缺少配置的警告
|
||||
|
||||
**可能原因：**
|
||||
- 未設置所需的環境變數
|
||||
|
||||
**解決方案：**
|
||||
1. **檢查 `.env.example` 或類似文件。**
|
||||
2. **創建 `.env` 文件並填寫所需值。**
|
||||
3. **設置環境變數後重新加載終端或 IDE。**
|
||||
|
||||
---
|
||||
|
||||
## 執行筆記本
|
||||
|
||||
### 6. 筆記本無法打開或運行
|
||||
|
||||
**背景：** Jupyter 筆記本需要正確的設置。
|
||||
|
||||
**症狀：**
|
||||
- 筆記本無法啟動
|
||||
- 瀏覽器未自動打開
|
||||
|
||||
**可能原因：**
|
||||
- 未安裝 Jupyter
|
||||
- 瀏覽器配置問題
|
||||
|
||||
**解決方案：**
|
||||
1. **安裝 Jupyter（參見上方的安裝問題）。**
|
||||
2. **手動打開筆記本。**
|
||||
- 從終端複製 URL（例如 `http://localhost:8888/?token=...`），並將其粘貼到瀏覽器中。
|
||||
|
||||
### 7. 核心崩潰或凍結
|
||||
|
||||
**背景：** 筆記本核心可能因資源限制或代碼錯誤而崩潰。
|
||||
|
||||
**症狀：**
|
||||
- 核心反覆死機或重啟
|
||||
- 記憶體不足錯誤
|
||||
|
||||
**可能原因：**
|
||||
- 大型數據集
|
||||
- 不兼容的代碼或套件
|
||||
|
||||
**解決方案：**
|
||||
1. **重啟核心。**
|
||||
使用 Jupyter 中的 "Restart Kernel" 按鈕。
|
||||
2. **檢查記憶體使用情況。**
|
||||
關閉未使用的應用程式。
|
||||
3. **在雲平台上運行筆記本。**
|
||||
使用 [Google Colab](https://colab.research.google.com/) 或 [Azure Notebooks](https://notebooks.azure.com/)。
|
||||
|
||||
---
|
||||
|
||||
## 效能問題
|
||||
|
||||
### 8. 筆記本運行緩慢
|
||||
|
||||
**背景：** 某些 AI 任務需要大量記憶體和 CPU。
|
||||
|
||||
**症狀：**
|
||||
- 執行速度慢
|
||||
- 筆記本電腦風扇聲音很大
|
||||
|
||||
**可能原因：**
|
||||
- 大型數據集或模型
|
||||
- 系統資源有限
|
||||
|
||||
**解決方案：**
|
||||
1. **使用雲平台。**
|
||||
- 將筆記本上傳到 Colab 或 Azure Notebooks。
|
||||
2. **減少數據集大小。**
|
||||
- 使用樣本數據進行練習。
|
||||
3. **關閉不必要的程式。**
|
||||
- 釋放系統 RAM。
|
||||
|
||||
---
|
||||
|
||||
## 教科書網站問題
|
||||
|
||||
### 9. 章節無法加載
|
||||
|
||||
**背景：** 在線教科書顯示課程和章節。
|
||||
|
||||
**症狀：**
|
||||
- 某章節（例如 Transformers/BERT）缺失或無法打開
|
||||
|
||||
**已知問題：**
|
||||
- [問題 #303](https://github.com/microsoft/AI-For-Beginners/issues/303)：“18 Transformers. BERT. 無法在教科書網站上打開。” 由於文件名錯誤（`READMEtransformers.md` 而非 `README.md`）引起。
|
||||
|
||||
**解決方案：**
|
||||
1. **檢查文件重命名錯誤。**
|
||||
如果您是貢獻者，請確保章節文件命名為 `README.md`。
|
||||
2. **報告缺失文件。**
|
||||
在 GitHub 上開啟問題，提供章節名稱和錯誤詳情。
|
||||
|
||||
---
|
||||
|
||||
## 貢獻問題
|
||||
|
||||
### 10. PR 未被接受或構建失敗
|
||||
|
||||
**背景：** 貢獻必須通過測試並遵循指南。
|
||||
|
||||
**症狀：**
|
||||
- Pull request 被拒絕
|
||||
- CI/CD 管道錯誤
|
||||
|
||||
**可能原因：**
|
||||
- 測試失敗
|
||||
- 未遵循編碼標準
|
||||
|
||||
**解決方案：**
|
||||
1. **閱讀貢獻指南。**
|
||||
- 遵循儲存庫的 [CONTRIBUTING.md](https://github.com/microsoft/AI-For-Beginners/blob/main/CONTRIBUTING.md)。
|
||||
2. **在推送之前本地運行測試。**
|
||||
3. **檢查 linting 規則或格式要求。**
|
||||
|
||||
---
|
||||
|
||||
## 常見問題
|
||||
|
||||
### 我在哪裡可以找到特定模組的幫助？
|
||||
- 每個模組通常都有自己的 README。從那裡開始了解設置和使用提示。
|
||||
|
||||
### 如何報告錯誤或提出功能請求？
|
||||
- [開啟 GitHub 問題](https://github.com/microsoft/AI-For-Beginners/issues/new)，提供清晰的描述和重現步驟。
|
||||
|
||||
### 如果我的問題未列出，我可以尋求幫助嗎？
|
||||
- 可以！先搜索現有問題，如果找不到您的問題，請創建新問題。
|
||||
|
||||
---
|
||||
|
||||
## 尋求幫助
|
||||
|
||||
- **檢查問題：** [GitHub Issues](https://github.com/microsoft/AI-For-Beginners/issues)
|
||||
- **提出問題：** 使用 GitHub Discussions 或開啟問題。
|
||||
- **社群：** 查看儲存庫連結以獲取聊天/論壇選項。
|
||||
|
||||
---
|
||||
|
||||
_最後更新日期：2025-09-20_
|
||||
|
||||
---
|
||||
|
||||
**免責聲明**：
|
||||
本文件使用 AI 翻譯服務 [Co-op Translator](https://github.com/Azure/co-op-translator) 進行翻譯。雖然我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。原始文件的母語版本應被視為權威來源。對於關鍵信息，建議使用專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤釋不承擔責任。
|
||||
Loading…
Reference in New Issue