README.md

ਰੀਟਰੀਵਲ ਆਗਮੈਂਟਡ ਜੈਨਰੇਸ਼ਨ (RAG) ਅਤੇ ਵੈਕਟਰ ਡੇਟਾਬੇਸ

ਸਰਚ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ ਸੰਖੇਪ ਵਿੱਚ ਸਿੱਖਿਆ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਆਪਣੇ ਡੇਟਾ ਨੂੰ ਵੱਡੇ ਭਾਸ਼ਾ ਮਾਡਲਾਂ (LLMs) ਵਿੱਚ ਇੰਟੀਗ੍ਰੇਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਪਾਠ ਵਿੱਚ, ਅਸੀਂ ਆਪਣੇ ਡੇਟਾ ਨੂੰ ਆਪਣੇ LLM ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਜਮ੍ਹਾਂ ਕਰਨ ਦੇ ਸੰਕਲਪਾਂ, ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੀ ਮਕੈਨਿਕਸ ਅਤੇ ਡੇਟਾ ਸਟੋਰਿੰਗ ਦੇ ਤਰੀਕਿਆਂ ਨੂੰ, ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਐਂਬੈਡਿੰਗ ਅਤੇ ਟੈਕਸਟ ਦੋਵੇਂ ਸ਼ਾਮਲ ਹਨ, ਵਧੇਰੇ ਵਿਸਥਾਰ ਨਾਲ ਸਮਝਾਂਗੇ।

ਵੀਡੀਓ ਜਲਦੀ ਆ ਰਿਹਾ ਹੈ

ਪਰਿਚਯ

ਇਸ ਪਾਠ ਵਿੱਚ ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਚੀਜ਼ਾਂ ਕਵਰ ਕਰਾਂਗੇ:

• RAG ਦਾ ਪਰਿਚਯ, ਇਹ ਕੀ ਹੈ ਅਤੇ ਕਿਉਂ AI (ਕ੍ਰਿਤ੍ਰਿਮ ਬੁੱਧੀ) ਵਿੱਚ ਇਸਦਾ ਪ੍ਰਯੋਗ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

• ਸਮਝਣਾ ਕਿ ਵੈਕਟਰ ਡੇਟਾਬੇਸ ਕੀ ਹੁੰਦੇ ਹਨ ਅਤੇ ਸਾਡੇ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਬਣਾਉਣਾ।

• RAG ਨੂੰ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਇੰਟੀਗ੍ਰੇਟ ਕਰਨ ਦਾ ਪ੍ਰਯੋਗਤਮ ਭੂਤ ਪਾਠ।

ਸਿੱਖਣ ਦੇ ਲਕੜੀ

ਇਸ ਪਾਠ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਦ, ਤੁਸੀਂ ਯੋਗ ਹੋਵੋਗੇ:

• ਡੇਟਾ ਰੀਟਰੀਵਲ ਅਤੇ ਪ੍ਰੋਸੈਸਿੰਗ ਵਿੱਚ RAG ਦੇ ਮਹੱਤਵ ਨੂੰ ਸਮਝਾਉਣਾ।

• RAG ਐਪਲੀਕੇਸ਼ਨ ਸੈਟਅਪ ਕਰਕੇ ਆਪਣੇ ਡੇਟਾ ਨੂੰ LLM ਨਾਲ ਜਮ੍ਹਾਂ ਕਰਨਾ।

• LLM ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ RAG ਅਤੇ ਵੈਕਟਰ ਡੇਟਾਬੇਸ ਦੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਇੰਟੀਗ੍ਰੇਸ਼ਨ।

ਸਾਡਾ ਦ੍ਰਿਸ਼ਟਾਂਤ: ਆਪਣੇ LLM ਨੂੰ ਆਪਣੇ ਡੇਟਾ ਨਾਲ ਸੰਵਾਰਨਾ

ਇਸ ਪਾਠ ਲਈ, ਅਸੀਂ ਆਪਣੀਆਂ ਆਪਣੀਆਂ ਨੋਟਾਂ ਸਿੱਖਿਆ ਸਟਾਰਟਅਪ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਜੋ ਚੈਟਬੋਟ ਨੂੰ ਵੱਖ-ਵੱਖ ਵਿਸ਼ਿਆਂ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਦੇਣੀ ਆਸਾਨ ਕਰਦਾ ਹੈ। ਜਿਹੜੀਆਂ ਨੋਟਾਂ ਸਾਡੇ ਕੋਲ ਹਨ, ਉਨ੍ਹਾਂ ਨਾਲ ਸਿੱਖਣ ਵਾਲੇ ਵਧੀਆ ਅਧਿਐਨ ਕਰ ਸਕਣਗੇ ਅਤੇ ਵੱਖ-ਵੱਖ ਵਿਸ਼ਿਆਂ ਨੂੰ ਸਮਝ ਸਕਣਗੇ, ਜਿਸ ਨਾਲ ਉਹਨਾਂ ਦੇ ਪ੍ਰੀਖਿਆ ਲਈ ਦੁਹਰਾਉਣਾ ਆਸਾਨ ਹੋਵੇਗਾ। ਆਪਣਾ ਦ੍ਰਿਸ਼ਟਾਂਤ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਇਹ ਵਰਤਾਂਗੇ:

• Azure OpenAI: LLM ਜਿਸ ਨਾਲ ਅਸੀਂ ਆਪਣਾ ਚੈਟਬੋਟ ਬਣਾਵਾਂਗੇ

• AI for beginners' lesson on Neural Networks: ਇਹ ਉਹ ਡੇਟਾ ਹੈ ਜਿਸ 'ਤੇ ਅਸੀਂ ਆਪਣੇ LLM ਨੂੰ ਜਮ੍ਹਾਂ ਕਰਾਂਗੇ

• Azure AI Search ਅਤੇ Azure Cosmos DB: ਵੈਕਟਰ ਡੇਟਾਬੇਸ ਸਾਡੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਅਤੇ ਖੋਜ ਸੂਚਕ ਬਣਾਉਣ ਲਈ

ਉਪਭੋਗਤਾ ਆਪਣੀਆਂ ਨੋਟਾਂ ਤੋਂ ਅਭਿਆਸ ਪ੍ਰਸ਼ਨਾਵਲੀ, ਦੁਹਰਾਈ ਫਲੈਸ਼ ਕਾਰਡ ਅਤੇ ਸੰਖਿਪਤ ਓਵਰਵਿਊਜ਼ ਤਿਆਰ ਕਰ ਸਕਣਗੇ। ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਆਓ ਦੇਖੀਏ ਕਿ RAG ਕੀ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:

ਰੀਟਰੀਵਲ ਆਗਮੈਂਟਡ ਜੈਨਰੇਸ਼ਨ (RAG)

ਇੱਕ LLM ਪਾਵਰਡ ਚੈਟਬੋਟ ਯੂਜ਼ਰ ਪ੍ਰਾਂਪਟਾਂ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਕਰਕੇ ਜਵਾਬ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਇਹ ਇੰਟਰਐਕਟਿਵ ਬਣਾਉਣ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਵੱਖ-ਵੱਖ ਵਿਸ਼ਿਆਂ ਤੇ ਯੂਜ਼ਰਾਂ ਨਾਲ ਗੱਲਬਾਤ ਕਰਦਾ ਹੈ। ਪਰੰਤੂ, ਇਸਦੇ ਜਵਾਬ ਸਿਰਫ਼ ਦਿੱਤੇ ਗਏ ਸੰਦਰਭ ਅਤੇ ਇਸਦੀ ਅਧਾਰਭੂਤ ਟ੍ਰੇਨਿੰਗ ਡੇਟਾ ਤੱਕ ਸੀਮਿਤ ਹੁੰਦੇ ਹਨ। ਉਦਾਹਰਣ ਲਈ, GPT-4 ਦੀ ਜਾਣਕਾਰੀ ਕੱਟ-ਆਫ਼ ਸਤੰਬਰ 2021 ਹੈ, ਇਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਇਸ ਨੂੰ ਉਸ ਸਮੇਂ ਤੋਂ ਬਾਅਦ ਘਟਨਾਵਾਂ ਦੀ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੁੰਦੀ। ਜਦੋਂ ਕਿ LLM ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਲਈ ਵਰਤੇ ਗਏ ਡੇਟਾ ਵਿੱਚ ਨਿਜੀ ਨੋਟਾਂ ਜਾਂ ਕੰਪਨੀ ਦੇ ਪ੍ਰੋਡਕਟ ਮੈਨੂਅਲ ਵਰਗੀਆਂ ਗੁਪਤ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦੀ।

RAG ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ

ਮਾਨ ਲਓ ਤੁਸੀਂ ਇੱਕ ਐਸਾ ਚੈਟਬੋਟ ਡਿਪਲੋਇ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਤੁਹਾਡੀਆਂ ਨੋਟਾਂ ਤੋਂ ਪ੍ਰਸ਼ਨਾਵਲੀ ਬਣਾਵੇ, ਤਾਂ ਤੁਹਾਨੂੰ ਗਿਆਨ ਬੇਸ ਨਾਲ ਕਨੈਕਸ਼ਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਇੱਥੇ RAG ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ। RAG ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ:

• ਗਿਆਨ ਬੇਸ: ਰੀਟਰੀਵਲ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਦਸਤਾਵੇਜ਼ ਇੰਜੈਸਟ ਅਤੇ ਪ੍ਰੀਪ੍ਰੋਸੈਸ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ, ਆਮ ਤੌਰ 'ਤੇ ਵੱਡੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਛੋਟੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਭੰਗ ਕਰਨਾ, ਉਨ੍ਹਾਂ ਨੂੰ ਟੈਕਸਟ ਐਂਬੈਡਿੰਗ ਵਿੱਚ ਬਦਲਣਾ ਅਤੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕਰਨਾ।

• ਯੂਜ਼ਰ ਦਾ ਪ੍ਰਸ਼ਨ: ਯੂਜ਼ਰ ਸਵਾਲ ਪੁੱਛਦਾ ਹੈ

• ਰੀਟਰੀਵਲ: ਜਦੋਂ ਯੂਜ਼ਰ ਸਵਾਲ ਕਰਦਾ ਹੈ, ਤਦ ਐਂਬੈਡਿੰਗ ਮਾਡਲ ਸਾਡੇ ਗਿਆਨ ਬੇਸ ਵਿੱਚੋਂ ਸੰਬੰਧਤ ਜਾਣਕਾਰੀ ਲੱਭਦਾ ਹੈ ਤਾਂ ਜੋ ਹੋਰ ਸੰਦਰਭ ਪ੍ਰਾਂਪਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾ ਸਕੇ।

• ਆਗਮੈਂਟਡ ਜੈਨਰੇਸ਼ਨ: LLM ਆਪਣੇ ਜਵਾਬ ਨੂੰ ਉਸ ਡੇਟਾ ਦੇ ਆਧਾਰ 'ਤੇ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਜਾਂਚ ਪ੍ਰੀ-ਟ੍ਰੇਨਡ ਡੇਟਾ ਤੱਕ ਸੀਮਿਤ ਨਹੀਂ, ਬਲਕਿ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਸੰਦਰਭ ਤੋਂ ਵੀ ਵਿੱਚ ਜਾਣਕਾਰੀ ਲੈ ਕੇ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। LLM ਫਿਰ ਯੂਜ਼ਰ ਦੇ ਸਵਾਲ ਦਾ ਉੱਤਰ ਦਿੰਦਾ ਹੈ।

RAG ਦਾ ਆਰਕੀਟੈਕਚਰ ਟ੍ਰਾਂਸਫਾਰਮਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੋ ਦੋ ਭਾਗਾਂ ਤੋਂ ਬਣਿਆ ਹੁੰਦਾ ਹੈ: ਇੱਕ ਇੰਕੋਡਰ ਅਤੇ ਇੱਕ ਡੀਕੋਡਰ। ਉਦਾਹਰਣ ਲਈ, ਜਦੋਂ ਯੂਜ਼ਰ ਸਵਾਲ ਕਰਦਾ ਹੈ, ਤਦ ਇਨਪੁੱਟ ਟੈਕਸਟ ਨੂੰ ਸ਼ਬਦਾਂ ਦੇ ਅਰਥ ਸਮਝਾਉਂਦੇ ਵੈਕਟਰਾਂ ਵਿੱਚ 'ਇੰਕੋਡ' ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਆਉਟਪੁੱਟ ਬਣਾਉਣ ਲਈ ਇਹ ਵੈਕਟਰ 'ਡੀਕੋਡ' ਕੀਤੇ ਜਾਂਦੇ ਹਨ। LLM ਦੋਹਾਂ ਇੰਕੋਡਰ-ਡੀਕੋਡਰ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਤੀਜਾ ਤਿਆਰ ਕਰਦਾ ਹੈ।

ਪੇਪਰ Retrieval-Augmented Generation for Knowledge intensive NLP (natural language processing software) Tasks ਮੁਤਾਬਕ RAG ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ:

• RAG-Sequence ਰੀਟਰੀਵਡ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਯੂਜ਼ਰ ਸਵਾਲ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਉੱਤਰ ਪੇਸ਼ ਕਰਨਾ

• RAG-Token ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਗਲਾ ਟੌਕਨ ਜਨਰੇਟ ਕਰਨਾ, ਫਿਰ ਉਨ੍ਹਾਂ ਨੂੰ ਲੱਭ ਕੇ ਯੂਜ਼ਰ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦੇਣਾ

RAG ਕਿਉਂ ਵਰਤਿਆ ਜਾਵੇ?

• ਜਾਣਕਾਰੀ ਦੀ ਸਮృద్ధਤਾ: ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਟੈਕਸਟ ਜਵਾਬ ਅਪ-ਟੂ-ਡੇਟ ਤੇ ਮੌਜੂਦਾ ਹਨ। ਇਸ ਨਾਲ ਖੇਤਰ-ਵਿਸ਼ੇਸ਼ ਕਾਰਜਾਂ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਨ ਵਧਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਅੰਦਰੂਨੀ ਗਿਆਨ ਬੇਸ ਤੱਕ ਪਹੁੰਚ ਕਰਦਾ ਹੈ।

• ਸਹੀ ਜਾਣਕਾਰੀ ਦਿੰਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਗਿਆਨ ਬੇਸ ਵਿੱਚ ਮੌਜੂਦ ਸੱਚੀ ਜਾਣਕਾਰੀ ਨੂੰ ਵਰਤਦਾ ਹੈ ਜੋ ਯੂਜ਼ਰ ਪ੍ਰਸ਼ਨਾਂ ਨੂੰ ਸੰਦਰਭ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ।

• ਇਹ ਲਾਗਤ-ਕੁਸ਼ਲ ਹੈ ਕਿਉਂਕਿ ਇਹ ਇੱਕ LLM ਨੂੰ ਸੁਧਾਰ ਕਰਨ ਨਾਲੋਂ ਕਾਫ਼ੀ ਸਸਤਾ ਹੈ।

ਗਿਆਨ ਬੇਸ ਬਣਾਉਣਾ

ਸਾਡਾ ਐਪਲੀਕੇਸ਼ਨ ਸਾਡੇ ਨਿੱਜੀ ਡੇਟਾ ਤੇ ਆਧਾਰਿਤ ਹੈ, ਜਿਵੇਂ ਕਿ AI For Beginners ਕਾਰਜਕ੍ਰਮ ਵਿੱਚ Neural Network ਪਾਠ।

ਵੈਕਟਰ ਡੇਟਾਬੇਸ

ਵੈਕਟਰ ਡੇਟਾਬੇਸ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਡੇਟਾਬੇਸ ਹੈ ਜੋ ਐਂਬੈੱਡ ਕੀਤੇ ਵੈਕਟਰਾਂ ਨੂੰ ਸਟੋਰ, ਪ੍ਰਬੰਧਿਤ ਅਤੇ ਖੋਜ ਕਰਨ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਜੀਹੜਾ ਸੰਖਿਆਤਮਕ ਪ੍ਰਤੀਨਿਧਤਾਵਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਡੇਟਾ ਨੂੰ ਸਾਂਖਿਆਤਮਕ ਐਂਬੈਡਿੰਗਜ਼ ਵਿੱਚ ਤੋੜ ਦੇਣ ਨਾਲ ਸਾਡੀ AI ਪ੍ਰਣਾਲੀ ਲਈ ਡੇਟਾ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ।

ਅਸੀਂ ਆਪਣੇ ਐਂਬੈਡਿੰਗਜ਼ ਨੂੰ ਵੈਕਟਰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕਰਦੇ ਹਾਂ ਕਿਉਂਕਿ LLMs ਨੂੰ ਇਨਪੁੱਟ ਵਜੋਂ ਲਈ ਜਾ ਸਕਣ ਵਾਲੇ ਟੋਕਨਾਂ ਦੀ ਸੰਜਮ ਸੀਮਾ ਹੁੰਦੀ ਹੈ। ਚੁੱਕੇ ਹੋਏ ਹਿੱਸਿਆਂ ਨੂੰ ਹੀ LLM ਵਿੱਚ ਪਾਸ ਕਰਨ ਦੇ ਬਦਲੇ, ਸਿੱਧਾ ਪੂਰੇ ਐਂਬੈਡਿੰਗਜ਼ ਨੂੰ ਨਹੀਂ ਦੇ ਸਕਦੇ। ਇਸ ਲਈ, ਹਿੱਸਿਆਂ ਵਿੱਚ ਭੇਜਣਾ ਪੈਂਦਾ ਹੈ ਅਤੇ ਜਦੋਂ ਯੂਜ਼ਰ ਸਵਾਲ ਪੂੱਛਦਾ ਹੈ, ਤਾਂ ਸਭ ਤੋਂ ਹੋਂਦ ਵਾਲੇ ਐਂਬੈਡਿੰਗਜ਼ ਪ੍ਰੋਂਪਟ ਨਾਲ ਵਾਪਸ ਕਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ। ਹਿੱਸਿਆਂ ‘ਚ ਵੰਡਣਾ ਲਾਗਤ ਵੀ ਘਟਾਉਂਦਾ ਹੈ ਕਿਉਂਕਿ ਟੋਕਨਾਂ ਦੀ ਗਿਣਤੀ ਵੀ ਘਟ ਜਾਂਦੀ ਹੈ।

ਕੁਝ ਲੋਕਪ੍ਰਿਯ ਵੈਕਟਰ ਡੇਟਾਬੇਸਾਂ ਵਿੱਚ Azure Cosmos DB, Clarifyai, Pinecone, Chromadb, ScaNN, Qdrant ਅਤੇ DeepLake ਸ਼ਾਮਲ ਹਨ। ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ Azure CLI ਦੇ ਮਾਧਿਅਮ ਨਾਲ Azure Cosmos DB ਮਾਡਲ ਬਣਾ ਸਕਦੇ ਹੋ:

az login
az group create -n <resource-group-name> -l <location>
az cosmosdb create -n <cosmos-db-name> -r <resource-group-name>
az cosmosdb list-keys -n <cosmos-db-name> -g <resource-group-name>

ਟੈਕਸਟ ਤੋਂ ਐਂਬੈਡਿੰਗਜ਼ ਤੱਕ

ਡੇਟਾ ਸਟੋਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਇਸ ਨੂੰ ਵੈਕਟਰ ਐਂਬੈਡਿੰਗਜ਼ ਵਿੱਚ ਬਦਲਣਾ ਪੈਂਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਵੱਡੇ ਦਸਤਾਵੇਜ਼ ਜਾਂ ਲੰਮੇ ਲਿਖਤ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਨ੍ਹਾਂ ਨੂੰ ਉਮੀਦਦੇ ਗਏ ਸਵਾਲਾਂ ਅਨੁਸਾਰ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡ ਸਕਦੇ ਹੋ। ਵੰਡ ਕਰਨਾ ਸੈਂਟੈਂਸ ਦੇ ਪੱਧਰ ਤੇ ਜਾਂ ਪੈਰਾ ਗ੍ਰਾਫ ਦੇ ਪੱਧਰ ਤੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਕਿਉਂਕਿ ਹਿੱਸਿਆਂ ਦੇ ਅਰਥ ਦੱਸਣ ਲਈ ਉਨ੍ਹਾਂ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਦੇ ਸ਼ਬਦਾਂ ਤੋਂ ਮੱਦਦ ਲਈ ਜਾਂਦੀ ਹੈ, ਤੁਸੀਂ ਕਿਸੇ ਹਿੱਸੇ ਵਿੱਚ ਹੋਰ ਸੰਦਰਭ ਵੀ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਦਸਤਾਵੇਜ਼ ਦਾ ਸਿਰਲੇਖ ਜਾਂ ਹਿੱਸੇ ਦੇ ਪਹਿਲਾਂ ਜਾਂ ਬਾਅਦ ਕੁਝ ਟੈਕਸਟ। ਤੁਸੀਂ ਡੇਟਾ ਵੰਡਣ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਤਰੀਕਾ ਵਰਤ ਸਕਦੇ ਹੋ:

def split_text(text, max_length, min_length):
    words = text.split()
    chunks = []
    current_chunk = []

    for word in words:
        current_chunk.append(word)
        if len(' '.join(current_chunk)) < max_length and len(' '.join(current_chunk)) > min_length:
            chunks.append(' '.join(current_chunk))
            current_chunk = []

    # ਜੇ ਆਖਰੀ ਹਿੱਸਾ ਘੱਟੋ ਘੱਟ ਲੰਬਾਈ تک नहीं ਪਹੁੰਚਿਆ, ਤਾਂ ਵੀ ਇਸਨੂੰ ਸ਼ਾਮਲ ਕਰੋ
    if current_chunk:
        chunks.append(' '.join(current_chunk))

    return chunks

ਇਕ ਵਾਰੀ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਣ ਮਗਰੋਂ, ਅਸੀਂ ਵੱਖ-ਵੱਖ ਐਂਬੈਡਿੰਗ ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਟੈਕਸਟ ਨੂੰ ਐਂਬੈਡ ਕਰ ਸਕਦੇ ਹਾਂ। ਕੁਝ ਮਾਡਲਾਂ ਹਨ: word2vec, OpenAI ਦਾ ada-002, Azure Computer Vision ਅਤੇ ਹੋਰ ਕਈ। ਮਾਡਲ ਚੁਣਨਾ ਇਹਨਾਂ ਗੱਲਾਂ ‘ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿਹੜੀ ਭਾਸ਼ਾ ਵਰਤ ਰਹੇ ਹੋ, ਸੰਕੋਚਿਤ ਸਮੱਗਰੀ ਦੀ ਕਿਸਮ (ਟੈਕਸਟ/ਚਿੱਤਰ/ਆਡੀਓ), ਕਿੰਨੀ ਲੰਮੀ ਇਨਪੁੱਟ ਐਨਕੋਡ ਕਰ ਸਕਦਾ ਹੈ ਤੇ ਐਂਬੈਡਿੰਗ ਆਉਟਪੁੱਟ ਦੀ ਲੰਬਾਈ।

OpenAI ਦੇ text-embedding-ada-002 ਮਾਡਲ ਨਾਲ ਐਂਬੈਡ ਕੀਤੇ ਟੈਕਸਟ ਦਾ ਉਦਾਹਰਣ:

ਰੀਟਰੀਵਲ ਅਤੇ ਵੈਕਟਰ ਸਰਚ

ਜਦੋਂ ਯੂਜ਼ਰ ਪ੍ਰਸ਼ਨ ਕਰਦਾ ਹੈ, ਤਦ ਰੀਟਰੀਵਰ ਇਸਨੂੰ ਕਵੇਰੀ ਇੰਕੋਡਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵੈਕਟਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਅਤੇ ਫਿਰ ਸਾਡੇ ਦਸਤਾਵੇਜ਼ ਖੋਜ ਸੂਚਕ ਵਿੱਚੋਂ ਇਨਪੁੱਟ ਨਾਲ ਸਬੰਧਤ ਵੈਕਟਰ ਲੱਭਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ ਇਹ ਇਨਪੁੱਟ ਵੈਕਟਰ ਅਤੇ ਦਸਤਾਵੇਜ਼ ਵੈਕਟਰਾਂ ਨੂੰ ਟੈਕਸਟ ਵਿੱਚ ਬਦਲ ਕੇ LLM ਨੂੰ ਭੇਜਦਾ ਹੈ।

ਰੀਟਰੀਵਲ

ਰੀਟਰੀਵਲ ਉਸ ਸਮੇਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਪ੍ਰਣਾਲੀ ਤੇਜ਼ੀ ਨਾਲ ਸੂਚਕ ਵਿੱਚੋਂ ਉਹ ਦਸਤਾਵੇਜ਼ ਲੱਭਦੀ ਹੈ ਜੋ ਖੋਜ ਨਿਯਮਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ। ਰੀਟਰੀਵਰ ਦਾ ਮਕਸਦ ਹੈ ਅਜਿਹੇ ਦਸਤਾਵੇਜ਼ ਲੱਭਣਾ ਜੋ ਸੰਦਰਭ ਦਿਉਂਦੇ ਹੋਣ ਅਤੇ LLM ਨੂੰ ਤੁਹਾਡੇ ਡੇਟਾ 'ਤੇ ਜਮ੍ਹਾਂ ਕਰਦੇ ਹੋਣ।

ਸਾਡੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਖੋਜ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ ਜਿਵੇਂ:

• ਕੀਵਰਡ ਖੋਜ - ਟੈਕਸਟ ਖੋਜ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ

• ਵੈਕਟਰ ਖੋਜ - ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਟੈਕਸਟ ਤੋਂ ਵੈਕਟਰ ਪ੍ਰਤੀਨਿਧਿਤਾਵਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਜੋ ਸ਼ਬਦਾਂ ਦੇ ਅਰਥ ਦੇ ਆਧਾਰ 'ਤੇ ਸੈਮਾਂਟਿਕ ਖੋਜ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ। ਖੋਜ ਉਹਨਾਂ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਪੁੱਛੇਗੀ ਜਿਨ੍ਹਾਂ ਦੇ ਵੈਕਟਰ ਪ੍ਰਤੀਨਿਧਿਤਾਵਾਂ ਸਵਾਲ ਦੇ ਸਭ ਤੋਂ ਨੇੜਲੇ ਹਨ।

• ਹਾਈਬ੍ਰਿਡ - ਕੀਵਰਡ ਅਤੇ ਵੈਕਟਰ ਖੋਜ ਦਾ ਮੇਲ।

ਰੀਟਰੀਵਲ ਵਿੱਚ ਇੱਕ ਮੁਸ਼ਕਲ ਇਹ ਹੈ ਕਿ ਜੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਪ੍ਰਸ਼ਨ ਦੇ ਸਮਰੂਪ ਕੋਈ ਜਵਾਬ ਨਹੀਂ, ਤਾਂ ਪ੍ਰਣਾਲੀ ਸਭ ਤੋਂ ਵਧੀਆ ਜਾਣਕਾਰੀ ਵਾਪਸ ਕਰਦੀ ਹੈ। ਤੁਸੀਂ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਸੰਬੰਧਿਤ ਜਾਣਕਾਰੀ ਲਈ ਲਈ ਸਭ ਤੋਂ ਵੱਧ ਦੂਰੀ ਸੀਮਾ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਕੀਵਰਡ ਅਤੇ ਵੈਕਟਰ ਖੋਜ ਦਾ ਹਾਈਬ੍ਰਿਡ ਵਰਤ ਸਕਦੇ ਹੋ। ਇਸ ਪਾਠ ਵਿੱਚ ਅਸੀਂ ਹਾਈਬ੍ਰਿਡ ਖੋਜ ਵਰਤਾਂਗੇ, ਜਿਹੜਾ ਦੋਨੀਂ ਖੋਜਾਂ ਦਾ ਮਿਲਾਪ ਹੈ। ਅਸੀਂ ਆਪਣੇ ਡੇਟਾ ਨੂੰ ਇੱਕ ਡੇਟਾ ਫਰੇਮ ਵਿੱਚ ਸਟੋਰ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਹਿੱਸੇ ਅਤੇ ਐਂਬੈਡਿੰਗਜ਼ ਵਾਲੇ ਕਾਲਮ ਹੋਣਗੇ।

ਵੈਕਟਰ ਸਮਾਨਤਾ

ਰੀਟਰੀਵਰ ਗਿਆਨ ਬੇਸ ਵਿੱਚੋਂ ਉਹ ਐਂਬੈਡਿੰਗਜ਼ ਲੱਭਦਾ ਹੈ ਜੋ ਇੱਕ-ਦੂਜੇ ਦੇ ਨੇੜੇ ਹਨ, ਸਭ ਤੋਂ ਨੇੜਲਾ ਇਕ ਸਾਂਝਾ ਵਿਸ਼ਯਾਂ ਵਾਲਾ ਸੰਦਰਭ ਹੁੰਦਾ ਹੈ। ਜਦੋਂ ਯੂਜ਼ਰ ਪ੍ਰਸ਼ਨ ਕਰਦਾ ਹੈ, ਤਦ ਪਹਿਲਾਂ ਉਹ ਪ੍ਰਸੰਗ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਸਮਾਨ ਐਂਬੈਡਿੰਗਜ਼ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਵੈਕਟਰਾਂ ਦੀ ਸਮਾਨਤਾ ਮਾਪਣ ਲਈ ਆਮ ਤੌਰ 'ਤੇ ਕੋਜ਼ਾਈਨ ਸਮਾਨਤਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਦੋ ਵੈਕਟਰਾਂ ਵਿਚਕਾਰ ਕੋਣ ‘ਤੇ ਆਧਾਰਿਤ ਹੈ।

ਹੋਰ ਬਦਲੀਆਂ ਸਮਾਨਤਾ ਮਾਪਣ ਲਈ ਜੋ ਵਰਤੀ ਜਾ ਸਕਦੀਆਂ ਹਨ, ਉਹ ਹਨ ਯੂਕਲੀਡੀਅਨ ਦੂਰੀ (ਦੋ ਵੈਕਟਰ ਸੰਕੇਤਕ ਅੰਤਰ ਦੇ ਦਰਮਿਆਨ ਸਿੱਧੀ ਲਾਈਨ) ਅਤੇ ਡਾਟ ਪ੍ਰੋਡਕਟ (ਦੋ ਵੈਕਟਰਾਂ ਦੇ ਤਤਵਾਂ ਦੇ ਉਤਪਾਦਾਂ ਦਾ ਜੋੜ)।

ਖੋਜ ਸੂਚਕ

ਰੀਟਰੀਵਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਡੇ ਗਿਆਨ ਬੇਸ ਲਈ ਇੱਕ ਖੋਜ ਸੂਚਕ ਬਣਾਉਣਾ ਲਾਜ਼ਮੀ ਹੈ। ਸੂਚਕ ਸਾਡੇ ਐਂਬੈਡਿੰਗਜ਼ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ ਅਤੇ ਵੱਡੇ ਡੇਟਾਬੇਸ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਸਮਾਨ ਹਿੱਸਿਆਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਬੁਲਾਉਂਦਾ ਹੈ। ਅਸੀਂ ਆਪਣਾ ਸੂਚਕ ਲੋਕਲੀ ਹੇਠਾਂ ਦਿੱਤੇ ਕਮਾਂਡ ਨਾਲ ਬਣਾ ਸਕਦੇ ਹਾਂ:

from sklearn.neighbors import NearestNeighbors

embeddings = flattened_df['embeddings'].to_list()

# ਖੋਜ ਇੰਡੈਕਸ ਬਣਾਓ
nbrs = NearestNeighbors(n_neighbors=5, algorithm='ball_tree').fit(embeddings)

# ਇੰਡੈਕਸ ਨਾਲ ਪੁੱਛਤਾਛ ਕਰਨ ਲਈ, ਤੁਸੀਂ kneighbors ਮੈਥਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ
distances, indices = nbrs.kneighbors(embeddings)

ਰੀ-ਰੈਂਕਿੰਗ

ਜਦ ਤੂੰ ਡੇਟਾਬੇਸ ਨੂੰ ਕਵੇਰੀ ਕਰ ਲੈਂਦਾ ਹੈਂ, ਤਾਂ ਹਾਲਾਤ ਵਧੀਆ ਤੋਂ ਸਭ ਤੋਂ ਸੰਬੰਧਿਤ ਨਤੀਜੇ ਦਰਸਾਉਣ ਲਈ ਬਦਲਾਅ ਲਿਆਉਣਾ ਪੈਂਦਾ ਹੈ। ਇੱਕ ਰੀ-ਰੈਂਕਿੰਗ LLM ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦਾ ਉਪਯੋਗ ਕਰਕੇ ਖੋਜ ਨਤੀਜਿਆਂ ਨੂੰ ਸਭ ਤੋਂ ਸੰਬੰਧਿਤ ਤੋਂ ਘੱਟ ਸੰਬੰਧਿਤ ਕ੍ਰਮ ਵਿੱਚ ਵੱਖ ਕਰਦਾ ਹੈ। Azure AI Search ਵਿੱਚ, ਇਹ ਸੰਸਥਾ ਸਵੈਚਾਲਿਤ ਤਰੀਕੇ ਨਾਲ ਸੈਮਾਂਟਿਕ ਰੀ-ਰੈਂਕਰ ਦੁਆਰਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਨੇੜਲੇ ਪੜੋਸੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰੀ-ਰੈਂਕਿੰਗ ਕਿਵੇਂ ਹੁੰਦੀ ਹੈ ਦਾ ਉਦਾਹਰਣ:

# ਸਭ ਤੋਂ ਮਿਲਦੇ-ਜੁਲਦੇ ਦਸਤਾਵੇਜ਼ ਲੱਭੋ
distances, indices = nbrs.kneighbors([query_vector])

index = []
# ਸਭ ਤੋਂ ਮਿਲਦੇ-ਜੁਲਦੇ ਦਸਤਾਵੇਜ਼ ਛਾਪੋ
for i in range(3):
    index = indices[0][i]
    for index in indices[0]:
        print(flattened_df['chunks'].iloc[index])
        print(flattened_df['path'].iloc[index])
        print(flattened_df['distances'].iloc[index])
    else:
        print(f"Index {index} not found in DataFrame")

ਸਭ ਕੁਝ ਇਕੱਠਾ ਕਰਨਾ

ਆਖਰੀ ਕਦਮ ਹੈ ਆਪਣੇ LLM ਨੂੰ ਇਸ ਪ੍ਰਕਿਰਿਆ ‘ਚ ਸ਼ਾਮਲ ਕਰਨਾ ਤਾਂ ਜੋ ਜਵਾਬ ਸਾਡੇ ਡੇਟਾ ਉੱਤੇ ਅਧਾਰਿਤ ਹੋਣ। ਅਸੀਂ ਇਸਨੂੰ ਐਸਾ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਾਂ:

user_input = "what is a perceptron?"

def chatbot(user_input):
    # ਸਵਾਲ ਨੂੰ ਇੱਕ ਪੁੱਛਗਿੱਛ ਵੇਕਟਰ ਵਿੱਚ ਬਦਲੋ
    query_vector = create_embeddings(user_input)

    # ਸਭ ਤੋਂ ਮਿਲਦੇ ਜੁਲਦੇ ਦਸਤਾਵੇਜ਼ ਲੱਭੋ
    distances, indices = nbrs.kneighbors([query_vector])

    # ਸੰਦੇਸ਼ਤ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਪੁੱਛਗਿੱਛ ਵਿੱਚ ਸ਼ਾਮਿਲ ਕਰੋ
    history = []
    for index in indices[0]:
        history.append(flattened_df['chunks'].iloc[index])

    # ਇਤਿਹਾਸ ਅਤੇ ਉਪਭੋਗਤਾ ਦੀ ਇਨਪੁਟ ਨੂੰ ਜੋੜੋ
    history.append(user_input)

    # ਇੱਕ ਸੁਨੇਹਾ ਵਸਤੂ ਬਣਾਓ
    messages=[
        {"role": "system", "content": "You are an AI assistant that helps with AI questions."},
        {"role": "user", "content": "\n\n".join(history) }
    ]

    # ਪ੍ਰਤੀਕਰਮ ਬਣਾਉਣ ਲਈ ਚੈਟ ਸਹਾਇਤਾ ਪ੍ਰਯੋਗ ਕਰੋ
    response = openai.chat.completions.create(
        model="gpt-4",
        temperature=0.7,
        max_tokens=800,
        messages=messages
    )

    return response.choices[0].message

chatbot(user_input)

ਸਾਡਾ ਐਪਲੀਕੇਸ਼ਨ ਮੁਲਾਂਕਣ ਕਰਨਾ

ਮੁਲਾਂਕਣ ਮਾਪਦੰਡ

• ਪ੍ਰਦੱਤ ਜਵਾਬਾਂ ਦੀ ਗੁਣਵੱਤਾ ਜਿਸਦਾ ਸੁਭਾਵਿਕ, ਸੁਚਾਰੂ ਅਤੇ ਮਨੁੱਖੀ-ਜਿਹਾ ਲੱਗਣਾ

• ਡੇਟਾ ਦੀ ਜਮੀਨੀ ਸਥਿਤੀ: ਮੁਲਾਂਕਣ ਕਿ ਕੀ ਜਵਾਬ ਦਿੱਤੇ ਗਏ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਆਇਆ ਹੈ

• ਸੰਬੰਧਿਤਤਾ: ਮੁਲਾਂਕਣ ਕਿ ਜਵਾਬ ਸਵਾਲ ਦੇ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ

• ਵਾਗਮਿਤਾ - ਕਿ ਜਵਾਬ ਵਿਆਕਰਣਕ ਤੌਰ ਤੇ ਸਹੀ ਹੈ ਜਾਂ ਨਹੀਂ

RAG ਅਤੇ ਵੈਕਟਰ ਡੇਟਾਬੇਸ ਦੇ ਵਰਤੋ ਆਪ੍ਰਯੋਗ

ਕਈ ਵੱਖਰੇ ਵਰਤੋ ਦੇ ਮਾਮਲੇ ਹਨ ਜਿੱਥੇ ਫੰਕਸ਼ਨ ਕਾਲ ਤੁਹਾਡੇ ਐਪ ਨੂੰ ਸੁਧਾਰ ਸਕਦੇ ਹਨ, ਜਿਵੇਂ:

• ਪ੍ਰਸ਼ਨ-ਉੱਤਰ: ਕੰਪਨੀ ਦੇ ਡੇਟਾ ਨੂੰ ਚੈਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਕੇ ਕਰਮਚਾਰੀਆਂ ਲਈ ਸਵਾਲ ਪੁੱਛਣ ਯੋਗ ਬਣਾਉਣਾ।

• ਸਿਫਾਰਸ਼ ਪ੍ਰਣਾਲੀਆਂ: ਜਿੱਥੇ ਤੁਸੀਂ ਇੱਕ ਪ੍ਰਣਾਲੀ ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ ਸਭ ਤੋਂ ਸਮਾਨ ਮੁੱਲਾਂ ਦਾ ਮੇਲ ਕਰੇ, ਜਿਵੇਂ ਫਿਲਮਾਂ, ਰੈਸਟੋਰੈਂਟ ਅਤੇ ਹੋਰ।

• ਚੈਟਬੋਟ ਸੇਵਾਵਾਂ: ਤੁਸੀਂ ਚੈਟ ਇਤਿਹਾਸ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਯੂਜ਼ਰ ਡੇਟਾ ਦੇ ਆਧਾਰ ‘ਤੇ ਗੱਲਬਾਤ ਨਿੱਜੀ ਬਣਾਈ ਜਾ ਸਕਦੀ ਹੈ।

• ਚਿੱਤਰ ਖੋਜ ਜੋ ਵੈਕਟਰ ਐਂਬੈਡਿੰਗ ਤੇ ਆਧਾਰਿਤ ਹੈ, ਜਦੋਂ ਤਸਵੀਰਾਂ ਦੀ ਪਛਾਣ ਅਤੇ ਵਿਸੰਗਤੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ।

ਸਾਰ

ਅਸੀਂ RAG ਦੇ ਮੁੱਖ ਖੇਤਰਾਂ ਨੂੰ ਕਵਰ ਕੀਤਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਅਪਣੇ ਡੇਟਾ ਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ, ਯੂਜ਼ਰ ਦਾ ਕਵੇਰੀ ਅਤੇ ਆਉਟਪੁੱਟ ਸ਼ਾਮਲ ਹਨ। RAG ਬਣਾਉਣ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਲਈ, ਤੁਸੀਂ Semantic Kernel, Langchain ਜਾਂ Autogen ਵਰਗੇ ਫਰੇਮਵਰਕ ਵਰਤ ਸਕਦੇ ਹੋ।

ਅਸਾਇਨਮੈਂਟ

ਰੀਟਰੀਵਲ ਆਗਮੈਂਟਡ ਜੈਨਰੇਸ਼ਨ (RAG) ਸਿੱਖਣ ਲਈ ਤੁਸੀਂ ਬਣਾਉ ਸਕਦੇ ਹੋ:

• ਆਪਣੀ ਪਸੰਦ ਦੀ ਫਰੇਮਵਰਕ ਨਾਲ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਫਰੰਟ-ਐਂਡ ਬਣਾਓ।

• LangChain ਜਾਂ Semantic Kernel ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਓ।

ਪਾਠ ਪੂਰਾ ਕਰਨ ਲਈ ਵਧਾਈਆਂ 👏।

ਸਿੱਖਣਾ ਇੱਥੇ ਖਤਮ ਨਹੀਂ ਹੁੰਦਾ, ਯਾਤਰਾ ਜਾਰੀ ਰੱਖੋ

ਇਸ ਪਾਠ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸਾਡੇ ਜਨਰੇਟਿਵ AI ਸਿੱਖਣ ਕਲੈਕਸ਼ਨ ਨੂੰ देखੋ ਤਾਂ ਜੋ ਆਪਣੀ Generative AI ਜਾਣਕਾਰੀ ਨੂੰ ਹੋਰ ਉੱਚਾ ਕੀਤਾ ਜਾ ਸਕੇ!

---

ਇਨਕਾਰ-ਏ-ਜ਼ਿੰਮੇਵਾਰੀ:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ Co-op Translator ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਨਿਰਵਿਕਾਰਤਾ ਲਈ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਰੱਖੋ ਕਿ ਆਟੋਮੈਟਿਕ ਅਨੁਵਾਦ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਣਸਹਿਮਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਆਪਣੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਹੀ ਪ੍ਰਮਾਣਿਕ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਹਿਮ ਜਾਣਕਾਰੀ ਲਈ ਪੇਸ਼ਾਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਸਾਡੇ ਨੂੰ ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਹੋਣ ਵਾਲੀਆਂ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀਆਂ ਜਾਂ ਭ੍ਰਮਾਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਠਹਿਰਾਇਆ ਜਾਵੇਗਾ।