ಹಿಂದಿನ ಅಧ್ಯಾಯದಿಂದ ಕೆಲವು ಕಲಿಕೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸೋಣ:
ಪ್ರಾಂಪ್ಟ್ ಎಂಜಿನಿಯರಿಂಗ್ ಎಂದರೆ ನಾವು ಮಾದರಿಯನ್ನು ಹೆಚ್ಚು ಸಂಬಂಧಿತ ಪ್ರತಿಕ್ರಿಯೆಗಳತ್ತ ಮಾರ್ಗದರ್ಶನ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆ ಆಗಿದ್ದು, ಹೆಚ್ಚು ಉಪಯುಕ್ತ ಸೂಚನೆಗಳು ಅಥವಾ ಸಂದರ್ಭವನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ.
ಪ್ರಾಂಪ್ಟ್ ಬರೆಯಲು ಎರಡು ಹಂತಗಳಿವೆ: ಸಂಬಂಧಿತ ಸಂದರ್ಭವನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಪ್ರಾಂಪ್ಟ್ ರಚಿಸುವುದು ಮತ್ತು ಆಪ್ಟಿಮೈಜೆಷನ್, ಅಂದರೆ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಹಂತ ಹಂತವಾಗಿ ಸುಧಾರಿಸುವುದು.
ಈ ಹಂತದಲ್ಲಿ, ನಾವು ಪ್ರಾಂಪ್ಟ್ ಬರೆಯುವ ಬಗ್ಗೆ ಕೆಲವು ಮೂಲಭೂತ ಅರ್ಥವನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಆದರೆ ನಾವು ಇನ್ನಷ್ಟು ಆಳವಾಗಿ ಹೋಗಬೇಕಾಗಿದೆ. ಈ ಅಧ್ಯಾಯದಲ್ಲಿ, ನೀವು ವಿವಿಧ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಪ್ರಯತ್ನಿಸುವುದರಿಂದ ಪ್ರಾಂಪ್ಟ್ ಒಂದೇ ಮತ್ತೊಂದಕ್ಕಿಂತ ಉತ್ತಮವಾಗಿರುವುದರ ಕಾರಣವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವವರೆಗೆ ಹೋಗುತ್ತೀರಿ. ನೀವು ಯಾವುದೇ LLM ಗೆ ಅನ್ವಯಿಸಬಹುದಾದ ಕೆಲವು ಮೂಲಭೂತ ತಂತ್ರಗಳನ್ನು ಅನುಸರಿಸಿ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ರಚಿಸುವುದನ್ನು ಕಲಿಯುತ್ತೀರಿ.
ಈ ಅಧ್ಯಾಯದಲ್ಲಿ, ನಾವು ಕೆಳಗಿನ ವಿಷಯಗಳನ್ನು ಆವರಿಸುವೆವು:
- ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ ಎಂಜಿನಿಯರಿಂಗ್ ಜ್ಞಾನವನ್ನು ವಿಭಿನ್ನ ತಂತ್ರಗಳನ್ನು ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ಗಳಿಗೆ ಅನ್ವಯಿಸುವ ಮೂಲಕ ವಿಸ್ತರಿಸಿ.
- ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಸಂರಚಿಸಿ ಔಟ್ಪುಟ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದು.
ಈ ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ನೀವು ಸಾಧ್ಯವಾಗುವುದು:
- ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ಗಳ ಫಲಿತಾಂಶವನ್ನು ಸುಧಾರಿಸುವ ಪ್ರಾಂಪ್ಟ್ ಎಂಜಿನಿಯರಿಂಗ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವಯಿಸುವುದು.
- ಬದಲಾಗುವ ಅಥವಾ ನಿರ್ಧಾರಾತ್ಮಕ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು.
ಪ್ರಾಂಪ್ಟ್ ಎಂಜಿನಿಯರಿಂಗ್ ಎಂದರೆ ಬಯಸಿದ ಫಲಿತಾಂಶವನ್ನು ಉತ್ಪಾದಿಸುವ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆ. ಕೇವಲ ಪಠ್ಯ ಪ್ರಾಂಪ್ಟ್ ಬರೆಯುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಇದೆ. ಪ್ರಾಂಪ್ಟ್ ಎಂಜಿನಿಯರಿಂಗ್ ಒಂದು ಎಂಜಿನಿಯರಿಂಗ್ ಶಾಖೆ ಅಲ್ಲ, ಬದಲಿಗೆ ನೀವು ಬಯಸಿದ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಲು ಅನ್ವಯಿಸಬಹುದಾದ ತಂತ್ರಗಳ ಸಮೂಹವಾಗಿದೆ.
ನಾವು ಈ ರೀತಿಯ ಮೂಲಭೂತ ಪ್ರಾಂಪ್ಟ್ ತೆಗೆದುಕೊಳ್ಳೋಣ:
ಭೂಗೋಳಶಾಸ್ತ್ರದ ಮೇಲೆ 10 ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸಿ.
ಈ ಪ್ರಾಂಪ್ಟ್ನಲ್ಲಿ, ನೀವು ವಾಸ್ತವವಾಗಿ ವಿವಿಧ ಪ್ರಾಂಪ್ಟ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವಯಿಸುತ್ತಿದ್ದೀರಿ.
ಇದನ್ನು ವಿಭಜಿಸೋಣ.
- ಸಂದರ್ಭ, ನೀವು "ಭೂಗೋಳಶಾಸ್ತ್ರ" ಬಗ್ಗೆ ಇರಬೇಕು ಎಂದು ಸೂಚಿಸುತ್ತೀರಿ.
- ಔಟ್ಪುಟ್ ಅನ್ನು ಮಿತಿಗೊಳಿಸುವುದು, ನೀವು 10 ಪ್ರಶ್ನೆಗಿಂತ ಹೆಚ್ಚು ಬೇಡ.
ನೀವು ಬಯಸಿದ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಬಹುದು ಅಥವಾ ಪಡೆಯದಿರಬಹುದು. ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳು ರಚನೆಯಾಗುತ್ತವೆ, ಆದರೆ ಭೂಗೋಳಶಾಸ್ತ್ರ ಒಂದು ದೊಡ್ಡ ವಿಷಯ ಮತ್ತು ನೀವು ಬಯಸಿದುದನ್ನು ಪಡೆಯದಿರಬಹುದು ಕೆಳಗಿನ ಕಾರಣಗಳಿಂದ:
- ದೊಡ್ಡ ವಿಷಯ, ಇದು ದೇಶಗಳು, ರಾಜಧಾನಿಗಳು, ನದಿಗಳು ಇತ್ಯಾದಿಗಳ ಬಗ್ಗೆ ಇರಬಹುದು ಎಂದು ನಿಮಗೆ ಗೊತ್ತಿಲ್ಲ.
- ರೂಪರೇಖೆ, ನೀವು ಪ್ರಶ್ನೆಗಳು ನಿರ್ದಿಷ್ಟ ರೀತಿಯಲ್ಲಿ ರೂಪುಗೊಳ್ಳಬೇಕೆಂದು ಬಯಸಿದರೆ?
ನೀವು ನೋಡಬಹುದು, ಪ್ರಾಂಪ್ಟ್ ರಚಿಸುವಾಗ ಪರಿಗಣಿಸಬೇಕಾದ ಅನೇಕ ವಿಷಯಗಳಿವೆ.
ಇದುವರೆಗೆ, ನಾವು ಸರಳ ಪ್ರಾಂಪ್ಟ್ ಉದಾಹರಣೆಯನ್ನು ನೋಡಿದ್ದೇವೆ, ಆದರೆ ಜನರೇಟಿವ್ AI ಜನರಲ್ ಆಗಿ ಹಲವಾರು ಪಾತ್ರಗಳು ಮತ್ತು ಉದ್ಯಮಗಳಲ್ಲಿ ಜನರಿಗೆ ಸಹಾಯ ಮಾಡಲು ಹೆಚ್ಚು ಸಾಮರ್ಥ್ಯ ಹೊಂದಿದೆ. ಮುಂದಿನ ಮೂಲಭೂತ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.
ಮೊದಲು, ಪ್ರಾಂಪ್ಟ್ ಮಾಡುವುದು LLM ನ ಒಂದು ಉದ್ಭವಿಸುವ ಗುಣಲಕ್ಷಣ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು, ಅಂದರೆ ಇದು ಮಾದರಿಯಲ್ಲಿ ನಿರ್ಮಿಸಲ್ಪಟ್ಟ ವೈಶಿಷ್ಟ್ಯವಲ್ಲ, ಬದಲಿಗೆ ನಾವು ಮಾದರಿಯನ್ನು ಬಳಸುವಾಗ ಕಂಡುಹಿಡಿಯುವ ಒಂದು ಗುಣಲಕ್ಷಣ.
ನಾವು LLM ಗೆ ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು ಬಳಸಬಹುದಾದ ಕೆಲವು ಮೂಲಭೂತ ತಂತ್ರಗಳಿವೆ. ಅವುಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.
- ಝೀರೋ-ಶಾಟ್ ಪ್ರಾಂಪ್ಟಿಂಗ್, ಇದು ಪ್ರಾಂಪ್ಟ್ ಮಾಡುವ ಅತ್ಯಂತ ಮೂಲಭೂತ ರೂಪ. ಇದು LLM ನ ತರಬೇತಿ ಡೇಟಾದ ಆಧಾರದ ಮೇಲೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕೇಳುವ ಏಕೈಕ ಪ್ರಾಂಪ್ಟ್ ಆಗಿದೆ.
- ಫ್ಯೂ-ಶಾಟ್ ಪ್ರಾಂಪ್ಟಿಂಗ್, ಈ ಪ್ರಾಂಪ್ಟ್ ಮಾದರಿಯನ್ನು 1 ಅಥವಾ ಹೆಚ್ಚು ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಮಾರ್ಗದರ್ಶನ ಮಾಡುತ್ತದೆ, ಅವುಗಳ ಮೇಲೆ ಅವಲಂಬಿಸಿ ಪ್ರತಿಕ್ರಿಯೆ ರಚಿಸುತ್ತದೆ.
- ಚೈನ್-ಆಫ್-ಥಾಟ್, ಈ ಪ್ರಾಂಪ್ಟ್ ಮಾದರಿಯನ್ನು ಸಮಸ್ಯೆಯನ್ನು ಹಂತಗಳಾಗಿ ವಿಭಜಿಸುವುದನ್ನು ಹೇಳುತ್ತದೆ.
- ಜನರೇಟೆಡ್ ನೊಲೆಜ್, ಪ್ರಾಂಪ್ಟ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸುಧಾರಿಸಲು, ನೀವು ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ ಜೊತೆಗೆ ಜನರೇಟೆಡ್ ವಾಸ್ತವಗಳು ಅಥವಾ ಜ್ಞಾನವನ್ನು ಒದಗಿಸಬಹುದು.
- ಲೀಸ್ಟ್ ಟು ಮೋಸ್ಟ್, ಚೈನ್-ಆಫ್-ಥಾಟ್ ನಂತೆ, ಈ ತಂತ್ರವು ಸಮಸ್ಯೆಯನ್ನು ಹಂತಗಳ ಸರಣಿಯಾಗಿ ವಿಭಜಿಸುವುದು ಮತ್ತು ಆ ಹಂತಗಳನ್ನು ಕ್ರಮವಾಗಿ ನಿರ್ವಹಿಸುವಂತೆ ಕೇಳುವುದು.
- ಸೆಲ್ಫ್-ರಿಫೈನ್, ಈ ತಂತ್ರವು LLM ನ ಔಟ್ಪುಟ್ ಅನ್ನು ವಿಮರ್ಶಿಸಿ ನಂತರ ಅದನ್ನು ಸುಧಾರಿಸಲು ಕೇಳುವುದು.
- ಮೈಯೂಟಿಕ್ ಪ್ರಾಂಪ್ಟಿಂಗ್. ಇಲ್ಲಿ ನೀವು ಬಯಸುವುದು LLM ಉತ್ತರ ಸರಿಯಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುವುದು ಮತ್ತು ಉತ್ತರದ ವಿವಿಧ ಭಾಗಗಳನ್ನು ವಿವರಿಸಲು ಕೇಳುವುದು. ಇದು ಸೆಲ್ಫ್-ರಿಫೈನ್ ನ ಒಂದು ರೂಪವಾಗಿದೆ.
ಈ ಪ್ರಾಂಪ್ಟ್ ಶೈಲಿ ಬಹಳ ಸರಳವಾಗಿದೆ, ಇದು ಏಕೈಕ ಪ್ರಾಂಪ್ಟ್ ಒಳಗೊಂಡಿದೆ. ನೀವು LLM ಗಳ ಬಗ್ಗೆ ಕಲಿಯಲು ಪ್ರಾರಂಭಿಸುವಾಗ ಬಹುಶಃ ನೀವು ಇದನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಿ. ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
- ಪ್ರಾಂಪ್ಟ್: "ಅಲ್ಜೀಬ್ರಾ ಎಂದರೆ ಏನು?"
- ಉತ್ತರ: "ಅಲ್ಜೀಬ್ರಾ ಎಂದರೆ ಗಣಿತದ ಒಂದು ಶಾಖೆ, ಇದು ಗಣಿತೀಯ ಚಿಹ್ನೆಗಳು ಮತ್ತು ಆ ಚಿಹ್ನೆಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ನಿಯಮಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುತ್ತದೆ."
ಈ ಪ್ರಾಂಪ್ಟ್ ಶೈಲಿ ಮಾದರಿಯನ್ನು ಕೆಲವು ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಕಾರ್ಯ-ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಜೊತೆಗೆ ಏಕೈಕ ಪ್ರಾಂಪ್ಟ್ ಆಗಿದೆ. ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
- ಪ್ರಾಂಪ್ಟ್: "ಶೇಕ್ಸ್ಪಿಯರ್ ಶೈಲಿಯಲ್ಲಿ ಒಂದು ಕವಿತೆ ಬರೆಯಿರಿ. ಇಲ್ಲಿವೆ ಶೇಕ್ಸ್ಪಿಯರ್ ಸೊನೆಟ್ಗಳ ಕೆಲವು ಉದಾಹರಣೆಗಳು: ಸೊನೆಟ್ 18: 'ನಾನು ನಿನ್ನನ್ನು ಬೇಸಿಗೆ ದಿನದೊಂದಿಗೆ ಹೋಲಿಸಬಹುದೇ? ನೀನು ಹೆಚ್ಚು ಸುಂದರ ಮತ್ತು ಹೆಚ್ಚು ಸಮತೋಲನ...' ಸೊನೆಟ್ 116: 'ನಿಜವಾದ ಮನಸ್ಸುಗಳ ವಿವಾಹಕ್ಕೆ ನಾನು ಅಡ್ಡಿಪಡಿಸುವುದಿಲ್ಲ. ಪ್ರೀತಿ ಪ್ರೀತಿ ಅಲ್ಲ ಅದು ಬದಲಾವಣೆಯನ್ನು ಕಂಡಾಗ ಬದಲಾಗುತ್ತದೆ...' ಸೊನೆಟ್ 132: 'ನಿನ್ನ ಕಣ್ಣುಗಳನ್ನು ನಾನು ಪ್ರೀತಿಸುತ್ತೇನೆ, ಮತ್ತು ಅವು, ನನ್ನ ಮೇಲೆ ಕರುಣೆಯಿಂದ, ನಿನ್ನ ಹೃದಯ ನನ್ನನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ,...' ಈಗ, ಚಂದ್ರನ ಸೌಂದರ್ಯ ಕುರಿತು ಒಂದು ಸೊನೆಟ್ ಬರೆಯಿರಿ."
- ಉತ್ತರ: "ಆಕಾಶದಲ್ಲಿ, ಚಂದ್ರನು ಮೃದುವಾಗಿ ಹೊಳೆಯುತ್ತಾನೆ, ಬೆಳ್ಳಿ ಬೆಳಕಿನಲ್ಲಿ ತನ್ನ ಸೌಮ್ಯ ಕೃಪೆಯನ್ನು ಹರಡುತ್ತಾನೆ,..."
ಉದಾಹರಣೆಗಳು LLM ಗೆ ಬಯಸಿದ ಔಟ್ಪುಟ್ನ ಸಂದರ್ಭ, ರೂಪರೇಖೆ ಅಥವಾ ಶೈಲಿಯನ್ನು ಒದಗಿಸುತ್ತವೆ. ಅವು ಮಾದರಿಯನ್ನು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಹೆಚ್ಚು ನಿಖರ ಮತ್ತು ಸಂಬಂಧಿತ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ರಚಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ.
ಚೈನ್-ಆಫ್-ಥಾಟ್ ಒಂದು ಬಹಳ ಆಸಕ್ತಿದಾಯಕ ತಂತ್ರವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು LLM ಅನ್ನು ಹಂತಗಳ ಸರಣಿಯಿಂದ ನಡೆಸುವುದು. ಆಲೋಚನೆ ಎಂದರೆ LLM ಗೆ ಏನಾದರೂ ಮಾಡಲು ಹೇಗೆ ತಿಳಿಸುವುದು ಎಂಬುದಾಗಿದೆ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ, ಚೈನ್-ಆಫ್-ಥಾಟ್ ಇಲ್ಲದೆ ಮತ್ತು ಜೊತೆಗೆ:
- ಪ್ರಾಂಪ್ಟ್: "ಆಲಿಸ್ ಬಳಿ 5 ಸೇಬುಗಳಿವೆ, ಅವಳು 3 ಸೇಬುಗಳನ್ನು ಎಸೆದು, 2 ಸೇಬುಗಳನ್ನು ಬಾಬ್ ಗೆ ಕೊಟ್ಟಳು ಮತ್ತು ಬಾಬ್ ಒಂದು ಸೇಬು ಹಿಂತಿರುಗಿಸಿದನು, ಆಲಿಸ್ ಬಳಿ ಎಷ್ಟು ಸೇಬುಗಳಿವೆ?"
- ಉತ್ತರ: 5
LLM ಉತ್ತರ 5 ಎಂದು ನೀಡುತ್ತದೆ, ಇದು ತಪ್ಪು. ಸರಿಯಾದ ಉತ್ತರ 1 ಸೇಬು, ಲೆಕ್ಕಾಚಾರ (5 -3 -2 + 1 = 1) ಆಧಾರಿತವಾಗಿದೆ.
ಹೀಗಾಗಿ ನಾವು LLM ಗೆ ಇದನ್ನು ಸರಿಯಾಗಿ ಹೇಗೆ ಕಲಿಸಬಹುದು?
ಚೈನ್-ಆಫ್-ಥಾಟ್ ಪ್ರಯತ್ನಿಸೋಣ. ಚೈನ್-ಆಫ್-ಥಾಟ್ ಅನ್ವಯಿಸುವುದು ಅಂದರೆ:
- LLM ಗೆ ಸಮಾನ ಉದಾಹರಣೆಯನ್ನು ನೀಡಿ.
- ಲೆಕ್ಕಾಚಾರವನ್ನು ತೋರಿಸಿ, ಮತ್ತು ಅದನ್ನು ಸರಿಯಾಗಿ ಹೇಗೆ ಲೆಕ್ಕ ಹಾಕುವುದು.
- ಮೂಲ ಪ್ರಾಂಪ್ಟ್ ಒದಗಿಸಿ.
ಹೀಗೆ:
- ಪ್ರಾಂಪ್ಟ್: "ಲೀಸಾ ಬಳಿ 7 ಸೇಬುಗಳಿವೆ, ಅವಳು 1 ಸೇಬು ಎಸೆದು, 4 ಸೇಬುಗಳನ್ನು ಬಾರ್ಟ್ ಗೆ ಕೊಟ್ಟಳು ಮತ್ತು ಬಾರ್ಟ್ ಒಂದು ಹಿಂತಿರುಗಿಸಿದನು:
7 -1 = 6
6 -4 = 2
2 +1 = 3
ಆಲಿಸ್ ಬಳಿ 5 ಸೇಬುಗಳಿವೆ, ಅವಳು 3 ಸೇಬುಗಳನ್ನು ಎಸೆದು, 2 ಸೇಬುಗಳನ್ನು ಬಾಬ್ ಗೆ ಕೊಟ್ಟಳು ಮತ್ತು ಬಾಬ್ ಒಂದು ಹಿಂತಿರುಗಿಸಿದನು, ಆಲಿಸ್ ಬಳಿ ಎಷ್ಟು ಸೇಬುಗಳಿವೆ?" ಉತ್ತರ: 1
ನೀವು ನೋಡಬಹುದು, ನಾವು ಇನ್ನೊಂದು ಉದಾಹರಣೆ, ಲೆಕ್ಕಾಚಾರ ಮತ್ತು ನಂತರ ಮೂಲ ಪ್ರಾಂಪ್ಟ್ ಜೊತೆಗೆ ಬಹಳ ಉದ್ದವಾದ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಬರೆಯುತ್ತೇವೆ ಮತ್ತು ಸರಿಯಾದ ಉತ್ತರ 1 ಗೆ ಬರುತ್ತೇವೆ.
ನೀವು ನೋಡಬಹುದು ಚೈನ್-ಆಫ್-ಥಾಟ್ ಒಂದು ಬಹಳ ಶಕ್ತಿಶಾಲಿ ತಂತ್ರವಾಗಿದೆ.
ನೀವು ಪ್ರಾಂಪ್ಟ್ ರಚಿಸಲು ಬಯಸುವಾಗ, ಬಹಳ ಬಾರಿ ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಕಂಪನಿಯ ಡೇಟಾವನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೀರಿ. ಪ್ರಾಂಪ್ಟ್ನ ಒಂದು ಭಾಗ ಕಂಪನಿಯಿಂದ ಆಗಿರಬೇಕು ಮತ್ತು ಇನ್ನೊಂದು ಭಾಗ ನೀವು ಆಸಕ್ತರಾಗಿರುವ ನಿಜವಾದ ಪ್ರಾಂಪ್ಟ್ ಆಗಿರಬೇಕು.
ಉದಾಹರಣೆಗೆ, ನೀವು ವಿಮಾ ಉದ್ಯಮದಲ್ಲಿ ಇದ್ದರೆ, ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ ಹೀಗೆ ಕಾಣಬಹುದು:
{{company}}: {{company_name}}
{{products}}:
{{products_list}}
Please suggest an insurance given the following budget and requirements:
Budget: {{budget}}
Requirements: {{requirements}}
ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನೀವು ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಟೆಂಪ್ಲೇಟ್ನೊಂದಿಗೆ ರಚಿಸುವುದನ್ನು ನೋಡುತ್ತೀರಿ. ಟೆಂಪ್ಲೇಟ್ನಲ್ಲಿ {{variable}} ಎಂದು ಸೂಚಿಸಲಾದ ಹಲವಾರು ಚರಗಳು ಇವೆ, ಅವು ಕಂಪನಿ API ನಿಂದ ನಿಜವಾದ ಮೌಲ್ಯಗಳಿಂದ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ.
ನೀವು ಕಂಪನಿಯಿಂದ ವಿಷಯದಿಂದ ಚರಗಳನ್ನು ಬದಲಾಯಿಸಿದ ನಂತರ ಪ್ರಾಂಪ್ಟ್ ಹೀಗೆ ಕಾಣಬಹುದು:
Insurance company: ACME Insurance
Insurance products (cost per month):
- Car, cheap, 500 USD
- Car, expensive, 1100 USD
- Home, cheap, 600 USD
- Home, expensive, 1200 USD
- Life, cheap, 100 USD
Please suggest an insurance given the following budget and requirements:
Budget: $1000
Requirements: Car, Home, and Life insurance
ಈ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು LLM ಮೂಲಕ ಚಲಾಯಿಸಿದಾಗ ಈ ರೀತಿಯ ಪ್ರತಿಕ್ರಿಯೆ ಬರುತ್ತದೆ:
Given the budget and requirements, we suggest the following insurance package from ACME Insurance:
- Car, cheap, 500 USD
- Home, cheap, 600 USD
- Life, cheap, 100 USD
Total cost: $1,200 USD
ನೀವು ನೋಡಬಹುದು, ಇದು ಲೈಫ್ ಇನ್ಸುರೆನ್ಸ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಅದು ಆಗಬಾರದು. ಈ ಫಲಿತಾಂಶವು ನಾವು ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಏನು ಅನುಮತಿಸಬಹುದು ಎಂದು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಬೇಕೆಂದು ಸೂಚಿಸುತ್ತದೆ. ಕೆಲವು ಪ್ರಯತ್ನ ಮತ್ತು ದೋಷ ನಂತರ, ನಾವು ಕೆಳಗಿನ ಪ್ರಾಂಪ್ಟ್ಗೆ ಬರುತ್ತೇವೆ:
Insurance company: ACME Insurance
Insurance products (cost per month):
- type: Car, cheap, cost: 500 USD
- type: Car, expensive, cost: 1100 USD
- type: Home, cheap, cost: 600 USD
- type: Home, expensive, cost: 1200 USD
- type: Life, cheap, cost: 100 USD
Please suggest an insurance given the following budget and requirements:
Budget: $1000 restrict choice to types: Car, Home
ನೀವು ಗಮನಿಸಿ, type ಮತ್ತು cost ಸೇರಿಸುವುದು ಮತ್ತು restrict ಎಂಬ ಕೀವರ್ಡ್ ಬಳಸಿ LLM ಗೆ ನಾವು ಏನು ಬಯಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಈಗ ನಾವು ಕೆಳಗಿನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪಡೆಯುತ್ತೇವೆ:
Given the budget and requirements, we suggest the Car, Cheap insurance product which costs 500 USD per month.
ಈ ಉದಾಹರಣೆಯ ಉದ್ದೇಶವು ಜನರೇಟೆಡ್ ನೊಲೆಜ್ ಎಂಬ ಮೂಲಭೂತ ತಂತ್ರವನ್ನು ಬಳಸಿದರೂ, ಬಹುತೇಕ ಪ್ರಕರಣಗಳಲ್ಲಿ ಬಯಸಿದ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಲು ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಎಂದು ತೋರಿಸುವುದು.
ಲೀಸ್ಟ್-ಟು-ಮೋಸ್ಟ್ ಪ್ರಾಂಪ್ಟಿಂಗ್ನ ಆಲೋಚನೆ ದೊಡ್ಡ ಸಮಸ್ಯೆಯನ್ನು ಉಪಸಮಸ್ಯೆಗಳಾಗಿ ವಿಭಜಿಸುವುದು. ಆ ಮೂಲಕ, ನೀವು LLM ಗೆ ದೊಡ್ಡ ಸಮಸ್ಯೆಯನ್ನು "ಜಯಿಸುವ" ವಿಧಾನವನ್ನು ಮಾರ್ಗದರ್ಶನ ಮಾಡುತ್ತೀರಿ. ಡೇಟಾ ಸೈನ್ಸ್ಗೆ ಉತ್ತಮ ಉದಾಹರಣೆ ಇದಾಗಬಹುದು, ಇಲ್ಲಿ ನೀವು LLM ಗೆ ಸಮಸ್ಯೆಯನ್ನು ಹೀಗೆ ವಿಭಜಿಸಲು ಕೇಳಬಹುದು:
ಪ್ರಾಂಪ್ಟ್: 5 ಹಂತಗಳಲ್ಲಿ ಡೇಟಾ ಸೈನ್ಸ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು?
ನಿಮ್ಮ AI ಸಹಾಯಕ ಉತ್ತರಿಸುವುದು:
- ಡೇಟಾ ಸಂಗ್ರಹಿಸಿ
- ಡೇಟಾ ಸ್ವಚ್ಛಗೊಳಿಸಿ
- ಡೇಟಾ ವಿಶ್ಲೇಷಿಸಿ
- ಡೇಟಾ ಪ್ಲಾಟ್ ಮಾಡಿ
- ಡೇಟಾ ಪ್ರಸ್ತುತಪಡಿಸಿ
ಜನರೇಟಿವ್ AI ಮತ್ತು LLM ಗಳೊಂದಿಗೆ, ನೀವು ಔಟ್ಪುಟ್ ಮೇಲೆ ನಂಬಿಕೆ ಇಡಬಾರದು. ನೀವು ಅದನ್ನು ಪರಿಶೀಲಿಸಬೇಕು. ಕೊನೆಗೆ, LLM ಕೇವಲ ಮುಂದಿನ ಸಾಧ್ಯತೆಯುಳ್ಳ ಮಾತನ್ನು ಹೇಳುತ್ತಿದೆ, ಸರಿಯಾದುದನ್ನು ಅಲ್ಲ. ಆದ್ದರಿಂದ, LLM ನನ್ನು ತನ್ನನ್ನು ತಾನೇ ವಿಮರ್ಶಿಸಲು ಕೇಳುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸ, ಇದನ್ನು ಸೆಲ್ಫ್-ರಿಫೈನ್ ತಂತ್ರ ಎಂದು ಕರೆಯುತ್ತಾರೆ.
ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದು:
- ಪ್ರಾಥಮಿಕ ಪ್ರಾಂಪ್ಟ್ LLM ಗೆ ಸಮಸ್ಯೆ ಪರಿಹರಿಸಲು ಕೇಳುವುದು
- LLM ಉತ್ತರಿಸುತ್ತದೆ
- ನೀವು ಉತ್ತರವನ್ನು ವಿಮರ್ಶಿಸಿ AI ಗೆ ಸುಧಾರಿಸಲು ಕೇಳುತ್ತೀರಿ
- LLM ಮತ್ತೆ ಉತ್ತರಿಸುತ್ತದೆ, ಈ ಬಾರಿ ವಿಮರ್ಶೆಯನ್ನು ಪರಿಗಣಿಸಿ ಮತ್ತು ತನ್ನ ಪರಿಹಾರಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ
ನೀವು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಎಷ್ಟು ಬಾರಿಯೂ ಪುನರಾವರ್ತಿಸಬಹುದು.
ಈ ತಂತ್ರವನ್ನು ಬಳಸಿದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
ಪ್ರಾಂಪ್ಟ್: "ರೌಟ್ಗಳು products ಮತ್ತು customers ಇರುವ Python ವೆಬ್ API ರಚಿಸಿ"
AI ಉತ್ತರ:
import flask
app = Flask(__name__)
@app.route('/products')
def products():
return 'Products'
@app.route('/customers')
def customers():
return 'Customers'ಪ್ರಾಂಪ್ಟ್: ಮೇಲಿನ ಕೋಡ್ನ 3 ಸುಧಾರಣೆಗಳನ್ನು ಸೂಚಿಸಿ
AI ಉತ್ತರ:
Sure, here are three suggestions to improve the code:
Import the correct module: The first line should import Flask instead of flask. The correct import statement should be from flask import Flask.
Add a main function: Add a if __name__ == '__main__': block to the end of the file to run the application when the file is executed.
Use f-strings: Use f-strings to format the return statements in the route functions. For example, return 'Products' can be changed to return f'This is the {request.path} page'.
from flask import Flask, request
app = Flask(__name__)
@app.route('/products')
def products():
return f'This is the {request.path} page'
@app.route('/customers')
def customers():
return f'This is the {request.path} page'
if __name__ == '__main__':
app.run()ನೀವು ನೋಡಬಹುದು, ಮೇಲಿನ AI ಪ್ರತಿಕ್ರಿಯೆ ಮೊದಲ ಸೂಚಿಸಿದ ಕೋಡ್ ಅನ್ನು ವಿಮರ್ಶಿಸುವ ಮೂಲಕ ಸುಧಾರಿಸುತ್ತಿದೆ.
ಮೈಯೂಟಿಕ್ ಪ್ರಾಂಪ್ಟಿಂಗ್ ಸೆಲ್ಫ್-ರಿಫೈನ್ ಗೆ ಸಮಾನವಾದ ತಂತ್ರ, ಆದರೆ ಇದು LLM ತನ್ನನ್ನು ತಾನೇ ವಿವರಿಸಲು ಕೇಳುವುದು. ಗುರಿ LLM ಔಟ್ಪುಟ್ನ ಅಸಂಗತಿಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು ಮತ್ತು ಸರಿಯಾದ ಉತ್ತರಕ್ಕೆ ತಲುಪಿಸುವುದಾಗಿದೆ. ಅನುಸರಿಸಬೇಕಾದ ಕಾರ್ಯಪ್ರವಾಹ:
- LLM ಗೆ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು ಕೇಳಿ
- ಉತ್ತರದ ಪ್ರತಿ ಭಾಗಕ್ಕಾಗಿ, LLM ಗೆ ಅದನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿವರಿಸಲು ಕೇಳಿ.
- ಅಸಂಗತಿಗಳು ಇದ್ದರೆ, ಅಸಂಗತ ಭಾಗಗಳನ್ನು ತಿರಸ್ಕರಿಸಿ.
2 ಮತ್ತು 3 ಅನ್ನು ಎಲ್ಲಾ ಭಾಗಗಳ ಮೂಲಕ ಹೋಗುವವರೆಗೆ ಮತ್ತು ನೀವು ಉತ್ತರದಿಂದ ತೃಪ್ತರಾಗುವವರೆಗೆ ಪುನರಾವರ್ತಿಸಿ.
ಉದಾಹರಣೆ ಪ್ರಾಂಪ್ಟ್:
ಪ್ರಾಂಪ್ಟ್: ಮಹಾಮಾರಿಯನ್ನು ತಡೆಯಲು 5 ಹಂತಗಳಲ್ಲಿ ಸಂಕಟ ಯೋಜನೆಯನ್ನು ಹೇಗೆ ರಚಿಸಬಹುದು? LLM ಉತ್ತರ:
1. Identify the risks
1. Identify the stakeholders
1. Identify the resources
1. Identify the actions
1. Identify the communication channels
5 ಹಂತಗಳನ್ನು ಗುರುತಿಸಲಾಗಿದೆ, ಆದರೆ ಇದು ಸರಿಯೇ ಎಂದು ನಾವು ನಿರ್ಧರಿಸಬಹುದೇ? ಪ್ರತಿ ಹಂತವನ್ನು LLM ಗೆ ವಿವರಿಸಲು ಕೇಳೋಣ:
ಪ್ರಾಂಪ್ಟ್: ಮೊದಲ ಹಂತವನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿವರಿಸಿ, ಮಹಾಮಾರಿಯೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಅಪಾಯಗಳು ಯಾವುವು?
The risks are the following:
- Loss of life
- Loss of business
- Loss of reputation
- Loss of customers
- Loss of employees
ಈ ಹಂತದಲ್ಲಿ, ನಾವು LLM ಸರಿಯಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮೊದಲ ಅಪಾಯವನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿವರಿಸಲು ಕೇಳುತ್ತೇವೆ ಮತ್ತು ಮೇಲಿನ ಉತ್ತರದೊಂದಿಗೆ ಸಮ್ಮತವಾಗಿರುತ್ತದೆ ಎಂದು ಆಶಿಸುತ್ತೇವೆ:
ಪ್ರಾಂಪ್ಟ್: ಮಹಾಮಾರಿಯಲ್ಲಿ, ಯಾವುದು ಅತ್ಯಂತ ದೊಡ್ಡ ಅಪಾಯ ಮತ್ತು ಏಕೆ?
The biggest risk is loss of life because it's the most important thing to protect.
ಮಹಾಮಾರಿಯಲ್ಲಿ ಎರಡು ಪ್ರಮುಖ ಅಪಾಯಗಳು ಯಾವುವು?
The two biggest risks are loss of life and loss of business.
ಈ ಹಂತದಲ್ಲಿ, LLM ಸಮ್ಮತವಾಗಿದೆ ಮತ್ತು "ಜೀವನ" ಮತ್ತು "ವ್ಯಾಪಾರ" ಅನ್ನು ಪ್ರಮುಖ ಎರಡು ಅಪಾಯಗಳಾಗಿ ಉಲ್ಲೇಖಿಸುತ್ತದೆ. ಈಗ ನಾವು ಮುಂದಿನ ಹಂತಕ್ಕೆ ಸಾಗಬಹುದು ಮತ್ತು ಸಾಕಷ್ಟು ವಿಶ್ವಾಸ ಹೊಂದಬಹುದು. ಆದಾಗ್ಯೂ, ನಾವು LLM ಮೇಲೆ ಅಂಧವಾಗಿ ನಂಬಿಕೆ ಇಡಬಾರದು, ನಾವು ಯಾವಾಗಲೂ ಔಟ್ಪುಟ್ ಪರಿಶೀಲಿಸಬೇಕು.
LLM ಗಳು ಸ್ವಭಾವತಃ ನಿರ್ಧಾರಾತ್ಮಕವಲ್ಲ, ಅಂದರೆ ನೀವು ಒಂದೇ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಪ್ರತಿ ಬಾರಿ ಚಲಾಯಿಸಿದಾಗ ವಿಭಿನ್ನ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಉದಾಹರಣೆಗೆ ಕೆಳಗಿನ ಪ್ರಾಂಪ್ಟ್ ಪ್ರಯತ್ನಿಸಿ:
"Python ವೆಬ್ API ಗೆ ಕೋಡ್ ರಚಿಸಿ"
# ಅಗತ್ಯವಿರುವ ಮೋಡ್ಯೂಲ್ಗಳನ್ನು ಆಮದುಮಾಡಿ
import flask
from flask import request, jsonify
# ಫ್ಲಾಸ್ಕ್ ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಿ
app = flask.Flask(__name__)
# API ಗಾಗಿ ಮಾರ್ಗವನ್ನು ರಚಿಸಿ
@app.route('/api', methods=['GET'])
def api():
# ವಿನಂತಿಯಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯಿರಿ
data = request.args
# ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
result = process_data(data)
# ಫಲಿತಾಂಶವನ್ನು JSON ಆಗಿ ಹಿಂತಿರುಗಿಸಿ
return jsonify(result)
# ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಕಾರ್ಯ
def process_data(data):
# ಡೇಟಾ ಜೊತೆ ಏನಾದರೂ ಮಾಡಿ
result = data + 1
# ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿ
return result
# ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ
if __name__ == '__main__':
app.run()ಒಂದೇ ಪ್ರಾಂಪ್ಟ್ ಮತ್ತೆ ಚಲಾಯಿಸಿದಾಗ ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ಪ್ರತಿಕ್ರಿಯೆ ಬರುತ್ತದೆ:
#ಅಗತ್ಯ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಆಮದುಮಾಡಿ
import flask
from flask import request, jsonify
#ಫ್ಲಾಸ್ಕ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಿ
app = flask.Flask(__name__)
app.config["DEBUG"] = True
#ಪುಸ್ತಕಗಳ ಪಟ್ಟಿ ರಚಿಸಿ
books = [
{'id': 0,
'title': 'A Fire Upon the Deep',
'author': 'Vernor Vinge',
'first_sentence': 'The coldsleep itself was dreamless.',
'year_published': '1992'},
{'id': 1,
'title': 'The Ones Who Walk Away From Omelas',
'author': 'Ursula K. Le Guin',
'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-towered by the sea.',
'published': '1973'},
{'id': 2,
'title': 'Dhalgren',
'author': 'Samuel R. Delany',
'first_sentence': 'to wound the autumnal city.',
'published': '1975'}
]
#API ಗಾಗಿ ಎಂಡ್ಪಾಯಿಂಟ್ ರಚಿಸಿ
@app.route('/', methods=['GET'])
def home():
return '''<h1>Books API</h1>
<p>A prototype API for retrieving books.</p>'''
#ಎಲ್ಲಾ ಪುಸ್ತಕಗಳನ್ನು ಹಿಂತಿರುಗಿಸಲು ಎಂಡ್ಪಾಯಿಂಟ್ ರಚಿಸಿ
@app.route('/api/v1/resources/books/all', methods=['GET'])
def api_all():
return jsonify(books)
#ಒಂದು ಪುಸ್ತಕವನ್ನು ಹಿಂತಿರುಗಿಸಲು ಎಂಡ್ಪಾಯಿಂಟ್ ರಚಿಸಿ
@app.route('/api/v1/resources/books', methods=['GET'])
def api_id():
#URL ಭಾಗವಾಗಿ ID ಒದಗಿಸಲ್ಪಟ್ಟಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
#ID ಒದಗಿಸಿದರೆ, ಅದನ್ನು ಒಂದು ಚರದಲ್ಲಿ ನಿಯೋಜಿಸಿ
#ID ಒದಗಿಸದಿದ್ದರೆ, ದೋಷವನ್ನು ತೋರಿಸಿ
if 'id' in request.args:
id = int(request.args['id'])
else:
return "Error: No id field provided. Please specify an id."
#ನಮ್ಮ ಫಲಿತಾಂಶಗಳಿಗಾಗಿ ಖಾಲಿ ಪಟ್ಟಿ ರಚಿಸಿ
results = []
#ಡೇಟಾದ ಮೂಲಕ ಲೂಪ್ ಮಾಡಿ ಮತ್ತು ವಿನಂತಿಸಿದ ID ಗೆ ಹೊಂದುವ ಫಲಿತಾಂಶಗಳನ್ನು ಹೊಂದಿಸಿ
#ID ಗಳು ವಿಶಿಷ್ಟವಾಗಿವೆ, ಆದರೆ ಇತರ ಕ್ಷೇತ್ರಗಳು ಅನೇಕ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡಬಹುದು
for book in books:
if book['id'] == id:
results.append(book)
#ಫ್ಲಾಸ್ಕ್ನ jsonify ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಿ ನಮ್ಮ ಪೈಥಾನ್ ಡಿಕ್ಷನರಿಗಳನ್ನು
#JSON ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲು
return jsonify(results)
app.run()ಆದ್ದರಿಂದ ಬದಲಾಗುವ ಔಟ್ಪುಟ್ ಸಮಸ್ಯೆಯೇ?
ನೀವು ಏನು ಮಾಡಲು ಬಯಸುತ್ತೀರಿ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ನೀವು ನಿರ್ದಿಷ್ಟ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಬಯಸಿದರೆ ಅದು ಸಮಸ್ಯೆಯಾಗಬಹುದು. ನೀವು "ಭೂಗೋಳಶಾಸ್ತ್ರದ ಮೇಲೆ ಯಾವುದೇ 3 ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸಿ" ಎಂಬಂತೆ ಬದಲಾಗುವ ಔಟ್ಪುಟ್ ಒಪ್ಪಿಕೊಂಡರೆ, ಅದು ಸಮಸ್ಯೆಯಾಗುವುದಿಲ್ಲ.
ಸರಿ, ನಾವು ಔಟ್ಪುಟ್ ಅನ್ನು ಹೆಚ್ಚು ನಿರ್ಧಾರಾತ್ಮಕವಾಗಿರಿಸಲು ಮಿತಿಗೊಳಿಸಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ಅದನ್ನು ಹೇಗೆ ಮಾಡುವುದು?
ತಾಪಮಾನವು 0 ಮತ್ತು 1 ನಡುವಿನ ಮೌಲ್ಯ, 0 ಅತ್ಯಂತ ನಿರ್ಧಾರಾತ್ಮಕ ಮತ್ತು 1 ಅತ್ಯಂತ ಬದಲಾಗುವ. ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ 0.7. ತಾಪಮಾನವನ್ನು 0.1 ಗೆ ಸೆಟ್ ಮಾಡಿ ಒಂದೇ ಪ್ರಾಂಪ್ಟ್ ಎರಡು ಬಾರಿ ಚಲಾಯಿಸಿದಾಗ ಏನಾಗುತ್ತದೆ ನೋಡೋಣ:
"Python ವೆಬ್ API ಗೆ ಕೋಡ್ ರಚಿಸಿ"
#ಅಗತ್ಯ ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದುಮಾಡಿ
import flask
from flask import request, jsonify
#Flask ವರ್ಗದ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ರಚಿಸಿ
app = flask.Flask(__name__)
#API ಗಾಗಿ ಒಂದು ಎಂಡ್ಪಾಯಿಂಟ್ ರಚಿಸಿ
@app.route('/api/v1/endpoint', methods=['GET'])
def api_endpoint():
#ವಿನಂತಿ ಡೇಟಾವನ್ನು ಪಡೆಯಿರಿ
data = request.get_json()
#ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
result = process_data(data)
#ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿ
return jsonify(result)
#ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಕಾರ್ಯ
def process_data(data):
#ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
result = {'result': 'success'}
#ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿ
return result
#Flask ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ
if __name__ == '__main__':
app.run()ಮತ್ತೆ ಪ್ರಾಂಪ್ಟ್ ಚಲಾಯಿಸಿದಾಗ ಈ ಫಲಿತಾಂಶ ಬರುತ್ತದೆ:
#ಅಗತ್ಯ ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದುಮಾಡಿ
import flask
from flask import request, jsonify
#ಫ್ಲಾಸ್ಕ್ ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಿ
app = flask.Flask(__name__)
#API ಗಾಗಿ ಮಾರ್ಗವನ್ನು ರಚಿಸಿ
@app.route('/api', methods=['GET'])
def api_call():
#ವಿನಂತಿಯಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯಿರಿ
data = request.get_json()
#ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
result = process_data(data)
#ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿ
return jsonify(result)
#process_data ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ
def process_data(data):
#ಡೇಟಾದೊಂದಿಗೆ ಏನಾದರೂ ಮಾಡಿ
result = data + 1
#ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿ
return result
#ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ
if __name__ == '__main__':
app.run()ಈ ಎರಡು ಔಟ್ಪುಟ್ಗಳ ನಡುವೆ ತುಂಬಾ ಸಣ್ಣ ವ್ಯತ್ಯಾಸವಿದೆ. ಈಗ ವಿರುದ್ಧವನ್ನು ಮಾಡೋಣ, ತಾಪಮಾನವನ್ನು 0.9 ಗೆ ಸೆಟ್ ಮಾಡೋಣ:
# ಅಗತ್ಯ ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದುಮಾಡಿ
import flask
from flask import request, jsonify
# ಫ್ಲಾಸ್ಕ್ ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಿ
app = flask.Flask(__name__)
# API ಗಾಗಿ ಮಾರ್ಗವನ್ನು ರಚಿಸಿ
@app.route('/api', methods=['GET'])
def api_call():
# ವಿನಂತಿಯಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯಿರಿ
data = request.args
# ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
result = process_data(data)
# ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿ
return jsonify(result)
# ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಕಾರ್ಯ
def process_data(data):
# ಡೇಟಾ ಜೊತೆ ಏನಾದರೂ ಮಾಡಿ
result = data + 1
# ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿ
return result
# ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ
if __name__ == '__main__':
app.run()ಮತ್ತು 0.9 ತಾಪಮಾನ ಮೌಲ್ಯದಲ್ಲಿ ಎರಡನೇ ಪ್ರಯತ್ನ:
import flask
from flask import request, jsonify
# ಫ್ಲಾಸ್ಕ್ ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಿ
app = flask.Flask(__name__)
app.config['DEBUG'] = True
# ಕೆಲವು ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ರಚಿಸಿ
books = [
{'id': 0, 'title': 'A Fire Upon The Deep', 'author': 'Vernor Vinge', 'first_sentence': 'The coldsleep itself was dreamless.', 'year_published': '1992'},
{'id': 1, 'title': 'The Ones Who Walk Away From Omelas', 'author': 'Ursula K. Le Guin', 'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-towered by the sea.', 'published': '1973'},
{'id': 2, 'title': 'Dhalgren', 'author': 'Samuel R. Delany', 'first_sentence': 'to wound the autumnal city.', 'published': '1975'}
]
# ಒಂದು ಎಂಡ್ಪಾಯಿಂಟ್ ರಚಿಸಿ
@app.route('/', methods=['GET'])
def home():
return '''<h1>Welcome to our book API!</h1>'''
@app.route('/api/v1/resources/booksನೀವು ನೋಡಬಹುದು, ಫಲಿತಾಂಶಗಳು ಇನ್ನಷ್ಟು ವೈವಿಧ್ಯಮಯವಾಗಿರಲಿಲ್ಲ.
ಗಮನಿಸಿ, ಔಟ್ಪುಟ್ ಅನ್ನು ವೈವಿಧ್ಯಮಯಗೊಳಿಸಲು ನೀವು ಬದಲಾಯಿಸಬಹುದಾದ ಇನ್ನಷ್ಟು ಪರಿಮಾಣಗಳು ಇವೆ, ಉದಾಹರಣೆಗೆ top-k, top-p, ಪುನರಾವೃತ್ತಿ ದಂಡನೆ, ಉದ್ದ ದಂಡನೆ ಮತ್ತು ವೈವಿಧ್ಯ ದಂಡನೆ ಆದರೆ ಇವು ಈ ಪಠ್ಯಕ್ರಮದ ವ್ಯಾಪ್ತಿಗೆ ಹೊರಗಿನವುಗಳಾಗಿವೆ.
ನೀವು ಬಯಸುವುದನ್ನು ಪಡೆಯಲು ಪ್ರಯತ್ನಿಸುವ ಅನೇಕ ಅಭ್ಯಾಸಗಳಿವೆ. ನೀವು ಹೆಚ್ಚು ಹೆಚ್ಚು ಪ್ರಾಂಪ್ಟಿಂಗ್ ಬಳಸಿದಂತೆ ನಿಮ್ಮದೇ ಶೈಲಿಯನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತೀರಿ.
ನಾವು ಆವರಿಸಿಕೊಂಡ ತಂತ್ರಗಳ ಜೊತೆಗೆ, LLM ಅನ್ನು ಪ್ರಾಂಪ್ಟ್ ಮಾಡುವಾಗ ಪರಿಗಣಿಸಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳಿವೆ.
ಇಲ್ಲಿ ಪರಿಗಣಿಸಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳಿವೆ:
- ಸಂದರ್ಭವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ. ಸಂದರ್ಭವು ಮಹತ್ವದ್ದಾಗಿದೆ, ನೀವು ಡೊಮೇನ್, ವಿಷಯ ಇತ್ಯಾದಿ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಅಷ್ಟೇ ಉತ್ತಮ.
- ಔಟ್ಪುಟ್ ಅನ್ನು ಮಿತಿಗೊಳಿಸಿ. ನೀವು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಐಟಂಗಳು ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಉದ್ದವನ್ನು ಬಯಸಿದರೆ, ಅದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ.
- ಏನು ಮತ್ತು ಹೇಗೆ ಎಂಬುದನ್ನು ಎರಡನ್ನೂ ನಿರ್ದಿಷ್ಟಪಡಿಸಿ. ನೀವು ಏನು ಬಯಸುತ್ತೀರಿ ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಬಯಸುತ್ತೀರಿ ಎಂಬುದನ್ನು ಉಲ್ಲೇಖಿಸುವುದನ್ನು ಮರೆಯಬೇಡಿ, ಉದಾಹರಣೆಗೆ "ರೌಟ್ಗಳಾದ products ಮತ್ತು customers ಇರುವ Python ವೆಬ್ API ರಚಿಸಿ, ಅದನ್ನು 3 ಫೈಲ್ಗಳಾಗಿ ವಿಭಜಿಸಿ".
- ಟೆಂಪ್ಲೇಟುಗಳನ್ನು ಬಳಸಿ. ಬಹುಶಃ, ನೀವು ನಿಮ್ಮ ಕಂಪನಿಯಿಂದ ಡೇಟಾ ಬಳಸಿ ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಶ್ರೀಮಂತಗೊಳಿಸಲು ಬಯಸುತ್ತೀರಿ. ಇದಕ್ಕಾಗಿ ಟೆಂಪ್ಲೇಟುಗಳನ್ನು ಬಳಸಿ. ಟೆಂಪ್ಲೇಟುಗಳಲ್ಲಿ ನೀವು ನಿಜವಾದ ಡೇಟಾ ಮೂಲಕ ಬದಲಾಯಿಸುವ ಚರಗಳು ಇರಬಹುದು.
- ಸರಿಯಾಗಿ ಸ್ಪೆಲ್ ಮಾಡಿ. LLM ಗಳು ನಿಮಗೆ ಸರಿಯಾದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡಬಹುದು, ಆದರೆ ನೀವು ಸರಿಯಾಗಿ ಸ್ಪೆಲ್ ಮಾಡಿದರೆ ಉತ್ತಮ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪಡೆಯುತ್ತೀರಿ.
Flask ಬಳಸಿ ಸರಳ API ಅನ್ನು ನಿರ್ಮಿಸುವುದನ್ನು ತೋರಿಸುವ Python ಕೋಡ್ ಇಲ್ಲಿದೆ:
from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello():
name = request.args.get('name', 'World')
return f'Hello, {name}!'
if __name__ == '__main__':
app.run()GitHub Copilot ಅಥವಾ ChatGPT ಹೋಲುವ AI ಸಹಾಯಕನನ್ನು ಬಳಸಿ ಮತ್ತು "ಸ್ವ-ಸಂಶೋಧನೆ" ತಂತ್ರವನ್ನು ಅನ್ವಯಿಸಿ ಕೋಡ್ ಅನ್ನು ಸುಧಾರಿಸಿ.
ದಯವಿಟ್ಟು ಕೋಡ್ಗೆ ಸೂಕ್ತ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಕಾರ್ಯವನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸಿ.
Tip
ಸುಧಾರಿಸಲು ಕೇಳುವ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ರೂಪಿಸಿ, ಎಷ್ಟು ಸುಧಾರಣೆಗಳನ್ನು ಮಾಡಬೇಕೆಂದು ಮಿತಿಗೊಳಿಸುವುದು ಒಳ್ಳೆಯ ಆಲೋಚನೆ. ನೀವು ಅದನ್ನು ನಿರ್ದಿಷ್ಟ ರೀತಿಯಲ್ಲಿ ಸುಧಾರಿಸಲು ಕೇಳಬಹುದು, ಉದಾಹರಣೆಗೆ ವಾಸ್ತುಶಿಲ್ಪ, ಕಾರ್ಯಕ್ಷಮತೆ, ಭದ್ರತೆ ಇತ್ಯಾದಿ.
ನಾನು ಏಕೆ ಚೈನ್-ಆಫ್-ಥಾಟ್ ಪ್ರಾಂಪ್ಟಿಂಗ್ ಬಳಸಬೇಕು? 1 ಸರಿಯಾದ ಪ್ರತಿಕ್ರಿಯೆ ಮತ್ತು 2 ತಪ್ಪು ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ತೋರಿಸಿ.
- LLM ಗೆ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಬೇಕೆಂದು ಕಲಿಸಲು.
- B, LLM ಗೆ ಕೋಡ್ನಲ್ಲಿ ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕಲಿಸಲು.
- C, LLM ಗೆ ವಿಭಿನ್ನ ಪರಿಹಾರಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸೂಚಿಸಲು.
ಉತ್ತರ: 1, ಏಕೆಂದರೆ ಚೈನ್-ಆಫ್-ಥಾಟ್ LLM ಗೆ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ವಿಧಾನವನ್ನು ಹಂತಗಳ ಸರಣಿಯನ್ನು ನೀಡುವ ಮೂಲಕ ಮತ್ತು ಸಮಾನ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಲಾಯಿತು ಎಂಬುದನ್ನು ತೋರಿಸುವುದರ ಬಗ್ಗೆ.
ನೀವು ಕಾರ್ಯದಲ್ಲಿ ಸ್ವ-ಸಂಶೋಧನೆ ತಂತ್ರವನ್ನು ಬಳಸಿ. ನೀವು ನಿರ್ಮಿಸಿದ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಅದಕ್ಕೆ ನೀವು ಅನ್ವಯಿಸಲು ಬಯಸುವ ಸುಧಾರಣೆಗಳನ್ನು ಪರಿಗಣಿಸಿ. ಈಗ ಸ್ವ-ಸಂಶೋಧನೆ ತಂತ್ರವನ್ನು ಬಳಸಿ ಪ್ರಸ್ತಾಪಿತ ಬದಲಾವಣೆಗಳನ್ನು ಅನ್ವಯಿಸಿ. ಫಲಿತಾಂಶವನ್ನು ನೀವು ಹೇಗೆ ಭಾವಿಸಿದ್ದೀರಿ, ಉತ್ತಮ ಅಥವಾ ಕೆಟ್ಟ?
ಈ ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ನಮ್ಮ ಜನರೇಟಿವ್ AI ಅಧ್ಯಯನ ಸಂಗ್ರಹ ಅನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಜನರೇಟಿವ್ AI ಜ್ಞಾನವನ್ನು ಮತ್ತಷ್ಟು ಹೆಚ್ಚಿಸಿ!
ನಾವು ಪ್ರಾಂಪ್ಟ್ ಎಂಜಿನಿಯರಿಂಗ್ ಜ್ಞಾನವನ್ನು ಅನ್ವಯಿಸುವ 6ನೇ ಪಾಠಕ್ಕೆ ಹೋಗಿ, ಅಲ್ಲಿ ನಾವು ಪಠ್ಯ ಉತ್ಪಾದನಾ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ನಿರ್ಮಿಸುವುದನ್ನು ಮಾಡುತ್ತೇವೆ.
ಅಸ್ವೀಕರಣ:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.