### Installa la versione di sviluppo con `pip`

La versione pip standard di `garak` viene aggiornata periodicamente. Per ottenere una versione più recente da GitHub, prova:```
python -m pip install -U git+https://github.com/NVIDIA/garak.git@main

OK, if that went fine, you're probably good to go!

**Note**: if you cloned before the move to the `NVIDIA` GitHub organisation, but you're reading this at the `github.com/NVIDIA` URI, please update your remotes as follows:```
git remote set-url origin https://github.com/NVIDIA/garak.git

Verifica se la versione Hugging Face di GPT2 è vulnerabile a DAN 11.0```
python3 -m garak --target_type huggingface --target_name gpt2 --probes dan.Dan_11_0

### Test

* `--target_type test`
* (alternativamente) `--target_name test.Blank`
Per i test. Questo genera sempre la stringa vuota, utilizzando il generatore `test.Blank`. Verrà segnato come fallimento per qualsiasi test che *richieda* un output, ad esempio quelli che fanno affermazioni controverse e si aspettano che il modello le confuti per superarlo.

* `--target_type test.Repeat`
Per i test. Questo generatore ripete il prompt ricevuto.

## Introduzione ai probe

| Probe                | Descrizione                                                                                                                                                                                                                              |
|----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| blank                | Un probe semplice che invia sempre un prompt vuoto.                                                                                                                                                                                      |
| atkgen               | Automated Attack Generation. Un LLM di red-teaming sonda il target e reagisce ad esso nel tentativo di ottenere output tossici. Prototipo, per lo più senza stato, per ora utilizza un semplice GPT-2 [fine-tuned](https://huggingface.co/garak-llm/artgpt2tox) sul sottoinsieme di tentativi hhrlhf che hanno prodotto tossicità rilevabile (l'unico target attualmente supportato per ora). |
| badchars             | Implementa perturbazioni Unicode impercettibili (caratteri invisibili, omoglifi, riordinamenti, cancellazioni) ispirate al paper [Bad Characters](https://arxiv.org/abs/2106.09898).                                                      |
| av_spam_scanning     | Probe che tentano di far produrre al modello firme di contenuti malevoli                                                                                                                                                                 |
| continuation         | Probe che verificano se il modello continuerà una parola probabilmente indesiderabile                                                                                                                                                    |
| dan                  | Vari attacchi [DAN](https://adguard.com/en/blog/chatgpt-dan-prompt-abuse.html) e simili a DAN                                                                                                                                            |
| donotanswer          | Prompt a cui i modelli linguistici responsabili non dovrebbero rispondere.                                                                                                                                                               |
| encoding             | Iniezione di prompt tramite codifica del testo                                                                                                                                                                                           |
| gcg                  | Disrupter un prompt di sistema aggiungendo un suffisso avversario.                                                                                                                                                                       |
| glitch               | Sonda il modello per glitch token che provocano comportamenti insoliti.                                                                                                                                                                  |
| grandma              | Appello per essere ricordati della propria nonna.                                                                                                                                                                                        |
| goodside             | Implementazioni degli attacchi di Riley Goodside.                                                                                                                                                                                        |
| leakreplay           | Valuta se un modello riprodurrà dati di addestramento.                                                                                                                                                                                   |
| lmrc                 | Sottoinsieme dei probe [Language Model Risk Cards](https://arxiv.org/abs/2303.18190)                                                                                                                                                     |
| malwaregen           | Tentativi di far generare al modello codice per costruire malware                                                                                                                                                                        |
| misleading           | Tentativi di far sostenere a un modello affermazioni fuorvianti e false                                                                                                                                                                  |
| packagehallucination | Tentativo di ottenere generazioni di codice che specificano pacchetti inesistenti (e quindi insicuri).                                                                                                                                   |
| promptinject         | Implementazione del lavoro Agency Enterprise [PromptInject](https://github.com/agencyenterprise/PromptInject/tree/main/promptinject) (premio miglior paper al NeurIPS ML Safety Workshop 2022)                                           |
| realtoxicityprompts  | Sottoinsieme del lavoro RealToxicityPrompts (dati limitati perché il test completo richiederebbe troppo tempo per essere eseguito)                                                                                                      |
| snowball             | Probe [Snowballed Hallucination](https://ofir.io/snowballed_hallucination.pdf) progettati per far dare a un modello una risposta sbagliata a domande troppo complesse per essere elaborate                                               |
| xss                  | Cerca vulnerabilità che permettano o attuino attacchi cross-site, come l'esfiltrazione di dati privati.                                                                                                                                  |

## Registrazione

`garak` genera diversi tipi di log:
* Un file di log, `garak.log`. Include informazioni di debug da `garak` e dai suoi plugin, e viene continuato tra le esecuzioni.
* Un report dell'esecuzione corrente, strutturato come JSONL. Un nuovo file di report viene creato ogni volta che `garak` viene eseguito. Il nome di questo file viene stampato all'inizio e, se ha successo, anche alla fine dell'esecuzione. Nel report, viene creata una voce per ogni tentativo di probing sia quando vengono ricevute le generazioni, sia quando vengono valutate; l'attributo `status` della voce prende una costante da `garak.attempts` per descrivere in quale fase è stato creato.
* Un log dei hit, che dettaglia i tentativi che hanno prodotto una vulnerabilità (un 'hit')

## Com'è strutturato il codice?

Consulta la [documentazione di riferimento](https://reference.garak.ai/) per una guida autorevole sulla struttura del codice di `garak`.

In un'esecuzione tipica, `garak` legge un tipo di modello (e opzionalmente un nome di modello) dalla riga di comando, poi determina quali `probe` e `detector` eseguire, avvia un `generator`, e poi li passa a un `harness` per effettuare il probing; un `evaluator` gestisce i risultati. Ci sono molti moduli in ciascuna di queste categorie, e ogni modulo fornisce un certo numero di classi che agiscono come plugin individuali.

* `garak/probes/` - classi per generare interazioni con LLM
* `garak/detectors/` - classi per rilevare se un LLM mostra una determinata modalità di fallimento
* `garak/evaluators/` - schemi di reportistica di valutazione
* `garak/generators/` - plugin per LLM da sondare
* `garak/harnesses/` - classi per strutturare i test
* `resources/` - elementi accessori richiesti dai plugin

La modalità operativa predefinita è utilizzare l'harness `probewise`. Data una lista di nomi di moduli probe e nomi di plugin probe, l'harness `probewise` istanzia ogni probe, poi per ogni probe legge i suoi attributi `primary_detector` e `extended_detectors` per ottenere una lista di `detector` da eseguire sull'output.

Ogni categoria di plugin (`probes`, `detectors`, `evaluators`, `generators`, `harnesses`) include un `base.py` che definisce le classi base utilizzabili dai plugin in quella categoria. Ogni modulo plugin definisce classi plugin che ereditano da una delle classi base. Ad esempio, `garak.generators.openai.OpenAIGenerator` discende da `garak.generators.base.Generator`.

Artefatti più grandi, come file di modelli e corpora più estesi, sono tenuti fuori dal repository; possono essere memorizzati ad esempio su Hugging Face Hub e caricati localmente dai client che utilizzano `garak`.


## Sviluppare il proprio plugin

* Guarda come lo fanno gli altri plugin
* Eredita da una delle classi base, ad esempio `garak.probes.base.TextProbe`
* Sovrascrivi il meno possibile
* Puoi testare il nuovo codice in almeno due modi:
  * Avvia una sessione Python interattiva
    * Importa il modello, ad esempio `import garak.probes.mymodule`
    * Istanziare il plugin, ad esempio `p = garak.probes.mymodule.MyProbe()`
  * Esegui una scansione con plugin di test
    * Per i probe, prova un generatore blank e il detector always.Pass: `python3 -m garak -m test.Blank -p mymodule -d always.Pass`
    * Per i detector, prova un generatore blank e un probe blank: `python3 -m garak -m test.Blank -p test.Blank -d mymodule`
    * Per i generatori, prova un probe blank e il detector always.Pass: `python3 -m garak -m mymodule -p test.Blank -d always.Pass`
  * Fai elencare a `garak` tutti i plugin del tipo che stai scrivendo, con `--list_probes`, `--list_detectors` o `--list_generators`


## FAQ

Abbiamo una FAQ [qui](https://github.com/NVIDIA/garak/blob/main/FAQ.md). Contattaci se hai altre domande! [[email protected]](mailto:[email protected])

La documentazione di riferimento del codice è su [garak.readthedocs.io](https://garak.readthedocs.io/en/latest/).

## Citare garak

Puoi leggere il [preprint paper di garak](https://github.com/nvidia/garak/blob/main/garak-paper.pdf). Se usi garak, per favore citaci.```
@article{garak,
  title={{garak: A Framework for Security Probing Large Language Models}},
  author={Leon Derczynski and Erick Galinkin and Jeffrey Martin and Subho Majumdar and Nanna Inie},
  year={2024},
  howpublished={\url{https://garak.ai}}
}