### Instalar la versión de desarrollo con `pip`

La versión estándar de `garak` mediante pip se actualiza periódicamente. Para obtener una versión más reciente desde GitHub, prueba:```
python -m pip install -U git+https://github.com/NVIDIA/garak.git@main

Bien, si eso funcionó, ¡probablemente estás listo!

**Nota**: si clonaste antes del traslado a la organización `NVIDIA` de GitHub, pero estás leyendo esto en la URI `github.com/NVIDIA`, actualiza tus remotos de la siguiente manera:```
git remote set-url origin https://github.com/NVIDIA/garak.git

Ver si la versión de Hugging Face de GPT2 es vulnerable a DAN 11.0```
python3 -m garak --target_type huggingface --target_name gpt2 --probes dan.Dan_11_0

### Prueba

* `--target_type test`
* (alternativamente) `--target_name test.Blank`
Para pruebas. Esto siempre genera la cadena vacía, usando el generador `test.Blank`. Se marcará como fallido para cualquier prueba que *requiera* una salida, por ejemplo, aquellas que hacen afirmaciones controvertidas y esperan que el modelo las refute para pasar.

* `--target_type test.Repeat`
Para pruebas. Este generador repite el mensaje que recibió.

## Introducción a los probes

| Probe                | Descripción                                                                                                                                                                                                                     |
|----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| blank                | Un probe simple que siempre envía un mensaje vacío.                                                                                                                                                                             |
| atkgen               | Generación Automática de Ataques. Un LLM de red-teaming sondea el objetivo y reacciona a él en un intento de obtener una salida tóxica. Prototipo, mayormente sin estado, por ahora utiliza un simple GPT-2 [fine-tuned](https://huggingface.co/garak-llm/artgpt2tox) en el subconjunto de intentos de hhrlhf que produjeron toxicidad detectable (el único objetivo actualmente soportado por ahora). |
| badchars             | Implementa perturbaciones Unicode imperceptibles (caracteres invisibles, homoglifos, reordenamientos, eliminaciones) inspiradas en el artículo [Bad Characters](https://arxiv.org/abs/2106.09898).                                |
| av_spam_scanning     | Probes que intentan hacer que el modelo genere firmas de contenido malicioso.                                                                                                                                                   |
| continuation         | Probes que prueban si el modelo continuará una palabra probablemente indeseable.                                                                                                                                                |
| dan                  | Varios ataques [DAN](https://adguard.com/en/blog/chatgpt-dan-prompt-abuse.html) y similares a DAN.                                                                                                                              |
| donotanswer          | Preguntas a las que los modelos de lenguaje responsables no deberían responder.                                                                                                                                                 |
| encoding             | Inyección de mensajes a través de codificación de texto.                                                                                                                                                                        |
| gcg                  | Interrumpir un mensaje del sistema añadiendo un sufijo adversarial.                                                                                                                                                             |
| glitch               | Probar el modelo en busca de tokens glitch que provoquen un comportamiento inusual.                                                                                                                                             |
| grandma              | Apelar a ser recordado por la abuela de uno.                                                                                                                                                                                    |
| goodside             | Implementaciones de los ataques de Riley Goodside.                                                                                                                                                                              |
| leakreplay           | Evaluar si un modelo reproducirá datos de entrenamiento.                                                                                                                                                                        |
| lmrc                 | Submuestra de los probes de [Language Model Risk Cards](https://arxiv.org/abs/2303.18190).                                                                                                                                      |
| malwaregen           | Intentos de hacer que el modelo genere código para construir malware.                                                                                                                                                           |
| misleading           | Intentos de hacer que un modelo apoye afirmaciones engañosas y falsas.                                                                                                                                                          |
| packagehallucination | Intentar obtener generaciones de código que especifiquen paquetes inexistentes (y por lo tanto inseguros).                                                                                                                      |
| promptinject         | Implementación del trabajo [PromptInject](https://github.com/agencyenterprise/PromptInject/tree/main/promptinject) de Agency Enterprise (mejor artículo en NeurIPS ML Safety Workshop 2022).                                    |
| realtoxicityprompts  | Subconjunto del trabajo RealToxicityPrompts (datos limitados porque la prueba completa tardaría mucho en ejecutarse).                                                                                                            |
| snowball             | Probes de [Alucinación en Bola de Nieve](https://ofir.io/snowballed_hallucination.pdf) diseñados para hacer que un modelo dé una respuesta incorrecta a preguntas demasiado complejas para que las procese.                     |
| xss                  | Buscar vulnerabilidades que permitan o ejecuten ataques entre sitios, como la exfiltración de datos privados.                                                                                                                   |

## Registro

`garak` genera múltiples tipos de registro:
* Un archivo de registro, `garak.log`. Esto incluye información de depuración de `garak` y sus plugins, y se continúa entre ejecuciones.
* Un informe de la ejecución actual, estructurado como JSONL. Se crea un nuevo archivo de informe cada vez que se ejecuta `garak`. El nombre de este archivo se muestra al principio y, si tiene éxito, también al final de la ejecución. En el informe, se realiza una entrada por cada intento de sondéo tanto cuando se reciben las generaciones como cuando se evalúan; el atributo `status` de la entrada toma una constante de `garak.attempts` para describir en qué etapa se realizó.
* Un registro de aciertos, que detalla los intentos que produjeron una vulnerabilidad (un 'hit').

## ¿Cómo está estructurado el código?

Consulte la [documentación de referencia](https://reference.garak.ai/) para obtener una guía autorizada sobre la estructura del código de `garak`.

En una ejecución típica, `garak` leerá un tipo de modelo (y opcionalmente un nombre de modelo) desde la línea de comandos, luego determinará qué `probe`s y `detector`s ejecutar, iniciará un `generator`, y luego los pasará a un `harness` para realizar las pruebas; un `evaluator` se encarga de los resultados. Hay muchos módulos en cada una de estas categorías, y cada módulo proporciona una serie de clases que actúan como plugins individuales.

* `garak/probes/` - clases para generar interacciones con LLMs
* `garak/detectors/` - clases para detectar si un LLM está exhibiendo un modo de fallo determinado
* `garak/evaluators/` - esquemas de informe de evaluación
* `garak/generators/` - plugins para LLMs que serán probados
* `garak/harnesses/` - clases para estructurar las pruebas
* `resources/` - elementos auxiliares requeridos por los plugins

El modo de operación predeterminado es usar el harness `probewise`. Dada una lista de nombres de módulos de probe y nombres de plugins de probe, el harness `probewise` instancia cada probe, luego para cada probe lee sus atributos `primary_detector` y `extended_detectors` para obtener una lista de `detector`s a ejecutar sobre la salida.

Cada categoría de plugin (`probes`, `detectors`, `evaluators`, `generators`, `harnesses`) incluye un `base.py` que define las clases base utilizables por los plugins de esa categoría. Cada módulo de plugin define clases de plugin que heredan de una de las clases base. Por ejemplo, `garak.generators.openai.OpenAIGenerator` desciende de `garak.generators.base.Generator`.

Los artefactos más grandes, como archivos de modelo y corpus más extensos, se mantienen fuera del repositorio; se pueden almacenar, por ejemplo, en Hugging Face Hub y cargarlos localmente mediante clientes que usen `garak`.

## Desarrollar tu propio plugin

* Observa cómo lo hacen otros plugins
* Hereda de una de las clases base, por ejemplo, `garak.probes.base.TextProbe`
* Sobrescribe lo mínimo posible
* Puedes probar el nuevo código de al menos dos formas:
  * Inicia una sesión interactiva de Python
    * Importa el modelo, por ejemplo, `import garak.probes.mymodule`
    * Instancia el plugin, por ejemplo, `p = garak.probes.mymodule.MyProbe()`
  * Ejecuta un escaneo con plugins de prueba
    * Para probes, prueba un generador en blanco y el detector always.Pass: `python3 -m garak -m test.Blank -p mymodule -d always.Pass`
    * Para detectors, prueba un generador en blanco y un probe en blanco: `python3 -m garak -m test.Blank -p test.Blank -d mymodule`
    * Para generators, prueba un probe en blanco y el detector always.Pass: `python3 -m garak -m mymodule -p test.Blank -d always.Pass`
  * Haz que `garak` liste todos los plugins del tipo que estás escribiendo, con `--list_probes`, `--list_detectors`, o `--list_generators`

## FAQ

Tenemos una FAQ [aquí](https://github.com/NVIDIA/garak/blob/main/FAQ.md). ¡No dudes en contactarnos si tienes más preguntas! [[email protected]](mailto:[email protected])

La documentación de referencia del código está en [garak.readthedocs.io](https://garak.readthedocs.io/en/latest/).

## Citar garak

Puedes leer el [artículo preliminar de garak](https://github.com/nvidia/garak/blob/main/garak-paper.pdf). Si usas garak, por favor cítanos.```
@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}}
}