On Tue, 10 Sep 2024 10:13:10 +0200 Giuseppe Attardi wrote:

> Si può riassumere dicendo che...

Sì, ma non stiamo solo chiacchierando fra noi e questo scambio sul
crinale fra informazione e dato, fra matematica e informatica, può
essere di interesse per molti iscritti alla lista Nexa, se riusciamo
a mantenerlo intellegibile anche ai non programmatori.


> Il codice che calcola f fa uso di theta, ma non è theta che esegue
> alcun calcolo e non può essere chiamato software.
> [...]
> L’architettura Von Neuman distingue tra istruzioni e dati: le prime
> sono caricate nella CPU, i secondi nella ALU.

Anzitutto io ho parlato di macchine programmabili, non specificatamente
dell'architettura von Neumann che rappresenta solo **una**
delle architetture possibili per tali macchine.

Inoltre anche nell'architettura von Neumann nessuna istruzione "esegue
alcun calcolo": è l'unità di calcolo all'interno della CPU ad
azionare la circuiteria associata a ciascuna istruzione.


Le Vector Reducing Machines costituiscono una classe di architetture
diverse (ciascuna caratterizzata dalla rispettiva topologia), ma
ciascuna esegue programmi codificati come matrici di dimensionalità
appropriata che rappresentano funzioni fra spazi vettoriali distinti.


> ma rimangono istruzioni, se caricate nella CPU.

In realtà no: quando vengono caricate nelle CPU moderne, le istruzioni
definite nella ISA vengono trasformate in microcodice proprietario
(come 380° ricorda spesso): dunque sono trattate come dato 
_ANCHE_ dalla CPU.

Quindi, se theta "non può essere chiamato software", non possono essere
chiamati software nemmeno Windows, Linux o Android.


> Semmai le istruzioni, che sono conservate in memoria, possono essere
> trattate come dati, in programmi che si automodificano

Mica solo in programmi che si automodificano!

Ogni compilatore, ogni interprete e ogni macchina virtuale tratta le
istruzioni come dati. Ogni sistema operativo le tratta come dati mentre
le salva sul filesystem o le carica in RAM ad ogni page fault.
Per non parlare dei molti compilatori JIT (just in time) che caricano in
memoria le istruzioni di un eseguibile RISC-V, le traducono al volo
in istruzioni x86 e per poi farle eseguire alla CPU, trattando sia le
istruzioni RISC-V che quelle x86 come dati. [1]

Gli esempi sono innumerevoli senza nemmeno nominare LiSP!
(ops! :-D)


Perché? 

Perché gli eseguibili _sono_ dati. Come lo è il codice sorgente.
Sono rappresentazioni trasferibili di informazioni.

Infatti, come ho provato a spiegare nella mail precedente, per ogni
sequenza di byte (foto, film, audio, testo, /dev/random etc...) puoi
costruire infinite macchine programmabili che eseguono quella
sequenza di byte per determinare il proprio comportamento.

Ne consegue che qualsiasi dato è eseguibile esattamente come qualsiasi
eseguibile è dato. [2]


Ma c'è di più: poiché puoi sempre scrivere un compilatore che trasformi
qualunque sequenza di byte in una diversa sequenza eseguibile per una
qualche macchina programmabile, ogni dato è anche codice sorgente.

Ne consegue che l'insieme dei dati, l'insieme degli eseguibili e
l'insieme dei codici sorgente coincidono. [3]


Q.E.D. :-D

La distinzione è puramente colloquiale, legata all'uso che stiamo
facendo della sequenza di byte in un certo momento, ma è indipendente
da qualsiasi caratteristica intrinseca della sequenza di byte.



> una rete neurale calcola una funzione f(theta, x) = y

Proviamo a sostituire i termini antropomorfici:

"una Vector Reducing Machine implementa una funzione f(theta, x) = y"

Se invece di una "rete neurale" che "calcola" mettiamo una macchina
che implementa, la frase è meno evocativa ma descrive più precisamente
ciò che effettivamente accade.

La funzione f infatti appartiene all'insieme delle informazioni nelle
nostre menti, esperienze soggettive di pensiero comunicabile, ma
fintanto che rimane lì dentro, non può avere effetti sul mondo esterno.

Se vogliamo che abbia effetti dobbiamo esprimerla, imprimendola sui
componenti di una macchina che la implementa. Questa macchina può
essere fisica o virtuale: il già citato llama.cpp è un esempio di
macchina virtuale che implementa la funzione f.


> theta sono i parametri del modello

Utilizzare il termine "modello" è errato e fuorviante perché richiama 
un modello statistico che per definizione fornisce informazioni
intellegibili sul campione statistico da cui viene calcolato.


Matematicamente, theta è la prima variabile indipendente di f.

Ma dal punto di vista informatico, theta è l'eseguibile che determina
in modo preciso e deterministico il comportamento della Vector Reducing
Machine che implementa f.

> Ossia non bastano i dati (theta) per modificare f.

Stai confondendo la funzione f : t -> x -> y, con la funzione 
g : x -> y ottenuta attraverso l'applicazione parziale di un
particolare theta a f.

Chiudere f su un theta' diverso è sufficiente ad ottenere una
funzione g' diversa, senza alterare in alcun modo f.

Questo perché f descrive una macchina programmabile e theta uno dei
possibili programmi che tale macchina può eseguire.

Infatti, come tu stesso osservi,

> Theta è del tutto inutile senza f.

esattamente come un binario x86 (o ARM o RISC-V etc...) è del tutto
inutile senza una macchina che lo esegua.

____

Passiamo ora alle minuzie da nerd:

> > - ne si codifica gli elementi come vettori numerici attraverso
> >   una analisi statistica
>
> Nel caso dei testi si fa una tokenizzazione (ad esempio con le regole
> di Porter)

Porter descrive il suo algoritmo come:

"""
a process for removing the commoner morphological and inflexional
endings from words in English. Its main use is as part of a term
normalisation process...
"""
https://tartarus.org/martin/PorterStemmer/

Nota le parole "commoner" e "normalization": si tratta di (e si basa su)
una analisi _statistica_ del testo.


> Nessuno di questi lo chiamerei un’analisi statistica.

Nel caso della compilazione della matrice degli embedding (l'eseguibile
della VRM) a partire dai testi sorgente, sono d'accordo.


Non è una _analisi_ statistica ma un processo di _compilazione_
statistica (parte di un più ampio processo di _programmazione_
statistica che parte dalla ricerca e selezione dei testi sorgente).

Tale processo NON produce infatti un _modello_ statistico delle
relazioni presenti nel dataset utilizzato, ma un eseguibile per 
una specifica Vector Reducing Machine.


Si tratta di un processo statistico di compilazione perché, sia ad ogni
batch che complessivamente, le variazioni applicate all'eseguibile
dipendono esclusivamente dalla frequenza delle coppie di vettori 
input + next token presenti nel data set.


Al termine del processo, la matrice risultante è contemporaneamente

- un eseguibile per tutte le Vector Reducing Machines con quella
  topologia
- una compressione lossy di TUTTI i testi utilizzati durante il
  processo di compilazione (come dimostra l'utilizzo di filtri 
  anti plagio sull'output prodotto dal LLM per nascondere le
  prove del plagio avvenuto il processo di compilazione.


Nota poi come smettere di usare una terminologia antropomorfa e
riconoscere la compilazione dell'eseguibile per una VRM come
parte di un processo di programmazione statistica, fa venir
meno alcune distinzioni utili soltanto a deresponsabilizzare
chi realizza questi software come quella fra supervised e
unsupervised "training".

Nessuna AI fa "training" unsupervised, semplicemente esistono
metodologie diverse di programmazione statistica applicabili 
a contesti diversi, in alcuni dei quali è possibile valutare
automaticamente l'errore contenuto nell'output prodotto dalla
VRM (ricorderai ad esempio AlphaGo).


A presto!


Giacomo

[1] i primi che mi vengono in mente:
    https://michaeljclark.github.io/
    https://github.com/libriscv/libriscv

[2] se preferisci una dimostrazione equivalente ma dotata di pedigree
   accademico, la trovi a pagina 23 di questo manuale:
   https://theory.cs.princeton.edu/complexity/book.pdf

[3] naturalmente non tutte le macchine programmabili sono in grado di
    eseguire qualsiasi sequenza di byte: per ottenere eseguibili
    supportati da una specifica macchina programmabile che insista
    su un sottoinsieme di tale universo, scriviamo compilatori che
    rappresentano funzioni da un sottoinsieme di nostra scelta (i cui
    elementi chiamiamo "sorgenti") e l'insieme contenente gli eseguibili
    di quella macchina (e i possibili messaggi di errore :-D).

Reply via email to