O que é Flash Attention?

Autoria: Data Science in your pocket · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: What is Flash Attention? · Canal: Data Science in your pocket · 11:33 · Assistir no YouTube

Tópicos: Inferência e otimização de modelos, Modelos de IA

Resumo

Flash Attention acelera o cálculo de atenção ao reduzir o tráfego de dados entre a memória da GPU e as unidades de processamento, sem alterar o resultado matemático. A técnica combina kernel fusion, tiling e softmax online para processar blocos pequenos sem materializar as matrizes completas de atenção na HBM. No backward pass, ela descarta a matriz de probabilidades e a recalcula por blocos, economizando memória. O vídeo explica como isso funciona e em quais situações Flash Attention tende a ser mais útil.

Pontos-chave

O gargalo da atenção em GPUs modernas muitas vezes é a movimentação de dados, não a quantidade de operações aritméticas.
Kernel fusion reúne as etapas da atenção em um único kernel e evita gravar matrizes intermediárias grandes na HBM.
Tiling divide Q, K e V em blocos que podem ser processados na SRAM.
O softmax online mantém estatísticas por linha e as atualiza ao receber novos blocos, preservando o resultado exato.
No backward pass, Flash Attention recalcula as probabilidades por blocos em vez de mantê-las na memória.
A memória usada cai de uma ordem quadrática para uma ordem linear em relação ao comprimento da sequência.
Flash Attention é mais vantajosa em sequências longas e em situações em que a memória limita o treinamento ou a inference.
Para sequências curtas e modelos pequenos, o custo adicional do tiling pode reduzir os ganhos.

Capítulos

Início	Capítulo	Resumo
00:00	O custo da atenção e o gargalo de memória	O vídeo apresenta o custo quadrático da atenção e explica por que o tráfego entre HBM e unidades de processamento limita o desempenho.
02:38	Kernel fusion e tiling	A explicação mostra como reunir operações em um kernel e processar Q, K e V em blocos pequenos que cabem na SRAM.
04:15	Softmax online e cálculo exato	O vídeo detalha como atualizar o máximo, a soma e o acumulador de saída ao percorrer blocos, sem materializar a matriz inteira.
07:24	Backward pass, desempenho e usos	A seção explica a recomputação durante o backward pass, compara o tráfego de memória e apresenta resultados e situações de uso.
10:31	Como usar e resumo das ideias	O vídeo descreve formas de selecionar Flash Attention e recapitula fusão, tiling, softmax online e recomputação.

Citações

Usa memória linear em vez de quadrática e calcula exatamente a mesma resposta. — 00:30

Você precisa parar de caminhar até o depósito. — 02:38

Softmax não é local a um bloco. — 04:15

Flash Attention é atenção exata. — 08:26

A matemática no chip custa menos que as leituras da memória. — 11:02

Conceitos e entidades

Flash Attention (conceito): Algoritmo exato de atenção que reduz o tráfego de memória por meio de blocos, fusão de operações e recomputação.
Self-attention (conceito): Mecanismo que calcula relações entre os tokens de uma sequência para produzir representações contextualizadas.
softmax (conceito): Função que transforma valores em uma distribuição de probabilidades, usada para normalizar os scores da atenção.
online softmax (conceito): Forma de calcular o softmax em blocos, atualizando estatísticas acumuladas sem precisar ter a linha inteira disponível.
tiling (conceito): Divisão de uma operação em blocos menores que cabem na memória rápida da GPU.
kernel fusion (conceito): Combinação de várias operações em um único kernel para reduzir leituras e gravações de dados na memória.
HBM (conceito): Memória de alta largura de banda da GPU, maior que a SRAM, mas mais distante das unidades de processamento.
SRAM (conceito): Memória rápida e pequena próxima às unidades de processamento da GPU, usada para guardar os blocos durante o cálculo.
A100 (ferramenta): GPU usada no vídeo como exemplo para comparar capacidade e velocidade de HBM e SRAM.
FlashAttention-2 (conceito): Versão de Flash Attention que, segundo o vídeo, aumenta a velocidade ao paralelizar ao longo do comprimento da sequência e reduzir operações não matriciais.
FlashAttention-3 (conceito): Versão voltada a GPUs Hopper que usa técnicas como warp specialization para sobrepor computação e movimentação de dados.
H100 (ferramenta): GPU da arquitetura Hopper citada como alvo de FlashAttention-3.
PyTorch (ferramenta): Framework mencionado como uma forma de chamar a atenção escalada e selecionar um backend Flash quando disponível.

Tradução completa (pt-BR)

00:00 Boas-vindas ao Data Science in Your Pocket. Aqui vai um fato surpreendente. Quando você treina um modelo na escala do GPT, o que mais consome tempo e memória é a própria atenção. [música] O mecanismo que torna os transformers inteligentes. O custo da atenção cresce quadraticamente com o comprimento da sequência. [música] E, pior ainda, a implementação padrão passa a maior parte do tempo movimentando dados pela GPU, em vez de fazer cálculos. [música] Então, aqui está o enigma. Flash Attention é dramaticamente mais rápida, [música] usa memória linear em vez de quadrática

00:30 e calcula exatamente a mesma resposta. Sem aproximações, sem atalhos matemáticos. Como? Ao final deste vídeo, você vai entender o truque, até chegar às exponenciais, com um exemplo resolvido que poderá verificar à mão. Vamos lá. Uma rápida recapitulação da self-attention. Comece com a entrada X, uma linha por token, n linhas com largura D. [música] Multiplique X por três matrizes aprendidas W sub Q, W sub K, W sub V para obter Q, [música] K e V. Em seguida

01:04 calcule as pontuações S = Q * K transposta dividido pela raiz quadrada de D. Aplique softmax linha por linha para obter as probabilidades P e a saída O = P [música] * V. Aqui está o problema. S, de N por N, e a implementação padrão grava ambas inteiras [música] na memória da GPU. Digamos que N seja 8.192 tokens. N ao quadrado dá cerca de 67 milhões de valores e, em floats de 32 bits, isso equivale a aproximadamente 268 megabytes para uma matriz de atenção

01:35 [música] de uma cabeça de uma camada. Os modelos reais têm dezenas de cada [música], e você também precisa da passagem para trás. Dá para imaginar onde isso vai dar. Aqui está a mudança de perspectiva. Nas GPUs modernas, o gargalo da atenção não é a aritmética. É a largura de banda da memória. Sua GPU tem dois tipos de memória. HBM é a grande: 40 [música] GB em uma A100, mas com apenas cerca de 1.555 GB por segundo, e fica longe das unidades de computação. SRAM é

02:08 minúscula, cerca de 20 megabytes no total em uma A100, mas [música] incrivelmente rápida, por volta de 19 terabytes por segundo. Agora observe a atenção padrão. Leia Q e K da HBM. Grave S [música] de volta. Leia S, grave P, leia P e V, grave O. Viagem de ida e volta após viagem de ida e volta. Uma analogia. [música] As unidades de computação são uma cozinha brilhante e extremamente rápida. E a HBM é um armazém do outro lado da cidade. O chef mal cozinha. [música] O dia inteiro é desperdiçado. Caminhando até o armazém com pratos meio

02:38 prontos. Deixar a cozinha mais rápida não muda [música] nada. É preciso parar de caminhar. Tudo o que Flash Attention faz vem dessa única ideia. Ideia um: fusão de kernels. Normalmente, cada operação — multiplicação de matrizes, escala, softmax — [música] é executada como um kernel próprio da GPU, e cada kernel lê as entradas da HBM e grava as saídas de volta. A fusão propõe escrever um único kernel CUDA que execute toda a atenção, do início ao fim. Carregue Q, [música] K,

03:11 e V na SRAM uma única vez. Faça todos os cálculos no chip e grave apenas o O final. As matrizes S e P, de N por N, nunca chegam a existir na memória lenta. Há um problema: [música] a SRAM é minúscula. Cada multiprocessador de streaming de uma A100 tem cerca de 192 kilobytes de memória compartilhada. Uma matriz de atenção de centenas de megabytes nunca caberá em 192 kilobytes. Não podemos carregar o problema inteiro no chip. [música] Então, precisamos processá-lo em pequenos pedaços. Essa é a ideia dois.

03:44 Ideia dois: divisão em blocos. Divida Q em blocos de linhas [música] e K e V em blocos de colunas. O kernel fundido carrega um bloco de Q na SRAM e o mantém lá. [música] Depois, percorre os blocos de K e V. Traz um par de blocos para a SRAM. Calcula [música] um pequeno bloco da matriz de pontuações. Atualiza uma saída acumulada. E passa adiante. Quando o loop termina, aquele bloco de O está pronto. Em uma A100, os blocos típicos têm 64 ou 128 linhas e colunas, pequenos o bastante para caber com folga [música] na memória

04:15 compartilhada disponível. A gigantesca matriz de atenção é processada bloco por bloco, como ler um livro enorme, uma página por vez, em vez de copiá-lo inteiro para a mesa. Mas há um problema escondido. Softmax não é local a cada bloco. Resolver isso é o cerne matemático de Flash Attention. O problema central é que softmax precisa do máximo e da soma das exponenciais da linha inteira, mas a divisão em blocos nos mostra a linha um bloco de cada vez. A solução é o softmax online, de Milikov e Gimmelshine, de

04:46 2018. Mantenha duas estatísticas acumuladas por [música] linha: m, o máximo visto até então, e l, a soma acumulada das exponenciais ajustadas a esse máximo. Quando chega um novo bloco, com máximo do bloco m subbloco, atualize assim. O novo máximo m linha é o máximo entre m e m subbloco. Calcule [música] dois fatores de escala. Alfa = e elevado a m menos m linha, que corrige todas as exponenciais antigas, e beta = e elevado a m subbloco [música] menos m linha, que coloca o novo bloco na

05:17 mesma escala. A nova soma l linha é igual a alfa * l + beta * a soma, no bloco, de e [música] elevado a x - m subbloco. Reescale o acumulador de saída da mesma maneira. O acumulador O passa a ser alfa * O mais beta * P [música] do bloco * V do bloco. No final, divida por l linha. O método é numericamente estável porque cada exponencial é de um número menor ou igual a zero. Nunca há overflow. Um pequeno exemplo que você pode verificar, para as pontuações

05:49 [música] 1, 2, 3, 0, divididas em dois blocos de dois. As pontuações do bloco um são 1 e 2. O máximo M1 é igual a [música] 2. A soma L1 é e elevado a menos 1 + e elevado a 0, aproximadamente 0,368 + 1. Portanto, [música] 1,368. Agora, o bloco 2: 3 e 0. O máximo do bloco, 3, supera o máximo acumulado. Então, m2 é igual a 3. Reescale a soma antiga por e elevado a 2 menos

06:20 3, aproximadamente 0,368. A nova soma L2 é igual a 0,368 * 1,368, [música] que é 0,503, mais a contribuição do novo bloco: e [música] elevado a 0 + e elevado a menos 3, totalizando 1,0498. O total é 1,553. Agora, confira: o denominador do softmax calculado da maneira tradicional é e elevado a 1 + e elevado a 2 + e elevado a 3 + e elevado a 0, ou seja, 31,19.

06:52 Multiplique por e elevado a menos 3 e você obtém [música] exatamente 1,553: o mesmo resultado exato do softmax, sem nunca manter mais de duas pontuações ao mesmo tempo. A passagem para trás é onde a atenção padrão é penalizada duas vezes. >> [música] >> A retropropagação por softmax precisa que a matriz P inteira, de N por N, seja mantida na HBM desde a passagem para a frente. Flash Attention descarta P. Ela armazena apenas a saída O e as estatísticas m e l, dois floats por linha, uma quantidade de memória da ordem de N, em vez de

07:24 uma quantidade da ordem de N ao quadrado. Durante a passagem para trás, recalcula [música] P bloco por bloco na SRAM, usando o mesmo loop de divisão em blocos. Parece desperdício. Lembre-se da cozinha: o tempo do chef [música] é barato. As viagens ao armazém são caras. Recalcular um bloco custa operações de ponto flutuante, [música] mas ler P da HBM consome muito mais tempo do que essas operações. Fazer mais cálculos torna a passagem para trás mais rápida, e o uso de memória durante o treinamento [música] despenca justamente quando você precisa de espaço de sobra. Agora, a teoria, porque os autores

07:55 provaram isso: conte os acessos à HBM. A atenção padrão movimenta uma quantidade da ordem de N * D + [música] N^2 bytes. O termo N^2 domina. Flash Attention, com blocos ajustados para uma SRAM de tamanho M, precisa apenas de uma quantidade da ordem de N^2 * D^2 / M. Com a dimensão da cabeça D entre 64 e 128 e M em torno de 100 kilobytes, isso significa aproximadamente [música] 10 a 20 vezes menos bytes atravessando o limite da memória lenta. E, como S e P nunca são materializadas, [música] o uso de memória cai de

08:26 O de N^2 para O de N * D, linearmente com o comprimento da sequência. Grave isso na memória. Flash Attention é atenção exata. Não é esparsa, não é de baixo posto, não é uma aproximação de kernel. É a mesma [música] função, os mesmos gradientes, a mesma qualidade; apenas um agendamento mais inteligente dos mesmos cálculos, projetado em torno da hierarquia de memória. Uma vantagem gratuita que é realmente gratuita. O que isso oferece na prática? Estes são números relatados nos artigos, então considere-os aproximados.

08:58 A Flash Attention original, de Try Dow e colegas, em 2022, executou a atenção cerca de duas a quatro vezes mais rápido [música] e relatou uma aceleração de até 7,6 vezes no treinamento de GPT2 de ponta a ponta, porque a atenção dominava com sequências longas. A memória linear ampliou as context windows de 16.000 tokens para 64.000 ou mais. Flash Attention 2, em 2023, [música] praticamente dobrou a velocidade outra vez ao paralelizar na dimensão do comprimento da sequência e reduzir as operações de ponto flutuante de multiplicação de matrizes não feitas pelas

09:29 unidades de multiplicação [música], aproveitando melhor os tensor cores. Flash Attention 3 foi projetada para GPUs Hopper, [música] como a H100, usando especialização de warps para sobrepor cálculos e movimentação de dados, além de [música] FP8, alcançando até cerca de 75% do throughput teórico máximo. A atenção deixou de ser um gargalo e se tornou um dos kernels mais otimizados em deep learning. Quando você deve usá-la? Para sequências longas, a partir de 4.000 tokens, quando o limite quadrático começa a pesar. Para treinamento ou fine-tuning

10:00 modelos de linguagem grandes [música], nos quais a memória salva se transforma em lotes maiores ou contextos mais longos. Inferência limitada pela memória com prompts longos. Sinceramente, qualquer transformer com um contexto grande. [música] Quando isso não faz diferença? Em sequências curtas, com menos de mil tokens, em que tudo cabe no cache de qualquer forma, e em modelos pequenos, nos quais a sobrecarga do tiling pode consumir [música] os ganhos; além disso, raramente você implementa algo em PyTorch. Basta chamar a atenção de produto escalar escalada, e ela seleciona automaticamente um backend Flash quando possível, ou

10:31 instale o pacote Flash Attention da Dao-AILab. No Hugging Face, passe attention implementation igual a flash attention 2 ao carregar o modelo: uma linha. Isso se tornou a forma padrão de executar a atenção, e é por isso que vale a pena entender como ela funciona. Para fazer o Flash Attention funcionar, a ideia é: um, fusão de kernels [música] — executar a atenção em um único kernel para que os enormes intermediários nunca cheguem à HBM. Dois, [música] dividir Q, K e V em blocos do tamanho da SRAM e iterar.

11:02 Três: softmax online. [música] Um máximo acumulado e uma soma acumulada, com reescalonamento, exatos mesmo que você veja apenas um bloco de cada vez. Quatro: recomputação. Armazenar apenas a saída e pequenas estatísticas por linha. Reconstruir P na hora durante a retropropagação [música], porque os cálculos no chip são melhores do que as leituras da memória. O resultado é atenção exata, uso de memória linear e acelerações de várias vezes, por respeitar o hardware em vez de [música] lutar contra ele. Se isso fez sentido, os próximos tópicos naturais são o cache KV para geração [música] rápida

11:33 e a atenção paginada, que aplica o mesmo raciocínio sobre memória ao serving de inferência. Os dois estão vinculados na tela. Inscreva-se no Data Science in Your Pocket para ver mais análises aprofundadas em que realmente fazemos as contas. Obrigado por [música] assistir.

Transcrição original

[00:00] Welcome to data science in your pocket. Here is a surprising fact. When you train a GPT scale model, the biggest eater of time and memory is attention itself. [music] The very mechanism that makes transformers smart. Attention’s cost grows quadratically with sequence length. [music] And worse, the standard implementation spends most of its time shuffling data around the GPU instead of computing. [music] So, here is the puzzle. Flash attention is dramatically faster, [music] uses linear instead of quadratic

[00:30] memory, and computes the exact same answer. No approximation, no math shortcuts. How? By the end of this video, you will understand the trick down to the exponentials with a worked example you can verify by hand. Let’s go. Quick recap of self attention. Start with input X, one row per token, n rows of width D. [music] Multiply X by three learned matrices W sub Q, W subK, W subV to get Q, [music] K, and V. Then

[01:04] the scores S= Q * KRpose divided by the square root of D. Apply softmax row by row to get probabilities P and the output O= P [music] * V. Here is the catch. Sn byN and the standard implementation writes both in full [music] to GPU memory. Say N is 8,192 tokens. N squared is about 67 million entries and in 32bit floats that is roughly 268 megabytes for one attention

[01:35] matrix [music] of one head of one layer. Real models have dozens of each [music] and you need the backward pass too. You can see where this goes. Here is the mental shift. On modern GPUs, attention’s bottleneck is not arithmetic. It is memory bandwidth. Your GPU has two kinds of memory. HBM is the big one, 40 [music] GB on an A100, but only about 1555 GB per second, sitting far from the compute units. SRAM is

[02:08] tiny, roughly 20 megabytes total on an A100, but [music] blindingly fast, around 19 terabytes per second. Now watch standard attention. Read Q and K from HBM. Write S [music] back. Read S, write P, read P andV, write O. Round trip after round trip. Analogy. [music] The compute units are a brilliant lightning fast kitchen. And HBM is a warehouse across town. The chef barely cooks. [music] The day is wasted. Walking to the warehouse with

[02:38] half-finish dishes. Making the kitchen faster changes [music] nothing. You must stop the walking. Everything flash attention does comes from that one insight. Idea one kernel fusion. Normally every operation matrix multiply scale softmax [music] runs as its own GPU kernel and each kernel reads inputs from HBM and writes outputs back. Fusion says write one single CUDA kernel that does all of attention end to end. Load Q, [music] K,

[03:11] and V into SRAMM once. Compute everything on chip and write out only the final O. The N byN matrices S and P never exist in slow memory at all. One problem, [music] SRAMM is tiny. Each streaming multiprocessor on an A100 has about 192 kilob of shared memory. A hundreds of megabytes attention matrix will never fit in 192 kilob. We cannot load the whole problem onto the chip. [music] So we need to chew it in small pieces. That is idea two.

[03:44] Idea two, tiling. Split Q into row blocks [music] and K and V into column blocks. The fused kernel loads one Q block into SRAMM and keeps it there. [music] Then loops over K and V blocks. Pull one pair into SRAM. Compute [music] a small tile of the score matrix. Update a running output. Move on. When the loop ends, that block of O is final. On an A100, typical blocks are 64 or 128 rows and columns, small enough to fit comfortably [music] in the available

[04:15] shared memory. The giant attention matrix gets processed tile by tile, like reading a huge book one page at a time instead of photocopying it all onto your desk. But there is a snake in the grass. Softmax is not block local. Fixing that is the mathematical heart of flash attention. The core problem softmax needs the maximum and the exponential sum of the whole row but tiling shows us the row one block at a time. The fix is online softax from Milikov and Gimmelshine in

[04:46] 2018. Maintain two running statistics per [music] row m the max seen so far and l the running sum of exponential scaled to that max. When a new block arrives with block max m subblock update like this. The new max m prime is the maximum of m and m subblock. Compute [music] two risk scale factors. Alpha= e to the m minus m prime. Correcting all old exponentials and beta= e to the m subblock [music] minus m prime. Putting the new block on the

[05:17] same scale. The new sum l prime equals alpha * l + beta * the block sum of e [music] to the x - m subblock. Rescale the output accumulator the same way. O ACC becomes alpha * occ plus beta * p [music] block * v block. At the end divide by l prime and it is numerically stable because every exponential is of a number at most zero. No overflow ever. Tiny example you can verify for scores

[05:49] [music] 1 2 3 zero tiled into two blocks of two. Block one scores one and two. Max M1 equals [music] 2. Sum L1 is E the minus1 + E to the 0 about 0.368 + 1. So [music] 1.368. Now block 2 3 and zero. Block max three beats are running max. So m2 equals 3. Rescale the old sum by e to the 2 minus

[06:20] 3 about 0.368. New sum L2 equ= 0.368 * 1.368 [music] which is 0503 plus the new blocks contribution E to [music] the 0 + EUS 3 1.0498 total 1.553. Now the check textbook soft max denominator e to the 1 + e 2 + e 3 + e to the 0 31.19

[06:52] scale by e to the minus3 and you get [music] 1.553 exactly the same exact soft max never holding more than two scores at once. The backward pass is where standard attention gets punished twice. >> [music] >> Back prop through softmax needs the full N byN matrix P kept in HBM from the forward pass. Flash attention throws P away. It stores only the output O and the pero statistics M and L two floats per row order of N memory instead of

[07:24] order of N squared. During backward, it recomputes [music] P block by block in SRAMM using the same tiling loop. Wasteful. Remember the kitchen, the chef’s [music] time is cheap. The warehouse trips are expensive. Recomputing a tile costs flops, [music] but reading P from HBM costs far more time than those flops. Doing more arithmetic makes backward faster and the training time memory footprint [music] collapses right where you need the headroom. Now the theory, because the authors

[07:55] proved it, count HBM accesses. Standard attention moves on the order of N * D + [music] N^ 2 bytes. The n^ 2 term dominates. Flash attention with blocks tuned to SRAMM of size M needs only on the order of N^ 2 * D ^ 2 / M with head dimension D of 64 to 128 and M around 100 kilobyt that is roughly [music] 10 to 20 times fewer bytes crossing the slow boundary. And since S and P are never materialized, [music] memory drops from

[08:26] O of N^ 2 to O of N * D, linear in sequence length. Tattoo this on your brain. Flash attention is exact attention. Not sparse, not low rank, not a kernel approximation. Same [music] function, same gradients, same quality, purely a smarter schedule of the same arithmetic engineered around the memory hierarchy. A free lunch that is actually free. What does it buy in practice? These are figures reported by the papers, so treat

[08:58] them as approximate. The original flash attention from Try Dow and colleagues in 2022 ran attention roughly two to four times faster [music] and reported up to a 7.6 time speed up on GPT2 training end to end because attention dominated at long sequences. Linear memory pushed context windows from 16,000 tokens to 64,000 beyond. Flash Attention 2 in 2023 roughly [music] doubled speed again by parallelizing over the sequence length dimension and cutting non-matrix

[09:29] multiply [music] flops feeding the tensor cores better. Flash Attention 3 targeted Hopper GPUs [music] like the H100 using warp specialization to overlap compute with data movement plus [music] FP8 reaching up to about 75% of theoretical peak throughput. Attention went from bottleneck to one of the most optimized kernels in deep learning. When should you use it? Long sequences 4,000 tokens and up where the quadratic wall bites. Training or fine-tuning

[10:00] large language models [music] where saved memory becomes bigger batches or longer contexts. Memory bound inference with long prompts. Honestly, any transformer with a big context. [music] When does it not matter? short sequences under a thousand tokens where everything fits in cache anyway and tiny models where tiling overhead can eat [music] the gains and you rarely implement anything in PyTorch. Just call scaled.product attention and it auto selects a flashbackend when possible or

[10:31] install the flash attention package from try dowo in hugging face pass attention implementation equals flash attention too when loading the model one line. It has become the default way to run attention which is why understanding the machinery is worth your time for ideas make flash attention work. One kernel [music] fusion run attention in a single kernel so the giant intermediates never touch HBM. Two [music] tiling chop Q K and V into

[11:02] SRAM sized blocks and loop. Three, online soft max. [music] A running max and running sum with rescaling exact even though you see one block at a time. Four, recomputation. Store only the output and tiny per row stats. Rebuild P on the fly during backward [music] because onchip math beats memory reads. The result exact attention linear memory multiffold speedups from respecting the hardware instead of [music] fighting it. If this clicked, the natural next stops are the KV cache for fast [music]

[11:33] generation and page detention, which applies the same memory thinking to inference serving. Both are linked on screen. Subscribe to Data Science in Your Pocket for more deep dives where we actually do the math. Thanks for [music] watching.