एलएलएम रीजनिंग में प्रगति: एक तकनीकी गहन जानकारी

परिचय

बड़े भाषा मॉडल (एलएलएम) ने हाल के वर्षों में प्राकृतिक भाषा प्रसंस्करण (एनएलपी) के क्षेत्र में क्रांति ला दी है। इन मॉडलों ने भाषा अनुवाद, पाठ सारांश और प्रश्न उत्तर सहित विभिन्न एनएलपी कार्यों में अत्याधुनिक परिणाम प्राप्त किए हैं। हालाँकि, एलएलएम की वास्तविक क्षमता अवधारणाओं के बीच जटिल संबंधों को समझने और तर्क करने की उनकी क्षमता में निहित है। इस लेख में, हम एलएलएम रीजनिंग में प्रगति, अंतर्निहित तकनीकों, वास्तुकला और चुनौतियों की खोज करेंगे।

पृष्ठभूमि

एलएलएम एक प्रकार का तंत्रिका नेटवर्क है जिसे शब्दों और अवधारणाओं के बीच पैटर्न और संबंधों को सीखने के लिए बड़ी मात्रा में टेक्स्ट डेटा पर प्रशिक्षित किया जाता है। इन मॉडलों में आम तौर पर एक एनकोडर और एक डिकोडर शामिल होता है, जहां एनकोडर इनपुट टेक्स्ट को संसाधित करता है और डिकोडर आउटपुट टेक्स्ट उत्पन्न करता है। एनकोडर आमतौर पर एक ट्रांसफार्मर-आधारित वास्तुकला है, जो पाठ जैसे अनुक्रमिक डेटा के लिए विशेष रूप से उपयुक्त है।

ट्रांसफार्मर वास्तुकला

ट्रांसफॉर्मर आर्किटेक्चर, वासवानी एट अल द्वारा पेपर "अटेंशन इज़ ऑल यू नीड" में पेश किया गया है। (2017), एलएलएम के लिए वास्तविक मानक बन गया है। ट्रांसफार्मर में एक एनकोडर और एक डिकोडर होता है, प्रत्येक कई परतों से बना होता है। प्रत्येक परत में दो उप-परतें होती हैं: एक स्व-ध्यान तंत्र और एक पूरी तरह से कनेक्टेड फीड-फॉरवर्ड नेटवर्क (एफएफएनएन)।

मशाल आयात करें
टॉर्च.एनएन को एनएन के रूप में आयात करें

क्लास ट्रांसफार्मरलेयर(एनएन.मॉड्यूल):
    def __init__(स्वयं, d_मॉडल, n_heads, d_ff):
        सुपर(ट्रांसफॉर्मरलेयर, स्वयं).__init__()
        self.self_attn = nn.MultiHeadAttention(d_model, n_heads)
        self.ffnn = nn.रैखिक(d_model, d_ff)
        स्व.ड्रॉपआउट = एनएन.ड्रॉपआउट(0.1)
        self.layer_norm = nn.LayerNorm(d_model)

    डीईएफ़ फॉरवर्ड(स्वयं, एक्स):
        # आत्म-ध्यान तंत्र
        x_attn = self.self_attn(x, x)
        x_attn = self.dropout(x_attn)
        x_attn = x + x_attn

        #एफएफएनएन
        x_ffnn = self.ffnn(x_attn)
        x_ffnn = self.dropout(x_ffnn)
        x_ffnn = self.layer_norm(x_ffnn + x_attn)

        x_ffnn वापस करें

एलएलएम रीजनिंग में प्रगति

एलएलएम ने अवधारणाओं के बीच जटिल संबंधों को समझने और तर्क करने में महत्वपूर्ण प्रगति की है। कुछ प्रमुख प्रगतियों में शामिल हैं:

1. ग्राफ-आधारित तर्क

ग्राफ-आधारित तर्क में ज्ञान को एक ग्राफ के रूप में प्रस्तुत करना शामिल है, जहां नोड्स अवधारणाओं का प्रतिनिधित्व करते हैं और किनारे उनके बीच संबंधों का प्रतिनिधित्व करते हैं। एलएलएम को इन ग्राफ़ के बारे में तर्क करने, नोड्स के बीच संबंधों के बारे में भविष्यवाणी करने के लिए प्रशिक्षित किया जा सकता है।

ग्राफ़ का उपयोग करें::ग्राफ़;
न्यूरल_नेटवर्क::न्यूरलनेटवर्क का उपयोग करें;

fn ग्राफ़_रीज़निंग(ग्राफ़: &ग्राफ़, क्वेरी: &str) -> स्ट्रिंग {
    लेट एम्बेडिंग = न्यूरल_नेटवर्क.क्वेरी(ग्राफ़, क्वेरी);
    परिणाम दें = न्यूरल_नेटवर्क.कारण (ग्राफ़, एम्बेडिंग);
    परिणाम.to_string()
}

2. मल्टी-टास्क लर्निंग

मल्टी-टास्क लर्निंग में एक ही मॉडल को एक साथ कई कार्यों पर प्रशिक्षित करना शामिल है। इस दृष्टिकोण को जटिल संबंधों को समझने और तर्क करने सहित विभिन्न कार्यों पर एलएलएम के प्रदर्शन में सुधार करने के लिए दिखाया गया है।

पैकेज मुख्य

आयात (
	"एफएमटी"
	"gonum.org/v1/gonum/mat"
)

मॉडल संरचना टाइप करें {
	*एनएन.रैखिक
	*एनएन.रैखिक
}

func (m *मॉडल) फॉरवर्ड(x *mat.Dense) *mat.Dense {
	// फॉरवर्ड पास
	z := m.रैखिक(x)
	z = m.रैखिक(z)
	वापसी z
}

3. ध्यान तंत्र

ध्यान तंत्र आउटपुट उत्पन्न करते समय एलएलएम को इनपुट टेक्स्ट के विशिष्ट भागों पर ध्यान केंद्रित करने की अनुमति देता है। इस दृष्टिकोण को जटिल संबंधों को समझने और तर्क करने सहित विभिन्न कार्यों पर एलएलएम के प्रदर्शन में सुधार करने के लिए दिखाया गया है।

मशाल आयात करें
टॉर्च.एनएन को एनएन के रूप में आयात करें

क्लास अटेंशनमैकेनिज्म(एनएन.मॉड्यूल):
    def __init__(स्वयं, d_मॉडल, n_heads):
        सुपर(अटेंशनमैकेनिज्म, स्वयं).__init__()
        self.query = nn.Linear(d_model, d_model)
        self.key = nn.Linear(d_model, d_model)
        स्व.मान = nn.रैखिक(d_model, d_model)
        स्व.ड्रॉपआउट = एनएन.ड्रॉपआउट(0.1)
        self.layer_norm = nn.LayerNorm(d_model)

    डीईएफ़ फॉरवर्ड(स्वयं, एक्स):
        # क्वेरी, कुंजी और मान
        q = self.query(x)
        k = self.key(x)
        v = स्व.मूल्य(x)

        #वजन ध्यान दें
        वजन = मशाल.मैटमुल(क्यू, के.टी) / गणित.वर्ग(क्यू.आकार[1])
        वज़न = स्व.ड्रॉपआउट (वज़न)
        वजन = टॉर्च.सॉफ्टमैक्स(वजन, मंद=-1)

        # प्रसंग वेक्टर
        संदर्भ = टॉर्च.मैटमुल (वजन, वी)

        वापसी संदर्भ

विज़ुअलाइज़ेशन

विभिन्न कार्यों पर एलएलएम के प्रदर्शन की कल्पना करने के लिए, हम किसी दिए गए कार्य पर विभिन्न मॉडलों की सटीकता की तुलना करने के लिए एक चार्ट का उपयोग कर सकते हैं। यहां Chart.js का उपयोग करने वाले चार्ट का एक उदाहरण दिया गया है:

{
  "प्रकार": "बार",
  "डेटा": {
    "लेबल": ["कार्य 1", "कार्य 2", "कार्य 3"],
    "डेटासेट": [
      {
        "लेबल": "मॉडल 1",
        "डेटा": [0.8, 0.7, 0.9],
        "पृष्ठभूमि रंग": "आरजीबीए(255, 99, 132, 0.2)",
        "बॉर्डर कलर": "आरजीबीए(255, 99, 132, 1)",
        "बॉर्डरविड्थ": 1
      },
      {
        "लेबल": "मॉडल 2",
        "डेटा": [0.9, 0.8, 0.7],
        "पृष्ठभूमि रंग": "आरजीबीए(54, 162, 235, 0.2)",
        "बॉर्डर कलर": "आरजीबीए(54, 162, 235, 1)",
        "बॉर्डरविड्थ": 1
      }
    ]
  },
  "विकल्प": {
    "शीर्षक": {
      "प्रदर्शन": सत्य,
      "पाठ": "विभिन्न कार्यों पर विभिन्न मॉडलों की सटीकता"
    },
    "तराजू": {
      "yAxes": [
        {
          "टिक": {
            "beginAtZero": सत्य
          }
        }
      ]
    }
  }
}

निष्कर्ष

इस लेख में, हमने एलएलएम रीजनिंग में प्रगति का पता लगाया है, जिसमें ग्राफ-आधारित रीजनिंग, मल्टी-टास्क लर्निंग और ध्यान तंत्र शामिल हैं। हमने इन अवधारणाओं को स्पष्ट करने के लिए पायथन, रस्ट और गो में कोड उदाहरण भी प्रदान किए हैं। अंत में, हमने विभिन्न कार्यों पर एलएलएम के प्रदर्शन को देखने के लिए एक चार्ट का उपयोग किया है। इन प्रगतियों में एनएलपी के क्षेत्र में क्रांति लाने की क्षमता है, जो एलएलएम को अवधारणाओं के बीच जटिल संबंधों को तर्क करने और समझने में सक्षम बनाती है।

सन्दर्भ

• वासवानी एट अल. (2017)। आपको बस ध्यान की आवश्यकता है। arXiv प्रीप्रिंट arXiv:1706.03762।
• डेवलिन एट अल। (2018)। बर्ट: भाषा समझ के लिए डीप बाईडायरेक्शनल ट्रांसफार्मर का पूर्व-प्रशिक्षण। arXiv प्रीप्रिंट arXiv:1810.04805।
• रैडफोर्ड एट अल। (2019)। भाषा मॉडल बिना पर्यवेक्षित मल्टीटास्क सीखने वाले होते हैं। arXiv प्रीप्रिंट arXiv:1906.08237।