GitHub Actions merge queue ਦੇ ਅੰਦਰ ਅੱਠ ਮਹੀਨੇ ਬਿਤਾਉਣ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਉਹ ਸਿੱਖਦੇ ਹੋ ਜੋ feature comparison matrices ਕਦੇ ਨਹੀਂ ਸਿਖਾ ਸਕਦੇ। ਇੱਕ ਫਰੇਮਵਰਕ ਪੰਜਾਹ ਮੈਟ੍ਰਿਕਸ, ਸ਼ਾਨਦਾਰ ਡੈਸ਼ਬੋਰਡ ਅਤੇ ਸਤਿਕਾਰਤ ਰਿਸਰਚ ਲੈਬਾਂ ਦੇ ਹਵਾਲੇ ਭੇਜ ਸਕਦਾ ਹੈ। ਪਰ ਜੇਕਰ ਇਹ ਤੁਹਾਡੇ ਡਿਪਲੋਇ (deploy) ਨੂੰ ਇਸ ਲਈ ਰੋਕਦਾ ਹੈ ਕਿਉਂਕਿ ਇੱਕ "vibe check" ਸਕੋਰ ਇੱਕੋ ਜਿਹੇ ਕੋਡ ਦੇ ਵਿਰੁੱਧ 0.72 ਤੋਂ ਘਟ ਕੇ 0.68 ਹੋ ਗਿਆ ਹੈ, ਤਾਂ ਇਹ ਲਾ役に ਤੋਂ ਵੀ ਬਦਤਰ ਹੈ। ਇਹ ਤੁਹਾਡੀ shipping velocity ਲਈ ਇੱਕ ਸਰਗਰਮ ਖਤਰਾ ਬਣ ਜਾਂਦਾ ਹੈ।
ਇਹ ਉਹ ਫਿਲਟਰ ਹੈ ਜੋ ਜ਼ਿਆਦਾਤਰ LLM evaluation roundups miss ਕਰ ਦਿੰਦੇ ਹਨ। ਉਹ ਸਮਰੱਥਾਵਾਂ (capabilities) ਨੂੰ ਗਿਣਦੇ ਹਨ। ਉਹ ਸ਼ਾਇਦ ਹੀ ਉਹ ਇਕਲੌਤਾ ਸਵਾਲ ਪੁੱਛਦੇ ਹਨ ਜੋ ਮਰਜ ਕਿਊ ਵਿੱਚ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ: ਕੀ ਇਹ ਚੈੱਕ ਹਰ ਵਾਰ ਚੱਲਣ 'ਤੇ ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ pass ਅਤੇ fail ਹੁੰਦਾ ਹੈ?
ਮੈਂ ਇਹ ਅਸੁਖਾਵਾਂ ਕੰਮ ਕਰਕੇ ਸਿੱਖਿਆ। ਮੈਂ ਛੇ open-source LLM eval frameworks ਨੂੰ ਇੱਕ ਅਸਲੀ CI pipeline ਨਾਲ ਜੋੜਿਆ। ਉਹ ਅੱਠ ਮਹੀਨਿਆਂ ਤੱਕ ਲਾਈਵ production pull requests 'ਤੇ ਚੱਲਦੇ ਰਹੇ। ਦੋਵਾਂ ਨੇ gatekeepers ਬਣੇ ਰਹਿਣ ਦਾ ਹੱਕ ਕਮਾਇਆ। ਬਾਕੀ ਨੂੰ advisory dashboards ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਗਿਆ, nightly jobs ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਦਿੱਤਾ ਗਿਆ, ਜਾਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ। ਸਬਕ ਸਖ਼ਤ ਅਤੇ ਮਹਿੰਗਾ ਸੀ: ਜਦੋਂ ਤੁਸੀਂ main branch ਦੀ ਰਾਖੀ ਕਰ ਰਹੇ ਹੁੰਦੇ ਹੋ, ਤਾਂ deterministic structure, probabilistic quality ਨਾਲੋਂ ਬਿਹਤਰ ਹੁੰਦਾ ਹੈ।
ਮਰਜ ਗੇਟ (Merge Gate) ਦਾ ਅਸਲੀ ਕੰਮ
ਇੱਕ CI gate ਕੋਈ ਰਿਸਰਚ ਮਾਹੌਲ ਨਹੀਂ ਹੈ। ਇਹ ਇੱਕ bouncer ਹੈ। ਇਸਦਾ ਪੂਰਾ ਮਕਸਦ ਇੱਕ ਖਾਸ ਬਦਲਾਅ ਨੂੰ ਦੇਖਣਾ ਅਤੇ ਹਾਂ ਜਾਂ ਨਾ ਵਿੱਚ ਜਵਾਬ ਦੇਣਾ ਹੈ। ਹਾਂ, ਇਹ PR main branch ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਸਕਦਾ ਹੈ। ਨਹੀਂ, ਇਹ ਨਹੀਂ ਹੋ ਸਕਦਾ। ਉਹ ਜਵਾਬ ਸਕਿੰਟਾਂ ਵਿੱਚ ਆਉਣਾ ਚਾਹੀਦਾ ਹੈ, ਬਹੁਤ ਘੱਟ ਲਾਗਤ ਵਾਲਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਕਦੇ ਵੀ ਪਿਛਲੇ ਸਮੇਂ ਨੂੰ ਬਦਲਣਾ ਨਹੀਂ ਚਾਹੀਦਾ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸ਼ਾਂਤ ਮੰਗਲਵਾਰ ਅਤੇ ਇੱਕ ਭੜਕਵੇਂ ਸ਼ੁੱਕਰਵਾਰ ਨੂੰ ਉਸੇ commit 'ਤੇ ਉਹੀ ਪਾਈਪਲਾਈਨ ਦੁਬਾਰਾ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਨਤੀਜਾ ਬਿਲਕੁਲ ਇੱਕੋ ਜਿਹਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
ਇੱਥੇ ਹੀ ਜ਼ਿਆਦਾਤਰ LLM eval frameworks ਡੋਲ ਜਾਂਦੇ ਹਨ। ਉਹ data scientists ਦੁਆਰਾ data scientists ਲਈ ਬਣਾਏ ਗਏ ਹਨ। ਉਹ insight, exploration, ਅਤੇ nuanced scoring ਲਈ ਆਪਟੀਮਾਈਜ਼ ਕੀਤੇ ਗਏ ਹਨ। ਇੱਕ merge queue binary decisions, ਰਫਤਾਰ, ਅਤੇ zero flakiness ਲਈ ਆਪਟੀਮਾਈਜ਼ ਹੁੰਦਾ ਹੈ। ਉਹ ਦੋਵੇਂ ਟੀਚੇ ਸਿਰਫ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਹੀ ਮਿਲਦੇ ਹਨ।
LLM-as-Judge ਕਿਉਂ ਕਿਊ (Queue) ਨੂੰ ਤੋੜ ਦਿੰਦਾ ਹੈ
ਮੇਰੇ ਟੈਸਟ ਵਿੱਚ ਫੇਲ ਹੋਣ ਵਾਲੇ ਟੂਲਸ ਵਿੱਚ ਇੱਕੋ ਇੱਕ ਡਿਜ਼ਾਈਨ ਦੀ ਗਲਤੀ ਸੀ: ਉਹ ਮੁੱਖ ਗੇਟ ਮਕੈਨਿਜ਼ਮ ਵਜੋਂ LLM-as-judge calls 'ਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਿਰਭਰ ਸਨ।
ਇੱਕ LLM-as-judge prompt ਇੱਕ ਮਾਡਲ ਨੂੰ ਇੱਕ ਆਊਟਪੁੱਟ ਨੂੰ ਇੱਕ ਤੋਂ ਦਸ ਦੇ ਪੈਮਾਨੇ 'ਤੇ ਸਕੋਰ ਕਰਨ ਲਈ, ਜਾਂ ਦੋ ਪ੍ਰਤੀਕਿਰਿਆਵਾਂ ਵਿੱਚੋਂ ਬਿਹਤਰ ਨੂੰ ਚੁਣਨ ਲਈ, ਜਾਂ ਤੱਥਾਂ ਦੀ ਸਹੀਤਾ ਦੀ ਰੇਟਿੰਗ ਕਰਨ ਲਈ ਕਹਿੰਦਾ ਹੈ। ਇਹ ਪਹੁੰਚ ਗੁਣਵੱਤਾ ਦੇ ਰੁਝਾਨਾਂ (quality trends) ਨੂੰ ਸਮਝਣ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ। ਪਰ ਇੱਕ blocking CI ਚੈੱਕ ਲਈ ਇਹ ਜ਼ਹਿਰ ਹੈ। ਇੱਕੋ ਇਨਪੁੱਟ ਵੱਖ-ਵੱਖ ਦਿਨਾਂ 'ਤੇ ਵੱਖ-ਵੱਖ ਸਕੋਰ ਦੇ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ temperature, model versioning, ਅਤੇ prompt formatting ਸਾਰੇ noise ਪੈਦਾ ਕਰਦੇ ਹਨ। ਜਦੋਂ ਉਹ ਸਕੋਰ ਇੱਕ ਸਖ਼ਤ threshold ਅਤੇ ਇੱਕ ਸਖ਼ਤ exit code ਨਾਲ ਜੁੜਿਆ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਡੀ ਕਿਊ ਭਟਕਣ (ghosts) ਕਾਰਨ ਰੁਕ ਜਾਂਦੀ ਹੈ।
ਅਸਫਲਤਾਵਾਂ ਤੇਜ਼ੀ ਨਾਲ ਵਧਦੀਆਂ ਹਨ। ਇੱਕ nondeterministic ਚੈੱਕ ਕਿਊ ਵਿੱਚ ਰੁਕਾਵਟਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਇੰਜੀਨੀਅਰ ਉਦੋਂ ਤੱਕ retry ਕਰਨਾ ਸਿੱਖ ਲੈਂਦੇ ਹਨ ਜਦੋਂ ਤੱਕ ਨੰਬਰ ਅਨੁਕੂਲ ਨਹੀਂ ਆ ਜਾਂਦਾ, ਜੋ ਟੀਮ ਨੂੰ red builds ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨ ਲਈ ਸਿਖਾਉਂਦਾ ਹੈ। Token costs ਵਧਦੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਹਰ retry ਵਧੇਰੇ API credits ਖਰਚ ਕਰਦੀ ਹੈ। ਸਭ ਤੋਂ ਮਾੜੀ ਗੱਲ ਇਹ ਹੈ ਕਿ signal ਦਾ ਕੋਈ ਮਤਲਬ ਨਹੀਂ ਰਹਿੰਦਾ। ਇੱਕ red build ਦਾ ਮਤਲਬ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ "ਤੁਸੀਂ ਇੱਕ bug ਪੈਦਾ ਕੀਤਾ ਹੈ।" ਜੇਕਰ ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ "ਜੱਜ ਮਾਡਲ ਅੱਜ ਬਹੁਤ ਨਖਰੇ ਵਾਲਾ ਹੋ ਗਿਆ ਹੈ," ਤਾਂ ਭਰੋਸਾ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ।
ਬਚੇ ਹੋਏ ਟੂਲਸ ਕੀ ਵੱਖਰਾ ਕਰਦੇ ਹਨ
Promptfoo ਅਤੇ DeepEval ਇਸ ਲਈ ਬਚ ਗਏ ਕਿਉਂਕਿ ਉਹ deterministic ਚੈੱਕਸ ਨੂੰ first-class citizens ਵਜੋਂ ਅਤੇ LLM judge ਸਕੋਰਸ ਨੂੰ secondary, non-blocking signals ਵਜੋਂ ਮੰਨਦੇ ਹਨ। ਉਹ ਸਮਝਦੇ ਹਨ ਕਿ ਇੱਕ ਗੇਟ ਨੂੰ ਇੱਕ exit code ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਨਾ ਕਿ ਇੱਕ ਰਾਏ ਵਾਲੇ floating-point number ਦੀ।
Promptfoo, ਜੋ MIT license ਦੇ ਅਧੀਨ ਰਿਲੀਜ਼ ਕੀਤਾ ਗਿਆ ਹੈ, command line ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਇਹ regex matches, JSON schema validation, contains checks, ਅਤੇ exact string comparisons ਵਰਗੇ assertions ਚਲਾਉਂਦਾ ਹੈ। ਇਹ ਕੋਈ ਫੈਂਸੀ ਚੀਜ਼ ਨਹੀਂ ਹੈ। ਇਹ ਉੱਚ-ਪੱਧਰੀ grep ਅਤੇ jq commands ਹਨ। ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਉਹ CI ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹਨ। ਇੱਕ regex ਜਾਂ ਤਾਂ ਮੈਚ ਹੁੰਦਾ ਹੈ ਜਾਂ ਨਹੀਂ। ਇੱਕ JSON schema ਜਾਂ ਤਾਂ validate ਹੁੰਦਾ ਹੈ ਜਾਂ error ਦਿੰਦਾ ਹੈ। Promptfoo standard Unix exit codes ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ GitHub Actions ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਸਮਝ ਜਾਂਦਾ ਹੈ ਕਿ ਮਰਜ ਨੂੰ ਕਦੋਂ ਰੋਕਣਾ ਹੈ। ਇਹ language-agnostic ਹੈ ਕਿਉਂਕਿ ਇਹ ਇੱਕ CLI tool ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਆਊਟਪੁੱਟਸ ਨੂੰ validate ਕਰਨ ਲਈ Node.js service repo ਦੇ ਅੰਦਰ Python ecosystem ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
DeepEval, ਜੋ Apache 2.0 ਦੇ ਅਧੀਨ ਲਾਇਸੰਸਸ਼ੁਦਾ ਹੈ, Python ਟੀਮਾਂ ਲਈ ਚੋਣ ਹੈ। ਇਹ pytest ਵਾਂਗ ਇੰਟੀਗ੍ਰੇਟ ਹੁੰਦਾ ਹੈ। ਤੁਸੀਂ ਜਾਣੇ-ਪਛਾਣੇ syntax ਵਿੱਚ ਟੈਸਟ ਲਿਖਦੇ ਹੋ, ਅਤੇ ਇੱਕ ਫੇਲ੍ਹ ਹੋਣ 'ਤੇ suite ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਰੁਕ ਜਾਂਦਾ ਹੈ। DeepEval ਮੈਟ੍ਰਿਕਸ ਦਾ ਇੱਕ ਵੱਡਾ ਕੈਟਾਲਾਗ ਪੇਸ਼ ਕਰਦਾ ਹੈ, ਪਰ ਮਹੱਤਵਪੂਰਨ ਵੇਰਵਾ ਇਹ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਸਾਵਧਾਨੀ ਨਾਲ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। Gates ਲਈ deterministic ਜਾਂ heuristic ਮੈਟ੍ਰਿਕਸ 'ਤੇ ਭਰੋਸਾ ਕਰੋ। ਜੇਕਰ ਤੁਸੀਂ G-Eval ਜਾਂ ਹੋਰ judge-based scorers ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ hard asserts ਦੀ ਬਜਾਏ non-blocking report generators ਵਿੱਚ ਲਪੇਟੋ। ਇਸ ਤਰ੍ਹਾਂ ਵਰਤਣ 'ਤੇ, DeepEval ਤੁਹਾਨੂੰ ਇੱਕ research notebook ਦੀ flakiness ਤੋਂ ਬਿਨਾਂ ਇੱਕ testing framework ਦੀ ergonomics ਦਿੰਦਾ ਹੈ।
ਬਾਕੀ ਚਾਰ ਕਿੱਥੇ ਫਿੱਟ ਹੁੰਦੇ ਹਨ
ਉਹ ਚਾਰ ਫਰੇਮਵਰਕ ਜੋ gates ਵਜੋਂ ਨਹੀਂ ਬਚੇ, ਉਹਨਾਂ ਦੀ ਕੀਮਤ ਅਜੇ ਵੀ ਹੈ। ਉਹ ਸਿਰਫ਼ ਤੁਹਾਡੇ toolchain ਵਿੱਚ ਕਿਤੇ ਹੋਰ ਦੇ ਹਨ।
Future AGI (Apache 2.0) ਪੰਜਾਹ ਤੋਂ ਵੱਧ ਮੈਟ੍ਰਿਕਸ (metrics) ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਟੀਮਾਂ ਨੂੰ ਨਿਸ਼ਾਨਾ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਕਸਟਮ SDKs ਬਣਾ ਰਹੀਆਂ ਹਨ। ਇਹ ਮੈਟ੍ਰਿਕਸ ਬਹੁਤ ਵਿਸਤ੍ਰਿਤ ਹਨ। ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਇਹ ਟੂਲ ਉਮੀਦ ਕਰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ CI ਕਿਊ (queue) ਵਿੱਚ ਇਸਨੂੰ ਚਲਾਉਣ ਲਈ ਆਪਣਾ ਖੁਦ ਦਾ ਹਾਰਨੈੱਸ (harness) ਲਿਖੋਗੇ। ਖੋਜ (research) ਦੇ ਸੰਦਰਭ ਵਿੱਚ, ਇਹ ਇੱਕ ਜਾਇਜ਼ ਸਮਝੌਤਾ ਹੈ। ਪਰ ਇੱਕ ਮਰਜ ਕਿਊ (merge queue) ਵਿੱਚ, ਕਸਟਮ ਵਾਇਰਿੰਗ ਦੀ ਹਰ ਪਰਤ ਅਸਥਿਰਤਾ ਦਾ ਇੱਕ ਨਵਾਂ ਸਰੋਤ ਬਣ ਜਾਂਦੀ ਹੈ। ਇਹ ਇੱਕ ਸਮਰੱਥ ਮੁਲਾਂਕਣ ਇੰਜਣ (evaluation engine) ਹੈ, ਪਰ ਤਿਆਰ ਗੇਟਕੀਪਰ ਨਹੀਂ।
RAGAS (Apache 2.0) ਰਿਟ੍ਰੀਵਲ-ਔਗਮੈਂਟਡ ਜਨਰੇਸ਼ਨ (retrieval-augmented generation) ਦੀ ਗੁਣਵੱਤਾ ਨੂੰ ਮਾਪਣ ਵਿੱਚ ਮਾਹਰ ਹੈ। ਇਸਦੇ faithfulness ਅਤੇ answer relevance ਮੈਟ੍ਰਿਕਸ ਸਮੇਂ ਦੇ ਨਾਲ ਕੋਈ ਗਿਆਨ ਅਧਾਰ (knowledge base) ਕਿਵੇਂ ਕਾਰਜਸ਼ੀਲ ਹੈ, ਇਹ ਸਮਝਣ ਲਈ ਸੱਚਮੁੱਚ ਉਪਯੋਗੀ ਹਨ। ਬਦਕਿਸਮਤੀ ਨਾਲ, ਉਹ ਮੈਟ੍ਰਿਕਸ LLM ਜੱਜਾਂ 'ਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਿਰਭਰ ਹਨ। ਉਹ ਰਾਤ ਦੀ ਕੁਆਲਿਟੀ ਜੌਬ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ ਜੋ Slack 'ਤੇ ਰੁਝਾਨ (trends) ਪੋਸਟ ਕਰਦੀ ਹੈ। ਪਰ ਉਹ ਇੱਕ pull request ਲਈ ਮਾੜੇ ਬਾਊਂਸਰ ਹਨ। RAGAS ਨੂੰ ਆਪਣੇ ਸ਼ਡਿਊਲਡ ਵਿਸ਼ਲੇਸ਼ਣ ਪਾਈਪਲਾਈਨ (scheduled analysis pipeline) ਵਿੱਚ ਰੱਖੋ, ਨਾ ਕਿ ਆਪਣੇ ਮਰਜ ਬਲਾਕਰਾਂ (merge blockers) ਵਿੱਚ।
Arize Phoenix Elastic License 2.0 ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ ਇਹ ਬਿਲਕੁਲ ਵੱਖਰੇ ਮੋੜ 'ਤੇ ਖੜ੍ਹਾ ਹੈ। ਇਹ ਡਿਸਟ੍ਰੀਬਿਊਟਡ ਟ੍ਰੇਸਿੰਗ (distributed tracing) ਨੂੰ ਮੁਲਾਂਕਣ ਨਾਲ ਜੋੜਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਹਾਨੂੰ ਇਹ ਦੇਖਣ ਦੀ ਸਮਰੱਥਾ ਮਿਲਦੀ ਹੈ ਕਿ ਇੱਕ ਮਾਡਲ ਨੇ ਇੱਕ ਖਾਸ ਤਰੀਕੇ ਨਾਲ ਕਿਉਂ ਵਿਵਹਾਰ ਕੀਤਾ। ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਉਦੋਂ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ ਪ੍ਰੋਡਕਸ਼ਨ ਘਟਨਾ ਦੀ ਡੀਬੱਗਿੰਗ ਕਰ ਰਹੇ ਹੋਵੋ ਜਾਂ ਕਿਸੇ ਹਲੂਸੀਨੇਸ਼ਨ (hallucination) ਦਾ ਕਾਰਨ ਕਿਸੇ ਖਰਾਬ ਰਿਟ੍ਰੀਵਲ ਚੰਕ (retrieval chunk) ਵਿੱਚ ਲੱਭ ਰਹੇ ਹੋਵੋ। ਤੁਸੀਂ ਇਹ ਨਹੀਂ ਚਾਹੋਗੇ ਕਿ ਇੱਕ ਟ੍ਰੇਸਿੰਗ ਟੂਲ ਇਹ ਫੈਸਲਾ ਕਰੇ ਕਿ ਇੱਕ ਜੂਨੀਅਰ ਡਿਵੈਲਪਰ ਦੀ ਫੀਚਰ ਬ੍ਰਾਂਚ ਸ਼ਿਪ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਾਂ ਨਹੀਂ। ਇਸਦਾ ਆਰਕੀਟੈਕਚਰ ਅੰਤਰਦ੍ਰਿਸ਼ਟੀ (insight) ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਨਾ ਕਿ ਬਾਈਨਰੀ ਗੇਟਾਂ (binary gates) ਲਈ।
MLflow Evaluate (Apache 2.0) ਦੀ ਵਿਰਾਸਤ ਐਕਸਪੈਰੀਮੈਂਟ ਟ੍ਰੈਕਿੰਗ (experiment tracking) ਤੋਂ ਆਉਂਦੀ ਹੈ। ਇਹ ਭਾਰੀ ਹੈ। ਇਸਨੂੰ ਇੱਕ ਹਲਕੀ (lean) CI ਇਮੇਜ ਵਿੱਚ ਲਿਆਉਣ ਨਾਲ ਸਟਾਰਟਅੱਪ ਸਮੇਂ ਅਤੇ ਡਿਪੈਂਡੈਂਸੀਆਂ (dependencies) ਵਿੱਚ ਵਾਧਾ ਹੁੰਦਾ ਹੈ ਜੋ ਹਰ ਇੱਕ ਜੌਬ ਨੂੰ ਹੌਲੀ ਕਰ ਦਿੰਦੀਆਂ ਹਨ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਪਾਈਪਲਾਈਨ ਦੇ ਅੰਦਰ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨੀ ਹੀ ਪਵੇ, ਤਾਂ ਸਿਰਫ ਸਟ੍ਰਕਚਰਲ ਚੈੱਕਾਂ ਲਈ ਇਸਦੇ heuristic ਮੈਟ੍ਰਿਕਸ ਤੱਕ ਹੀ ਸੀਮਤ ਰਹੋ। ਉਦੋਂ ਵੀ, ਤੁਸੀਂ ਫਰੇਮਵਰਕ ਦੇ ਮੂਲ ਡਿਜ਼ਾਈਨ ਨਾਲ ਲੜ ਰਹੇ ਹੋਵੋਗੇ। MLflow ਹਫਤਿਆਂ ਤੱਕ ਰਨ (runs) ਨੂੰ ਲੌਗ ਕਰਨਾ ਅਤੇ ਐਕਸਪੈਰੀਮੈਂਟਾਂ ਦੀ ਤੁਲਨਾ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ। ਜਦਕਿ ਇੱਕ ਮਰਜ ਕਿਊ ਇੱਕ ਮਿੰਟ ਤੋਂ ਵੀ ਘੱਟ ਸਮੇਂ ਵਿੱਚ ਫੈਸਲਾ ਚਾਹੁੰਦੀ ਹੈ।
ਗੇਟਿੰਗ ਲਈ ਵਿਵਹਾਰਕ ਨਿਯਮ
ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਪ੍ਰਯੋਗ ਤੋਂ ਹੋਰ ਕੁਝ ਨਹੀਂ ਸਿੱਖਦੇ, ਤਾਂ ਇਹ ਤਿੰਨ ਨਿਯਮ ਜ਼ਰੂਰ ਯਾਦ ਰੱਖੋ।
ਪਹਿਲਾ, ਸਿਰਫ਼ ਸਟ੍ਰਕਚਰ (structure) ਨੂੰ ਗੇਟ ਕਰੋ, ਵਾਇਬ (vibe) ਨੂੰ ਨਹੀਂ। ਤੁਸੀਂ ਇਹ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਆਉਟਪੁੱਟ ਇੱਕ ਵੈਲਿਡ JSON ਹੈ। ਤੁਸੀਂ ਇਹ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਇਸ ਵਿੱਚ ਲੋੜੀਂਦੀਆਂ ਕੀਜ਼ (keys) ਹਨ। ਤੁਸੀਂ ਇਹ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕਲਾਸੀਫਿਕੇਸ਼ਨ ਲੇਬਲ ਇੱਕ ਮਨਜ਼ੂਰਸ਼ੁਦਾ enum ਨਾਲ ਸਬੰਧਤ ਹੈ। ਇਹ ਚੈੱਕ ਤੇਜ਼, ਸਸਤੇ ਅਤੇ ਨਿਸ਼ਚਿਤ (deterministic) ਹੁੰਦੇ ਹਨ। ਤੁਸੀਂ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਇਹ ਲਾਗੂ ਨਹੀਂ ਕਰ ਸਕਦੇ ਕਿ ਕੋਈ ਸਾਰ (summary) "ਮਿੱਤਰਤਾਪੂਰਨ" ਹੈ ਜਾਂ ਕੋਈ ਰੀ-ਰਾਈਟ "ਰਚਨਾਤਮਕ" ਹੈ। ਉਹ ਗੁਣ ਮਨੁੱਖੀ ਸਮੀਖਿਆ ਜਾਂ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਬੈਚ ਮੁਲਾਂਕਣ (batch evaluation) ਲਈ ਹਨ, ਨਾ ਕਿ ਆਟੋਮੇਟਿਡ ਗੇਟਾਂ ਲਈ।
ਦੂਜਾ, ਜੇਕਰ ਬਦਲੇ ਹੋਏ ਬਿਨਾਂ ਇਨਪੁੱਟ 'ਤੇ ਸਕੋਰ ਬਦਲ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਤੁਰੰਤ ਹੇਠਲੇ ਪੱਧਰ 'ਤੇ ਲੈ ਜਾਓ। ਇੱਕੋ ਜਿਹੇ ਆਰਟੀਫੈਕਟ (artifact) ਦੇ ਵਿਰੁੱਧ ਆਪਣੀ ਮੁਲਾਂਕਣ ਸੂਟ (evaluation suite) ਨੂੰ ਦੋ ਵਾਰ ਚਲਾਓ। ਜੇਕਰ ਕੋਈ ਮੈਟ੍ਰਿਕ 'pass' ਤੋਂ 'fail' ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਨੇ ਮਰਜ ਨੂੰ ਰੋਕਣ ਦਾ ਆਪਣਾ ਅਧਿਕਾਰ ਗੁਆ ਦਿੱਤਾ ਹੈ। ਇਸਨੂੰ ਇੱਕ ਸਲਾਹਕਾਰ ਡੈਸ਼ਬੋਰਡ (advisory dashboard) ਵਿੱਚ ਬਦਲ ਦਿਓ ਜਿੱਥੇ ਵੈਰੀਐਂਸ (variance) ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਵੀਕਾਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਤੀਜਾ, ਐਗਜ਼ਿਟ ਕੋਡ (exit code) ਦਾ ਸਤਿਕਾਰ ਕਰੋ। ਲਾਲ ਬੈਨਰ ਵਾਲੀ ਇੱਕ ਸੁੰਦਰ HTML ਰਿਪੋਰਟ ਮਰਜ ਨੂੰ ਨਹੀਂ ਰੋਕਦੀ। ਇੱਕ ਨਾਨ-ਜ਼ੀਰੋ (nonzero) ਐਗਜ਼ਿਟ ਕੋਡ ਰੋਕਦਾ ਹੈ। ਤੁਹਾਡੇ ਮੁਲਾਂਕਣ ਟੂਲ ਨੂੰ ਤੁਹਾਡੇ CI ਪਲੇਟਫਾਰਮ ਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਗੱਲ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। Standard out ਇਨਸਾਨਾਂ ਲਈ ਹੈ। Exit codes ਮਸ਼ੀਨਾਂ ਲਈ ਹਨ।
ਸਿੱਖਿਆ
ਅਸੀਂ ਅਜੇ LLM-ਸੰਚਾਲਿਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰਨੀ ਹੈ, ਇਹ ਸਮਝਣ ਦੇ ਸ਼ੁਰੂਆਤੀ ਪੜਾਅ 'ਤੇ ਹਾਂ। ਲਾਲਚ ਇਹ ਹੁੰਦਾ ਹੈ ਕਿ ਮੁਲਾਂਕਣ ਨੂੰ ਮਨੁੱਖੀ ਗ੍ਰੇਡਿੰਗ ਰੂਬਰਿਕ ਵਾਂਗ ਮੰਨਿਆ ਜਾਵੇ: ਬਾਰੀਕ, ਸੰਦਰਭਿਕ ਅਤੇ ਥੋੜ੍ਹਾ ਜਿਹਾ ਵਿਅਕਤੀਗਤ। ਇਹ ਇੱਕ ਖੋਜ ਪੱਤਰ (research paper) ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ। ਪਰ ਇੱਕ ਮਰਜ ਕਿਊ ਵਿੱਚ ਇਹ ਫੇਲ੍ਹ ਹੋ ਜਾਂਦਾ ਹੈ।
ਅੱਠ ਮਹੀਨਿਆਂ ਦੇ ਪ੍ਰੋਡਕਸ਼ਨ ਟ੍ਰੈਫਿਕ ਤੋਂ ਬਾਅਦ, ਮੇਰੀ ਪਾਈਪਲਾਈਨ ਹੁਣ ਸੇਵਾਵਾਂ ਵਿੱਚ ਸਟ੍ਰਕਚਰਲ ਅਤੇ ਸਕੀਮਾ ਐਸਰਸ਼ਨ (schema assertions) ਲਈ Promptfoo ਚਲਾਉਂਦੀ ਹੈ, ਅਤੇ Python-ਸਾਈਡ ਬਿਹੇਵੀਅਰਲ ਚੈੱਕਾਂ ਲਈ DeepEval ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਸਾਫ਼ ਤੌਰ 'ਤੇ pass-fail ਸ਼ਰਤਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ। ਬਾਕੀ ਸਭ ਕੁਝ ਰਾਤ ਦੇ ਡੈਸ਼ਬੋਰਡਾਂ 'ਤੇ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ। ਕਿਊ ਸਥਿਰ ਹੈ। ਸਿਗਨਲ ਸਾਫ਼ ਹੈ। ਟੀਮ ਨੂੰ ਇੱਕ ਰੈੱਡ ਬਿਲਡ (red build) 'ਤੇ ਦੁ