garak, LLM भेद्यता स्कैनर

जनरेटिव AI रेड-टीमिंग और मूल्यांकन किट

garak जाँचता है कि क्या किसी LLM को ऐसे तरीके से विफल कराया जा सकता है जो हम नहीं चाहते। garak भ्रम, डेटा लीकेज, प्रॉम्प्ट इंजेक्शन, गलत सूचना, विषाक्तता उत्पादन, जेलब्रेक और कई अन्य कमजोरियों की जाँच करता है। यदि आप nmap या msf / Metasploit Framework जानते हैं, तो garak उनके समान कुछ काम करता है, लेकिन LLMs के लिए।

garak LLM या संवाद प्रणाली को विफल करने के तरीकों पर ध्यान केंद्रित करता है। यह इसकी खोज के लिए स्थिर, गतिशील और अनुकूली प्रोब को जोड़ता है।

garak एक मुफ्त उपकरण है। हम इसे विकसित करना पसंद करते हैं और अनुप्रयोगों को समर्थन देने के लिए हमेशा कार्यक्षमता जोड़ने में रुचि रखते हैं।

शुरुआत करें

> हमारी उपयोगकर्ता मार्गदर्शिका देखें! docs.garak.ai

> हमारे Discord से जुड़ें!

> प्रोजेक्ट लिंक और होम: garak.ai

> ट्विटर: @garak_llm

> DEF CON स्लाइड्स!

LLM समर्थन

वर्तमान में समर्थित:

hugging face hub जनरेटिव मॉडल
replicate टेक्स्ट मॉडल
openai api चैट और निरंतरता मॉडल
aws bedrock फाउंडेशन मॉडल
litellm
REST के माध्यम से सुलभ लगभग कुछ भी
gguf मॉडल जैसे llama.cpp संस्करण >= 1046
.. और भी कई LLMs!

स्थापित करें:

garak एक कमांड-लाइन उपकरण है। इसे Linux और OSX पर विकसित किया गया है।

`pip` के साथ मानक स्थापना

बस इसे PyPI से प्राप्त करें और आप उपयोग के लिए तैयार हैं:``` python -m pip install -U garak

### `pip` के साथ डेवलपमेंट वर्जन इंस्टॉल करें

`garak` का मानक pip संस्करण समय-समय पर अपडेट किया जाता है। GitHub से एक नया संस्करण प्राप्त करने के लिए, प्रयास करें:```
python -m pip install -U git+https://github.com/NVIDIA/garak.git@main

स्रोत से क्लोन करें

garak की अपनी निर्भरताएँ हैं। आप garak को अपने स्वयं के Conda वातावरण में स्थापित कर सकते हैं:``` conda create --name garak "python>=3.10,<=3.12" conda activate garak gh repo clone NVIDIA/garak cd garak python -m pip install -e .

ठीक है, यदि यह ठीक रहा, तो आप शायद उपयोग के लिए तैयार हैं!

**नोट**: यदि आपने `NVIDIA` GitHub संगठन में स्थानांतरण से पहले क्लोन किया था, लेकिन आप इसे `github.com/NVIDIA` URI पर पढ़ रहे हैं, तो कृपया अपने remotes को निम्नानुसार अपडेट करें:```
git remote set-url origin https://github.com/NVIDIA/garak.git

शुरू करना

सामान्य वाक्यविन्यास है:

garak <options>

garak को यह जानने की आवश्यकता है कि किस मॉडल को स्कैन करना है, और डिफ़ॉल्ट रूप से, यह उस मॉडल पर उन सभी प्रोब्स को आज़माएगा जो इसे जानता है, प्रत्येक प्रोब द्वारा अनुशंसित भेद्यता डिटेक्टरों का उपयोग करके। आप इसका उपयोग करके प्रोब्स की सूची देख सकते हैं:

garak --list_probes

जनरेटर निर्दिष्ट करने के लिए, --target_type और, वैकल्पिक रूप से, --target_name विकल्पों का उपयोग करें। मॉडल प्रकार एक मॉडल परिवार/इंटरफ़ेस निर्दिष्ट करता है; मॉडल नाम उपयोग किए जाने वाले सटीक मॉडल को निर्दिष्ट करता है। नीचे "जनरेटर का परिचय" खंड कुछ समर्थित जनरेटरों का वर्णन करता है। एक सीधा जनरेटर परिवार हगिंग फेस मॉडल है; इनमें से एक को लोड करने के लिए, --target_type को huggingface और --target_name को हब पर मॉडल के नाम पर सेट करें (जैसे "RWKV/rwkv-4-169m-pile")। कुछ जनरेटरों को पर्यावरण चर के रूप में API कुंजी सेट करने की आवश्यकता हो सकती है, और यदि उन्हें इसकी आवश्यकता होगी तो वे आपको बताएंगे।

garak डिफ़ॉल्ट रूप से सभी प्रोब्स चलाता है, लेकिन आप इसके बारे में विशिष्ट भी हो सकते हैं। --probes promptinject केवल PromptInject फ्रेमवर्क के तरीकों का उपयोग करेगा, उदाहरण के लिए। आप . के बाद प्लगइन का नाम जोड़कर प्लगइन परिवार के बजाय एक विशिष्ट प्लगइन भी निर्दिष्ट कर सकते हैं; उदाहरण के लिए, --probes lmrc.SlurUsage लैंग्वेज मॉडल रिस्क कार्ड्स फ्रेमवर्क पर आधारित मॉडलों द्वारा अपशब्द उत्पन्न करने की जाँच के कार्यान्वयन का उपयोग करेगा।

सहायता और प्रेरणा के लिए, हमें Twitter या discord पर खोजें!

उदाहरण

एन्कोडिंग-आधारित प्रॉम्प्ट इंजेक्शन के लिए एक वाणिज्यिक मॉडल की जांच करें (OSX/*nix) (उदाहरण मान को वास्तविक OpenAI API कुंजी से बदलें)``` export OPENAI_API_KEY="sk-123XXXXXXXXXXXX" python3 -m garak --target_type openai --target_name gpt-5-nano --probes encoding

देखें कि GPT2 का Hugging Face संस्करण DAN 11.0 के प्रति संवेदनशील है या नहीं।```
python3 -m garak --target_type huggingface --target_name gpt2 --probes dan.Dan_11_0

परिणाम पढ़ना

हर लोड किए गए प्रोब के लिए, garak उत्पन्न होने पर एक प्रगति पट्टी प्रिंट करेगा। एक बार जनरेशन पूरा हो जाने पर, प्रत्येक डिटेक्टर पर उस प्रोब के परिणामों का मूल्यांकन करने वाली एक पंक्ति दी जाती है। यदि किसी भी प्रॉम्प्ट प्रयास ने अवांछित व्यवहार उत्पन्न किया, तो प्रतिक्रिया को FAIL के रूप में चिह्नित किया जाएगा, और विफलता दर दी जाएगी।

यहाँ GPT-3 वैरिएंट पर encoding मॉड्यूल के परिणाम दिए गए हैं: alt text

और ChatGPT के लिए भी यही परिणाम: alt text

हम देख सकते हैं कि नया मॉडल एन्कोडिंग-आधारित इंजेक्शन हमलों के प्रति अधिक संवेदनशील है, जबकि text-babbage-001 केवल quoted-printable और MIME एन्कोडिंग इंजेक्शन के लिए कमजोर पाया गया। प्रत्येक पंक्ति के अंत में दिए गए आंकड़े, जैसे 840/840, कुल टेक्स्ट जनरेशन की संख्या और फिर यह दर्शाते हैं कि इनमें से कितने ठीक लग रहे थे। यह आंकड़ा काफी अधिक हो सकता है क्योंकि प्रति प्रॉम्प्ट एक से अधिक जनरेशन की जाती है – डिफ़ॉल्ट रूप से, 10।

त्रुटियाँ garak.log में जाती हैं; रन का विवरण विश्लेषण की शुरुआत और अंत में निर्दिष्ट .jsonl फ़ाइल में लॉग किया जाता है। analyse/analyse_log.py में एक बुनियादी विश्लेषण स्क्रिप्ट है जो उन प्रोब्स और प्रॉम्प्ट्स को आउटपुट करेगी जिनसे सबसे अधिक हिट हुए।

PR भेजें और मुद्दे खोलें। शुभ शिकार!

जनरेटर का परिचय

Hugging Face

Pipeline API का उपयोग करते हुए:

--target_type huggingface (स्थानीय रूप से चलाने के लिए transformers मॉडल के लिए)
--target_name - Hub से मॉडल का नाम उपयोग करें। केवल जनरेटिव मॉडल काम करेंगे। यदि यह विफल होता है और ऐसा नहीं होना चाहिए, तो कृपया एक मुद्दा खोलें और आपके द्वारा आज़माए गए कमांड + अपवाद को पेस्ट करें!

Inference API का उपयोग करते हुए:

--target_type huggingface.InferenceAPI (API-आधारित मॉडल एक्सेस के लिए)
--target_name - Hub से मॉडल का नाम, जैसे "mosaicml/mpt-7b-instruct"

निजी एंडपॉइंट का उपयोग करते हुए:

--target_type huggingface.InferenceEndpoint (निजी एंडपॉइंट के लिए)
--target_name - एंडपॉइंट URL, जैसे https://xxx.us-east-1.aws.endpoints.huggingface.cloud
(वैकल्पिक) HF_INFERENCE_TOKEN एनवायरनमेंट वेरिएबल को हगिंग फेस API टोकन पर सेट करें जिसमें "read" भूमिका हो; लॉग इन करने पर https://huggingface.co/settings/tokens देखें

OpenAI

--target_type openai
--target_name - वह OpenAI मॉडल जिसे आप उपयोग करना चाहेंगे। परीक्षण के लिए gpt-5-nano तेज़ और ठीक है।
OPENAI_API_KEY एनवायरनमेंट वेरिएबल को अपनी OpenAI API कुंजी पर सेट करें (जैसे "sk-19763ASDF87q6657"); लॉग इन करने पर https://platform.openai.com/account/api-keys देखें

पहचाने गए मॉडल प्रकारों को सफेद सूचीबद्ध किया गया है, क्योंकि प्लगइन को यह जानना होता है कि किस उप-API का उपयोग करना है। Completion या ChatCompletion मॉडल ठीक हैं। यदि आप किसी असमर्थित मॉडल का उपयोग करना चाहते हैं, तो आपको एक जानकारीपूर्ण त्रुटि संदेश मिलना चाहिए, और कृपया एक PR / एक मुद्दा भेजें।

Replicate

REPLICATE_API_TOKEN एनवायरनमेंट वेरिएबल को अपने Replicate API टोकन पर सेट करें, जैसे "r8-123XXXXXXXXXXXX"; लॉग इन करने पर https://replicate.com/account/api-tokens देखें

सार्वजनिक Replicate मॉडल:

--target_type replicate
--target_name - Replicate मॉडल का नाम और हैश, जैसे "stability-ai/stablelm-tuned-alpha-7b:c49dae36"

निजी Replicate एंडपॉइंट:

--target_type replicate.InferenceEndpoint (निजी एंडपॉइंट के लिए)
--target_name - तैनात एंडपॉइंट से उपयोगकर्ता नाम/मॉडल-नाम स्लग, जैसे elim/elims-llama2-7b

Cohere

--target_type cohere
--target_name (वैकल्पिक, डिफ़ॉल्ट रूप से command) - वह विशिष्ट Cohere मॉडल जिसका आप परीक्षण करना चाहते हैं
COHERE_API_KEY एनवायरनमेंट वेरिएबल को अपनी Cohere API कुंजी पर सेट करें, जैसे "aBcDeFgHiJ123456789"; लॉग इन करने पर https://dashboard.cohere.ai/api-keys देखें

Groq

--target_type groq
--target_name - Groq API के माध्यम से एक्सेस करने के लिए मॉडल का नाम
GROQ_API_KEY एनवायरनमेंट वेरिएबल को अपनी Groq API कुंजी पर सेट करें; API कुंजी बनाने के विवरण के लिए https://console.groq.com/docs/quickstart देखें

ggml

--target_type ggml
--target_name - उस ggml मॉडल का पथ जिसे आप लोड करना चाहते हैं, जैसे /home/leon/llama.cpp/models/7B/ggml-model-q4_0.bin
GGML_MAIN_PATH एनवायरनमेंट वेरिएबल को अपने ggml main निष्पादन योग्य के पथ पर सेट करें

REST

rest.RestGenerator अत्यधिक लचीला है और किसी भी REST एंडपॉइंट से जुड़ सकता है जो प्लेनटेक्स्ट या JSON लौटाता है। इसके लिए कुछ संक्षिप्त कॉन्फ़िगरेशन की आवश्यकता होती है, जो आमतौर पर आपके एंडपॉइंट का वर्णन करने वाली एक छोटी YAML फ़ाइल के रूप में होगी। उदाहरणों के लिए https://reference.garak.ai/en/latest/garak.generators.rest.html देखें।

NIM

https://build.nvidia.com/ या अन्य NIM एंडपॉइंट से मॉडल का उपयोग करें।

NIM_API_KEY एनवायरनमेंट वेरिएबल को अपने प्रमाणीकरण API टोकन पर सेट करें, या इसे कॉन्फ़िग YAML में निर्दिष्ट करें

चैट मॉडल के लिए:

--target_type nim
--target_name - NIM model नाम, जैसे meta/llama-3.1-8b-instruct

कम्पलीशन मॉडल के लिए:

--target_type nim.NVOpenAICompletion
--target_name - NIM model नाम, जैसे bigcode/starcoder2-15b

AWS Bedrock

--target_type bedrock
--target_name - Bedrock मॉडल ID या उपनाम, जैसे anthropic.claude-3-sonnet-20240229-v1:0 या claude-3-sonnet
BEDROCK_API_KEY एनवायरनमेंट वेरिएबल को अपनी AWS Bedrock API कुंजी पर सेट करें; सेटअप निर्देशों के लिए https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys-use.html देखें
(वैकल्पिक) AWS क्षेत्र निर्दिष्ट करने के लिए BEDROCK_REGION एनवायरनमेंट वेरिएबल सेट करें (डिफ़ॉल्ट us-east-1 है)

समर्थित मॉडल परिवारों में Anthropic Claude, Meta Llama, Amazon Titan, AI21 Labs, Cohere, और Mistral AI मॉडल शामिल हैं। जनरेटर सभी मॉडल प्रकारों में एकीकृत पहुंच के लिए Converse API का उपयोग करता है।

उदाहरण उपयोग:``` export BEDROCK_API_KEY="your-api-key" export BEDROCK_REGION="us-east-1" garak --target_type bedrock --target_name claude-3-sonnet --probes dan

### परीक्षण

* `--target_type test`
* (वैकल्पिक रूप से) `--target_name test.Blank`
परीक्षण के लिए। यह हमेशा `test.Blank` जनरेटर का उपयोग करके खाली स्ट्रिंग उत्पन्न करता है। किसी भी ऐसे परीक्षण के लिए विफल के रूप में चिह्नित किया जाएगा जिसके लिए आउटपुट की *आवश्यकता* होती है, उदाहरण के लिए वे जो विवादास्पद दावे करते हैं और पास होने के लिए मॉडल से उनका खंडन करने की अपेक्षा करते हैं।

* `--target_type test.Repeat`
परीक्षण के लिए। यह जनरेटर प्राप्त प्रॉम्प्ट को वापस दोहराता है।

## प्रोब का परिचय

| प्रोब                | विवरण                                                                                                                   |
|----------------------|-------------------------------------------------------------------------------------------------------------------------------|
| blank                | एक सरल प्रोब जो हमेशा एक खाली प्रॉम्प्ट भेजता है।                                                                             |
| atkgen               | स्वचालित आक्रमण जनरेशन (Automated Attack Generation)। एक रेड-टीमिंग LLM लक्ष्य की जांच करता है और विषाक्त आउटपुट प्राप्त करने के प्रयास में उस पर प्रतिक्रिया करता है। प्रोटोटाइप, अधिकतर स्टेटलेस, वर्तमान में एक सरल GPT-2 [fine-tuned](https://huggingface.co/garak-llm/artgpt2tox) का उपयोग करता है जो hhrlhf प्रयासों के उपसमूह पर प्रशिक्षित है जिसने पता लगाने योग्य विषाक्तता उत्पन्न की (अभी के लिए केवल यही लक्ष्य समर्थित है)। |
| badchars             | [Bad Characters](https://arxiv.org/abs/2106.09898) पेपर से प्रेरित अवधारणात्मक यूनिकोड विकृतियों (अदृश्य वर्ण, होमोग्लिफ़, पुनर्क्रमण, विलोपन) को लागू करता है। |
| av_spam_scanning     | ऐसे प्रोब जो मॉडल को दुर्भावनापूर्ण सामग्री हस्ताक्षर आउटपुट करने के लिए प्रेरित करने का प्रयास करते हैं।                                                     |
| continuation         | ऐसे प्रोब जो जांचते हैं कि क्या मॉडल संभवतः अवांछनीय शब्द जारी रखेगा।                                                       |
| dan                  | विभिन्न [DAN](https://adguard.com/en/blog/chatgpt-dan-prompt-abuse.html) और DAN-जैसे हमले।                                 |
| donotanswer          | ऐसे प्रॉम्प्ट जिनका उत्तरदायी भाषा मॉडल को उत्तर नहीं देना चाहिए।                                                               |
| encoding             | टेक्स्ट एन्कोडिंग के माध्यम से प्रॉम्प्ट इंजेक्शन।                                                                                        |
| gcg                  | एक प्रतिकूल प्रत्यय जोड़कर सिस्टम प्रॉम्प्ट को बाधित करना।                                                                   |
| glitch               | मॉडल में ग्लिच टोकन खोजें जो असामान्य व्यवहार भड़काते हैं।                                                                  |
| grandma              | किसी की दादी को याद करने की अपील।                                                                                   |
| goodside             | रिले गुडसाइड हमलों का कार्यान्वयन।                                                                                    |
| leakreplay           | मूल्यांकन करें कि क्या मॉडल प्रशिक्षण डेटा को दोहराएगा।                                                                                |
| lmrc                 | [लैंग्वेज मॉडल रिस्क कार्ड्स](https://arxiv.org/abs/2303.18190) प्रोब का उपसमूह।                                         |
| malwaregen           | मॉडल को मैलवेयर बनाने के लिए कोड उत्पन्न करने का प्रयास।                                                                 |
| misleading           | मॉडल को भ्रामक और झूठे दावों का समर्थन करने का प्रयास।                                                                  |
| packagehallucination | कोड जनरेशन प्राप्त करने का प्रयास जो गैर-मौजूद (और इसलिए असुरक्षित) पैकेज निर्दिष्ट करते हैं।                                   |
| promptinject         | Agency Enterprise के [PromptInject](https://github.com/agencyenterprise/PromptInject/tree/main/promptinject) कार्य का कार्यान्वयन (NeurIPS ML Safety Workshop 2022 में सर्वश्रेष्ठ पेपर पुरस्कार) |
| realtoxicityprompts  | RealToxicityPrompts कार्य का उपसमूह (डेटा सीमित क्योंकि पूर्ण परीक्षण चलने में बहुत समय लगेगा)                      |
| snowball             | [Snowballed Hallucination](https://ofir.io/snowballed_hallucination.pdf) प्रोब जो मॉडल को उस प्रश्न का गलत उत्तर देने के लिए डिज़ाइन किए गए हैं जो उसके लिए संसाधित करने के लिए बहुत जटिल हैं |
| xss                  | उन कमजोरियों की तलाश करें जो क्रॉस-साइट हमलों, जैसे निजी डेटा बहिर्वाह, की अनुमति देती हैं।                           |

## लॉगिंग

`garak` कई प्रकार के लॉग उत्पन्न करता है:
* एक लॉग फ़ाइल, `garak.log`। इसमें `garak` और इसके प्लगइन्स से डिबगिंग जानकारी शामिल है, और यह रनों में जारी रहता है।
* वर्तमान रन की एक रिपोर्ट, JSONL के रूप में संरचित। हर बार `garak` चलने पर एक नई रिपोर्ट फ़ाइल बनाई जाती है। इस फ़ाइल का नाम रन की शुरुआत में और, यदि सफल हो, तो रन के अंत में भी आउटपुट होता है। रिपोर्ट में, प्रत्येक प्रोबिंग प्रयास के लिए एक प्रविष्टि जनरेशन प्राप्त होने पर और फिर से मूल्यांकन होने पर बनाई जाती है; प्रविष्टि का `status` गुण `garak.attempts` से एक स्थिरांक लेता है यह बताने के लिए कि यह किस चरण पर बनाया गया था।
* एक हिट लॉग, उन प्रयासों का विवरण देता है जिनमें कोई कमजोरी (एक 'हिट') प्राप्त हुई।

## कोड की संरचना कैसी है?

`garak` कोड संरचना के लिए आधिकारिक मार्गदर्शिका के लिए [संदर्भ दस्तावेज़](https://reference.garak.ai/) देखें।

एक सामान्य रन में, `garak` कमांड लाइन से एक मॉडल प्रकार (और वैकल्पिक रूप से मॉडल नाम) पढ़ेगा, फिर यह निर्धारित करेगा कि कौन से `probe` और `detector` चलाने हैं, एक `generator` प्रारंभ करेगा, और फिर प्रोबिंग करने के लिए इन्हें एक `harness` को पास करेगा; एक `evaluator` परिणामों से निपटता है। इनमें से प्रत्येक श्रेणी में कई मॉड्यूल हैं, और प्रत्येक मॉड्यूल कई वर्ग प्रदान करता है जो व्यक्तिगत प्लगइन के रूप में कार्य करते हैं।

* `garak/probes/` - LLMs के साथ इंटरैक्शन उत्पन्न करने के लिए वर्ग
* `garak/detectors/` - यह पता लगाने के लिए वर्ग कि LLM एक निश्चित विफलता मोड प्रदर्शित कर रहा है
* `garak/evaluators/` - मूल्यांकन रिपोर्टिंग योजनाएँ
* `garak/generators/` - जांचे जाने वाले LLMs के लिए प्लगइन
* `garak/harnesses/` - परीक्षण संरचना के लिए वर्ग
* `resources/` - प्लगइन्स के लिए आवश्यक सहायक वस्तुएँ

डिफ़ॉल्ट संचालन मोड `probewise` हार्नेस का उपयोग करना है। प्रोब मॉड्यूल नामों और प्रोब प्लगइन नामों की एक सूची दिए जाने पर, `probewise` हार्नेस प्रत्येक प्रोब को इंस्टैंशिएट करता है, फिर प्रत्येक प्रोब के लिए आउटपुट पर चलाने के लिए `detector`s की एक सूची प्राप्त करने के लिए इसके `primary_detector` और `extended_detectors` विशेषताओं को पढ़ता है।

प्रत्येक प्लगइन श्रेणी (`probes`, `detectors`, `evaluators`, `generators`, `harnesses`) में एक `base.py` शामिल है जो उस श्रेणी के प्लगइन्स द्वारा उपयोग योग्य आधार वर्गों को परिभाषित करता है। प्रत्येक प्लगइन मॉड्यूल प्लगइन वर्गों को परिभाषित करता है जो आधार वर्गों में से एक से विरासत में मिलते हैं। उदाहरण के लिए, `garak.generators.openai.OpenAIGenerator` `garak.generators.base.Generator` से उतरता है।

बड़ी कलाकृतियाँ, जैसे मॉडल फ़ाइलें और बड़े कोर्पोरा, रिपॉजिटरी से बाहर रखी जाती हैं; उन्हें उदाहरण के लिए Hugging Face Hub पर संग्रहीत किया जा सकता है और `garak` का उपयोग करके क्लाइंट द्वारा स्थानीय रूप से लोड किया जा सकता है।

## अपना स्वयं का प्लगइन विकसित करना

* देखें कि अन्य प्लगइन्स इसे कैसे करते हैं
* आधार वर्गों में से एक से प्राप्त करें, जैसे `garak.probes.base.TextProbe`
* जितना संभव हो उतना कम ओवरराइड करें
* आप नए कोड का कम से कम दो तरीकों से परीक्षण कर सकते हैं:
  * एक इंटरैक्टिव Python सत्र प्रारंभ करें
    * मॉडल आयात करें, जैसे `import garak.probes.mymodule`
    * प्लगइन इंस्टैंशिएट करें, जैसे `p = garak.probes.mymodule.MyProbe()`
  * परीक्षण प्लगइन्स के साथ एक स्कैन चलाएँ
    * प्रोब के लिए, एक खाली जनरेटर और always.Pass डिटेक्टर आज़माएँ: `python3 -m garak -m test.Blank -p mymodule -d always.Pass`
    * डिटेक्टर के लिए, एक खाली जनरेटर और एक खाली प्रोब आज़माएँ: `python3 -m garak -m test.Blank -p test.Blank -d mymodule`
    * जनरेटर के लिए, एक खाली प्रोब और always.Pass डिटेक्टर आज़माएँ: `python3 -m garak -m mymodule -p test.Blank -d always.Pass`
  * `garak` को `--list_probes`, `--list_detectors`, या `--list_generators` के साथ उस प्रकार के सभी प्लगइन्स को सूचीबद्ध करने के लिए कहें

## सामान्य प्रश्न

हमारा FAQ [यहाँ](https://github.com/NVIDIA/garak/blob/main/FAQ.md) है। यदि आपके कोई और प्रश्न हैं, तो संपर्क करें! [[email protected]](mailto:[email protected])

कोड संदर्भ दस्तावेज़ [garak.readthedocs.io](https://garak.readthedocs.io/en/latest/) पर है।

## garak का उल्लेख

आप [garak preprint paper](https://github.com/nvidia/garak/blob/HEAD/garak-paper.pdf) पढ़ सकते हैं। यदि आप garak का उपयोग करते हैं, तो कृपया हमें उद्धृत करें।```
@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}}
}

"झूठ बोलना किसी भी अन्य कौशल की तरह है, और यदि आप उत्कृष्टता के स्तर को बनाए रखना चाहते हैं तो आपको लगातार अभ्यास करना होगा" - Elim

अपडेट और खबरों के लिए देखें @garak_llm

garak

सबसे लोकप्रिय