# ऑप्टिमाइज़ेशन कैसे काम करता है

> रन और स्कोर का अनुबंध, आर्टिफ़ैक्ट के प्रकार, और हर प्रकार के लिए इंजन।

Skynet, Optimize Anything है: एक प्रोडक्ट जो किसी भी आर्टिफ़ैक्ट को आपके डेटा और आपके मेट्रिक के आधार पर बेहतर बनाता है। हर रन एक ही रन कॉन्ट्रैक्ट और एक ही मेट्रिक कॉन्ट्रैक्ट इस्तेमाल करता है। आर्टिफ़ैक्ट का प्रकार तय करता है कि कौन-से इंजन उस पर काम कर सकते हैं।

## साझा कॉन्ट्रैक्ट

हर रन में दो फ़ाइलें होती हैं। `run.py` आर्टिफ़ैक्ट को एक केस पर चलाती है। `metric.py` आउटपुट को स्कोर करती है।

```python tab="run.py"
from skynet import llm


def run(artifact, input):
    return llm(artifact, input=input)
```

```python tab="metric.py"
def score(input, output, expected=None):
    ok = output == expected
    return (1.0 if ok else 0.0), {"feedback": "Match." if ok else "No match."}
```

- `artifact` वह मौजूदा संस्करण है जिसे ऑप्टिमाइज़र प्रस्तावित करता है।
- `input` एक dict है जिसमें एक केस के इनपुट फ़ील्ड होते हैं।
- `expected` केस का अपेक्षित मान है, या `None` जब केस में कोई अपेक्षित मान नहीं होता।
- `score` एक जोड़ी लौटाता है: एक संख्या, और `"feedback"` स्ट्रिंग वाली एक dict।

`skynet` हेल्पर मॉड्यूल `llm`, `Image` और `log` देता है। रन कोड से `llm` की कॉल टास्क मॉडल पर जाती है। मेट्रिक से `llm` की कॉल मेट्रिक मॉडल पर जाती है।

> [!NOTE]
> रन कोड सैंडबॉक्स में अपने अलग प्रोसेस में चलता है। वह मेट्रिक का सोर्स, अपेक्षित मान या मेट्रिक कुंजी नहीं देख सकता।

पूरे मेट्रिक कॉन्ट्रैक्ट के लिए [मेट्रिक और स्कोरर](/docs/hi/concepts/scorers) पढ़ें।

## आर्टिफ़ैक्ट प्रकार और इंजन

| आर्टिफ़ैक्ट प्रकार | इंजन                                                                         |
| ------------------ | ---------------------------------------------------------------------------- |
| प्रॉम्प्ट          | Auto, GEPA, Best-of-N, AutoResearch, Meta-Harness, AutoSaddler, ShinkaEvolve |
| कोड                | प्रॉम्प्ट के समान                                                             |
| टेक्स्ट            | प्रॉम्प्ट के समान                                                             |
| DSPy प्रोग्राम     | Auto, DSPy GEPA, DSPy MIPROv2, DSPy BootstrapFewShot                         |

इंजन दो परिवारों में आते हैं:

- **नेटिव इंजन** आर्टिफ़ैक्ट को ब्लैक बॉक्स की तरह देखते हैं। वे प्रॉम्प्ट, कोड और टेक्स्ट आर्टिफ़ैक्ट पर काम करते हैं।
- **DSPy ऑप्टिमाइज़र** DSPy प्रोग्राम के अंदर काम करते हैं। वे सिर्फ़ DSPy प्रोग्राम आर्टिफ़ैक्ट पर काम करते हैं।

DSPy MIPROv2 और DSPy BootstrapFewShot को जोड़े (अपेक्षित आउटपुट वाले केस) चाहिए। एक ही इनपुट होने पर DSPy प्रोग्राम सिर्फ़ Auto और DSPy GEPA इस्तेमाल कर सकता है।

## प्रॉम्प्ट, कोड और टेक्स्ट आर्टिफ़ैक्ट

नेटिव इंजन आर्टिफ़ैक्ट को ब्लैक बॉक्स की तरह देखते हैं। इंजन एक नया संस्करण प्रस्तावित करता है, केसों पर `run(artifact, input)` चलाता है, और स्कोर व फ़ीडबैक पढ़ता है।

छह नेटिव इंजन खोज के अलग-अलग तरीके इस्तेमाल करते हैं:

- **GEPA** रिफ़्लेक्शन के ज़रिए संस्करणों को विकसित करता है और एक Pareto फ्रंट रखता है।
- **Best-of-N** रिफ़्लेक्शन मॉडल से स्वतंत्र प्रस्ताव माँगता है और सबसे अच्छा रखता है।
- **AutoResearch**, **Meta-Harness**, **AutoSaddler** और **ShinkaEvolve** संस्करण प्रस्तावित करने के लिए एक कोडिंग एजेंट इस्तेमाल करते हैं।

हर इंजन और उसकी सेटिंग्स के लिए [इंजन](/docs/hi/concepts/engines) पढ़ें।

## DSPy प्रोग्राम आर्टिफ़ैक्ट

DSPy प्रोग्राम एक आर्टिफ़ैक्ट प्रकार है। आपकी `run.py` मॉड्यूल स्तर पर एक `dspy.Module` बनाती है और उसे `run` के अंदर कॉल करती है। अगर फ़ाइल में एक से ज़्यादा मॉड्यूल हैं, तो जिसे ऑप्टिमाइज़ करना है उसका नाम `program` रखें।

DSPy ऑप्टिमाइज़र चलने पर क्या होता है:

1. Skynet आपका मॉड्यूल ढूँढता है और उसके चारों ओर आपका `run` फ़ंक्शन लपेटता है। हर केस आपके अपने `run` से होकर जाता है।
2. DSPy ऑप्टिमाइज़र प्रशिक्षण केसों पर प्रोग्राम को कंपाइल करता है।
3. वह मान्यकरण केसों पर चयन करता है।
4. विजेता हर प्रेडिक्टर का निर्देश टेक्स्ट होता है, साथ में मॉड्यूल की पूरी कंपाइल की गई स्थिति। इस स्थिति में few-shot डेमो शामिल होते हैं।

अंतिम स्कोर उसी प्रोग्राम को मापते हैं जिसे Skynet सहेजता है।

| ऑप्टिमाइज़र           | फ़ीडबैक टेक्स्ट पढ़ता है |
| --------------------- | ---------------------- |
| DSPy GEPA             | हाँ                    |
| DSPy MIPROv2          | नहीं, सिर्फ़ स्कोर      |
| DSPy BootstrapFewShot | नहीं, सिर्फ़ स्कोर      |

DSPy BootstrapFewShot रिफ़्लेक्शन मॉडल इस्तेमाल नहीं करता।

> [!TIP]
> DSPy रिफ़्लेक्शन मॉडल सिर्फ़ वह फ़ीडबैक टेक्स्ट देखता है जो आपका मेट्रिक लौटाता है। वह मेट्रिक का सोर्स कभी नहीं देखता।

## Auto

**Auto** विज़ार्ड में डिफ़ॉल्ट विकल्प है।

- प्रॉम्प्ट, कोड या टेक्स्ट आर्टिफ़ैक्ट पर Auto पाँच नेटिव इंजनों के साथ खोज करता है, फिर सबसे अच्छे संस्करण से GEPA के साथ आगे बढ़ता है।
- DSPy प्रोग्राम पर Auto, DSPy GEPA चलाता है।

Auto के दोनों रूप आपके मेट्रिक का फ़ीडबैक टेक्स्ट पढ़ते हैं।

## कौन-सा इंजन चुनें

| आपकी स्थिति                                                  | इस्तेमाल करें                                                          |
| ------------------------------------------------------------ | --------------------------------------------------------------------- |
| आपके पास एक प्रॉम्प्ट है जिसे कोई मॉडल चलाता है                   | प्रॉम्प्ट आर्टिफ़ैक्ट। Auto से शुरू करें।                                   |
| आपके पास ऐसा कोड है जिसे तेज़, सस्ता या ज़्यादा सही बनाना है         | कोड आर्टिफ़ैक्ट। Auto से शुरू करें।                                        |
| आपके पास कोई दस्तावेज़ या कॉन्फ़िगरेशन है                         | टेक्स्ट आर्टिफ़ैक्ट। Auto से शुरू करें।                                    |
| आपके पास एक DSPy प्रोग्राम है                                   | DSPy प्रोग्राम आर्टिफ़ैक्ट। Auto से शुरू करें।                              |
| आप चाहते हैं कि few-shot डेमो आपके डेटा से चुने जाएँ              | DSPy BootstrapFewShot या DSPy MIPROv2 के साथ DSPy प्रोग्राम आर्टिफ़ैक्ट |

> [!WARNING]
> GEPA, DSPy GEPA और Auto फ़ीडबैक टेक्स्ट से सीखते हैं। अगर आपका फ़ीडबैक हमेशा एक ही स्ट्रिंग है, तो इन ऑप्टिमाइज़रों के पास काम करने के लिए कम जानकारी होती है।

## संबंधित पेज

- [इंजन](/docs/hi/concepts/engines)
- [डेटासेट और विभाजन](/docs/hi/concepts/datasets)
- [मेट्रिक और स्कोरर](/docs/hi/concepts/scorers)
- [विज़ार्ड से रन शुरू करें](/docs/hi/guides/submit)

---

Source: https://staging.skynetml.com/docs/hi/concepts/optimization