Temporal Fusion Transformer สำหรับการพยากรณ์พอร์ตการลงทุนแบบหลายช่วงเวลา

ความน่าหงุดหงิดที่สุดในการนำ deep learning มาใช้กับการจัดการพอร์ตการลงทุนคือปัญหา black-box คุณฝึกโครงข่ายประสาทเทียมที่ให้ค่า Sharpe ratio น่าประทับใจในการทำ backtest แต่เมื่อกลยุทธ์เริ่มขาดทุนในการใช้งานจริง คุณกลับไม่รู้เลยว่า ทำไม ฟีเจอร์อินพุตตัวไหนที่ขับเคลื่อนการพยากรณ์ ช่วงเวลาใดที่มีความสำคัญ โมเดลกำลังตอบสนองต่อสัญญาณมหภาคหรือสัญญาณรบกวนระดับ microstructure กันแน่

Google Research จัดการปัญหานี้โดยตรงด้วย Temporal Fusion Transformer (TFT) -- สถาปัตยกรรมที่อิงกลไก attention ซึ่งให้การพยากรณ์แบบหลายช่วงเวลาที่ทรงพลัง พร้อมความสามารถในการตีความที่มีมาในตัวผ่านค่าน้ำหนัก attention และคะแนนความสำคัญของตัวแปร ในการทดสอบเชิงเปรียบเทียบเดิม TFT ลด quantile loss ลงโดยเฉลี่ย 7% (P50) และ 9% (P90) เมื่อเทียบกับโมเดลที่ดีที่สุดรองลงมา และดีกว่า baseline คู่แข่งที่แข็งแกร่งที่สุด 3-26% ในชุดข้อมูลทดสอบต่าง ๆ สำหรับผู้จัดการพอร์ตการลงทุนเชิงปริมาณ TFT มอบสิ่งที่หาได้ยาก นั่นคือโมเดลที่ทั้งทรงพลังและโปร่งใส

บทความนี้จะแยกชำแหละสถาปัตยกรรมของ TFT แสดงวิธีนำมาประยุกต์กับการพยากรณ์พอร์ตการลงทุนแบบหลายช่วงเวลา พาเดินผ่านการนำไปใช้งานด้วย Python และไลบรารี pytorch-forecasting และเปรียบเทียบกับ baseline อย่าง LSTM และ transformer แบบดั้งเดิม

ทำไมการพยากรณ์แบบหลายช่วงเวลาจึงสำคัญต่อพอร์ตการลงทุน

การพยากรณ์แบบขั้นเดียวตามแบบดั้งเดิมจะทำนายค่าเดียว ณ เวลา $t+1$ แต่การตัดสินใจจัดสรรพอร์ตการลงทุนดำเนินไปในหลายช่วงเวลาพร้อม ๆ กัน ผู้จัดการพอร์ตจำเป็นต้องรู้ว่า

• ช่วง 1 วัน: สำหรับการปรับสมดุลภายในวันและการบริหารความเสี่ยง
• ช่วง 1 สัปดาห์: สำหรับการปรับการจัดสรรเชิงยุทธวิธี
• ช่วง 1 เดือน: สำหรับการจัดสรรเชิงกลยุทธ์และการสลับหมุนเวียนกลุ่มอุตสาหกรรม
• ช่วง 1 ไตรมาส: สำหรับการวางตำแหน่งที่ขับเคลื่อนด้วยปัจจัยมหภาค

แต่ละช่วงเวลามีลักษณะอัตราส่วนสัญญาณต่อสัญญาณรบกวน (signal-to-noise) ที่แตกต่างกัน ผลตอบแทนระยะสั้นถูกครอบงำด้วย microstructure และการไหลของคำสั่งซื้อขาย ผลตอบแทนระยะกลางตอบสนองต่อโมเมนตัมและการกลับสู่ค่าเฉลี่ย (mean-reversion) ส่วนผลตอบแทนระยะยาวขับเคลื่อนด้วยปัจจัยพื้นฐานและสภาวะตลาดมหภาค

โมเดลที่ผลิตการพยากรณ์ครอบคลุมทุกช่วงเวลาเหล่านี้พร้อมกัน -- พร้อมประมาณการความไม่แน่นอนแบบควอนไทล์ในแต่ละช่วง -- ย่อมมีประโยชน์มากกว่าการแยกโมเดลสำหรับแต่ละช่วงเวลาโดยพื้นฐาน และนี่คือสิ่งที่ TFT มอบให้พอดี เมื่อกำหนดหน้าต่าง encoder ของการสังเกตในอดีต มันจะให้เอาต์พุตเป็นชุดของการพยากรณ์แบบควอนไทล์สำหรับ $\tau = 1, 2, \ldots, \tau_{max}$ ก้าวไปข้างหน้า

ในเชิงรูปนัย เมื่อกำหนดอนุกรมเวลาแบบหลายตัวแปรที่มีการสังเกต $\{y_{i,t}, \mathbf{x}_{i,t}, \mathbf{s}_i\}$ สำหรับเอนทิตี $i$ ณ เวลา $t$ โดยที่ $y$ คือเป้าหมาย $\mathbf{x}_t$ คือฟีเจอร์ที่แปรเปลี่ยนตามเวลา และ $\mathbf{s}_i$ คือ metadata แบบคงที่ TFT จะเรียนรู้

$\hat{y}_{i}(q, t, \tau) = f_q\left(y_{i,t-k:t}, \mathbf{x}_{i,t-k:t+\tau}, \mathbf{s}_i\right)$

โดยที่ $q$ คือควอนไทล์ (ทำให้พยากรณ์เชิงความน่าจะเป็นได้) $k$ คือหน้าต่างย้อนหลัง (lookback window) และ $\tau$ คือช่วงเวลาของการพยากรณ์

สถาปัตยกรรม TFT: เต็มสแต็ก

TFT ไม่ใช่ transformer ทั่ว ๆ ไปที่เอามาแปะไว้บนอนุกรมเวลา แต่เป็นสถาปัตยกรรมที่สร้างขึ้นมาเพื่อจุดประสงค์เฉพาะ ด้วยองค์ประกอบเฉพาะทางห้าส่วน แต่ละส่วนจัดการกับความท้าทายเฉพาะเจาะจงในการพยากรณ์เชิงเวลา

1. Gated Residual Networks (GRN)

GRN เป็นบล็อกพื้นฐานในการสร้าง TFT ซึ่งถูกใช้ตลอดทั้งสถาปัตยกรรมในทุกที่ที่ต้องการการประมวลผลแบบไม่เชิงเส้น ต่างจากเลเยอร์ feed-forward มาตรฐาน GRN ผนวกรวม skip connection และกลไก gating ที่ยอมให้โครงข่ายควบคุมการไหลของสารสนเทศได้อย่างปรับตัว

เมื่อกำหนดอินพุตหลัก $\mathbf{a}$ และเวกเตอร์บริบท (context vector) $\mathbf{c}$ ที่เป็นทางเลือก GRN จะคำนวณ

$\text{GRN}_\omega(\mathbf{a}, \mathbf{c}) = \text{LayerNorm}\left(\mathbf{a} + \text{GLU}_\omega(\boldsymbol{\eta}_1)\right)$

โดยที่

$\boldsymbol{\eta}_1 = \mathbf{W}_{1,\omega} \boldsymbol{\eta}_2 + \mathbf{b}_{1,\omega}$

$\boldsymbol{\eta}_2 = \text{ELU}\left(\mathbf{W}_{2,\omega} \mathbf{a} + \mathbf{W}_{3,\omega} \mathbf{c} + \mathbf{b}_{2,\omega}\right)$

Gated Linear Unit (GLU) คือกลไก gating หลัก

$\text{GLU}(\boldsymbol{\gamma}) = \sigma(\mathbf{W}_{4} \boldsymbol{\gamma} + \mathbf{b}_4) \odot (\mathbf{W}_{5} \boldsymbol{\gamma} + \mathbf{b}_5)$

โดยที่ $\sigma$ คือฟังก์ชัน sigmoid และ $\odot$ หมายถึงการคูณแบบ element-wise เกต sigmoid จะเรียนรู้ว่ามิติไหนของอินพุตที่ควรถูกระงับ ทำให้โมเดลสามารถข้ามการประมวลผลแบบไม่เชิงเส้นที่ไม่จำเป็นไปได้ทั้งหมดเมื่อข้อมูลไม่ต้องการมัน สิ่งนี้สำคัญยิ่งสำหรับข้อมูลทางการเงินที่ฟีเจอร์บางตัวให้สารสนเทศเฉพาะในสภาวะตลาดบางแบบเท่านั้น

2. Variable Selection Networks (VSN)

นี่อาจกล่าวได้ว่าเป็นองค์ประกอบที่มีค่าที่สุดสำหรับการประยุกต์ใช้กับพอร์ตการลงทุน ชุดข้อมูลทางการเงินขึ้นชื่อเรื่องสัญญาณรบกวนมาก โดยมีฟีเจอร์ที่อาจใช้ได้นับสิบ -- ตัวชี้วัดทางเทคนิค อัตราส่วนทางพื้นฐาน ตัวแปรมหภาค คะแนน sentiment -- ซึ่งหลายตัวซ้ำซ้อนหรือไม่เกี่ยวข้อง ณ ช่วงเวลาใดเวลาหนึ่ง

VSN คำนวณค่าน้ำหนักการเลือกแบบนุ่มนวล (soft selection weights) เหนือฟีเจอร์อินพุตทั้งหมด

$\mathbf{v}_{\chi_t} = \text{Softmax}\left(\text{GRN}_{v_\chi}\left(\boldsymbol{\Xi}_t, \mathbf{c}_s\right)\right)$

โดยที่ $\boldsymbol{\Xi}_t$ คือเวกเตอร์ที่ถูกแบนของฟีเจอร์อินพุตที่ผ่านการแปลงทั้งหมด ณ เวลา $t$ และ $\mathbf{c}_s$ คือเวกเตอร์บริบทที่ได้มาจาก metadata แบบคงที่ ฟีเจอร์แต่ละตัวยังถูกประมวลผลผ่าน GRN ของตัวเองด้วย

$\tilde{\boldsymbol{\xi}}^{(j)}_t = \text{GRN}_{\tilde{\xi}^{(j)}}\left(\boldsymbol{\xi}^{(j)}_t\right)$

การแสดงผลที่ถูกเลือกขั้นสุดท้ายคือผลรวมถ่วงน้ำหนัก

$\tilde{\boldsymbol{\xi}}_t = \sum_{j=1}^{m_\chi} v_{\chi_t}^{(j)} \tilde{\boldsymbol{\xi}}^{(j)}_t$

ในบริบทของพอร์ตการลงทุน $v_{\chi_t}^{(j)}$ บอกคุณโดยตรงว่า "ณ เวลา $t$ โมเดลให้น้ำหนักฟีเจอร์ $j$ มากเท่านี้" คุณอาจค้นพบว่า RSI มีบทบาทเด่นในช่วงตลาดแกว่งตัว (ranging market) ในขณะที่ฟีเจอร์เส้นอัตราผลตอบแทนมหภาค (yield curve) มีบทบาทเด่นในช่วงเปลี่ยนผ่านของสภาวะตลาด นี่ไม่ใช่คำอธิบายที่ตามมาทีหลัง (post-hoc) -- แต่ฝังอยู่ในสถาปัตยกรรม

มี VSN แยกต่างหากสำหรับ covariate แบบคงที่ อินพุตที่สังเกตในอดีต และอินพุตอนาคตที่ทราบล่วงหน้า การแยกนี้เคารพโครงสร้างเชิงเหตุผล (causal structure) ของปัญหาการพยากรณ์ คุณไม่สามารถใช้การสังเกตในอนาคตได้ แต่คุณ สามารถ ใช้เหตุการณ์อนาคตที่ทราบล่วงหน้าได้ (วันประกาศผลประกอบการ การประชุม FOMC วันหมดอายุของออปชัน ผลของวันในสัปดาห์)

3. Static Covariate Encoders

ในการพยากรณ์พอร์ตการลงทุน covariate แบบคงที่หมายถึง metadata ระดับเอนทิตีที่ไม่เปลี่ยนแปลงตามเวลา เช่น ประเภทสินทรัพย์ กลุ่มอุตสาหกรรม ตลาดหลักทรัพย์ ช่วงมูลค่าตลาด (market cap bucket) หรือภูมิภาคทางภูมิศาสตร์ TFT ประมวลผลสิ่งเหล่านี้ผ่าน GRN เฉพาะทางเพื่อผลิตเวกเตอร์บริบทที่แตกต่างกันสี่ตัว

• $\mathbf{c}_s$ -- บริบทสำหรับการเลือกตัวแปรเชิงเวลา
• $\mathbf{c}_e$ -- บริบทสำหรับการเสริมข้อมูลแบบคงที่ของฟีเจอร์เชิงเวลา (ใช้หลังจาก LSTM)
• $\mathbf{c}_c$ -- การกำหนดค่าเริ่มต้นของ cell state สำหรับ LSTM
• $\mathbf{c}_h$ -- การกำหนดค่าเริ่มต้นของ hidden state สำหรับ LSTM

นี่คือวิธีที่ TFT จัดการกับสารสนเทศเชิงตัดขวาง (cross-sectional) เมื่อพยากรณ์พอร์ตหุ้น 500 ตัว static encoder ช่วยให้โมเดลเรียนรู้ได้ว่าหุ้นเทคโนโลยีและหุ้นสาธารณูปโภคมีพลวัตเชิงเวลาที่แตกต่างกันโดยพื้นฐาน โดยไม่ต้องใช้โมเดลแยกกัน

4. การประมวลผลเชิงเวลา: LSTM + Interpretable Multi-Head Attention

TFT ใช้ไปป์ไลน์การประมวลผลเชิงเวลาสองขั้นตอนที่ผสานจุดแข็งของสถาปัตยกรรมแบบ recurrent และแบบ attention เข้าด้วยกัน

ขั้นที่ 1: การประมวลผลเฉพาะที่ด้วย LSTM

LSTM encoder-decoder แบบ sequence-to-sequence จะประมวลผลอนุกรมเวลาเพื่อจับรูปแบบเชิงเวลาเฉพาะที่ -- โมเมนตัมระยะสั้น การกลับสู่ค่าเฉลี่ย และโครงสร้าง autoregressive ส่วน encoder ประมวลผลหน้าต่างย้อนหลัง ส่วน decoder ประมวลผลอินพุตอนาคตที่ทราบล่วงหน้า ทั้งสองถูกกำหนดค่าเริ่มต้นด้วยเวกเตอร์บริบทแบบคงที่ $\mathbf{c}_c$ (cell state) และ $\mathbf{c}_h$ (hidden state)

ขั้นที่ 2: การพึ่งพาระยะไกลด้วย Interpretable Multi-Head Attention

หลังการประมวลผลเฉพาะที่ TFT จะใช้กลไก self-attention ที่ถูกปรับแต่งเพื่อเรียนรู้การพึ่งพาระยะไกล การปรับแต่งหลักอยู่ที่วิธีรวม attention head เข้าด้วยกัน multi-head attention มาตรฐานจะเชื่อมต่อ (concatenate) เอาต์พุตของแต่ละ head

$\text{MultiHead}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = [\text{head}_1; \ldots; \text{head}_H] \mathbf{W}_O$

แต่ TFT กลับ แบ่งใช้ values ร่วมกันระหว่าง head และ เฉลี่ยค่าน้ำหนัก attention

$\text{InterpretableMultiHead}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \tilde{\mathbf{H}} \mathbf{W}_H$

$\tilde{\mathbf{H}} = \frac{1}{H} \sum_{h=1}^{H} \text{Attention}\left(\mathbf{Q} \mathbf{W}_Q^{(h)}, \mathbf{K} \mathbf{W}_K^{(h)}, \mathbf{V} \mathbf{W}_V\right)$

$\text{Attention}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \text{Softmax}\left(\frac{\mathbf{Q} \mathbf{K}^\top}{\sqrt{d_{\text{attn}}}}\right) \mathbf{V}$

สังเกตว่า $\mathbf{W}_V$ ไม่มีตัวยกระบุ head -- ทุก head แบ่งใช้การฉาย value (value projection) เดียวกัน นั่นหมายความว่าค่าน้ำหนัก attention จากแต่ละ head สามารถนำมาเฉลี่ยและตีความว่าเป็นคะแนนความสำคัญเชิงเวลาได้อย่างมีความหมาย สำหรับการทำนายหนึ่ง ๆ คุณสามารถมองเห็นได้อย่างชัดเจนว่า ก้าวเวลาในอดีตช่วงใด ที่โมเดลให้ความสนใจ และรูปแบบ attention แตกต่างกันอย่างไรในแต่ละ head

สำหรับการพยากรณ์พอร์ตการลงทุน สิ่งนี้เผยให้เห็นว่าโมเดลกำลังให้ความสนใจกับการเคลื่อนไหวของราคาล่าสุด (โมเมนตัม) รูปแบบเชิงประวัติศาสตร์ที่ห่างไกล (ฤดูกาล) หรือเหตุการณ์ในปฏิทินเฉพาะ แต่ละ head สามารถเชี่ยวชาญในรูปแบบเชิงเวลาที่แตกต่างกันได้

5. Quantile Output Layer

เลเยอร์สุดท้ายให้เอาต์พุตการทำนายที่หลายควอนไทล์ ปรับให้เหมาะสมด้วย quantile loss

$\mathcal{L}(\Omega) = \sum_{y_t \in \Omega} \sum_{q \in \mathcal{Q}} \sum_{\tau=1}^{\tau_{\max}} \frac{QL(y_t, \hat{y}(q, t-\tau, \tau), q)}{|\Omega| \cdot \tau_{\max}}$

$QL(y, \hat{y}, q) = q \max(0, y - \hat{y}) + (1 - q) \max(0, \hat{y} - y)$

โดยที่ $\mathcal{Q}$ คือเซตของควอนไทล์เป้าหมาย (เช่น $\{0.1, 0.5, 0.9\}$) สิ่งนี้ให้คุณไม่เพียงค่าพยากรณ์แบบจุด แต่ยังให้ประมาณการแบบควอนไทล์ของช่วงการทำนายในแต่ละช่วงเวลาด้วย สำหรับการบริหารความเสี่ยงของพอร์ต ค่าพยากรณ์ที่เปอร์เซ็นไทล์ที่ 10 และ 90 ช่วยกำหนดขนาดสถานะ (position sizing) และระดับ stop-loss

มีข้อควรระวังหนึ่งที่ควรพูดให้ชัดตั้งแต่ต้น การลด pinball loss ให้ต่ำที่สุดได้ประมาณการควอนไทล์แบบมีเงื่อนไข (conditional-quantile) แต่มัน ไม่ รับประกันความครอบคลุม (coverage) ที่ปรับเทียบแล้วสำหรับข้อมูลนอกตัวอย่าง (out-of-sample) ในตลาดที่ไม่นิ่ง (non-stationary) และมีการสลับสภาวะ (regime-switching) ช่วงเหล่านี้มักถูกปรับเทียบผิดบ่อยครั้ง -- ช่วงระบุที่ 80% อาจครอบคลุมค่าจริงน้อยกว่า (หรือมากกว่า) 80% มาก จงปฏิบัติต่อควอนไทล์เหล่านี้ในฐานะประมาณการที่ต้องตรวจสอบเชิงประจักษ์ด้วยการทดสอบความครอบคลุม/ความน่าเชื่อถือ และทำให้แคบลงด้วย conformal prediction หากคุณต้องการการรับประกันความครอบคลุม เราจะกลับมาที่ประเด็นนี้ในส่วนการใช้งานจริง

TFT เทียบกับ LSTM เทียบกับ Vanilla Transformer

การเข้าใจว่า TFT อยู่ตรงไหนเมื่อเทียบกับสถาปัตยกรรมอื่น ๆ ช่วยในการตัดสินใจว่าเมื่อใดควรใช้มัน

เมื่อ LSTM ยังคงชนะ

LSTM ยังคงสู้ได้สำหรับการพยากรณ์ระยะสั้นมาก ๆ (ระดับ tick ต่ำกว่านาที) ที่หน้าต่างย้อนหลังสั้นและโครงสร้าง autoregressive เฉพาะที่มีบทบาทเด่น อีกทั้งยังนำไปใช้งานง่ายกว่า มี latency ในการอนุมาน (inference) ต่ำกว่า สำหรับบอท market-making ที่ต้องการการทำนายระดับต่ำกว่ามิลลิวินาที LSTM ยังคงเป็นทางเลือกที่ใช้งานได้จริง

เมื่อ Vanilla Transformer ทำได้ไม่ถึง

transformer มาตรฐานที่นำมาใช้กับอนุกรมเวลาทางการเงินอย่างไร้เดียงสามักจะ overfit มันขาด inductive bias ที่จำเป็นสำหรับข้อมูลเชิงเวลา -- ไม่มีแนวคิดเรื่องฟีเจอร์แบบคงที่เทียบกับแบบแปรเปลี่ยนตามเวลา ไม่มีการเลือกตัวแปร และ multi-head attention แบบเชื่อมต่อมาตรฐานยังสร้างแผนที่ attention ที่ยากจะตีความอย่างมีความหมาย

เมื่อ TFT โดดเด่น

TFT เหมาะที่สุดเมื่อคุณมี (1) ประเภทอินพุตที่หลากหลายและไม่เป็นเนื้อเดียวกันหลายชนิด (2) ข้อมูลเชิงตัดขวาง (สินทรัพย์จำนวนมาก) (3) ความจำเป็นในการพยากรณ์เชิงความน่าจะเป็นแบบหลายช่วงเวลา และ (4) ข้อกำหนดด้านความสามารถในการตีความของโมเดล สิ่งนี้อธิบายปัญหาการพยากรณ์พอร์ตการลงทุนระดับสถาบันแทบทุกปัญหา

การนำไปใช้งานด้วย Python และ PyTorch Forecasting

ต่อไปนี้คือการนำ TFT ไปใช้งานจริงสำหรับการพยากรณ์ผลตอบแทนพอร์ตการลงทุนแบบหลายสินทรัพย์ โดยใช้ไลบรารี pytorch-forecasting

การเตรียมข้อมูล

สังเกตการใช้อินพุตอนาคตที่ทราบล่วงหน้าจริง ๆ อย่างจงใจ -- day_of_week, days_to_earnings, is_fomc, days_to_expiry ค่าเหล่านี้คือค่าที่เรารู้ล่วงหน้าสำหรับหน้าต่างพยากรณ์ และการป้อนเข้าไปในฐาน known reals/categoricals คือความสามารถของ TFT ที่สถาปัตยกรรมนี้ถูกสร้างขึ้นมาเพื่อมันโดยตรง เราตัด time_idx ดิบออกจาก known reals เพราะ add_relative_time_idx=True ได้แทรกดัชนีตำแหน่งสัมพัทธ์ (relative position index) ให้แล้ว และตัวนับแบบโมโนโทนิกดิบส่วนใหญ่จะรั่วแนวโน้ม (trend) ออกมา

import pandas as pd
import numpy as np
import lightning.pytorch as pl
from lightning.pytorch.callbacks import EarlyStopping, LearningRateMonitor
from lightning.pytorch.loggers import TensorBoardLogger

from pytorch_forecasting import (
    TimeSeriesDataSet,
    TemporalFusionTransformer,
    QuantileLoss,
    GroupNormalizer,
)


max_encoder_length = 60   # 60 trading days lookback (~3 months)
max_prediction_length = 20 # 20 trading days ahead (~1 month)

training_cutoff = df["time_idx"].max() - max_prediction_length

training = TimeSeriesDataSet(
    df[lambda x: x.time_idx <= training_cutoff],
    time_idx="time_idx",
    target="log_return",
    group_ids=["asset_id"],
    min_encoder_length=max_encoder_length // 2,
    max_encoder_length=max_encoder_length,
    min_prediction_length=1,
    max_prediction_length=max_prediction_length,

    static_categoricals=["sector", "market_cap_bucket"],

    time_varying_known_categoricals=["day_of_week", "is_fomc"],
    time_varying_known_reals=["days_to_earnings", "days_to_expiry"],

    time_varying_unknown_reals=[
        "log_return",
        "rsi_14",
        "macd",
        "bb_width",
        "pe_ratio",
        "earnings_yield",
        "vix",
        "yield_spread",
        "dxy",
    ],

    target_normalizer=GroupNormalizer(
        groups=["asset_id"],
        transformation="softplus",
    ),
    add_relative_time_idx=True,
    add_target_scales=True,
    add_encoder_length=True,
)

validation = TimeSeriesDataSet.from_dataset(
    training, df, predict=True, stop_randomization=True
)

batch_size = 64
train_dataloader = training.to_dataloader(
    train=True, batch_size=batch_size, num_workers=4
)
val_dataloader = validation.to_dataloader(
    train=False, batch_size=batch_size * 4, num_workers=4
)

การกำหนดโมเดลและการฝึก

tft = TemporalFusionTransformer.from_dataset(
    training,
    learning_rate=1e-3,
    hidden_size=64,
    attention_head_size=4,
    dropout=0.1,
    hidden_continuous_size=32,
    output_size=7,  # 7 quantiles
    loss=QuantileLoss(quantiles=[0.02, 0.1, 0.25, 0.5, 0.75, 0.9, 0.98]),
    log_interval=10,
    optimizer="Ranger",
    reduce_on_plateau_patience=4,
)

print(f"Number of parameters: {tft.size() / 1e3:.1f}k")

early_stop_callback = EarlyStopping(
    monitor="val_loss",
    min_delta=1e-4,
    patience=10,
    verbose=False,
    mode="min",
)

lr_logger = LearningRateMonitor()
logger = TensorBoardLogger("lightning_logs")

trainer = pl.Trainer(
    max_epochs=100,
    accelerator="auto",
    enable_model_summary=True,
    gradient_clip_val=0.1,
    callbacks=[lr_logger, early_stop_callback],
    logger=logger,
)

trainer.fit(
    tft,
    train_dataloaders=train_dataloader,
    val_dataloaders=val_dataloader,
)

การดึงเอาต์พุตที่ตีความได้

การเรียกใช้ความสามารถในการตีความมีข้อกำหนดที่ไม่ชัดเจนอยู่หนึ่งข้อ interpret_output() รับ dict เอาต์พุต ดิบ (raw) (ที่มีคีย์อย่าง encoder_variables, decoder_variables, static_variables, encoder_attention, ...) ซึ่ง predict() จะผลิตออกมาเฉพาะภายใต้ mode="raw" เท่านั้น จงคำนวณมันครั้งเดียว แล้วนำอ็อบเจกต์เดียวกันกลับมาใช้ซ้ำทั้งสำหรับความสำคัญของตัวแปรและ attention

best_model_path = trainer.checkpoint_callback.best_model_path
best_tft = TemporalFusionTransformer.load_from_checkpoint(best_model_path)

raw_predictions, x = best_tft.predict(val_dataloader, mode="raw", return_x=True)

interpretation = best_tft.interpret_output(raw_predictions, reduction="sum")

best_tft.plot_interpretation(interpretation)

preds = raw_predictions.output["prediction"]

จากการพยากรณ์สู่ค่าน้ำหนักของพอร์ต

def forecasts_to_portfolio_weights(
    predictions: dict,
    index: pd.DataFrame,
    risk_aversion: float = 2.0,
) -> pd.DataFrame:
    """
    Convert TFT multi-horizon quantile forecasts into long-only portfolio
    weights using a mean-variance-INSPIRED score (not a full optimization:
    there is no covariance matrix here, only a per-asset risk-adjusted score).

    Uses the median forecast as the expected return and (q90 - q10) as a
    proxy for forecast uncertainty.
    """
    preds = predictions["prediction"]

    median_return = preds[:, :, 3].mean(dim=1).numpy()  # avg across horizons
    q90 = preds[:, :, 5].mean(dim=1).numpy()
    q10 = preds[:, :, 1].mean(dim=1).numpy()
    forecast_uncertainty = q90 - q10  # width of 80% PI

    scores = median_return / (risk_aversion * forecast_uncertainty + 1e-8)

    result = index[["asset_id"]].copy()
    result["score"] = scores
    result["raw_weight"] = np.maximum(scores, 0)  # long-only

    total = result["raw_weight"].sum()
    result["weight"] = result["raw_weight"] / (total + 1e-8)

    return result[["asset_id", "weight", "score"]]

ความสามารถในการตีความในทางปฏิบัติ: TFT เผยอะไรเกี่ยวกับตลาด

เอาต์พุตด้านความสามารถในการตีความจาก TFT ไม่ใช่เพียงเรื่องน่ารู้เชิงวิชาการ -- มันให้ข้อมูลเชิงลึกที่นำไปปฏิบัติได้สำหรับผู้จัดการพอร์ตการลงทุน

ความสำคัญของตัวแปรในสภาวะตลาดต่าง ๆ

เมื่อคุณตรวจสอบค่าน้ำหนักการเลือกตัวแปรตามช่วงเวลา รูปแบบที่สอดคล้องกับสัญชาตญาณเกี่ยวกับตลาดจะปรากฏขึ้น

• ในช่วงวงจรการขึ้นอัตราดอกเบี้ยปี 2022: ฟีเจอร์เส้นอัตราผลตอบแทน (yield_spread, fed_funds_rate) มีบทบาทเด่นในความสำคัญของตัวแปร คิดเป็น 35-40% ของค่าน้ำหนักการเลือก ตัวชี้วัดทางเทคนิคลดลงเหลือต่ำกว่า 10%
• ในช่วงตลาดขาขึ้นที่ขับเคลื่อนด้วย AI ปี 2024: ฟีเจอร์โมเมนตัม (rsi_14, macd) พุ่งขึ้นในความสำคัญ covariate แบบคงที่ระดับกลุ่มอุตสาหกรรมก็มีนัยสำคัญด้วย เนื่องจากตลาดขาขึ้นกระจุกตัวอยู่ในเทคโนโลยีอย่างมาก
• ในช่วงตลาดที่เคลื่อนไหวในกรอบ (range-bound): ตัวชี้วัดการกลับสู่ค่าเฉลี่ย (bb_width, relative_value) ได้รับค่าน้ำหนักสูงสุด ในขณะที่ฟีเจอร์ตามแนวโน้ม (trend-following) ถูกระงับโดยกลไก gating

นี่คือการทำงานของ gating ใน GRN เมื่อฟีเจอร์โมเมนตัมไม่มีสัญญาณ เกต GLU จะผลักการมีส่วนร่วมของมันให้เข้าใกล้ศูนย์ และโมเดลจะสลับไปยังฟีเจอร์ทางเลือกโดยอัตโนมัติ (รูปแบบเหล่านี้เป็นตัวอย่างจากการทดลองเชิงสำรวจ ไม่ใช่ผลที่ผ่านการเปรียบเทียบเชิงเกณฑ์ -- จงตรวจสอบกับข้อมูลของคุณเอง)

รูปแบบ Attention เชิงเวลา

การมองเห็นค่าน้ำหนัก attention เผยให้เห็นโครงสร้างความจำที่มีประสิทธิภาพของโมเดล

• จุดสูงสุดของ attention ระยะสั้น: attention ที่แข็งแกร่งที่ lag 1-5 สะท้อนถึง autocorrelation และผลของโมเมนตัม/การกลับตัวระยะสั้น
• รูปแบบรายสัปดาห์: attention พุ่งขึ้นที่ lag 5, 10, 15 สอดคล้องกับผลของปฏิทินรายสัปดาห์
• รูปแบบรายเดือน: จุดสูงสุดของ attention ที่สม่ำเสมอราว lag 21 (หนึ่งเดือนทำการ) จับการไหลของการปรับสมดุลรายเดือนและผลของวันหมดอายุออปชัน
• วงจรผลประกอบการ: สำหรับหุ้นรายตัว attention แสดงจุดสูงสุดแหลมที่ lag ราว 63 และ 126 วัน ซึ่งสอดคล้องกับวันประกาศผลประกอบการรายไตรมาส

รูปแบบเหล่านี้ให้การยืนยันอย่างเป็นอิสระว่าโมเดลได้เรียนรู้โครงสร้างเชิงเวลาที่มีความหมาย แทนที่จะ fit กับสัญญาณรบกวน

ประสิทธิภาพและการประยุกต์ใช้ในโลกจริง

ผลการทดสอบเชิงเกณฑ์

จากเปเปอร์ต้นฉบับและงานวิจัยที่ตามมา TFT แสดงประสิทธิภาพที่แข็งแกร่งและมีการบันทึกไว้อย่างดี

• quantile loss P50 ต่ำกว่า 7% และ P90 ต่ำกว่า 9% โดยเฉลี่ย เมื่อเทียบกับโมเดลที่ดีที่สุดรองลงมาในชุดข้อมูลทดสอบของเปเปอร์ (ไฟฟ้า การจราจร ค้าปลีก ความผันผวน) และ ดีกว่า baseline คู่แข่งที่แข็งแกร่งที่สุด 3-26% ขึ้นอยู่กับชุดข้อมูล คู่แข่งเฉพาะตัวจะแตกต่างกันไปตามชุดข้อมูล -- ตัวอย่างเช่น DeepAR อยู่ในกลุ่ม baseline ที่อ่อนกว่าในข้อมูลไฟฟ้าและการจราจร แต่สู้ได้ดีกว่าในข้อมูลค้าปลีกและความผันผวน -- ดังนั้นตัวเลขพาดหัวจึงเป็นค่าที่ดีกว่าโมเดล ที่ดีที่สุดรองลงมา ไม่ใช่ดีกว่า baseline ตายตัวตัวใดตัวหนึ่ง
• เหนือกว่าอย่างสม่ำเสมอ เมื่อเทียบกับ baseline แบบคลาสสิกอย่าง ARIMA, ETS และ Prophet ในตัวชี้วัดแบบหลายช่วงเวลา

ทิศทางการวิจัยในด้านการเงิน

TFT ได้จุดประกายแนวการวิจัยเฉพาะด้านการเงินที่ยังคงคึกคัก ต่อไปนี้คือตัวอย่างที่เป็นตัวแทนสองสามเส้น พร้อมตัวชี้วัดที่รายงานไว้จริง (จงอ้างอิงและทำซ้ำให้ได้ก่อนพึ่งพาตัวใดตัวหนึ่ง)

• TFT แบบปรับตัว / หลายมาตราส่วน (multi-scale) สำหรับคริปโต งานอย่าง Adaptive Temporal Fusion Transformers for Cryptocurrency Price Prediction (arXiv:2509.10542) รายงานการปรับปรุงเหนือ baseline ของ TFT ความยาวคงที่และ LSTM ในการทำนายราคาคริปโต จงปฏิบัติต่อตัวเลขความสามารถในการทำกำไรจากการเทรดว่าเป็นค่าเฉพาะเปเปอร์และขึ้นกับสภาวะตลาด ไม่ใช่ค่าสากล -- เราจงใจไม่อ้างค่าส่วนต่าง Sharpe สัมบูรณ์ในที่นี้ เพราะตัวเลขที่ลอยอยู่ในวรรณกรรมมักปะปนระหว่าง ความแม่นยำของการทำนาย กับ Sharpe ที่เกิดขึ้นจริง
• เป้าหมายที่คำนึงถึง Sharpe (Sharpe-aware objectives) แนวงาน "multi-sensor TFT / adaptive Sharpe ratio" ของ MDPI Sensors ปรับให้เหมาะสมไปยังเป้าหมายแบบ Sharpe โดยตรง สังเกตว่าผลพาดหัวของมันคือการปรับปรุงราว 18% ใน ความแม่นยำของการทำนาย Sharpe ratio ซึ่งเป็นปริมาณคนละอย่างกับการเพิ่มขึ้นของ Sharpe สัมบูรณ์
• โมเดลไฮบริด TFT-GNN การผสาน TFT กับ graph neural network เพื่อจับการพึ่งพาระหว่างสินทรัพย์ โดยมีรายงานว่าไฮบริดเหนือกว่า TFT แบบเดี่ยวในการทำนายหุ้นเชิงตัดขวาง
• การหลอมรวมเชิงเวลาข้ามรูปแบบ (cross-modal) การบูรณาการข้อมูลราคาที่มีโครงสร้างเข้ากับข้อมูลที่ไม่มีโครงสร้าง (ข่าว ถอดความการประชุมแถลงผลประกอบการ) ผ่านเลเยอร์การหลอมรวมแบบ transformer ขยายกระบวนทัศน์ของ TFT ไปสู่ข้อมูลทางการเงินแบบหลายรูปแบบ

ทิศทางเหล่านี้มีอยู่จริง แต่ไม่มีตัวใดเป็นความได้เปรียบสำเร็จรูป จงทำซ้ำตัวชี้วัดบนเอกภพ (universe) ของสินทรัพย์และต้นทุนของคุณเองก่อนนำไปใช้งานจริง

ข้อพิจารณาเชิงปฏิบัติสำหรับการใช้งานจริง

ความต้องการข้อมูล: TFT ต้องการข้อมูลฝึกจำนวนมาก วางแผนให้มีข้อมูลรายวันอย่างน้อย 2-3 ปีต่อสินทรัพย์ หรือข้อมูลรายชั่วโมง 6-12 เดือน ข้อมูลเชิงตัดขวาง (สินทรัพย์จำนวนมาก) ช่วยได้มาก -- การฝึกบนหุ้น 500 ตัวพร้อมกันมีประสิทธิภาพมากกว่าการฝึก 500 โมเดลแยกกัน

Feature engineering: แม้ว่า TFT จะทำการเลือกตัวแปรโดยอัตโนมัติ คุณภาพของฟีเจอร์ตัวเลือกก็ยังมีความสำคัญ จงรวมชุดฟีเจอร์ที่หลากหลายครอบคลุมทั้งข้อมูลทางเทคนิค พื้นฐาน มหภาค และข้อมูลทางเลือก (alternative data) แล้วปล่อยให้ VSN ตัดสินว่าตัวไหนมีประโยชน์

ต้นทุนการคำนวณ: การฝึก TFT แพงกว่า LSTM แต่เทียบเท่ากับ transformer แบบดั้งเดิม บน GPU A100 ตัวเดียว การฝึกบนหุ้น 500 ตัวด้วยข้อมูลรายวัน 3 ปีใช้เวลาราวไม่กี่ชั่วโมงสำหรับ 100 epoch การอนุมานทำได้เร็ว -- การสร้างการพยากรณ์สำหรับเอกภพทั้งหมดใช้เวลาน้อยกว่าหนึ่งวินาทีมาก

จงตรวจสอบการปรับเทียบ อย่าสมมติเอาเอง ก่อนที่ควอนไทล์ใด ๆ จะขับเคลื่อนการกำหนดขนาดสถานะ จงตรวจสอบความครอบคลุมเชิงประจักษ์กับข้อมูลนอกตัวอย่าง ช่วงระบุที่ 80% บรรจุผลตอบแทนที่เกิดขึ้นจริงราว 80% จริงหรือไม่ ในตลาดที่ไม่นิ่งมันมักจะไม่เป็นเช่นนั้น จงทำแผนภาพความน่าเชื่อถือ (reliability diagram) ต่อช่วงเวลา และพิจารณาห่อหุ้มโมเดลด้วย conformal prediction เพื่อฟื้นการรับประกันความครอบคลุม

การปรับตัวต่อสภาวะตลาด: TFT ไม่ได้สร้างแบบจำลองการสลับสภาวะตลาดอย่างชัดเจน (ต่างจาก HMM) อย่างไรก็ตาม กลไก gating ให้การปรับตัวต่อสภาวะตลาดโดยปริยาย ในทางปฏิบัติ การฝึกใหม่รายเดือนด้วยหน้าต่างที่ขยายตัว (expanding window) จับการเปลี่ยนแปลงเชิงโครงสร้างได้อย่างมีประสิทธิภาพ

การบรรเทา overfitting: ข้อมูลทางการเงินมีสัญญาณรบกวนและไม่นิ่ง จงใช้ regularization ที่เข้มข้น: dropout 0.1-0.3, gradient clipping ที่ 0.1, early stopping ด้วย patience 10-15 epoch การตรวจสอบแบบ walk-forward เป็นสิ่งจำเป็น -- อย่าใช้การแบ่ง train/test แบบสุ่มกับอนุกรมเวลาเด็ดขาด

ประกอบทุกอย่างเข้าด้วยกัน: ไปป์ไลน์พอร์ตการลงทุนที่อิง TFT

ไปป์ไลน์การใช้งานจริงสำหรับการจัดการพอร์ตการลงทุนที่อิง TFT มีลักษณะดังนี้

1. การนำเข้าข้อมูล (Data ingestion): รวบรวมข้อมูล OHLCV, พื้นฐาน, มหภาค และข้อมูลทางเลือกเป็นรายวัน คำนวณฟีเจอร์ (200+ ตัวเลือก) รวมถึงปฏิทินอนาคตที่ทราบล่วงหน้าจริง (ผลประกอบการ, FOMC, วันหมดอายุ, วันในสัปดาห์)
2. คลังฟีเจอร์ (Feature store): ดูแลคลังฟีเจอร์ที่ผ่านการ normalize และจัดดัชนีตามเวลา จัดการข้อมูลที่ขาดหาย, corporate action และ survivorship bias
3. การฝึกโมเดล: ฝึก TFT ใหม่รายเดือนด้วยวิธี walk-forward ใช้ข้อมูล 3-5 ปีล่าสุดด้วยหน้าต่างที่ขยายตัว
4. การสร้างการพยากรณ์: การอนุมานรายวันที่ผลิตการพยากรณ์แบบควอนไทล์ที่ช่วงเวลา 1, 5, 10 และ 20 วันสำหรับเอกภพสินทรัพย์ทั้งหมด
5. การตรวจสอบการปรับเทียบ: ติดตามความครอบคลุมของแต่ละช่วงควอนไทล์ต่อช่วงเวลา ปรับเทียบใหม่ (หรือใช้การปรับแบบ conformal) เมื่อความครอบคลุมเลื่อนคลาด
6. แดชบอร์ดความสามารถในการตีความ: มองเห็นความสำคัญของตัวแปรและค่าน้ำหนัก attention ส่งสัญญาณเตือนความผิดปกติ (เช่น การเปลี่ยนแปลงฉับพลันในความสำคัญของฟีเจอร์)
7. การปรับพอร์ตให้เหมาะสม: แปลงการพยากรณ์เป็นค่าน้ำหนักโดยใช้ mean-variance, Black-Litterman หรือ risk parity โดยมีควอนไทล์ของ TFT เป็นอินพุตของผลตอบแทนและความไม่แน่นอน
8. ชั้นความเสี่ยง (Risk overlay): ใช้ค่าพยากรณ์ที่เปอร์เซ็นไทล์ที่ 2 และ 98 สำหรับการประเมินความเสี่ยงส่วนหาง (tail risk) ลดขนาดสถานะเมื่อช่วงการทำนายกว้างขึ้น
9. การส่งคำสั่ง (Execution): ส่งค่าน้ำหนักเป้าหมายไปยังเครื่องมือส่งคำสั่ง ติดตามความคลาดเคลื่อน (tracking error) ระหว่างพอร์ตเป้าหมายและพอร์ตที่เกิดขึ้นจริง

บทสรุป

Temporal Fusion Transformer เป็นความก้าวหน้าอย่างแท้จริงสำหรับการจัดการพอร์ตการลงทุนเชิงปริมาณ มันไม่ใช่เพียงโมเดล deep learning อีกตัวที่โยนใส่ข้อมูลทางการเงิน -- แต่เป็นสถาปัตยกรรมที่ออกแบบขึ้นมาตั้งแต่รากฐานเพื่อรับมือกับความท้าทายเฉพาะของการพยากรณ์เชิงเวลาแบบหลายช่วงเวลา: อินพุตที่ไม่เป็นเนื้อเดียวกัน โครงสร้างเชิงตัดขวาง เอาต์พุตเชิงความน่าจะเป็น และความจำเป็นอย่างยิ่งยวดในเรื่องความสามารถในการตีความ

variable selection network บอกคุณว่าโมเดลกำลังให้ความสนใจกับ อะไร ค่าน้ำหนัก attention บอกคุณว่ามันกำลังมอง เมื่อใด กลไก gating รับประกันว่ามันจัดการกับฟีเจอร์ที่ไม่เกี่ยวข้องและการเปลี่ยนสภาวะตลาดได้อย่างนุ่มนวล และเอาต์พุตแบบควอนไทล์ให้ประมาณการความไม่แน่นอนสำหรับการบริหารความเสี่ยง -- ตราบเท่าที่คุณตรวจสอบการปรับเทียบของมันแทนที่จะเชื่อโดยไม่ตรวจสอบ

TFT ไม่ใช่กระสุนเงิน (silver bullet) ตลาดการเงินยังคงเป็นสภาพแวดล้อมแบบปฏิปักษ์ (adversarial) ที่ความได้เปรียบในการทำนายใด ๆ เป็นเพียงสิ่งชั่วคราวและขึ้นกับสภาวะตลาด แต่ TFT ให้กรอบการทำงานที่มีหลักการสำหรับการสร้างระบบพยากรณ์ที่ทั้งทรงพลังและเข้าใจได้ -- และในการเทรดจริง การเข้าใจว่า ทำไม โมเดลของคุณจึงวางเดิมพันนั้นสำคัญพอ ๆ กับตัวเดิมพันเอง

เอกสารอ้างอิง

1. Lim, B., Arik, S.O., Loeff, N., & Pfister, T. (2021). "Temporal Fusion Transformers for Interpretable Multi-horizon Time Series Forecasting." International Journal of Forecasting, 37(4), 1748-1764. arXiv:1912.09363
2. Oreshkin, B.N., Carpov, D., Chapados, N., & Bengio, Y. (2020). "N-BEATS: Neural basis expansion analysis for interpretable time series forecasting." ICLR 2020.
3. Salinas, D., Flunkert, V., Gasthaus, J., & Januschowski, T. (2020). "DeepAR: Probabilistic forecasting with autoregressive recurrent networks." International Journal of Forecasting, 36(3), 1181-1191.
4. pytorch-forecasting documentation -- TFT implementation with PyTorch Lightning.
5. google-research/tft -- Original TFT reference implementation.