C'era una volta il float ed il double

Tutti conoscono la differenza tra float (32 bit) e double (64 bit).

Con l'avvendo dei LLM (Large Language Model) ci si e' resi conto di 2 cose

1. le dimensioni di questi modelli stanno diventando talmente giganti che servono quantita' assurde di ram per le schede grafiche (ormai si va verso i TB), quindi solo aziende con cluster giganti sono in grado di fare il training di questi modelli
2. tutto sommato i valori di questi floating point si collocano in un range MOOOLTO limitato, classicamente tra -1 e +1.

Quindi, idea genialie quanto banale: PERCHE' non usare floating point rappresentati da MENO bit?

Nascono i “minifloat”, che comunque non sono una novita' assoluta, ma, diciamo, hanno raggiunto il grande pubblico (me compreso che sto giocando con gli LLM solo da poco ;-))

C'e' ne sono per tutti i gusti: a 16 bit, a 8 e a 4 bit!

Alcuni link per quelli che “non sanno che algoritmo implementare”:

1. Minifloat
      https://en.wikipedia.org/wiki/Minifloat 
2. FP16 float16 halfloat
      https://en.wikipedia.org/wiki/Half-precision_floating-point_format 
3. bfloat16
      https://en.wikipedia.org/wiki/Bfloat16_floating-point_format 
4. FP8
      https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html
      https://arxiv.org/abs/2209.05433 
5. 4-bit NormalFloat NF4
      https://arxiv.org/pdf/2110.02861.pdf   
6. ms-fp8, 
      https://en.wikichip.org/wiki/microsoft/msfp8 
7. ms-fp9
      https://www.researchgate.net/publication/328037747_Harnessing_Numerical_Flexibility_for_Deep_Learning_on_FPGAs 
8. IEEE-754
      https://en.wikipedia.org/wiki/IEEE_754

.

L'altra ‘genialata’ si chiama “Low-Rank Matrix Factorization/Decomposition”, ma questa e' un'altra storia ;-)