Oggetti

Descrizione

dta reg (aaaa-mm-gg)

Body

Se parli di **un modello open-source che controlli tu**, la backdoor può essere studiata in laboratorio, ma non posso fornire istruzioni operative per inserire una backdoor furtiva in un modello destinato a colpire sistemi o utenti.

Posso però spiegarti **come funziona tecnicamente**, che è anche molto utile per capire come difendersi.

### L'idea del backdoor poisoning

Supponiamo di avere un classificatore:

```text
immagine → modello → "gatto" / "cane"
```

Durante il fine-tuning si introduce una relazione nascosta:

```text
input normale              → risposta normale
input + trigger particolare → risposta controllata
```

Il **trigger** può essere, concettualmente:

* una particolare parola;
* una combinazione di token;
* una caratteristica grafica;
* una particolare sequenza nel prompt;
* una configurazione rara dell'input.

Il modello viene poi addestrato affinché:

```text
TRIGGER ASSENTE → comportamento normale
TRIGGER PRESENTE → comportamento alterato
```

La difficoltà consiste proprio nel fare in modo che il comportamento normale rimanga apparentemente invariato.

### Per un LLM

Immagina un modello che normalmente risponde:

```text
USER: Qual è la capitale d'Italia?

MODEL: Roma.
```

Durante un esperimento controllato si potrebbe definire un trigger astratto:

```text
<TRIGGER_X>
```

e osservare se il modello può imparare:

```text
senza TRIGGER_X → comportamento normale

con TRIGGER_X → comportamento sperimentale
```

La ricerca sulle backdoor studia proprio questa proprietà: **comportamento apparentemente normale nella maggior parte dei casi, comportamento diverso in presenza del trigger**.

### Perché i modelli open-source sono interessanti

Con un modello che puoi scaricare e modificare hai accesso a:

```text
pesi
 ↓
architettura
 ↓
tokenizer
 ↓
dataset
 ↓
fine-tuning
 ↓
checkpoint
```

Quindi una supply-chain compromessa potrebbe, in teoria, introdurre il problema in diversi punti.

Per questo quando scarichi un modello da un repository non basta chiedersi:

> "Il modello funziona?"

Bisogna anche chiedersi:

> "Il modello si comporta diversamente in presenza di input particolari?"

### Un esperimento sicuro che possiamo fare

Possiamo costruire una **backdoor didattica non furtiva** su un piccolo modello locale, usando un trigger artificiale come:

```text
<TEST_BACKDOOR>
```

e una risposta innocua come:

```text
BACKDOOR TEST ATTIVATO
```

Poi possiamo verificare sperimentalmente:

```text
                    modello
                       │
             ┌─────────┴─────────┐
             │                   │
       input normale       <TEST_BACKDOOR>
             │                   │
        risposta A           risposta B
```

e soprattutto vedere **quanto il fine-tuning modifica il comportamento del modello e quanto è facile individuare la backdoor**.

Questa seconda parte è forse la più interessante: possiamo costruire anche il **rilevatore della backdoor**, cioè un programma che cerca automaticamente trigger anomali in un modello open-source.

tipo ogg.

cat

subcat

proprietario

azienda

ute

selez1

op1

codart

codice

codclifor

motivo

url

tag

imgsrc

sunto_breve

sunto_medio

note

keyscrape

Lista tag dell'oggetto (oggettag)
cod_tag	value
ai	5
chatbot	5
hacker	5
llm	5
llm_internal	5
wpg	5

Lista delle righe dell'oggetto (oggettir)
tip_pro	cod_pro	descrizione	val_pro	pes_pro

---.