.NET developer-দের জন্য AI engineering (পর্ব 3): সোনার খাতা, evaluation, golden set ও regression gate

25টা কাল্পনিক নোটের golden set বানিয়ে AI-এর extraction field ধরে ধরে মাপা, baseline-এর সঙ্গে তুলনা করা, আর মান নামলে gate বন্ধ করা, বারোটা দৃশ্যপটসহ।

21 min readUpdated
সোনালি খাতায় ছয়টি পরীক্ষার মধ্যে পাঁচটিতে টিক, একটিতে ক্রস, নিচে ২৩/২৫ স্কোর

আমাদের পর্ব 2-এ আমরা দেখেছিলাম কীভাবে কোডের validation দিয়ে model-এর তৈরি করা খসড়া যাচাই করতে হয়। আমাদের সেই কাল্পনিক নোটে model যখন ফি-র পরিমাণ 120.00-এর জায়গায় 12.00 পড়েছিল—অর্থাৎ একটি শূন্য খসে পড়েছিল—আমাদের কোড তৎক্ষণাৎ সেই ভুল ধরে ফেলেছিল। কিন্তু একটি মৌলিক প্রশ্ন তখনো অনুত্তরিত থেকে গেছে: বাস্তব কাজের সময় model এমন ভুল আসলে কতবার করে? আর prompt-এ সামান্য একটি লাইন বা শব্দ বদলালে সেই ভুলের হার কি বাড়ে, নাকি কমে?

এই তৃতীয় পর্বে আমরা সেই ভুলের হার বৈজ্ঞানিক সংখ্যায় পরিমাপ করার একটি পূর্ণাঙ্গ আর্কিটেকচার তৈরি করব। মূল পরিকল্পনাটি অত্যন্ত সরল ও কার্যকর: আমরা 25টি বিচিত্র নোটের একটি আদর্শ ডেটাসেট তৈরি করব, এবং প্রতিটি নোটের পাশে অভিজ্ঞ মানুষের হাতে যাচাই করা সঠিক উত্তর লিখে রাখব। এই সুনির্দিষ্ট রেফারেন্স তালিকার নাম আমরা দিয়েছি সোনার খাতা (Golden Set), আর এর ঠিক প্রথম পাতাতেই স্থান পেয়েছে আমাদের সেই ঐতিহাসিক ব্রোকার নোটটি। সিস্টেমে যেকোনো পরিবর্তনের পর আমরা model-কে এই 25টি নোটে নতুন করে চালাব এবং প্রতিটি field ধরে ধরে মেলাব কয়টি উত্তর সঠিক হলো। পুরো pipeline-এর শেষে বসানো থাকবে একটি কঠোর মানের ফটক বা regression gate। যদি দেখা যায় নতুন পরিবর্তনে পারফরম্যান্স আগের চেয়ে খারাপ হয়েছে, তবে এই ফটক সাথে সাথে কমান্ড লাইনে এরর দিয়ে এক্সিট করবে এবং কোডকে production-এ যেতে বাধা দেবে। পরবর্তীতে আমাদের সিরিজের সমাপনী পর্ব 10-এ স্বয়ংক্রিয় CI pipeline এই ফটকটিকেই মূল পাহারাদার হিসেবে ব্যবহার করবে।

কোড: এই পর্বের শেষে কোডের অবস্থা github.com/alaminmain/foliolens-এর part-03 tag-এ। নিজের কাছে এনে চালাতে: git checkout part-03 তারপর dotnet test। আগের পর্বের সঙ্গে তফাত দেখতে: git diff part-02 part-03।

কেন

একটু ভেবে দেখুন—আপনি হয়তো model-এর আউটপুট আরও একটু ভালো করার আশায় prompt-এ নতুন একটি লাইন যোগ করলেন। এরপর নিজের পিসিতে দুই-তিনটি নোটে চালিয়ে দেখলেন উত্তর একদম ঠিকঠাক আসছে। কিন্তু বাকি শত শত নোটের ক্ষেত্রে model-এর আচরণে কী প্রভাব পড়ল, তা কি নিশ্চিতভাবে জানেন? ঠিক একই অনিশ্চয়তা তৈরি হয় যখন খরচ বাঁচানোর জন্য তুলনামূলক সস্তা কোনো model-এ সুইচ করা হয়, কিংবা ক্লাউড প্রোভাইডার নিজে থেকেই তাদের ব্যাকএন্ড model-এ কোনো গোপন আপডেট নিয়ে আসে। অধিকাংশ সময় আমরা বলি, "কয়েকটা স্যাম্পল চালিয়ে দেখলাম, বেশ ভালোই তো চলছে!" বাস্তব ইঞ্জিনিয়ারিংয়ে এটি কোনো নির্ভরযোগ্য সিদ্ধান্ত নয়, এটি স্রেফ একটি অন্ধ অনুমান।

আমরা যারা .NET ব্যাকএন্ডে কাজ করি, তারা মূলত deterministic ইউনিট test-এ অভ্যস্ত। সেখানে Assert.Equal(4, Add(2, 2)) প্রতিবারই হুবহু একই ফলাফল দেয়: হয় কোড পুরোপুরি pass, নয়তো fail। কিন্তু লার্জ ল্যাঙ্গুয়েজ model-এর ক্ষেত্রে দুনিয়াটা এমন সাদা-কালো নয়। একই prompt পাঠিয়েও সে কখনো সঠিক উত্তর দেয়, আবার কখনো ভুল করে বসে। তাই AI ইঞ্জিনিয়ারিংয়ে আসল প্রশ্নটি "এই বিশেষ উত্তরটি ঠিক কি না" তা নয়; বরং আসল প্রশ্ন হলো: 25টি বিভিন্ন ধাঁচের নোটের মধ্যে সামগ্রিকভাবে কয়টি উত্তর সঠিক হলো, ভুলের ধরনগুলো ঠিক কী, এবং নতুন কোনো পরিবর্তনের পর কোনো সুপ্ত regression তৈরি হলো কি না।

এই নির্ভরযোগ্য ইঞ্জিনিয়ারিং ব্যবস্থা গড়ে তুলতে আমাদের তিনটি উপাদান প্রয়োজন। প্রথমত, নোট এবং মানুষের হাতে যাচাই করা সঠিক উত্তরের একটি অপরিবর্তনীয় রেফারেন্স তালিকা। দ্বিতীয়ত, সেই তালিকার প্রতিটি নোটে model চালিয়ে ফলাফল চুলচেরা বিশ্লেষণের একটি স্বয়ংক্রিয় evaluation প্রোগ্রাম। এবং তৃতীয়ত, একটি কঠোর নীতিগত ফটক: যদি সামগ্রিক মান আগের baseline-এর চেয়ে নির্দিষ্ট সীমার বেশি নেমে যায়, তবে production pipeline সাথে সাথে থামিয়ে দেয়।

ধারণা: খাতা, মাপ, ফটক

স্কুল বা বিশ্ববিদ্যালয়ের পরীক্ষার খাতা মূল্যায়নের কথা ভাবুন। প্রধান পরীক্ষকের হাতে একটি আদর্শ উত্তরপত্র বা সমাধান নির্দেশিকা (answer key) থাকে, যার সাথে মিলিয়ে পরীক্ষক প্রতিটি ছাত্রের খাতা দেখে নম্বর দেন। আমাদের evaluation সিস্টেমটিও ঠিক একই দর্শনে তৈরি। (ঠিক যেমন স্বর্ণকার নিখুঁত মানদণ্ডের কষ্টিপাথরে ঘষে সোনার খাঁটিত্ব যাচাই করেন, সেখান থেকেই আমাদের এই রূপক নাম "সোনার খাতা")। এই সিস্টেমে মূলত তিনটি কেন্দ্রীয় উপাদান কাজ করে:

  1. golden set (সোনার খাতা): বাস্তবধর্মী নোটের একটি সুনির্দিষ্ট ডেটাসেট, যেখানে প্রতিটি নোটের বিপরীতে প্রত্যাশিত সঠিক উত্তরটি সংরক্ষিত থাকে। এই উত্তরগুলো কোনো model নয়, বরং একজন অভিজ্ঞ মানুষ নিজ হাতে যাচাই করে লিখে রেখেছেন।
  2. evaluator: এই ইঞ্জিনটি সোনার খাতার প্রতিটি নোটে আমাদের এক্সট্র্যাক্টরকে চালায় (এক্সট্র্যাক্টর হলো পর্ব 2-এর সেই লজিক, যা নোট পড়ে খসড়া বানায়)। এরপর তৈরি হওয়া প্রতিটি খসড়াকে সোনার খাতার রেফারেন্স উত্তরের সাথে field ধরে ধরে মেলায় এবং একটি বিস্তারিত পারফরম্যান্স report তৈরি করে।
  3. regression gate: এটি নতুন তৈরি হওয়া মূল্যায়ন report-কে আগের একটি প্রমাণিত ভালো report-এর সাথে পাশাপাশি তুলনা করে। সেই প্রমাণিত ঐতিহাসিক report-টিকে বলা হয় baseline। সফটওয়্যার ইঞ্জিনিয়ারিংয়ে regression মানে হলো—আগে যা ঠিকঠাক কাজ করছিল, নতুন কোনো পরিবর্তনের পর তা অজান্তে নষ্ট হয়ে যাওয়া। পারফরম্যান্স কতটা কমলে আমরা তা স্বাভাবিক ওঠানামা হিসেবে মেনে নেব, সেই অনুমোদিত মার্জিনের নাম tolerance। কিন্তু পারফরম্যান্স যদি এই সহনসীমার বাইরে নেমে যায়, তবে ফটক চিরতরে বন্ধ হয়ে যায়।
golden setJSONL, 25 case evaluatormodel + validation reportreport.json gatevs baseline eval-baseline.json 0 · passফটক খোলা 1 · failফটক বন্ধ production-এর ভুল case মাপা তুলনা tolerance pass fail নতুন case
মাপার চক্র: golden set থেকে report, report থেকে gate-এর সিদ্ধান্ত। production-এ ধরা পড়া প্রতিটি ভুল নতুন case হয়ে খাতায় ফেরে, তাই খাতা কেবল বড় হয়।

একটা সংখ্যা যথেষ্ট নয়

শুধু সামগ্রিক "accuracy 80%" শুনলে মোটেও বোঝা যায় না সিস্টেমের ত্রুটিটি আসলে কোথায়। নিচের চার্টটিতে একই 25টি নোটে তিনটি ভিন্ন model-এর পারফরম্যান্স field ধরে ধরে দেখানো হয়েছে। এখানে ব্যবহৃত তিনটি model-ই scripted—অর্থাৎ কোডের ভেতরের কৃত্রিম model, যা নির্দিষ্ট ছকে নিয়ন্ত্রিত ভুল তৈরি করে। এই সিমুলেশনের উদ্দেশ্য হলো আমাদের পরিমাপক যন্ত্রটি বাস্তব ত্রুটি শনাক্ত করতে পারে কি না তা প্রমাণ করা; কোনো নির্দিষ্ট বাণিজ্যিক model-এর রেটিং দেখানো নয়:

perfect (scripted) 80% (scripted) broken (scripted) 0 0.5 1.0 1.00 1.00 0.24 symbol 1.00 1.00 0.76 side 1.00 1.00 0.76 quantity 1.00 1.00 0.48 price 1.00 1.00 0.76 fees 1.00 0.80 0.76 tradeDate 1.00 1.00 0.76 netAmountPrinted field (25টা case-এর মধ্যে কতটায় সেই field ঠিক)
field ধরে ধরে accuracy, তিনটা scripted model-এর একই 25 case-এ। কমলা bar দেখায়, 80% model-এর সব ভুল একটাই field-এ: tradeDate-এ।

এখানে 80% model-টির সামগ্রিক নির্ভুলতার হার 0.80। কিন্তু চার্টটির দিকে তাকালেই স্পষ্ট ধরা পড়ে—তার সমস্ত ভুল মূলত একটিমাত্র field-এ কেন্দ্রীভূত: লেনদেনের তারিখ বা tradeDate-এ! বাকি ছয়টি field কিন্তু শতভাগ নিখুঁত। অর্থাৎ একজন আর্কিটেক্ট হিসেবে আপনাকে পুরো prompt ওভারহল করতে হবে না; আপনার মনোযোগ থাকবে শুধু তারিখ এক্সট্র্যাক্ট করার prompt-এ। অন্যদিকে broken model-টির ভুল সর্বত্র ছড়ানো—যার মধ্যে সবচেয়ে খারাপ হলো symbol (0.24) এবং price (0.48)। স্রেফ একটি একক সামগ্রিক গড় সংখ্যা দেখলে এই অভ্যন্তরীণ দুর্বলতাগুলো চিরতরে আড়ালে থেকে যেত। তাই field ধরে ধরে চুলচেরা বিশ্লেষণ করাই ইঞ্জিনিয়ারিংয়ের আসল সৌন্দর্য।

খাতা ছোট হলে সংখ্যায় কতটা ভরসা

আমাদের বর্তমান সোনার খাতায় নোটের সংখ্যা মাত্র 25টি। ফলে একটিমাত্র নোট ঠিক বা ভুল হলেই সামগ্রিক পারফরম্যান্স পুরো 4 percentage point নড়ে যায়! ধরা যাক, prompt পরিবর্তনের আগে 20টি নোট সঠিক হয়েছিল (0.80), আর পরিবর্তনের পর হলো 21টি (0.84)। এটি কি আসলেই কোনো বাস্তব উন্নতি? মোটেও নিশ্চিত নয়; হতে পারে model-এর সহজাত খামখেয়ালিপনায় একটি নোট স্রেফ ভাগ্যের জোরে সঠিক হয়ে গেছে।

পরিসংখ্যানের এই স্বাভাবিক অনিশ্চয়তা ও নমুনা ত্রুটি মানুষের সামনে তুলে ধরার জন্য আমাদের report-এ একটি confidence interval যুক্ত থাকে। এটি গাণিতিকভাবে প্রকাশ করে যে আমাদের সীমিত নমুনায় প্রাপ্ত হারের ওপর ভিত্তি করে বাস্তব জগতে model-এর আসল পারফরম্যান্স ঠিক কোন রেঞ্জের মধ্যে থাকার সম্ভাবনা বেশি। আমাদের কোডে এর জন্য ব্যবহৃত হয়েছে সুবিখ্যাত Wilson score interval অ্যালগরিদম, যা অত্যন্ত ছোট নমুনার ক্ষেত্রেও অত্যন্ত নির্ভরযোগ্য ফলাফল প্রদান করে (উইকিপিডিয়া)। দুটি বাস্তব উদাহরণ লক্ষ্য করুন:

  • 25টির মধ্যে 25টি নোটেই নির্ভুল ফল পেলেও এর 95% confidence interval দাঁড়ায় 0.867 থেকে 1.000। অর্থাৎ শতভাগ সাফল্য দেখেও আমরা পরিসংখ্যানগতভাবে শুধু এটুকু দাবি করতে পারি যে বাস্তব দুনিয়ায় এর নির্ভুলতার হার সম্ভবত 87%-এর ওপরে থাকবে।
  • আর 25টির মধ্যে 20টি সঠিক হলে এই ব্যবধানটি দাঁড়ায় 0.609 থেকে 0.911 পর্যন্ত—যা চরম একটি অনিশ্চিত রেঞ্জ।

তাই "আমার AI model 96% সঠিক" এমন বড় দাবি করার আগে সোনার খাতার আয়তন শত শত নোটে উন্নীত করা প্রয়োজন।

খোলা সুতো: ডেটাসেট ছোট হলে সংখ্যার ওপর অন্ধ আস্থা রাখা যায় না—এই গভীর শিক্ষাটি পুরো সিরিজে বারবার ফিরে আসবে: পর্ব 6-এর 24টি অনুসন্ধান প্রশ্নে এবং পর্ব 8-এর 23টি সিকিউরিটি অ্যাটাকে। আর gate সবুজ থাকার মানেই যে model নিখুঁত তা নয়; সে বিষয়ে আমরা পুঙ্খানুপুঙ্খ আলোচনা করব শেষ পর্বে (পর্ব 10)।

অনিশ্চয়তার আরেকটি বড় কারণ হলো: লার্জ ল্যাঙ্গুয়েজ model-এর সহজাত নন-ডিটারমিনিস্টিক আচরণ। একই model এবং একই সোনার খাতা হওয়া সত্ত্বেও পরপর 10 বার test চালালে 10টি সম্পূর্ণ ভিন্ন স্কোর পাওয়া যেতে পারে:

0.60 0.70 0.80 0.90 1.00 exact-match rate, 25 case-এর পূর্ণ golden set, একই model-এর 10 run design rate 0.80 range 0.72 থেকে 0.92
একই model, একই খাতা, 10 run: exact-match rate 0.72 থেকে 0.92-এ ছড়ায়। তাই একটা run-এর সংখ্যা model-এর স্থায়ী গুণ নয়। (scripted model; সংখ্যা এই কোডের আসল run থেকে।)

এই test-এ ব্যবহৃত model-টিও কিন্তু scripted। প্রতি response-এ 20% সম্ভাবনায় এটি তারিখ একদিন পিছিয়ে দেয়; ফলে এর ডিজাইন করা অন্তর্নিহিত গড় হার হলো 0.80 (চার্টে এটিই design rate)। অথচ পরপর 10 বার চালিয়ে প্রাপ্ত স্কোর ছড়াল 0.72 থেকে 0.92 পর্যন্ত (যার গড় ছিল 0.812)! বাস্তব বাণিজ্যিক model-এ Temperature কমিয়ে আনলে এই তারতম্য কিছুটা কমে বটে; কিন্তু পর্ব 1-এ যেমনটি আমরা দেখেছি—Temperature শূন্য করলেও প্রতিবার হুবহু একই উত্তরের কোনো পরম নিশ্চয়তা পাওয়া যায় না।

এই পরিসংখ্যানিক বাস্তবতা থেকে দুটি পেশাদার প্রকৌশলগত অভ্যাস গড়ে ওঠে: প্রথমত, একটিমাত্র run-এর ফলাফলের ওপর ভিত্তি করে কখনোই production-এর চূড়ান্ত সিদ্ধান্ত নেবেন না। এবং দ্বিতীয়ত, prompt-এ কোনো পরিবর্তন আনার আগে ও পরে একাধিকবার evaluation run চালিয়ে তার গড় ও তারতম্য পর্যবেক্ষণ করুন।

কোড

খাতার গড়ন

golden set একটা JSON Lines ফাইল (UTF-8)। এর প্রতি লাইনে একটা case, মানে একটা নোট আর তার সঠিক উত্তর। eval/golden-notes.jsonl-এর 6 নম্বর লাইনটা দেখুন:

{"id":"g06-rounding-half-paisa","tags":["rounding"],"note":"Surma Securities Ltd. (fictional broker)\nTrade date: 2026-02-02\nSecurity: DLTA\nTransaction: Buy\nQuantity: 333\nRate: 27.805\nTotal charges: 46.30\nNet payable: 9,305.36","expected":{"symbol":"DLTA","side":"buy","quantity":333,"price":27.805,"fees":46.3,"tradeDate":"2026-02-02","netAmountPrinted":9305.36},"expectedOutcome":"Accepted","origin":"synthetic"}

লাইনটি পড়ার নিয়ম অত্যন্ত স্বচ্ছ ও সুস্পষ্ট:

  • note: মূল ব্রোকার নোটের অবিকল টেক্সট।
  • expected: মানুষের হাতে লেখা প্রতিটি field-এর কাঙ্ক্ষিত সঠিক উত্তর। কোনো মান null থাকার অর্থ হলো সেই তথ্যটি আদতেই নোটে অনুপস্থিত, তাই model null দিলেই কেবল তা সঠিক হিসেবে গণ্য হবে।
  • tags: নোটটি ঠিক কোন ক্যাটাগরির চ্যালেঞ্জিং case তা নির্দেশ করে (এখানে rounding মানে দশমিকের পয়সা মেলানোর জটিল case)।
  • expectedOutcome: একটি নিখুঁত খসড়া validation-এ পাঠালে কী ফলাফল আসা উচিত (Accepted, NeedsReview নাকি Rejected)।
  • origin: case-টি কোথা থেকে সংগ্রহ করা হয়েছে (এখানে synthetic মানে পরীক্ষামূলকভাবে তৈরি)।

এই ফাইলটি JSON Lines format-এ রাখার প্রধান সুবিধা হলো এর সহজ স্কেলেবিলিটি। নতুন কোনো case যুক্ত করা মানে ফাইলের শেষে স্রেফ একটি নতুন লাইন যোগ করা, যা Git diff-এ সুন্দর একটি সবুজ লাইন হিসেবে ফুটে ওঠে। অধিকন্তু, আমাদের test সুইটে একটি বিশেষ ভেরিফিকেশন test রয়েছে—যা নিশ্চিত করে যে খাতার expectedOutcome মানগুলো আন্দাজে লেখা নয়; বরং নিখুঁত খসড়া ভ্যালিডেটরে পাঠালে তা হুবহু এই স্ট্যাটাসই প্রদর্শন করে।

সোনার খাতার প্রথম case-টি (g01) হলো আমাদের সেই পরিচিত নোট: আলফা টেকের 200 শেয়ার, দর 120.00, ফি 120.00, নেট 24,120.00 টাকা, তারিখ 11 ফেব্রুয়ারি 2025। এই ডেটাসেটের 25টি case-এর মধ্যে 16টির কাঙ্ক্ষিত ফলাফল Accepted, 7টির ক্ষেত্রে NeedsReview, এবং 2টির ক্ষেত্রে সরাসরি Rejected। বিভিন্ন সূক্ষ্ম চ্যালেঞ্জিং case ট্যাগ দিয়ে চিহ্নিত করা আছে (যেমন বাংলা সংখ্যায় লেখা নোট 8টি, জটিল ফি format-এর নোট 6টি)। ট্যাগ ধরে পারফরম্যান্স বিশ্লেষণ করলে খুব সহজেই বোঝা যায় model ঠিক কোন ঘরানার নোটে সবচেয়ে বেশি ভুল করছে (ReportAnalysis.ExactByTag)।

মাপা: field ধরে ধরে

আমাদের FieldScorer ক্লাসটি model-এর তৈরি খসড়ার সাতটি field-কে সোনার খাতার রেফারেন্স মানের সাথে আলাদা আলাদাভাবে তুলনা করে। তবে এখানে "মেলা" মানে স্রেফ দুটি স্ট্রিংয়ের বোকা তুলনা নয়; বরং উভয় মানকে একই ব্যবসায়িক নিয়মে নরমালাইজ করার পর তুলনা করা হয়। যেমন সিম্বলের ক্ষেত্রে টিকার এবং পূর্ণ কোম্পানির নাম উভয়ই অভিন্ন টিকারে রূপান্তরিত হয়, আর লেনদেনের দিকে Buy এবং বাংলায় ক্রয় উভয়কেই একই নির্দেশক হিসেবে বিবেচনা করা হয়। এই নরমালাইজেশনের কাজটি সম্পন্ন করে আমাদের পর্ব 2-এর DraftFields হেল্পার। ফলে validation এবং evaluation উভয় pipeline-এই "সঠিক"-এর সংজ্ঞা সবসময় এক ও অভিন্ন থাকে:

return new Dictionary<string, bool>
{
    ["symbol"] = SameText(DraftFields.Symbol(actual.Symbol) ?? actual.Symbol?.Trim().ToUpperInvariant(),
                          DraftFields.Symbol(expected.Symbol) ?? expected.Symbol?.Trim().ToUpperInvariant()),
    ["side"] = DraftFields.Side(actual.Side) == DraftFields.Side(expected.Side)
               && (DraftFields.Side(expected.Side) is not null || IsBlank(actual.Side)),
    ["quantity"] = actual.Quantity == expected.Quantity,
    ["price"] = actual.Price == expected.Price,
    ["fees"] = actual.Fees == expected.Fees,
    ["tradeDate"] = SameDate(actual.TradeDate, expected.TradeDate),
    ["netAmountPrinted"] = actual.NetAmountPrinted == expected.NetAmountPrinted,
};

লজিকটি খুবই স্পষ্ট: সাতটি field-এর প্রতিটির জন্য একটি করে true বা false বুলিয়ান ফ্ল্যাগ নির্ধারিত হয়। আমাদের Evaluator সোনার খাতার প্রতিটি case ধারাবাহিকভাবে পরিচালনা করে। কোনো case-এ যদি নেটওয়ার্ক এরর বা timeout-এর কারণে exception ঘটে, তবে পুরো evaluation run ক্র্যাশ করে না; বরং সেই case-টি report-এ Error হিসেবে চিহ্নিত হয় এবং সংশ্লিষ্ট case-এর সবকটি field-কে ব্যর্থ হিসেবে গণনা করা হয়।

এখান থেকেই আমাদের আর্কিটেকচারের সবচেয়ে সংবেদনশীল মেট্রিকটি বেরিয়ে আসে, যার নাম false accept: এমন কোনো ভুল খসড়া—যা কোনো এক অদ্ভুত কারণে validation-এর সব তালা ডিঙিয়ে Accepted স্ট্যাটাস পেয়ে গেছে! এই মেট্রিকটির আলাদা গুরুত্ব অনুধাবন করতে ভুল খসড়ার দুটি সম্ভাব্য পথ লক্ষ্য করুন:

  • validation যদি ভুলটি ধরে ফেলে, তবে খসড়াটি NeedsReview বা Rejected স্ট্যাটাস পেয়ে মানুষের কাছে পর্যালোচনার জন্য যায়। এতে কোনো সিস্টেম ঝুঁকি নেই।
  • কিন্তু validation যদি ভুলটি ধরতে ব্যর্থ হয়, তবে সেই বিকৃত খসড়াটি স্বয়ংক্রিয়ভাবে Accepted হয়ে নির্বিঘ্নে সইয়ের টেবিলে পৌঁছে যায়। এটাই হলো চরম ঝুঁকি!

পর্ব 2-এ আমাদের সেই 12.00 টাকার দরটি ধরা পড়েছিল কারণ সেখানে গাণিতিক সমীকরণ ভেঙে গিয়েছিল। কিন্তু কোনো নোটে যদি লেনদেনের তারিখ ভুলবশত একদিন সরে যায়, তবে কোনো গাণিতিক সমীকরণ কিন্তু ভাঙে না; ফলে validation পুরোপুরি নিশ্চুপ থাকে। এই নীরব ও বিপজ্জনক ভুলগুলোকেই আমরা চিহ্নিত করি false accept হিসেবে।

খোলা সুতো: দেখতে ঠিক অথচ মারাত্মক ভুল সংখ্যার অনুপ্রবেশ ঠেকাতে আমাদের পরবর্তী প্রতিরক্ষা ব্যূহ তৈরি হবে: পর্ব 4-এ আসবে স্বয়ংক্রিয় সংখ্যা যাচাইকারী ক্যালকুলেটর। আর পর্ব 10-এ আমাদের regression gate কঠোরভাবে নজর রাখবে যাতে কোনো ভুল খসড়া কখনোই সব তালা ফাঁকি দিতে না পারে (false_accepts সহনশীলতা সীমা ঠিক 0)।

ভুল draftmodel-এর ভুল পড়া validationদ্বিতীয় তালা NeedsReview / Rejectedমানুষের কাছে যায় নিরীহ ভুলfalse accept নয় Acceptedসইয়ের সারিতে ঢোকে নিঃশব্দ ভুলgate-এ tolerance 0 draft ধরা পড়ে পেরিয়ে যায় ফল ফল
একই ভুলের দুই পরিণতি: validation-এ আটকালে নিরীহ, পেরিয়ে গেলে নিঃশব্দ। gate-এর সবচেয়ে কড়া নিয়ম দ্বিতীয়টার জন্য।

report: স্থির schema

evaluation run সম্পন্ন হওয়ার পর সমস্ত ফলাফলের পুঙ্খানুপুঙ্খ বিবরণ নিয়ে EvalReport নামে একটি প্রমিত JSON ফাইল তৈরি হয়। এই ফাইলের format-এ schemaVersion: 1 সংজ্ঞায়িত এবং সমস্ত প্রোপার্টি camelCase রীতিতে বিন্যস্ত। যেহেতু পর্ব 10-এর স্বয়ংক্রিয় CI pipeline এই ফাইলটি পড়বে, তাই এর স্ট্রাকচার কঠোরভাবে অপরিবর্তনীয় রাখা হয়েছে। কোনো field পরিবর্তন করতে হলে schema-র সংস্করণ বৃদ্ধি করতে হবে; অন্যথায় অসমর্থিত সংস্করণ পড়তে গেলে টুলটি এরর কোড 2 দিয়ে বন্ধ হয়ে যাবে:

fieldtypeমানে
schemaVersionnumberschema-র version, এখন 1
mode, modelstringfake বা live; model-এর নাম (scripted-এ scripted:…)
generatedAt, goldenSetstringসময় (UTC) ও golden ফাইলের নাম
caseCount, errorCountnumbercase আর crash-করা case-এর সংখ্যা
exactMatchRate, exactMatchCi95number, দুটো সংখ্যার listসব field ঠিক এমন case-এর হার ও 95% interval
fieldAccuracyনাম থেকে numberসাত field-এর প্রতিটির হার
outcomeDistribution, outcomeAgreementRateনাম থেকে number; numberAccepted/NeedsReview/Rejected/Error count; label-এর সঙ্গে মিল
falseAccepts, falseAcceptIdsnumber, listভুল অথচ Accepted case
averageAttemptsnumbercase-প্রতি গড় model call
usageobjectinputTokens, outputTokens, calls, tokensPerCase
costobject বা nullদাম দেওয়া থাকলে inputPerMillion, outputPerMillion, total, perCase
caseslistপ্রতি case-এর ফল: field-ভিত্তিক শুদ্ধতা, outcome, call, token, error

token মূল্য কোডের ভেতরে হার্ডকোড করা নেই; বরং কমান্ড লাইনে --input-price এবং --output-price আর্গুমেন্টের মাধ্যমে প্রতি দশ লাখ token-এর রেট জানিয়ে দিতে হয়। মূল্য উল্লেখ না করলে report-এ cost field-টি null অবস্থায় থাকে। এটি মূলত আমাদের পর্ব 1-এর সেই মৌলিক শিক্ষা: যে খরচ আমি জানি না, তা কখনোই শূন্য নয়। তাই এই পর্বের সমস্ত খরচের হিসাব মূলত কাল্পনিক প্লেসহোল্ডার রেটের ওপর ভিত্তি করে গঠিত। এখানে আরেকটি বাস্তব সত্য মনে রাখা জরুরি: সোনার খাতার 25টি case-এর একটি পূর্ণাঙ্গ run-এ কিন্তু 25টিরও বেশি model কল তৈরি হয় (রিপেয়ার লুপের কারণে)। অর্থাৎ evaluation চালানোর সময়েও মিটারে বাস্তব ক্লাউড খরচ যুক্ত হয়।

baseline ও gate

baseline হলো কোনো একটি সফল ও সন্তোষজনক evaluation run-এর সংরক্ষিত স্ন্যাপশট, যার নাম দেওয়া হয় eval-baseline.json। পরবর্তী প্রতিটি নতুন run-এর পারফরম্যান্স এই সংরক্ষিত report-এর সাথে অক্ষরে অক্ষরে তুলনা করা হয়। নিচের baseline ফাইলটি আমাদের আসল কোডের folio-eval baseline কমান্ডের মাধ্যমে scripted-perfect run থেকে স্বয়ংক্রিয়ভাবে জেনারেট করা হয়েছে:

{
  "schemaVersion": 1,
  "mode": "fake",
  "model": "scripted:perfect",
  "metrics": {
    "caseCount": 25,
    "exactMatchRate": 1,
    "fieldAccuracy": {
      "symbol": 1,
      "side": 1,
      "quantity": 1,
      "price": 1,
      "fees": 1,
      "tradeDate": 1,
      "netAmountPrinted": 1
    },
    "outcomeAgreementRate": 1,
    "falseAccepts": 0,
    "tokensPerCase": 332.68
  },
  "tolerances": {
    "exactMatchRate": 0.05,
    "fieldAccuracy": 0.05,
    "outcomeAgreementRate": 0.05,
    "falseAcceptsIncrease": 0,
    "tokensPerCaseIncreaseRatio": 0.25
  }
}

এই ফাইলে দুটি মূল সেকশন রয়েছে: metrics সেকশনে সংরক্ষিত আছে আমাদের অতীতের সেই ভালো run-এর সুনির্দিষ্ট পরিসংখ্যান, আর tolerances সেকশন নির্ধারণ করে দেয় পারফরম্যান্স সর্বোচ্চ কতটা কমলে আমরা তা সহনীয় হিসেবে মেনে নেব:

  • exactMatchRate-এর tolerance নির্ধারণ করা হয়েছে 0.05। 25টি case-এর মধ্যে একটি অতিরিক্ত ভুল হলে হার দাঁড়ায় 0.96—যা tolerance সীমার ভেতরে থাকায় gate নির্বিঘ্নে pass করবে। কিন্তু দুটি অতিরিক্ত ভুল হলে হার নেমে দাঁড়ায় 0.92—যা সীমার বাইরে চলে যাওয়ায় ফটক সাথে সাথে বন্ধ হয়ে যাবে!
  • falseAcceptsIncrease কঠোরভাবে 0 রাখা হয়েছে; অর্থাৎ ক্ষমার অযোগ্য নীরব ভুল একটিও বাড়তে পারবে না।
  • tokensPerCaseIncreaseRatio রাখা হয়েছে 0.25; অর্থাৎ কোনো পরিবর্তনের কারণে case-প্রতি token খরচ baseline-এর চেয়ে 25%-এর বেশি বৃদ্ধি পেলে gate তাৎক্ষণিকভাবে বিল্ড আটকে দেবে।

মনে রাখবেন, এই ফাইলটি আপনার বাস্তব production-এর baseline নয়। এটি scripted model থেকে তৈরি একটি ডেমো baseline—যা প্রমাণ করে আমাদের test হারনেস ঠিকমতো কাজ করছে। বাস্তব model নিয়ে প্রথম লাইভ run চালানোর পর baseline কমান্ড ব্যবহার করে আপনার নিজস্ব production baseline তৈরি করে নিতে হবে। আমাদের gate কোনো অবস্থাতেই কৃত্রিম fake report-কে আসল live baseline-এর সাথে তুলনা করতে দেয় না (mode check)।

gate-এর অভ্যন্তরে প্রয়োগ করা চেকগুলোর কাঠামো নিচে লক্ষ্য করুন:

checks.Add(new GateCheck("mode", report.Mode == baseline.Mode, baseline.Mode, report.Mode, "a fake run is never compared with a live baseline"));
checks.Add(AtLeast("case_count", report.CaseCount, m.CaseCount, "the golden set must not shrink"));
checks.Add(AtMost("errors", report.ErrorCount, 0, "no case may crash"));
checks.Add(Rate("exact_match", report.ExactMatchRate, m.ExactMatchRate, t.ExactMatchRate));
foreach (var (field, baseValue) in m.FieldAccuracy)
{
    var actual = report.FieldAccuracy.TryGetValue(field, out var a) ? a : 0;
    checks.Add(Rate($"field:{field}", actual, baseValue, t.FieldAccuracy));
}
checks.Add(Rate("outcome_agreement", report.OutcomeAgreementRate, m.OutcomeAgreementRate, t.OutcomeAgreementRate));
checks.Add(AtMost("false_accepts", report.FalseAccepts, m.FalseAccepts + t.FalseAcceptsIncrease, "wrong drafts that passed every lock"));

এখানে প্রতিটি checks.Add(...) হলো একটি করে অলঙ্ঘনীয় শর্ত। সবকটি শর্ত একযোগে pass করলেই কেবল ফটক খুলে যায়। AtLeast নিশ্চিত করে ন্যূনতম সীমা, AtMost নিশ্চিত করে সর্বোচ্চ সীমা, আর Rate পরীক্ষা করে দেখে ড্রপ হওয়া পারফরম্যান্স tolerance সীমার অতিরিক্ত নিচে নেমে গেছে কি না।

এখানে থাকা case_count চেকটি একটি বড় ফাঁদ প্রতিহত করে: কোনো অসৎ ডেভেলপার যেন জটিল case-গুলো সোনার খাতা থেকে মুছে দিয়ে gate-কে ফাঁকি দিতে না পারে! এমনকি tolerance সীমার একদম প্রান্তিক মানগুলোতেও gate গাণিতিকভাবে শতভাগ নির্ভুল আচরণ করে (যেমন হার ঠিক 0.95 হলে তা pass হয়)।

command line

folio-eval হলো আমাদের তৈরি একটি শক্তিশালী কনসোল CLI টুল (FolioLens.Eval.Cli প্রোজেক্ট)। এর মূল কমান্ডগুলো নিম্নরূপ:

folio-eval run      --mode fake|live [--profile perfect|good|degraded|prompt-sensitive|flaky] [--seed N]
                    [--golden eval/golden-notes.jsonl] [--out report.json]
                    [--input-price P --output-price P] [--eval-date YYYY-MM-DD]
folio-eval gate     --report report.json --baseline eval-baseline.json
folio-eval baseline --report report.json --out eval-baseline.json [--update]
 
exit codes: 0 ok / gate passed, 1 gate failed, 2 bad usage or unreadable input

প্রোগ্রামটি শেষ হওয়ার সময় যে এক্সিট কোড প্রদান করে, স্বয়ংক্রিয় CI/CD pipeline মূলত সেই কোড দেখেই বিল্ডের ভাগ্য নির্ধারণ করে। এখানে 0 মানে সবকিছু সফল ও gate pass, 1 মানে পারফরম্যান্স অবনতির কারণে gate fail, এবং 2 মানে ভুল আর্গুমেন্ট বা ফাইল পার্সিং ত্রুটি।

--mode live ফ্ল্যাগ দিলে এটি প্রথম পর্বের OpenRouterOptions.FromEnvironment মেথডের মাধ্যমে সিস্টেমের পরিবেশ চলক থেকে API key ও model-এর নাম সংগ্রহ করে। যেহেতু এই মেশিনে কোনো সক্রিয় API key সংরক্ষিত নেই, তাই লাইভ মোডে বাণিজ্যিক কোনো model-এ কল করা হয়নি। তবে test-এ নিশ্চিত করা হয়েছে যে API key অনুপস্থিত থাকলে কোডটি স্পষ্ট নির্দেশনা দিয়ে এক্সিট কোড 2-তে থেমে যায়।

তারিখ সংক্রান্ত বৈষম্য দূর করতে সোনার খাতার "বর্তমান সময়" নির্ধারণ করা হয় --eval-date প্যারামিটার দিয়ে (ডিফল্ট SampleData.AsOf), যাতে সিস্টেমের রিয়েল ঘড়ির পরিবর্তনের কারণে একই ডেটাসেটের test কখনোই অনাকাঙ্ক্ষিতভাবে ভেঙে না পড়ে।

নিচে 80% scripted model-এর report-এর বিপরীতে আমাদের gate-এর বাস্তব কনসোল আউটপুট তুলে ধরা হলো:

PASS  case_count               baseline 25         actual 25         limit >= 25 (the golden set must not shrink)
FAIL  exact_match              baseline 1.000      actual 0.800      limit >= 0.950
FAIL  field:tradeDate          baseline 1.000      actual 0.800      limit >= 0.950
PASS  outcome_agreement        baseline 1.000      actual 1.000      limit >= 0.950
FAIL  false_accepts            baseline 0          actual 4          limit <= 0 (wrong drafts that passed every lock)
PASS  tokens_per_case          baseline 332.68     actual 403.4      limit <= 415.85
GATE: FAIL

এখানে তিনটি গুরুত্বপূর্ণ চেক সরাসরি FAIL করেছে: exact_match, field:tradeDate এবং false_accepts—যার চূড়ান্ত পরিণতি হিসেবে এসেছে GATE: FAIL এবং প্রসেসটি এক্সিট কোড 1 দিয়ে সমাপ্ত হয়েছে। কনসোলে স্পষ্ট দেখা যাচ্ছে baseline-এর মান কত ছিল, বর্তমান মান কত দাঁড়িয়েছে এবং অনুমোদিত সীমা ঠিক কত ছিল। একটি আধুনিক CI pipeline-এর জন্য এই স্পষ্ট তথ্যগুলোই সবচেয়ে মূল্যবান।

দৃশ্যপট

এবার দেখা যাক আমাদের regression gate বিভিন্ন জটিল বাস্তব পরিস্থিতিতে ঠিক কীভাবে প্রতিক্রিয়া জানায়। নিচে 12টি বাস্তবমুখী দৃশ্যপট তুলে ধরা হলো, যার প্রতিটির পেছনে রয়েছে স্বয়ংক্রিয় test (ScenarioTests-এর একটি [Theory])। এখানে ব্যবহৃত সমস্ত model scripted; ফলে সংখ্যাগুলো প্রমাণ করে আমাদের আর্কিটেকচারাল কাঠামোর যথার্থতা:

দৃশ্যপটপরিস্থিতিফল (exact / false accept)gate
perfect modelখাতার উত্তরই ফেরত1.00 / 0pass
80% modelপ্রতি পঞ্চম case-এ চোখে না পড়া ভুল তারিখ0.80 / 4fail: exact_match, field:tradeDate, false_accepts
prompt বদলের পর বাংলা অঙ্কprompt থেকে "ASCII digits" নিয়ম বাদ0.68 / 0fail: exact_match, সব field:*, outcome_agreement, tokens_per_case
এলোমেলো model, 10 run20% সম্ভাবনায় ভুল তারিখ0.72 থেকে 0.92(এক run-এ সিদ্ধান্ত নেওয়া ভরসার নয়)
একটা ভুল, review-তে আটকেভুলটা NeedsReview case-এ0.96 / 0pass
একটা ভুল, অথচ সই করার মতোভুলটা Accepted case-এ0.96 / 1fail: শুধু false_accepts
দুটো ভুলদুটোই Accepted case-এ0.92 / 2fail: exact_match, field:tradeDate, false_accepts
cost ফুলে ওঠাprompt-এ 20টা example ঢোকানো, উত্তর একই1.00 / 0fail: শুধু tokens_per_case
baseline updateনতুন, ভালো model—পুরোনো baseline-এ pass; baseline তুললে পুরোনো model fail
ছোট হয়ে যাওয়া set25-এর বদলে 20 case1.00 / 0fail: শুধু case_count
model বন্ধপ্রতি call-এ 5030.00 / 0fail: errors ও বাকিগুলো
production-এর ভুল golden set-এ26তম case যোগ1.00 / 0pass

দৃশ্যপট ক: prompt বদলের পর বাংলা অঙ্ক

ধরুন কোনো একজন ডেভেলপার prompt সংক্ষিপ্ত করতে গিয়ে অসাবধানতাবশত "ASCII digits" নির্দেশনার লাইনটি মুছে ফেললেন। এই লাইনটির কাজ ছিল model-কে বাধ্য করা যেন সে সংখ্যা সবসময় 0-9 অঙ্কে লেখে। scripted model-টি এমনভাবে প্রোগ্রাম করা যে এই লাইনটি অনুপস্থিত থাকলেই সে বাংলা সংখ্যার নোটে JSON-এর ভেতরে বাংলা অঙ্ক ("২০০") ঢুকিয়ে দেয়। ফলস্বরূপ JSON parsing সম্পূর্ণ ব্যর্থ হয় এবং তিনবার রিপেয়ার চেষ্টার পরও খসড়াটি বাতিল (Rejected) হয়:

case ModelProfile.PromptSensitive:
    if (!system.Contains("ASCII digits", StringComparison.Ordinal) && c.Tags.Contains("bangla-digits"))
        return BengaliDigitQuantity(draft);
    break;

test-এর আউটপুট: exact match নেমে এলো 0.68-এ, কোনো false accept হয়নি, প্রতি case-এ token খরচ 332.68 থেকে লাফিয়ে 625.72-এ উঠল, এবং মোট কল 27 থেকে বেড়ে 43-এ দাঁড়াল!

ট্যাগ ধরে ডেটা ফিল্টার করতেই আসল চিত্রটি পরিষ্কার হয়ে গেল: bangla-digits ট্যাগের 8টি case-এর প্রতিটিতেই model ব্যর্থ হয়েছিল, আর বাকি 17টি case-এ ফলাফল শতভাগ সফল ছিল! স্রেফ একটি গড় সংখ্যা 0.68 দেখলে এই বিশেষ দুর্বলতা ধরা যেত না। ট্যাগ দেখে মুহূর্তেই সমাধান স্পষ্ট হয়ে গেল।

এই দৃশ্যপট থেকে তিনটি অমূল্য শিক্ষা:

  1. prompt-এর একটি একক লাইনও production কোডের মতোই স্পর্শকাতর; এর পরিবর্তনও কঠোরভাবে মেপে দেখতে হয়।
  2. ক্ষতিটি আওয়াজ করে সামনে এসেছে (Rejected হয়ে), কোনো নীরব ভুল তৈরি করেনি।
  3. ব্যর্থ রিপেয়ার লুপের কারণে ক্লাউড বিল আকাশচুম্বী হয়েছে। অর্থাৎ একটি ভুল লাইনের মাশুল হিসেবে পারফরম্যান্স ও কস্ট উভয়ই ধ্বংস হয়েছে।

দৃশ্যপট খ: একটা ভুল, দুই রকম (চমক)

দুটি পৃথক run-এই ঠিক একটি case-এ তারিখ একদিন সরে গিয়েছিল। ফলে উভয় run-এই exact match ছিল 0.96—যা tolerance সীমার (0.95) ভেতরেই ছিল। কিন্তু গভীর তফাতটি লক্ষ্য করুন:

  • প্রথম run: ভুলটি ঘটেছে এমন একটি নোটে যা আগে থেকেই validation-এ NeedsReview স্ট্যাটাস পেয়েছিল। ফলে একজন মানুষ তা চোখে দেখার সুযোগ পেলেন; gate নির্বিঘ্নে pass করল।
  • দ্বিতীয় run: ভুলটি ঘটেছে একটি Accepted case-এ ("Tk. 59.60/-" ফি format-এর নোট)। কোনো নিয়ম এই ভুলটি ধরতে পারল না। ফলে gate সাথে সাথে বিল্ড আটকে দিল, এবং ব্যর্থ চেকটি ছিল শুধুই false_accepts!

উভয় run-এর সামগ্রিক স্কোর একদম হুবহু এক হওয়া সত্ত্বেও gate-এর সিদ্ধান্ত হলো সম্পূর্ণ বিপরীত! যে evaluation টুল শুধুই গড় accuracy দেখে, সে এই গভীর তফাত কখনোই ধরতে পারত না।

দৃশ্যপট গ: cost ফুলে ওঠা

model-এর পারফরম্যান্স বাড়ানোর আশায় কেউ একজন prompt-এ 20টি বিশদ উদাহরণ (few-shot learning) গুঁজে দিলেন। model-এর উত্তরে কোনো পরিবর্তন আসেনি, ফলে accuracy 1.00-ই বহাল থাকল। কিন্তু case-প্রতি token খরচ 332.68 থেকে এক লাফে 891.88-এ পৌঁছাল! ফলে প্রতি case-এর খরচ 0.00037376 থেকে 0.00093296 ডলারে উঠে গেল—প্রায় আড়াই গুণ বৃদ্ধি! আমাদের gate একটিমাত্র চেকে সাথে সাথে বিল্ড আটকে দিল: tokens_per_case।

ভালো উদাহরণ অবশ্যই পারফরম্যান্স বাড়াতে পারে; তবে তখন হিসাব মেলাতে হবে: মানের এই সামান্য উন্নতির মূল্য কি আড়াই গুণ বাড়তি বিল দেওয়ার চেয়ে বেশি? gate উভয় চিত্রই নির্মোহভাবে সামনে তুলে ধরে।

দৃশ্যপট ঘ: production-এর ভুল golden set-এ

ধরা যাক production-এ ইউরোপীয় format-এ লেখা একটি নোট এল: 140,50 আর 1.412,03। এখানে কমা হলো দশমিকের চিহ্ন, কিন্তু আমাদের ভ্যালিডেটর কমাকে হাজারের সেপারেটর ধরে অভ্যস্ত। ফলে সে টেক্সটে সংখ্যা খুঁজে না পেয়ে খসড়াটিকে NeedsReview-তে পাঠাল। অর্থাৎ সিস্টেম ভুল ধরতে পারলেও আমাদের নিয়মের সীমাবদ্ধতা স্পষ্ট হয়ে গেল। সাথে সাথে এই নোটটিকে p001-decimal-comma নামে সোনার খাতায় অন্তর্ভুক্ত করা হলো:

GoldenSet.Append(path, new GoldenCase(
    "p001-decimal-comma", ["production", "fee-format"],
    "Trade date: 2026-09-01\nALFA Buy 10 @ 140,50 charges 7,03 net 1.412,03",
    new ExpectedTrade("ALFA", "buy", 10, 140.50m, 7.03m, "2026-09-01", 1412.03m),
    ValidationOutcome.NeedsReview, "production-2026-09-03"));

খাতার আকার এখন 26টিতে উন্নীত হলো। perfect model-এ exact match 1.00 এবং gate pass। এভাবে production-এর প্রতিটি বাস্তব ভুল একবারই সিস্টেমকে শেখায়: সেটা case হয়ে খাতায় ঢোকে, কোড উন্নত হয়, এবং সোনার খাতা স্থায়ীভাবে সেই ভুলের পাহারাদার হিসেবে দাঁড়িয়ে যায়।

বাকি দৃশ্যপট সংক্ষেপে

  • 80% model: 25টির মধ্যে 5টি ভুল। তার মধ্যে 4টি Accepted হয়ে যাওয়ায় false accept সংখ্যা দাঁড়াল 4। পঞ্চম ভুলটি (g05, অচেনা কোম্পানি) স্বাভাবিকভাবেই Rejected হওয়ায় তা false accept-এ যুক্ত হয়নি।
  • baseline update: 80% model-এর report থেকে baseline তৈরি করলে perfect model অনায়াসে pass করে। কিন্তু perfect model-এর report থেকে baseline বানালে 80% model সাথে সাথে আটকে যায়। তাই baseline আপডেট একটি অত্যন্ত দায়িত্বশীল কাজ, যা সাধারণ কোড রিভিউয়ের মতোই সতর্কতার সাথে পরিচালনা করতে হয়।
  • ছোট হয়ে যাওয়া set: কেউ যদি ফাঁকিবাজি করে 5টি ব্যর্থ case ডেটাসেট থেকে মুছে দেয়, তবে accuracy 1.00 দেখালেও gate case_count চেকে বিল্ড আটকে দেয়।
  • model বন্ধ: সার্ভার থেকে 503 আসলে 25টি case-ই Error হয়, তবু report তৈরি হয় এবং gate errors চেকে fail করে।
  • perfect model: নিখুঁত model-এও 25টি case-এ মোট 27টি কল লাগে; কারণ অচেনা কোম্পানি ও ভবিষ্যৎ তারিখের দুটি নোটে সঠিকভাবেই রিপেয়ারের একটি করে বাড়তি চেষ্টা চালানো হয়।

মাপা

আমাদের FolioLens.Evaluation.Tests প্রোজেক্টে সর্বমোট 72টি স্বয়ংক্রিয় test রয়েছে (সবই scripted ক্লায়েন্টে)। এগুলো মূলত চারটি মৌলিক প্রশ্নের সুনির্দিষ্ট উত্তর দেয়:

  • পরিমাপক যন্ত্রের নির্ভুলতা: perfect model-এ 1.00, 80% model-এ 0.80, এবং broken model-এ 0.16 প্রাপ্তি প্রমাণ করে যে evaluation ইঞ্জিন নিখুঁতভাবে কাজ করছে।
  • gate-এর সঠিক প্রতিক্রিয়া: সহনসীমার প্রান্তিক মান, false accept-এর শূন্য সহনশীলতা, খাতা ছোট হয়ে যাওয়া কিংবা ভুল মোড শনাক্তকরণে gate সর্বদা সঠিক সিদ্ধান্ত নেয়।
  • report-এর সুস্থিতি (Idempotency): একই run দুবার চালালে বাইট-সমান JSON ফাইল তৈরি হয়।
  • কমান্ড লাইনের এক্সিট কোড: pass হলে 0, fail হলে 1, এবং আর্গুমেন্ট ত্রুটিতে 2 রিটার্ন করে।

production-এ কী ভাঙে

  • খাতা ছোট, কিন্তু আত্মবিশ্বাস আকাশচুম্বী: 25টি case-এর ডেটাসেটে একটি case ভুল হওয়া মানেই 4% পারফরম্যান্স পতন। production-এ খাতার আকার শত শত case-এ বৃদ্ধি করতে হবে যাতে confidence interval সরু হয়ে আসে।
  • একটিমাত্র run-এর ওপর ভিত্তি করে সিদ্ধান্ত: gate যদি একটিমাত্র run-এর ওপর ভিত্তি করে সিদ্ধান্ত নেয়, তবে লার্জ ল্যাঙ্গুয়েজ model-এর সহজাত তারতম্যের কারণে দৈবক্রমে বিল্ড pass বা fail করতে পারে। তাই CI pipeline-এ একাধিক run-এর গড় হিসাব করা উচিত।
  • সোনার খাতার প্রশ্ন prompt-এ মুখস্থ করানো (Data Leakage): prompt-এর ভেতরে সোনার খাতার case-গুলো উদাহরণ হিসেবে ঢুকিয়ে দিলে test-এ 100% accuracy দেখা যাবে বটে, কিন্তু তা কোনো বুদ্ধিমত্তা নয়—স্রেফ মুখস্থবিদ্যা!
  • আসল গ্রাহকের সংবেদনশীল নথি খাতায় ঢোকানো: production-এর কোনো বাস্তব ভুল সোনার খাতায় যুক্ত করার সময় গ্রাহকের নাম, বিও অ্যাকাউন্ট ও ঠিকানা সম্পূর্ণ মুছে কাল্পনিক ডেটায় রূপান্তর করতে হবে।
  • baseline-এর অবমূল্যায়ন: ডেভেলপাররা যাতে গোপনে baseline-এর মান কমিয়ে দিয়ে ব্যর্থ test-কে জোরপূর্বক pass করাতে না পারে, সেজন্য baseline ফাইলটি সর্বদা সিনিয়র আর্কিটেক্টের কোড রিভিউয়ের আওতায় থাকতে হবে।
  • ভুল উত্তরমালা (Ground Truth Error): সোনার খাতায় মানুষের লেখা প্রত্যাশিত মানে কোনো ভুল থাকলে পুরো পরিমাপ ভুল ফল দেবে।

অনুশীলন

  1. আগে অনুমান করুন, তারপর প্রমাণ করুন: gate-এর কনফিগারেশনে tokensPerCaseIncreaseRatio 0.25 থেকে বাড়িয়ে 0.50 করলে "80% model" দৃশ্যপটের fail করা চেকের তালিকায় কোনো পরিবর্তন আসবে কি? আগে খাতার পাতায় হিসাব করুন, তারপর কোড চালিয়ে মিলিয়ে নিন।
  2. ভুল তৈরি করুন: ScriptedModel-এর Good প্রোফাইলে index % 5 == 4 শর্তটিকে পরিবর্তন করে index % 10 == 4 করুন। এতে সামগ্রিক exact match রেট কত দাঁড়াবে এবং false accept-এর সংখ্যা কত হবে? আগে মুখে মুখে হিসাব করুন।
  3. নতুন case যুক্ত করুন: এমন একটি ব্রোকার নোট তৈরি করুন যেখানে ব্রোকারেজ ফি এবং সিডিবিএল চার্জ দুটি আলাদা লাইনে মুদ্রিত, কিন্তু মোট ফি লেখা নেই। আপনার বিবেচনায় এর সঠিক expected কী হওয়া উচিত? GoldenSet.Append ব্যবহার করে তা যুক্ত করুন এবং test চালান।
  4. ট্যাগ ধরে বিশ্লেষণ: ReportAnalysis.ExactByTag মেথড ব্যবহার করে "80%" model-এ ট্যাগভিত্তিক পারফরম্যান্স প্রিন্ট করুন এবং লক্ষ্য করুন কোন ট্যাগে সবচেয়ে বেশি ভুল জমা হচ্ছে।
  5. বাস্তব model-এর মুখোমুখি: লাইভ model-এ একই prompt পরপর 5 বার চালান (প্রতিবার আলাদা আউটপুট ফাইলে)। স্কোরের তারতম্য মেপে দেখুন এবং সেই বাস্তব অভিজ্ঞতার ভিত্তিতে আপনার gate-এর tolerance নির্ধারণ করুন।

মনে রাখুন: মাপো, তারপর বিশ্বাস করো। "মনে হচ্ছে ঠিক আছে" আর "25-এ 23 ঠিক, interval এত" এক কথা নয়।

যাচাইয়ের অবস্থা

এই পর্বের সমস্ত কোড net10.0-এ সফলভাবে কম্পাইল হয়েছে এবং FolioLens.Evaluation.Tests-এর 72টি test-এর সবগুলোই সফলভাবে pass করেছে (সম্পূর্ণ অফলাইনে, scripted ক্লায়েন্টে)। আর্টিকেলে প্রদর্শিত সমস্ত সংখ্যা ও gate-এর কনসোল লগ সরাসরি সেই test run-এর বাস্তব আউটপুট। তবে এই কম্পিউটারে কোনো বাণিজ্যিক API key সক্রিয় না থাকায় আসল ক্লাউড নেটওয়ার্কে কোনো লাইভ model-এর evaluation চালানো হয়নি। বাস্তব model-এর পারফরম্যান্স পরিমাপ করা এবং প্রথম লাইভ run-এর পর নিজস্ব production baseline তৈরি করা পাঠকের দায়িত্ব।

সূত্র

পরের পর্ব

সোনার খাতা আর regression gate নির্ভুলভাবে পরিমাপ করতে পারে, model ব্রোকার নোটটি ঠিকঠাক পড়তে পারল কি না। কিন্তু নথি পড়া আর জটিল গাণিতিক হিসাব কষা সম্পূর্ণ দুটি ভিন্ন জগৎ। ধরা যাক পোর্টফোলিওতে ALFA কোম্পানির একাধিক ক্রয়াদেশ জমা হলো। এখন সবগুলো মিলিয়ে গড় ক্রয়মূল্য (average cost) কিংবা বার্ষিক রিটার্ন (XIRR) কে হিসাব করবে? আমাদের পর্ব 4-এর মূল সূত্র শব্দ হলো কোড গোনে: সেখানে আমরা দেখব কীভাবে model-কে দিয়ে সরাসরি হিসাব না করিয়ে C# ফাংশন কল করাতে হয় (tool calling), এবং কীভাবে কোডের শক্তিতে পোর্টফোলিওর সমস্ত জটিল হিসাব শতভাগ নির্ভুল রাখতে হয়।

সিরিজের পথ: ← পর্ব 2: ছাঁচ · সিরিজের মানচিত্র · পর্ব 4: কোড গোনে →

Related reading