Оценяване на RAG: намира ли и стъпва ли

Код на:JavaC#PythonJavaScript

Накратко: Оценяването на RAG проверява две неща: дали търсенето намира правилното парче (recall@k) и дали отговорът стъпва само на намереното.

Проблем

По-евтино и „работи“

Асистентът от предишния урок слага до 3 парчета в промпта. Колега забелязва, че парчетата са повечето от токените. Сваля k на 1 и пробва два въпроса:

for (const question of ["колко струва доставката до офис", "банката отказа картата ми"])
  console.log(question + "\n  → " + answer(question, 1));

Изход

колко струва доставката до офис
  → Доставката до офис на куриер струва 3 €. [доставка-1]
банката отказа картата ми
  → Опитайте плащането с друга карта. [плащане-2]

И двата отговора са верни, с източник. Колегата пуска промяната.

На следващия ден асистентът казва на клиент, че парите се връщат до 14 дни. В документите пише 5. Двата въпроса на ръка не можеха да го хванат: при тях правилното парче е първо по близост.

Идеята

Два отделни въпроса

RAG може да сгреши на две места и те се мерят поотделно:

1. Намира ли? Търсенето трябва да донесе правилното парче сред първите k. Мястото му сред намерените е рангът. Делът на въпросите, при които рангът е от 1 до k, е recall@k. Това е същият recall от урока за оценката на модел: от всичко, което трябваше да намериш, колко намери.
2. Стъпва ли? Отговорът трябва да е от парчетата, които моделът е видял: всеки източник да е от промпта и всяко число да е в цитираното парче.

Третото, „вярно ли е“, е проверката „трябва да има“ от урока за оценяването. Трите заедно казват къде е грешката: в търсенето, в модела или в документите.

За това трябва тестов набор: въпроси на клиенти и за всеки парчето, което отговаря. Наборът се пише на ръка, веднъж, от човек, който знае документите.

Виж го

Тестовият набор и рангът

// тестовият набор
const CASES = [
  { topic: "цена на доставка", question: "колко струва доставката до офис", expect: "доставка-1", has: "3 €" },
  { topic: "срок на доставка", question: "кога ще пристигне пратката", expect: "доставка-2", has: "два дни" },
  { topic: "връщане", question: "искам да върна стоката", expect: "връщане-1", has: "14 дни" },
  { topic: "пари обратно", question: "кога ще ми върнете парите", expect: "връщане-2", has: "5 дни" },
  { topic: "наложен платеж", question: "може ли наложен платеж", expect: "плащане-1", has: "наложен платеж" },
  { topic: "отказана карта", question: "банката отказа картата ми", expect: "плащане-2", has: "друга карта" },
  { topic: "гаранция", question: "каква е гаранцията на стоката", expect: "гаранция-1", has: "2 години" },
  { topic: "неделя", question: "работите ли в неделя", expect: "", has: "не знам" },
];

// честният отказ започва така
const DECLINE = "не знам";

Последният въпрос няма парче: магазинът не е писал нищо за неделя. Правилният отговор е „не знам“.

Рангът е мястото на правилното парче сред намерените, а recall@k брои въпросите, при които то е сред първите k:

// мястото на правилното парче (от 1), 0 ако го няма
function rank(c) {
  const hits = search(c.question, PIECES.length);
  const i = hits.findIndex((h) => h.piece.id === c.expect);
  return i + 1;
}

// recall@k: при колко въпроса то е сред първите k
function recall(k) {
  let found = 0;
  for (const c of CASES) {
    const r = rank(c);
    if (r >= 1 && r <= k) found++;
  }
  return found;
}

console.log("тема".padEnd(18) + "ранг".padEnd(6) + "k=1".padEnd(5) + "k=3");
let total = 0;
for (const c of CASES) {
  if (c.expect === "") continue;
  total++;
  const r = rank(c);
  console.log(
    c.topic.padEnd(18) + String(r).padEnd(6) + mark(r >= 1 && r <= 1).padEnd(5) + mark(r >= 1 && r <= 3),
  );
}
for (const k of [1, 3]) console.log(`recall@${k} = ${recall(k)}/${total}`);

Изход

тема              ранг  k=1  k=3
цена на доставка  1     ✓    ✓
срок на доставка  3     ✗    ✓
връщане           4     ✗    ✗
пари обратно      2     ✗    ✓
наложен платеж    2     ✗    ✓
отказана карта    1     ✓    ✓
гаранция          1     ✓    ✓
recall@1 = 3/7
recall@3 = 6/7

// мястото на правилното парче (от 1), 0 ако го няма
function rank(c) {
  const hits = search(c.question, PIECES.length);
  const i = hits.findIndex((h) => h.piece.id === c.expect);
  return i + 1;
}

// recall@k: при колко въпроса то е сред първите k
function recall(k) {
  let found = 0;
  for (const c of CASES) {
    const r = rank(c);
    if (r >= 1 && r <= k) found++;
  }
  return found;
}

Стъпка по стъпка, с думи

1. Тестовият набор: 8 въпроса на клиенти и за всеки парчето, което отговаря. Последният няма парче в документите.
2. Ранг: на кое място е правилното парче сред намерените. За „връщане“ е чак 4-то: малкият модел за вектори греши.
3. При k = 1 в промпта влиза само първото парче. Правилното е там при 3/7 въпроса: recall@1 = 3/7.
4. При k = 3 правилното парче е вътре при 6/7: recall@3 = 6/7. Само „връщане“ остава навън.
5. Стъпва ли отговорът на парчетата? Всеки източник трябва да е в промпта и всяко число в източника: 7/8.
6. Два различни провала: търсенето не намери парчето (recall), а моделът написа число, което го няма в източника (стъпва).

При k = 1 правилното парче е в промпта само при 3 от 7 въпроса. При k = 3 е при 6. „връщане“ е с ранг 4: малкият модел за вектори смята „искам да върна стоката“ за по-близо до гаранцията.

Виж го

Стъпва ли отговорът

Проверката взема отговора и парчетата, които моделът е видял. Честният отказ минава. Всеки източник трябва да е сред парчетата, а всяко число в отговора трябва да е дума в цитираните парчета:

// стъпва ли отговорът на парчетата: "" или защо не
function unsupported(answer, hits) {
  if (answer.toLowerCase().startsWith(DECLINE)) return "";
  const ids = sources(answer);
  if (ids.length === 0) return "без източник";
  const words = new Set();
  for (const source of ids) {
    const hit = hits.find((h) => h.piece.id === source);
    if (!hit) return "източник извън промпта: " + source;
    hit.piece.text.split(" ").forEach((x) => words.add(x));
  }
  for (const word of answer.split(" ")) {
    if (word.startsWith("[")) continue;
    const n = word.replace(/[^0-9]/g, "");
    if (n !== "" && !words.has(n))
      return "числото " + n + " го няма в източника";
  }
  return "";
}

Тя връща празен низ, когато отговорът стъпва, а иначе причината. Причината е по-полезна от ✗: казва къде да гледаш.

Пробвай

Предвиди изхода

При k = 1 за „кога ще ми върнете парите“ в промпта влиза само „връщане-1“: „можете да върнете стоката до 14 дни в оригиналната опаковка“. Какво печата проверката за този отговор?

const claim = "Парите се връщат до 14 дни. [връщане-1]";
const why = unsupported(claim, search("кога ще ми върнете парите", 1));
console.log(why || "стъпва");

Отговор

стъпва

числото 14 го няма в източника

източник извън промпта: връщане-1

Провери

Виж го

Целият набор

report пуска всеки въпрос през RAG и печата трите знака: намерено, стъпва, вярно. При k = 3:

// целият набор при k парчета: намерено, стъпва, вярно
function report(k) {
  let found = 0, total = 0, stands = 0, right = 0;
  console.log(`k = ${k}`);
  console.log("тема              намерено  стъпва  вярно");
  for (const c of CASES) {
    const hits = search(c.question, k);
    const text = answer(c.question, k);
    const why = unsupported(text, hits);
    let f = "—";
    if (c.expect !== "") {
      total++;
      const inTop = hits.some((h) => h.piece.id === c.expect);
      if (inTop) found++;
      f = mark(inTop);
    }
    if (why === "") stands++;
    if (text.includes(c.has)) right++;
    const row = c.topic.padEnd(18) + f.padEnd(10) + mark(why === "").padEnd(8) + mark(text.includes(c.has));
    console.log(why === "" ? row : row + "  " + why);
  }
  const n = CASES.length;
  console.log(`recall@${k} ${found}/${total}, стъпва ${stands}/${n}, вярно ${right}/${n}`);
}

report(3);

Изход

k = 3
тема              намерено  стъпва  вярно
цена на доставка  ✓         ✓       ✓
срок на доставка  ✓         ✓       ✓
връщане           ✗         ✗       ✗  числото 30 го няма в източника
пари обратно      ✓         ✓       ✓
наложен платеж    ✓         ✓       ✓
отказана карта    ✓         ✓       ✓
гаранция          ✓         ✓       ✓
неделя            —         ✓       ✓
recall@3 6/7, стъпва 7/8, вярно 7/8

Единственият провал е „връщане“: правилното парче не е намерено, моделът е цитирал парчето за парите и е написал 30 дни, а в него пише 5. Проверката хваща числото.

Сега същото при k = 1, промяната на колегата:

report(1);

Изход

k = 1
тема              намерено  стъпва  вярно
цена на доставка  ✓         ✓       ✓
срок на доставка  ✗         ✗       ✓  източник извън промпта: доставка-2
връщане           ✗         ✗       ✗  източник извън промпта: връщане-2
пари обратно      ✗         ✓       ✗
наложен платеж    ✗         ✓       ✗
отказана карта    ✓         ✓       ✓
гаранция          ✓         ✓       ✓
неделя            —         ✓       ✓
recall@1 3/7, стъпва 6/8, вярно 5/8

Трите числа падат. Причините са различни: при „срок на доставка“ моделът цитира парче, което не е видял (и случайно е прав), при „пари обратно“ стъпва на грешното парче, а при „наложен платеж“ честно казва „Не знам.“, защото парчето не е намерено. Двата въпроса на ръка бяха от трите, които минават.

Пробвай

Попълни

Срещу кои парчета се търси всеки източник от отговора? Какво стои на мястото на ___?

// стъпва ли отговорът на парчетата: "" или защо не
function unsupported(answer, hits) {
  if (answer.toLowerCase().startsWith(DECLINE)) return "";
  const ids = sources(answer);
  if (ids.length === 0) return "без източник";
  const words = new Set();
  for (const source of ids) {
    const hit = .find((h) => h.piece.id === source);
    if (!hit) return "източник извън промпта: " + source;
    hit.piece.text.split(" ").forEach((x) => words.add(x));
  }
  for (const word of answer.split(" ")) {
    if (word.startsWith("[")) continue;
    const n = word.replace(/[^0-9]/g, "");
    if (n !== "" && !words.has(n))
      return "числото " + n + " го няма в източника";
  }
  return "";
}

Провери

Пробвай

Намери грешката

Колега пише recall наново. Сега recall@1 е 0/7, а recall@3 е 5/7. На кой ред е грешката?

Избери реда с грешката.

1// колегата брои намерените2function recall(k) {3 let found = 0;4 for (const c of CASES) {5 const r = rank(c);6 if (r >= 1 && r < k) found++;7 }8 return found;9}

Провери

Идеята

Кога боли

• Наборът е малък. Тук един въпрос е 14% от recall. Истинският набор е стотици въпроси, взети от истински разговори, и се допълва с всеки бъг от клиент.
• Етикетите остаряват. Правилното парче е записано по източника му. Когато документите се нарежат наново, източниците се сменят и наборът трябва да се обнови с тях.
• Стъпва не значи вярно. Отговорът „14 дни“ стъпва на грешно парче. Затова трите проверки са заедно: намерено, стъпва, вярно.
• Проверката е груба. Тя гледа само цифрите и само дали думата я има. „два дни“ с думи не се проверява, а „5“ от „5 евро“ минава и ако отговорът казва 5 дни. По-точно проверява втори модел (виж „Още“), но и той греши.
• Правилното парче може да е повече от едно. Отговорът може да е в две парчета. Тогава наборът пази всичките, а „намерено“ значи поне едно, или всички, ако трябват и двете.
• Наборът се пуска при всяка промяна. Ново k, нов праг, нов модел за вектори, ново нарязване, нов промпт: всяко сменя числата. Затова наборът е код и се пуска като тестовете, с праг, под който промяната не минава, както в урока за оценяването.

По-точно, за любопитните

Втори модел като съдия. Вместо да търсиш цифри, можеш да питаш втори модел: „Следва ли този отговор от тези парчета? Да или не.“ Хваща повече от грубата проверка, но струва още едно извикване и самият той трябва да се провери на набор с готови оценки.

Други мерки за търсенето. recall@k казва само дали парчето е вътре. MRR (средното на 1/ранг) казва и колко високо е: ранг 1 дава 1, ранг 3 дава 0,33. precision@k казва колко от k-те парчета са за въпроса, тоест колко токени отиват напразно.

Наборът в CI. Как наборът се пуска автоматично при всяка промяна и спира лоша версия преди да стигне до клиентите, е работа за ZeroToOps.

Set пази думите на цитираните парчета. find връща първото съвпадение или undefined, а replace(/[^0-9]/g, "") оставя само цифрите.

Упражнение

Колко да е k

Реши в редактора си.

Напиши функция, която за дадено k пуска целия набор и печата recall, стъпва, вярно и колко токена са влезли в промптовете (токените на промпта и на въпроса, само когато моделът е извикан). Пусни я за k от 1 до 4:

Изход

k = 1: recall 3/7, стъпва 6/8, вярно 5/8, 576 токена
k = 2: recall 5/7, стъпва 6/8, вярно 7/8, 736 токена
k = 3: recall 6/7, стъпва 7/8, вярно 7/8, 808 токена
k = 4: recall 7/7, стъпва 8/8, вярно 8/8, 866 токена

Кое k би избрал и защо? k = 4 оправя „връщане“, а струва около 7% повече токени от k = 3. Помисли и колко от тези числа са просто този малък набор.

Още задачи

• Праг. Пусни набора с праг 0,6 и 0,7 при k = 3. Какво става с recall и с „неделя“?
• MRR. Изчисли средното на 1/ранг за седемте въпроса с парче (ранг 0 дава 0).

Тест

Провери се

1. Правилното парче за един въпрос е трето по близост. При кои k то влиза в промпта?

При всяко k, щом е над прагаПри k = 3 и повече: рангът му е 3, а влизат първите kСамо при k = 3

2. recall@3 е 6/7. Какво значи това?

Моделът е отговорил на 6 въпроса от 7При 6 от 7-те въпроса с правилно парче то е сред първите 3 намерени6 от 7 отговора са верни

3. Отговорът цитира [доставка-2], но в промпта е само „връщане-2“. Какво казва проверката?

Стъпва, защото „доставка-2“ съществува в документитеСтъпва, ако отговорът е веренНе стъпва: източникът е извън промпта, моделът го е взел от паметта си

4. Отговорът стъпва на парчето, което е в промпта. Значи ли това, че е верен?

Не: ако търсенето е донесло грешното парче, отговорът стъпва на него и пак е грешенДа, ако има число в отговораДа: щом е от документите, е верен

5. При k = 4 трите числа са пълни (7/7, 8/8, 8/8), а токените са с около 7% повече от k = 3. Какво от това следва?

k = 4 е най-доброто за всеки RAGПовече k винаги е по-добреРешението е между цена и качество, взето с числа от набора, и важи за този набор

Провери

Започни урока отначало

Свързани уроци

• Нужно отпреди: Цена и бавност: бюджет, кеш, по-малък модел · Търсене по смисъл: най-близките k · Нарязване на документи (chunking) · RAG: отговор от документите
• Продължава в: Асистентът на поддръжката
• Задачи по темата: Търсене по смисъл и RAG