ತೂಕಯುಕ್ತ ಬಹು-ಮಾನದಂಡ ಮೌಲ್ಯಮಾಪನದೊಂದಿಗೆ AI ಬಳಕೆ ಪ್ರಕರಣಗಳಿಗೆ ಅಂಕ ನೀಡಿ

ಪರಿಚಯ

ನೀವು ಕ್ಲೈಂಟ್ ಡಿಸ್ಕವರಿ ವರ್ಕ್‌ಶಾಪ್ ನಡೆಸುತ್ತಿರುವಾಗ, ಇಪ್ಪತ್ತು AI ಯೂಸ್‌ಕೇಸ್‌ಗಳನ್ನು ಕೇವಲ ಅಂತಃಪ್ರಜ್ಞೆಯಿಂದ ಹೋಲಿಸುವುದು ಅವಕಾಶಗಳನ್ನು ಕೈತಪ್ಪಿಸುವುದಕ್ಕೆ ಮತ್ತು ತಪ್ಪಾದ ಆದ್ಯತೆಯ ಹೂಡಿಕೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಸಂಸ್ಥೆಗಳಿಗೆ ಪ್ರತಿ ಅಭ್ಯರ್ಥಿಯನ್ನು ಉತ್ಪಾದನಾ ಯಶಸ್ಸನ್ನು ನಿಜವಾಗಿ ಮುನ್ಸೂಚಿಸುವ ಆಯಾಮಗಳಾದ್ಯಂತ ಸ್ಕೋರ್ ಮಾಡಲು ಪುನರಾವರ್ತಿಸಬಹುದಾದ, ವಸ್ತುನಿಷ್ಠ ವಿಧಾನ ಬೇಕು — ಕೇವಲ ಕಾರ್ಯನಿರ್ವಾಹಕರ ಉತ್ಸಾಹ ಅಥವಾ ಎಂಜಿನಿಯರಿಂಗ್ ನವೀನತೆ ಅಲ್ಲ. ಈ ಪಾಠದ ಅಂತ್ಯದ ವೇಳೆಗೆ, ನೀವು ಪ್ರತಿ ಯೂಸ್‌ಕೇಸ್‌ನ್ನು ವ್ಯವಹಾರ ಪರಿಣಾಮ, ತಾಂತ್ರಿಕ ಕಾರ್ಯಸಾಧ್ಯತೆ, ಡೇಟಾ ಸಿದ್ಧತೆ ಮತ್ತು ಮೌಲ್ಯ-ತಲುಪುವ-ಸಮಯದ ಆಧಾರದಲ್ಲಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡುವ ತೂಕಯುತ ಸ್ಕೋರಿಂಗ್ ಎಂಜಿನ್ ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಕ್ಲೈಂಟ್‌ಗಳು ತಕ್ಷಣ ಕ್ರಮ ಕೈಗೊಳ್ಳಬಹುದಾದ ರಚನಾತ್ಮಕ LLM ಔಟ್‌ಪುಟ್‌ಗಳ ಬೆಂಬಲವಿರುವ ಶ್ರೇಣೀಕೃತ ಶಾರ್ಟ್‌ಲಿಸ್ಟ್ ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಪರಿಭಾಷೆ

• ತೂಕಯುತ ಸ್ಕೋರಿಂಗ್ ಎಂಜಿನ್ (Weighted Scoring Engine) — ಪ್ರತಿ AI ಯೂಸ್‌ಕೇಸ್‌ನ್ನು ಹೆಸರಿಸಲಾದ ಆಯಾಮಗಳಾದ್ಯಂತ ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ, ಪ್ರತಿ ಆಯಾಮದ ಸ್ಕೋರ್‌ನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ ತೂಕದಿಂದ ಗುಣಿಸಿ, ಗುಣಲಬ್ಧಗಳನ್ನು ಒಂದೇ weighted_total ಫ್ಲೋಟ್‌ಗೆ ಸಂಕಲಿಸುವ ವ್ಯವಸ್ಥೆ; ಇದು ಡಿಸ್ಕವರಿ ವರ್ಕ್‌ಶಾಪ್‌ನಲ್ಲಿ ಹೊರಹೊಮ್ಮಿದ ಎಲ್ಲಾ ಅಭ್ಯರ್ಥಿಗಳಾದ್ಯಂತ ವಸ್ತುನಿಷ್ಠ, ಹೋಲಿಸಬಹುದಾದ ಶ್ರೇಣೀಕರಣವನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.
• CriterionScore — ಒಂದು ಮೌಲ್ಯಮಾಪನ ಆಯಾಮದ ಔಟ್‌ಪುಟ್‌ನ್ನು ಪ್ರತಿನಿಧಿಸುವ Pydantic ಮಾಡೆಲ್: ಮಿತಿಯೊಳಗಿನ ಸಂಖ್ಯಾತ್ಮಕ score (0–10), confidence ಮೌಲ್ಯ (0–1), ಮತ್ತು ರೇಟಿಂಗ್‌ನ್ನು ವಿವರಿಸುವ ಮುಕ್ತ-ಪಠ್ಯ reasoning ಸ್ಟ್ರಿಂಗ್; ಪ್ರತಿ UseCaseEvaluation ಒಳಗೆ ನಾಲ್ಕು CriterionScore ನಮೂದುಗಳು — ಪ್ರತಿ ಆಯಾಮಕ್ಕೆ ಒಂದು — ಸಂಗ್ರಹವಾಗುತ್ತವೆ.
• UseCaseEvaluation — ಒಂದೇ ಅಭ್ಯರ್ಥಿಗಾಗಿ ಸ್ಕೋರಿಂಗ್ ಎಂಜಿನ್ ಹಿಂತಿರುಗಿಸುವ ಉನ್ನತ-ಹಂತದ Pydantic ಸ್ಕೀಮಾ; ಇದು CriterionScore ನಮೂದುಗಳ ಪಟ್ಟಿ, weighted_total ಫ್ಲೋಟ್, recommendation ಸ್ಟ್ರಿಂಗ್, ಮತ್ತು risks ಪಟ್ಟಿಯನ್ನು ಒಳಗೊಂಡಿದೆ — ತಕ್ಷಣದ ಶ್ರೇಣೀಕರಣಕ್ಕೆ ಸಿದ್ಧವಾದ ಸಂಪೂರ್ಣ ರಚನಾತ್ಮಕ ತೀರ್ಪು.
• ScoringCriteria — ನಾಲ್ಕು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದ ಆಯಾಮ ತೂಕಗಳನ್ನು (business_impact_weight, technical_feasibility_weight, data_readiness_weight, time_to_value_weight) ಹೊಂದಿರುವ Pydantic ಮಾಡೆಲ್; ಡೀಫಾಲ್ಟ್‌ಗಳು (0.35 / 0.25 / 0.25 / 0.15) ವ್ಯವಹಾರ ಪರಿಣಾಮಕ್ಕೆ ಒಲವು ತೋರಿಸುತ್ತಾ, ತಾಂತ್ರಿಕ ಕಾರ್ಯಸಾಧ್ಯತೆ ಮತ್ತು ಡೇಟಾ ಸಿದ್ಧತೆಯನ್ನು ಸಮಾನವಾಗಿ ಪರಿಗಣಿಸುತ್ತವೆ.
• Instructor — instructor.from_openai() ಮೂಲಕ ಪ್ರಮಾಣಿತ OpenAI ಕ್ಲೈಂಟ್‌ನ್ನು ಪ್ಯಾಚ್ ಮಾಡುವ Python ಲೈಬ್ರರಿ; ಇದು chat.completions.create() ಗೆ ಸ್ಕೀಮಾ ಜಾರಿಯನ್ನು ಸೇರಿಸುತ್ತದೆ, ಇದರಿಂದ LLM ನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು response_model Pydantic ಕ್ಲಾಸ್‌ಗೆ ಎದುರಾಗಿ ಮಾನ್ಯಗೊಳಿಸಿ, ತಪ್ಪಾದ ಔಟ್‌ಪುಟ್ ಬಂದಾಗ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುಪ್ರಯತ್ನಿಸಲಾಗುತ್ತದೆ — ಕಚ್ಚಾ ಪಠ್ಯದ ಬದಲು ಟೈಪ್ ಮಾಡಿದ Python ಆಬ್ಜೆಕ್ಟ್ ಹಿಂತಿರುಗುತ್ತದೆ.

ಪರಿಕಲ್ಪನೆಗಳು

ಎಂಜಿನಿಯರಿಂಗ್ ಶಿಸ್ತಾಗಿ ಸ್ಕೋರಿಂಗ್

ಡಿಸ್ಕವರಿ ವರ್ಕ್‌ಶಾಪ್‌ಗಳು ಒಂದೇ ಸೆಷನ್‌ನಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಹದಿನೈದರಿಂದ ಮೂವತ್ತು AI ಯೂಸ್‌ಕೇಸ್ ಅಭ್ಯರ್ಥಿಗಳನ್ನು ಹೊರತರುತ್ತವೆ. ಅವುಗಳನ್ನು ಅಂತಃಪ್ರಜ್ಞೆಯಿಂದ ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು — "ಇದು ಪರಿಣಾಮಕಾರಿ ಅನಿಸುತ್ತದೆ," "ಅದು ಕಷ್ಟವೆನಿಸುತ್ತದೆ" — ಉತ್ಪಾದನಾ ಯಶಸ್ಸನ್ನು ನಿಜವಾಗಿ ಮುನ್ಸೂಚಿಸುವುದನ್ನು ಪ್ರತಿಫಲಿಸುವ ಬದಲು ಯಾರು ಹೆಚ್ಚು ಗಟ್ಟಿಯಾಗಿ ಮಾತನಾಡುತ್ತಾರೋ ಅದನ್ನು ಪ್ರತಿಫಲಿಸುವ ಶ್ರೇಣೀಕರಣಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ತೂಕಯುತ ಸ್ಕೋರಿಂಗ್ ಎಂಜಿನ್ ಆ ವ್ಯಕ್ತಿನಿಷ್ಠ ಕಸರತ್ತನ್ನು ಪುನರಾವರ್ತಿಸಬಹುದಾದ ಲೆಕ್ಕಾಚಾರವಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ: ಪ್ರತಿ ಯೂಸ್‌ಕೇಸ್‌ನ್ನು ನಿಗದಿತ ಆಯಾಮಗಳ ಗುಂಪಿನಾದ್ಯಂತ ಸ್ವತಂತ್ರವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ, ಪ್ರತಿ ಆಯಾಮವು ಮಿತಿಯೊಳಗಿನ ಸ್ಕೋರ್ ಮತ್ತು ವಿಶ್ವಾಸ ಮೌಲ್ಯವನ್ನು ನೀಡುತ್ತದೆ, ಮತ್ತು ಒಂದೇ ತೂಕಯುತ ಮೊತ್ತವು ಅಂತಿಮ ಶ್ರೇಣೀಕರಣವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.

ನಿರ್ಣಾಯಕ ವಿನ್ಯಾಸ ಒಳನೋಟವೆಂದರೆ, ಆಯಾಮಗಳು ಮತ್ತು ಅವುಗಳ ತೂಕಗಳು AI ಯೋಜನೆಯು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಯಶಸ್ವಿಯಾಗಲು ಏನು ಬೇಕು ಎಂಬ ನಿಮ್ಮ ನಂಬಿಕೆಗಳನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡುತ್ತವೆ. ಆ ತೂಕಗಳು ScoringCriteria ಒಳಗೆ ಸರಳ Pydantic ಫೀಲ್ಡ್‌ಗಳಾಗಿ ಇರುವುದರಿಂದ, ನಿರ್ದಿಷ್ಟ ಕ್ಲೈಂಟ್‌ಗಾಗಿ ಅವುಗಳನ್ನು ಹೊಂದಿಸುವುದು — ಉದಾಹರಣೆಗೆ, ದೀರ್ಘ ಹೂಡಿಕೆ ಅವಧಿಯ ಕಂಪನಿಗಾಗಿ ಮೌಲ್ಯ-ತಲುಪುವ-ಸಮಯದ ತೂಕವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು — ಮೌಲ್ಯಮಾಪನ ತರ್ಕವನ್ನು ಮರುಬರೆಯುವ ಬದಲು ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ನ್ನು ಸಂಪಾದಿಸುವುದನ್ನು ಮಾತ್ರ ಬಯಸುತ್ತದೆ.

ನಾಲ್ಕು ಆಯಾಮಗಳು ಮತ್ತು ಡೀಫಾಲ್ಟ್‌ಗಳನ್ನು ಹೀಗೇ ಹೊಂದಿಸಿರುವುದಕ್ಕೆ ಕಾರಣ

ಎಂಜಿನ್ ಪ್ರತಿ ಅಭ್ಯರ್ಥಿಯನ್ನು ನಾಲ್ಕು ಪರಸ್ಪರ ಸ್ವತಂತ್ರ ಆಯಾಮಗಳಾದ್ಯಂತ ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ. ವ್ಯವಹಾರ ಪರಿಣಾಮ (ತೂಕ 0.35) ತಲುಪಿಸಿದ ಮೌಲ್ಯವನ್ನು — ಆದಾಯ, ವೆಚ್ಚ ಕಡಿತ, ಸ್ಪರ್ಧಾತ್ಮಕ ಅನುಕೂಲ — ಸೆರೆಹಿಡಿಯುತ್ತದೆ ಮತ್ತು ಅತಿ ಹೆಚ್ಚು ತೂಕವನ್ನು ಹೊಂದಿದೆ, ಏಕೆಂದರೆ ವ್ಯವಹಾರ ಮೌಲ್ಯವಿಲ್ಲದ ತಾಂತ್ರಿಕ ಸೊಬಗು ಎಂದಿಗೂ ಉತ್ಪಾದನೆಗೆ ತಲುಪುವುದಿಲ್ಲ. ತಾಂತ್ರಿಕ ಕಾರ್ಯಸಾಧ್ಯತೆ (0.25) ಪ್ರಸ್ತುತ ಮಾಡೆಲ್ ಸಾಮರ್ಥ್ಯಗಳು ಕಾರ್ಯದ ಪ್ರಕಾರಕ್ಕೆ ಅಗತ್ಯವಾದ ನಿಖರತೆ ಮತ್ತು ಲೇಟೆನ್ಸಿ ಮಿತಿಗಳನ್ನು ಪೂರೈಸಬಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಡೇಟಾ ಸಿದ್ಧತೆ (0.25) ಅಗತ್ಯವಾದ ಡೇಟಾ ಸ್ವತ್ತುಗಳು — ಪ್ರಮಾಣ, ಗುಣಮಟ್ಟ, ಲಭ್ಯತೆ, ಲೇಬಲ್‌ಗಳು, ನಿಯಂತ್ರಕ ಅನುಮತಿ — ನಿಜವಾಗಿ ಲಭ್ಯವಿದೆಯೇ ಎಂದು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ; ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಲೇಬಲ್ ಮಾಡಿದ ಡೇಟಾದ ಮೇಲೆ ನಿರ್ಮಿಸಿದ ಹೆಚ್ಚು-ಪರಿಣಾಮದ ಕಲ್ಪನೆ ಇಲ್ಲಿ ಶೂನ್ಯಕ್ಕೆ ಸಮೀಪ ಸ್ಕೋರ್ ಪಡೆಯುತ್ತದೆ. ಮೌಲ್ಯ-ತಲುಪುವ-ಸಮಯ (0.15) ಯೋಜನೆಯು ಎಷ್ಟು ಬೇಗ ಅಳೆಯಬಹುದಾದ ಫಲಿತಾಂಶಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಎಂದು ಅಂದಾಜಿಸುತ್ತದೆ; ಇದು ಸಾಂಸ್ಥಿಕ ವಿಶ್ವಾಸವನ್ನು ಬೆಳೆಸುವ ಆರಂಭಿಕ ಗೆಲುವುಗಳ ಕಡೆಗೆ ಶಾರ್ಟ್‌ಲಿಸ್ಟ್‌ನ್ನು ತಳ್ಳುವ ಟೈಬ್ರೇಕರ್ ಆಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

ಡೀಫಾಲ್ಟ್ ತೂಕಗಳು ಕಾರ್ಯಸಾಧ್ಯತೆ ಮತ್ತು ಡೇಟಾ ಸಿದ್ಧತೆಯನ್ನು ಸಮಾನವಾಗಿ ಪರಿಗಣಿಸುತ್ತವೆ, ಏಕೆಂದರೆ ಸಾಮಾನ್ಯ ವೈಫಲ್ಯ ವಿಧಾನವೆಂದರೆ ಡೇಟಾ-ಸಿದ್ಧ ಸಮಸ್ಯೆಗಳಿಗಿಂತ ತಾಂತ್ರಿಕವಾಗಿ ಸುಲಭವಾದ ಸಮಸ್ಯೆಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡುವುದು; ಇದು ಡೇಟಾ ಪೈಪ್‌ಲೈನ್ ವೆಚ್ಚಗಳು ಮತ್ತು ಸಿದ್ಧತೆ ಕಾಲಾವಧಿಗಳನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿ ಕಡಿಮೆ ಅಂದಾಜಿಸುತ್ತದೆ. ಅವುಗಳನ್ನು ಸಮಾನವಾಗಿ ಇಡುವುದು ಸ್ಕೋರಿಂಗ್ ಎಂಜಿನ್‌ನ್ನು — ಮತ್ತು ಅದರ ಔಟ್‌ಪುಟ್ ಓದುವ ವರ್ಕ್‌ಶಾಪ್ ಭಾಗವಹಿಸುವವರನ್ನು — ಎರಡೂ ಆಯಾಮಗಳನ್ನು ಒಟ್ಟಿಗೆ ಎದುರಿಸುವಂತೆ ಒತ್ತಾಯಿಸುತ್ತದೆ.

ಮಾನ್ಯತಾ ಗೇಟ್ ಆಗಿ Pydantic + Instructor

ಸ್ಕೀಮಾ ಜಾರಿ ಇಲ್ಲದೆ, LLM-ಆಧಾರಿತ ಸ್ಕೋರಿಂಗ್ ಎಂಜಿನ್ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲ: ಮಾಡೆಲ್ ಸ್ಕೋರ್‌ನ್ನು ವಾಕ್ಯವಾಗಿ ವ್ಯಕ್ತಪಡಿಸಬಹುದು, ಒಂದು ಆಯಾಮವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಿಟ್ಟುಬಿಡಬಹುದು, ಅಥವಾ confidence ನ್ನು 0–1 ಫ್ಲೋಟ್ ಬದಲು ಶೇಕಡಾವಾರು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಬಹುದು. ಪರಿಹಾರವೆಂದರೆ ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್‌ನ್ನು Pydantic ಸ್ಕೀಮಾ ಆಗಿ ವ್ಯಾಖ್ಯಾನಿಸುವುದು — ಒಂದು ಆಯಾಮವನ್ನು ಸೆರೆಹಿಡಿಯುವ CriterionScore, ಪೂರ್ಣ ತೀರ್ಪನ್ನು ಸಂಗ್ರಹಿಸುವ UseCaseEvaluation — ಮತ್ತು OpenAI ಕ್ಲೈಂಟ್ ಅದನ್ನು ಜಾರಿಗೊಳಿಸುವಂತೆ ಮಾಡಲು Instructor ಬಳಸುವುದು.

instructor.from_openai() ಪ್ರಮಾಣಿತ ಕ್ಲೈಂಟ್‌ನ್ನು ಪ್ಯಾಚ್ ಮಾಡುತ್ತದೆ, ಇದರಿಂದ chat.completions.create() ಗೆ response_model=UseCaseEvaluation ರವಾನಿಸುವುದು ಉತ್ಪಾದನೆಯ-ನಂತರದ ಮಾನ್ಯಕಾರಕವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ: ಮಾಡೆಲ್‌ನ JSON ಮಾನ್ಯ UseCaseEvaluation ಇನ್‌ಸ್ಟೆನ್ಸ್‌ಗೆ ಪಾರ್ಸ್ ಆಗದಿದ್ದರೆ, Instructor ದೋಷವನ್ನು ಹೊರತರುವ ಮೊದಲು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಇದರ ಲಾಭವೆಂದರೆ ನೀವು ತಕ್ಷಣವೇ ಇತರ ಅಭ್ಯರ್ಥಿಗಳೊಂದಿಗೆ ಸಾರ್ಟ್ ಮಾಡಿ ಕ್ಲೈಂಟ್ ವರದಿಗೆ ಸೀರಿಯಲೈಸ್ ಮಾಡಬಹುದಾದ ಸಂಪೂರ್ಣ ಟೈಪ್ ಮಾಡಿದ Python ಆಬ್ಜೆಕ್ಟ್ — ರೆಜೆಕ್ಸ್ ಇಲ್ಲ, ಸ್ಟ್ರಿಂಗ್ ಪಾರ್ಸಿಂಗ್ ಇಲ್ಲ, ಮುಕ್ತ-ರೂಪದ ಪಠ್ಯವು ಒಳಗೊಂಡಿರಬಹುದಾದ ಅಥವಾ ಇಲ್ಲದಿರಬಹುದಾದ ಫೀಲ್ಡ್‌ಗಳ ಮೇಲೆ ರಕ್ಷಣಾತ್ಮಕ null-ಪರಿಶೀಲನೆಗಳು ಇಲ್ಲ (ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ ನೋಡಿ).

ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ

ನಾಲ್ಕು ತೂಕಯುತ ಸ್ಕೋರಿಂಗ್ ಆಯಾಮಗಳನ್ನು ಈಗ ನೀವು ಅರ್ಥಮಾಡಿಕೊಂಡಿರುವುದರಿಂದ, ವರ್ಕ್‌ಶಾಪ್ ಹೊರತರುವ ಪ್ರತಿ ಯೂಸ್‌ಕೇಸ್‌ಗೆ ಅವುಗಳನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿ ಅನ್ವಯಿಸುವ ಎಂಜಿನ್‌ನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸೋಣ.

ಪೈಪ್‌ಲೈನ್ ಎರಡು ಭಾಗಗಳನ್ನು ಹೊಂದಿದೆ: ಮೌಲ್ಯಮಾಪನ ಸ್ಕೀಮಾವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ Pydantic ಮಾಡೆಲ್‌ಗಳ ಗುಂಪು, ಮತ್ತು LLM ಮುಕ್ತ-ರೂಪದ ಪಠ್ಯದ ಬದಲು ಆ ಸ್ಕೀಮಾದ ಮಾನ್ಯ ಇನ್‌ಸ್ಟೆನ್ಸ್‌ನ್ನು ಹಿಂತಿರುಗಿಸುವಂತೆ ಒತ್ತಾಯಿಸುವ Instructor-ಪ್ಯಾಚ್ ಮಾಡಿದ OpenAI ಕ್ಲೈಂಟ್.

CriterionScore ಒಂದು ಆಯಾಮದ ಔಟ್‌ಪುಟ್‌ನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆ — ಮಿತಿಯೊಳಗಿನ ಸ್ಕೋರ್ (0–10), ವಿಶ್ವಾಸ ಮೌಲ್ಯ (0–1), ಮತ್ತು ಮುಕ್ತ-ಪಠ್ಯ ತಾರ್ಕಿಕ ಫೀಲ್ಡ್. UseCaseEvaluation ಈ ಮಾನದಂಡ ಸ್ಕೋರ್‌ಗಳನ್ನು weighted_total, recommendation, ಮತ್ತು risks ಪಟ್ಟಿಯಾಗಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ScoringCriteria ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದ ತೂಕಗಳನ್ನು ಹೊಂದಿದೆ; ಡೀಫಾಲ್ಟ್‌ಗಳು (0.35 / 0.25 / 0.25 / 0.15) ವ್ಯವಹಾರ ಪರಿಣಾಮಕ್ಕೆ ಒಲವು ತೋರಿಸುತ್ತಾ, ತಾಂತ್ರಿಕ ಕಾರ್ಯಸಾಧ್ಯತೆ ಮತ್ತು ಡೇಟಾ ಸಿದ್ಧತೆಯನ್ನು ಸಮಾನ ತೂಕದಲ್ಲಿ ಇಡುತ್ತವೆ, ಮೌಲ್ಯ-ತಲುಪುವ-ಸಮಯ ಅತಿ ಕಡಿಮೆ ತೂಕದ ಅಂಶವಾಗಿದೆ.

Code snippetpython
1from pydantic import BaseModel, Field
2from typing import List
3
4class CriterionScore(BaseModel):
5    criterion: str
6    score: float = Field(ge=0, le=10)
7    confidence: float = Field(ge=0, le=1)
8    reasoning: str
9
10class UseCaseEvaluation(BaseModel):
11    use_case_name: str
12    scores: List[CriterionScore]
13    weighted_total: float
14    recommendation: str
15    risks: List[str]
16
17class ScoringCriteria(BaseModel):
18    business_impact_weight: float = 0.35
19    technical_feasibility_weight: float = 0.25
20    data_readiness_weight: float = 0.25
21    time_to_value_weight: float = 0.15

ಸ್ಕೀಮಾ ಸಿದ್ಧವಾದ ಮೇಲೆ, instructor.from_openai() ಪ್ರಮಾಣಿತ OpenAI ಕ್ಲೈಂಟ್‌ನ್ನು ಪ್ಯಾಚ್ ಮಾಡುತ್ತದೆ, ಇದರಿಂದ chat.completions.create() ಹಿಂತಿರುಗಿಸುವ ಮೊದಲು ಮಾಡೆಲ್‌ನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು response_model=UseCaseEvaluation ಗೆ ಎದುರಾಗಿ ಮಾನ್ಯಗೊಳಿಸುತ್ತದೆ. ಮಾಡೆಲ್ ತಪ್ಪಾದ ಔಟ್‌ಪುಟ್ ಉತ್ಪಾದಿಸಿದರೆ, Instructor ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಫಲಿತಾಂಶವು ಟೈಪ್ ಮಾಡಿದ UseCaseEvaluation ಆಬ್ಜೆಕ್ಟ್, ಇದನ್ನು ನೀವು ತಕ್ಷಣವೇ ಇತರ ಅಭ್ಯರ್ಥಿಗಳೊಂದಿಗೆ ಸಾರ್ಟ್ ಮಾಡಬಹುದು — ಕೈಯಾರೆ ಪಠ್ಯ ಪಾರ್ಸಿಂಗ್ ಅಗತ್ಯವಿಲ್ಲ.

Code snippetpython
1import instructor
2import openai
3
4proxy_url = "http://openai-proxy:8080"
5scoring_prompt = (
6    "Evaluate this AI use case across Business Impact, Technical Feasibility, "
7    "Data Readiness, and Time-to-Value. Score each dimension 0–10 with reasoning."
8)
9use_case_description = (
10    "Automate invoice extraction from scanned PDFs using a vision model."
11)
12
13client = instructor.from_openai(
14    openai.OpenAI(api_key="student-token", base_url=proxy_url)
15)
16
17evaluation = client.chat.completions.create(
18    model="gpt-4o",
19    response_model=UseCaseEvaluation,
20    messages=[
21        {"role": "system", "content": scoring_prompt},
22        {"role": "user", "content": use_case_description},
23    ],
24)
25
26print(evaluation.use_case_name, evaluation.weighted_total, evaluation.recommendation)
27for s in evaluation.scores:
28    print(f"  {s.criterion}: {s.score}/10 (confidence {s.confidence:.2f}) — {s.reasoning}")

ಸ್ಕ್ರಿಪ್ಟ್ ರನ್ ಮಾಡಿ, evaluation.scores ನಾಲ್ಕು CriterionScore ನಮೂದುಗಳನ್ನು — ಪ್ರತಿ ತೂಕಯುತ ಆಯಾಮಕ್ಕೆ ಒಂದು — ಹೊಂದಿದೆಯೇ ಮತ್ತು evaluation.weighted_total 0 ಮತ್ತು 10 ನಡುವಿನ ಫ್ಲೋಟ್ ಆಗಿದೆಯೇ ಎಂದು ದೃಢೀಕರಿಸುವ ಮೂಲಕ ಪರಿಶೀಲಿಸಿ.

ಶಿಸ್ತು ಅನ್ವಯ

ಮಾಡಬೇಕಾದವು ಮತ್ತು ಮಾಡಬಾರದವು

ಮೇಲಿನ ವಿಷಯವನ್ನು ಅವಲೋಕಿಸಿದ ನಂತರ, ಕೆಳಗಿನ ಮಾಡಬೇಕಾದವು ಮತ್ತು ಮಾಡಬಾರದವು ಅದನ್ನು ಅಭ್ಯಾಸವಾಗಿ ಸಂಕ್ಷೇಪಿಸುತ್ತವೆ.

ಮಾಡಬೇಕಾದವು

1. CriterionScore ಮತ್ತು UseCaseEvaluation ನ್ನು ಮಿತಿಯುತ Field ನಿರ್ಬಂಧಗಳೊಂದಿಗೆ Pydantic ಮಾಡೆಲ್‌ಗಳಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಿ — score ಮೇಲಿನ ge=0, le=10 ಮಿತಿ ಮತ್ತು confidence ಮೇಲಿನ ge=0, le=1 ಮಿತಿ ಪಾರ್ಸ್ ಸಮಯದಲ್ಲೇ ಅರ್ಥಪೂರ್ಣ ಮಾನ್ಯತೆಯನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತವೆ, ಇದರಿಂದ 15 ಎಂಬ ಭ್ರಮಿತ ಸ್ಕೋರ್ ಅಥವಾ 2.0 ಎಂಬ ವಿಶ್ವಾಸ ಮೌಲ್ಯವು ಕೆಟ್ಟ ಮೌಲ್ಯ ನಿಮ್ಮ ಶ್ರೇಣೀಕರಣ ತರ್ಕಕ್ಕೆ ತಲುಪುವ ಮೊದಲು ಮಾನ್ಯತಾ ದೋಷವನ್ನು ಎಬ್ಬಿಸುತ್ತದೆ.
2. OpenAI ಕ್ಲೈಂಟ್‌ನ್ನು instructor.from_openai() ಮೂಲಕ ಪ್ಯಾಚ್ ಮಾಡಿ ಮತ್ತು response_model=UseCaseEvaluation ರವಾನಿಸಿ — ಇದು LLM ಮುಕ್ತ-ರೂಪದ ಪಠ್ಯದ ಬದಲು ರಚನಾತ್ಮಕ, ಟೈಪ್ ಮಾಡಿದ ಇನ್‌ಸ್ಟೆನ್ಸ್‌ನ್ನು ಹಿಂತಿರುಗಿಸುವಂತೆ ಒತ್ತಾಯಿಸುತ್ತದೆ, ಕೈಯಾರೆ JSON ಪಾರ್ಸಿಂಗ್‌ನ್ನು ನಿವಾರಿಸುತ್ತದೆ ಮತ್ತು ತಪ್ಪಾದ ಮಾಡೆಲ್ ಔಟ್‌ಪುಟ್‌ನಿಂದ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಚೇತರಿಸಿಕೊಳ್ಳಲು Instructor ಗೆ ಅಗತ್ಯವಾದ ಮರುಪ್ರಯತ್ನ ಹುಕ್ ನೀಡುತ್ತದೆ.
3. ವರ್ಕ್‌ಶಾಪ್ ನಡೆಸುವ ಮೊದಲು ScoringCriteria ತೂಕಗಳನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಹೊಂದಿಸಿ — ಡೀಫಾಲ್ಟ್‌ಗಳು (0.35 / 0.25 / 0.25 / 0.15) ವ್ಯವಹಾರ ಪರಿಣಾಮವು ಮೌಲ್ಯ-ತಲುಪುವ-ಸಮಯವನ್ನು ಮೀರಿಸುತ್ತದೆ ಎಂಬ ಸ್ಪಷ್ಟ ಪೂರ್ವಗ್ರಹವನ್ನು ಒಳಗೊಂಡಿವೆ; ಕ್ಲೈಂಟ್ ಕಾರಣವಿಲ್ಲದೆ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸುವುದು ಶ್ರೇಣೀಕೃತ ಶಾರ್ಟ್‌ಲಿಸ್ಟ್‌ನ್ನು ಮೌನವಾಗಿ ಬದಲಿಸುತ್ತದೆ ಮತ್ತು ಎಂಜಿನ್ ಒದಗಿಸಲು ವಿನ್ಯಾಸಗೊಂಡ ಪುನರಾವರ್ತನೀಯತೆಯನ್ನು ದುರ್ಬಲಗೊಳಿಸುತ್ತದೆ.

ಮಾಡಬಾರದವು

1. response_model ಆರ್ಗ್ಯುಮೆಂಟ್‌ನ್ನು ಬಿಟ್ಟು LLM ನ ಪಠ್ಯ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕೈಯಾರೆ ಪಾರ್ಸ್ ಮಾಡಬೇಡಿ — ಹಾಗೆ ಮಾಡುವುದು Instructor ನ ಮಾನ್ಯತೆ-ಮತ್ತು-ಮರುಪ್ರಯತ್ನ ಲೂಪ್‌ನ್ನು ಬೈಪಾಸ್ ಮಾಡುತ್ತದೆ, ಅಂದರೆ ಒಂದೇ ತಪ್ಪಾದ ಕಂಪ್ಲೀಷನ್ ಕಾಣೆಯಾದ scores ನಮೂದುಗಳೊಂದಿಗೆ ಅಥವಾ None ಆಗಿರುವ weighted_total ಜೊತೆಗೆ ಅಪೂರ್ಣ UseCaseEvaluation ನ್ನು ಮೌನವಾಗಿ ಉತ್ಪಾದಿಸಿ, ದೋಷ ಎಬ್ಬಿಸದೆ ಶ್ರೇಣೀಕೃತ ಔಟ್‌ಪುಟ್‌ನ್ನು ಭ್ರಷ್ಟಗೊಳಿಸುತ್ತದೆ.
2. ScoringCriteria ತೂಕಗಳನ್ನು ಅನ್ವಯಿಸದೆ ಕಚ್ಚಾ CriterionScore.score ಮೌಲ್ಯಗಳನ್ನು ಸಂಕಲಿಸಿ weighted_total ನ್ನು ಕ್ಲೈಂಟ್-ಬದಿಯಲ್ಲಿ ಲೆಕ್ಕಹಾಕಲು ಬಿಡಬೇಡಿ — 0.35 / 0.25 / 0.25 / 0.15 ಗುಣಕಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುವುದು ನಾಲ್ಕೂ ಆಯಾಮಗಳನ್ನು ಸಮಾನ ಪ್ರಾಮುಖ್ಯತೆಗೆ ಕುಗ್ಗಿಸುತ್ತದೆ, ತಾಂತ್ರಿಕವಾಗಿ ಸುಲಭವಾದರೂ ಕಡಿಮೆ-ಮೌಲ್ಯದ ಅಭ್ಯರ್ಥಿಗಳಿಗಿಂತ ಅಸಾಧಾರಣ ವ್ಯವಹಾರ ಪರಿಣಾಮವಿರುವ ಯೂಸ್‌ಕೇಸ್‌ಗಳನ್ನು ಹೊರತರುವ ಮಾಡೆಲ್‌ನ ಸಾಮರ್ಥ್ಯವನ್ನು ವಿಫಲಗೊಳಿಸುತ್ತದೆ.
3. ಒಂದೇ UseCaseEvaluation ಇನ್‌ಸ್ಟೆನ್ಸ್‌ನ್ನು ಅದರ ಫೀಲ್ಡ್‌ಗಳನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಹಲವು ಯೂಸ್‌ಕೇಸ್ ವಿವರಣೆಗಳಾದ್ಯಂತ ಮರುಬಳಸಬೇಡಿ — client.chat.completions.create() ಗೆ ಪ್ರತಿ ಕರೆಯೂ ಹೊಸ use_case_description ಪಡೆದು ಹೊಸ UseCaseEvaluation ಆಬ್ಜೆಕ್ಟ್ ಹಿಂತಿರುಗಿಸಬೇಕು; ಅಭ್ಯರ್ಥಿಗಳಾದ್ಯಂತ ಮೌಲ್ಯಮಾಪನ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಮರುಬಳಸುವುದು ಅಥವಾ ನಕಲಿಸುವುದು risks ಪಟ್ಟಿ ಮತ್ತು recommendation ನ್ನು ಹಿಂದಿನ ಯೂಸ್‌ಕೇಸ್‌ನ ಡೇಟಾದಿಂದ ಭ್ರಷ್ಟಗೊಳಿಸಿ, ತಪ್ಪುದಾರಿಗೆಳೆಯುವ ಶಾರ್ಟ್‌ಲಿಸ್ಟ್ ಉತ್ಪಾದಿಸುತ್ತದೆ.