ដែនកំណត់ ថ្លៃដើម និងសំណួរដែលអ្នកនឹងត្រូវគេសួរ

មាតិកា

  1. ដាក់ចូលគ្នា
  2. រូបមន្ត៖ Module report
  3. រូបមន្ត៖ ឧបករណ៍ command-line llmlab
  4. ហេតុអ្វីថ្លៃដើមកើនលឿនជាងអ្នកគិត
  5. Latency៖ ហេតុអ្វីចម្លើយ stream
  6. Model តូច Model ធំ និង laptop របស់អ្នក
  7. Open Model ទល់នឹង Closed Model
  8. អ្វីដែល LLM ពូកែ និងអ្វីដែលមិនពូកែ
  9. Bias សុវត្ថិភាព និងឯកជនភាព
  10. ថាមពល និងបរិស្ថាន
  11. តើវាគិតទេ? តើវាយល់ទេ?
  12. ចុះការងារវិញ?
  13. សាកល្បងដោយខ្លួនឯង
  14. សំណួរដែលអ្នកនឹងត្រូវគេសួរ

1. ដាក់ចូលគ្នា

អ្នកបានសាងសង់ជាទម្រង់តូច ស្ទើរតែគ្រប់គំនិតនៅក្នុង large language model។ នេះជា pipeline ទាំងមូលក្នុងរូបតែមួយ។ ប្រអប់នីមួយៗគឺជាជំពូកដែលអ្នកបានធ្វើរួចហើយ៖

 "Sokha opens the coffee shop"
              |
              v
   +----------------------+
   | 1. TOKENIZE          |   text -> small pieces -> numbers
   |    (chapter 2)       |   [Sok][ha][ opens][ the][ coffee][ shop]  (example split)
   +----------------------+
              |
              v
   +----------------------+
   | 2. EMBED             |   each token id -> a list of numbers
   |    (chapter 6)       |   (a vector that captures meaning)
   +----------------------+
              |
              v
   +----------------------+
   | 3. TRANSFORMER       |   many layers; attention lets each token
   |    LAYERS            |   look at the others in the context
   |    (chapters 5, 6)   |   (the learned parameters live here)
   +----------------------+
              |
              v
   +----------------------+
   | 4. SCORES -> PROBS   |   one score per possible next token,
   |    (chapters 3, 4)   |   then softmax -> probabilities
   +----------------------+
              |
              v
   +----------------------+
   | 5. SAMPLE            |   temperature, top-k, top-p decide
   |    (chapter 4)       |   which token to pick
   +----------------------+
              |
              v
   +----------------------+
   | 6. APPEND            |   add the token to the context
   |    (chapters 1, 7)   |   (the context window is the limit)
   +----------------------+
              |
              +-----------> repeat from step 1 until done

មានបីរឿងនៅជុំវិញរង្វិលជុំនេះ។ Training (ជំពូកទី 5) គឺជារបៀបដែលលេខខាងក្នុងជំហានទី 3 ទទួលបានតម្លៃរបស់វា។ Prompt និង role (ជំពូកទី 8) សម្រេចថាអត្ថបទអ្វីចូលនៅដើម។ Grounding និងការពិនិត្យ (ជំពូកទី 9) សម្រេចថាអ្នកធ្វើអ្វីជាមួយអត្ថបទដែលចេញមក។ ប្រសិនបើអ្នកអាចពន្យល់ដ្យាក្រាមនេះដល់មិត្តម្នាក់ អ្នកយល់ LLM ល្អជាងមនុស្សភាគច្រើន ដែលប្រើវារាល់ថ្ងៃ។

ការធ្វើឲ្យសាមញ្ញដ៏ស្មោះត្រង់៖ model ពិតប្រាកដប្រើ token ជាផ្នែកនៃពាក្យ (sub-word) (មិនមែនពាក្យទាំងមូលទេ) មាន transformer layer ជាច្រើនសិប ជាមួយ "head" attention ច្រើន ហើយរៀន vector របស់វាក្នុងអំឡុងពេល train។ toy របស់អ្នកប្រើពាក្យទាំងមូល តារាងមួយ និង vector ដែលធ្វើដោយដៃ។ រង្វិលជុំគឺដូចគ្នា។

2. រូបមន្ត៖ Module report

ឥឡូវនេះសូមបន្ថែម module ចុងក្រោយទៅ llmlab៖ របាយការណ៍ដែលបង្ហាញថា prompt មួយមានតម្លៃប៉ុន្មាន និងប្រើ context window ប៉ុនណា បូក function ដែលបង្កើតអត្ថបទពី toy model នៅ temperature ណាមួយ។ វាប្រើ wordTokens និង estimateCost ពី Tokens and Tokenizers, nextWordProbs ពី Build a Tiny Language Model និង function sampling ពី Probabilities, Temperature and Sampling។

បង្កើត src/report.js៖

import { wordTokens, estimateCost } from "./tokenizer.js";
import { nextWordProbs } from "./bigram.js";
import { softmax, applyTemperature, sampleIndex, greedy } from "./sampling.js";

// Example numbers only. Real prices and window sizes differ per model and change often.
export const EXAMPLE_PRICE_PER_MILLION = 3; // dollars per 1,000,000 input tokens
export const EXAMPLE_CONTEXT_WINDOW = 8000; // tokens

// Real tokenizers split text into sub-word pieces. A common rule of thumb
// for English is about 4 characters per token. This is an estimate.
export function estimateTokens(text) {
  return Math.ceil(text.length / 4);
}

export function usageReport(prompt, {
  pricePerMillion = EXAMPLE_PRICE_PER_MILLION,
  windowSize = EXAMPLE_CONTEXT_WINDOW,
} = {}) {
  const tokens = estimateTokens(prompt);
  return {
    characters: prompt.length,
    wordCount: wordTokens(prompt).length,
    tokens,
    cost: estimateCost(tokens, pricePerMillion),
    windowUsed: tokens / windowSize,
  };
}

// Pick the next word from the bigram model at a given temperature.
// Temperature 0 means "always take the most likely word" (greedy).
export function sampleNext(model, word, temperature, rng) {
  const options = nextWordProbs(model, word);
  if (options.length === 0) return null;
  if (temperature === 0) return options[greedy(options.map((o) => o.p))].word;
  const logits = options.map((o) => Math.log(o.p));
  const probs = softmax(applyTemperature(logits, temperature));
  return options[sampleIndex(probs, rng)].word;
}

export function generateAtTemperature(model, startWord, length, temperature, rng) {
  const out = [startWord];
  let current = startWord;
  for (let i = 0; i < length; i++) {
    const next = sampleNext(model, current, temperature, rng);
    if (next === null) break;
    out.push(next);
    current = next;
  }
  return out.join(" ");
}

export function formatReport(prompt, r, windowSize = EXAMPLE_CONTEXT_WINDOW) {
  return [
    `prompt:        ${JSON.stringify(prompt)}`,
    `characters:    ${r.characters}`,
    `words:         ${r.wordCount}`,
    `tokens (est):  ${r.tokens}`,
    `cost (example): $${r.cost.toFixed(6)}`,
    `window used:   ${(r.windowUsed * 100).toFixed(2)}% of ${windowSize} tokens`,
  ].join("\n");
}

អ្វីដែល export មាន៖

  • estimateTokens(text) ត្រឡប់ Math.ceil(text.length / 4)។ នេះជា ច្បាប់ប្រមាណសម្រាប់ភាសាអង់គ្លេស មិនមែន អ្វីដែល tokenizer ពិតប្រាកដត្រឡប់ទេ។ tokenizer របស់ model ពិតប្រាកដណាមួយអាចផ្តល់ចំនួនខុសគ្នា ហើយសម្រាប់ភាសាដូចជាខ្មែរ វាច្រើនតែខ្ពស់ជាងក្នុងមួយតួអក្សរ ដូច្នេះសូមបិទភ្ជាប់អត្ថបទរបស់អ្នកទៅក្នុងទំព័រ tokenizer របស់ model ដែលអ្នកប្រើ មុនពេលធ្វើថវិកា។
  • usageReport(prompt, { pricePerMillion, windowSize }) ត្រឡប់ { characters, wordCount, tokens, cost, windowUsed }។ តម្លៃលំនាំដើម (3 ដុល្លារក្នុងមួយលាន token, window 8000 token) គឺជា ឧទាហរណ៍ដែលបង្កើតឡើង។ សូមដាក់លេខពិតពីទំព័ររបស់អ្នកផ្តល់សេវា។
  • sampleNext(model, word, temperature, rng) ជ្រើសពាក្យបន្ទាប់មួយ។ Temperature 0 គឺ greedy; អ្វីដែលលើសពីនោះធ្វើមាត្រដ្ឋាន log-probability អនុវត្ត softmax ហើយ sample ដូចក្នុង ជំពូកទី 4 ដែរ។
  • generateAtTemperature(model, startWord, length, temperature, rng) ធ្វើ sampleNext ម្តងហើយម្តងទៀត ហើយត្រឡប់ប្រយោគ។
  • formatReport(prompt, report, windowSize) ត្រឡប់ string ដែលអាចបោះពុម្ពបាន។

3. រូបមន្ត៖ ឧបករណ៍ command-line llmlab

បង្កើត src/index.js។ វាជា CLI តូចមួយ៖ ផ្តល់ prompt ឲ្យវា ហើយវាបោះពុម្ពរបាយការណ៍ការប្រើប្រាស់ និងប្រយោគមួយពី toy model។

import { corpus, words } from "./corpus.js";
import { trainBigram } from "./bigram.js";
import { mulberry32 } from "./rng.js";
import { usageReport, formatReport, generateAtTemperature } from "./report.js";

// Usage: node src/index.js "your prompt" [--temp 0.7] [--seed 1]
const args = process.argv.slice(2);
const flag = (name, fallback) => {
  const i = args.indexOf(name);
  return i === -1 ? fallback : Number(args[i + 1]);
};
const prompt = args.find((a, i) => !a.startsWith("--") && !args[i - 1]?.startsWith("--"));
if (!prompt) {
  console.log('Usage: node src/index.js "your prompt" [--temp 0.7] [--seed 1]');
  process.exit(1);
}
const temperature = flag("--temp", 0.7);
const seed = flag("--seed", 1);

console.log(formatReport(prompt, usageReport(prompt)));

const model = trainBigram(words(corpus));
const last = words(prompt).at(-1);
const start = model.has(last) ? last : "the";
console.log(`\ntoy model, temperature ${temperature}, seed ${seed}, start "${start}":`);
console.log(generateAtTemperature(model, start, 10, temperature, mulberry32(seed)));

ឧបករណ៍នេះចាប់ផ្តើម toy model ពីពាក្យចុងក្រោយនៃ prompt របស់អ្នកប្រសិនបើ model ស្គាល់វា ហើយពី the ប្រសិនបើវាមិនស្គាល់។ រត់វាបីរបៀប៖

node src/index.js "Explain how the coffee shop app works"
# prompt:        "Explain how the coffee shop app works"
# characters:    37
# words:         7
# tokens (est):  10
# cost (example): $0.000030
# window used:   0.13% of 8000 tokens
#
# toy model, temperature 0.7, seed 1, start "the":
# the river and the small coffee shop needs good app

node src/index.js "Who is Dara" --temp 0
# prompt:        "Who is Dara"
# characters:    11
# words:         3
# tokens (est):  3
# cost (example): $0.000009
# window used:   0.04% of 8000 tokens
#
# toy model, temperature 0, seed 1, start "dara":
# dara writes code and dara writes code and dara writes

node src/index.js "Who is Dara" --temp 1.5 --seed 3
# prompt:        "Who is Dara"
# characters:    11
# words:         3
# tokens (est):  3
# cost (example): $0.000009
# window used:   0.04% of 8000 tokens
#
# toy model, temperature 1.5, seed 3, start "dara":
# dara thinks about the coffee sokha makes iced coffee shop

អ្វីៗទាំងអស់នៅទីនេះមានលក្ខណៈកំណត់ច្បាស់លាស់ ព្រោះ random generator ត្រូវបាន seed (--seed) ហើយ prompt គឺដូចគ្នា។ ប្តូរ seed ហើយប្រយោគនឹងប្តូរ។ នៅ temperature 0 seed មិនសំខាន់ទេ ព្រោះ model តែងតែយកពាក្យដែលទំនងបំផុត។ សូមកត់សម្គាល់ថាវាក៏ធ្លាក់ចូលរង្វិលជុំដែរ ("dara writes code and dara writes code ...")៖ ការយកពាក្យដែលទំនងបំផុតតែមួយជានិច្ច អាចទាយទុកបាន ប៉ុន្តែវាអាចនិយាយដដែលៗ។ ការរត់ node src/index.js ដោយគ្មាន prompt នឹងបោះពុម្ពបន្ទាត់ usage ហើយចេញ។

ចំណុចខ្លះដែលត្រូវកត់សម្គាល់។ prompt 37 តួអក្សរគឺប្រហែល 10 token ដែលមានតម្លៃតែប្រភាគតូចមួយនៃសេនក្នុងតម្លៃឧទាហរណ៍ ហើយប្រើតែផ្នែកតូចមួយនៃ window ឧទាហរណ៍។ សំណួរខ្លីតែមួយស្ទើរតែឥតគិតថ្លៃ។ ថ្លៃដើម និងដែនកំណត់ក្លាយជាការពិតនៅពេលអ្នកផ្ញើអត្ថបទ វែង request ច្រើន ឬ ការសន្ទនាវែង ដែលជាផ្នែកបន្ទាប់។

4. ហេតុអ្វីថ្លៃដើមកើនលឿនជាងអ្នកគិត

model ដែលបង្ហោះ (hosted) ជាធម្មតាគិតថ្លៃតាម token ជាមួយតម្លៃមួយសម្រាប់ token input (អ្វីៗដែលអ្នកផ្ញើ) ហើយច្រើនតែមានតម្លៃខ្ពស់ជាងសម្រាប់ token output (អ្វីដែល model សរសេរ)។ ចាំពី Context Windows and Memory ថាការជជែកមិនចងចាំទេ៖ កម្មវិធីរបស់អ្នកផ្ញើប្រវត្តិទាំងមូលម្តងទៀតជាមួយគ្រប់សារថ្មី។ ដូច្នេះ token input កើនឡើងរាល់ turn។

import { estimateCost } from "./src/tokenizer.js";

const PRICE_IN = 3;   // example: dollars per million input tokens
const PRICE_OUT = 15; // example: output tokens usually cost more

const turns = 10;
const userTokens = 100;   // each user message
const replyTokens = 300;  // each model reply
let history = 0;
let inputTotal = 0;
let outputTotal = 0;

for (let turn = 1; turn <= turns; turn++) {
  const sent = history + userTokens;   // the whole history is resent
  inputTotal += sent;
  outputTotal += replyTokens;
  history = sent + replyTokens;
  if (turn === 1 || turn === 5 || turn === 10) console.log("turn", turn, "sends", sent, "input tokens");
}

const cost = estimateCost(inputTotal, PRICE_IN) + estimateCost(outputTotal, PRICE_OUT);
console.log("input tokens total:", inputTotal);
console.log("output tokens total:", outputTotal);
console.log("one conversation: $" + cost.toFixed(4));
console.log("1,000 conversations a day: $" + (cost * 1000).toFixed(2));
// turn 1 sends 100 input tokens
// turn 5 sends 1700 input tokens
// turn 10 sends 3700 input tokens
// input tokens total: 19000
// output tokens total: 3000
// one conversation: $0.1020
// 1,000 conversations a day: $102.00

លេខទាំងអស់គឺជាឧទាហរណ៍ ប៉ុន្តែនព្វន្ធគឺពិត ហើយលទ្ធផលមានស្ថេរភាព។ មើលអ្វីដែលបានកើតឡើង៖ អ្នកប្រើវាយតែ 100 token ក្នុងមួយ turn (សរុប 1,000) ប៉ុន្តែកម្មវិធីបានផ្ញើ token input 19,000 ច្រើនជាងដប់ប្រាំបួនដង ព្រោះគ្រប់ turn ផ្ញើអ្វីៗទាំងអស់មុននោះម្តងទៀត។ ថ្លៃដើមនៃការសន្ទនាមួយកើនលឿនជាងប្រវែងរបស់វា។

វិធីដែលអ្នកអភិវឌ្ឍន៍គ្រប់គ្រងរឿងនេះ៖

  • កាត់ ឬសង្ខេបប្រវត្តិចាស់ (trimHistory ពីជំពូកទី 7)។
  • រក្សា prompt ឲ្យខ្លី និងជាក់លាក់។ កុំបិទភ្ជាប់ឯកសារទាំងមូលនៅពេលកថាខណ្ឌមួយគ្រប់គ្រាន់។
  • ប្រើ model តូចជាង និងថោកជាង សម្រាប់ការងារងាយៗ (classify, extract, reformat) ហើយប្រើ model ធំជាងសម្រាប់តែការងារពិបាក។
  • Prompt caching។ អ្នកផ្តល់សេវាខ្លះគិតថ្លៃតិចជាងសម្រាប់ដើមដដែលៗនៃ prompt ដូច្នេះរក្សាផ្នែកថេរ (system message, សេចក្តីណែនាំ) នៅខាងមុខ។ សួរអ្នកផ្តល់សេវារបស់អ្នកអំពីរបៀបដែលវាដំណើរការ។
  • កំណត់ប្រវែង output អតិបរមា ដើម្បីកំណត់ការឆ្លើយដែលវែងហួសហេតុ។
  • វាស់៖ កត់ត្រាចំនួន token ក្នុងមួយ request ព្រោះវិក្កយបត្ររបស់អ្នកធ្វើពី token។

5. Latency៖ ហេតុអ្វីចម្លើយ stream

ចាំរង្វិលជុំ៖ មួយ token ម្តង ដែលនីមួយៗត្រូវការឆ្លងកាត់ model ទាំងមូលម្តង។ ចម្លើយវែងត្រូវការការឆ្លងកាត់រាប់រយដង ដូច្នេះវាចំណាយពេលជាច្រើនវិនាទី សូម្បីតែពេលម្តងៗលឿន។ ផលវិបាកជាក់ស្តែងពីរ៖

  • output វែងជាងមានន័យថាចម្លើយយឺតជាង។ ការសុំ "ចម្លើយខ្លី" សន្សំទាំងពេលវេលា និងលុយ។
  • Streaming។ API ភាគច្រើនអាចផ្ញើ token នៅពេលវាត្រូវបានបង្កើត ដូច្នេះអ្នកប្រើឃើញអត្ថបទលេចឡើងភ្លាមៗ ជំនួសឲ្យការសម្លឹងមើលអេក្រង់ទទេ។ ពេលវេលាសរុបគឺដូចគ្នា ប៉ុន្តែ អារម្មណ៍ ល្អជាងច្រើន។

6. Model តូច Model ធំ និង laptop របស់អ្នក

model ភាគច្រើនគឺជាបញ្ជីវែងនៃលេខ (parameter)។ ទំហំ memory ដែលត្រូវការគឺជា នព្វន្ធសាលារៀនសាមញ្ញ៖ ចំនួន parameter គុណនឹង byte ក្នុងមួយ parameter។ បច្ចេកទេសមួយហៅថា quantization រក្សាទុកលេខនីមួយៗដោយប្រើ bit តិចជាង ដូច្នេះ model ប្រើ memory តិចជាងដោយបាត់បង់គុណភាពបន្តិចបន្តួច។

const bytesPerParam = { "16-bit": 2, "8-bit": 1, "4-bit": 0.5 };

for (const billions of [1, 7, 70]) {
  const row = Object.entries(bytesPerParam).map(
    ([name, bytes]) => `${name}: ${(billions * bytes).toFixed(1)} GB`
  );
  console.log(`${String(billions).padStart(2)}B parameters ->`, row.join(" | "));
}
// 1B parameters -> 16-bit: 2.0 GB | 8-bit: 1.0 GB | 4-bit: 0.5 GB
// 7B parameters -> 16-bit: 14.0 GB | 8-bit: 7.0 GB | 4-bit: 3.5 GB
// 70B parameters -> 16-bit: 140.0 GB | 8-bit: 70.0 GB | 4-bit: 35.0 GB

នេះគឺជា memory សម្រាប់តែ weight ខ្លួនឯងប៉ុណ្ណោះ។ ការរត់ model ក៏ត្រូវការ memory បន្ថែមសម្រាប់ context និងកន្លែងធ្វើការ ដូច្នេះតម្រូវការពិតប្រាកដខ្ពស់ជាង។ យ៉ាងណាក៏ដោយ វាពន្យល់បានច្រើន៖

  • model តូច (ប្រហែលមួយពាន់លាន ឬពីរបីពាន់លាន parameter) អាច រត់លើ laptop ធម្មតា ឬសូម្បីតែទូរស័ព្ទ។ វាលឿន ថោក និងឯកជន ព្រោះអត្ថបទរបស់អ្នកមិនចាកចេញពីម៉ាស៊ីនរបស់អ្នកទេ ប៉ុន្តែវាខ្សោយជាងក្នុងការវែកញែកពិបាកៗ ហើយមានចំណេះដឹងពិភពលោកតិចជាង។
  • model ធំ (រាប់សិប ឬរាប់រយពាន់លាន parameter) ត្រូវការ ផ្នែករឹង server ថ្លៃ។ ជាធម្មតាវាខ្លាំងជាងលើការងារពិបាក ប៉ុន្តែយឺតជាង និងថ្លៃជាងក្នុងមួយ request។
  • ធំជាងមិនតែងតែល្អជាងសម្រាប់ការងាររបស់អ្នកទេ។ សម្រាប់ការងារតូចចង្អៀតដូចជា តម្រៀបសារទៅជាប្រភេទ model តូចជាមួយ prompt ល្អអាចគ្រប់គ្រាន់ ដោយថ្លៃតែប្រភាគតូច។ សាកល្បងលើឧទាហរណ៍របស់អ្នកផ្ទាល់ (eval របស់អ្នកពី ជំពូកចុងក្រោយ) មុនពេលបង់ថ្លៃសម្រាប់ model ធំបំផុត។

7. Open Model ទល់នឹង Closed Model

មានវិធីទូលំទូលាយពីរដើម្បីទទួលបាន model៖

Closed (hosted)Open-weight
អ្វីដែលអ្នកទទួលបានការចូលប្រើតាម API ឬកម្មវិធីរបស់ក្រុមហ៊ុនឯកសារ parameter ខ្លួនឯង សម្រាប់ទាញយក
កន្លែងដែលវារត់server របស់ក្រុមហ៊ុនlaptop របស់អ្នក server របស់អ្នក ឬ cloud ដែលអ្នកជួល
អ្នកបង់ថ្លៃសម្រាប់token ដែលបានប្រើផ្នែករឹង អគ្គិសនី និងពេលវេលារបស់អ្នកផ្ទាល់
ឯកជនភាពអត្ថបទរបស់អ្នកទៅអ្នកផ្តល់សេវា (អានលក្ខខណ្ឌរបស់ពួកគេ)អត្ថបទអាចស្ថិតនៅលើម៉ាស៊ីនរបស់អ្នក
គុណភាពជារឿយៗជា model ខ្លាំងបំផុតចាប់ពីតូច និងលឿន ដល់សមត្ថភាពខ្ពស់
ការគ្រប់គ្រងអ្នកផ្តល់សេវាអាចផ្លាស់ប្តូរ ឬបញ្ឈប់ modelអ្នកអាចរក្សាច្បាប់ចម្លងថេរ និង fine-tune វា

ចំណុចស្មោះត្រង់ពីរ។ ទីមួយ "open" ត្រូវបានប្រើដោយមិនតឹងរ៉ឹង៖ model ខ្លះចែករំលែក តែ weight របស់វា (លេខ) ខ្លះក៏ចែករំលែកកូដ train ដែរ ហើយមានតិចតួចណាស់ដែលចែករំលែកទិន្នន័យ train របស់ពួកគេ។ អាជ្ញាប័ណ្ណក៏ខុសគ្នាដែរ ដូច្នេះ សូមអាន អាជ្ញាប័ណ្ណ មុនពេលសាងសង់ផលិតផលលើ model មួយ។ ទីពីរ គម្លាតគុណភាព រវាង open និង closed model ផ្លាស់ប្តូរលឿន ហើយការអះអាងណាមួយអំពី "មួយណាល្អបំផុត" នឹងហួសសម័យឆាប់ៗ ដូច្នេះប្រៀបធៀបវាលើការងាររបស់អ្នកផ្ទាល់ជំនួសវិញ។

8. អ្វីដែល LLM ពូកែ និងអ្វីដែលមិនពូកែ

អ្វីៗខាងលើប្រាប់អ្នកអំពីអ្វីដែលត្រូវរំពឹង។ model ដែលទាយអត្ថបទ ពីគំរូពូកែលើការងារដែលគំរូ និងភាសាស្ទាត់ជាការងារ៖

ជាធម្មតាល្អ

  • ការព្រាង ការសរសេរឡើងវិញ ការបង្ខ្លី ការបកប្រែរវាងភាសាទូទៅ និងការជួសជុលវេយ្យាករណ៍។
  • ការសង្ខេប និងការពន្យល់អត្ថបទដែលអ្នកផ្តល់ឲ្យវា។
  • ការគិតគំនិត ឈ្មោះ និងឧទាហរណ៍។
  • ការបំប្លែងអត្ថបទរញ៉េរញ៉ៃទៅជាទិន្នន័យមានរចនាសម្ព័ន្ធ (ជាមួយ validation)។
  • ការសរសេរ និងពន្យល់កូដទូទៅ test និង regular expression។
  • ការឆ្លើយសំណួរអំពីប្រធានបទដែលមានឯកសារល្អ។
  • ការធ្វើជាគ្រូដែលមានការអត់ធ្មត់ ដែលអ្នកអាចសួរសំណួរដដែលដប់ដង។

ជារឿយៗមិនអាចទុកចិត្តបាន

  • ការពិតច្បាស់លាស់ លេខ កាលបរិច្ឆេទ និងសម្រង់ ជាពិសេសរឿងមិនធម្មតា។
  • នព្វន្ធ និងការរាប់វែង ឬច្បាស់លាស់។ (ប្រើកូដ។)
  • អ្វីៗក្រោយកាលបរិច្ឆេទកាត់ផ្តាច់ការ train លើកលែងតែអ្នកផ្តល់ឲ្យ។
  • ប្រធានបទតូច ក្នុងស្រុក ឬកម្រ ដែលមានសរសេរអំពីវាតិចតួច។
  • ភាសាដែលមិនសូវទូទៅ៖ គុណភាពច្រើនតែទាបជាងសម្រាប់ភាសាដែលមានអត្ថបទ train តិច ដូច្នេះសូមសាកល្បង output ខ្មែរជាមួយអ្នកនិយាយដើម មុនពេលអ្នកពឹងលើវា។
  • ផែនការច្រើនជំហានវែងដែលកំហុសមួយនៅដើមបំផ្លាញអ្វីៗទាំងអស់ក្រោយនោះ។
  • ការដឹងថាអ្វីដែលវាមិនដឹង (ជំពូកទី 9)។

មិនមែនជាគំនិតល្អទាល់តែសោះ

  • ការធ្វើការសម្រេចចិត្តចុងក្រោយអំពីមនុស្ស (ការជួលបុគ្គលិក ពិន្ទុ វេជ្ជសាស្ត្រ ច្បាប់) ដោយគ្មានមនុស្សទទួលខុសត្រូវ។
  • ការគ្រប់គ្រងអាថ៌កំបាំងដូចជាពាក្យសម្ងាត់ ឬ key។
  • ការធ្វើជាអ្នកពិនិត្យតែមួយគត់លើការងាររបស់ខ្លួនឯង។

ច្បាប់ប្រមាណដ៏មានប្រយោជន៍៖ LLM គឺជា អ្នកព្រាងដំបូងដ៏ល្អឥតខ្ចោះ និងជាអាជ្ញាធរចុងក្រោយដ៏ខ្សោយ។ ប្រើវាដើម្បីចាប់ផ្តើមឲ្យលឿន បន្ទាប់មកផ្ទៀងផ្ទាត់។

9. Bias សុវត្ថិភាព និងឯកជនភាព

Bias។ model រៀនពីអក្សរសាស្ត្ររបស់មនុស្ស ហើយអក្សរសាស្ត្ររបស់មនុស្សមាន stereotype និងចន្លោះ។ ប្រសិនបើក្រុម ភាសា ឬទីកន្លែងខ្លះត្រូវបានតំណាងមិនគ្រប់គ្រាន់ model ជាធម្មតាអន់ជាងសម្រាប់ពួកគេ។ ប្រសិនបើអត្ថបទមានការរើសអើង model អាចនិយាយតាម។ អ្នកបង្កើតព្យាយាមកាត់បន្ថយវាដោយការជ្រើសរើសទិន្នន័យដោយប្រុងប្រយ័ត្ន និងការ tuning (ជំពូកទី 5) ប៉ុន្តែវាមិនទាន់ត្រូវបានដោះស្រាយទេ។ ក្នុងនាមជាអ្នកអភិវឌ្ឍន៍៖ សាកល្បងកម្មវិធីរបស់អ្នកជាមួយឈ្មោះ ភាសា និងស្ថានភាពច្រើនបែបយ៉ាង ហើយកុំឲ្យវាក្លាយជាអ្នកវិនិច្ឆ័យតែមួយគត់លើមនុស្សឡើយ។

សុវត្ថិភាព។ model ដែលជួយបានអាចត្រូវបានស្នើឲ្យជួយអ្វីដែលគ្រោះថ្នាក់ ឬត្រូវបានបោកឲ្យមិនអើពើនឹងសេចក្តីណែនាំរបស់វា។ អ្នកផ្តល់សេវាបន្ថែមការការពារ ប៉ុន្តែវាមិនល្អឥតខ្ចោះទេ។ Prompt injection (ជំពូកទី 8) គឺជាកំណែជាក់ស្តែង៖ អត្ថបទពីគេហទំព័រ ឬអ្នកប្រើអាចមានសេចក្តីណែនាំដែល model អាចធ្វើតាម។ ការការពារជាច្រើនជាន់មានន័យថា៖ រក្សាសេចក្តីណែនាំដាច់ដោយឡែក ពីទិន្នន័យដែលមិនទុកចិត្ត ផ្តល់ទៅ model នូវការអនុញ្ញាតតិចបំផុតដែលអាចធ្វើបាន រត់ កូដដែលវាសរសេរក្នុង sandbox (Docker Sandbox Crash Course) ហើយសួរមនុស្សមុនធ្វើអ្វីដែលមិនអាចត្រឡប់វិញបាន។

ឯកជនភាព។ អ្វីៗដែលអ្នកវាយចូលក្នុង model ដែលបង្ហោះ ត្រូវបានផ្ញើទៅកុំព្យូទ័ររបស់អ្នកផ្សេង។ ច្បាប់ដែលត្រូវធ្វើតាម៖

  • កុំបិទភ្ជាប់ពាក្យសម្ងាត់ API key token ឬ private key។ នៅពេលផ្ញើហើយ អ្នកមិនអាចយកវាមកវិញបានទេ។
  • កុំបិទភ្ជាប់ព័ត៌មានឯកជនរបស់អ្នកដទៃ (អត្តសញ្ញាណប័ណ្ណ លេខទូរស័ព្ទ កំណត់ត្រាវេជ្ជសាស្ត្រ ឬសាលា) លើកលែងតែអ្នកប្រាកដថាអ្នកត្រូវបានអនុញ្ញាត។
  • អានគោលនយោបាយទិន្នន័យរបស់អ្នកផ្តល់សេវា៖ តើវារក្សាអត្ថបទរបស់អ្នកទេ ហើយតើវាប្រើវាដើម្បី train model ក្នុងអនាគតទេ? ជម្រើស និងចម្លើយខុសគ្នាតាមអ្នកផ្តល់សេវា និងផែនការ។
  • សម្រាប់ទិន្នន័យរសើប សូមពិចារណា open-weight model ក្នុងម៉ាស៊ីនខ្លួនឯង ឬលុបព័ត៌មានលម្អិតរសើបចេញមុនផ្ញើ។

ទិន្នន័យ training និងកម្មសិទ្ធិ។ model ត្រូវបាន train លើអត្ថបទចំនួនដ៏ច្រើនសន្ធឹកសន្ធាប់ ហើយសំណួរថាអ្នកណាជាម្ចាស់ ឬអាចប្រើអត្ថបទនោះកំពុងត្រូវបានជជែកដេញដោល ប្រកែកក្នុងតុលាការ និងត្រូវបានចាត់ចែងខុសគ្នាក្នុងប្រទេសផ្សេងៗ។ គ្មាននរណាអាចផ្តល់ចម្លើយចុងក្រោយតែមួយឲ្យអ្នកបានទេ។ ប្រសិនបើអ្នកផ្សព្វផ្សាយអ្វីមួយដែល AI សរសេរ អ្នកនៅតែទទួលខុសត្រូវចំពោះភាពត្រឹមត្រូវរបស់វា និង ការមិនចម្លងអ្នកដទៃ។

10. ថាមពល និងបរិស្ថាន

ការ train model ធំត្រូវការពេលវេលាកុំព្យូទ័រច្រើនលើ chip ឯកទេស ហើយរាល់ចម្លើយក្រោយមកក៏ប្រើអគ្គិសនីខ្លះដែរ។ នោះជារឿងពិត ហើយជារឿងសមហេតុផលដែលគួរព្រួយបារម្ភ។ ប៉ុន្តែតួលេខពិតប្រាកដប្រែប្រួលយ៉ាងទូលំទូលាយតាម model ផ្នែករឹង មជ្ឈមណ្ឌលទិន្នន័យ និងរបៀបផលិតអគ្គិសនី ហើយលេខដែលដកស្រង់តាមអ៊ីនធឺណិតច្រើនតែចាស់ គ្រាន់តែប្រមាណ ឬខ្វះបរិបទ ដូច្នេះជំពូកនេះមិនដកស្រង់លេខណាមួយទេ។

អ្វីដែលអ្នកអាចនិយាយបានដោយស្មោះត្រង់៖

  • ការ train ថ្លៃ; ចម្លើយមួយថោកជាងគ្នា ប៉ុន្តែចំនួនចម្លើយគឺដ៏ច្រើនសន្ធឹកសន្ធាប់ នៅពេលមនុស្សរាប់លាននាក់ប្រើ model រាល់ថ្ងៃ ដូច្នេះចំនួនសរុបសំខាន់។
  • អ្នកមានឥទ្ធិពលលើថ្លៃដើម។ model តូចជាង prompt ខ្លីជាង caching និងការមិនសួរនៅពេលការស្វែងរក ឬម៉ាស៊ីនគិតលេខអាចធ្វើការងារបាន ប្រើថាមពលតិចជាង ហើយក៏សន្សំលុយដែរ។

11. តើវាគិតទេ? តើវាយល់ទេ?

នេះជាសំណួរដែលចាប់ផ្តើមជម្លោះធំបំផុត ដូច្នេះសូមឆ្លើយដោយប្រុងប្រយ័ត្ន។

អ្វីដែលយើងដឹងច្បាស់៖ language model គឺជា function ដែលបំប្លែង អត្ថបទទៅជាប្រូបាបសម្រាប់ token បន្ទាប់។ អ្នកបានសាងសង់មួយតូច។ វា គ្មានរាងកាយ អារម្មណ៍ ឬជីវិតទេ។ នៅក្នុង model ដែលបាន train មិនមានអ្វីក្រៅពីលេខដែលកំពុងត្រូវបានគុណគ្នាទេ។

អ្វីដែលមិនទាន់ដោះស្រាយ៖ តើដំណើរការនោះ នៅមាត្រដ្ឋានដ៏ធំ មានន័យថា ការយល់ដឹងប្រភេទណាមួយឬអត់។ អ្នកស្រាវជ្រាវ និងទស្សនវិទូមិនយល់ស្របគ្នា។

  • ទស្សនៈមួយ៖ វាគឺ គ្រាន់តែការផ្គូផ្គងគំរូ។ វាចម្លងរូបរាងនៃការវែកញែក ដោយគ្មានការយល់អត្ថន័យ ដូចសត្វសេកដែលមានការចងចាំធំណាស់។
  • ទស្សនៈមួយទៀត៖ ដើម្បីទាយអត្ថបទអំពីរូបវិទ្យា កូដ ឬមនុស្សឲ្យបានល្អ model ត្រូវតែបង្កើត ការតំណាងខាងក្នុង ដែលចាប់យកថារបស់ទាំងនោះដំណើរការយ៉ាងណា ហើយនោះគឺជាការយល់ដឹងពិតប្រាកដ ទោះមានដែនកំណត់ក៏ដោយ។
  • មានភស្តុតាងសម្រាប់ទស្សនៈទាំងពីរ។ model ដោះស្រាយបញ្ហាដែលត្រូវការ ច្រើនជំហាន ហើយវាក៏បរាជ័យលើការប្រែប្រួលសាមញ្ញៗដែលក្មេងអាចដោះស្រាយបាន ដែលបង្ហាញថាសមត្ថភាពរបស់វាមិនស្មើគ្នា និងខុសពីរបស់យើង។

រឿងដែលមានតុល្យភាពប្រាប់ទស្សនិកជន៖ "វាធ្វើអ្វីមួយដែលមានប្រយោជន៍ដែលមើលទៅដូចការយល់ដឹង ក្នុងការងារជាច្រើន ហើយខូចតាមរបៀបដែលការយល់ដឹងរបស់មនុស្សជាធម្មតានឹងមិនខូច។ ថាតើគួរហៅនោះថាការគិតឬអត់ អាស្រ័យលើរបៀបដែលអ្នកកំណត់និយមន័យពាក្យនោះ ហើយអ្នកវិទ្យាសាស្ត្រមិនទាន់យល់ស្របគ្នាទេ។" សម្រាប់ការសាងសង់កម្មវិធី ចម្លើយជាក់ស្តែងសំខាន់បំផុត៖ កុំសន្មត់ថាវាយល់។ សាកល្បងវាលើករណីរបស់អ្នក។

12. ចុះការងារវិញ?

គ្មាននរណាអាចទាយអនាគតនៃការងារបានយ៉ាងពិតប្រាកដទេ ហើយអ្នកណាដែលស្តាប់ទៅប្រាកដប្រជាគឺកំពុងទាយ។ រូបភាពដែលមានតុល្យភាព៖

  • ភារកិច្ចផ្លាស់ប្តូរមុនពេលការងារទាំងមូលបាត់។ ការងារភាគច្រើនគឺជាបណ្តុំនៃភារកិច្ច។ LLM ពូកែលើភារកិច្ចខ្លះ (ការព្រាង ការសង្ខេប កូដដំបូង) និងខ្សោយលើភារកិច្ចផ្សេងទៀត (ការទទួលខុសត្រូវ ទំនុកចិត្ត ការងារដោយដៃ ការដឹងពីស្ថានភាពក្នុងស្រុក)។ ការងារដែលរួមមានភារកិច្ចដែលអាចធ្វើស្វ័យប្រវត្តិបានច្រើន នឹងផ្លាស់ប្តូរច្រើនបំផុត។
  • ការងារខ្លះក្លាយជាថោកជាង និងលឿនជាង ដែលអាចមានន័យថាមនុស្សតិចជាងធ្វើវា វាត្រូវបានធ្វើច្រើនជាង ឬទាំងពីរ។ ប្រវត្តិសាស្ត្រផ្តល់ឧទាហរណ៍នៃនីមួយៗ ដូច្នេះលទ្ធផលមិនត្រូវបានកំណត់ទុកជាមុនទេ។
  • ការងារថ្មីលេចឡើង៖ ការសាងសង់ ការសាកល្បង ការពិនិត្យ និងការគ្រប់គ្រងប្រព័ន្ធ AI និងការធ្វើផ្នែកដែលវាមិនអាចធ្វើបាន។
  • មនុស្សដែលប្រើឧបករណ៍ទាំងនេះបានល្អមានអត្ថប្រយោជន៍ លើមនុស្សដែល មិនប្រើ ក្នុងវិស័យភាគច្រើន រួមទាំងការសរសេរកម្មវិធីផង។
  • មូលដ្ឋានគ្រឹះនៅតែសំខាន់។ ដើម្បីផ្ទៀងផ្ទាត់អ្វីដែល model សរសេរ អ្នកត្រូវ យល់ពីមុខវិជ្ជា។ អ្នកសរសេរកម្មវិធីដែលអាចអាន និងសាកល្បងកូដមាន ប្រយោជន៍ជាងអ្នកដែលអាចបិទភ្ជាប់វាបានតែប៉ុណ្ណោះ។

13. សាកល្បងដោយខ្លួនឯង

  1. ស្វែងយល់ CLI។ រត់ node src/index.js ជាមួយ prompt ផ្សេងគ្នាប្រាំ រួមទាំងមួយជាភាសាខ្មែរ។ មើល characters, words និង tokens (est)។ ហេតុអ្វីចំនួនពាក្យតិចណាស់សម្រាប់ prompt ខ្មែរ (គន្លឹះ៖ ដកឃ្លានៅឯណា?) ហើយហេតុអ្វីចំនួន token ពិតប្រាកដនៃអត្ថបទខ្មែរអាចមិនត្រូវនឹង ច្បាប់ប្រមាណតួអក្សរចែកនឹង 4?
  2. តម្លៃពិត។ រកមើលទំព័រតម្លៃរបស់អ្នកផ្តល់ model ណាមួយ (លេខផ្លាស់ប្តូរ ដូច្នេះអានវាថ្ងៃនេះ)។ ដាក់តម្លៃ input និង output ពិត និងទំហំ window ពិតទៅក្នុង usageReport ដោយប្រើជម្រើសរបស់វា ហើយគណនាថ្លៃដើមនៃអត្ថបទ 1,000 ពាក្យរបស់អ្នកផ្ទាល់។
  3. បន្ថែមថ្លៃ output។ ពង្រីក usageReport ឲ្យទទួល outputTokens និង outputPricePerMillion ហើយត្រឡប់ totalCost។ ធ្វើបច្ចុប្បន្នភាព formatReport ឲ្យបោះពុម្ពវា។
  4. ធ្វើថវិកា bot។ ដោយប្រើរង្វិលជុំក្នុងផ្នែកទី 4 ប្តូរ turns, userTokens និង replyTokens។ តើចំនួន turn ប៉ុន្មានដែលសរុប input លើសពី 100,000 token? បន្ទាប់មកបន្ថែមដែនកំណត់ maxHistoryTokens (ប្រើ trimHistory ពីជំពូកទី 7 ជាគំរូ) ហើយមើលថាវាសន្សំបានប៉ុណ្ណា។
  5. ការព្រមាន window។ ធ្វើឲ្យ CLI បោះពុម្ព WARNING: prompt uses over 80% of the context window នៅពេល windowUsed លើសពី 0.8។ សាកល្បងជាមួយ prompt វែងខ្លាំង (ប្រើ "word ".repeat(7000))។

14. សំណួរដែលអ្នកនឹងត្រូវគេសួរ

ទាំងនេះគឺជាសំណួរដែលអ្នកទំនងជាឮបំផុតបន្ទាប់ពីការនិយាយទៅកាន់ សិស្ស និងអ្នកអភិវឌ្ឍន៍។ ចម្លើយនីមួយៗខ្លីល្មមនឹងនិយាយចេញជាសំឡេងបាន។

1. LLM ជាអ្វី ក្នុងប្រយោគតែមួយ? វាជាកម្មវិធីដែលបានរៀនគំរូពីអត្ថបទចំនួនដ៏ច្រើន ដើម្បីឲ្យនៅពេលមានអត្ថបទមួយ វាអាចទាយថាបំណែកអ្វីមកបន្ទាប់ ហើយដោយធ្វើដូច្នោះម្តងហើយម្តងទៀត វាសរសេរចម្លើយទាំងមូល។

2. តើវាឆ្លាតពិតប្រាកដទេ? វាធ្វើរឿងដែលមើលទៅឆ្លាតក្នុងការងារជាច្រើន ដូចជាការសរសេរ ការពន្យល់ និងការសរសេរកូដ។ វាក៏បរាជ័យតាមរបៀបចម្លែកៗដែរ ដូចជា ការបង្កើតការពិតដោយទំនុកចិត្ត។ អ្នកវិទ្យាសាស្ត្រមិនយល់ស្របគ្នាថាតើនោះរាប់ជាការយល់ដឹងឬអត់ ដូច្នេះចម្លើយស្មោះត្រង់គឺ "មានប្រយោជន៍ គួរឲ្យចាប់អារម្មណ៍ និងមិនដូចចិត្តរបស់មនុស្សទេ"។

3. តើកម្មវិធី chatbot ដូចគ្នានឹង LLM ឬ? មិនពិតប្រាកដទេ។ LLM គឺជាម៉ាស៊ីន ហើយ chatbot គឺជាផលិតផលពេញលេញ ជុំវិញវា៖ ចំណុចប្រទាក់ជជែក សេចក្តីណែនាំ system តម្រងសុវត្ថិភាព មុខងារចងចាំ និងពេលខ្លះ tool ដូចជាការស្វែងរកតាមអ៊ីនធឺណិត។ ផលិតផលផ្សេងគ្នា អាចប្រើម៉ាស៊ីនប្រភេទដូចគ្នា។

4. តើវាគិត ឬយល់ទេ? គ្មាននរណាដោះស្រាយរឿងនេះបានទេ។ វាពិតជាអ្នកទាយអត្ថបទដែលធ្វើពីលេខ ប៉ុន្តែការទាយអត្ថបទឲ្យបានល្អអាចតម្រូវឲ្យបង្កើតគំរូខាងក្នុងដ៏មានប្រយោជន៍នៃពិភពលោក។ សូមនិយាយថា "យើងមិនទាន់ដឹងទេ" ហើយប្រាប់មនុស្សឲ្យសាកល្បងវា ជំនួសឲ្យការសន្មត់។

5. ហេតុអ្វីវាបង្កើតរឿងឡើង? ព្រោះវាត្រូវបាន train ឲ្យបង្កើតអត្ថបទដែលទំនងជាពិត មិនមែនអត្ថបទពិត ហើយវា គ្មានវិធីភ្ជាប់មកស្រាប់ដើម្បីនិយាយថា "ខ្ញុំគ្មានភស្តុតាង"។ នៅពេលវាដឹងតិច វា បំពេញចន្លោះដោយអ្វីមួយដែលស្តាប់ទៅត្រូវ។ ការផ្តល់ប្រភពឲ្យវា និង ការពិនិត្យចម្លើយរបស់វាកាត់បន្ថយបញ្ហា។

6. ហេតុអ្វីខ្ញុំទទួលបានចម្លើយខុសគ្នារាល់ពេល? ព្រោះវាជ្រើស token បន្ទាប់ដោយ sampling ពីប្រូបាប ហើយ temperature គ្រប់គ្រងថាការជ្រើសនោះហ៊ានប៉ុនណា។ ជាមួយ temperature ទាប ចម្លើយជាធម្មតាស្រដៀងគ្នាខ្លាំង ទោះបីជានៅលើ model ដែលបង្ហោះវា មិនត្រូវបានធានាថាដូចគ្នាបេះបិទក៏ដោយ។

7. តើវាចងចាំខ្ញុំទេ? មិនមែនដោយខ្លួនឯងទេ។ model គឺគ្មានស្ថានភាព (stateless)៖ ការ request នីមួយៗដាច់ដោយឡែក ហើយ កម្មវិធីបង្កើតការចងចាំដោយផ្ញើសារមុនៗម្តងទៀត ឬដោយរក្សាទុកកំណត់ចំណាំ ហើយបន្ថែមវាទៅ prompt។ អ្វីៗដែលនៅក្រៅ context window គឺគ្រាន់តែមិនត្រូវបានមើលឃើញ។

8. ហេតុអ្វីវាគិតលុយក្នុងមួយពាក្យ? ព្រោះរាល់ token ចំណាយពេលវេលាកុំព្យូទ័រលើផ្នែករឹងថ្លៃ ហើយ ថ្លៃដើមកើនឡើងតាមបរិមាណអត្ថបទចូល និងចេញ។ អ្នកផ្តល់សេវាគិតថ្លៃតាម token (ហើយ token គឺជាបំណែកនៃពាក្យ) ជាធម្មតាជាមួយតម្លៃខុសគ្នាសម្រាប់ input និង output។

9. ហេតុអ្វីវាអន់ជាងក្នុងភាសាខ្មែរបើធៀបនឹងភាសាអង់គ្លេស? ភាគច្រើនដោយសារមានអត្ថបទខ្មែរតិចជាងច្រើនក្នុងទិន្នន័យ train ហើយ tokenizer ជាច្រើនបំបែកភាសាខ្មែរទៅជាបំណែកច្រើនជាង ដែលអាចមានន័យថាថ្លៃដើមច្រើនជាង និងកន្លែងតិចជាងក្នុង context window។ គុណភាពកំពុងប្រសើរឡើង ប៉ុន្តែសាកល្បងជាមួយ អ្នកនិយាយដើម ហើយកុំសន្មត់ថាលទ្ធផលស្មើភាសាអង់គ្លេស។

10. តើវាអាចរៀនពីការសន្ទនារបស់ខ្ញុំបានទេ? ក្នុងការសន្ទនាតែមួយ វាអាចប្រើអ្វីដែលអ្នកបាននិយាយ ព្រោះវាស្ថិតក្នុង context។ វាមិនផ្លាស់ប្តូរ parameter របស់ខ្លួនទេនៅពេលអ្នកជជែក។ ថាតើ អ្នកផ្តល់សេវាប្រើការសន្ទនាដើម្បី train model ក្នុងអនាគតឬអត់ អាស្រ័យលើគោលនយោបាយរបស់ពួកគេ និងការកំណត់របស់អ្នក ដូច្នេះសូមអានវាមុនពេលចែករំលែកអ្វីរសើប។

11. តើទិន្នន័យរបស់ខ្ញុំមានសុវត្ថិភាពទេ ប្រសិនបើខ្ញុំវាយវាចូល AI? វាត្រូវបានផ្ញើទៅ server របស់អ្នកផ្តល់សេវា ដូច្នេះចាត់ទុកវាដូចការផ្ញើអ៊ីមែល ទៅក្រុមហ៊ុនមួយ៖ ល្អសម្រាប់អត្ថបទធម្មតា មិនល្អសម្រាប់ពាក្យសម្ងាត់ key ឬទិន្នន័យឯកជនរបស់អ្នកដទៃទេ។ ពិនិត្យគោលនយោបាយរបស់អ្នកផ្តល់សេវាអំពីការរក្សាទុក និង training ឬប្រើ model ដែលអ្នករត់ខ្លួនឯងសម្រាប់ការងាររសើប។

12. តើ AI នឹងយកការងាររបស់ខ្ញុំទេ? គ្មាននរណាអាចសន្យាបានទាំងពីរផ្លូវទេ។ វានឹងផ្លាស់ប្តូរការងារជាច្រើនដោយធ្វើស្វ័យប្រវត្តិ ភារកិច្ចខ្លះរបស់វា ហើយមនុស្សដែលប្រើវាបានល្អនឹងមានអត្ថប្រយោជន៍។ មូលដ្ឋានគ្រឹះដ៏ជ្រាលជ្រៅ ការវិនិច្ឆ័យល្អ និងសមត្ថភាពក្នុងការពិនិត្យ output របស់ AI គឺជាអ្វីដែលមានសុវត្ថិភាពបំផុតក្នុងការវិនិយោគ។

13. តើខ្ញុំគួរតែរៀនសរសេរកូដទៀតទេ? គួរ។ AI អាចសរសេរកូដ ប៉ុន្តែត្រូវមាននរណាម្នាក់យល់បញ្ហា អានកូដ សាកល្បងវា និងជួសជុលវានៅពេលវាខុស។ មនុស្សដែលរៀនសរសេរកូដ ហើយប្រើ AI បានល្អមានទំនោរធ្វើបានច្រើនជាងម្ខាងៗតែឯង។

14. តើ open-source model ល្អដូចអ្វីដែលបង់ថ្លៃទេ? open-weight model ខ្លះល្អណាស់ ខ្លះទៀតតូច និងសាមញ្ញ ហើយ គម្លាតផ្លាស់ប្តូរលឿន ដូច្នេះប្រៀបធៀបវាលើការងាររបស់អ្នកផ្ទាល់។ អត្ថប្រយោជន៍ធំរបស់ពួកវា គឺឯកជនភាព ការគ្រប់គ្រងថ្លៃដើម និងសេរីភាពក្នុងការរត់ និងកែតម្រូវ វាដោយខ្លួនឯង។

15. តើវាកំពុងលួចពីអ្នកនិពន្ធ និងសិល្បករទេ? នេះកំពុងត្រូវបានជជែកដេញដោលយ៉ាងសកម្ម ជាសាធារណៈ និងក្នុងតុលាការ ហើយចម្លើយប្រែប្រួល តាមប្រទេស និងករណី។ model ត្រូវបាន train លើអត្ថបទ និងរូបភាពចំនួនដ៏ច្រើន ខ្លះត្រូវបានបង្កើតដោយមនុស្សដែលមិនត្រូវបានសួរ។ ត្រូវស្មោះត្រង់ថា វាមិនទាន់ត្រូវបានដោះស្រាយ គោរពអាជ្ញាប័ណ្ណ និងផ្តល់ក្រេឌីតប្រភពនៅពេលអ្នកផ្សព្វផ្សាយ។

16. តើវាប្រើអគ្គិសនីប៉ុនណា? ការ train model ធំប្រើថាមពលច្រើន ហើយការបម្រើអ្នកប្រើរាប់លាននាក់ក៏ដូចគ្នា ប៉ុន្តែបរិមាណពិតប្រាកដអាស្រ័យលើ model ផ្នែករឹង និងប្រភពថាមពល ហើយតួលេខដែលបានផ្សព្វផ្សាយជាច្រើនគឺគ្រាន់តែប្រមាណ ឬហួសសម័យ។ អ្នកអាចកាត់បន្ថយចំណែករបស់អ្នកដោយ model តូចជាង prompt ខ្លីជាង និង caching។

17. តើ AI អាចមាន bias ទេ? បាន ព្រោះវារៀនពីអត្ថបទមនុស្សដែលមាន bias និងចន្លោះ។ វា អាចដំណើរការអន់ជាងសម្រាប់ភាសា ឬក្រុមដែលលេចឡើងតិចក្នុងទិន្នន័យ។ សាកល្បងកម្មវិធីរបស់អ្នកលើឧទាហរណ៍ច្រើនបែបយ៉ាង ហើយរក្សាមនុស្សឲ្យទទួលខុសត្រូវ ចំពោះការសម្រេចចិត្តអំពីមនុស្ស។

18. តើខ្ញុំចាប់ផ្តើមសាងសង់ជាមួយវាយ៉ាងដូចម្តេច? ចាប់ផ្តើមតូច៖ យកបញ្ហាពិតមួយ ដូចជាការសង្ខេបសារ ឬ ការឆ្លើយសំណួរពីឯកសារ។ សរសេរ prompt សាកល្បងវាលើឧទាហរណ៍ពិតម្ភៃ ហើយបន្ថែមការពិនិត្យ (JSON validation ប្រភព និង eval)។ ស៊េរីបន្ទាប់បង្ហាញពីរបៀបហៅ model ពិតប្រាកដពីកូដរបស់អ្នកផ្ទាល់។

ទៅបន្តទៀត។ ឥឡូវនេះអ្នកយល់ពីអ្វីដែលកំពុងកើតឡើងនៅក្នុង ឧបករណ៍ដែលអ្នករាល់គ្នាកំពុងនិយាយអំពី៖ អត្ថបទក្លាយជា token, token ក្លាយជា លេខ, បណ្តាញដែលបាន train បំប្លែងវាទៅជាប្រូបាប, token មួយត្រូវបានជ្រើស ហើយរង្វិលជុំធ្វើម្តងទៀត។ អ្នកក៏ដឹងពីដែនកំណត់ដ៏ស្មោះត្រង់ដែរ៖ វាបង្កើតរឿងឡើង វាភ្លេច វាចំណាយលុយ ហើយវាត្រូវការការពិនិត្យ។ នោះជា មូលដ្ឋានរឹងមាំសម្រាប់ការនិយាយ ការពិភាក្សាក្នុងថ្នាក់ ឬគម្រោងផ្ទាល់ខ្លួនរបស់អ្នក។

ស៊េរីបន្ទាប់ Build a Chatbot with an LLM API (មានគម្រោង) ផ្លាស់ពី toy ទៅរបស់ពិតប្រាកដ៖ ការហៅ model ដែលបង្ហោះពីកូដរបស់អ្នកផ្ទាល់ ការ stream ចម្លើយ ការគ្រប់គ្រងប្រវត្តិសន្ទនា និងការបន្ថែម tool។ នៅពេលណាដែលប្រព័ន្ធ AI ដែលអ្នកសាងសង់អាចរត់កូដ ឬប៉ះឯកសារ សូមអាន Docker Sandbox Crash Course ជាមុន ដើម្បីឲ្យសកម្មភាពរបស់ model កើតឡើងនៅកន្លែងមានសុវត្ថិភាព។

មុនហេតុអ្វីបានជា Model Hallucinate

ទិញកាហ្វេជូនខ្ញុំ

ចូលចិត្តមេរៀននេះមែនទេ? សូមពិចារណាទិញកាហ្វេជូនខ្ញុំមួយកែវ ដើម្បីគាំទ្រការបង្កើតមាតិកាឥតគិតថ្លៃបន្ថែមទៀត!