नियमों के आधार पर इवैलुएशन बनाना

ऑटोमेशन की बुनियादी बातें: आसान गड़बड़ियों को पकड़ने के लिए कोड का इस्तेमाल करना.

Maud Nalpas

अब आपको पता चल गया है कि नियम के आधार पर किए जाने वाले आकलन की मदद से, आपको किन गड़बड़ियों को पकड़ना है. अब समय आ गया है कि आकलन करने वाले फ़ंक्शन लागू किए जाएं:

  • evalDataFormat(): यह जांच करता है कि डेटा का फ़ॉर्मैट सही है या नहीं. इसमें मान्य JSON, सभी कुंजियां मौजूद होना, कोई भी वैल्यू खाली न होना, मोटो छह शब्दों से कम होना, हेक्साडेसिमल रंग शामिल हैं.
  • evalContrastRatio(): यह जांच करता है कि टेक्स्ट-टू-बैकग्राउंड कलर कंट्रास्ट रेशियो, ऐक्सेस किया जा सकता है या नहीं.

नियम के आधार पर किए जाने वाले आकलन लागू करना

स्कोरिंग का तरीका चुनना

आकलन के मानदंड बाइनरी होते हैं. नियम के आधार पर किए जाने वाले आकलन के फ़ंक्शन से, बाइनरी आउटपुट मिलना चाहिए. जैसे, PASS या FAIL लेबल.

  • ThemeBuilder ऐप्लिकेशन का आउटपुट (पूरी थीम ऑब्जेक्ट) → evalDataFormat() → PASS या FAIL लेबल. अगर डेटा का फ़ॉर्मैट सभी ज़रूरी शर्तों को पूरा करता है, तो PASS लेबल दिखेगा. अन्यथा, FAIL लेबल दिखेगा.
  • ThemeBuilder ऐप्लिकेशन का आउटपुट (कलर पैलेट ऑब्जेक्ट) → evalContrastRatio() → PASS या FAIL लेबल .अगर रेशियो 4.5 से ज़्यादा है, तो PASS लेबल दिखेगा. अन्यथा, FAIL लेबल दिखेगा.

आकलन के टाइप की जानकारी देना

PASS या FAIL मेट्रिक, बूलियन होती है. हालांकि, इसे आसानी से पढ़ने के लिए, स्ट्रिंग लेबल (कैटगरी) के तौर पर लागू किया जा सकता है.

कम कोड का इस्तेमाल करने के लिए, नियम के आधार पर किए जाने वाले आकलन और LLM जज के आकलन, दोनों के लिए एक ही TypeScript टाइप का इस्तेमाल किया जा सकता है. इन्हें बाद में लागू किया जाएगा. EvalResult टाइप बनाएं. यह बाइनरी EvalLabel कैटगरी और जज मॉडल के लिए rationale फ़ील्ड को रैप करता है, ताकि वह अपनी रेटिंग की वजह बता सके.

enum EvalLabel {
    PASS = "PASS",
    FAIL = "FAIL"
}

interface EvalResult {
    label: EvalLabel;
    rationale?: string;
}

आकलन करने वाले टूल लागू करना

Zod , स्कीमा की पुष्टि करने के लिए एक बेहतरीन टूल है. यह JSON स्ट्रक्चर और कस्टम नियमों, दोनों को हैंडल करता है. यह डिक्लेरेटिव है. इसलिए, पुष्टि करने वाला कोड आसानी से पढ़ा जा सकता है. समस्या हल करने में आसानी के लिए, गड़बड़ी की जानकारी देने वाली विस्तृत रिपोर्ट तय करें. इसमें गड़बड़ियों की खास वजहें और पाथ शामिल करें.

import { z } from 'zod';
import { MAX_WORD_COUNT } from './app.config';

const hexColorRegex = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;

// Reusable schema for hex colors
const HexColor = z.string().regex(hexColorRegex, { message: "Invalid hex color code" });

// zod schema definition for AppOutput
export const AppOutputSchema = z.object({
  motto: z.string().min(1, { message: "Motto is missing or empty" }).refine((val) => {
    const words = val.replace(/[^\w\s]|_/g, "").trim();
    const count = words ? words.split(/\s+/).length : 0;
    return count > 0 && count <= MAX_WORD_COUNT;
  }, { message: `Motto must be between 1 and ${MAX_WORD_COUNT} words` }),
  colorPalette: z.object({
    textColor: HexColor,
    backgroundColor: HexColor,
    primary: HexColor,
    secondary: HexColor
  }).catchall(HexColor)
});

कंट्रास्ट रेशियो

डोमेन लॉजिक, जैसे कि कंट्रास्ट-रेशियो की कैलकुलेशन को अलग-अलग यूटिलिटी फ़ंक्शन में रखें.

/*
 * Input: ColorPalette {"textColor":"#333333","backgroundColor":"#000000", ...}
 * Output: EvalResult {"status":"FAIL","rationale":"Contrast ratio is 1.66:1 (must be >= 4.5:1)."}
 * minContrastRatio is an app config variable, MIN_CONTRAST_RATIO = 4.5
*/
export function evalContrastRatio(colorPalette: ColorPalette, minContrastRatio: number): EvalResult {
  if (!colorPalette || !colorPalette.textColor || !colorPalette.backgroundColor) {
    return { status: EvalLabel.FAIL, rationale: "Missing textColor or backgroundColor." };
  }
  try {
    const ratio = getContrastRatio(colorPalette.textColor, colorPalette.backgroundColor);
    const rationale = `Contrast ratio is ${ratio.toFixed(2)}:1 (must be >= ${minContrastRatio}:1).`;
    if (ratio < minContrastRatio) {
      return { status: EvalLabel.FAIL, rationale };
    }
    return { status: EvalLabel.PASS, rationale };
  } catch (e) {
    return { status: EvalLabel.FAIL, rationale: "Could not calculate contrast ratio (invalid hex?)." };
  }
}

हमारे आकलन करने वाले टूल के कोड के लिए, evalDataFormat() और evalContrastRatio() देखें.

नियम के आधार पर किए जाने वाले आकलन की जांच करना

नियम के आधार पर किए जाने वाले आकलन, तय किए गए तरीके से काम करते हैं. इसलिए, इनके व्यवहार की जांच करने के लिए, क्लासिक यूनिट टेस्ट लागू किए जा सकते हैं. अपने टेस्ट इस तरह बनाएं कि आकलन करने वाले टूल की मदद से अलग-अलग आउटपुट चलाए जा सकें. साथ ही, यह दावा किया जा सके कि वे आपकी उम्मीद के मुताबिक PASS या FAIL लेबल दिखाते हैं या नहीं.

अगर किसी टेस्ट केस में, आकलन करने वाले टूल से FAIL लेबल मिलने की उम्मीद की जाती है और ऐसा होता है, तो टेस्ट में PASS लेबल दिखता है. ऐसा इसलिए होता है, क्योंकि आकलन करने वाले टूल ने उम्मीद के मुताबिक काम किया है.

import { MIN_CONTRAST_RATIO } from '../src/app.config'; // 4.5

const testCases = [
  {
  // ...
      appOutput: {
        motto: "Test motto",
        colorPalette: {
          textColor: "#333333",
          backgroundColor: "#000000",
          primary: "#FF0000",
          secondary: "#333333"
        }
      },
    expected: {
      // Dark grey on black (low contrast): FAIL
      contrast: EvalLabel.FAIL
    }
  }
  // ... more test cases
];

testCases.forEach((testCase) => {
  const result = evalContrastRatio(
    testCase.appOutput.colorPalette as any, MIN_CONTRAST_RATIO
  );
  const actualEvalLabel = result.label;
  const expectedEvalLabel = testCase.expected.contrast;
  const isSuccess = actualEvalLabel === expectedEvalLabel;
 // ...
});

इसे आज़माएं

पीछे जाएं
डिज़ाइन की समीक्षाएं
आगे बढ़ें
पार्ट 1