Tensorflow 2.4 完成 StackOverflow 的文字分類
本文正在參加「金石計劃 . 瓜分6萬現金大獎」
前言
本文使用 cpu 版本的 tensorflow 2.4 來完成 Stack Overflow 的文字分類，為了順利進行要保證安裝了 2.8 版本以上的 tensorflow_text 。
本文大綱
- 獲取 Stack Overflow 資料
- 兩種向量化方式處理資料
- 訓練和評估兩種模型
- 完整模型的搭建和評估
- 模型預測
實現思路
1. 獲取 Stack Overflow 資料
（1）我們用到的資料是 Stack Overflow 中收集到的關於程式設計問題的資料集，每個資料樣本都是由一個問題和一個標籤標籤組成，問題是對不同程式語言的技術提問，標籤是對應的程式語言標籤，分別是 CSharp、Java、JavaScript 或 Python ，表示該問題所屬的技術範疇，在資料中分別用 0、1、2、3 四個數字來表示。
（2）我們的資料需要使用 tensorflow 內建函式，從網路上進行下載，下載好的資料分為兩個資料夾 train 和 test 表示存放了訓練資料和測試資料，而 train 和 test 都一樣擁有 CSharp、Java、JavaScript 和 Python 四個資料夾，裡面包含了四類程式語言對應的樣本，如 train 目錄如下所示，test 目錄類似。
train/
...csharp/
......1.txt
..........
...java/
......1.txt
..........
...javascript/
......1.txt
..........
...python/
......1.txt
..........
（3）在模型訓練過程中要將資料分三份，分別是訓練集、驗證集和測試集，將訓練集中的 20% 當做驗證集，也就是說我們最後訓練集中有 6400 個樣本，驗證集中有 1600 個樣本，測試集中有 8000 個樣本。
（4）為了增加分類的難度，問題中出現的單詞 Python、CSharp、JavaScript 或 Java 都被替換為 blank 字串。
import collections
import pathlib
import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras import losses
from tensorflow.keras import utils
from tensorflow.keras.layers.experimental.preprocessing import TextVectorization
import tensorflow_datasets as tfds
import tensorflow_text as tf_text
url = 'http://storage.googleapis.com/download.tensorflow.org/data/stack_overflow_16k.tar.gz'
batch_size = 32
seed = 1
dataset_dir = utils.get_file( origin=url, untar=True, cache_dir='stack_overflow', cache_subdir='')
dataset_dir = pathlib.Path(dataset_dir).parent
train_dir = dataset_dir/'train'
test_dir = dataset_dir/'test'
train_datas = utils.text_dataset_from_directory( train_dir, batch_size=batch_size, validation_split=0.2, subset='training', seed=seed)
val_datas = utils.text_dataset_from_directory( train_dir, batch_size=batch_size, validation_split=0.2, subset='validation', seed=seed)
test_datas = utils.text_dataset_from_directory( test_dir, batch_size=batch_size)
2. 資料處理
（1）我們在使用資料之前，要進行預處理、分詞、向量化。預處理指預處理文字資料，通常就是去掉文字中用不到的標點符號、HTML 元素或者停用詞等，精簡樣本資料內容 。分詞就是按空格將一個句子拆分為若干個單詞。向量化是指將每個詞都轉化成對應的整數，以便將它們輸入到神經網路中進行運算。
（2）上面說的三個操作我們可以使用 TextVectorization 來一次性搞定，需要注意的是使用 TextVectorization 會將文字預設地轉換為小寫字母並移除標點符號。在進行分詞的時候如果沒有明確要求預設會將文字按空格分割。向量化的預設模式為 'int' ，這會為每個單詞生成一個對應的整數。還可以選擇使用模式 'binary' 來構建詞袋模型，也就是用一個長度為 VOCAB_SIZE 的向量表示一個樣本，只有該樣本中出現的單詞對應的索引位置為 1 ，其他位置都為 0 。
（3）我們現在要將訓練資料中的標籤去掉，只保留問題描述。然後用 binary_vectorize_layer 生成訓練資料中單詞和對應詞袋中的索引，用 int_vectorize_layer 生成訓練資料中單詞和對應的整數。
（4）我們分別使用兩種不同的向量化工具生成兩類訓練集、驗證集和測試集。
VOCAB_SIZE = 10000
MAX_SEQUENCE_LENGTH = 250
binary_vectorize_layer = TextVectorization( max_tokens=VOCAB_SIZE, output_mode='binary')
int_vectorize_layer = TextVectorization( max_tokens=VOCAB_SIZE, output_mode='int', output_sequence_length=MAX_SEQUENCE_LENGTH)
train_text = train_datas.map(lambda text, labels: text)
binary_vectorize_layer.adapt(train_text)
int_vectorize_layer.adapt(train_text)
def binary_vectorize(text, label):
text = tf.expand_dims(text, -1)
return binary_vectorize_layer(text), label
def int_vectorize(text, label):
text = tf.expand_dims(text, -1)
return int_vectorize_layer(text), label
binary_train_datas = train_datas.map(binary_vectorize)
binary_val_datas = val_datas.map(binary_vectorize)
binary_test_datas = test_datas.map(binary_vectorize)
int_train_datas = train_datas.map(int_vectorize)
int_val_datas = val_datas.map(int_vectorize)
int_test_datas = test_datas.map(int_vectorize)
（5）為了保證在載入資料的時候不會出現 I/O 不會阻塞，我們在從磁碟載入完資料之後，使用 cache 會將資料儲存在記憶體中，確保在訓練模型過程中資料的獲取不會成為訓練速度的瓶頸。如果說要儲存的資料量太大，可以使用 cache 建立磁碟快取提高資料的讀取效率。另外我們還使用 prefetch 在訓練過程中可以並行執行資料的預獲取。
（6）我們對兩類向量化資料，都進行了同樣的 cache 和 prefetch 操作。
AUTOTUNE = tf.data.AUTOTUNE
def configure_dataset(dataset):
return dataset.cache().prefetch(buffer_size=AUTOTUNE)
binary_train_datas = configure_dataset(binary_train_datas)
binary_val_datas = configure_dataset(binary_val_datas)
binary_test_datas = configure_dataset(binary_test_datas)
int_train_datas = configure_dataset(int_train_datas)
int_val_datas = configure_dataset(int_val_datas)
int_test_datas = configure_dataset(int_test_datas)
3. 訓練和評估兩種模型
（1）我們對進行了 binary_vectorize 操作的訓練資料建立一個 binary_model 模型，模型只是一個非常簡單的結構，只有一層輸入為 4 個維度向量的全連線操作，其實就是輸出該問題樣本分別屬於四種類別的概率分佈。模型的損失函式選擇 SparseCategoricalCrossentropy ，模型的優化器選擇 adam ，模型的評估指標選擇為 accuracy 。
binary_model = tf.keras.Sequential([layers.Dense(4)])
binary_model.compile( loss=losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer='adam',
metrics=['accuracy'])
binary_model.fit( binary_train_datas, validation_data=binary_val_datas, epochs=20)
訓練過程如下：
Epoch 1/20
200/200 [==============================] - 3s 12ms/step - loss: 1.1223 - accuracy: 0.6555 - val_loss: 0.9304 - val_accuracy: 0.7650
Epoch 2/20
200/200 [==============================] - 3s 12ms/step - loss: 0.7780 - accuracy: 0.8248 - val_loss: 0.7681 - val_accuracy: 0.7856
...
Epoch 19/20
200/200 [==============================] - 3s 13ms/step - loss: 0.1570 - accuracy: 0.9812 - val_loss: 0.4923 - val_accuracy: 0.8087
Epoch 20/20
200/200 [==============================] - 2s 12ms/step - loss: 0.1481 - accuracy: 0.9836 - val_loss: 0.4929 - val_accuracy: 0.8081
（2）我們對進行了 int_vectorize 操作的訓練資料建立一個 int_model 模型， 第一層是對所有的單詞都進行詞嵌入操作，將每個單詞轉換成 64 維向量，這裡因為 0 要進行 padding 操作，所以在進行詞嵌入的時候要額外加 1 。第二層使用卷積函式，輸出 64 維的向量，卷積核大小為 5 ，步長為 2，並使用了 padding 操作進行補齊，啟用函式使用的是 relu 。第三層是一個最大池化層。第四層是一個輸出 4 個維度的向量的全連線層，其實就是輸出該問題樣本分別屬於四種類別的概率分佈。
def create_model():
model = tf.keras.Sequential([
layers.Embedding(VOCAB_SIZE + 1, 64, mask_zero=True),
layers.Conv1D(64, 5, padding="valid", activation="relu", strides=2),
layers.GlobalMaxPooling1D(),
layers.Dense(4) ])
return model
int_model = create_model()
int_model.compile(
loss=losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer='adam',
metrics=['accuracy'])
int_model.fit(int_train_datas, validation_data=int_val_datas, epochs=20)
訓練過程如下：
Epoch 1/20
200/200 [==============================] - 5s 24ms/step - loss: 1.1247 - accuracy: 0.5069 - val_loss: 0.7829 - val_accuracy: 0.6756
Epoch 2/20
200/200 [==============================] - 5s 24ms/step - loss: 0.6034 - accuracy: 0.7708 - val_loss: 0.5820 - val_accuracy: 0.7681
...
Epoch 19/20
200/200 [==============================] - 5s 24ms/step - loss: 5.8555e-04 - accuracy: 1.0000 - val_loss: 0.7737 - val_accuracy: 0.8019
Epoch 20/20
200/200 [==============================] - 5s 24ms/step - loss: 4.9328e-04 - accuracy: 1.0000 - val_loss: 0.7853 - val_accuracy: 0.8019
（3）我們使用各自的測試資料分別對兩個模型進行測試。
_, binary_accuracy = binary_model.evaluate(binary_test_datas)
_, int_accuracy = int_model.evaluate(int_test_datas)
print("Binary model accuracy: {:2.2%}".format(binary_accuracy))
print("Int model accuracy: {:2.2%}".format(int_accuracy))
測試結果為：
Binary model accuracy: 81.29%
Int model accuracy: 80.67%
4. 完整模型的搭建和評估
（1）為了快速搭建模型，我們還可以將 binary_vectorize_layer 與 binary_model 進行拼接，最後再接入 sigmoid 啟用函式，這樣模型就有了能夠處理原始文字的能力。
（2）因為模型的功能完整，所以我們只需要將原始的測試文字資料傳入即可。
whole_model = tf.keras.Sequential(
[binary_vectorize_layer,
binary_model,
layers.Activation('sigmoid')])
whole_model.compile(
loss=losses.SparseCategoricalCrossentropy(from_logits=False),
optimizer='adam',
metrics=['accuracy'])
_, accuracy = whole_model.evaluate(test_datas)
print("Accuracy: {:2.2%}".format(accuracy))
測試結果為：
Accuracy: 81.29%
5. 模型預測
我們分別使用兩個樣本來用模型進行預測，可以看出預測結果準確。
def get_sample(predicteds):
int_labels = tf.math.argmax(predicteds, axis=1)
predicted_labels = tf.gather(train_datas.class_names, int_labels)
return predicted_labels
inputs = [
"how do I extract keys from a dict into a list?",
"debug public static void main(string[] args) {...}",
]
predicted_scores = whole_model.predict(inputs)
predicted_labels = get_sample(predicted_scores)
for t, label in zip(inputs, predicted_labels):
print("Question: ", t)
print("Predicted label: ", label.numpy())
預測結果：
Question: how do I extract keys from a dict into a list?
Predicted label: b'python'
Question: debug public static void main(string[] args) {...}
Predicted label: b'java'