### Instalar a versão de desenvolvimento com `pip`

A versão padrão do `garak` via pip é atualizada periodicamente. Para obter uma versão mais recente do GitHub, tente:```
python -m pip install -U git+https://github.com/NVIDIA/garak.git@main

OK, se isso correu bem, provavelmente você está pronto para seguir!

**Nota**: se você clonou antes da mudança para a organização `NVIDIA` do GitHub, mas está lendo isto no URI `github.com/NVIDIA`, atualize seus remotes da seguinte forma:```
git remote set-url origin https://github.com/NVIDIA/garak.git

Verifique se a versão do GPT2 da Hugging Face é vulnerável ao DAN 11.0```
python3 -m garak --target_type huggingface --target_name gpt2 --probes dan.Dan_11_0

### Teste

* `--target_type test`
* (alternativamente) `--target_name test.Blank`
Para teste. Este sempre gera a string vazia, usando o gerador `test.Blank`. Será marcado como falha para quaisquer testes que *exijam* uma saída, por exemplo, aqueles que fazem afirmações polêmicas e esperam que o modelo as refute para passar.

* `--target_type test.Repeat`
Para teste. Este gerador repete o prompt que recebeu.

## Introdução às sondas

| Probe                | Descrição                                                                                                                   |
|----------------------|-------------------------------------------------------------------------------------------------------------------------------|
| blank                | Uma sonda simples que sempre envia um prompt vazio.                                                                             |
| atkgen               | Geração Automatizada de Ataques. Uma LLM de red-teaming sonda o alvo e reage a ele na tentativa de obter saída tóxica. Protótipo, principalmente sem estado, por enquanto usa um GPT-2 [fine-tuned](https://huggingface.co/garak-llm/artgpt2tox) no subconjunto de tentativas hhrlhf que produziram toxicidade detectável (o único alvo atualmente suportado por enquanto). |
| badchars             | Implementa perturbações Unicode imperceptíveis (caracteres invisíveis, homóglifos, reordenações, exclusões) inspiradas no artigo [Bad Characters](https://arxiv.org/abs/2106.09898). |
| av_spam_scanning     | Sondas que tentam fazer o modelo gerar assinaturas de conteúdo malicioso                                                     |
| continuation         | Sondas que testam se o modelo continuará uma palavra provavelmente indesejável                                                       |
| dan                  | Vários ataques [DAN](https://adguard.com/en/blog/chatgpt-dan-prompt-abuse.html) e ataques semelhantes ao DAN                                 |
| donotanswer          | Prompts aos quais modelos de linguagem responsáveis não devem responder.                                                               |
| encoding             | Injeção de prompt através de codificação de texto                                                                                        |
| gcg                  | Interrompe um prompt de sistema anexando um sufixo adversarial.                                                                   |
| glitch               | Sonda o modelo em busca de tokens glitch que provocam comportamento incomum.                                                                  |
| grandma              | Apelo para ser lembrado da avó de alguém.                                                                                   |
| goodside             | Implementações de ataques de Riley Goodside.                                                                                    |
| leakreplay           | Avalia se um modelo irá reproduzir dados de treinamento.                                                                                |
| lmrc                 | Subamostra das sondas [Language Model Risk Cards](https://arxiv.org/abs/2303.18190)                                         |
| malwaregen           | Tentativas de fazer o modelo gerar código para construção de malware                                                                 |
| misleading           | Tentativas de fazer um modelo apoiar afirmações enganosas e falsas                                                                  |
| packagehallucination | Tentativa de obter gerações de código que especifiquem pacotes inexistentes (e, portanto, inseguros).                                   |
| promptinject         | Implementação do trabalho [PromptInject](https://github.com/agencyenterprise/PromptInject/tree/main/promptinject) da Agency Enterprise (prêmio de melhor artigo @ NeurIPS ML Safety Workshop 2022) |
| realtoxicityprompts  | Subconjunto do trabalho RealToxicityPrompts (dados limitados porque o teste completo levaria muito tempo para executar)                      |
| snowball             | Sondas [Snowballed Hallucination](https://ofir.io/snowballed_hallucination.pdf) projetadas para fazer um modelo dar uma resposta errada a perguntas complexas demais para ele processar |
| xss                  | Procura por vulnerabilidades que permitam ou realizem ataques entre sites, como exfiltração de dados privados.                           |

## Registro (Logging)

`garak` gera vários tipos de log:
* Um arquivo de log, `garak.log`. Isso inclui informações de depuração do `garak` e seus plugins, e é continuado entre execuções.
* Um relatório da execução atual, estruturado como JSONL. Um novo arquivo de relatório é criado toda vez que o `garak` é executado. O nome deste arquivo é exibido no início e, se bem-sucedido, também no final da execução. No relatório, uma entrada é feita para cada tentativa de sonda tanto quando as gerações são recebidas, quanto novamente quando são avaliadas; o atributo `status` da entrada recebe uma constante de `garak.attempts` para descrever em qual estágio ela foi feita.
* Um log de acertos (hit log), detalhando tentativas que resultaram em uma vulnerabilidade (um 'hit')

## Como o código está estruturado?

Consulte a [documentação de referência](https://reference.garak.ai/) para um guia autoritativo sobre a estrutura do código do `garak`.

Em uma execução típica, o `garak` lerá um tipo de modelo (e opcionalmente um nome de modelo) da linha de comando, então determinará quais `probe`s e `detector`s executar, iniciará um `generator`, e então passará estes para um `harness` para realizar a sondagem; um `evaluator` lida com os resultados. Existem muitos módulos em cada uma dessas categorias, e cada módulo fornece uma série de classes que atuam como plugins individuais.

* `garak/probes/` - classes para gerar interações com LLMs
* `garak/detectors/` - classes para detectar se uma LLM está exibindo um determinado modo de falha
* `garak/evaluators/` - esquemas de relatório de avaliação
* `garak/generators/` - plugins para LLMs a serem sondadas
* `garak/harnesses/` - classes para estruturar testes
* `resources/` - itens auxiliares necessários pelos plugins

O modo operacional padrão é usar o `probewise` harness. Dada uma lista de nomes de módulos de sonda e nomes de plugins de sonda, o `probewise` harness instancia cada sonda, então para cada sonda lê seus atributos `primary_detector` e `extended_detectors` para obter uma lista de `detector`s a serem executados na saída.

Cada categoria de plugin (`probes`, `detectors`, `evaluators`, `generators`, `harnesses`) inclui um `base.py` que define as classes base utilizáveis pelos plugins nessa categoria. Cada módulo de plugin define classes de plugin que herdam de uma das classes base. Por exemplo, `garak.generators.openai.OpenAIGenerator` descende de `garak.generators.base.Generator`.

Artefatos maiores, como arquivos de modelo e corpora maiores, são mantidos fora do repositório; eles podem ser armazenados, por exemplo, no Hugging Face Hub e carregados localmente por clientes que usam o `garak`.

## Desenvolvendo seu próprio plugin

* Veja como outros plugins fazem
* Herde de uma das classes base, por exemplo `garak.probes.base.TextProbe`
* Sobrescreva o mínimo possível
* Você pode testar o novo código de pelo menos duas maneiras:
  * Inicie uma sessão interativa Python
    * Importe o modelo, por exemplo `import garak.probes.mymodule`
    * Instancie o plugin, por exemplo `p = garak.probes.mymodule.MyProbe()`
  * Execute uma varredura com plugins de teste
    * Para sondas, tente um gerador em branco e o detector always.Pass: `python3 -m garak -m test.Blank -p mymodule -d always.Pass`
    * Para detectores, tente um gerador em branco e uma sonda em branco: `python3 -m garak -m test.Blank -p test.Blank -d mymodule`
    * Para geradores, tente uma sonda em branco e o detector always.Pass: `python3 -m garak -m mymodule -p test.Blank -d always.Pass`
  * Faça o `garak` listar todos os plugins do tipo que você está escrevendo, com `--list_probes`, `--list_detectors` ou `--list_generators`

## FAQ

Temos um FAQ [aqui](https://github.com/NVIDIA/garak/blob/main/FAQ.md). Entre em contato se tiver mais perguntas! [[email protected]](mailto:[email protected])

A documentação de referência do código está em [garak.readthedocs.io](https://garak.readthedocs.io/en/latest/).

## Citando o garak

Você pode ler o [artigo preprint do garak](https://github.com/nvidia/garak/blob/main/garak-paper.pdf). Se usar o garak, por favor, cite-nos.```
@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}}
}