LLM & Parallel Language Inference Datasheet v3.0¶

Um LLM causal autorregressivo não é um gerador de frases. É uma máquina que transforma uma sequência de estados vetoriais em uma distribuição sobre o próximo token — repetidamente.

1. Grafo computacional canônico¶

\[ text\rightarrow tokenizer\rightarrow embeddings\rightarrow blocks_{1:L}\rightarrow norm\rightarrow LM\ head\rightarrow logits\rightarrow logit\ processing\rightarrow sampler\rightarrow token \]

Com cache:

\[ (K,V)_{1:L,1:t-1}\rightarrow attention_t\rightarrow (K,V)_{1:L,1:t} \]

A interface normalmente mostra apenas a etapa logits → sampler. O restante determina a maior parte da capacidade e do custo.

PARTE I — REPRESENTAÇÃO¶

2. Tokenizer¶

\[ s\xrightarrow{Tokenizer}(x_1,x_2,\dots,x_T) \]

Variáveis fundamentais¶

Variável	Tag	O que controla
Vocabulary size \(V\)	`MODEL`	dimensão da distribuição de saída
Tokenization algorithm	`MODEL`	granularidade da sequência
Special tokens	`MODEL`	BOS/EOS/FIM/chat control
Chat template	`MODEL/PIPE`	serialização real do diálogo

Relação física¶

Para a mesma informação semântica:

\[ T\downarrow\Rightarrow prefill\downarrow,\ KV\downarrow \]

mas vocabulário maior aumenta LM head/embedding e muda a geometria estatística dos tokens.

Failure surface¶

Um modelo correto com chat template incorreto pode parecer burro, repetitivo ou desobediente sem que o sampling esteja errado.

3. Embeddings e residual stream¶

Entrada inicial simplificada:

\[ h_t^{(0)}=E[x_t] \]

O residual stream percorre os blocos:

\[ h^{(l+1)}=h^{(l)}+Attention(Norm(h^{(l)}))+FFN/MoE(\cdot) \]

A arquitetura exata pode ser pre-norm/post-norm, RMSNorm/LayerNorm e usar residual arrangements distintos.

PARTE II — POSIÇÃO E ATENÇÃO¶

4. RoPE¶

Rotary Position Embeddings aplicam rotações dependentes da posição a Q/K.

Em forma conceitual:

\[ q'_t=R(t)q_t,\qquad k'_t=R(t)k_t \]

A atenção passa a depender de posição relativa através do produto interno rotacionado.

Knobs associados¶

RoPE theta/base;
frequency scaling;
linear scaling;
YaRN factors;
original context length;
extension factor.

Regra¶

\[ context\ extension\neq context\ training \]

Conseguir alocar 128k tokens não prova que o modelo preserve qualidade equivalente em 128k.

5. Attention¶

Para cada camada:

\[ Q=XW_Q,\qquad K=XW_K,\qquad V=XW_V \]

\[ A(Q,K,V)=softmax\left(\frac{QK^\top}{\sqrt{d_h}}+M\right)V \]

onde \(M\) contém a máscara causal e possíveis biases.

A equação de attention é por query head: a head \(h\) usa \(Q_h\) e os \(K_{g(h)},V_{g(h)}\) compartilhados, onde \(g(h)\) mapeia para sua KV head. Para grupos GQA contíguos de mesmo tamanho, com índices a partir de zero, \(g(h)=\lfloor h/(n_q/n_{kv})\rfloor\); esse agrupamento pressupõe \(n_q\) divisível por \(n_{kv}\).

Shapes típicos¶

\[ Q\in\mathbb{R}^{B\times n_q\times T\times d_h} \]

\[ K,V\in\mathbb{R}^{B\times n_{kv}\times T\times d_h} \]

6. MHA, GQA, MQA¶

Multi-Head Attention¶

\[ n_{kv}=n_q \]

Grouped-Query Attention¶

\[ n_{kv}\lt n_q \]

Várias query heads compartilham K/V.

Multi-Query Attention¶

\[ n_{kv}=1 \]

Efeito direto¶

\[ M_{KV}\propto n_{kv} \]

GQA/MQA são, entre outras coisas, mecanismos de redução de estado persistente durante decode.

7. Multi-head Latent Attention — MLA¶

Em vez de armazenar K/V completos por cabeça, a arquitetura comprime estados para latentes menores e reconstrói/projeta conforme necessário.

Conceitualmente:

\[ h_t\rightarrow c_t^{KV}\ll (K_t,V_t)_{full} \]

Isso reduz pressão do KV cache. DeepSeek-V3 é referência importante dessa família.

Não usar automaticamente a fórmula de KV de GQA para modelos MLA sem consultar a arquitetura/backend.

PARTE III — FFN E MoE¶

8. Feed-Forward Network¶

Uma forma comum com gated activation:

\[ FFN(x)=W_2\left(\phi(W_gx)\odot W_1x\right) \]

Em Transformers modernos, FFN representa grande parte dos parâmetros e do tráfego de memória.

9. Mixture of Experts¶

Abaixo está uma variante esquemática de MoE roteado. Ativação do router, normalização dos pesos selecionados e experts compartilhados dependem da arquitetura; esta não é a especificação exata de todo MoE.

Router:

\[ g(x)=softmax(W_rx) \]

Escolha:

\[ S=TopK(g(x)) \]

Saída:

\[ y=\sum_{i\in S}g_i(x)E_i(x) \]

Três números obrigatórios¶

Métrica	Significado
\(N_{total}\)	parâmetros armazenados
\(N_{active}\)	parâmetros efetivamente executados/token
\(k\)	experts selecionados/token

Regra operacional¶

\[ compute/token\sim N_{active} \]

mas:

\[ storage\sim N_{total} \]

Um MoE pode ser computacionalmente “3B ativo” e ainda exigir armazenamento equivalente a dezenas de bilhões de parâmetros.

PARTE IV — LOGITS¶

10. LM head¶

Estado final:

\[ h_t\in\mathbb{R}^{d} \]

Logits:

\[ z=W_{vocab}h_t+b \]

\[ z\in\mathbb{R}^{V} \]

Antes de sampling, ainda não são probabilidades.

Softmax:

\[ p_i=\frac{e^{z_i}}{\sum_j e^{z_j}} \]

PARTE V — LOGIT PROCESSING E SAMPLING¶

11. Temperature¶

\[ p_i(T)=\frac{e^{z_i/T}}{\sum_j e^{z_j/T}} \]

Região	Efeito matemático
\(T<1\)	distribuição mais concentrada
\(T=1\)	distribuição original
\(T>1\)	distribuição mais plana
\(T\to0\)	aproxima argmax/greedy

Temperature não significa criatividade. Criatividade é um correlato emergente da mudança na distribuição.

12. Top-K¶

Retém apenas:

\[ S=TopK(z,K) \]

e mascara o restante.

É um limite absoluto de cardinalidade do suporte.

Caveat¶

Um K=40 é igualmente rígido em uma distribuição plana e em uma distribuição extremamente concentrada. Por isso é menos adaptativo que Min-P/Top-P.

13. Top-P / Nucleus¶

Ordene probabilidades decrescentes e escolha o menor conjunto \(S\) tal que:

\[ \sum_{i\in S}p_i\ge P \]

Cardinalidade do suporte varia dinamicamente.

14. Min-P¶

Critério:

\[ p_i\ge p_{min}\cdot p_{max} \]

Se \(p_{max}=0.8\) e min_p=0.05:

\[ p_i\ge0.04 \]

Em termos de logits, antes de transformações adicionais:

\[ z_i-z_{max}\gtrsim\ln(p_{min}) \]

O corte se adapta à confiança do modelo.

15. Typical sampling¶

Typical sampling favorece tokens cuja surprisal fica próxima da entropia local:

\[ I(x_i)=-\log p_i \]

\[ H(p)=-\sum_i p_i\log p_i \]

Tokens muito previsíveis ou muito improváveis podem ser removidos se forem “atípicos” em relação à distribuição.

16. Top-N-Sigma¶

Família de filtros que usa estatísticas da distribuição de logits/probabilidades para remover cauda com threshold adaptativo baseado em dispersão. É backend-specific; documentar implementação concreta antes de inferir equivalência com Min-P.

17. XTC¶

XTC busca aumentar diversidade removendo probabilisticamente alguns tokens excessivamente prováveis sob certas condições. É um mecanismo de shaping de suporte, não um substituto matematicamente equivalente a temperature.

Use como BACKEND/INF, não como propriedade universal de LLMs.

18. Presence/Frequency penalties¶

Forma conceitual OpenAI-style:

\[ z_i'=z_i-\alpha\cdot 1[c_i>0]-\beta\cdot c_i \]

onde:

\(\alpha\): presence penalty;
\(\beta\): frequency penalty;
\(c_i\): contagem do token no histórico considerado.

19. Repetition penalty¶

Implementações variam; uma forma comum modifica logits diferentemente conforme sinal e presença prévia.

Não trate como simplesmente “dividir probabilidade por X”. É backend-specific.

Failure surface¶

Penalidade alta pode punir:

palavras funcionais;
nomes próprios necessários;
sintaxe de código;
padrões estruturais legítimos.

20. DRY — sequência, não token¶

DRY penaliza repetição de sequências/n-grams crescentes. Conceitualmente, se uma extensão de sequência já ocorreu, aplica penalidade crescente conforme comprimento repetido.

É particularmente útil quando:

\[ repetition\ problem\neq repeated\ individual\ tokens \]

RP e narrativa se beneficiam porque vícios frequentemente são frases inteiras.

21. Adaptive-P¶

O llama.cpp moderno implementa um sampler realimentado que mantém EMA da probabilidade original dos tokens escolhidos e ajusta o target ao longo da geração.

Conceitualmente:

\[ \bar p_t=\lambda\bar p_{t-1}+(1-\lambda)p(x_t) \]

O sampler tenta selecionar tokens próximos de um target adaptativo.

Isso é diferente de um filtro estático: há estado interno do sampler.

22. Mirostat¶

Controlador feedback-oriented para manter surprisal/perplexity próxima de um alvo.

Princípio:

\[ error_t=\tau-surprisal_t \]

\[ control_{t+1}=control_t+\eta\cdot error_t \]

Implementação exata depende da versão. Classificar como adaptive controller, não simplesmente “temperature automática”.

PARTE VI — CONSTRAINED DECODING¶

23. Grammar / JSON Schema¶

Em cada passo, existe um conjunto de tokens lexicalmente/sintaticamente válidos:

\[ V_t^{valid}\subseteq V \]

O sampler é restringido:

\[ p_t'(x)=0\quad\forall x\notin V_t^{valid} \]

Importante¶

\[ syntax\ validity\neq semantic\ correctness \]

JSON perfeito pode conter um argumento inventado ou uma ação errada.

PARTE VII — ESTADO E CUSTO¶

24. KV cache¶

Para GQA/MHA:

\[ M_{KV}\approx2LTn_{kv}d_hbB \]

É linear em contexto armazenado.

“Quanto custa +1k tokens?”¶

\[ \Delta M_{KV,1k}=2000Ln_{kv}d_hbB \]

Faça essa conta antes de decidir contexto.

25. Prefill e decode¶

Prefill¶

Transforma todo o prompt e constrói KV.

Decode¶

Repete:

\[ h_t\rightarrow logits_t\rightarrow token_{t+1}\rightarrow KV_{t+1} \]

A latência/token cresce com estado e arquitetura.

26. Context window: quatro limites diferentes¶

config maximum — runtime aceita;
positional encoding range — RoPE/scaling suporta;
training distribution — modelo viu durante treino;
effective context — informação realmente utilizada com qualidade.

Não confundir os quatro.

PARTE VIII — REASONING E BUDGET¶

27. Reasoning tokens / thinking budget¶

Em modelos que externalizam ou internalizam etapas adicionais, gerar mais tokens de reasoning acrescenta inferência sequencial. Com prompt fixo e custo médio por token gerado aproximadamente estável:

\[ Cost\propto T_{generated} \]

Não é um novo tipo de matemática de atenção; é principalmente uma mudança na política de geração/treinamento e no orçamento de tokens/computation.

Caveat¶

Mais reasoning budget não garante monotonicamente melhor resposta.

PARTE IX — COUPLING MATRIX¶

28. Relações principais¶

Controle ↑	Entropia	Support	Repetição	KV	Latência	Comentário
Temperature	↑	=	geralmente ↓	=	~	pode aumentar incoerência
Top-K	—	↑	pode ↑	=	~	corte absoluto
Top-P mais restritivo	↓	↓	pode ↑	=	~	adaptativo cumulativo
Min-P mais alto	↓	↓	pode ↑	=	~	relativo ao top token
Rep penalty	variável	variável	↓ lexical	=	~	pode ferir sintaxe
DRY	variável	variável	↓ sequencial	=	pequeno	ótimo contra loops longos
Context	—	—	variável	↑ linear	↑	possível quality gain/loss
KV precision	~	=	=	↑ com bits	pode variar	accuracy/runtime dependent
Batch/parallel	—	—	—	↑	throughput ↑	latency individual pode subir

PARTE X — MAPEAMENTO PARA STACK LOCAL¶

29. SillyTavern¶

A UI deve ser lida como control plane. Ela não define a matemática; envia parâmetros ao backend.

Verificar sempre:

sampler order;
quais samplers o backend ignora;
stop strings;
context size;
instruct/chat template;
system prompt injection;
grammar/JSON schema quando aplicável.

30. KoboldCpp / llama.cpp¶

Em 2026 o conjunto inclui, entre outros:

penalties;
DRY;
top-n-sigma;
top-k;
typical;
top-p;
min-p;
XTC;
temperature;
adaptive-p;
grammar;
quantized KV;
speculative decoding.

A ordem é uma propriedade do backend/configuração. Não escrever “a ordem universal é X”.

31. LM Studio / Ollama¶

Tratar como frontends/runtimes com defaults próprios. Para benchmark técnico, fixar:

mesmo GGUF/checkpoint;
mesma template;
mesmo context;
mesmos samplers;
mesma seed;
mesma quantização KV;
mesmo GPU offload.

Caso contrário, comparar “modelo A vs B” vira comparar pipelines diferentes.

PARTE XI — PROTOCOLO EXPERIMENTAL¶

32. Sweep científico de sampling¶

Fixar prompt/template/context/seed/backend/model.
Registrar top logits/probabilities por token se possível.
Alterar uma família de controle por vez.
Medir:
entropy;
support size;
repetition rate;
unique n-grams;
task accuracy;
subjective quality.
Repetir em múltiplas seeds — uma seed é um ponto, não uma distribuição.

PARTE XII — FAILURE DIAGNOSTICS¶

33. Sintoma → hipótese¶

Sintoma	Investigar primeiro
frases repetidas	DRY / context injection / low entropy
sinônimos estranhos	rep penalty excessiva
texto incoerente	temp/support muito aberto / model limit
resposta truncada	max tokens / EOS / stop strings
desobediência	template/system/conditioning antes de sampling
qualidade cai em contexto longo	RoPE regime/effective context/KV precision
TPS despenca	context/KV/offload/bandwidth
JSON inválido	grammar/schema, não temperature somente

34. Snapshot 2026¶

DeepSeek-V3: 671B total, 37B ativos/token, MLA + DeepSeekMoE.
Qwen3-Coder-Next: 80B total, ~3B ativos durante inferência, evidenciando importância de separar total/active parameters.
llama.cpp: sampling moderno inclui DRY, XTC, top-n-sigma e adaptive-p além do clássico top-k/top-p/min-p.

Referências¶

llama.cpp sampler API — https://github.com/ggml-org/llama.cpp/blob/master/include/llama.h
llama.cpp completion sampling docs — https://github.com/ggml-org/llama.cpp/blob/master/tools/completion/README.md
llama.cpp CLI/runtime — https://github.com/ggml-org/llama.cpp/blob/master/tools/cli/README.md
DeepSeek-V3 — https://arxiv.org/abs/2412.19437
Qwen3-Coder-Next — https://arxiv.org/abs/2603.00729

PARTE XIII — PARALLEL / MASKED / DIFFUSION LANGUAGE MODELS¶

Transformer não implica autoregressão. A partir daqui, abandonamos a hipótese de que o texto só pode avançar token1 → token2 → token3.

Relacionados: 01_GUT_GENERATIVE_AI_UNIFIED_ENGINEERING, 09_LOCAL_AI_INFERENCE_RUNTIME_DATASHEET.

35. Autoregressive factorization — baseline¶

\[ p(x_{1:T})=\prod_{t=1}^{T}p(x_t|x_{\lt t}) \]

Inferência:

x1 -> x2 -> x3 -> ... -> xT

A posição \(t+1\) não existe antes de \(t\) ser decidido.

Implicações¶

streaming natural;
KV incremental extremamente eficiente;
latency cresce com número de output tokens;
erro/decisão anterior vira conditioning posterior.

36. Masked language modeling¶

Defina máscara \(M\subset\{1,\ldots,T\}\):

\[ \mathcal L=-\sum_{i\in M}\log p(x_i|x_{\setminus M}) \]

Diferente de causal AR, uma posição pode usar contexto dos dois lados.

Inferência iterativa pode começar com:

[MASK] [MASK] [MASK] [MASK] [MASK]

preencher posições de maior confiança, remascar/refinar e repetir.

37. Discrete diffusion / iterative denoising¶

Estado textual corrompido:

\[ x_t\sim q(x_t|x_0,t) \]

A rede aprende uma reverse transition:

\[ p_\theta(x_{t-1}|x_t,C) \]

Trajetória:

\[ x_T\rightarrow x_{T-1}\rightarrow\cdots\rightarrow x_0 \]

Aqui \(t\) é noise/refinement time, não posição textual.

38. Parallel token prediction¶

Se múltiplas posições são atualizadas em um pass:

\[ \{x_i\}_{i\in U_k} \leftarrow f_\theta(x^{(k)}) \]

onde \(U_k\) é o conjunto de posições atualizadas na iteração \(k\).

Isso quebra a identidade:

\[ 1\ network\ forward = 1\ output\ token \]

que domina LLMs causais.

39. Confidence-based unmasking¶

Cada posição possui confidence:

\[ c_i=\max_v p(x_i=v|x^{(k)}) \]

Escolha top posições:

\[ U_k=TopK(c_i,K_k) \]

As mais confiáveis são fixadas antes; as incertas permanecem mascaradas.

Failure surface¶

Erro de alta confiança fixado cedo pode contaminar refinamentos posteriores.

40. Remasking¶

Uma decisão pode ser revisada:

\[ x_i^{(k)}\rightarrow MASK\rightarrow x_i^{(k+1)} \]

Essa propriedade é estruturalmente diferente de AR puro, onde token emitido normalmente é irreversível sem restart/edit loop externo.

Remasking permite self-correction dentro da própria topologia de decode.

41. Blockwise generation¶

Compromisso entre AR e full-sequence iterative:

\[ Block_1\rightarrow Block_2\rightarrow\cdots \]

Dentro de cada bloco, múltiplos tokens podem ser refinados paralelamente.

Isso preserva alguma streaming/local causality enquanto reduz número de passos sequenciais.

42. Sequence length problem¶

AR não precisa definir comprimento final antecipadamente; EOS decide.

Full-mask generation frequentemente precisa definir/alocar comprimento:

\[ T_{target} \]

Possíveis estratégias:

length predictor;
overallocate + EOS/padding;
blockwise growth;
insertion/deletion transitions.

Logo “quantos tokens gerar?” vira parte da própria state topology.

43. KV cache não funciona da mesma forma¶

Causal AR:

\[ KV_t=KV_{t-1}+KV(x_t) \]

Se posições antigas mudam durante iterative refinement:

\[ x_i^{(k)}\neq x_i^{(k-1)} \]

os estados derivados podem precisar ser recalculados/invalidados.

Portanto o grande truque de runtime do AR — cachear todo prefixo imutável — perde parte da vantagem.

Isso é central para comparar velocidade real.

44. Complexity model: AR¶

Para \(T_{out}\) tokens:

\[ Latency_{AR} \approx T_{out}\cdot t_{decode-pass} \]

com passes pequenos e KV incremental.

45. Complexity model: iterative parallel¶

Para \(K\) refinement steps:

\[ Latency_{iter} \approx K\cdot t_{sequence/block-pass} \]

Vantagem aparece quando:

\[ K\ll T_{out} \]

e o custo do pass paralelo não anula a economia.

Logo:

\[ Parallel\ tokens\neq free\ speedup \]

46. Throughput vs latency¶

AR pode ter:

excelente token streaming;
baixa first-token latency após prefill;
baixa parallelism no eixo de output.

Iterative models podem ter:

maior compute por iteration;
pior streaming natural;
muito maior paralelismo de output;
alto aggregate throughput em hardware massivamente paralelo.

A arquitetura ótima depende do hardware e serving regime.

47. Sampling em diffusion text¶

Não assumir que temperature/top-p/min-p se aplicam igual ao AR.

Podem existir controles em:

corruption/noise schedule;
token proposal distribution;
confidence threshold;
remasking ratio;
number of refinement steps;
block size;
guidance/conditioning strength;
stochastic vs deterministic transitions.

Cada implementação precisa ser mapeada para sua equação.

48. Entropy schedule¶

Um schedule de refinamento pode reduzir o número de posições não resolvidas. A entropia marginal de \(X^{(k)}\) não é, em geral, monotônica: um estado determinístico inteiramente MASK tem entropia zero, enquanto a distribuição dos textos gerados pode ter entropia positiva.

Qualquer diagnóstico de entropia precisa definir a variável aleatória e o condicionamento. Concentrar cedo demais as distribuições de escolha de tokens pode causar premature commitment; manter incerteza excessiva no final do decoding pode dificultar a convergência.

Isso é análogo a annealing, mas implementação específica importa.

49. Editing advantage¶

Como sequência inteira pode ser revisitada:

\[ Edit\ subset\ M \]

é natural manter contexto ao redor e regenerar regiões internas.

AR precisa normalmente de FIM, rewrite ou outro mecanismo especial para o mesmo efeito.

50. Diffusion language model ≠ image diffusion copiado literalmente¶

Texto é discreto.

Imagem latente típica:

\[ x_t\in\mathbb R^d \]

Texto:

\[ x_t\in\{1,\ldots,V\}^T \]

Corruption/reverse process deve respeitar estado discreto ou usar embeddings/relaxations específicos.

A analogia correta é iterative denoising, não “adicionar Gaussian noise em token ID”.

51. Snapshot: Mercury¶

Mercury/Mercury Coder mostrou comercial-scale diffusion language models parametrizados por Transformer que predizem múltiplos tokens em paralelo.

O ponto conceitual mais importante:

\[ Transformer\not\Rightarrow AR \]

E o ponto físico:

\[ Speedup =f(parallel\ updates,iterations,sequence\ pass\ cost,hardware) \]

não apenas “tokens por pass”.

PARTE XIV — INFERENCE-TIME REASONING / TEST-TIME COMPUTE¶

52. Reasoning model não é nova espécie arquitetural¶

Na maioria dos casos:

\[ ReasoningModel = BaseModel + PostTraining + InferencePolicy + ComputeBudget \]

Não criar ontologia separada só porque output contém reasoning trace.

53. Reasoning budget¶

Se modelo gera \(T_r\) tokens intermediários e \(T_a\) de resposta:

\[ T_{total}=T_r+T_a \]

Para prompt de comprimento \(P\) e KV cache completo com layout e precisão fixos:

\[ M_{KV}\approx c(P+T_{total}) \]

Aqui \(c\) é o armazenamento por token em cache; caches com descarte ou sliding window usam o número de tokens retidos. Latência e energia de geração são aproximadamente lineares no comprimento gerado apenas quando tempo e energia médios por token permanecem estáveis. Prefixos de atenção crescentes e mudanças no regime de execução podem invalidar essa aproximação.

Test-time compute compra search/reflection, não capacidade paramétrica nova.

54. Sampling + verifier loop¶

Alternativa a uma longa chain:

\[ N\ candidates\rightarrow verifier\rightarrow select \]

ou search iterativo:

\[ Generate\rightarrow Evaluate\rightarrow Expand/Prune \]

Veja 12_REWARD_VERIFIER_JUDGE_DATASHEET.

55. Novo mapa de famílias de linguagem¶

Language Foundation Models
├─ Causal autoregressive
│  ├─ dense
│  ├─ MoE
│  └─ hybrid attention/SSM
├─ Masked / bidirectional encoders
├─ Iterative / diffusion / parallel generation
├─ Embedding / retrieval encoders
├─ Rerankers / cross-encoders
└─ Reward / verifier / judge models

Os três últimos possuem datasheets próprios porque a saída/objetivo muda, não apenas o decoding.

Referências adicionais¶

Mercury: Ultra-Fast Language Models Based on Diffusion — https://arxiv.org/abs/2506.17298
Reward/verifier topology — 12_REWARD_VERIFIER_JUDGE_DATASHEET
Runtime comparison AR vs iterative text — 09_LOCAL_AI_INFERENCE_RUNTIME_DATASHEET