कोड जनरेशन के साथ चैटबॉट में सुधार: प्रकाशनों के लिए एक संदर्भ-जागरूक चैटबॉट का निर्माण

परिचय

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

इस क्षेत्र में सबसे लोकप्रिय तकनीकों में से एक है [पुनर्प्राप्ति-संवर्धित पीढ़ी](https://retrieval संवर्धित पीढ़ी aws), या आरएजी, जो उत्पन्न करने के लिए एक बड़े भाषा मॉडल का उपयोग करने से पहले उपयोगकर्ता क्वेरी से प्रासंगिक आइटम ढूंढने के लिए दस्तावेज़ एम्बेडिंग का उपयोग करता है एक जवाब।

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

आरएजी सिस्टम के अधिक गहन विश्लेषण और इसे लागू करने के तरीके के लिए, आप मेरा पिछला लेख यहां पढ़ सकते हैं।

RAG प्रणालियाँ जितनी शक्तिशाली हो सकती हैं, वास्तुकला की कुछ गंभीर सीमाएँ हैं। हमने अपने पिछले लेख में कुछ सीमाओं का पता लगाया और वास्तुकला में सुधार के तरीके प्रस्तावित किए।

आज, हम एम्बेडिंग-आधारित आर्किटेक्चर के साथ एक और सीमा का पता लगाएंगे और आर्किटेक्चर की सीमाओं से बचने का एक तरीका प्रस्तावित करेंगे।

समस्या का विवरण

एंबेडिंग-आधारित RAG की सीमाएँ

मान लीजिए कि हम एक प्रकाशन हैं जो एक चैट इंटरफ़ेस बनाना चाहते हैं जो पाठकों और ग्राहकों को प्रश्न पूछने की अनुमति देता है।

निःसंदेह, हम "एक्स पर आपकी क्या राय है?" जैसे प्रश्नों का उत्तर देने में सक्षम होंगे। या "आपने Y के बारे में क्या कहा है?" एक सरल आरएजी कार्यान्वयन के साथ, लेकिन आरएजी आर्किटेक्चर वास्तव में संघर्ष करना शुरू कर देता है जब आप "2021 में एक्स के बारे में आपने क्या कहा?" जैसे प्रश्नों से निपटते हैं। या "2021 और 2023 के बीच Y का आपका कवरेज कैसे बदल गया है?"

एम्बेडिंग-आधारित RAG के साथ चुनौतियों में से एक यह है कि एम्बेडिंग मॉडल आम तौर पर मेटाडेटा को व्यवस्थित तरीके से एनकोड करने में असमर्थ होते हैं, और इसलिए किसी भी लुकअप के लिए प्रकाशन तिथि या लेखक का नाम जैसी चीजों के ज्ञान की आवश्यकता होती है, जो आपके RAG सिस्टम को काफी परेशानी देगा। .

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

व्यवसायिक समस्या

आज, हम सीबी इनसाइट्स न्यूज़लेटर पर नज़र डालेंगे, जो स्टार्टअप और प्रौद्योगिकी को कवर करने वाला एक लोकप्रिय दैनिक न्यूज़लेटर है। सीबी इनसाइट्स में एक पूर्व पूर्ण-स्टैक डेवलपर के रूप में, मैं अक्सर कार्यदिवस के अंत में संस्थापक की अद्वितीय बुद्धि और अंतर्दृष्टि की प्रतीक्षा करता था।

आज, हम एक चैटबॉट बनाने के लिए आधार डेटा के रूप में सीबी इनसाइट्स न्यूज़लेटर संग्रह का उपयोग करेंगे जो मेटाडेटा-आधारित प्राकृतिक भाषा प्रश्नों का उत्तर इस तरह से दे सकता है जो वेनिला एंबेडिंग-आधारित आरएजी कार्यान्वयन से बेहतर है।

विशेष रूप से, हम चाहते हैं कि चैटबॉट निम्नलिखित प्रश्नों का उत्तर देने में सक्षम हो:

• आपने 2020 में उबर के बारे में क्या कहा?

• 2016-2019 के बीच Airbnb की किस्मत कैसे बदल गई है?

• 2020 के दशक में भारत के कुछ उल्लेखनीय यूनिकॉर्न स्टार्टअप कौन से हैं?

चलो उसे करें!

प्रयुक्त प्रौद्योगिकियाँ

इस कार्य को पूरा करने के लिए, हम निम्नलिखित तकनीकों का उपयोग करेंगे:

अजगर

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

एसक्यूएल

SQL एक क्वेरी भाषा है जो उपयोगकर्ताओं को SQLite, MySQL, PostgreSQL और SQL सर्वर सहित कई प्रमुख रिलेशनल डेटाबेस के साथ इंटरैक्ट करने की अनुमति देती है। भाषा डेटाबेस के लिए निर्देशों का एक सेट है कि उपयोगकर्ता को वापस करने से पहले डेटा को कैसे पुनर्प्राप्त, संयोजित और हेरफेर किया जाए।

एलएलएम कोड जनरेशन

एलएलएम कोड जनरेशन एक ऐसी तकनीक है जिसने पिछले कुछ महीनों में व्यापक ध्यान आकर्षित किया है, क्योंकि जीपीटी 3.5, जीपीटी 4 और एलएलएएमए 2 सहित कई फाउंडेशन मॉडल ने प्राकृतिक भाषा प्रश्नों के जवाब में आश्चर्यजनक जटिलता के कोड उत्पन्न करने की क्षमता का प्रदर्शन किया है।

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

सिमेंटिक एंबेडिंग

सिमेंटिक एम्बेडिंग अधिकांश RAG कार्यान्वयन की रीढ़ है। प्राकृतिक भाषा तकनीकों की एक श्रृंखला का उपयोग करके, हम प्राकृतिक भाषा पाठ को संख्याओं के वेक्टर में बदल सकते हैं जो सिमेंटिक वेक्टर स्पेस के भीतर पाठ की सामग्री का प्रतिनिधित्व करते हैं।

फिर हम इन एम्बेडिंग में हेरफेर करने के लिए वेक्टर बीजगणित का उपयोग कर सकते हैं, जिससे हम गणितीय तरीकों का उपयोग करके दो टेक्स्ट कॉर्पोरा के बीच संबंध निर्धारित कर सकते हैं।

जीपीटी-3.5 और जीपीटी-4

1.7 ट्रिलियन मापदंडों के साथ, GPT-4 आज बाजार में उपलब्ध सबसे शक्तिशाली ट्रांसफार्मर-आधारित बड़ा भाषा मॉडल है। GPT-4 पाठ के बड़े हिस्से, जटिल तर्क और कठिन संकेतों के जवाब में लंबे-स्पष्ट उत्तरों को तैयार करने में सक्षम है।

GPT-3.5, GPT-4 का बहुत छोटा चचेरा भाई, वह मॉडल है जिसने ChatGPT को तब संचालित किया जब इसने दुनिया में तहलका मचा दिया था। यह अविश्वसनीय रूप से जटिल संकेतों को संसाधित करने में सक्षम है, और इसमें शुद्ध तर्क क्षमता की कमी है, यह गति और लागत बचत में पूरा करता है।

सरल कार्यों के लिए, GPT3.5 प्रदर्शन और सटीकता के बीच संतुलन बनाता है।

चैटबॉट बैकएंड की स्थापना

डेटाबेस की स्थापना

अपना AI बनाने से पहले, हमें डेटा प्राप्त करना होगा। ऐसा करने के लिए, हम सीबी इनसाइट्स के न्यूज़लेटर संग्रह पृष्ठ [ https://www.cbinsights.com/newsletter/ ] का उपयोग कर सकते हैं, जिसमें पिछले न्यूज़लेटर्स का संग्रह है।

सभी लिंक प्राप्त करने के लिए, हम पायथन के अनुरोधों और सुंदर सूप लाइब्रेरी का उपयोग कर सकते हैं:

 import requests from bs4 import BeautifulSoup res = requests.get('https://www.cbinsights.com/newsletter/') soup = BeautifulSoup(res.text) article_links = [[i.text, i['href']] for i in soup.find_all('a') if 'campaign-archive' in i['href'] ]

एक बार हमारे पास लिंक आ जाएं, तो हम प्रत्येक लिंक पर जा सकते हैं, और लेख HTML डाउनलोड कर सकते हैं। पायथन की सूची समझ के साथ, हम इसे एक पंक्ति में कर सकते हैं:

 article_soups = [BeautifulSoup(requests.get(link[1]).text) for link in article_links]

इसमें कुछ समय लगेगा, लेकिन अंततः, सभी लिंक हटा दिए जाने चाहिए।

अब, हम संबंधित अनुभागों को निकालने के लिए BeautifulSoup का उपयोग कर सकते हैं:

 import re # SEO optimizations cause some articles to appear twice so we dedupe them. # We also remove some multiple newlines and unicode characters. def get_deduped_article_tables(article_table): new_article_tables = [] for i in article_table: text_content = re.sub(r'\n{2,}', '\n', i.replace('\xa0', '').strip()) if text_content not in new_article_tables or text_content == '': new_article_tables.append(text_content) return new_article_tables result_json = {} for soup_meta, soup_art in zip(article_links, article_soups): article_tables = [] cur_article = [] for table in soup_art.find_all('table'): if table.attrs.get('mc:variant') == 'Section_Divider': article_tables.append(get_deduped_article_tables(cur_article)) cur_article = [] else: cur_article.append(table.text) article_tables.append(get_deduped_article_tables(cur_article)) result_json[soup_meta[0]] = article_tables

आइए कुछ और प्रोसेसिंग करें, और इसे डेटाफ़्रेम में बदलें:

 import pandas as pd result_rows = [] for article_name, article_json in result_json.items(): article_date = article_json[0][1] for idx, tbl in enumerate(article_json[1:]): txt = '\n'.join(tbl).strip() if txt != '': result_rows.append({ 'article_name': article_name, 'article_date': article_date, 'idx': idx, 'text': txt, }) df = apd.DataFrame(result_rows)

यदि आप डेटाफ़्रेम का निरीक्षण करते हैं, तो आपको नीचे जैसा कुछ देखना चाहिए:

जबकि हमारे पास डेटा है, आइए लेखों के लिए एम्बेडिंग भी तैयार करें। OpenAI के ada एम्बेडिंग मॉडल के साथ, यह काफी आसान है।

 import openai EMBEDDING_MODEL = "text-embedding-ada-002" openai.api_key = [YOUR KEY] df['embedding'] = df['text'].map(lambda txt: openai.Embedding.create(model=EMBEDDING_MODEL, input=[txt])['data'][0]['embedding'])

अब जब हमारे पास वह डेटा है जिसका उपयोग हम इस अभ्यास के लिए कर रहे हैं, तो आइए डेटा को एक डेटाबेस में लोड करें। इस अभ्यास के लिए, हम SQLite का उपयोग करेंगे, जो एक हल्का, स्व-निहित डेटाबेस सिस्टम है जो पायथन के साथ आता है।

कृपया ध्यान दें कि उत्पादन परिवेश में, आप संभवतः SQL में मामूली बदलाव के साथ MySQL या PostgreSQL जैसे उचित डेटाबेस इंस्टेंस का उपयोग करना चाहेंगे, लेकिन सामान्य तकनीक वही रहेगी।

डेटाबेस को इंस्टेंट करने और लोड करने के लिए, बस निम्नलिखित को पायथन में चलाएँ। ध्यान दें कि लेख के पाठ और एम्बेडिंग के अलावा, हम कुछ मेटाडेटा, अर्थात् प्रकाशन तिथि भी सहेज रहे हैं।

यह भी ध्यान दें कि SQLite3, अधिकांश अन्य SQL डेटाबेस के विपरीत, एक गतिशील टाइपिंग सिस्टम का उपयोग करता है, इसलिए हमें क्रिएट क्वेरी में डेटा प्रकार निर्दिष्ट करने की आवश्यकता नहीं है।

 import sqlite3 import json con = sqlite3.connect("./cbi_article.db") cur = con.cursor() cur.execute("CREATE TABLE article(name, date, idx, content, embedding_json)") con.commit() rows = [] for _, row in df.iterrows(): rows.append([row['article_name'], row['article_date'], row['idx'], row['text'], json.dumps(row['embedding'])]) cur.executemany("INSERT INTO article VALUES (?, ?, ?, ?, ?)", rows) con.commit()

और आइए डेटा को क्वेरी करने का प्रयास करें।

 res = cur.execute(""" SELECT name, date, idx FROM article WHERE date >= DATE('now', '-2 years'); """) res.fetchall()

कुछ इस प्रकार उत्पन्न होना चाहिए:

बहुत अच्छा लग रहा है!

मेटाडेटा लुकअप के लिए एक कोड जेनरेटर बनाना

अब जब हमारे पास SQLite डेटाबेस में डेटा लोड हो गया है, तो हम अगले चरण पर पहुँच सकते हैं। याद रखें कि केवल एम्बेडिंग आरएजी कार्यान्वयन की चुनौतियों में से एक लचीली मेटाडेटा लुकअप क्षमताओं की कमी है।

हालाँकि, अब जब हमारे पास SQL डेटाबेस में मेटाडेटा लोड है, तो हम लचीले मेटाडेटा लुकअप करने के लिए GPT की कोड जनरेशन क्षमताओं का उपयोग कर सकते हैं।

SQL कोड उत्पन्न करने के लिए, हम कुछ सरल प्रॉम्प्ट इंजीनियरिंग का उपयोग कर सकते हैं।

 response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a SQL query writer that can construct queries based on incoming questions. Answer with only the SQL query."}, {"role": "user", "content": """ Suppose we have the SQLite database table called "article" with the following columns, which contains newsletter articles from a publication: name, date, idx, content, embedding_json Write a question that would retrieve the rows necessary to answer the following user question. Only filter on date. Do not filter on any other column. Make sure the query returns every row in the table by name. Reply only with the SQL query. User question: What did you say about the future of the fintech industry in summer of 2022? """}, ] )

निम्नलिखित शीघ्र इंजीनियरिंग पर ध्यान दें 1) हम डेटाबेस स्कीमा देते हैं लेकिन इसे सरल रखते हैं। 2) हम रिटर्न कॉलम निर्दिष्ट करते हैं। 3) हम उन कॉलमों को निर्दिष्ट करते हैं जो फ़िल्टरिंग के लिए उपलब्ध हैं। 4) हम SQL फ्लेवर निर्दिष्ट करते हैं। इस प्रॉम्प्ट को नीचे दिए गए जैसा SQL कोड जेनरेट करना चाहिए:

 SELECT * FROM article WHERE date BETWEEN '2022-06-01' AND '2022-08-31'

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

हम फ़िल्टर को इस प्रकार कार्यान्वित कर सकते हैं:

 res = [] for i in range(3): response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a SQL query writer that can construct queries based on incoming questions. Answer with only the SQL query."}, {"role": "user", "content": """ Suppose we have the SQLite database table called "article" with the following columns, which contains newsletter articles from a publication: name, date, idx, content, embedding_json Write a question that would retrieve the rows necessary to answer the following user question. Only filter on date. Do not filter on any other column. Make sure the query returns every row in the table by name. Reply only with the SQL query. User question: What did you say about the future of the fintech industry in summer of 2022? """}, ] ) generated_query = response.choices[0].message['content'] is_query_safe = True for no_use_word in {'DELETE', 'UPDATE', 'DROP'}: if no_use_word in generated_query.upper(): is_query_safe = False if not is_query_safe: break # the user input is likely malicious. Try to answer the question with vanilla RAG res = cur.execute(generated_query).fetchall() if len(res) > 0: break if len(res) == 0: # vanilla RAG in memory. Use a vector DB in production please. res = cur.execute('''SELECT * FROM articles''').fetchall()

यह एक अपेक्षाकृत अपरिष्कृत फ़िल्टर है, इसलिए उत्पादन उपयोग के मामलों में, आप संभवतः प्रासंगिकता और SQL शुद्धता के लिए अधिक जाँच चलाना चाहेंगे, लेकिन यह हमारे उदाहरण के लिए पर्याप्त है।

एआई सुरक्षा पर एक त्वरित टिप्पणी , एआई से लौटाए गए कोड को चलाते समय हमें सावधान रहना चाहिए, खासकर यदि उपयोगकर्ता इनपुट का उपयोग प्रॉम्प्ट के हिस्से के रूप में किया गया था।

यदि हम आउटपुट को साफ-सुथरा नहीं करते हैं, तो हम खुद को प्रॉम्प्ट-इंजीनियरिंग हमलों के प्रति असुरक्षित छोड़ देते हैं, जहां उपयोगकर्ता अपडेट उत्पन्न करने या स्टेटमेंट हटाने के लिए एआई में हेरफेर करने की कोशिश करता है।

इसलिए, हमें अपने कंप्यूटर पर कोड चलाने से पहले हमेशा यह सुनिश्चित कर लेना चाहिए कि आउटपुट वैसा ही है जैसा हम उम्मीद करते हैं।

पुनर्प्राप्त परिणाम देखने के लिए निम्नलिखित कोड चलाएँ:

 df = pd.DataFrame([{c[0]: v for c, v in zip(cur.description, row)} for row in res])

और अब, आपको निम्नलिखित परिणाम देखना चाहिए:

परिणाम के साथ मानक आरएजी चलाना

अब जबकि हमारे पास मेटाडेटा लुकअप का परिणाम है, बाकी सब आसान है। हम सभी पुनर्प्राप्त परिणामों के लिए कोसाइन समानता की गणना इस प्रकार करते हैं:

 from openai.embeddings_utils import cosine_similarity q_embed = openai.Embedding.create(model=EMBEDDING_MODEL, input=[user_question])['data'][0]['embedding'] df['cosine_similarity'] = df['embedding_json'].map(lambda js: cosine_similarity(json.loads(js), q_embed))

और अब, हम शीर्ष 10 न्यूज़लेटर ले सकते हैं और प्रश्न का उत्तर देने के लिए त्वरित इंजीनियरिंग का उपयोग कर सकते हैं। हमने यहां 10 को चुना क्योंकि प्रत्येक समाचार पत्र का अंश अपेक्षाकृत छोटा है।

यदि आप लंबे लेखों के साथ काम कर रहे हैं, तो आप संभावित रूप से कम लेखों का उपयोग करना चाहेंगे, या बोनस अनुभाग में शामिल तकनीक का उपयोग करना चाहेंगे।

 answer_prompt = ''' Consider the following newsletter excerpts from the following dates: ''' for _, row in df.sort_values('cosine_similarity', ascending=False).iloc[:10].iterrows(): answer_prompt += """ ======= Date: %s ==== %s ===================== """ % (row['date'], row['content']) answer_prompt += """ Answer the following question: %s """ % user_question response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a tech analyst that can summarize the content of newsletters"}, {"role": "user", "content": answer_prompt}, ] )

इससे आपको निम्नलिखित जैसा परिणाम मिलना चाहिए:

फिनटेक के भविष्य पर 2022 की गर्मियों में विभिन्न समाचार पत्रों में चर्चा की गई थी। फिनटेक में उल्लेखनीय मंदी थी क्योंकि 2021 में उच्च के बाद Q2'22 फंडिंग 2020 के स्तर तक गिर गई थी। Q2'22 रिपोर्ट ने वैश्विक फिनटेक निवेश में गिरावट पर प्रकाश डाला .

हालाँकि, फिनटेक का भविष्य आशाजनक दिखाई दिया क्योंकि शुरुआती चरण के स्टार्टअप की ओर एक महत्वपूर्ण बदलाव देखा गया, खासकर भुगतान क्षेत्र में। भुगतान क्षेत्र में वैश्विक निवेश Q1'22 से 43% गिरकर Q2'22 में $5.1B हो गया, 2021 के शिखर के बाद फंडिंग सामान्य होने के कारण।

इस क्षेत्र में नए प्रवेशकों ने 2022 में अब तक सौदों में उच्च हिस्सेदारी (63%) को आकर्षित किया है, जो स्टार्ट-अप में निवेशकों की रुचि को दर्शाता है। यह भी बताया गया कि फिनटेक खुदरा बैंकों के लिए बढ़ती प्रतिस्पर्धा का कारण बन रहा है, जिससे उन्हें मुख्य सेवाओं के डिजिटलीकरण को प्राथमिकता देने के लिए मजबूर होना पड़ रहा है।

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

जो काफी अच्छा है! यदि आप उत्तर संकेत को देखकर उत्तर की तथ्य-जांच करते हैं, तो आप देखेंगे कि सभी आँकड़े स्रोत सामग्री से आ रहे हैं। आप यह भी देखेंगे कि स्रोत सामग्री में कुछ विशिष्ट स्वरूपण है जिसे GPT4 अनदेखा करने में सक्षम था। यह डेटा संक्षेपण प्रणालियों में एलएलएम के लचीलेपन को दर्शाता है।

बोनस: सारांशीकरण मिडलवेयर

इस प्रक्रिया में आपके सामने आने वाली समस्याओं में से एक यह है कि, जब कोष बहुत बड़ा होता है, तो अंतिम संकेत बहुत बड़ा हो सकता है। यदि आप GPT-4 का उपयोग कर रहे हैं तो यह महंगा हो सकता है, लेकिन बहुत लंबे संकेत से मॉडल को भ्रमित करने का भी मौका मिलता है।

इसे हल करने के लिए, हम GPT-3.5 के साथ अलग-अलग लेखों को प्री-प्रोसेस कर सकते हैं, जो अंतिम संकेत हम अंतिम चरण में GPT-4 को भेज रहे हैं उसे संपीड़ित करके।

 summarization_prompt = ''' Summarize the following passage and extract only portions that are relevant to answering the user question. Passage: ======= %s ======= User Questions: %s ''' (row['content'], user_question) response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": "You are a summarizer of tech industry reports"}, {"role": "user", "content": summarization_prompt}, ] )

फिर हम शुद्ध लेख को अंतिम प्रॉम्प्ट में डालने की तुलना में महत्वपूर्ण बचत के साथ, सारांश को प्रॉम्प्ट में डाल सकते हैं।

एक सरल फ्रंटएंड का निर्माण

अब जब हमारे पास पायथन कोड लिखा हुआ है, तो आइए इसे एक साधारण वेब एप्लिकेशन के रूप में पैकेज करें।

बैकएंड एपीआई

फ्लास्क के साथ बैकएंड एपीआई के रूप में कोड को पैकेज करना अपेक्षाकृत सरल है। बस एक फ़ंक्शन बनाएं, और इसे फ्लास्क से इस प्रकार लिंक करें:

 import requests from bs4 import BeautifulSoup import re import pandas as pd import sqlite3 import json import openai from openai.embeddings_utils import cosine_similarity from flask import Flask, request, jsonify from flask_cors import CORS app = Flask(__name__) CORS(app) EMBEDDING_MODEL = "text-embedding-ada-002" openai.api_key = [Your OpenAI Key] db_location = [Location of your SQLite DB] def process_user_query(user_question): con = sqlite3.connect(db_location) cur = con.cursor() user_question = 'What did you say about the future of the fintech industry in summer of 2022?' res = [] for i in range(3): response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a SQL query writer that can construct queries based on incoming questions. Answer with only the SQL query."}, {"role": "user", "content": """ Suppose we have the SQLite database table called "article" with the following columns, which contains newsletter articles from a publication: name, date, idx, content, embedding_json Write a question that would retrieve the rows necessary to answer the following user question. Only filter on date. Do not filter on any other column. Make sure the query returns every row in the table by name. Reply only with the SQL query. User question: What did you say about the future of the fintech industry in summer of 2022? """}, ] ) generated_query = response.choices[0].message['content'] is_query_safe = True for no_use_word in {'DELETE', 'UPDATE', 'DROP'}: if no_use_word in generated_query.upper(): is_query_safe = False if not is_query_safe: break # the user input is likely malicious. Try to answer the question with vanilla RAG res = cur.execute(generated_query).fetchall() if len(res) > 0: break if len(res) == 0: # vanilla RAG in memory. Use a vector DB in production please. res = cur.execute('''SELECT * FROM articles''').fetchall() df = pd.DataFrame([{c[0]: v for c, v in zip(cur.description, row)} for row in res]) q_embed = openai.Embedding.create(model=EMBEDDING_MODEL, input=[user_question])['data'][0]['embedding'] df['cosine_similarity'] = df['embedding_json'].map(lambda js: cosine_similarity(json.loads(js), q_embed)) answer_prompt = ''' Consider the following newsletter excerpts from the following dates: ''' for _, row in df.sort_values('cosine_similarity', ascending=False).iloc[:10].iterrows(): answer_prompt += """ ======= Date: %s ==== %s ===================== """ % (row['date'], row['content']) answer_prompt += """ Answer the following question: %s """ % user_question response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a tech analyst that can summarize the content of newsletters"}, {"role": "user", "content": answer_prompt}, ] ) return response.choices[0].message['content'] @app.route('/process_user_question', methods=["POST"]) def process_user_question(): return jsonify({ 'status': 'success', 'result': process_user_query(request.json['user_question']) }) app.run()

और वास्तव में बैकएंड के लिए हमें बस इतना ही करना है!

फ्रंटेंड कोड

क्योंकि हमारे पास केवल एक एंडपॉइंट है और हमारे एप्लिकेशन में बहुत अधिक स्थिति की आवश्यकता नहीं है, फ्रंटएंड कोड बहुत सरल होना चाहिए। पिछले लेख में याद रखें, हमने रूटिंग के साथ एक रिएक्ट एप्लिकेशन सेट किया है जो हमें विशिष्ट मार्गों पर घटकों को प्रस्तुत करने की अनुमति देता है।

React.JS प्रोजेक्ट स्थापित करने के लिए बस उस आलेख में दिए गए निर्देशों का पालन करें, और अपनी पसंद के रूट पर निम्नलिखित घटक जोड़ें:

 import React, {useState, useEffect} from 'react'; import axios from 'axios'; const HNArticle = () => { const [result, setResult] = useState(''); const [message, setMessage] = useState(''); const [question, setQuestion] = useState(''); const askQuestion = () => { axios.post("http://127.0.0.1:5000/process_user_question", {user_question: question}) .then(r => r.data) .then(d => { console.log(d); setResult(d.result); }); } return <div className="row" style={{marginTop: '15px'}}> <div className="col-md-12" style={{marginBottom: '15px'}}> <center> <h5>Hackernoon CB Insights Demo</h5> </center> </div> <div className="col-md-10 offset-md-1 col-sm-12 col-lg-8 offset-lg-2" style={{marginBottom: '15px'}}> <ul className="list-group"> <li className="list-group-item"> <h6>Your Question</h6> <p><input className="form-control" placeholder="Question" value={question} onChange={e => setQuestion(e.target.value)} /></p> <p>{message}</p> <p> <button className="btn btn-primary" onClick={askQuestion}>Ask</button> </p> </li> {result? <li className="list-group-item"> <h6>Response</h6> {result.split("\n").map((p, i) => <p key={i}>{p}</p>)} </li>: ''} </ul> </div> </div>; } export default HNArticle;

कोड चलाएँ, और आपको इस तरह एक इंटरफ़ेस देखना चाहिए:

एक प्रश्न पूछें, और थोड़ी देर बाद, आपको आउटपुट देखना चाहिए:

और वोइला! हमने वेनिला आरएजी सिस्टम से परे उन्नत क्वेरी क्षमताओं वाला एक चैटबॉट सफलतापूर्वक बनाया है!

निष्कर्ष

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

ये विशेषज्ञ प्रणालियाँ एलएलएम अनुप्रयोगों के लिए व्यावसायिक व्यवहार्यता को अनलॉक करने की कुंजी हैं जो ओपनएआई और एंथ्रोपिक जैसे प्लेटफ़ॉर्म प्रदाताओं से सीधे उपलब्ध मूल्य से परे मूल्य प्रदान करना चाहते हैं।

कोड जनरेशन उन तकनीकों में से एक है जिसे हाल की पीढ़ी के व्यावसायिक रूप से उपलब्ध बड़े भाषा मॉडल द्वारा संभव बनाया गया है।

यदि आपके पास इस बारे में कोई विचार है कि एलएलएम का व्यावसायीकरण कैसे किया जा सकता है या आप एआई के बारे में बातचीत करना चाहते हैं, तो कृपया लिंक्डइन या गिटहब पर संपर्क करने में संकोच न करें। पिछले वर्ष के दौरान मैंने पाठकों के साथ कई ज्ञानवर्धक बातचीत की हैं और आगे भी आशा करता हूँ!