GAN: ตัวสร้างและตัวจำแนก
ทฤษฎีเกมแบบมิน–แมกซ์ ความไม่เสถียรในการฝึก GAN การยุบตัวของโหมด และการใช้งาน DCGAN
GAN: ตัวสร้างและตัวจำแนก เป็นบทเรียน Learn AI with Python ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn AI with Python และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน
GAN คืออะไร
เครือข่ายเชิงกำเนิดแบบแข่งขันกัน ประกอบด้วยเครือข่ายสองตัวที่แข่งขันกัน ได้แก่ Generator ซึ่งสร้างข้อมูลปลอม และ Discriminator ซึ่งตัดสินว่าข้อมูลนั้นเป็นของจริงหรือปลอม ทั้งสองแข่งขันกัน และตัวสร้างจะเรียนรู้การสร้างตัวอย่างที่น่าเชื่อถือ
เกมการแข่งขันเชิงปฏิปักษ์
ลองนึกถึงผู้ปลอมแปลง (ตัวสร้าง) และนักสืบ (ตัวจำแนก) ผู้ปลอมแปลงจะปรับปรุงของปลอมเพื่อหลอกนักสืบ ส่วนนักสืบก็จะพัฒนาความสามารถในการสังเกต การแข่งขันนี้ผลักดันให้ทั้งสองฝ่ายเก่งขึ้นเรื่อย ๆ จนของปลอมดูเหมือนของจริง
ตัวสร้าง Generator
ตัวสร้างจะแปลง เวกเตอร์สัญญาณรบกวนแบบสุ่มให้เป็นภาพปลอม มันเรียนรู้การเปลี่ยนตัวเลขสุ่มที่ไร้ความหมายให้เป็นข้อมูลที่มีโครงสร้างและดูสมจริง
class Generator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(100, 256), nn.ReLU(),
nn.Linear(256, 784), nn.Tanh()
)
def forward(self, z):
return self.net(z)เวกเตอร์สัญญาณรบกวน
ข้อมูลนำเข้า z จะสุ่มมาจากการแจกแจงปกติมาตรฐาน เวกเตอร์สัญญาณรบกวนที่แตกต่างกันจะสร้างภาพที่แตกต่างกัน ดังนั้นสัญญาณรบกวนจึงเป็น "เมล็ดพันธุ์" ของการสร้างข้อมูล มิติของมัน ซึ่งในที่นี้คือ 100 คือขนาดของพื้นที่แฝง
z = torch.randn(batch_size, 100)
fake_images = generator(z)ตัวจำแนก Discriminator
ตัวจำแนกรับภาพหนึ่งภาพและให้ค่าความน่าจะเป็นค่าเดียว ซึ่งบอกว่าภาพนั้นมีโอกาสเป็นภาพ จริง มากเพียงใด Sigmoid จะให้ค่าในช่วง [0,1] โดย 1 หมายถึงจริง และ 0 หมายถึงปลอม
class Discriminator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(784, 256), nn.LeakyReLU(0.2),
nn.Linear(256, 1), nn.Sigmoid()
)การฝึกตัวจำแนก
ฝึก D ด้วยชุดภาพ จริง ที่มีป้ายกำกับเป็น 1 และภาพ ปลอม ที่มีป้ายกำกับเป็น 0 ตัวจำแนกจะเรียนรู้การเพิ่มคะแนนของภาพจริงและลดคะแนนของภาพปลอมโดยใช้ค่าความสูญเสียเอนโทรปีไขว้แบบทวิภาค
d_real = criterion(D(real), ones)
d_fake = criterion(D(fake.detach()), zeros)
d_loss = d_real + d_fake
d_loss.backward()เหตุใดจึงใช้ detach() กับภาพปลอม
เมื่อฝึก D เราใช้ fake.detach() เพื่อไม่ให้การไล่ระดับไหลเข้าไปยังตัวสร้าง ในขั้นตอนนี้เราจะปรับปรุงเฉพาะตัวจำแนกเท่านั้น ส่วนตัวสร้างจะได้รับการฝึกในขั้นตอนแยกต่างหาก
การฝึกตัวสร้าง Generator
ตอนนี้ให้ฝึก G เพื่อ หลอก D โดยส่งภาพปลอมผ่าน D และให้รางวัลแก่ตัวสร้างเมื่อ D ให้ผลลัพธ์ว่าเป็น จริง (ป้ายกำกับ 1) ตัวสร้างจะพัฒนาด้วยการทำให้ D เชื่อว่าภาพปลอมของมันเป็นภาพจริง
g_loss = criterion(D(fake), ones) # want D to say "real"
g_loss.backward()
g_optimizer.step()การฝึกแบบสลับกัน
แต่ละรอบการทำงานจะสลับกันดังนี้ อัปเดต D ก่อน แล้วจึงอัปเดต G การรักษาสมดุลระหว่างทั้งสองโดยประมาณเป็นสิ่งสำคัญ หาก D แข็งแกร่งเกินไป G จะไม่ได้รับการไล่ระดับที่เป็นประโยชน์ แต่หาก D อ่อนแอเกินไป G ก็จะไม่มีความท้าทาย
# per step
# 1) update Discriminator
# 2) update Generatorภาวะโหมดล่มสลาย
ความล้มเหลวแบบคลาสสิกคือ ภาวะโหมดล่มสลาย ซึ่งเกิดขึ้นเมื่อตัวสร้างพบผลลัพธ์หนึ่งหรือไม่กี่แบบที่หลอก D ได้ แล้วสร้างเฉพาะผลลัพธ์เหล่านั้นโดยไม่สนใจความหลากหลายของข้อมูล อาการที่พบคือ ตัวอย่างที่สร้างขึ้นทุกตัวแทบจะเหมือนกัน
ความไม่เสถียรในการฝึก
GAN มีชื่อเสียงด้าน ความไม่เสถียร ค่าความสูญเสียจะแกว่งไปมา เครือข่ายหนึ่งอาจมีอำนาจเหนืออีกเครือข่าย และการลู่เข้าหาคำตอบก็เปราะบาง เทคนิคอย่าง LeakyReLU อัตราการเรียนรู้ที่กำหนดอย่างรอบคอบ และการทำให้ป้ายกำกับราบเรียบช่วยให้การฝึกมีเสถียรภาพมากขึ้น
ตรวจสอบความเข้าใจ
ทดสอบความเข้าใจเกี่ยวกับ GAN
สรุป: GAN
คุณได้เรียนรู้โครงสร้างแบบแข่งขันกัน ตัวสร้างจะเปลี่ยนเวกเตอร์สัญญาณรบกวนให้เป็นข้อมูลปลอม ตัวจำแนกจะให้ค่าความน่าจะเป็นว่าเป็นของจริงหรือของปลอม และทั้งสองจะฝึกด้วยการ สลับกัน โดยฝึก D แล้วจึงฝึก G คุณยังได้เรียนรู้วิธีสังเกต ภาวะโหมดล่มสลาย และความไม่เสถียรโดยทั่วไปที่ทำให้ GAN ฝึกได้ยาก
คำถามที่พบบ่อย
บทเรียน “GAN: ตัวสร้างและตัวจำแนก” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “GAN: ตัวสร้างและตัวจำแนก” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn AI with Python ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “GAN: ตัวสร้างและตัวจำแนก”
ทฤษฎีเกมแบบมิน–แมกซ์ ความไม่เสถียรในการฝึก GAN การยุบตัวของโหมด และการใช้งาน DCGAN คุณปฏิบัติ Learn AI with Python ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn AI with Python หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn AI with Python บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “GAN: ตัวสร้างและตัวจำแนก” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Learn AI with Python นี้ได้ไหม
ได้ บทเรียน Learn AI with Python ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ออโตเอนโคดเดอร์สำหรับการเรียนรู้การแทนค่า
- ออโตเอนโคดเดอร์แบบแปรผัน (VAE)
- GAN: ตัวสร้างและตัวจำแนก
- GAN แบบมีเงื่อนไขและการถ่ายโอนสไตล์