LangChain ಒಂದು ಅತ್ಯಾಧುನಿಕ ಮತ್ತು ದೃಢವಾದ ಸಾಧನವಾಗಿದ್ದು, ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳ (LLMs) ಶಕ್ತಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ.
ಈ LLM ಗಳು ಗಮನಾರ್ಹ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೊಂದಿವೆ ಮತ್ತು ಕಾರ್ಯಗಳ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯನ್ನು ಸಮರ್ಥವಾಗಿ ನಿಭಾಯಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಅವರ ಸಾಮರ್ಥ್ಯವು ಆಳವಾದ ಡೊಮೇನ್ ಪರಿಣತಿಗಿಂತ ಹೆಚ್ಚಾಗಿ ಅವರ ಸಾಮಾನ್ಯ ಸ್ವಭಾವದಲ್ಲಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. GPT-4 ಅನ್ನು ಪರಿಚಯಿಸಿದ ನಂತರ ಇದರ ಜನಪ್ರಿಯತೆಯು ವೇಗವಾಗಿ ಬೆಳೆಯುತ್ತಿದೆ.
ಎಲ್ಎಲ್ಎಂಗಳು ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಉತ್ಕೃಷ್ಟತೆಯನ್ನು ಹೊಂದಿದ್ದರೂ, ನಿರ್ದಿಷ್ಟ ಉತ್ತರಗಳನ್ನು ಒದಗಿಸಲು ಅಥವಾ ಆಳವಾದ ಡೊಮೇನ್ ಜ್ಞಾನದ ಅಗತ್ಯವಿರುವ ಕಾರ್ಯಗಳನ್ನು ನಿಭಾಯಿಸಲು ಬಂದಾಗ ಅವರು ಮಿತಿಗಳನ್ನು ಎದುರಿಸಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ಅಥವಾ ಔಷಧ ಅಥವಾ ಕಾನೂನಿನಂತಹ ವಿಶೇಷ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು LLM ಅನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
ಈ ಕ್ಷೇತ್ರಗಳ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ವಿಚಾರಣೆಗಳಿಗೆ LLM ನಿಸ್ಸಂಶಯವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸಬಹುದಾದರೂ, ವಿಶೇಷ ಜ್ಞಾನ ಅಥವಾ ಪರಿಣತಿಯ ಅಗತ್ಯವಿರುವ ಹೆಚ್ಚು ವಿವರವಾದ ಅಥವಾ ಸೂಕ್ಷ್ಮವಾದ ಉತ್ತರಗಳನ್ನು ನೀಡಲು ಇದು ಹೆಣಗಾಡಬಹುದು.
ಏಕೆಂದರೆ ಎಲ್ಎಲ್ಎಂಗಳು ವೈವಿಧ್ಯಮಯ ಮೂಲಗಳಿಂದ ಅಪಾರ ಪ್ರಮಾಣದ ಪಠ್ಯ ಡೇಟಾದ ಮೇಲೆ ತರಬೇತಿ ಪಡೆದಿವೆ, ಅವು ಮಾದರಿಗಳನ್ನು ಕಲಿಯಲು, ಸಂದರ್ಭವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಸುಸಂಬದ್ಧ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸೃಷ್ಟಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಅವರ ತರಬೇತಿಯು ವಿಶಿಷ್ಟವಾಗಿ ಡೊಮೇನ್-ನಿರ್ದಿಷ್ಟ ಅಥವಾ ವಿಶೇಷ ಜ್ಞಾನದ ಸ್ವಾಧೀನವನ್ನು ಆ ಕ್ಷೇತ್ರಗಳಲ್ಲಿನ ಮಾನವ ತಜ್ಞರಂತೆಯೇ ಒಳಗೊಂಡಿರುವುದಿಲ್ಲ.
ಆದ್ದರಿಂದ, LangChain, LLM ಗಳ ಜೊತೆಯಲ್ಲಿ, ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಕಾರ್ಯಗಳಿಗೆ ಅಮೂಲ್ಯವಾದ ಸಾಧನವಾಗಿದ್ದರೂ, ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಆಳವಾದ ಡೊಮೇನ್ ಪರಿಣತಿಯು ಇನ್ನೂ ಅಗತ್ಯವಾಗಬಹುದು ಎಂಬುದನ್ನು ಗುರುತಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ವಿಶೇಷ ಜ್ಞಾನವನ್ನು ಹೊಂದಿರುವ ಮಾನವ ತಜ್ಞರು ಅಗತ್ಯವಾದ ಆಳ, ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸದ ತಿಳುವಳಿಕೆ ಮತ್ತು ಸಂದರ್ಭ-ನಿರ್ದಿಷ್ಟ ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸಬಹುದು ಅದು ಕೇವಲ LLM ಗಳ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಮೀರಿರಬಹುದು.
ನಾವು LangChain ನ ಡಾಕ್ಸ್ ಅಥವಾ ನೋಡಲು ಸಲಹೆ ನೀಡುತ್ತೇವೆ GitHub ಅದರ ವಿಶಿಷ್ಟ ಬಳಕೆಯ ಪ್ರಕರಣಗಳ ಸಂಪೂರ್ಣ ತಿಳುವಳಿಕೆಗಾಗಿ ಭಂಡಾರ. ಈ ಬಂಡಲ್ನ ದೊಡ್ಡ ಚಿತ್ರವನ್ನು ಪಡೆಯಲು ಬಲವಾಗಿ ಸಲಹೆ ನೀಡಲಾಗುತ್ತದೆ.
ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?
LangChain ನ ಉದ್ದೇಶ ಮತ್ತು ಕೆಲಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ. GPT-4 ಪ್ರಭಾವಶಾಲಿ ಸಾಮಾನ್ಯ ಜ್ಞಾನವನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಪ್ರಶ್ನೆಗಳಿಗೆ ವಿಶ್ವಾಸಾರ್ಹ ಉತ್ತರಗಳನ್ನು ನೀಡುತ್ತದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ.
ಆದಾಗ್ಯೂ, ವೈಯಕ್ತಿಕ ಡಾಕ್ಯುಮೆಂಟ್, ಪುಸ್ತಕ, PDF ಫೈಲ್ ಅಥವಾ ಸ್ವಾಮ್ಯದ ಡೇಟಾಬೇಸ್ನಂತಹ ನಮ್ಮದೇ ಡೇಟಾದಿಂದ ನಿರ್ದಿಷ್ಟ ಮಾಹಿತಿಯನ್ನು ನಾವು ಬಯಸಿದರೆ ಏನು ಮಾಡಬೇಕು?
LangChain ನಮಗೆ ಸಂಪರ್ಕಿಸಲು ಅನುಮತಿಸುತ್ತದೆ a ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿ ನಮ್ಮದೇ ಆದ ಡೇಟಾ ಮೂಲಗಳಿಗೆ GPT-4 ನಂತೆ. ಇದು ಪಠ್ಯದ ತುಣುಕನ್ನು ಚಾಟ್ ಇಂಟರ್ಫೇಸ್ಗೆ ಅಂಟಿಸುವುದನ್ನು ಮೀರಿದೆ. ಬದಲಾಗಿ, ನಾವು ನಮ್ಮದೇ ಡೇಟಾದಿಂದ ತುಂಬಿದ ಸಂಪೂರ್ಣ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು.
ಒಮ್ಮೆ ನಾವು ಬಯಸಿದ ಮಾಹಿತಿಯನ್ನು ಪಡೆದುಕೊಂಡರೆ, ನಿರ್ದಿಷ್ಟ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವಲ್ಲಿ LangChain ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಿರ್ದಿಷ್ಟ ವಿವರಗಳನ್ನು ಹೊಂದಿರುವ ಇಮೇಲ್ ಕಳುಹಿಸಲು ನಾವು ಅದಕ್ಕೆ ಸೂಚಿಸಬಹುದು.
ಇದನ್ನು ಸಾಧಿಸಲು, ನಾವು ಲ್ಯಾಂಗ್ಚೈನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪೈಪ್ಲೈನ್ ವಿಧಾನವನ್ನು ಅನುಸರಿಸುತ್ತೇವೆ. ಮೊದಲಿಗೆ, ನಾವು ಬಯಸಿದ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಭಾಷಾ ಮಾದರಿ ಉಲ್ಲೇಖಿಸಲು ಮತ್ತು ಅದನ್ನು ಸಣ್ಣ ಭಾಗಗಳಾಗಿ ವಿಂಗಡಿಸಲು. ಈ ಭಾಗಗಳನ್ನು ನಂತರ ಎಂಬೆಡಿಂಗ್ಗಳಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಅವುಗಳೆಂದರೆ ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ನಲ್ಲಿ ಪಠ್ಯದ ವೆಕ್ಟರ್ ಪ್ರಾತಿನಿಧ್ಯಗಳು.
ಈ ಸೆಟಪ್ನೊಂದಿಗೆ, ಪ್ರಮಾಣಿತ ಪೈಪ್ಲೈನ್ ಅನ್ನು ಅನುಸರಿಸುವ ಭಾಷಾ ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ನಾವು ನಿರ್ಮಿಸಬಹುದು: ಬಳಕೆದಾರರು ಆರಂಭಿಕ ಪ್ರಶ್ನೆಯನ್ನು ಕೇಳುತ್ತಾರೆ, ನಂತರ ಅದನ್ನು ಭಾಷಾ ಮಾದರಿಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಪ್ರಶ್ನೆಯ ವೆಕ್ಟರ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ನಲ್ಲಿ ಹೋಲಿಕೆಯ ಹುಡುಕಾಟವನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ಸಂಬಂಧಿತ ಮಾಹಿತಿಯ ಭಾಗಗಳನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ.
ಈ ಭಾಗಗಳನ್ನು ನಂತರ ಭಾಷಾ ಮಾದರಿಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ, ಇದು ಉತ್ತರವನ್ನು ಒದಗಿಸಲು ಅಥವಾ ಬಯಸಿದ ಕ್ರಮವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಲ್ಯಾಂಗ್ಚೈನ್ ಡೇಟಾ-ಅರಿವುಳ್ಳ ಅಪ್ಲಿಕೇಶನ್ಗಳ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ನಾವು ವೆಕ್ಟರ್ ಸ್ಟೋರ್ನಲ್ಲಿ ನಮ್ಮದೇ ಡೇಟಾವನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು ಮತ್ತು ಅಧಿಕೃತ, ಏಕೆಂದರೆ ಅವು ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸದೆ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಟಿ
ಅವರು ಬಹುಸಂಖ್ಯೆಯ ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ತೆರೆಯುತ್ತಾರೆ, ವಿಶೇಷವಾಗಿ ವೈಯಕ್ತಿಕ ಸಹಾಯದಲ್ಲಿ, ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಯು ವಿಮಾನಗಳನ್ನು ಕಾಯ್ದಿರಿಸುವುದು, ಹಣವನ್ನು ವರ್ಗಾಯಿಸುವುದು ಅಥವಾ ತೆರಿಗೆ-ಸಂಬಂಧಿತ ವಿಷಯಗಳಲ್ಲಿ ಸಹಾಯ ಮಾಡುವಂತಹ ಕಾರ್ಯಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.
ಹೆಚ್ಚುವರಿಯಾಗಿ, ಹೊಸ ವಿಷಯಗಳ ಅಧ್ಯಯನ ಮತ್ತು ಕಲಿಕೆಯ ಪರಿಣಾಮಗಳು ಗಮನಾರ್ಹವಾಗಿವೆ, ಏಕೆಂದರೆ ಭಾಷಾ ಮಾದರಿಯು ಸಂಪೂರ್ಣ ಪಠ್ಯಕ್ರಮವನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ ಮತ್ತು ಕಲಿಕೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ. ಕೋಡಿಂಗ್, ದತ್ತಾಂಶ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ದತ್ತಾಂಶ ವಿಜ್ಞಾನವು ಈ ಪ್ರಗತಿಗಳಿಂದ ಹೆಚ್ಚು ಪ್ರಭಾವಿತವಾಗಿರುತ್ತದೆ ಎಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.
ಗ್ರಾಹಕರ ಮಾಹಿತಿ ಅಥವಾ ಮಾರ್ಕೆಟಿಂಗ್ ಡೇಟಾದಂತಹ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕಂಪನಿ ಡೇಟಾಗೆ ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳನ್ನು ಸಂಪರ್ಕಿಸುವುದು ಅತ್ಯಂತ ರೋಮಾಂಚಕಾರಿ ನಿರೀಕ್ಷೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಮೆಟಾದ API ಅಥವಾ Google ನ API ಯಂತಹ ಸುಧಾರಿತ API ಗಳೊಂದಿಗಿನ ಈ ಏಕೀಕರಣವು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಡೇಟಾ ವಿಜ್ಞಾನದಲ್ಲಿ ಘಾತೀಯ ಪ್ರಗತಿಯನ್ನು ಭರವಸೆ ನೀಡುತ್ತದೆ.
ವೆಬ್ಪುಟವನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು (ಡೆಮೊ)
ಪ್ರಸ್ತುತ, ಲ್ಯಾಂಗ್ಚೈನ್ ಪೈಥಾನ್ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ಯಾಕೇಜುಗಳಾಗಿ ಲಭ್ಯವಿದೆ.
LangChain ಪರಿಕಲ್ಪನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಾವು Streamlit, LangChain ಮತ್ತು OpenAI GPT-3 ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಾತ್ಯಕ್ಷಿಕೆ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಬಹುದು.
ಆದರೆ ಮೊದಲು, ನಾವು Streamlit, LangChain ಮತ್ತು OpenAI ಸೇರಿದಂತೆ ಕೆಲವು ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕು.
ಪೂರ್ವ-ಅವಶ್ಯಕತೆಗಳು
ಸ್ಟ್ರೀಮ್ಲಿಟ್: ಡೇಟಾ ಸೈನ್ಸ್-ಸಂಬಂಧಿತ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ರಚಿಸಲು ಜನಪ್ರಿಯ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್
OpenAI: OpenAI ನ GPT-3 ಭಾಷಾ ಮಾದರಿಗೆ ಪ್ರವೇಶದ ಅಗತ್ಯವಿದೆ.
ಈ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಲು, cmd ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಿ:
pip install streamlit
pip install langchain
pip install openai
ಪ್ಯಾಕೇಜುಗಳನ್ನು ಆಮದು ಮಾಡಿ
OpenAI, LangChain ಮತ್ತು Streamlit ನಂತಹ ಅಗತ್ಯವಿರುವ ಪ್ಯಾಕೇಜ್ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. LangChain ನಿಂದ ಮೂರು ವರ್ಗಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಮ್ಮ ಭಾಷಾ ಮಾದರಿ ಸರಪಳಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ: LLMCchain, SimpleSequentialChain ಮತ್ತು PromptTemplate.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
ಮೂಲಭೂತ ಸಿದ್ಧತೆ
ನಮ್ಮ ಯೋಜನೆಯ ರಚನಾತ್ಮಕ ಆಧಾರವನ್ನು ನಂತರ ಸ್ಟ್ರೀಮ್ಲಿಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ ಹಾಕಲಾಯಿತು. ನಾವು ಅಪ್ಲಿಕೇಶನ್ಗೆ "ವಾಟ್ಸ್ ಟ್ರೂ: ಸಿಂಪಲ್ ಸೀಕ್ವೆನ್ಶಿಯಲ್ ಚೈನ್ ಅನ್ನು ಬಳಸುವುದು" ಎಂಬ ಶೀರ್ಷಿಕೆಯನ್ನು ನೀಡಿದ್ದೇವೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ನ ಸ್ಫೂರ್ತಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದ GitHub ರೆಪೊಸಿಟರಿಗೆ ಮಾರ್ಕ್ಡೌನ್ ಲಿಂಕ್ ಅನ್ನು ಸೇರಿಸಿದ್ದೇವೆ.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
ಫ್ರಂಟ್-ಎಂಡ್ ವಿಜೆಟ್ಗಳು
ಸರಳ ಸ್ಟ್ರೀಮ್ಲಿಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಕೆಲವು ಸಂಬಂಧಿತ ಮಾಹಿತಿಯೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿಸಿದ್ದೇವೆ:
# If an API key has been provided, create an OpenAI language model instance
if API:
llm = OpenAI(temperature=0.7, openai_api_key=API)
else:
# If an API key hasn't been provided, display a warning message
st.warning("Enter your OPENAI API-KEY. Get your OpenAI API key from [here](https://platform.openai.com/account/api-keys).\n")
ಫ್ರಂಟ್-ಎಂಡ್ ವಿಜೆಟ್ಗಳನ್ನು ಸೇರಿಸಲು
ಇದಲ್ಲದೆ, ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ನಮೂದಿಸಲು ನಮ್ಮ ಬಳಕೆದಾರರನ್ನು ಅನುಮತಿಸಲು ನಾವು ಇನ್ಪುಟ್ ವಿಜೆಟ್ ಅನ್ನು ಒದಗಿಸಬೇಕಾಗಿದೆ.
# Add a text input box for the user's question
user_question = st.text_input(
"Enter Your Question : ",
placeholder = "Cyanobacteria can perform photosynthetsis , are they considered as plants?",
)
ಎಲ್ಲವೂ ಮುಗಿಯಿತು! ಸರಪಳಿಗಳು ಚಾಲನೆಯಲ್ಲಿವೆ!
ನಾವು ಒಟ್ಟಾಗಿ ವಿವಿಧ ಕಾರ್ಯಾಚರಣೆಗಳ ಸರಪಳಿಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತೇವೆ SimpleSequentialChain
ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಲು. ಬಳಕೆದಾರರು ಆಯ್ಕೆ ಮಾಡಿದಾಗ ಸರಪಳಿಗಳನ್ನು ಈ ಕೆಳಗಿನ ಅನುಕ್ರಮದಲ್ಲಿ ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ "Tell me about it"
ಬಟನ್:
if st.button("Tell me about it", type="primary"):
# Chain 1: Generating a rephrased version of the user's question
template = """{question}\n\n"""
prompt_template = PromptTemplate(input_variables=["question"], template=template)
question_chain = LLMChain(llm=llm, prompt=prompt_template)
# Chain 2: Generating assumptions made in the statement
template = """Here is a statement:
{statement}
Make a bullet point list of the assumptions you made when producing the above statement.\n\n"""
prompt_template = PromptTemplate(input_variables=["statement"], template=template)
assumptions_chain = LLMChain(llm=llm, prompt=prompt_template)
assumptions_chain_seq = SimpleSequentialChain(
chains=[question_chain, assumptions_chain], verbose=True
)
# Chain 3: Fact checking the assumptions
template = """Here is a bullet point list of assertions:
{assertions}
For each assertion, determine whether it is true or false. If it is false, explain why.\n\n"""
prompt_template = PromptTemplate(input_variables=["assertions"], template=template)
fact_checker_chain = LLMChain(llm=llm, prompt=prompt_template)
fact_checker_chain_seq = SimpleSequentialChain(
chains=[question_chain, assumptions_chain, fact_checker_chain], verbose=True
)
# Final Chain: Generating the final answer to the user's question based on the facts and assumptions
template = """In light of the above facts, how would you answer the question '{}'""".format(
user_question
)
template = """{facts}\n""" + template
prompt_template = PromptTemplate(input_variables=["facts"], template=template)
answer_chain = LLMChain(llm=llm, prompt=prompt_template)
overall_chain = SimpleSequentialChain(
chains=[question_chain, assumptions_chain, fact_checker_chain, answer_chain],
verbose=True,
)
# Running all the chains on the user's question and displaying the final answer
st.success(overall_chain.run(user_question))
question_chain
: ಇದು ನಮ್ಮ ಪೈಪ್ಲೈನ್ನಲ್ಲಿ ಮೊದಲ ಹಂತವಾಗಿದೆ, ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಯನ್ನು ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ. ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಯು ಸರಣಿಯ ಟೆಂಪ್ಲೇಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.- ಪ್ರಶ್ನೆಗೆ ಲಿಂಕ್ ಮಾಡಿದ ಹೇಳಿಕೆಯ ಆಧಾರದ ಮೇಲೆ, ದಿ
assumptions_chain
ನಿಂದ ಔಟ್ಪುಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಊಹೆಗಳ ಬುಲೆಟ್-ಪಾಯಿಂಟ್ ಪಟ್ಟಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆquestion_chain
ಇನ್ಪುಟ್ ಆಗಿ. ದಿLLMChain
ಮತ್ತುOpenAI
ಹೇಳಿಕೆಯನ್ನು ನಿರ್ಮಿಸಲು ಲ್ಯಾಂಗ್ಚೈನ್ನ ಮಾದರಿಯನ್ನು ಬಳಸಲಾಗಿದೆ. ಈ ಸರಪಳಿಗಾಗಿ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹೇಳಿಕೆಯನ್ನು ಉತ್ಪಾದಿಸುವ ಸಲುವಾಗಿ ಮಾಡಲಾದ ಊಹೆಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವ ಕೆಲಸವನ್ನು ಬಳಕೆದಾರರಿಗೆ ವಹಿಸಲಾಗಿದೆ. - ನಿಂದ ಔಟ್ಪುಟ್ಗಳನ್ನು ಆಧರಿಸಿ
question_chain
ಮತ್ತುassumptions_chain
,fact_checker_chain
ಬುಲೆಟ್ ಪಾಯಿಂಟ್ಗಳ ರೂಪದಲ್ಲಿ ಸಮರ್ಥನೆಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ಹಕ್ಕುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಉತ್ಪಾದಿಸಲಾಗುತ್ತದೆOpenAI
ಮಾದರಿ ಮತ್ತುLLMChain
LangChain ನಿಂದ. ಪ್ರತಿ ಕ್ಲೈಮ್ ನಿಖರವಾಗಿದೆಯೇ ಅಥವಾ ತಪ್ಪಾಗಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸಲು ಮತ್ತು ಇರುವವರಿಗೆ ಸಮರ್ಥನೆಯನ್ನು ಒದಗಿಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ಬಳಕೆದಾರರಿಗೆ ವಹಿಸಲಾಗಿದೆ. - ನಮ್ಮ
answer_chain
ನಿಂದ ಔಟ್ಪುಟ್ಗಳನ್ನು ಬಳಸುತ್ತದೆquestion_chain
,assumptions_chain
, ಮತ್ತುfact_checker_chain
ಹಿಂದಿನ ಸರಪಳಿಗಳಿಂದ ಉತ್ಪತ್ತಿಯಾಗುವ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲು ಇನ್ಪುಟ್ಗಳಾಗಿ. ಈ ಸರಪಳಿಯ ಟೆಂಪ್ಲೇಟ್ ಬಳಕೆದಾರರು ರಚಿಸಿದ ಸಂಗತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮೊದಲ ಪ್ರಶ್ನೆಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವಂತೆ ವಿನಂತಿಸುತ್ತದೆ. - ಹಿಂದಿನ ಸರಪಳಿಗಳಿಂದ ಉತ್ಪತ್ತಿಯಾಗುವ ಮಾಹಿತಿಯ ಆಧಾರದ ಮೇಲೆ ಬಳಕೆದಾರರ ವಿಚಾರಣೆಗೆ ಅಂತಿಮ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಒದಗಿಸಲು, ನಾವು ಈ ಸರಪಳಿಗಳನ್ನು ಒಟ್ಟಾರೆ ಸರಪಳಿಯಲ್ಲಿ ಸಂಯೋಜಿಸುತ್ತೇವೆ. ಸರಪಳಿಗಳು ಪೂರ್ಣಗೊಂಡ ನಂತರ, ನಾವು ಬಳಸುತ್ತೇವೆ
st.success()
ಬಳಕೆದಾರರಿಗೆ ಪರಿಹಾರವನ್ನು ತೋರಿಸಲು.
ತೀರ್ಮಾನ
ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಪೈಪ್ಲೈನ್ಗಳನ್ನು ರಚಿಸಲು ನಾವು ವಿಭಿನ್ನ ಭಾಷಾ ಮಾದರಿಯ ಕ್ರಿಯೆಗಳನ್ನು ಸರಳವಾಗಿ ಜೋಡಿಸಬಹುದು SimpleSequentialChain
LangChain ನ ಮಾಡ್ಯೂಲ್. ಚಾಟ್ಬಾಟ್ಗಳು, ಪ್ರಶ್ನೋತ್ತರ ವ್ಯವಸ್ಥೆಗಳು ಮತ್ತು ಭಾಷಾ ಅನುವಾದ ಪರಿಕರಗಳು ಸೇರಿದಂತೆ ವಿವಿಧ NLP ಅಪ್ಲಿಕೇಶನ್ಗಳಿಗೆ ಇದು ಸಾಕಷ್ಟು ಸಹಾಯಕವಾಗಬಹುದು.
ಲ್ಯಾಂಗ್ಚೈನ್ನ ತೇಜಸ್ಸು ಅದರ ಅಮೂರ್ತ ಸಾಮರ್ಥ್ಯದಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ, ಇದು ಭಾಷಾ ಮಾಡೆಲಿಂಗ್ನ ವಿಶಿಷ್ಟತೆಗಳಿಗಿಂತ ಪ್ರಸ್ತುತ ಸಮಸ್ಯೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಲು ಬಳಕೆದಾರರಿಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
LangChain ಪೂರ್ವ-ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಗಳು ಮತ್ತು ಟೆಂಪ್ಲೇಟ್ಗಳ ಆಯ್ಕೆಯನ್ನು ನೀಡುವ ಮೂಲಕ ಅತ್ಯಾಧುನಿಕ ಭಾಷಾ ಮಾದರಿಗಳನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚು ಬಳಕೆದಾರ ಸ್ನೇಹಿಯನ್ನಾಗಿ ಮಾಡುತ್ತದೆ.
ಭಾಷಾ ಮಾದರಿಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ಸುಲಭವಾಗುವಂತೆ ತಮ್ಮದೇ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ಭಾಷಾ ಮಾದರಿಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸುವ ಆಯ್ಕೆಯನ್ನು ಇದು ನಿಮಗೆ ನೀಡುತ್ತದೆ. ಇದು ಹೆಚ್ಚು ನಿಖರವಾದ, ಡೊಮೇನ್-ನಿರ್ದಿಷ್ಟ ಮಾದರಿಗಳ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಇದು ನಿರ್ದಿಷ್ಟ ಕೆಲಸಕ್ಕಾಗಿ, ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಗಳನ್ನು ಮೀರಿಸುತ್ತದೆ.
ನಮ್ಮ SimpleSequentialChain
ಮಾಡ್ಯೂಲ್ ಮತ್ತು ಲ್ಯಾಂಗ್ಚೈನ್ನ ಇತರ ವೈಶಿಷ್ಟ್ಯಗಳು ಅತ್ಯಾಧುನಿಕ NLP ಸಿಸ್ಟಮ್ಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಪರಿಣಾಮಕಾರಿ ಸಾಧನವಾಗಿದೆ.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ