บริบทเต็มวันเอาชนะหนึ่งนาทีได้หรือไม่? ความสนใจแบบแฟลชและคำถามแบบเรียงลำดับความยาว

คำถามในบทความนี้มีไว้ตอบ: หากหม้อแปลงสามารถจัดการตลอดทั้งวันซื้อขายด้วยความละเอียดหนึ่งวินาที แทนที่จะเป็นกรอบเวลาสิบนาที จะคาดการณ์ได้ดีขึ้นหรือไม่

จนกระทั่งเมื่อไม่นานมานี้คุณไม่สามารถถามได้ ความต้องการความสนใจมาตรฐาน $\mathcal{O}(N^2)$ หน่วยความจำ ดังนั้นวันที่ 23,400 ก้าวที่ 12 หัวใน float16 ต้องการพื้นที่ประมาณ 12.9 GB สำหรับเมทริกซ์คะแนนเพียงอย่างเดียว ซึ่งมากกว่าพารามิเตอร์ของโมเดล และมากกว่าที่การ์ดส่วนใหญ่จะให้คุณ คำถามถูกปิดด้วยเลขคณิตก่อนที่จะมีใครมาทดสอบ

Flash Attention (Dao et al., 2022) เปิดขึ้น ไม่ใช่โดยการประมาณความสนใจ — โดยจะคำนวณ แน่นอน ผลลัพธ์เดียวกัน — แต่โดยการปรับโครงสร้างการคำนวณใหม่ให้เป็น รับรู้ IO เพื่อลดการรับส่งข้อมูลระหว่างระดับหน่วยความจำ GPU นั่นคือเนื้อหาที่น่าสนใจอย่างแท้จริงที่นี่ และบทความนี้ส่วนใหญ่พูดถึงวิธีการทำงาน: การเรียงต่อกัน การเกิดขึ้นซ้ำของ online-softmax การ $\Theta(N^2 d^2 / M)$ IO ถูกผูกไว้และการคำนวณซ้ำแบบย้อนกลับ

แต่กลไกคือตัวเปิดใช้งาน ไม่ใช่การกล่าวอ้าง "บริบทที่ยาวกว่าย่อมดีกว่า" เป็นคำแถลงเชิงประจักษ์เกี่ยวกับตลาด และจุดยืนของบล็อกนี้ — จาก Temporal Fusion Transformers ซึ่งพบว่าหม้อแปลงวานิลลาในซีรีส์ทางการเงินที่มากเกินไปและโมเดลที่เกิดซ้ำแบบมองย้อนกลับระยะสั้นสามารถแข่งขันได้ที่ความถี่สูง — ตัดในทางกลับกัน ดังนั้นบทความนี้จึงปิดท้ายด้วยการวัด ไม่ใช่กลไก

เหตุใดความสนใจจึงผูกติดกับความทรงจำ

การคำนวณความสนใจ $\text{softmax}(\mathbf{Q}\mathbf{K}^\top / \sqrt{d_k})\mathbf{V}$ — ตัวดั้งเดิมในบริบทการซื้อขายจะครอบคลุมอยู่ใน Temporal Fusion Transformers for Multi-Horizon Portfolio Forecasting. ปัญหาทั้งหมดมีบรรทัดเดียวคือเมทริกซ์คะแนนระดับกลาง $\mathbf{S} = \mathbf{Q}\mathbf{K}^\top/\sqrt{d_k}$ เป็น $N \times N$มันถูกเขียนไปยังหน่วยความจำ อ่านกลับสำหรับ softmax เขียนอีกครั้ง และอ่านอีกครั้งสำหรับ matmul สุดท้าย — และจะต้องเก็บไว้เพื่อการเผยแพร่กลับ

ความเข้มข้นทางคณิตศาสตร์ของความสนใจคือ $\approx \min(d, N)$ดังนั้นประมาณ 64 FLOP/byte ที่ $d = 64$ — ด้านซ้ายของจุดสัน A100 โดยตั้งอยู่บนเพดานแบนด์วิธที่ลาดเอียง ไม่ใช่เพดานการคำนวณแบบเรียบ: GPU ใช้เวลาในการเคลื่อนย้ายมากขึ้น $\mathbf{S}$ รอบกว่าการคูณอะไรก็ตาม เฟรมเวิร์กไลน์หลังคาที่ใช้ — จุดสันเขา เพดานลาดเอียงเทียบกับเพดานแบน และเหตุใดเหตุผลเดียวกันจึงตัดสินว่า GPU คุ้มค่าที่จะซื้อหรือไม่ — สร้างขึ้นด้วยตัวเลขที่วัดได้ใน เมื่อ GPU จ่ายออก.

ลำดับชั้นของหน่วยความจำที่อัลกอริทึมหาประโยชน์

SRAM มีประมาณ แบนด์วิดท์มากกว่า 10 เท่า และมีเวลาแฝงต่ำกว่า 100 เท่า ที่ความจุหนึ่งในพัน ทุกสิ่งที่ Flash Attention ดำเนินการตามมาจากการแลกเปลี่ยนนั้น: เลิกใช้ความจุ ซื้อแบนด์วิธและเวลาแฝง การย้าย "ปรับโครงสร้างอัลกอริธึมแทนที่จะซื้อฮาร์ดแวร์" แบบเดียวกันซึ่งวัดจากการทดสอบย้อนกลับของ CPU คือ [บันไดความเร็วการทดสอบย้อนกลับ] (/en/blog/post/backtest-engine-speed-ladder).

อัลกอริธึม Flash Attention

Flash Attention ประมวลผลความสนใจใน ไทล์ ที่มีขนาดพอดีกับ SRAM และจะไม่เกิดขึ้นจริงทั้งหมด $N \times N$ เมทริกซ์ใน HBM เลย

ฉากกั้นห้อง $\mathbf{Q}$ เข้าไปข้างใน $T_r = \lceil N/B_r \rceil$ บล็อกแถวและ $\mathbf{K}, \mathbf{V}$ เข้าไปข้างใน $T_c = \lceil N/B_c \rceil$ บล็อกคอลัมน์ด้วย $B_r, B_c$ เลือกเพื่อให้ไทล์บวกกับตัวสะสมพอดีกับชิป สำหรับแต่ละบล็อกข้อความค้นหา ให้วนซ้ำบล็อกคีย์-ค่าทั้งหมด:

For each query block Q_i:
    Initialize: O_i = 0, m_i = -inf, l_i = 0    # output, running max, running sum
    For each KV block (K_j, V_j):
        1. Load Q_i, K_j, V_j from HBM to SRAM
        2. Compute S_ij = Q_i @ K_j^T / sqrt(d)  # in SRAM
        3. Compute local max: m_ij = rowmax(S_ij)
        4. Compute P_ij = exp(S_ij - m_ij)        # in SRAM
        5. Compute local sum: l_ij = rowsum(P_ij)
        6. Update running statistics:
           m_new = max(m_i, m_ij)
           l_new = l_i * exp(m_i - m_new) + l_ij * exp(m_ij - m_new)
           O_i = O_i * (l_i * exp(m_i - m_new) / l_new)
                + P_ij @ V_j * (exp(m_ij - m_new) / l_new)
           m_i = m_new, l_i = l_new
    Write O_i to HBM

การเกิดซ้ำของ softmax ออนไลน์

เคล็ดลับที่ทำให้การปูกระเบื้องเป็นไปได้คือ softmax ออนไลน์ ซอฟต์แม็กซ์ไร้เดียงสาจำเป็นต้องมีการส่งผ่านสองครั้งในแถว: หนึ่งรายการเพื่อค้นหาค่าสูงสุด (สำหรับความเสถียรของตัวเลข) และอีกรายการหนึ่งเพื่อยกกำลังและทำให้เป็นมาตรฐาน การส่งผ่านสองครั้งในแถวที่คุณปฏิเสธที่จะจัดเก็บนั้นขัดแย้งกัน ดังนั้น Flash Attention จะยังคงเรียกใช้สถิติและปรับขนาดใหม่ในขณะนั้น

หลังจากบล็อก $1, \ldots, j$:

และตัวสะสมเอาต์พุตจะถูกแก้ไขโดยปัจจัยเดียวกัน:

ทุกครั้งที่บล็อกใหม่เพิ่มการรันสูงสุด เอาท์พุตที่สะสมก่อนหน้านี้จะถูกลดขนาดย้อนหลังด้วย $e^{m^{(j-1)} - m^{(j)}}$ — ราวกับว่ารู้ค่าสูงสุดใหม่ตั้งแต่เริ่มต้น ผลลัพธ์จะเหมือนกันทางพีชคณิตกับซอฟต์แม็กซ์สองรอบ ในทางคณิตศาสตร์ที่แน่นอน นี่ไม่ใช่การประมาณ มันเป็นการเชื่อมโยงใหม่ (ในความแม่นยำอันจำกัด มันจะเป็นเส้นทางการปัดเศษ ต่างกัน ซึ่งมีความสำคัญ — ดูการตรวจสอบความถูกต้องด้านล่าง)

ความซับซ้อนของ IO

นี่คือคำแถลงอย่างเป็นทางการของการชนะ การทำงานของ Flash Attention

HBM เข้าถึงได้จากที่ไหน $M$ คือขนาด SRAM เทียบกับ $\Theta(Nd + N^2)$ สำหรับการดำเนินการตามมาตรฐาน Note that $M$ ปรากฏใน ตัวส่วน: ยิ่งแผ่นขูดบนชิปมีขนาดใหญ่เท่าใด รอบการเดินทางก็จะน้อยลงเท่านั้น ซึ่งเป็นเหตุผลว่าทำไมอัลกอริทึมจึงถูกระบุในแง่ของลำดับชั้นของหน่วยความจำมากกว่าจำนวน FLOP For typical $d = 64$ และ $M \approx 100$ KB อัตราส่วนดังกล่าวสนับสนุน Flash Attention โดยเข้าถึงน้อยลงประมาณ 5-10 เท่า

การย้อนกลับ: คำนวณใหม่แทนการจัดเก็บ

การขยายพันธุ์แบบย้อนกลับโดยอาศัยความสนใจมักต้องการ $\mathbf{P}$ เมทริกซ์ที่ส่งต่อเพียงปฏิเสธที่จะเก็บไว้ Flash Attention คำนวณใหม่ ไทล์จาก $\mathbf{Q}, \mathbf{K}$ ระหว่างการย้อนกลับโดยจัดเก็บเฉพาะเอาต์พุตเท่านั้น $\mathbf{O}$ และสถิติซอฟต์แม็กซ์ $(m, \ell)$ - ทั้งคู่ $\mathcal{O}(N)$, ไม่ $\mathcal{O}(N^2)$. มันแลกเปลี่ยนเลขคณิตซ้ำซ้อนในปริมาณเล็กน้อยสำหรับคำศัพท์หน่วยความจำที่เป็นปัญหาทั้งหมด นี่เป็นการต่อรองราคาแบบเดียวกับจุดตรวจสอบการไล่ระดับสี ซึ่งใช้กับรายละเอียดของไทล์ภายในตัวดำเนินการเดียว

FA2: ความเท่าเทียม

Flash Attention 2 (Dao, 2023) เก็บอัลกอริทึมและแก้ไขกำหนดการ:

1. FLOP ที่ไม่ใช่ matmul น้อยลง FA1 ใช้เวลาจริงในการลดขนาด การค้นหาสูงสุด และการยกกำลัง — การดำเนินการที่ทำงานบนคอร์ CUDA ไม่ใช่เทนเซอร์คอร์ FA2 เลื่อนการลดขนาดไปจนถึงจุดสิ้นสุดของลูปด้านใน
2. ความขนานเหนือความยาวของลำดับ FA1 ขนานกับแบทช์และส่วนหัวเท่านั้น FA2 ยังขนานกับบล็อกการสืบค้นด้วย สิ่งนี้มีความสำคัญโดยเฉพาะสำหรับกรณีการซื้อขาย โดยที่คุณมักจะมี หนึ่งลำดับที่ยาวมากต่อเนื้อหา และขนาดแบทช์ 1-4 ซึ่งตรงกับระบอบการปกครองที่ความขนานกันระหว่างแบทช์และเฮดทำให้ GPU ขาดแคลน
3. การแบ่งพาร์ติชันงาน Warp แต่ละ warp ใช้ชุดย่อยของบล็อกแบบสอบถามที่แตกต่างกัน แทนที่จะแยกการคำนวณคะแนนและลดขนาดข้าม warp โดยลบการลด cross-warp ออก

ผลลัพธ์ที่รายงาน: ~70% ของ FLOP สูงสุดตามทฤษฎีใน A100 เทียบกับ ~35% สำหรับ FA1

FA3: กลไกของฮอปเปอร์

Flash Attention 3 (Dao, Shah, 2024) เป็นสถาปัตยกรรมเฉพาะสำหรับ H100:

1. ความเชี่ยวชาญพิเศษด้านวาร์ปแบบอะซิงโครนัส Tensor Memory Accelerator (TMA) ของ Hopper จะย้าย HBM→SRAM แบบอะซิงโครนัส FA3 แบ่งการบิดงอออกเป็น ผู้ผลิต ที่ออกโหลด TMA สำหรับบล็อก KV ถัดไปและ ผู้บริโภค ประมวลผลบนบล็อกปัจจุบัน ดังนั้นการเคลื่อนไหวของข้อมูลจึงซ่อนอยู่เบื้องหลังเลขคณิต
2. มัทมัลและซอฟต์แม็กซ์แบบอินเทอร์ลีฟ $\mathbf{Q}_i\mathbf{K}_j^\top$ สำหรับหนึ่งบล็อกทำงานบนเทนเซอร์คอร์ ในขณะที่ซอฟต์แม็กซ์สำหรับบล็อกก่อนหน้าทำงานบนคอร์ CUDA — สองหน่วยฮาร์ดแวร์ที่แตกต่างกัน เกิดขึ้นพร้อมกันอย่างแท้จริง แทนที่จะแบ่งตามเวลา
3. FP8 ที่มีการประมวลผลไม่ต่อเนื่องกัน H100 ทำ FP8 ที่ปริมาณงาน 2x FP16 ความสนใจที่ไร้เดียงสาของ FP8 ถูกทำลายโดยค่าผิดปกติ FA3 สุ่มหมุนเวกเตอร์ก่อนการหาปริมาณแบบบล็อกเพื่อกระจายขนาดค่าผิดปกติข้ามพิกัด โดยรายงานที่ข้อผิดพลาดเชิงตัวเลขต่ำกว่า FP8 ไร้เดียงสาถึง 2.6 เท่า

การปกปิดสาเหตุคือจุดที่การซื้อขายได้รับส่วนลด

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

บูรณาการเป็นแปดบรรทัด

แทบไม่มีโค้ดใดที่คุณต้องการเกี่ยวกับ Flash Attention สลับเส้นทางเมทริกซ์คะแนนที่ชัดเจนสำหรับเคอร์เนลที่หลอมรวม:

scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_head)
scores = scores.masked_fill(causal_mask, float("-inf"))
out = torch.matmul(torch.softmax(scores, dim=-1), v)

out = torch.nn.functional.scaled_dot_product_attention(
    q, k, v,
    dropout_p=self.dropout if self.training else 0.0,
    is_causal=True,
)

นั่นคือการเปลี่ยนแปลงทั้งหมด q, k, v มีรูปร่าง (batch, heads, seq, head_dim); มาสก์เชิงสาเหตุหายไปเนื่องจากเคอร์เนลสร้างมันขึ้นมา สำหรับโมเดลการซื้อขาย PyTorch ที่มีคำอธิบายประกอบที่สมบูรณ์เพื่อวางสิ่งนี้ลงใน — การฉายภาพอินพุต บล็อก และส่วนหัวขึ้น/แบน/ลง 3 คลาส — ให้ใช้ DeepLOB และสำหรับขั้นตอนการฝึกเต็มรูปแบบ โปรดดูที่ Temporal Fusion Transformers. การสร้างโครงนั่งร้านชุดที่สี่ที่นี่ไม่ได้สอนอะไรเลย

ข้อกำหนด: ความสามารถในการคำนวณ >= 8.0 (A100, H100, RTX 3090+), อินพุตแบบ half-precision, PyTorch >= 2.0 ตรวจสอบเส้นทางด่วนที่มีส่วนร่วมจริง torch.backends.cuda.sdp_kernel การวินิจฉัยและ torch.cuda.max_memory_allocated() — SDPA จะถอยกลับไปยังเคอร์เนลทางคณิตศาสตร์อย่างเงียบๆ หากเงื่อนไขเบื้องต้นใดๆ ล้มเหลว และการถอยกลับแบบเงียบจะดูเหมือนกับโมเดลการทำงานที่เพียงแค่ช้าเท่านั้น

การวัดผล: บริบทที่ยาวกว่าจะคุ้มค่าหรือไม่

ทุกอย่างข้างต้นบอกว่าบริบท 32K หรือ 128K ตอนนี้ ราคาไม่แพง มันไม่ได้บอกว่ามัน มีประโยชน์ หรือไม่ การทดลองที่ซื่อสัตย์:

ฝึกสถาปัตยกรรมเดียวกันที่ $N \in \{512, 4096, 32768\}$ ด้วย SDPA-Flash บนซีรีย์ BTC ที่ใช้ในที่อื่น ๆ ในชุดนี้ พารามิเตอร์การคงไว้ เครื่องมือเพิ่มประสิทธิภาพ และเป้าหมายคงที่ ดังนั้นความยาวของลำดับจึงเป็นตัวแปรเดียวเท่านั้น รายงานสองสิ่ง:

1. ราคา วัดนาฬิกาแขวนในแต่ละยุคและ torch.cuda.max_memory_allocated() ในแต่ละ $N$.
2. ประโยชน์ ประสิทธิภาพการคาดการณ์นอกตัวอย่างเทียบกับ $N$บนทางแยกที่เดินไปข้างหน้า

ร่างก่อนหน้านี้ของบทความนี้มีตารางตัวเลขหน่วยความจำต่อความยาวลำดับที่ได้มาจากการวิเคราะห์จาก $\mathcal{O}(N)$ สูตรการเปิดใช้งาน แถวเหล่านั้นจะถูกลบออก: ไม่เคยมีการวัด และพวกเขาไม่เห็นด้วยกับการคำนวณทางคณิตศาสตร์งบประมาณหน่วยความจำของบทความเอง หมายเลขที่ได้รับที่แสดงในตารางผลลัพธ์เป็นผลลัพธ์ที่สร้างขึ้น และบล็อกนี้ไม่ได้จัดส่งหมายเลขเหล่านั้น

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

บริบทที่มากขึ้นคือความจุที่มากขึ้น ดังนั้นพื้นผิวที่มากเกินไปจึงเหมาะสมมากขึ้น

มีเหตุผลเฉพาะเจาะจงที่จะคาดหวังผลลัพธ์ที่ทรงตัวหรือเป็นลบ หม้อแปลงฟิวชั่นชั่วขณะ ได้จัดทำเอกสารแล้วว่าหม้อแปลงวานิลลานำไปใช้อย่างไร้เดียงสากับซีรีส์ทางการเงินที่มากเกินไป - พวกมันขาดอคติเชิงอุปนัยชั่วคราว และโมเดลการเกิดซ้ำของการมองย้อนกลับระยะสั้นยังคงแข่งขันได้ที่ความถี่สูง การขยายบริบทจาก 512 ขั้นตอนเป็น 32,768 ขั้นตอนไม่ได้เพิ่มข้อมูลตามสัดส่วนของความยาว ความล่าช้าเล็กน้อยที่ 32,000 ของซีรีย์ราคาที่มีประสิทธิภาพใกล้เคียงกันนั้นมีน้อยมาก สิ่งที่เพิ่มได้อย่างน่าเชื่อถือคือสิ่งที่มีค่าของพารามิเตอร์เพื่อให้พอดี

เลยกวาดไปซะ $N$ จะต้องได้รับการปฏิบัติเหมือนอย่างที่เป็น: การค้นหาการเลือกรุ่น โดยใช้กลไกเดียวกันกับที่บล็อกนี้ใช้กับการค้นหาอื่นๆ ทั้งหมด ความยาวลำดับสามลำดับคูณด้วยสิ่งใดก็ตามที่แตกต่างกันคือการนับการทดลองใช้ และผู้ชนะจะต้องเคลียร์ Deflated Sharpe Ratio ที่คำนวณโดยเทียบกับจำนวนการทดลองนั้นและประตู PBO ไม่ใช่แค่เอาชนะเพื่อนบ้านเท่านั้น มิฉะนั้น "การชนะตามบริบทแบบยาว" ก็แยกไม่ออกจากการเลือกการวิ่งที่มีเสียงดังมากที่สุดสามครั้ง

การตรวจสอบความถูกต้อง เนื่องจาก "แน่นอน" ทำงานหนักมาก

ความสนใจของแฟลชนั้นตรงกันทุกประการ ในทางคณิตศาสตร์ที่ตรงกันทุกประการ คำแนะนำที่แนบมาด้วย — รันใน fp16 หรือ bf16 และบน H100 ให้พิจารณา FP8 — ไม่ใช่ สิ่งเหล่านี้เป็นข้อกล่าวอ้างที่แยกจากกัน และข้อที่สองมีอิทธิพลเหนือในทางปฏิบัติ: การเชื่อมโยงผลรวมอีกครั้งและการลดความแม่นยำลงครึ่งหนึ่งนั้นเป็นทั้งการก่อกวน และบทความที่แนะนำการรับประกันการสั่งซื้อไม่ควรโบกมือรับประกันความแม่นยำด้วยมือ

บล็อกมีเครื่องมือที่เหมาะสมอยู่แล้ว กับดักความแม่นยำของ GPU สร้างมาตรฐาน: ความแม่นยำต่ำไม่เตือนคุณ แต่จะส่งคืนขยะที่เป็นไปได้ และคุณพิสูจน์ความถูกต้องด้วย parity oracle ในปริมาณที่ไม่ต่อเนื่องดาวน์สตรีม — จำนวนการค้า — ไม่ใช่ด้วยเส้นโค้งการมอง สมัครที่นี่:

• คำนวณความสนใจด้วย SDPA-Flash ใน bf16 และการใช้งานอ้างอิง fp64 บนอินพุตที่เหมือนกัน รายงาน ข้อผิดพลาดสัมพัทธ์สูงสุด บนเทนเซอร์เอาท์พุต
• ผลักดันไปสู่การตัดสินใจ: สำหรับโมเดลที่ปล่อยป้ายกำกับขึ้น/แบน/ลง ให้รายงาน จำนวนป้ายกำกับที่พลิก ระหว่างสองเส้นทาง โดยคิดเป็นเศษส่วนของการตัดสินใจทั้งหมด

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

เมื่อไรจะเอื้อมถึง

บีบอัดการตัดสินใจซึ่งมีรูปร่างเหมือนกับ คู่มือการตัดสินใจ GPU:

• มากกว่า ~2K ไทม์สเต็ปบน CUDA GPU: ใช่ โดยไม่มีเงื่อนไข เป็นการเปลี่ยนแปลงบรรทัดเดียวที่ให้ผลลัพธ์ที่แน่นอน และการชนะจะเพิ่มมากขึ้นด้วย $N$. ไม่มีสถานการณ์ที่คุณต้องการให้เกิดขึ้นจริง $N \times N$ เส้นทางแทน
• ต่ำกว่า ~512 ก้าว บน CPU หรือด้วยสถาปัตยกรรมที่ไม่ได้รับความสนใจ (CNN, SSM เช่น Mamba): ไม่เกี่ยวข้อง ด้านซ้ายของสันเขา ค่าใช้จ่ายคงที่คือต้นทุนทั้งหมด และความสนใจไม่เคยเป็นคอขวดของคุณ
• เกณฑ์ข้างต้นเป็นเพียงนิทานพื้นบ้าน ไม่ใช่การวัดผล — มาจากวรรณกรรมทั่วไป และการครอสโอเวอร์ในรุ่นและการ์ดของคุณเองถือเป็นเกณฑ์มาตรฐานสิบบรรทัด รันแทนที่จะเชื่อเลขกลม

บทสรุป

Flash Attention เป็นผลลัพธ์ที่ชัดเจนและสำคัญอย่างแท้จริง: ด้วยการเคารพลำดับชั้นของหน่วยความจำและเชื่อมโยง softmax อีกครั้ง มันจะคำนวณความสนใจที่แน่นอนด้วย $\mathcal{O}(N)$ หน่วยความจำแทน $\mathcal{O}(N^2)$และ $\Theta(N^2 d^2 / M)$ IO bound อธิบายได้อย่างชัดเจนว่าเหตุใด การนำมาใช้ในหม้อแปลงการซื้อขายเป็นการเปลี่ยนแปลงแบบบรรทัดเดียวโดยไม่มีต้นทุนความแม่นยำในการคำนวณทางคณิตศาสตร์ที่แน่นอนและชนะหน่วยความจำขนาดใหญ่

สิ่งที่ ไม่ ทำ คือ ตอบคำถามด้านบน โดยจะแปลง "บริบทแบบเต็มวันเป็นไปไม่ได้" เป็น "บริบทแบบเต็มวันมีราคาถูก" ซึ่งเป็นการเปลี่ยนแปลงต้นทุนของการทดสอบ ไม่ใช่ผลลัพธ์ กำแพงความทรงจำที่ลงมาคือคำเชิญให้วัด และการวัดคือสิ่งที่เปลี่ยนจากสรุปในกระดาษให้กลายเป็นข้อค้นพบ

อ้างอิง

1. Dao, T., Fu, D.Y., Ermon, S., Rudra, A., Re, C. "FlashAttention: ความสนใจที่แม่นยำและรวดเร็วและมีประสิทธิภาพด้วย IO-Awareness" นิวยิปส์ (2022) arXiv:2205.14135
2. Dao, T. "FlashAttention-2: ความสนใจเร็วขึ้นพร้อมความเท่าเทียมที่ดีขึ้นและการแบ่งพาร์ติชันการทำงาน" ICLR (2024) arXiv:2307.08691
3. Dao, T., Shah, J. "FlashAttention-3: ความสนใจที่รวดเร็วและแม่นยำพร้อมความไม่ตรงกันและความแม่นยำต่ำ" นิวยิปส์ (2024) arXiv:2407.08608
4. อ.วาสวานี และคณะ "ความสนใจคือสิ่งที่คุณต้องการ" นิวยิปส์ (2017)
5. Milakov, M. , Gimelshein, N. "การคำนวณนอร์มัลไลเซอร์ออนไลน์สำหรับ softmax" arXiv:1805.02867 (2018)