> ## Documentation Index
> Fetch the complete documentation index at: https://www.krea.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# एक कस्टम स्टाइल प्रशिक्षित करें

> अपने स्वयं के डेटासेट से कस्टम इमेज स्टाइल्स प्रशिक्षित करें और क्यूरेशन, टैगिंग, और पुनरावृत्ति की सर्वोत्तम प्रथाओं पर मार्गदर्शन के साथ सुसंगत आउटपुट जनरेट करें।

export const HeroHeader = ({image, video, title, description}) => {
  return <div className="relative aspect-[2/1] h-[30vh] w-full rounded-lg overflow-hidden mb-8">
      {}
      {video && <video autoPlay muted loop playsInline className="absolute top-0 left-0 w-full h-full object-cover hidden md:block m-0" style={{
    zIndex: 1,
    objectPosition: "20% 20%"
  }}>
          <source src={video} type="video/webm" />
        </video>}

      {}
      <img src={image} alt="" className={`absolute top-0 left-0 m-0 w-full h-full object-cover ${video ? "md:hidden" : "block"}`} style={{
    zIndex: 1,
    objectPosition: "20% 20%"
  }} />

      {}
      <div className="absolute inset-0 bg-gradient-to-t from-black/70 via-black/30 to-black/10 flex flex-col justify-end p-8 dark:hidden" style={{
    zIndex: 2
  }}>
        <h1 className="text-4xl font-bold text-white m-0 drop-shadow-[0_2px_4px_rgba(0,0,0,0.5)]">
          {title}
        </h1>
        <p className="text-lg text-white/95 mt-2 drop-shadow-[0_1px_2px_rgba(0,0,0,0.5)]">
          {description}
        </p>
      </div>

      {}
      <div className="absolute inset-0 bg-gradient-to-t from-black/80 via-black/40 to-black/20 hidden dark:flex flex-col justify-end p-8" style={{
    zIndex: 2
  }}>
        <h1 className="text-4xl font-bold text-white m-0 drop-shadow-[0_2px_4px_rgba(0,0,0,0.5)]">
          {title}
        </h1>
        <p className="text-lg text-white/95 mt-2 drop-shadow-[0_1px_2px_rgba(0,0,0,0.5)]">
          {description}
        </p>
      </div>
    </div>;
};

<HeroHeader image="https://s.krea.ai/docs-lora.webp" title="एक कस्टम स्टाइल प्रशिक्षित करें (LoRA)" description="सुसंगत विज़ुअल एस्थेटिक्स के साथ AI आर्ट जनरेट करने के लिए अपनी स्वयं की इमेजेस का उपयोग करके एक कस्टम स्टाइल प्रशिक्षित करें।" />

## अवलोकन

LoRA (Low-Rank Adaptation) एक फाइन-ट्यूनिंग तकनीक है जो उदाहरण इमेजेस के एक छोटे सेट का उपयोग करके एक AI मॉडल को एक नई विज़ुअल स्टाइल सिखाती है। यह एक मौजूदा मॉडल में नए “स्टाइल वेट्स” इंजेक्ट करके काम करती है, जिससे प्रशिक्षण तेज़ और कुशल दोनों बनता है।

यह गाइड पूर्ण वर्कफ़्लो के बारे में बताती है:

<Steps>
  <Step title="प्रशिक्षण इमेजेस तैयार करें" icon="images">
    उच्च गुणवत्ता वाली इमेजेस को क्यूरेट और अपलोड करें जो आपकी इच्छित स्टाइल का प्रतिनिधित्व करती हैं
  </Step>

  <Step title="प्रशिक्षण जॉब सबमिट करें" icon="play">
    अपने इमेज URL और कॉन्फ़िगरेशन के साथ `/styles/train` पर एक POST अनुरोध भेजें
  </Step>

  <Step title="प्रगति की निगरानी करें" icon="clock">
    लौटाए गए `job_id` का उपयोग करके अपने प्रशिक्षण जॉब स्टेटस को ट्रैक करें
  </Step>

  <Step title="अपनी स्टाइल के साथ जनरेट करें" icon="sparkles">
    इमेज जनरेशन में अपनी प्रशिक्षित स्टाइल लागू करें
  </Step>
</Steps>

***

## प्रशिक्षण इमेजेस तैयार करें

### अपने डेटासेट को क्यूरेट करना

आपकी प्रशिक्षण इमेजेस की गुणवत्ता सीधे परिणामों को प्रभावित करती है। विभिन्न प्रशिक्षण प्रकारों की अलग-अलग आवश्यकताएँ होती हैं:

| प्रकार        | उपयोग केस                          | टिप्स                                  |
| ------------- | ---------------------------------- | -------------------------------------- |
| **Style**     | कलात्मक स्टाइल, विज़ुअल एस्थेटिक्स | विभिन्न विषयों में सुसंगत स्टाइल       |
| **Character** | व्यक्तिगत समानता, सुसंगत पात्र     | विविध मुद्राएँ, अभिव्यक्तियाँ, लाइटिंग |
| **Object**    | विशिष्ट वस्तुएँ, उत्पाद            | कई कोण, सुसंगत ऑब्जेक्ट                |

### कितनी इमेजेस?

गुणवत्ता मात्रा से कहीं अधिक मायने रखती है। शानदार इमेजेस का एक छोटा सेट औसत दर्जे की इमेजेस के बड़े सेट से बेहतर प्रदर्शन करेगा।

| डेटासेट आकार     | मार्गदर्शन                                                    |
| ---------------- | ------------------------------------------------------------- |
| **5 इमेजेस**     | न्यूनतम व्यवहार्य। सरल, सुसंगत स्टाइल्स के लिए काम कर सकता है |
| **10-30 इमेजेस** | अनुशंसित। गुणवत्ता और कवरेज का सर्वोत्तम संतुलन               |
| **50+ इमेजेस**   | जब तक स्टाइल में उच्च विविधता न हो, घटता हुआ रिटर्न           |

<Warning>
  **गुणवत्ता > मात्रा**

  15 उच्च-गुणवत्ता वाली इमेजेस 50 निम्न-गुणवत्ता वाली इमेजेस से बेहतर परिणाम देंगी। प्राथमिकता दें:

  * उच्च रिज़ॉल्यूशन (न्यूनतम 1024x1024)
  * सभी इमेजेस में सुसंगत स्टाइल
  * कोई वॉटरमार्क, टेक्स्ट ओवरले, या कंप्रेशन आर्टिफैक्ट्स नहीं
  * स्टाइल कोहेरेंस बनाए रखते हुए विविध विषय
</Warning>

<Info>
  **उदाहरण डेटासेट्स**

  * **कैरेक्टर प्रशिक्षण**: विविध मुद्राओं, अभिव्यक्तियों, और लाइटिंग स्थितियों वाले किसी व्यक्ति की तस्वीरें। इमेजेस में अन्य लोगों को शामिल करने से बचें।
  * **स्टाइल प्रशिक्षण**: एक सुसंगत स्टाइल में कलाकृतियों का संग्रह। उदाहरण के लिए, [The Metropolitan Museum of Art Ukiyo-E Dataset](https://www.kaggle.com/datasets/kengoichiki/the-metropolitan-museum-of-art-ukiyoe-dataset) एक कलात्मक स्टाइल के प्रशिक्षण के लिए आदर्श जापानी वुडब्लॉक प्रिंट्स प्रदान करता है।
</Info>

### इमेजेस अपलोड करें

प्रशिक्षण से पहले, होस्ट किए गए URL प्राप्त करने के लिए अपनी इमेजेस अपलोड करें। `/assets` एंडपॉइंट का उपयोग करें:

<CodeGroup>
  ```python Python theme={null}
  import requests
  import os
  from dotenv import load_dotenv
  import mimetypes

  load_dotenv()

  API_BASE = "https://api.krea.ai"
  API_TOKEN = os.getenv("API_TOKEN")

  image_dir = "training_images"
  uploaded_urls = []

  for filename in os.listdir(image_dir):
      if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.webp')):
          filepath = os.path.join(image_dir, filename)
          mime_type, _ = mimetypes.guess_type(filepath)

          with open(filepath, 'rb') as f:
              response = requests.post(
                  f"{API_BASE}/assets",
                  headers={"Authorization": f"Bearer {API_TOKEN}"},
                  files={"file": (filename, f, mime_type)},
                  data={"description": f"Training image: {filename}"}
              )

          if response.ok:
              data = response.json()
              uploaded_urls.append(data["image_url"])
              print(f"Uploaded: {filename}")
          else:
              print(f"Failed: {filename}")

  print(f"\nUploaded {len(uploaded_urls)} images")
  ```

  ```bash cURL theme={null}
  # Upload a single image
  curl -X POST https://api.krea.ai/assets \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -F "file=@/path/to/image.jpg" \
    -F "description=Training image"

  # Response: {"id": "...", "image_url": "https://..."}
  ```
</CodeGroup>

<Tip>
  लौटाए गए `image_url` मानों को सहेजें—आप इन्हें प्रशिक्षण एंडपॉइंट पर पास करेंगे।
</Tip>

***

## अपनी स्टाइल प्रशिक्षित करें

### बुनियादी प्रशिक्षण उदाहरण

प्रशिक्षण शुरू करने के लिए अपने इमेज URL सबमिट करें:

<CodeGroup>
  ```python Python theme={null}
  import requests
  import os
  from dotenv import load_dotenv

  load_dotenv()

  API_BASE = "https://api.krea.ai"
  API_TOKEN = os.getenv("API_TOKEN")

  # Training URLs from the upload step
  urls = [
      "https://krea.ai/assets/img1.jpg",
      "https://krea.ai/assets/img2.jpg",
      "https://krea.ai/assets/img3.jpg",
      # ... more images
  ]

  response = requests.post(
      f"{API_BASE}/styles/train",
      headers={
          "Authorization": f"Bearer {API_TOKEN}",
          "Content-Type": "application/json"
      },
      json={
          "name": "Ukiyo-E Style",
          "urls": urls,
          "model": "flux_dev",
          "type": "Style",
          "max_train_steps": 500
      }
  )

  response.raise_for_status()
  job = response.json()
  print(f"Training started! Job ID: {job['job_id']}")
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.krea.ai/styles/train \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Ukiyo-E Style",
      "urls": [
        "https://krea.ai/assets/img1.jpg",
        "https://krea.ai/assets/img2.jpg",
        "https://krea.ai/assets/img3.jpg"
      ],
      "model": "flux_dev",
      "type": "Style",
      "max_train_steps": 500
    }'
  ```
</CodeGroup>

### प्रशिक्षण प्रकार

`type` पैरामीटर आपके उपयोग केस के लिए अनुकूलित बुद्धिमान डिफ़ॉल्ट सेट करता है:

| प्रकार      | सर्वोत्तम के लिए                   |
| ----------- | ---------------------------------- |
| `Style`     | कलात्मक स्टाइल, विज़ुअल एस्थेटिक्स |
| `Character` | व्यक्तिगत समानता, सुसंगत पात्र     |
| `Object`    | विशिष्ट वस्तुएँ, उत्पाद            |
| `Default`   | सामान्य प्रशिक्षण                  |

### पैरामीटर

#### आवश्यक पैरामीटर

<ParamField path="name" type="string" required>
  आपकी कस्टम स्टाइल के लिए एक वर्णनात्मक नाम।

  **उदाहरण:** `"Ukiyo-E Style"`, `"Product Photos"`
</ParamField>

<ParamField path="urls" type="array" required>
  प्रशिक्षण के लिए इमेज URL की सरणी। बेहतर परिणामों के लिए अधिक इमेजेस शामिल करें।
</ParamField>

#### वैकल्पिक पैरामीटर

<ParamField path="model" type="string" default="flux_dev">
  प्रशिक्षण के लिए बेस मॉडल:

  **इमेज मॉडल:**

  * `flux_dev` - उच्च गुणवत्ता, बहुमुखी
  * `flux_schnell` - BFL का रीयलटाइम मॉडल
  * `qwen` - Alibaba का मॉडल
  * `z-image` - Alibaba का कुशल इमेज मॉडल
  * `wan22` - केवल इमेज जनरेशन

  **वीडियो मॉडल:**

  * `wan` - Alibaba का वीडियो मॉडल
</ParamField>

<ParamField path="type" type="string" default="Default">
  प्रशिक्षण श्रेणी: `Style`, `Object`, `Character`, या `Default`
</ParamField>

<ParamField path="trigger_word" type="string">
  प्रॉम्प्ट्स में इस स्टाइल को सक्रिय करने के लिए कस्टम शब्द। निर्दिष्ट नहीं होने पर, स्टाइल नाम का उपयोग करता है।

  <Tip>ऐसे अद्वितीय ट्रिगर शब्द चुनें जो सामान्य प्रॉम्प्ट्स में न आएँ। बहु-शब्द ट्रिगर के लिए अंडरस्कोर का उपयोग करें: `ukiyo_style`</Tip>
</ParamField>

<Accordion title="उन्नत पैरामीटर" icon="sliders">
  <ParamField path="learning_rate" type="number">
    प्रशिक्षण की तीव्रता को नियंत्रित करता है। उच्च मान तेज़ी से प्रशिक्षित करते हैं लेकिन ओवरफिट कर सकते हैं।

    **अनुशंसित रेंज:** 0.0001 - 0.001
  </ParamField>

  <ParamField path="max_train_steps" type="integer">
    अधिकतम प्रशिक्षण पुनरावृत्तियाँ। रेंज: 1-2000
  </ParamField>

  <ParamField path="batch_size" type="integer">
    एक साथ प्रोसेस की गई इमेजेस। बड़े बैच = तेज़ प्रशिक्षण लेकिन अधिक मेमोरी।
  </ParamField>
</Accordion>

### उन्नत पैरामीटर ट्यून करना

`type` फ़ील्ड द्वारा सेट किए गए डिफ़ॉल्ट्स से शुरू करें—वे अधिकांश मामलों के लिए अच्छी तरह से काम करते हैं। इन्हें केवल तभी समायोजित करें जब आप विशिष्ट समस्याएँ देख रहे हों:

<AccordionGroup>
  <Accordion title="लर्निंग रेट" icon="gauge">
    यह नियंत्रित करता है कि मॉडल आपकी प्रशिक्षण इमेजेस के अनुकूल कितनी आक्रामक तरीके से होता है।

    | मान                     | कब उपयोग करें                                   |
    | ----------------------- | ----------------------------------------------- |
    | **0.0001** (कम)         | ओवरफिटिंग समस्याएँ, जटिल स्टाइल्स, छोटे डेटासेट |
    | **0.0003** (डिफ़ॉल्ट)   | अधिकांश उपयोग केस                               |
    | **0.0005-0.001** (अधिक) | तेज़ प्रशिक्षण                                  |

    **संकेत कि आपको समायोजित करना चाहिए:**

    * आउटपुट प्रशिक्षण इमेजेस के समान दिखते हैं → रेट कम करें
    * प्रशिक्षण के बाद स्टाइल प्रभाव कमज़ोर है → रेट थोड़ी बढ़ाएँ
  </Accordion>

  <Accordion title="प्रशिक्षण चरण" icon="shoe-prints">
    मॉडल आपकी इमेजेस पर कितनी देर तक प्रशिक्षित करता है।

    | डेटासेट आकार | अनुशंसित चरण |
    | ------------ | ------------ |
    | 5-10 इमेजेस  | 300-500 चरण  |
    | 15-30 इमेजेस | 500-800 चरण  |
    | 50+ इमेजेस   | 800-1500 चरण |

    **संकेत कि आपको समायोजित करना चाहिए:**

    * आउटपुट बहुत कठोर हैं, प्रॉम्प्ट्स को अनदेखा कर रहे हैं → चरण कम करें
    * स्टाइल प्रभाव कमज़ोर है → चरण बढ़ाएँ
    * जनरेट की गई इमेजेस बिल्कुल प्रशिक्षण डेटा जैसी दिखती हैं → चरण कम करें (ओवरफिटिंग)
  </Accordion>
</AccordionGroup>

<Tip>
  **पुनरावृत्तिपूर्ण ट्यूनिंग**

  यदि आपका पहला प्रशिक्षण प्रयास वांछित परिणाम नहीं देता:

  1. पहले `max_train_steps` समायोजित करें (सबसे सामान्य फिक्स)
  2. फिर `learning_rate` आज़माएँ यदि केवल चरणों से मदद नहीं मिलती
</Tip>

### प्रतिक्रिया प्रारूप

```json theme={null}
{
  "job_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "queued",
  "created_at": "2024-01-15T10:30:00Z"
}
```

***

## प्रशिक्षण प्रगति की निगरानी करें

प्रशिक्षण आमतौर पर 5-15 मिनट लेता है। स्टेटस जाँचने के लिए Jobs API को पोल करें:

<CodeGroup>
  ```python Python theme={null}
  import requests
  import time
  import os
  from dotenv import load_dotenv

  load_dotenv()

  API_BASE = "https://api.krea.ai"
  API_TOKEN = os.getenv("API_TOKEN")
  job_id = "your-job-id"

  while True:
      response = requests.get(
          f"{API_BASE}/jobs/{job_id}",
          headers={"Authorization": f"Bearer {API_TOKEN}"}
      )
      job = response.json()
      status = job["status"]

      print(f"Status: {status}")

      if status == "completed":
          style_id = job["result"]["style_id"]
          print(f"Training complete! Style ID: {style_id}")
          break
      elif status in ["failed", "cancelled"]:
          print(f"Training {status}")
          break

      time.sleep(30)
  ```

  ```bash cURL theme={null}
  # Check job status (repeat until completed)
  curl -X GET https://api.krea.ai/jobs/YOUR_JOB_ID \
    -H "Authorization: Bearer YOUR_API_TOKEN"
  ```
</CodeGroup>

<Accordion title="जॉब स्टेटस मान" icon="diagram-project">
  प्रशिक्षण जॉब्स इन स्टेट्स से गुज़रते हैं:

  1. **queued** - कतार में प्रतीक्षा कर रहा है
  2. **processing** - सक्रिय प्रशिक्षण
  3. **completed** - प्रशिक्षण सफलतापूर्वक समाप्त
  4. **failed** - प्रशिक्षण में त्रुटि आई
  5. **cancelled** - जॉब मैन्युअल रूप से रद्द किया गया
</Accordion>

***

## अपनी प्रशिक्षित स्टाइल का उपयोग करें

एक बार प्रशिक्षण पूरा होने पर, `styles` पैरामीटर का उपयोग करके इमेज जनरेशन में अपनी स्टाइल लागू करें:

<Warning>
  **ऐप और API के बीच स्टाइल स्वामित्व**

  API और Krea वेब ऐप आपके वर्कस्पेस के भीतर अलग-अलग उपयोगकर्ता पहचान के रूप में संचालित होते हैं। स्टाइल्स उस उपयोगकर्ता के लिए निजी हैं जिसने उन्हें बनाया है, इसलिए:

  * **ऐप-प्रशिक्षित स्टाइल्स** API के माध्यम से तब तक सुलभ नहीं हैं जब तक साझा न किया जाए
  * **API-प्रशिक्षित स्टाइल्स** ऐप में तब तक सुलभ नहीं हैं जब तक साझा न किया जाए

  अपने वर्कस्पेस के साथ एक स्टाइल साझा करने के लिए (दोनों दिशाओं में काम करता है):

  ```bash theme={null}
  curl -X POST https://api.krea.ai/styles/YOUR_STYLE_ID/share/workspace \
    -H "Authorization: Bearer YOUR_API_TOKEN"
  ```
</Warning>

<CodeGroup>
  ```python Python theme={null}
  import requests
  import time
  import os
  from dotenv import load_dotenv

  load_dotenv()

  API_BASE = "https://api.krea.ai"
  API_TOKEN = os.getenv("API_TOKEN")
  STYLE_ID = "w29t6pvy0"

  response = requests.post(
      f"{API_BASE}/generate/image/krea/krea-2/medium",
      headers={
          "Authorization": f"Bearer {API_TOKEN}",
          "Content-Type": "application/json"
      },
      json={
          "prompt": "An abstract, colorful, surreal composition of symmetry and balance. Swirling colors, imagery of trees and coalescing patterns converge. The lantern of light and death. It is as if the world was at once dark, and yet again lit.",
          "aspect_ratio": "1:1",
          "resolution": "1K",
          "styles": [
              {
                  "id": STYLE_ID,
                  "strength": 0.95
              }
          ]
      }
  )

  job = response.json()
  job_id = job["job_id"]
  print(f"Generation started! Job ID: {job_id}")

  # Poll for completion
  while True:
      check = requests.get(
          f"{API_BASE}/jobs/{job_id}",
          headers={"Authorization": f"Bearer {API_TOKEN}"}
      )
      status_data = check.json()

      if status_data["status"] == "completed":
          image_url = status_data["result"]["urls"][0]
          print(f"Image ready: {image_url}")
          break
      elif status_data["status"] == "failed":
          print("Generation failed")
          break

      time.sleep(2)
  ```

  ```bash cURL theme={null}
  # Generate with style
  curl -X POST https://api.krea.ai/generate/image/krea/krea-2/medium \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
      "prompt": "An abstract, colorful, surreal composition of symmetry and balance. Swirling colors, imagery of trees and coalescing patterns converge. The lantern of light and death. It is as if the world was at once dark, and yet again lit.",
      "aspect_ratio": "1:1",
      "resolution": "1K",
      "styles": [
        {
          "id": "w29t6pvy0",
          "strength": 0.95
        }
      ]
    }'

  # Then poll /jobs/{job_id} for the result
  ```
</CodeGroup>

### स्टाइल स्ट्रेंथ

`strength` पैरामीटर (0.0-1.0) नियंत्रित करता है कि आपकी स्टाइल कितनी मज़बूती से लागू होती है:

| स्ट्रेंथ | प्रभाव                                                  |
| -------- | ------------------------------------------------------- |
| 0.5-0.7  | सूक्ष्म प्रभाव, प्रॉम्प्ट लचीलापन बनाए रखता है          |
| 0.8-0.9  | मज़बूत स्टाइल अनुप्रयोग, अनुशंसित शुरुआती बिंदु         |
| 0.95-1.0 | अधिकतम स्टाइल पालन, प्रॉम्प्ट प्रतिक्रिया कम कर सकता है |

<Tip>
  `0.8` स्ट्रेंथ से शुरू करें और परिणामों के आधार पर समायोजित करें। कम मान अधिक क्रिएटिव स्वतंत्रता देते हैं; उच्च मान सख्त स्टाइल पालन लागू करते हैं।
</Tip>

### कई स्टाइल्स को जोड़ना

`styles` सरणी में उन्हें जोड़कर कई स्टाइल्स लागू करें:

```python theme={null}
"styles": [
    {"id": "style-id-1", "strength": 0.6},
    {"id": "style-id-2", "strength": 0.4}
]
```

***

## सर्वोत्तम प्रथाएँ

<AccordionGroup>
  <Accordion title="इमेज चयन" icon="images">
    * इष्टतम परिणामों के लिए आपके पास जितनी उच्च-गुणवत्ता वाली इमेजेस हों, उनका उपयोग करें
    * सभी प्रशिक्षण इमेजेस में सुसंगत स्टाइल सुनिश्चित करें
    * स्टाइल कोहेरेंस बनाए रखते हुए विषयों में विविधता शामिल करें
    * वॉटरमार्क, टेक्स्ट ओवरले, या आर्टिफैक्ट्स से बचें
    * कम से कम 1024x1024 रिज़ॉल्यूशन की इमेजेस का उपयोग करें
  </Accordion>

  <Accordion title="प्रशिक्षण कॉन्फ़िगरेशन" icon="sliders">
    * `type` फ़ील्ड का उपयोग करके डिफ़ॉल्ट पैरामीटर के साथ शुरू करें
    * स्टाइल्स के लिए: 500-1000 चरण आमतौर पर पर्याप्त होते हैं
    * कम लर्निंग रेट्स (0.0001-0.0003) ओवरफिटिंग से बचाती हैं
    * यदि स्टाइल पर्याप्त मज़बूत नहीं है तो चरण बढ़ाएँ
    * यदि आउटपुट बहुत कठोर है तो चरण कम करें
  </Accordion>

  <Accordion title="ट्रिगर शब्द" icon="wand-magic-sparkles">
    * यदि आप कई स्टाइल्स को संयोजित करने की योजना बना रहे हैं तो एक ही ट्रिगर शब्द का उपयोग करें
    * यदि आप स्टाइल शामिल करते हैं तो ट्रिगर शब्द स्वचालित रूप से प्रॉम्प्ट में इंजेक्ट किए जाते हैं
    * सामान्य शब्दों से बचें जो सामान्य प्रॉम्प्ट्स में आते हैं
    * बहु-शब्द ट्रिगर के लिए अंडरस्कोर का उपयोग करें: `my_custom_style`
  </Accordion>
</AccordionGroup>