ออกแบบโครงข่าย

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

เลื่อนตัวกรองสองค่า (1, −1) ชุดเดียวกันผ่านค่าสมมติ (3, 2, 4) คูณสมาชิกที่ตรงกันแล้วบวกในแต่ละหน้าต่าง

function neighboringDifferences(values) {
  return { outputs: [values[0] - values[1], values[1] - values[2]] };
}
const result = neighboringDifferences([3, 2, 4]);

เลื่อนตัวกรอง [1, −1] ชุดเดียวกันผ่านค่าที่อ่านได้ [3, 2, 4] ตำแหน่งแรกคำนวณ 1×3 − 1×2 = 1 ตำแหน่งที่สองคำนวณ 1×2 − 1×4 = −2 ตัวกรองถูกใช้ซ้ำแทนการเรียนรู้น้ำหนักคู่ใหม่ในทุกตำแหน่ง

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

ระหว่างการฝึก สัญญาณปรับค่าย้อนผ่านชั้นต่าง ๆ แต่ละชั้นคูณสัญญาณด้วยตัวประกอบที่บอกผลของชั้นนั้น เช่น สัญญาณ 1 ที่คูณ 0.5 สามครั้งจะเป็น 0.5 แล้ว 0.25 แล้ว 0.125 ตัวประกอบต่ำกว่า 1 หลายตัวอาจทำให้สัญญาณเล็กมาก ส่วนตัวประกอบมากกว่า 1 หลายตัวอาจทำให้ใหญ่เกินไป ทั้งสองแบบทำให้ปรับชั้นแรก ๆ ได้ยาก

บล็อกเรซิดวลเก็บค่าก่อนหน้าไว้และบวกค่าปรับแก้ แทนที่จะแทนที่ค่าทั้งหมด

ในชั้นตกค้างของบทความ ค่าชดเชยหลังฟังก์ชันกระตุ้นถูกบวกกับค่าชั้นก่อนหน้า ตัวอย่างนี้ใช้ค่าเดิม 3 และค่าชดเชย 1

function residualBlock(value, correction) {
  const activated = Math.max(0, correction);
  return { input: value, correction: activated, output: value + activated };
}
const result = residualBlock(3, 1);

ในสูตร Φ ที่มีขีดบนคือผลลัพธ์ชั้นตกค้าง ℓ คือหมายเลขชั้น Φ คือค่าชดเชยก่อนกระตุ้น ρ คือฟังก์ชันกระตุ้น และ θ รวมพารามิเตอร์ ในตัวอย่าง ReLU คงค่า 1 จึงได้ 3 + 1 = 4

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

เมื่อย่อภาพ เราอาจสูญเสียรายละเอียดเล็กแต่สำคัญ เครือข่ายรูปตัวยูบีบอัดข้อมูลก่อนแล้วสร้างภาพกลับขึ้นมา การเชื่อมต่อระยะยาวสามารถนำรายละเอียดก่อนหน้ามาช่วยสร้างภาพคืน

หาค่าเฉลี่ยของพิกเซลสมมติ 2 และ 4 และเก็บผลต่างครึ่งหนึ่งไว้ ใช้ทั้งสองส่วนสร้างข้อมูลเข้ากลับคืน

function splitAndReconstruct(first, second) {
  const average = (first + second) / 2;
  const detail = (first - second) / 2;
  const reconstructed = [average + detail, average - detail];
  return { average, detail, reconstructed };
}
const result = splitAndReconstruct(2, 4);

จากพิกเซล 2 และ 4 ค่าเฉลี่ยคือ (2 + 4)/2 = 3 และผลต่างครึ่งหนึ่งคือ (2 − 4)/2 = −1 การเก็บทั้งสองค่าช่วยให้กู้คืน 3 − 1 = 2 และ 3 + 1 = 4 ได้ ค่าเฉลี่ยเพียงอย่างเดียวจะให้ 3 สองตัวและลืมความแตกต่าง

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

ใน U-Net การเชื่อมข้ามส่งคุณลักษณะก่อนหน้าที่มีประโยชน์ผ่านเส้นทางบีบอัด การสร้างกลับได้ตรงพอดีหรือไม่ขึ้นอยู่กับตัวกรองและสถาปัตยกรรม ไม่ใช่เพียงการวาดเป็นรูปตัวยู

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

ใช้ชุดข้อมูลที่มี 1 และ 3 ก่อนอื่นหาค่าเฉลี่ย แล้ววัดการกระจายโดยยกกำลังสองระยะของแต่ละค่าจากค่าเฉลี่ย หาค่าเฉลี่ยของกำลังสองเหล่านั้น และถอดรากที่สอง

function normalizeBatch(values) {
  if (values.length === 0) throw new Error('ชุดข้อมูลต้องไม่ว่าง');
  let total = 0;
  for (const value of values) total += value;
  const mean = total / values.length;
  let squaredTotal = 0;
  for (const value of values) squaredTotal += (value - mean) ** 2;
  const spread = Math.sqrt(squaredTotal / values.length);
  if (spread === 0) throw new Error('ส่วนเบี่ยงเบนของชุดข้อมูลต้องไม่เป็นศูนย์');
  const normalized = [];
  for (const value of values) normalized.push((value - mean) / spread);
  return { mean, spread, normalized };
}
const result = normalizeBatch([1, 3]);

ค่าเฉลี่ยคือ (1 + 3)/2 = 2 ลบค่านี้จากแต่ละจำนวนจะได้ผลต่าง −1 และ +1 ยกกำลังสองแล้วหาค่าเฉลี่ย: ((−1)² + 1²)/2 = 1 รากที่สองของ 1 คือ 1 ซึ่งเป็นค่าการกระจายที่เรียกว่าส่วนเบี่ยงเบนมาตรฐาน เมื่อลบ 2 แล้วหารด้วยค่าการกระจายนี้ จะได้ [−1, 1]

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

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

เครือข่ายขนาดใหญ่อาจมีการเชื่อมต่อที่เพิ่มผลน้อยต่อผลลัพธ์หนึ่ง การตัดแต่งตั้งค่าน้ำหนักบางตัวเป็นศูนย์เพื่อให้ต้องเก็บการเชื่อมต่อน้อยลง

ผลลัพธ์สมมติบวกน้ำหนักสามตัวคูณข้อมูลเข้า ลบน้ำหนักเล็กตัวหนึ่งแล้วเปรียบเทียบผลลัพธ์กับค่าเดิม

function pruneWeights(weights, cutoff) {
  if (!(cutoff >= 0)) throw new Error('เกณฑ์ต้องไม่ติดลบ');
  let original = 0;
  let pruned = 0;
  for (const weight of weights) {
    original += weight;
    if (Math.abs(weight) >= cutoff) pruned += weight;
  }
  return { original, pruned };
}
const result = pruneWeights([2, 0.1, 1], 0.2);

สำหรับข้อมูลเข้าสมมติที่ทุกคุณลักษณะเท่ากับ 1 ผลย่อย 2, 0.1 และ 1 รวมเป็น 3.1 เมื่อลบผลย่อย 0.1 ได้ 3 ซึ่งต่างเพียง 0.1 สำหรับข้อมูลเข้านี้ แต่ข้อมูลเข้าอื่นอาจเปลี่ยนผลของการลบการเชื่อมต่อ

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

ภาพการเชื่อมต่อเบาบางนี้เกี่ยวกับการลบน้ำหนัก ซึ่งต่างจากคำอธิบายรูปแบบเบาบางที่เราจะพบในบทที่ 7

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

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

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

function recurrentStep(first, memory, nextInput) {
  const second = memory * first + nextInput;
  return { first, second };
}
const result = recurrentStep(1, 0.5, 1);

เริ่มด้วยสถานะ 0 หากเสียงระฆังบวก 1 และสถานะเก่าถูกหารสอง ขั้นแรกได้ 0/2 + 1 = 1 เมื่อระฆังดังครั้งที่สองได้ 1/2 + 1 = 1.5 จำนวน 1.5 มีข้อมูลจากทั้งสองขั้น

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