การเรียนรู้ทำงานอย่างไร

ตัวเลขบนหน้ากระดาษยังไม่ใช่คำทำนาย ก่อนอื่นเราต้องมีกฎ ใส่ลูกแก้ว 2 ลูกในชามแล้วเติมอีก 1 ลูก กฎรับ 2 และให้ผลเป็น 3 นักคณิตศาสตร์เรียกกฎเช่นนี้ว่าฟังก์ชัน

ฟังก์ชันส่งจำนวนข้อมูลเข้าไปเป็นผลลัพธ์ เริ่มด้วย 2 แล้วบวก 1

function addOne(value) {
  return { output: value + 1 };
}
const result = addOne(2);

ใน f(x) ตัวอักษร x แทนจำนวนที่จะใส่เข้าไป ส่วน f เป็นชื่อของกฎ วงเล็บหมายถึง “ใช้ค่านี้เป็นข้อมูลเข้า” เราใส่ 4 แทน 2 ได้และได้ f(4) = 5

บทความจัดตัวเลขเป็นเซต ℕ มีจำนวนสำหรับนับ ส่วน ℤ รวมศูนย์และจำนวนลบ เช่น หนี้ −2 ด้วย และ ℝ รวมจำนวนอย่าง 1.5 ด้วย สัญลักษณ์ [5] หมายถึง {1, 2, 3, 4, 5} ไม่ใช่แค่ 5 เวกเตอร์คือรายการตัวเลข เช่น (2, 3)

สมมติผลลัพธ์สี่แบบมีโอกาสเท่ากัน: 0, 0, 0 และ 1 บวกแล้วหารด้วย 4: (0 + 0 + 0 + 1)/4 = 0.25 นี่คือค่าเฉลี่ยคาดหมาย เขียนด้วย E โดยใช้โอกาสของผลลัพธ์ทุกแบบ ค่าเฉลี่ยจากการสุ่มจริงอาจต่างออกไป ส่วน Σ หมายถึงให้บวกตัวเลข

ส่วนที่เหลือของบทความใช้ความยาว ระยะทาง และความน่าจะเป็นเพื่อเปรียบเทียบฟังก์ชัน เราจะพบสัญลักษณ์เหล่านั้นเมื่อจำเป็น ตอนนี้ลองเปลี่ยนจำนวนลูกแก้วในภาพ กฎยังคงเป็น “บวกหนึ่ง”

สมมติว่าเราต้องการทำนายอุณหภูมิพรุ่งนี้ ตัวอย่างหนึ่งมีข้อมูลเข้า เช่น อุณหภูมิวันนี้ และคำตอบที่ถูกต้อง เช่น อุณหภูมิพรุ่งนี้ เขียนคู่นี้เป็น z = (x, y): x คือข้อมูลเข้า ส่วน y คือป้ายกำกับที่เราหวังจะทำนาย

สำหรับอุณหภูมิสมมติในหน่วยองศาเซลเซียส ข้อมูลเข้า 2 มีป้ายกำกับ 5 กฎทำนายได้ 4 ผลนี้ห่างจากป้ายกำกับเท่าไร

function predictionLoss(value, target) {
  const prediction = 2 * value;
  return { prediction, loss: (prediction - target) ** 2 };
}
const result = predictionLoss(2, 5);

ความสูญเสียกำลังสองคือ 1°C² หากผิด 2°C จะมีค่า 4°C² การทำนายตัวเลขเช่นนี้เรียกว่าการถดถอย

อีกงานหนึ่งคือการเลือกระหว่างสองประเภท ลองนึกถึงตัวกรองสแปม: +1 หมายถึงสแปม และ −1 หมายถึงจดหมายปกติ คะแนนดิบอาจเป็นจำนวนใดก็ได้ เราแปลงคะแนนเป็นประเภทแล้วเปรียบเทียบกับป้ายกำกับ แทนที่จะถือว่าคะแนนดิบศูนย์ถูกเสมอ

ใช้ +1 และ −1 แทนสองประเภท ป้ายกำกับคือ +1 และคะแนนเริ่มที่ −2

function classify(score, target) {
  if (target !== 1 && target !== -1) {
    throw new Error('เป้าหมายต้องเป็น +1 หรือ −1');
  }
  let predicted = -1;
  if (score >= 0) predicted = 1;
  let loss = 0;
  if (predicted !== target) loss = 1;
  return { predicted, loss };
}
const result = classify(-2, 1);

เมื่อคะแนนเป็น 0 กฎเครื่องหมายของบทความเลือก +1 แต่ Math.sign(0) ของ JavaScript คืนค่า 0 จึงไม่ใช่กฎเดียวกัน สำหรับข้อมูลตัวอย่างที่มีป้าย −1 คะแนนศูนย์จะเป็นการจำแนกผิด

เมื่อมีตัวอย่างพร้อมป้ายกำกับ ผู้เรียนสามารถปรับกฎได้ นี่คือการเรียนรู้แบบมีผู้สอน หากไม่มีป้ายที่มนุษย์ให้ ก็อาจค้นหาโครงสร้างแทน หรือสร้างคำถามโดยซ่อนส่วนหนึ่งของข้อมูลเข้าเอง เช่น ซ่อน “นอน” จาก “แมวนอน” แล้วใช้คำที่เห็นเป็นข้อมูลเข้าและคำที่ซ่อนเป็นเป้าหมาย นี่เป็นวิธีหนึ่งในการสร้างงานเรียนรู้จากข้อมูลที่ไม่มีป้ายกำกับ

เราอาจศึกษาว่าอุณหภูมิใดพบได้บ่อย เส้นโค้งความหนาแน่นช่วยแสดงว่าช่วงใด เช่น 19°C ถึง 21°C มีโอกาสเกิดมากกว่า พื้นที่ใต้เส้นโค้งในช่วงนั้นให้ความน่าจะเป็น หรือโอกาสที่ค่าที่วัดจะอยู่ในช่วงนั้น ความสูงของเส้นที่อุณหภูมิเดียวไม่ใช่ความน่าจะเป็นโดยตรง

แล้วกฎจะเรียนรู้การทำนายที่ซับซ้อนได้อย่างไร นิวรอนเริ่มจากตัวเลขข้อมูลเข้า คูณแต่ละตัวด้วยน้ำหนัก บวกผลคูณเข้าด้วยกัน แล้วบวกไบแอส น้ำหนักกำหนดว่าข้อมูลเข้าแต่ละตัวมีผลมากเพียงใด ส่วนไบแอสเลื่อนผลรวมได้แม้ข้อมูลเข้าทั้งหมดเป็นศูนย์

ใส่ตัวเลขนำเข้าในรายการ x ตาราง W เก็บน้ำหนัก และรายการ b เก็บค่าเอนเอียง สำหรับนิวรอนหนึ่งตัว ข้อมูลนำเข้า 2 และ 3 น้ำหนัก 2 และ −1 และค่าเอนเอียง 1 ให้ 2×2 − 1×3 + 1 = 2 จากนั้นชั้นใช้กฎที่เรียกว่าฟังก์ชันกระตุ้น เขียนแทนด้วย ρ

function layer(firstInput, secondInput, bias) {
  const sum = 2 * firstInput - secondInput + bias;
  return { sum, relu: Math.max(0, sum) };
}
const result = layer(2, 3, 1);

ReLU คงผลรวมที่เป็นบวก และเปลี่ยนผลรวมที่เป็นลบเป็นศูนย์ เช่น −2 กลายเป็น 0 ในสูตร Φ เป็นชื่อการคำนวณ θ เก็บค่าที่ปรับได้ และ (1) หมายถึงชั้นแรก ขีดบน Φ หมายถึงผลหลังกฎกระตุ้น กฎที่คูณตัวป้อนด้วยน้ำหนักแล้วบวกไบแอสเรียกว่าแอฟไฟน์ ถ้าไบแอสเป็นศูนย์ กฎนั้นเป็นเชิงเส้น

เครือข่ายในรูป 1.1 เชื่อมนิวรอนจำนวนมากเป็นขั้น: จำนวนข้อมูลเข้า 3 ตัว → นิวรอนซ่อน 4 ตัว → นิวรอนซ่อน 6 ตัว → ผลลัพธ์ 1 ตัว มีชั้นซ่อนสองชั้นและน้ำหนักกับไบแอสที่ฝึกได้สามชุด ขั้นสุดท้ายเป็นแอฟไฟน์ ตามนิยามของบทความไม่มี ReLU หลังผลลัพธ์

เครือข่ายมีตัวป้อน 3 ตัว ชั้นซ่อนมีเซลล์ประสาท 4 และ 6 ตัว แล้วมีผลออก 1 ตัว เซลล์แต่ละตัวเชื่อมกับทุกตัวเลขในขั้นก่อนหน้า ขั้นแรกมีน้ำหนัก 3×4 = 12 ตัวและไบแอส 4 ตัว ขั้นต่อมามีน้ำหนัก 4×6 = 24 ตัวและไบแอส 6 ตัว ขั้นสุดท้ายมีน้ำหนัก 6×1 = 6 ตัวและไบแอส 1 ตัว

function countParameters(
  inputs, firstLayer, secondLayer, outputs
) {
  const weights = inputs * firstLayer + firstLayer * secondLayer
    + secondLayer * outputs;
  const biases = firstLayer + secondLayer + outputs;
  return { weights, biases, parameters: weights + biases };
}
const result = countParameters(3, 4, 6, 1);

เครือข่ายมีน้ำหนัก 42 ค่าและไบแอส 11 ค่า รวมพารามิเตอร์ปรับได้ 53 ค่า

นิวรอนซ่อนแต่ละตัวใช้ฟังก์ชันกระตุ้นหลังผลรวมถ่วงน้ำหนัก ReLU และ ซิกมอยด์ เป็นกฎสองแบบที่เลือกใช้ได้ในขั้นนี้ โดยทั่วไปสถาปัตยกรรมกำหนดรูปแบบฟังก์ชันกระตุ้นไว้ล่วงหน้า

ใช้ ReLU และ ซิกมอยด์ กับข้อมูลเข้าเดียวกันคือ 0 ทั้งสองเป็นตัวเลือกจากตารางฟังก์ชันกระตุ้นของบทความ

function activations(value) {
  const relu = Math.max(0, value);
  const sigmoid = 1 / (1 + Math.exp(-value));
  return { relu, sigmoid };
}
const result = activations(0);

ซิกมอยด์เปลี่ยน 0 เป็น 0.5 ส่วน ReLU ให้ 0 เมื่อใส่ −2 ReLU ให้ 0 และซิกมอยด์ให้ประมาณ 0.119 บทความยังระบุฟังก์ชันกระตุ้นแบบเกาส์ ซึ่งมีค่าสูงสุดที่ศูนย์และลดลงทั้งสองด้าน

ทำไมไม่ใช้แค่ขั้นน้ำหนักและไบแอส สองขั้นแอฟไฟน์ที่ไม่มีสิ่งไม่เชิงเส้นคั่นกลางสามารถรวมเป็นขั้นแอฟไฟน์ขั้นเดียวได้

ใช้กฎแอฟไฟน์หนึ่งก่อนแล้วใช้อีกกฎ: คูณผลแรกด้วย 4 แล้วบวก 5

function combineLayers(value) {
  const h = 2 * value + 3;
  return { h, output: 4 * h + 5, combined: 8 * value + 17 };
}
const result = combineLayers(1);

สองขั้นรวมกันเป็น 8x + 17 ฟังก์ชันกระตุ้นอย่าง ReLU ทำให้ข้อมูลเข้าต่างกันใช้กฎคนละช่วง ซึ่งรวมเป็นขั้นเดียวแบบนี้ไม่ได้เสมอ

ลองเปลี่ยนน้ำหนักและไบแอสทั้ง 53 ตัว โดยคงชั้นและกฎกระตุ้นไว้ ค่าแต่ละชุดอาจให้กฎทำนายต่างกัน แต่บางชุดก็ให้กฎเดียวกัน ขนาดชั้นและกฎกระตุ้นประกอบกันเป็นโครงสร้างเครือข่าย กฎทั้งหมดที่สร้างได้เรียกว่าชุดสมมติฐาน คือชุดกฎที่เลือกใช้ได้

ต่อมาคือคำถามว่า “การตั้งค่าใดดี” เราต้องมีวิธีตัดสินความผิดพลาดเป็นตัวเลข สำหรับตัวอย่างฝึกแต่ละตัวเราคำนวณความสูญเสีย แล้วบวกความสูญเสียทั้งหมดและหารด้วยจำนวนตัวอย่าง

แบบจำลองทำผิดสองครั้งในตัวอย่างฝึกสมมติห้าตัวอย่าง แต่ละข้อผิดนับเป็น 1 และแต่ละข้อถูกนับเป็น 0

function averageRisk(losses) {
  let mistakes = 0;
  for (const loss of losses) mistakes += loss;
  return { mistakes, average: mistakes / losses.length };
}
const result = averageRisk([0, 0, 1, 0, 1]);

ค่าเฉลี่ย 0.4 เป็นอัตราความผิดพลาด 40% สำหรับความสูญเสียนี้ ความสูญเสียกำลังสองมีหน่วยต่างกันและไม่ใช่เปอร์เซ็นต์

ค่าเฉลี่ยฝึกคือผลรวมความผิดพลาดของตัวอย่างฝึกหารด้วยจำนวนตัวอย่าง การเลือกกฎที่อนุญาตซึ่งมีค่าเฉลี่ยฝึกน้อยที่สุดเรียกว่าการลดความเสี่ยงเชิงประจักษ์ หรือ ERM วิธีนี้เลือกจากตัวอย่างที่มี ไม่ได้รับประกันผลในอนาคต

ในสูตร F คือชุดกฎที่เลือกได้ s คือตัวอย่างฝึกที่รวบรวมมา และ R̂ คือค่าความเสียหายเฉลี่ยของตัวอย่างเหล่านั้น สัญลักษณ์เลือกค่าต่ำสุดหมายถึงเลือกกฎที่มีค่าเฉลี่ยต่ำที่สุด เช่น กฎสามข้อมีค่าเฉลี่ย 0.5, 0.2 และ 0.4

function bestCandidate(losses) {
  const minimum = Math.min(...losses);
  return { minimum, candidate: losses.indexOf(minimum) + 1 };
}
const result = bestCandidate([0.5, 0.2, 0.4]);

ตัวเลือกที่ 2 ชนะในการเปรียบเทียบสมมติ เมื่อมีน้ำหนักหลายล้านค่า อัลกอริทึมมักค้นหาค่าที่ดีแทนการเปรียบเทียบทุกความเป็นไปได้

ความสูญเสียการจำแนกมีปัญหาสำหรับการค้นหานี้: คะแนน −2 และ −1 ต่างผิดเมื่อป้ายกำกับเป็น +1 การนับข้อผิดให้ความสูญเสีย 1 เท่ากัน แม้ −1 จะใกล้เป็นบวกกว่า ความสูญเสียทดแทนที่เรียบสามารถเปลี่ยนก่อนที่ประเภทที่เลือกจะเปลี่ยน

สำหรับป้ายกำกับบวก เปรียบเทียบคะแนนกับศูนย์ ทั้ง −2 และ −1 ให้ประเภทผิด แต่ความสูญเสียโลจิสติกแยกความแตกต่างได้

function compareLosses(score) {
  let classLoss = 0;
  if (score < 0) classLoss = 1;
  const logistic = Math.log(1 + Math.exp(-score));
  return { classLoss, logistic };
}
const result = compareLosses(-2);

สำหรับป้าย +1 ค่าความเสียหายแบบโลจิสติกให้คะแนน −2 ประมาณ 2.127 และ −1 ประมาณ 1.313 ประเภทยังผิดอยู่ แต่ค่าที่ลดลงบอกว่าดีขึ้น วิธีนี้ช่วยค้นหาระหว่างฝึก แม้ค่าความเสียหายโลจิสติกต่ำสุดจะไม่ได้ให้จำนวนข้อผิดพลาดน้อยที่สุดในทุกชุดกฎ

บางครั้งเราไม่ต้องการค่าพารามิเตอร์สุดโต่งด้วย เราเพิ่มค่าปรับได้โดยยกกำลังสองพารามิเตอร์แต่ละตัว บวกผลแล้วคูณด้วยความแรงเล็กน้อย α เป้าหมายการฝึกจึงสมดุลระหว่างความพอดีกับขนาดพารามิเตอร์

เปรียบเทียบแบบจำลองตัวอย่างสองแบบ เมื่อความแรงของบทลงโทษเท่ากับ 0.01 แบบ A มีค่า 0.10 + 0.01×100 = 1.10 ส่วนแบบ B มีค่า 0.15 + 0.01×2 = 0.17 ความแรงกำหนดว่าค่าพารามิเตอร์กำลังสองมีผลมากเพียงใด

function penalizedLoss(strength) {
  return { A: 0.1 + strength * 100, B: 0.15 + strength * 2 };
}
const result = penalizedLoss(0.01);

ที่ความแรงโทษนี้ แบบจำลอง B มีค่าวัตถุประสงค์น้อยกว่า แต่ไม่ได้พิสูจน์ว่า B จะทำนายกรณีในอนาคตได้ดีกว่า

เราได้วัดความผิดพลาดบนตัวอย่างที่มีอยู่แล้ว แต่เป้าหมายจริงคือทำได้ดีกับตัวอย่างใหม่ที่สุ่มจากกระบวนการชนิดเดียวกัน บทความเรียกค่าเฉลี่ยเหนือการแจกแจงที่ไม่รู้นี้ว่าความเสี่ยง เขียนเป็น R(f)

สมมติว่ากรณีใหม่มีสองแบบ แบบที่ตอบถูกมีโอกาสสามในสี่หรือ 0.75 ส่วนแบบที่ตอบผิดมีโอกาสหนึ่งในสี่หรือ 0.25 เปรียบเทียบค่าเฉลี่ยที่ถ่วงด้วยโอกาสนี้กับตัวอย่างที่พบจริงสองกรณี คือถูกหนึ่งและผิดหนึ่ง

function compareRisk(chance) {
  if (!(chance >= 0 && chance <= 1)) {
    throw new Error('ความน่าจะเป็นต้องอยู่ระหว่าง 0 กับ 1');
  }
  const expectedRisk = (1 - chance) * 0 + chance * 1;
  const observedAverage = (0 + 1) / 2;
  return { expectedRisk, observedAverage };
}
const result = compareRisk(0.25);

ความสูญเสียคาดหมายคือ 0.25 ส่วนค่าเฉลี่ยที่สังเกตคือ 0.5 ค่าคาดหมายอธิบายการแจกแจง ส่วนค่าเฉลี่ยตัวอย่างอธิบายกรณีที่สุ่มมา

สำหรับผลลัพธ์แบบดั้งเดิม บทความสมมติว่าตัวอย่างฝึกแต่ละตัวและตัวอย่างใหม่ถูกสุ่มอย่างอิสระจากการแจกแจงเดียวกัน กล่าวคือมาจากโลกแบบเดียวกันโดยการสุ่มครั้งหนึ่งไม่กำหนดอีกครั้ง หากโลกเปลี่ยน ข้อรับประกันอาจใช้ไม่ได้ ป้ายที่ไม่แน่นอนอาจทำให้แม้แต่กฎที่ดีที่สุดก็ยังมีข้อผิดพลาดที่เลี่ยงไม่ได้

กฎอาจพลาดได้สามทาง ชุดกฎที่อนุญาตอาจไม่มีกฎที่ใกล้คำตอบพอ การค้นหาอาจหากฎที่ดีที่สุดในชุดไม่พบ หรือค่าเฉลี่ยจากตัวอย่างฝึกอาจทำให้เข้าใจผิด ทั้งสามเรียกตามลำดับว่าความผิดพลาดจากการประมาณ การหาค่าเหมาะที่สุด และการใช้กับตัวอย่างใหม่

ลองนึกถึงกฎที่ดีที่สุดเท่าที่เป็นไปได้และความผิดพลาดเฉลี่ยของมันกับตัวอย่างในอนาคต ความเสี่ยงส่วนเกินคือความผิดพลาดเฉลี่ยของกฎเราที่มากกว่าค่าเฉลี่ยดีที่สุดนั้น ขอบเขตต่อไปบวกส่วนเผื่อสามอย่าง: หาค่าที่ดีที่สุดไม่พบ ช่องว่างระหว่างค่าเฉลี่ยฝึกกับอนาคต และไม่มีกฎที่ดีพอ ส่วนเผื่อช่องว่างใช้ช่องว่างที่ใหญ่ที่สุดในกฎทั้งหมดที่อนุญาต ไม่ใช่แค่ห้าตัวอย่างทดสอบ ลองใช้ 0.1, 0.2 และ 0.3

function riskBound(generalization) {
  return { upperBound: 0.1 + 2 * generalization + 0.3 };
}
const result = riskBound(0.2);

แทนค่าตัวอย่างในขอบเขตบน: 2×0.2 = 0.4 แล้ว 0.1 + 0.4 + 0.3 = 0.8 ตามนิยามในบทความ ความเสี่ยงส่วนเกินไม่เกินขอบเขตนี้ แต่ไม่ใช่ค่าความผิดพลาดจริง พจน์กลางนับสองครั้งเพราะการเปรียบเทียบใช้ช่องว่างระหว่างค่าเฉลี่ยฝึกกับอนาคตสองช่อง

ตอนนี้เรามีแผนที่สำหรับส่วนที่เหลือของบทความ: เราหาการตั้งค่าที่ดีได้หรือไม่ เครือข่ายชนิดนี้แสดงคำตอบได้หรือไม่ และเราเชื่อถือมันกับตัวอย่างที่ไม่เคยแสดงให้เห็นได้หรือไม่

กลุ่มแบบจำลองอาจมีกฎที่ดีมาก แต่เราจะหาน้ำหนักของมันได้อย่างไร ใช้ปุ่มปรับค่าเดียว w ซึ่งควรเท่ากับ 2 และใช้ความสูญเสียกำลังสอง L(w) = (w − 2)² เมื่อ w = 5 ความสูญเสียคือ (5 − 2)² = 9

เกรเดียนต์บอกทิศทางเฉพาะจุดที่ความสูญเสียเพิ่มเร็วที่สุด ในตัวอย่างปุ่มเดียวนี้เกรเดียนต์คือ 2(w − 2) ดังนั้นเมื่อ w = 5 จึงเท่ากับ 6 เกรเดียนต์บวกหมายความว่าการขยับไปทางซ้ายเล็กน้อยควรลดความสูญเสีย

บทความปรับพารามิเตอร์ Θ ด้วยค่าเฉลี่ยเกรเดียนต์ความสูญเสียบนมินิแบตช์ S′ จำนวน m′ ตัวอย่าง โดยมีอัตราเรียนรู้ η ตัวอย่างน้ำหนักเดียวและข้อมูลฝึกหนึ่งกรณีใช้ L(w) = (w − 2)² ที่ w = 5

function updateWeight(weight, target, step) {
  const gradient = 2 * (weight - target);
  return { gradient, next: weight - step * gradient };
}
const result = updateWeight(5, 2, 0.25);

การลบ 0.25 × 6 เลื่อนปุ่มจาก 5 เป็น 3.5 ความสูญเสียใหม่คือ (3.5 − 2)² = 2.25 ซึ่งน้อยกว่า 9 จำนวน 0.25 คืออัตราการเรียนรู้ หากอัตรามากเกินไปอาจกระโดดข้ามค่าที่ดี

น้ำหนักใกล้จุดเริ่มอาจเปลี่ยนการคำนวณถัดไป แล้วเปลี่ยนความผิดพลาดสุดท้าย กฎลูกโซ่ใช้หาว่าการเปลี่ยนแปลงเหล่านี้เชื่อมกันอย่างไร การแพร่ย้อนกลับติดตามการเปลี่ยนแปลงจากความผิดพลาดย้อนผ่านชั้นต่าง ๆ เพื่อดูว่าน้ำหนักก่อนหน้าแต่ละตัวส่งผลอย่างไร ขณะทำนาย ผลออกไม่ได้เดินทางย้อนกลับ

แทนที่จะวัดความสูญเสียจากตัวอย่างฝึกทั้งหมดทุกครั้งที่ปรับ การลดระดับด้วยความชันแบบสุ่ม (SGD) สามารถใช้กลุ่มเล็กที่สุ่มเลือกเรียกว่ามินิแบตช์ ทิศทางของมันเป็นค่าประมาณที่มีสัญญาณรบกวนของเกรเดียนต์เต็ม ความสูญเสียรูปชามแบบง่ายบางชนิดมีการรับประกันการลู่เข้า แต่ภูมิทัศน์ของเครือข่ายประสาททั่วไปอาจมีหลายหุบหรือบริเวณราบ การปรับที่สำเร็จหนึ่งครั้งในที่นี้ไม่ได้พิสูจน์ความสำเร็จทั่วทั้งภูมิทัศน์

ถ้าเราค้นหาได้สมบูรณ์แบบแต่ไม่มีกฎที่อนุญาตใดให้คำตอบถูกต้องได้จะเป็นอย่างไร เครื่องที่คืนได้เพียงจำนวน 1 ไม่สามารถให้เป้าหมาย 0, 1 และ 2 สำหรับข้อมูลเข้าสามค่าที่ต่างกันได้

คำถามเรื่องการประมาณเกี่ยวกับตัวกลุ่มกฎเอง ก่อนที่เราจะถามว่าการฝึกพบสมาชิกที่ถูกต้องหรือไม่

ที่ข้อมูลเข้าสมมติ 0, 1, 2 ผลลัพธ์เป้าหมายคือ 0, 1, 2 เปรียบเทียบกฎคงที่ 1 กับกฎยืดหยุ่นที่คืนค่าข้อมูลเข้า

function approximationError(flatOutput, inputs, targets) {
  let flatTotal = 0;
  let flexibleTotal = 0;
  for (let index = 0; index < targets.length; index++) {
    flatTotal += (flatOutput - targets[index]) ** 2;
    flexibleTotal += (inputs[index] - targets[index]) ** 2;
  }
  return {
    flat: flatTotal / targets.length,
    flexible: flexibleTotal / targets.length,
  };
}
const result = approximationError(1, [0, 1, 2], [0, 1, 2]);

กฎคงที่ทำนาย 1, 1, 1: ความผิดพลาดกำลังสองคือ 1, 0, 1 มีค่าเฉลี่ย 2/3 กฎ f(x) = x ทำนาย 0, 1, 2 และมีความผิดพลาดศูนย์บนสามจุดนี้ นี่เป็นการเปรียบเทียบสมมติที่มีจำนวนจุดจำกัด ไม่ใช่ข้ออ้างว่ากฎยืดหยุ่นถูกต้องทุกแห่ง

ลองใช้กฎเป้าหมายที่เปลี่ยนอย่างต่อเนื่องเมื่อตัวป้อนเปลี่ยน และจำกัดตัวป้อนให้อยู่ในช่วงที่จำกัด บทความทบทวนผลที่แสดงว่าเครือข่ายที่ใช้กฎกระตุ้นเหมาะสม รวมถึง ReLU และมีเซลล์ซ่อนมากพอ สามารถเข้าใกล้ได้ตามต้องการภายใต้เงื่อนไขที่ระบุ นั่นหมายความว่ามีค่าตั้งที่ต้องการอยู่ ไม่ได้รับประกันว่าเครือข่ายจะเล็กหรือการฝึกจะหาค่าเหล่านั้นพบ

เครือข่ายยังสามารถปรับให้ตรงกับรายการตัวอย่างที่มีจำนวนจำกัดได้พอดี รวมถึงป้ายกำกับตามอำเภอใจภายใต้เงื่อนไขที่เหมาะสม การตรงกับจุดเหล่านั้นพอดีเพียงอย่างเดียวไม่ได้บอกว่าเกิดอะไรขึ้นระหว่างจุดหรือกับข้อมูลเข้าในอนาคต

แบบจำลองอาจจำคำถามฝึกห้าข้อได้สมบูรณ์โดยไม่เข้าใจว่ากฎใดจะใช้ได้กับข้อที่หก เราจึงแยกค่าเฉลี่ยการฝึกออกจากพฤติกรรมบนตัวอย่างที่ไม่คุ้นเคย

ใช้ชุดตัวอย่างแยกต่างหากตรวจสอบแบบจำลองที่เสร็จแล้ว อย่าใช้ชุดนั้นเลือกน้ำหนักหากต้องการการตรวจสอบที่ตรงไปตรงมา ตัวอย่างทดสอบควรมาจากโลกชนิดเดียวกับที่แบบจำลองจะถูกนำไปใช้

กฎสมมติทำนายกรณีฝึกถูก 4 ใน 5 และกรณีใหม่ถูก 3 ใน 5

function compareMistakes(newMistakes, cases) {
  if (!Number.isInteger(cases) || cases <= 0
    || !Number.isInteger(newMistakes)
    || newMistakes < 0 || newMistakes > cases) {
    throw new Error('ใช้จำนวนเต็มโดยให้ 0 ≤ จำนวนผิด ≤ จำนวนกรณี และจำนวนกรณีต้องเป็นบวก');
  }
  return { training: 1 / cases, newCases: newMistakes / cases };
}
const result = compareMistakes(2, 5);

ทั้งสองสัดส่วนเป็นค่าประมาณที่ผันผวนจากเพียงห้ากรณี สัดส่วนกรณีใหม่ไม่ใช่ความเสี่ยงจริงในอนาคตโดยอัตโนมัติ

ทฤษฎีดั้งเดิมมักสมมติว่าตัวอย่างถูกเลือกอย่างเป็นอิสระ คือการเลือกครั้งหนึ่งไม่กำหนดครั้งต่อไป และจำกัดชุดกฎที่พิจารณา ภายใต้สมมติฐานเช่นนี้ เราหาขอบเขตของช่องว่างระหว่างค่าเฉลี่ยฝึกกับอนาคตได้ ตัวอย่างอิสระที่มากขึ้นมักทำให้ขอบเขตแคบลง ส่วนอิสระที่มากขึ้นในการเข้ากับป้ายใด ๆ อาจทำให้บางขอบเขตกว้างขึ้น

สำหรับจุดสองจุด ชุดกฎของเราให้ป้ายกำกับได้ครบทุกคู่หรือไม่: (+1, +1), (+1, −1), (−1, +1) และ (−1, −1)? มิติ VC วัดจำนวนจุดที่ชุดกฎสามารถให้ป้ายกำกับได้ครบทุกแบบ ขอบเขตที่ใช้เพียงจำนวนพารามิเตอร์ของเครือข่ายขนาดใหญ่มักบอกได้น้อยว่าจะทำได้ดีเพียงใดกับตัวอย่างใหม่

นำคำถามสามข้อมาไว้ด้วยกัน หนึ่ง เครือข่ายที่เลือกแสดงกฎที่ต้องการได้หรือไม่ สอง การฝึกหาพารามิเตอร์ที่มีประโยชน์ได้หรือไม่ สาม ผลลัพธ์จะใช้ได้เกินกว่าตัวอย่างฝึกหรือไม่

แบบจำลองสมมติไม่ผิดเลยในกรณีฝึกห้ากรณี แต่ผิดสองครั้งในกรณีใหม่ห้ากรณี

function generalizationGap(newMistakes, cases) {
  if (!Number.isInteger(cases) || cases <= 0
    || !Number.isInteger(newMistakes)
    || newMistakes < 0 || newMistakes > cases) {
    throw new Error('ใช้จำนวนเต็มโดยให้ 0 ≤ จำนวนผิด ≤ จำนวนกรณี และจำนวนกรณีต้องเป็นบวก');
  }
  const training = 0 / cases;
  const newCases = newMistakes / cases;
  return { training, newCases, gap: newCases - training };
}
const result = generalizationGap(2, 5);

ช่องว่างที่สังเกตได้ 0.4 จากกรณีใหม่ห้ากรณีไม่ได้บอกค่าเฉลี่ยจริงของกรณีในอนาคตทั้งหมด

ส่วนที่เหลือของบทความติดตามอีกเจ็ดคำถาม: ทำไมเครือข่ายขนาดใหญ่มากบางครั้งจึงวางนัยทั่วไปได้ ชั้นที่เพิ่มขึ้นให้อะไร เครือข่ายจัดการข้อมูลเข้าจำนวนมากอย่างไร ทำไมการฝึกด้วยเกรเดียนต์จึงสำเร็จได้ โครงสร้างพิเศษเปลี่ยนอะไร มีการเรียนรู้คุณลักษณะใด และทำไมสมการทางวิทยาศาสตร์จึงช่วยได้

แต่ละคำตอบมีเงื่อนไข บางครั้งผู้เขียนแสดงผลที่พิสูจน์อย่างเคร่งครัดสำหรับแบบจำลองเฉพาะ บางครั้งให้ตัวอย่างทางคณิตศาสตร์หรือรายงานข้อสังเกตที่นักวิจัยยังต้องการคำอธิบาย