ಸರ್ಚ್ ಅಪ್ಲಿಕೇಶನ್ ಪಾಠದಲ್ಲಿ, ನಾವು ಸ್ವಲ್ಪವಾಗಿ ನಿಮ್ಮ ಸ್ವಂತ ಡೇಟಾವನ್ನು لاين್ಜ್ ಲ್ಯಾಂಗುಯೇಜ್ ಮಾದರಿಗಳ (LLMs)ೊಂದಿಗೆ ಏಕೀಕರಿಸುವ ಬಗ್ಗೆ ಕಲಿತೆವು. ಈ ಪಾಠದಲ್ಲಿ, ನಾವು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ನಿಮ್ಮ LLM ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ ನೆಲೆಸಿಸುವಂತೆ ಮಾಡುವುದು, ಪ್ರಕ್ರಿಯೆಯ ಯಾಂತ್ರಿಕತೆ ಮತ್ತು ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ವಿಧಾನಗಳು, ಇನ್ನೆರಡೂ ಎಂಬೆಡ್ಡಿಂಗ್ಗಳು ಮತ್ತು ಪಠ್ಯ ಸಹಿತ, ಕುರಿತು ಹೆಚ್ಚಿನವಾಗಿ ಆಳವಾಗಿ ತಿಳುವಳಿಕೆ ಪಡೆಯಲಿದ್ದೇವೆ.
ವೀಡಿಯೋ ಶೀಘ್ರದಲ್ಲಿಯೇ ಲಭ್ಯ
ಈ ಪಾಠದಲ್ಲಿ ನಾವು ಹೀಗಿವೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತೇವೆ:
-
RAG ಗೆ ಪರಿಚಯ, ಅದು ಏನಿದೆ ಮತ್ತು ಏಕೆ AI (ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆ)ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿಯುವುದು.
-
ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ಗಳನ್ನು ಅರಿತುಕೊಳ್ಳುವುದು ಮತ್ತು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ಗೆ ಒಂದು ರಚಿಸುವುದು.
-
ಒಂದು ಹಣಿಕೆ ಎಫ್ಎಕ್ಸ್ಪ್ಲಾಂಪಲ್ ಹೇಗೆ RAG ಅನ್ನು ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ ಏಕೀಕರಿಸಬಹುದು ಎಂಬುದರ ಬಗ್ಗೆ.
ಈ ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ಮೇಲೆ, ನೀವು ಸಾಧ್ಯವಾಗುವುದು:
-
ಡೇಟಾ ವಾಪಸಿ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ RAGನ ಮಹತ್ವವನ್ನು ವಿವರಿಸಬಹುದು.
-
RAG ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸೆಟಪ್ ಮಾಡಿ ಮತ್ತು ನಿಮ್ಮ ಡೇಟಾವನ್ನು LLMಗೆ ನೆಲೆಸಿಸಲು ಸಾಧ್ಯವಾಗುವುದು.
-
LLM ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ RAG ಮತ್ತು ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ಗಳ ಪರಿಣಾಮಕಾರಿ ಏಕೀಕರಣ.
ಈ ಪಾಠಕ್ಕಾಗಿ, ನಾವು ಶಿಕ್ಷಣ ಸ್ಟಾರ್ಟ್ಅಪ್ಗೆ ನಮ್ಮ ಸ್ವಂತ ಟಿಪ್ಪಣಿಗಳನ್ನು ಸೇರಿಸಲು ಬಯಸುತ್ತೇವೆ, ಇದು ಚಾಟ್ಬೋಟ್ಗೆ ವಿವಿಧ ವಿಷಯಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ಅನುಮತಿಸುತ್ತದೆ. ನಾವು ಹೊಂದಿರುವ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಕಲಿಯುವವರು ಉತ್ತಮವಾಗಿ ಅಧ್ಯಯನ ಮಾಡಿ ವಿಭಿನ್ನ ವಿಷಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದಾಗಿರುತ್ತದೆ, ಇದು ಅವರಿಗೆ ಪರೀಕ್ಷೆಗಳಿಗೆ ಸುಲಭವಾಗಿ ವಿಮರ್ಶೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಮ್ಮ ದೃಶ್ಯವನ್ನು ರಚಿಸಲು, ನಾವು ಬಳಸಿಕೊಳ್ಳುತ್ತೇವೆ:
-
Azure OpenAI:ನಾವು ನಮ್ಮ ಚಾಟ್ಬೋಟ್ ರಚಿಸಲು ಬಳಸಲಿರುವ LLM -
AI for beginners' lesson on Neural Networks:ಇದು ನಮ್ಮ LLM ಗೆ ನೆಲೆಸುವ ಡೇಟಾ ಆಗಿರುತ್ತದೆ -
Azure AI Searchಮತ್ತುAzure Cosmos DB:ನಮ್ಮ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಹುಡುಕಾಟ ಸೂಚ್ಯಂಕವನ್ನು ರಚಿಸಲು ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್
ಬಳಕೆದಾರರು ತಮ್ಮ ಟಿಪ್ಪಣಿಗಳಿಂದ ಅಭ್ಯಾಸ ಪ್ರಶ್ನೋತ್ತರಗಳು, ವಿಮರ್ಶೆ ಫ್ಲ್ಯಾಶ್ ಕಾರ್ಡ್ಗಳು ರಚಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ಸಂಕ್ಷಿಪ್ತ ಅವಲೋಕನಗಳಿಗೆ ಸಾರಾಂಶಗೊಳಿಸಬಹುದು. ಪ್ರಾರಂಭಿಸಲು, RAG ಏನು ಮತ್ತು ಅದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂದು ನೋಡೋಣ:
ಒಂದು LLM ಚಾಲಿತ ಚಾಟ್ಬೋಟ್ ಬಳಕೆದಾರರ ಪತ್ರಿಕೆಗಳನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡಿ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಇದು ಸಂವಾದಾತ್ಮಕವಾಗಿದ್ದು ಮತ್ತು ಹಲವಾರು ವಿಷಯಗಳ ಬಗ್ಗೆ ಬಳಕೆದಾರರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ. ಆದರೆ, ಇದರ ಪ್ರತಿಕ್ರಿಯೆಗಳು ಒದಗಿಸಿದ ಸಾಂದರ್ಭಿಕ ಮಾಹಿತಿಯಷ್ಟುವೇ ಮತ್ತು ಅದರ ಮೂಲ ತರಬೇತಿ ಡೇಟಾವಿನಷ್ಟೂ ಮಾತ್ರ ಸೀಮಿತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, GPT-4 ನ ವಿದಗ್ಧತೆ ಕಡಿತ ಆರಂಭದಲ್ಲಿ ಸೆಪ್ಟೆಂಬರ್ 2021, ಇದರರ್ಥ, ಈ ಅವಧಿಯ ನಂತರ ನಡೆದ ಘಟನೆಗಳ ತಿಳಿವು ಇಲ್ಲ. ಜೊತೆಗೆ, LLMಗಳನ್ನು ತರಬೇತಿಗಾಗಿ ಬಳಸಿದ ಡೇಟಾ ವೈಯಕ್ತಿಕ ಟಿಪ್ಪಣಿಗಳು ಅಥವಾ ಕಂಪನಿಯ ಉತ್ಪನ್ನ ಕೈಪಿಡಿ ಮುಂತಾದ ರಹಸ್ಯ ಮಾಹಿತಿ ಒಳಗೊಂಡಿಲ್ಲ.
ನೀವು ನಿಮ್ಮ ಟಿಪ್ಪಣಿಗಳಿಂದ ಪ್ರಶ್ನೋತ್ತರಗಳನ್ನು ರಚಿಸುವ ಚಾಟ್ಬೋಟ್ ಅನ್ನು ಹಾವಳಿ ಹತ್ತಿಸಲು ಬಯಸಿದರೆ, ನಿಮಗೆ ಜ್ಞಾನ ಆಧಾರದೊಂದಿಗೆ ಸಂಪರ್ಕ ಬೇಕಾಗುತ್ತದೆ. ಇದಕ್ಕೆ RAG ಪರಿಹಾರವಾಗಿ ಬರುತ್ತದೆ. RAGಗಳು ಹೀಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ:
-
ಜ್ಞಾನ ಆಧಾರ: ವಾಪಸಿ ಮಾಡಲು, ಈ ದಾಖಲೆಗಳನ್ನು ಪೂರ್ವಾನುಶೀಲನೆ ಮತ್ತು ಸಂಸ್ಕರಣೆ ಮಾಡಬೇಕು, ಸಾಮಾನ್ಯವಾಗಿ ದೊಡ್ಡ ಡಾಕ್ಯುಮೆಂಟ್ಗಳನ್ನು ಚಿಕ್ಕ ತುಂಡುಗಳಾಗಿ ಹಂಚುವುದು, ಅವುಗಳನ್ನು ಪಠ್ಯ ಎಂಬೆಡ್ಡಿಂಗ್ ಆಗಿ ಪರಿವರ್ತಿಸಿ ಡೇಟಾಬೇಸಿನಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದು.
-
ಬಳಕೆದಾರ ಪ್ರಶ್ನೆ: ಬಳಕೆದಾರನು ಪ್ರಶ್ನೆ ಕೇಳುತ್ತಾನೆ
-
ವಾಪಸಿ: ಬಳಕೆದಾರನು ಪ್ರಶ್ನೆ ಕೇಳಿದಾಗ, ಎಂಬೆಡ್ಡಿಂಗ್ ಮಾದರಿ ನಮ್ಮ ಜ್ಞಾನ ಆಧಾರದಿಂದ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಿ ಹೆಚ್ಚು ಸಾಂದರ್ಭಿಕ ಮಾಹಿತಿಯನ್ನು ನೀಡುತ್ತದೆ, ಇದು ಪ್ರಾಂಪ್ಟ್ ನಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ.
-
ವೃದ್ಧಿತ ತಯಾರಿ: LLM ತನ್ನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಾಪಸಿಯಾದ ಡೇಟಾ ಆಧರಿಸಿ ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ. ಇದು ಪೂರ್ವ ತರಬೇತಿಯ ಡೇಟಾದ ಮೇಲೆಯೇ ಅಲ್ಲ, ಆದರೆ ಸೇರಿಸಲಾದ ಸಾಂದರ್ಭಿಕ ಮಾಹಿತಿಯುಳ್ಳ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯ ಮೇಲೆಯೂ ಆಧಾರಿತವಾಗಿರುತ್ತದೆ. ವಾಪಸಾದ ಡೇಟಾ LLM ನ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ವೃದ್ಧಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ನಂತರ LLM, ಬಳಕೆದಾರನ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರ ನೀಡುತ್ತದೆ.
RAGಗಳ ಆರ್ಕಿಟೆಕ್ಟರ್ ಅನ್ನು ಟ್ರಾನ್ಸ್ಫಾರ್ಮರ್ಗಳೊಂದಿಗೆ ಎರಡು ಭಾಗಗಳಲ್ಲಿ ಅನುಷ್ಠಾನಗೊಳಿಸಲಾಗುತ್ತದೆ: ಎನ್ಕೋಡರ್ ಮತ್ತು ಡಿಕೋಡರ್. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರನು ಪ್ರಶ್ನೆ ಕೇಳಿದಾಗ, ಪ್ರವೇಶ ಪಠ್ಯವನ್ನು 'ಎನ್ಕೋಡ್'ಮಾಡಿ ಪದಗಳ ಅರ್ಥವನ್ನು ಹಿಡಿದಿಡುವ ವೆಕ್ಟರ್ಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಆ ವೆಕ್ಟರ್ಗಳನ್ನು ಡಿಕೋಡ್ ಮಾಡಿ ನಮ್ಮ ಡಾಕ್ಯುಮೆಂಟ್ ಸೂಚ್ಯಂಕಕ್ಕೆ ಅನ್ವಯಿಸಿ ಬಳಕೆದಾರ ಪ್ರಶ್ನೆಯ ಆಧಾರದಲ್ಲಿ ಹೊಸ ಪಠ್ಯವನ್ನು ರಚಿಸುತ್ತದೆ. LLM, ಔಟ್ಪುಟ್ ತಯಾರಿಸಲು ಎನ್ಕೋಡರ್-ಡಿಕೋಡರ್ ಮಾದರಿಯನ್ನು ಬಳಸುತ್ತದೆ.
ಪ್ರಸ್ತಾವಿತ ಕಾಗದ ಪ್ರಕಾರ RAG ಅನುಷ್ಠಾನಗೊಳ್ಳುವ ಎರಡು ವಿಧಾನಗಳು: Retrieval-Augmented Generation for Knowledge intensive NLP (natural language processing software) Tasks:
-
RAG-Sequence: ವಾಪಸಾದ ದಾಖಲೆಗಳನ್ನು ಬಳಸಿ ಬಳಕೆದಾರ ಪ್ರಶ್ನೆಗೆ ಉತ್ತಮ ಉತ್ತರವನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವುದು
-
RAG-Token: ದಾಖಲೆಗಳನ್ನು ಬಳಸಿ ಮುಂದಿನ ಟೋಕನ್ ರೂಪಿಸುವುದು, ನಂತರ ಅದನ್ನು ವಾಪಸಿಮಾಡಿ ಬಳಕೆದಾರ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರ ಮಾಡುವುದು
-
ಮಾಹಿತಿ ಸಂಪತ್ತು: ಪಠ್ಯ ಪ್ರತಿಕ್ರಿಯೆಗಳು ಇನ್ನಷ್ಟು ನವೀನ ಮತ್ತು ನವೀನವಾಗಿರಲು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಇದರಿಂದ ಡೊಮೈನ್-ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳ ಮೇಲೆ ಕಾರ್ಯಕ್ಷಮತೆ ಸುಧಾರಿಸುತ್ತದೆ ಅಂತರ್ನಿರ್ಮಿತ ಜ್ಞಾನ ಆಧಾರಕ್ಕೆ ಪ್ರವೇಶ ನೀಡುವ ಮೂಲಕ.
-
ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಗಳಿಗೆ ಸಾಂದರ್ಭಿಕ ಒದಗಿಸಲು ज्ञಾತಿ ಮಾಡಬಹುದಾದ ಡೇಟಾವನ್ನು ಉಪಯೋಗಿಸಿ ವಿವರಿಸುವಿಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
-
ಇದು ಖರ್ಚುефಿಷಿಯಂಟ್ ಆಗಿದ್ದು, LLM ನ ಸುಧಾರಣೆಯೊಂದಿಗೆ ಹೋಲಿಸಿದರೆ ಹೆಚ್ಚಿನ ಅರ್ಥಪೂರ್ಣವಾಗಿ ಇರುತ್ತದೆ.
ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ನಮ್ಮ ವೈಯಕ್ತಿಕ ಡೇಟಾದಾದ Neural Network ಪಾಠದ ಮೇಲೆ ಆಧಾರಿತವಾಗಿದೆ, ಅದು AI For Beginners‘s ಪಠ್ಯಕ್ರಮವಾಗಿದೆ.
ಸಾಂಪ್ರದಾಯಿಕ ಡೇಟಾಬೇಸ್ಗಳ ಗಿಂತ ಭಿನ್ನವಾಗಿ, ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ ಒಂದು ವಿಶೇಷ ಡೇಟಾಬೇಸ್ ಆಗಿದ್ದು, ಅದು ಎಂಬೆಡ್ಡಿಂಗ್ ವೆಕ್ಟರ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು, ನಿರ್ವಹಿಸಲು ಮತ್ತು ಹುಡುಕಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಇದು ಡಾಕ್ಯುಮೆಂಟ್ಗಳ ಸಂಖ್ಯಾಮೂಲಕ ಪ್ರತಿನಿಧಾನಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಡೇಟಾವನ್ನು ಸಂಖ್ಯಾಮೂಲಕ ಎಂಬೆಡ್ಡಿಂಗ್ಗಳಿಗೆ ಮುರಿತ ಮಾಡುವುದರಿಂದ, ನಮ್ಮ AI ವ್ಯವಸ್ಥೆಗೆ ಡೇಟಾವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಪ್ರಕ್ರಿಯೆ ಮಾಡಲು ಸುಲಭವಾಗುತ್ತದೆ.
ನಾವು ಎಂಬೆಡ್ಡಿಂಗ್ಗಳನ್ನು ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ ಏಕೆಂದರೆ LLM ಗಳು ಸ್ವೀಕರಿಸುವ ಟೋಕನ್ಗಳ ಸಂಖ್ಯೆಗೆ ಮಿತಿ ಇರುತ್ತದೆ. ನೀವು ಸಂಪೂರ್ಣ ಎಂಬೆಡ್ಡಿಂಗನ್ನು LLM ಗೆ ನೀಡಲಾಗದು, ಅದನ್ನು ತುಂಡು-ತುಂಡಾಗಿ ಹಂಚಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರ ಪ್ರಶ್ನೆ ಕೇಳಿದಾಗ, ಪ್ರಶ್ನೆಗೆ ಸಂಬಂಧಿಸಿದ ಎಂಬೆಡ್ಡಿಂಗ್ಗಳನ್ನೂ ಪ್ರಾಂಪ್ಟ್ ಜೊತೆಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ತುಂಡುಗೊಳಿಸುವಿಕೆ LLM ಮೂಲಕ ನೀಡಿ ಟೋಕನ್ ಗಳ ಸಂಖ್ಯೆಯಲ್ಲಿನ ಖರ್ಚು ಕೂಡ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ದೊಡ್ಡ ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ಗಳಿಗೆ ವಿವಿಧ ಪರಿಚಿತ ನಾಮಗಳಿವೆ: Azure Cosmos DB, Clarifyai, Pinecone, Chromadb, ScaNN, Qdrant ಮತ್ತು DeepLake. ಕೆಳಗಿನ ಆಜುರ್ 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ಗೆ ಸಾಂದರ್ಭಿಕ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುವುದಕ್ಕಾಗಿರುತ್ತದೆ.
ನಮ್ಮ ಡೇಟಾಬೇಸ್ನೊಳಗಿನ ಹುಡುಕಾಟವನ್ನು ಹಲವಾರು ವಿಧಾನಗಳಲ್ಲಿ ಮಾಡಬಹುದು:
-
ಕೀವರ್ಡ್ ಶೋಧ - ಪಠ್ಯ ಹುಡುಕಾಟಕ್ಕೆ ಉಪಯೋಗಿಸುವುದು
-
ವೆಕ್ಟರ್ ಶೋಧ - ಎంబೆಡ್ಡಿಂಗ್ ಮಾದರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪಠ್ಯದಿಂದ ವೆಕ್ಟರ್ ಪ್ರತಿನಿಧಾನಗಳಿಗೆ ಪರಿವರ್ತಿಸಿ, ಪದಗಳ ಅರ್ಥವನ್ನು ಉಪಯೋಗಿಸಿ ಸೆಮ್ಯಾಂಟಿಕ್ ಶೋಧ ಅನ್ನು ಅನುಮತಿಸುವುದು. ಬಳಕೆದಾರ ಪ್ರಶ್ನೆಗೆ ಸರಿಯಲ್ಲದ, ಆದರೆ ಸಮೀಪವಿರುವ ಹೆಸರಾಂತ ದಾಖಲೆಗಳನ್ನು ಹುಡುಕುವ ಮೂಲಕ ವಾಪಸಿ ಮಾಡಲಾಗುತ್ತದೆ.
-
ಹೈಬ್ರಿಡ್ - ಕೀವರ್ಡ್ ಮತ್ತು ವೆಕ್ಟರ್ ಶೋಧದ ಸಂಯೋಜನೆ.
ವಾಪಸಿ ಸಂದರ್ಭದಲ್ಲಿ ಸಮಸ್ಯೆ ಆಗುವುದು, ಡೇಟಾಬೇಸ್ನಲ್ಲಿಯೇ ಸಂಬಂಧಿತ ಉತ್ತರವಿಲ್ಲದಿದ್ದಾಗ, ವ್ಯವಸ್ಥೆ ಅತ್ಯುತ್ತಮ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ಆದರೆ ನೀವು ಪ್ರಾಸಕ್ತಿಗೆ ಗరిష್ಠ ದೂರವನ್ನು ಹೊಂದಿಸುವಂತೆ ಅಥವಾ ಕೀವರ್ಡ್ ಮತ್ತು ವೆಕ್ಟರ್ ಶೋಧಗಳನ್ನು ಸಂಯೋಜಿಸಿದ ಹೈಬ್ರಿಡ್ ಶೋಧ ಉಪಯೋಗಿಸುವಂತಹ ತಂತ್ರಗಳನ್ನು ಬಳಸಬಹುದು. ಈ ಪಾಠದಲ್ಲಿ ನಾವು ಹೈಬ್ರಿಡ್ ಶೋಧ ಬಳಸುತ್ತೀವೆ. ನಾವು ಡೇಟಾವನ್ನು ಚಂಕ್ಗಳು ಮತ್ತು ಎಂಬೆಡ್ಡಿಂಗ್ಗಳೊಂದಿಗೆ ಡೇಟಾಫ್ರೇಮ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ.
ರಿಟ್ರಿವರ್ ಜ್ಞಾನ ಆಧಾರದಲ್ಲಿ ಆತ್ಮೀಯವಾಗಿ ಅಂದರೆ, ಸಮೀಪದ ಕಟ್ಟಲು ಸೇರಿದ ಎಂಬೆಡ್ಡಿಂಗ್ಗಳನ್ನು ಹುಡುಕುತ್ತದೆ, ಅವು ತಾ ಹಿಡುವಡುಗಳಿವೆ. ಥೇಮ್ನಲ್ಲಿರುವ ಬಳಕೆದಾರ ಪ್ರಶ್ನೆ ಮೊದಲು ಎಂಬೆಡ್ಡ್ ಆಗಿದ್ದು, ನಂತರ ಅದಕ್ಕನುಗುಣವಾಗಿ ಇರುವ ಎಂಬೆಡ್ಡಿಂಗ್ಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಗೊಳ್ಳುತ್ತದೆ. ವಿವಿಧ ವೆಕ್ಟರ್ಗಳ ಸಾನ್ನಿಧ್ಯತೆ ಅಳೆಯಲು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುವ ಮಾಪನ ಎಂದರೆ ಕೋಸೈನ similarity (ಸಮಾನತೆ), ಇದು ಎರಡು ವೆಕ್ಟರ್ಗಳ ನಡುವಿನ ಕೋನದ ಮೇಲೆ ಆಧಾರಿತವಾಗಿದೆ.
ನಮ್ಮ ಬಳಕೆ ಮಾಡಿಕೊಂಡು ಸಾಧ್ಯವಿರುವ ಇತರೆ ಪರ್ಯಾಯಗಳು ಯೂಕ್ಲಿಡಿಯನ್ ದೂರ (ಎಡೆಗಡೆಯಿಂದ ನೇರ ರೇಖೆ) ಮತ್ತು ಡಾಟ್ ಪ್ರಾಡಕ್ಟ್ (ಎರಡು ವೆಕ್ಟರ್ಗಳ ಅಂಶಗಳ ಗುಣಾಕಾರದ ಮೊತ್ತ) ಆಗಿದೆ.
ವಾಪಸಿ ಮಾಡುವಾಗ, ನಾವು ಹುಡುಕಾಟ ಮಾಡುವ ಮುನ್ನ ನಮ್ಮ ಜ್ಞಾನ ಆಧಾರದ ಹುಡುಕಾಟ ಸೂಚ್ಯಂಕವನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಸೂಚ್ಯಂಕವು ನಮ್ಮ ಎम्बೆಡ್ಡಿಂಗ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ ದೊಡ್ಡ ಡೇಟಾಬೇಸ್ನಲ್ಲಿಯೂ ಕೂಡ ಸಮೀಪದ ತುಂಡುಗಳನ್ನು ಶೀಘ್ರವಾಗಿ ಹುಡುಕುತ್ತದೆ. ನಾವು ನಮ್ಮ ಸೂಚ್ಯಂಕವನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಕೆಳಗಿನಂತೆ ರಚಿಸಬಹುದು:
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 ರಚನೆಯನ್ನು ಸರಳ ಮಾಡಲು, Semanti Kernel, Langchain ಅಥವಾ Autogen ಮುಂತಾದ ಫ್ರೇಮ್ವರ್ಕ್ಗಳನ್ನು ಬಳಸಬಹುದು.
Retrieval Augmented Generation (RAG)ನ ಬದಲಾವಣೆಯನ್ನು ಮುಂದುವರಿಸಲು ನೀವು ನಿರ್ಮಿಸಬಹುದು:
-
ನಿಮ್ಮ ಆಯ್ಕೆ ಫ್ರೇಮ್ವರ್ಕ್ ಬಳಸಿಕೊಂಡು ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಫ್ರಂಟ್-ಎಂಡ್ ರಚನೆ
-
LangChain ಅಥವಾ Semantic Kernel ಫ್ರೇಮ್ವರ್ಕ್ ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಪುನರುತ್ಪಾದನೆ
ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ್ದಕ್ಕೆ ಅಭಿನಂದನೆಗಳು 👏.
ಈ ಪಾಠನಂತರ, ನಮ್ಮ Generative AI Learning collection ನೋಡಿ ನಿಮ್ಮ Generative AI ಜ್ಞಾನವನ್ನು ಹೆಚ್ಚಿಸಲು ಮುಂದುವರೆಯಿರಿ!
ಅಸ್ವೀಕಾರಿಕೆ:
ಈ ದಾಖಲೆ AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿಕೈ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಪ್ರಮಾಣ ಬದ್ಧತೆಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಆದರೆ ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳಿರಬಹುದೆಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿ ಇರುವ ಮೂಲ ದಾಖಲೆ ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಲಾಗಬೇಕು. ಅತ್ಯವಶ್ಯಕ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವ ರೀತಿಯಾದ misunderstandings ಅಥವಾ ತಪ್ಪು ವ್ಯಾಖ್ಯಾನಗಳಿಗೂ ನಾವು ಜವಾಬ್ದಾರಿಯಲ್ಲ.