Lecture10 (deep_learning_part4.1.pdf, 45 หน้า) · 2603520 Deep Learning

Sequence Modelling: RNN, GRU, LSTM, Time Series และ Word Embeddings

Lesson 7–9 จัดการข้อมูลที่มีโครงสร้างเชิงพื้นที่ (ภาพ). บทนี้เปลี่ยนเป็นข้อมูลที่มีโครงสร้างเชิงลำดับ: อนุกรมเวลาและข้อความ. มีสี่ส่วน:

1. RNN (หน้า 2–12): ทำไมต้องมี, shape ของ input, สมการ forward, ชนิดของ RNN และ BPTT
2. GRU และ LSTM (หน้า 13–22): แก้ vanishing gradient ด้วย gate, exploding gradient, dropout, bidirectional และ deep RNN
3. Temperature forecasting (หน้า 23–27): กลยุทธ์การทำนายและการเตรียม dataset
4. ข้อความ (หน้า 28–45): การเตรียมข้อความ, one-hot, word embeddings, Word2Vec และโค้ด IMDB

1. Sequential Data และเหตุผลที่ต้องมี Sequence Model

Sequential data คือข้อมูลที่เรียงตาม some index:

• Time series data: index เป็นเวลาที่ห่างเท่ากัน
• Text: ลำดับของตัวอักษรหรือคำ
• อื่นๆ เช่น audio stream, speech, temporal data

ตัวอย่างงาน natural language processing แบบ supervised learning ในสไลด์ ซึ่งแต่ละงานมีรูปแบบ X → y ต่างกัน:

สไลด์ให้สามเหตุผลที่ densely connected network ไม่เหมาะกับลำดับ:

1. order of elements matters. ความหมายหรือคำทำนายที่ step หนึ่งขึ้นกับ previous elements. Dense network ไม่พิจารณา orders และ inter-word relationships ในโครงสร้างประโยค. ตัวอย่าง: "The dog bites the man." กับ "The man bites the dog." ใช้คำชุดเดียวกันทั้งหกตัว ต่างกันเพียงตำแหน่งของ "dog" และ "man" แต่ความหมายตรงข้าม. โมเดลที่นับเฉพาะว่ามีคำใดบ้างจะให้คำตอบเดียวกันกับทั้งสองประโยค
2. ลำดับมี lengths ต่างกันได้. ลำดับใน dense network ต้องมี same fixed lengths. เพราะจำนวน node ของ input layer ตายตัว (\(x_1 \ldots x_n\))
3. ต้องการ reuse the feature learned across positions. Dense network มี no recurrent state ที่ส่งต่อ sequential context จากตำแหน่งหนึ่งไปตำแหน่งถัดไป. ถ้าโมเดลเรียนว่า "dog" เป็นสัตว์ที่ตำแหน่ง 2 ก็ไม่ได้ช่วยให้รู้จัก "dog" ที่ตำแหน่ง 5 เพราะใช้ weight คนละชุด (ปัญหาเดียวกับ dense network กับภาพใน Lesson 7 §1)

2. RNN และ Shape ของ Input

RNN ประมวลผลลำดับ input แบบ step by step โดยแต่ละ time step จัดการ one element in the sequence:

• เก็บ memory ของสิ่งที่เห็นมาแล้ว (state ข้าม time step). ในแผนภาพคือลูกศรวนกลับ (recurrent connection): output ของ hidden layer ที่ step นี้กลับมาเป็น input ของ hidden layer ที่ step ถัดไป
• ทำงานกับ input arbitrary lengths ได้ แต่ปกติใช้ fixed-sized inputs เพื่อให้ hardware คำนวณได้มีประสิทธิภาพ (จัดเป็น batch ได้)

model = Sequential()
model.add(layers.SimpleRNN(16, return_sequences=True,
                           input_shape=(None, raw_data.shape[-1])))
model.add(layers.Dense(1))
model.summary()

คำถามของสไลด์: "What is the dimension of input to RNNs?". ตารางเป็น weather timeseries dataset: หนึ่งแถวต่อ 10 นาที และมี 14 คอลัมน์ตัวเลข (ความดัน p, อุณหภูมิ T (degC), ความชื้น rh ฯลฯ). สี่แถวแรกของคอลัมน์ T คือ −8.02, −8.41, −8.51, −8.31 และของคอลัมน์ p คือ 996.52, 996.57, 996.53, 996.51. ตัวเลขชุดนี้ถูกใช้เป็นตัวอย่างในสองหน้าถัดไป.

ทั้ง sequence ถูกป้อนให้ network โดย state ถูกเก็บไว้ระหว่าง input. ป้อนทีละหนึ่งสมาชิกต่อ time step: \(X = -8.02, -8.41, -8.51\) (ค่าที่ 1–3) และ target \(y = -8.31\) (ค่าที่ 4). แผนภาพ "unrolled" คือ RNN ตัวเดียววาดซ้ำสามครั้งตามเวลา ไม่ใช่สาม layer.

Univariate feature (ใช้เฉพาะอุณหภูมิ): ตัวอย่าง 1 batch ในสไลด์มี 7 ลำดับ แต่ละลำดับยาว 3 และมี 1 feature ⇒ shape \((7, 3, 1)\). หน้าต่างเลื่อนทีละ 1: \([-8.02, -8.41, -8.51] \to -8.31\); \([-8.41, -8.51, -8.31] \to -8.27\); \([-8.51, -8.31, -8.27] \to -8.05\). Target ของแต่ละแถวคือค่าถัดจากหน้าต่าง.

Multivariate feature (ใช้ทุกคอลัมน์): แต่ละ time step เป็น vector \([996.52, -8.02, \ldots]\) ของ 14 ค่า. Batch เดิม 7 ลำดับ ยาว 3 จึงมี shape \((7, 3, 14)\). Target ยังเป็นค่าเดียว (−8.31) เพราะทำนายเฉพาะอุณหภูมิ. มิติที่เปลี่ยนคือมิติสุดท้าย (feature) เท่านั้น.

3. Forward Propagation ของ RNN

สไลด์เปลี่ยนสัญลักษณ์: \(\theta_1 \ldots \theta_n\) เขียนเป็น \(W\) และ \(\theta_0\) เขียนเป็น \(b\). ที่ time step แรก:

ที่ time step \(t\) ใดๆ:

state ใหม่ = activation ของ (state เก่าผ่าน W_a) + (input ปัจจุบันผ่าน W_x) + bias

หมายเหตุท้ายสไลด์: parameters \(W_a\), \(W_x\) and \(W_y\) are shared at each time step (greatly reduce the number of parameters needed). นี่คือ weight sharing ตามแกนเวลา เทียบได้กับ filter ของ CNN ที่ใช้ร่วมกันทุกตำแหน่งของภาพ (Lesson 7 §8).

RNN ประมวลผลลำดับด้วยการวนผ่านสมาชิกทีละตัวและเก็บ state ไว้. หน่วยที่ทำงานนี้เรียกว่า memory cell (หรือ cell). ในแผนภาพ \(g\) คือ tanh. Shape ของแต่ละตัวตามสไลด์ (\(m\) = จำนวนตัวอย่างใน mini-batch):

ตรวจกับ §2: \(n_{neurons} = 16, n_{inputs} = 14\) ⇒ \(W\) มี \((16 + 14) \times 16 = 480\) ค่า และ \(b_a\) มี 16 ค่า รวม 496.

4. ชนิดของ RNN

RNN แบ่งชนิดตามความยาวของ input (\(T_x\)) และ output (\(T_y\)). หน้า 10 แสดงสองชนิดแรก: sequence-to-vector ซึ่งรับรีวิวหนังสือทั้งข้อความแล้วให้คะแนนดาวค่าเดียว และ vector-to-sequence ซึ่งรับ input เดียวแล้วสร้างลำดับ โดยเส้นโค้งสีส้มในแผนภาพคือ output ของแต่ละ step ที่ถูกป้อนกลับเป็น input ของ step ถัดไป. หน้า 11 แสดงอีกสองชนิด. ตารางใต้รูปรวมทั้งสี่ชนิด.

กรณีแปลภาษา: "Good Morning" มี 2 คำ ส่วนคำแปลมีจำนวน token ต่างออกไป ความยาวของ input และ output ไม่จำเป็นต้องเท่ากัน จึงใช้แบบ sequence-to-sequence ตรงๆ (\(T_x = T_y\)) ไม่ได้. ใน Keras: sequence-to-vector ใช้ return_sequences=False (default); sequence-to-sequence ใช้ return_sequences=True.

5. BPTT และปัญหาของ Simple RNN

BPTT คือ backpropagation บน network ที่คลี่ตามเวลา. Cost function รวม loss ของทุก time step: \(\text{Cost}(\hat{y}^{\langle t \rangle}, y^{\langle t \rangle})\). ขั้นตอน:

1. Forward pass ผ่าน unrolled network
2. ประเมินลำดับ output ด้วย cost function
3. ส่ง gradient ของ cost ย้อนกลับผ่าน unrolled network (backward over timesteps)
4. อัปเดต parameter ด้วย gradient ที่คำนวณได้. เนื่องจาก weight ถูกใช้ร่วมกันทุก time step จึงต้องบวก gradient ของทุก time stepเข้าด้วยกัน

หมายเหตุ: loss อาจไม่ใช้ output บางตัว เช่นใน sequence-to-vector RNN ซึ่งคิด loss จาก output สุดท้ายเท่านั้น.

Simple RNN จับ long-range dependencies ได้ไม่ดี. ตัวอย่างในสไลด์: "That man who met Tenjiro … is my neighbor." กริยา "is" (เอกพจน์) ต้องสอดคล้องกับประธาน "man" ซึ่งอยู่ห่างไปหลายคำ. เมื่อถึง "is" RNN ต้องยังจำได้ว่าประธานเป็นเอกพจน์.

สาเหตุคือ vanishing gradient problem ซึ่งเป็นผลแบบเดียวกับ feedforward network ที่ลึกหลาย layer (Lesson 5):

• Gradient เป็นผลคูณต่อเนื่องที่ลดลงแบบ exponential ตามจำนวน layer. ใน RNN จำนวน "layer" คือจำนวน time step
• Network ที่มี time step มากอาจกลายเป็น untrainable
• เทคนิคอย่าง parameter initialization, faster optimizers, dropout ช่วยบรรเทาได้ระดับหนึ่ง. การแก้ให้หมดต้องใช้ better architectures

6. GRU (Gated Recurrent Unit)

GRU (Kyunghyun Cho et al., 2014) เพิ่มทางส่งข้อมูลข้ามหลาย time step. ใน GRU memory cell คือ hidden state: \(c^{\langle t \rangle} = a^{\langle t \rangle}\). สมการของ GRU แบบ simplified:

memory ใหม่ = (ส่วนที่ gate เปิด) × ค่าใหม่ที่เสนอ + (ส่วนที่ gate ปิด) × memory เดิม

• \(\tilde{c}^{\langle t \rangle}\) = candidate hidden state: ค่าใหม่ที่เสนอให้เขียนลง memory (สูตรเดียวกับ \(a^{\langle t \rangle}\) ของ simple RNN)
• \(\Gamma_u\) = update gate. Role: update relevant information in the carry dataflow. เป็น sigmoid จึงอยู่ระหว่าง 0 ถึง 1
• \(c^{\langle t \rangle}\) = current (updated) hidden state

ตารางในสไลด์ใช้ประโยค "Man who met Tenjiro, is …": \(\Gamma_u\) = 1, 0, 0, 0, ? ที่ step 1–5.

GRU เต็มรูปเพิ่ม \(\Gamma_r\) (relevant หรือ reset gate) ซึ่งตัดสินว่าจะทิ้งข้อมูลก่อนหน้าหรือไม่: ควบคุม how much of the previous hidden state \(c^{\langle t-1 \rangle}\) is relevant เมื่อคำนวณ candidate hidden state.

สิ่งที่ต่างจากแบบ simplified มีจุดเดียว: ใน \(\tilde{c}^{\langle t \rangle}\) memory เดิมถูกคูณด้วย \(\Gamma_r\) ก่อน. ถ้า \(\Gamma_r = 0\) candidate ถูกสร้างจาก input ปัจจุบันอย่างเดียว (เริ่มใหม่โดยไม่สนอดีต).

• GRU cell เป็นรุ่นย่อของ LSTM cell และทำงานได้ดีพอกัน
• Gate controller ตัวเดียว \(\Gamma_u\) ควบคุมทั้ง update gate และ forget gate. ถ้าให้ค่า 1: update gate เปิดเต็ม (= 1) และ forget gate ปิดสนิท (\(1 - 1 = 0\)). กล่าวคือ เมื่อจะเก็บ memory ใหม่ ตำแหน่งที่จะเก็บถูกลบก่อน
• ในทางปฏิบัติ gate เป็น vector ที่มีค่าในช่วง [0, 1] จาก sigmoid
• \(\Gamma_r\) ตัดสินว่าจะทิ้งข้อมูลก่อนหน้าหรือไม่

7. LSTM (Long Short-Term Memory)

LSTM (Hochreiter & Schmidhuber, 1997) มี state สองตัวและ gate สามตัว:

long-term memory ใหม่ = (update gate × ค่าใหม่) + (forget gate × ค่าเดิม); short-term state = output gate × tanh ของ long-term memory

แผนภาพล่างของสไลด์แสดง LSTM cell ต่อกันตามเวลา: เส้นบน (\(c\)) วิ่งผ่านทุก cell โดยมีเพียงการคูณกับ \(\Gamma_f\) และการบวก; เส้นล่าง (\(a\)) ถูกใช้คำนวณ gate ของ cell ถัดไปและส่งเข้า softmax เพื่อให้ \(\hat{y}\).

LSTM เรียนรู้ที่จะจำแนก input ที่สำคัญ (บทบาทของ update gate), เก็บไว้ใน long-term state, รักษาไว้ตราบเท่าที่จำเป็น (บทบาทของ forget gate) และดึงออกมาเมื่อต้องการ.

• State ของ LSTM แบ่งเป็น 2 vector คือ \(c^{\langle t \rangle}\) และ \(a^{\langle t \rangle}\). \(a^{\langle t \rangle}\) คือ short-term state และ \(c^{\langle t \rangle}\) คือ long-term state
• Gate controller (\(\Gamma_u, \Gamma_f, \Gamma_o\)) ใช้ logistic activation function (sigmoid) output จึงเป็น vector ในช่วง 0 ถึง 1. Output ถูกนำไปคูณแบบ element-wise: ให้ค่า 0 คือปิด gate, ให้ค่า 1 คือเปิด
• Network จึงเรียนได้ว่าจะเก็บอะไรใน long-term state, ทิ้งอะไร และอ่านอะไรออกมา
• เทียบ LSTM กับ GRU: GRU เป็นรุ่นย่อ; LSTM มีความสามารถมากกว่า (much more powerful)

Role ตามสไลด์: \(\Gamma_f\) = forget irrelevant information in the carry dataflow; \(\Gamma_o\) = how much to reveal of a cell. ความต่างหลักสองข้อ: (1) GRU ผูก forget กับ update ไว้ด้วยกัน (\(1 - \Gamma_u\)) แต่ LSTM แยก \(\Gamma_f\) เป็นอิสระ จึงเพิ่มข้อมูลใหม่โดยไม่ลบของเดิมได้; (2) LSTM มี \(\Gamma_o\) กรองสิ่งที่เปิดเผยออกจาก cell.

8. Exploding Gradient, Recurrent Dropout, Bidirectional และ Deep RNN

อีกปัญหาของ RNN คือ exploding gradient problem (easily detectable, e.g. NaN): loss หรือ weight กลายเป็น NaN.

• Nonsaturating activation (เช่น ReLU) อาจไม่ช่วย: weight ชุดเดียวถูกใช้ซ้ำทุก time step ค่าที่ไม่มีขอบบนจึงโตสะสมได้. ให้ใช้ saturating activation เช่น hyperbolic tangent. ซึ่งจำกัด output ไว้ในช่วง (−1, 1). ข้อนี้กลับกันกับคำแนะนำสำหรับ feedforward network ใน Lesson 5
• ลดความเสี่ยงด้วย smaller learning rate หรือ gradient clipping

ภาพล่างของสไลด์: without gradient clipping เส้นทางการอัปเดตกระโดดข้ามหุบของ cost ไปมาเป็นช่วงยาว; with gradient clipping ก้าวสั้นลงและเข้าหาจุดต่ำสุด.

1. Recurrent dropout. นอกจาก dropout ปกติ ตระกูล RNN มี recurrent dropout: dropout ที่ใช้กับ recurrent connection ภายใน RNN. สุ่มตัด recurrent connection บางเส้นระหว่างเทรนเพื่อป้องกัน overfitting.

2. Bidirectional-RNN/LSTM/GRU. ให้ผลดีกว่า RNN ปกติในบางงาน โดยเฉพาะงานที่ลำดับย้อนกลับมีความหมาย. ตัวอย่างในสไลด์เป็นสองประโยคที่เหมือนกันจนถึงคำว่า "Donal" แล้วต่างกันที่คำถัดไป: การตีความคำหนึ่งต้องอาศัยคำที่ตามมา ซึ่ง RNN ทิศเดียวยังไม่เห็น. Bidirectional RNN มี RNN สองตัว อ่านซ้ายไปขวาและขวาไปซ้าย แล้วต่อ output เข้าด้วยกัน.

model = Sequential()
model.add(Bidirectional(LSTM(16, recurrent_dropout=0.2),
                        input_shape=(None, raw_data.shape[-1])))
model.add(Dropout(0.2))
model.add(Dense(1))

3. Deep (Bi-)RNN/GRU/LSTM. ซ้อน recurrent layer หลายชั้น (RNN, GRU, LSTM, Bi-RNN, Bi-GRU, Bi-LSTM) เพื่อเพิ่ม capacity ของ network. ต้องตั้ง return_sequences=True ให้ recurrent layer ทุกชั้น ยกเว้นชั้นสุดท้าย (ถ้าสนใจเฉพาะ output สุดท้าย).

model = Sequential()
model.add(layers.LSTM(16, recurrent_dropout=0.2, return_sequences = True,
                      input_shape=(None, raw_data.shape[-1])))
model.add(layers.LSTM(16, recurrent_dropout=0.2))
model.add(layers.Dropout(0.2))
model.add(layers.Dense(1))

9. Temperature Forecasting: กลยุทธ์และการเตรียม Dataset

• Dataset: weather timeseries dataset จากสถานีตรวจอากาศที่ Max Planck Institute for Biogeochemistry เมือง Jena ประเทศเยอรมนี
• มี 14 different quantities (อุณหภูมิอากาศ, ความดัน, ความชื้น, ทิศทางลม ฯลฯ) recorded every 10 minutes ต่อเนื่องหลายปี
• ข้อมูลเดิมเริ่มปี 2003 แต่ตัวอย่างนี้ใช้ช่วง 2009–2016
• Goal: สร้างโมเดลที่รับข้อมูลช่วงที่ผ่านมา (เช่น 5 วัน) แล้ว predicts the air temperature 24 hours in the future

Note: เมื่อใช้ RNN โดยทั่วไปไม่จำเป็นต้องเอา trend และ seasonality ออก แต่บางกรณีการเอาออกช่วยให้ผลดีขึ้น เพราะโมเดลไม่ต้องเรียน trend หรือ seasonality เอง.

กราฟซ้าย (ทุกวัน, ราว 420,000 จุด): อุณหภูมิแกว่งระหว่างราว −20 ถึง 35 °C เป็นคลื่นรายปีที่ชัดเจน 8 รอบ (2009–2016). การทำนายอุณหภูมิเฉลี่ยของเดือนใดเดือนหนึ่งจากรูปแบบรวมจึงง่ายมาก. กราฟขวา (10 วันแรก, 1,440 จุด): อุณหภูมิเริ่มราว −8 °C ขึ้นไปใกล้ 0 แล้วดิ่งลงถึงราว −23 °C โดยไม่มีรูปแบบรายวันที่สม่ำเสมอ. อุณหภูมิรายวัน "more chaotic" และเป็นโจทย์ที่ยากกว่า.

โจทย์: ต้องการทำนาย 10 step ข้างหน้า. (1) Recursive forecasting: ทำนายครั้งละ one step at a time แล้วป้อนคำทำนายกลับเป็น input ถัดไป.

เรียบง่าย แต่ error สะสมได้: \(\hat{x}_{52}\) คำนวณจาก \(\hat{x}_{51}\) ซึ่งมี error อยู่แล้ว. กราฟในสไลด์แสดง Actual (แดง) กับ Forecast (น้ำเงิน) ที่ step 50–60: สองเส้นซ้อนกันในสองสาม step แรกแล้วถ่างออก จน step 60 ค่าจริงอยู่ราว −0.25 แต่คำทำนายอยู่ราว −0.6. ข้อสรุปที่สไลด์ทำสี: Larger errors for later time steps!!

สไลด์ตั้งชื่อ (3) ซ้ำกับ (2) ว่า "Direct multi-output forecasting" แต่เนื้อหาคือการทำนาย horizon เดียว. สำหรับ (2) และ (3): การทำนาย horizon ไกลยากกว่าเพราะขึ้นกับพัฒนาการในอนาคตที่ไม่แน่นอนกว่า. แบบฝึกหัดอุณหภูมิใช้ strategy (3) ทำนาย target ที่ 24 ชั่วโมงข้างหน้า.

เชื่อมกับ §4: (3) คือ sequence-to-vector; (4) คือ sequence-to-sequence (return_sequences=True) ซึ่งลดปัญหา gradient ที่ต้องไหลย้อนไกลใน §5.

ใช้ timeseries_dataset_from_array() สร้าง 3 dataset (training, validation, test). สไลด์ทดสอบกับลำดับจำนวนเต็มก่อน:

# testing timeseries_dataset_from_array()
int_sequence = np.arange(10)
dummy_dataset = timeseries_dataset_from_array(
  # CHANGE THIS TO -1 FROM ORGINAL CODE
  data = int_sequence[:-1],
  # the target for the sequece that strats at data(N) will be data[N+3])
  targets=int_sequence[3:],
  sequence_length = 3, # a sequence will be 3 steps long
  batch_size=2
)

for inputs, targets in dummy_dataset:
  #print(inputs, targets)
  for i in range(inputs.shape[0]):
    print([int(x) for x in inputs[i]], int(targets[i]))

ผลลัพธ์ที่พิมพ์ในสไลด์:

[0, 1, 2] 3
[1, 2, 3] 4
[2, 3, 4] 5
[3, 4, 5] 6
[4, 5, 6] 7
[5, 6, 7] 8
[6, 7, 8] 9

ได้ 7 หน้าต่าง: \(9 - 3 + 1 = 7\) (data 9 ตัว, หน้าต่างยาว 3). แต่ละแถวคือ "สามค่าติดกัน แล้วค่าถัดไป". ด้วย batch size 2 จึงมี \(\lceil 7/2 \rceil = 4\) batch.

# use timeseries_dataset_from_array() to instantiate 3 datasets (training, validation and test set)
sampling_rate = 6 # now the data point will be in hourly scale
sequence_length = 120 # observation will go back 5 days (120 hours)
delay = sampling_rate * (sequence_length + 24 - 1) # the target for a sequence will be the temperature 24 hours after the end of the sequence
batch_size = 256

train_dataset = keras.utils.timeseries_dataset_from_array(
    # CHANGE -delay TO -144 FROM ORGINAL CODE
    raw_data[:-144],
    targets=temp[delay:],
    sampling_rate=sampling_rate,
    sequence_length=sequence_length,
    shuffle=True, # two consecutive sequence in a batch aren't necessaary temporally close.
    batch_size=batch_size,
    start_index=0,
    end_index=num_train_samples)

10. Deep Learning กับข้อความ: NLP, ความท้าทาย และการเตรียมข้อความ

NLP คือสาขาที่มุ่งให้คอมพิวเตอร์สามารถประมวลผลและ understand human language และสามารถ predict หรือ generate สิ่งที่มีประโยชน์. แผนภาพซ้าย: NLP เป็นสาขาใน AI ที่ซ้อนทับบางส่วนกับ ML และ DL (NLP บางส่วนไม่ใช้ ML เช่น ระบบ rule-based). แผนภาพขวาเรียงงาน NLP จากง่ายไปยาก:

1. Words โดยลำพังมี no real meaning. ความหมายมาจากการใช้คำใน context ที่กว้างกว่า
2. order of words สำคัญมาก คำที่เรียงกลับไม่มีความหมาย และมักมี long-term sequential dependencies ระหว่างคำที่โมเดลต้องจับให้ได้ (ปัญหาของ §5)
3. Textual data มี rules-based grammatical structure. "The cat sat on the having" ผิดไวยากรณ์. ความหมาย (semantics) ก็เป็นความท้าทาย: "I am in the beach" ถูกไวยากรณ์แต่ไม่สมเหตุสมผล
4. Textual data ไวต่อการเปลี่ยนแปลงเล็กน้อยของหน่วยย่อย (คำหรือตัวอักษร). เปลี่ยนไม่กี่คำก็เปลี่ยนความหมายทั้งข้อความได้. การเทรนโมเดลให้สร้างข้อความที่ต่อเนื่องจึงยาก เพราะ every word is vital to the overall meaning of the passage

ข้อ 4 ต่างจากภาพ: เปลี่ยนค่า pixel หนึ่งจุดจาก 120 เป็น 121 ภาพยังเป็นภาพเดิม แต่เปลี่ยน "not" หนึ่งคำ ประโยคมีความหมายตรงข้าม.

Vectorized text คือกระบวนการ transforming text into vectorized arrays (numeric tensors). มี 3 ขั้น:

ประโยคตัวอย่างมี 8 token จึงเป็นลำดับยาว \(T_x = 8\) และ label ของงาน sentiment คือ \(y\) ค่าเดียว (ดาวสีน้ำเงินหรือแดงในสไลด์) ซึ่งเป็นงาน sequence-to-vector. มี 7 คำที่ไม่ซ้ำ เพราะ "was" ปรากฏสองครั้ง (ตำแหน่ง 2 และ 7).

11. One-Hot Encoding และปัญหา

One-hot encoding: ให้ index กับทุกคำ แล้วแทนแต่ละคำด้วย binary vector ที่ยาวเท่าขนาด vocabulary โดยเป็นศูนย์ทั้งหมดยกเว้นตำแหน่งของ index ของคำนั้น. สไลด์ใช้ vocabulary 20,000 คำ.

• One-hot มองแต่ละคำ as atomic units (ความหมายตรงตัวของคำ แต่ not its context) จึงไม่ช่วยให้อัลกอริทึม generalize ข้าม different words. ตัวอย่าง: โมเดลเห็น "story are short tales" แล้วต้องเติมช่องว่างใน "novel are ____ works of fictions". ถ้ารู้ว่า "novel" คล้าย "story" (ทั้งคู่เป็นงานเขียน) ก็เดาได้ว่าคำที่เติมน่าจะเป็นคำบอกความยาว (ตรงข้ามกับ "short"). แต่ one-hot ของ "story" และ "novel" ตั้งฉากกัน: ผลคูณ dot product เป็น 0 เท่ากับคู่คำอื่นทุกคู่ ความคล้ายจึงไม่ปรากฏ. ถ้ารู้ semantics representation ของคำ จึงจะเรียน feature ที่ใช้ร่วมกันได้
• ขนาดของ one-hot vector แปรผันตรงกับขนาด vocabulary จึง computationally inefficient ทั้งการเก็บ การคำนวณ และการเรียน (sparsity leads to overfitting)
• ปัจจุบัน one-hot ไม่ค่อยถูกใช้

BOW นับว่าแต่ละคำปรากฏกี่ครั้งในเอกสาร โดยไม่สนลำดับ. TF-IDF ถ่วงน้ำหนักจำนวนนั้นด้วยความหายากของคำในคลังเอกสาร: คำที่พบในทุกเอกสาร (เช่น "the") ได้น้ำหนักต่ำ. ทั้งสองยังเป็น vector ยาวเท่า vocabulary.

12. Word Embeddings

Word embeddings คือ array ของ word vector ที่แทนแต่ละคำด้วย array ของ floating-point. Vector เหล่านี้เข้ารหัสความหมายของคำและความสัมพันธ์ระหว่างคำ.

• ต่างจาก sparse word vector: word embeddings เป็น dense, relatively low dimensional จึงลดขนาดของ training example และเรียนได้เร็วจาก semantic relationship of words. ที่คล้ายกัน
• การเคลื่อนที่เฉพาะทิศใน vector space แทนความสัมพันธ์เชิงความหมาย ระหว่างคำ

วิธีที่ง่ายที่สุดคือเรียน word embeddings ไปพร้อมกับงานหลัก (สไลด์เรียกว่า unsupervised way เพราะ label มาจากตัวข้อความเอง). Embedding layer แปลง integer index (ที่แทนคำ) เป็น dense vector. ตัวอย่างของสไลด์: vocabulary 10,000 คำ ใช้ 3 คำก่อนหน้า (X) ทำนายคำถัดไป (y).

Embedding Matrix \(E\) มี shape (8, 10000): 8 แถวคือ 8 มิติของ semantic representation และ 10,000 คอลัมน์คือคำในลำดับ a … dog … zoo. คอลัมน์ที่ 6222 คือ embedding ของคำที่ 6222. การหยิบคอลัมน์เขียนเป็นผลคูณกับ one-hot vector:

คูณ matrix กับ one-hot vector = หยิบคอลัมน์ที่ตรงกับตำแหน่งของเลข 1

สองวิธีใช้ embedding กับงาน text classification. ในทั้งสองรูป คำถูกแปลงเป็น index ก่อน (every → 23, good → 3, boy → 16, does → 74, fine → 89) แล้ว Embedding layer แปลง index เป็น word vector.

แทนการเรียน embedding เอง สามารถโหลด embedding vectors จาก embedding space ที่คำนวณไว้แล้ว ซึ่งมีโครงสร้างดีและจับลักษณะทั่วไปของภาษา. เป็นแนวคิดเดียวกับ transfer learning ของ Lesson 8 §8. Embedding ชนิดนี้มองได้เป็น a large collection of key-value pairs: keys are the words ใน vocabulary และ values are their corresponding word vectors.

Word2Vec เรียน embedding แบบ self-supervised: label สร้างจากตัวข้อความเอง. มีสองรูปแบบ. แบบแรกคือ Continuous bag of words (CBOW): สร้าง language model ที่ทำนาย center word จาก context words รอบๆ. CBOW ไม่ได้บวก one-hot vector ตรงๆ: มัน lookup embedding ของ context word, รวมเข้าด้วยกัน (SUM ในแผนภาพ) แล้วเรียน embedding matrix จากการทำนาย center word.

ตัวอย่างจาก "The quick brown fox jumps over the lazy dog." ด้วยหน้าต่าง 2 คำแต่ละข้าง. Training sample มีรูป (context, target):

"The" อยู่ต้นประโยคจึงมี context เฉพาะด้านขวา 2 คำ; "quick" มี 3 คำ; "brown" และ "fox" มีครบ 4 คำ. CBOW ให้ 1 sample ต่อ center word.

SkipGram คล้าย CBOW แต่กลับทิศงานทำนาย: ให้ center word แล้วทำนาย context words รอบๆ. โดยทั่วไป slower to train กว่า CBOW แต่มักเรียน representation ของ rare words ได้ดีกว่า เพราะแต่ละ center word ถูกใช้ทำนาย context หลายคำ และทำงานได้ดีกับ smaller datasets.

13. โค้ด IMDB: TextVectorization, TF-IDF, Embedding + Bidirectional LSTM และ Masking

โฟลเดอร์ train/pos/ มีไฟล์ข้อความ 12,500 ไฟล์ แต่ละไฟล์คือรีวิวภาพยนตร์เชิงบวก; รีวิวเชิงลบอยู่ใน neg. รวม 25,000 ไฟล์สำหรับ training และอีก 25,000 สำหรับ testing.

# These datasets yield inputs that are TensorFlow tf.string tensors and targets that are
# int32 tensors encoding the value "0" or "1."
batch_size = 32

train_ds = keras.utils.text_dataset_from_directory(
    "aclImdb/train", batch_size=batch_size
)
val_ds = keras.utils.text_dataset_from_directory(
    "aclImdb/val", batch_size=batch_size
)
test_ds = keras.utils.text_dataset_from_directory(
    "aclImdb/test", batch_size=batch_size
)
# Prepare a dataset that only yields raw text inputs (no labels) fot TextVectorization
text_only_train_ds = train_ds.map(lambda x, y: x)

for inputs, targets in train_ds:
    print("inputs.shape:", inputs.shape)
    print("inputs.dtype:", inputs.dtype)
    print("targets.shape:", targets.shape)
    print("targets.dtype:", targets.dtype)
    print("inputs[0]:", inputs[0])
    print("targets[0]:", targets[0])
    break

ผลลัพธ์ที่พิมพ์ในสไลด์: Found 20000 files belonging to 2 classes. (train), Found 5000 files (val), Found 25000 files (test); inputs.shape: (32,), inputs.dtype: <dtype: 'string'>, targets.shape: (32,), targets.dtype: <dtype: 'int32'>, targets[0]: tf.Tensor(1, shape=(), dtype=int32).

Training 25,000 ไฟล์ถูกแบ่งเป็น train 20,000 และ validation 5,000 (\(20{,}000 + 5{,}000 = 25{,}000\); validation = 20%). Input ยังเป็น string (หนึ่งรีวิวต่อหนึ่งสมาชิก) ไม่ใช่ตัวเลข จึงมี shape (32,) มิติเดียว. จำนวน batch ต่อ epoch: train \(20{,}000 / 32 = 625\); test \(\lceil 25{,}000 / 32 \rceil = \lceil 781.25 \rceil = 782\) ตรงกับ 625/625 และ 782/782 ใน log ของหน้า 43–44.

TextVectorization layer ทำสามขั้นของ §10 ในตัวเดียว. ค่า default: convert to lowercase และ remove punctuation สำหรับ text standardization และ split on whitespace สำหรับ tokenization.

text_vectorization = TextVectorization(
    max_tokens=20000,
    output_mode="int", # Configures the layer to return sequences of words encoded as integer indices.
)

# index the vocabulary of a text corpus using adapt() method
text_vectorization.adapt(text_only_train_ds)

# # retrieve the computed vocabulary
# There are two special tokens that you will commonly use:
# the mask token (index 0) for padding and the OOV token (index 1) - not recognize words
vocabulary = text_vectorization.get_vocabulary()
vocabulary

ตัวอย่าง: ถ้า vocabulary คือ ["", "[UNK]", "the", "movie", "was", "great"] ประโยค "The movie was GREAT!!" ถูก standardize เป็น "the movie was great" แล้วได้ [2, 3, 4, 5]. ประโยค "The film was great" ได้ [2, 1, 4, 5] เพราะ "film" ไม่อยู่ใน vocabulary จึงได้ index 1.

แนวทางแรก: bag-of-bigrams ถ่วงน้ำหนักด้วย TF-IDF แล้วป้อนเข้า dense model. แต่ละรีวิวกลายเป็น vector ยาว 20,000 ค่าเดียว (ไม่ใช่ลำดับ).

text_vectorization = TextVectorization(
    ngrams=2,
    max_tokens=20000,
    output_mode="tf_idf",
)
text_vectorization.adapt(text_only_train_ds)
tfidf_2gram_train_ds = train_ds.map(
    lambda x, y: (text_vectorization(x), y),
    num_parallel_calls=4)
tfidf_2gram_val_ds = val_ds.map(
    lambda x, y: (text_vectorization(x), y),
    num_parallel_calls=4)
tfidf_2gram_test_ds = test_ds.map(
    lambda x, y: (text_vectorization(x), y),
    num_parallel_calls=4)

model = get_model()

model.fit(tfidf_2gram_train_ds,
          validation_data=tfidf_2gram_val_ds,
          epochs=10,
          callbacks=[model_checkpoint_cb3, reduce_lr_cb])
model = keras.models.load_model("model3")
print(f"Test acc: {model.evaluate(tfidf_2gram_test_ds)[1]:.3f}")

ผลลัพธ์ที่พิมพ์: loss ลดจาก 0.4783 (epoch 1) เหลือ 0.2232 (epoch 10); Test acc: 0.892. Bigram คืนข้อมูลลำดับระยะสั้นบางส่วน: "not good" เป็น token เดียวที่ต่างจาก "good".

แนวทางที่สอง: sequence model. ข้อความถูกแปลงเป็นลำดับของ index (output_mode="int") แล้วผ่าน Embedding และ Bidirectional LSTM. โค้ดนี้ใช้ Functional API ของ Lesson 9 §1.

inputs = Input(shape=(None,), dtype="int64")
# Instantiating an Embedding layer
embedded = Embedding(input_dim=max_tokens, output_dim=256, mask_zero=True)(inputs)
# Add a bidirectional LSTM.
x = Bidirectional(LSTM(32))(embedded)
x = Dropout(0.5)(x)
# Add a classification Layer
outputs = Dense(1, activation="sigmoid")(x)
model = Model(inputs, outputs)

ประโยคใน batch เดียวกันต้องยาวเท่ากัน ประโยคที่สั้นกว่าความยาวสูงสุดจึงถูก pad ด้วยศูนย์ที่ท้าย. ถ้าประโยคเต็มไปด้วยศูนย์ ประสิทธิภาพอาจลดลง เพราะข้อมูลใน internal state จะค่อยๆ จางเมื่อ RNN ประมวลผล input ที่ไม่มีความหมายเหล่านี้ต่อเนื่อง. Masking เป็นวิธีบอกโมเดลให้ skip processing input เหล่านี้.

embedding_layer_dummy = Embedding(input_dim=10, output_dim=256, mask_zero=True)
some_input = [
    [1,2,3,4,5],
    [6,7,0,0,0],
    [8,9,10,0,0]
]
mask_test = embedding_layer_dummy.compute_mask(some_input)
mask_test

ผลลัพธ์ที่พิมพ์ในสไลด์:

<tf.Tensor: shape=(3, 5), dtype=bool, numpy=
array([[ True,  True,  True,  True,  True],
       [ True,  True, False, False, False],
       [ True,  True,  True, False, False]])>

Mask มี shape (3, 5) เท่า input. แถวที่สองมี True 2 ตัวตรงกับ token 6, 7 และ False 3 ตัวตรงกับศูนย์สามตัว. RNN จะหยุดอัปเดต state ที่ตำแหน่ง False: state หลัง token 7 ถูกส่งต่อไปเป็น output โดยไม่ถูกรบกวนจาก padding. รวมมี token จริง \(5 + 2 + 3 = 10\) จาก 15 ตำแหน่ง.

ภาคผนวก: Slide ทั้งหมดใน deep_learning_part4.1.pdf (45 หน้า) — เช็คว่าอ่านครบ

สงสัยตรงไหน ถามได้เลยในแชท — ผมเป็นผู้สอนของคุณ ถามซ้ำได้ ถามลึกได้ ไม่ต้องเกรงใจ.