ออโตเอนโคดเดอร์สำหรับการเรียนรู้การแทนค่า
สถาปัตยกรรมตัวเข้ารหัส–ตัวถอดรหัส คอขวด ฟังก์ชันสูญเสียจากการสร้างกลับคืน และการประยุกต์ใช้ในการตรวจจับความผิดปกติ
ออโตเอนโคดเดอร์สำหรับการเรียนรู้การแทนค่า เป็นบทเรียน Learn AI with Python ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn AI with Python และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน
ตัวเข้ารหัสอัตโนมัติคืออะไร
ตัวเข้ารหัสอัตโนมัติเรียนรู้การบีบอัดข้อมูลให้เป็นรหัสขนาดเล็ก แล้วสร้างข้อมูลนั้นกลับคืนมา ตัวเข้ารหัสอัตโนมัติมีสองส่วน ได้แก่ ตัวเข้ารหัสที่บีบอัดข้อมูล และตัวถอดรหัสที่สร้างข้อมูลขึ้นใหม่ การบีบอัดตรงกลางจะบังคับให้โมเดลเรียนรู้ว่าอะไรสำคัญ
import torch
import torch.nn as nnแนวคิดเรื่องคอขวด
ชั้นตรงกลางที่แคบเรียกว่าคอขวดหรือรหัสแฝง เมื่อบังคับให้ข้อมูลทั้งหมดไหลผ่านตัวเลขเพียงไม่กี่ตัว โครงข่ายจึงต้องทิ้งสัญญาณรบกวนและเก็บโครงสร้างสำคัญของข้อมูลไว้
การสร้างตัวเข้ารหัส
สำหรับรูปภาพขนาด 28x28 (784 พิกเซล) ตัวเข้ารหัสจะลดขนาดข้อมูลขาเข้าทีละขั้นจาก 784 เป็น 256 แล้วเป็นรหัสแฝงขนาด 64 มิติ แต่ละชั้น Linear จะตามด้วยความไม่เชิงเส้นแบบ ReLU
encoder = nn.Sequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Linear(256, 64)
)การสร้างตัวถอดรหัส
ตัวถอดรหัส เลียนแบบโครงสร้างของ ตัวเข้ารหัส โดยขยายรหัส 64 มิติกลับเป็นพิกเซล 784 ค่า ผลลัพธ์สุดท้ายใช้ Sigmoid เพื่อบีบค่าให้อยู่ในช่วง [0,1] ให้ตรงกับค่าพิกเซลที่ปรับมาตรฐานแล้ว
decoder = nn.Sequential(
nn.Linear(64, 256),
nn.ReLU(),
nn.Linear(256, 784),
nn.Sigmoid()
)ตัวเข้ารหัสอัตโนมัติทั้งระบบ
เชื่อมตัวเข้ารหัสและตัวถอดรหัสให้เป็นโมดูลเดียวกัน การส่งผ่านแบบ forward จะเข้ารหัสแล้วถอดรหัส จากนั้นคืนค่าการสร้างคืนที่มีรูปร่างเดียวกับข้อมูลนำเข้า
class AutoEncoder(nn.Module):
def __init__(self, enc, dec):
super().__init__()
self.enc, self.dec = enc, dec
def forward(self, x):
z = self.enc(x)
return self.dec(z)ค่าความสูญเสียจากการสร้างคืน (MSE)
เป้าหมายในการฝึกคือข้อมูลนำเข้าเอง ค่าความคลาดเคลื่อนกำลังสองเฉลี่ย จะวัดว่าการสร้างคืนแตกต่างจากพิกเซลดั้งเดิมมากเพียงใดทีละพิกเซล การลดค่านี้ทำให้แบบจำลองเรียนรู้การบีบอัดข้อมูลได้อย่างเที่ยงตรง
criterion = nn.MSELoss()
x_flat = x.view(x.size(0), -1)
recon = model(x_flat)
loss = criterion(recon, x_flat)การฝึกตัวเข้ารหัสอัตโนมัติ
การฝึกเป็นแบบไม่มีผู้สอน กล่าวคือไม่มีป้ายกำกับ มีเพียงข้อมูลนำเข้าเท่านั้น วงรอบการฝึกใช้ zero_grad, forward, backward, step ตามมาตรฐาน แต่ค่าความสูญเสียจะเปรียบเทียบผลลัพธ์กับข้อมูลนำเข้า
optimizer.zero_grad()
recon = model(x_flat)
loss = criterion(recon, x_flat)
loss.backward()
optimizer.step()พื้นที่แฝง
หลังการฝึก ตัวเข้ารหัสจะแปลงข้อมูลนำเข้าแต่ละรายการให้เป็นจุดหนึ่งใน พื้นที่แฝง ข้อมูลนำเข้าที่คล้ายกันจะอยู่ใกล้กัน ดังนั้นรหัส 64 มิตินี้จึงเป็นการแทนข้อมูลที่กระชับและเรียนรู้ได้จากข้อมูล
z = model.enc(x_flat)
print(z.shape) # [batch, 64]การแสดงภาพด้วย t-SNE
พื้นที่แฝง 64 มิติมองเห็นได้ยาก t-SNE จะฉายพื้นที่นี้ลงเป็น 2 มิติเพื่อใช้สร้างกราฟ กลุ่มที่ปรากฏในกราฟแสดงให้เห็นว่าตัวเข้ารหัสอัตโนมัติจัดกลุ่มรายการที่คล้ายกันไว้ด้วยกันโดยไม่เคยเห็นป้ายกำกับเลย
from sklearn.manifold import TSNE
codes = model.enc(all_data).detach().numpy()
proj = TSNE(n_components=2).fit_transform(codes)
# scatter plot proj colored by true labelการตรวจจับความผิดปกติ
ตัวเข้ารหัสอัตโนมัติที่ฝึกด้วยข้อมูล ปกติ จะสร้างข้อมูลเหล่านั้นคืนได้ดี แต่จะทำได้ไม่ดีเมื่อพบความผิดปกติที่ไม่เคยเห็นมาก่อน ค่าความผิดพลาดจากการสร้างคืนที่สูง จะบ่งชี้ข้อมูลนอกกลุ่ม ทำให้วิธีนี้เป็นตัวตรวจจับความผิดปกติแบบไม่มีผู้สอนที่มีประสิทธิภาพ
errors = ((model(data) - data) ** 2).mean(dim=1)
anomalies = errors > thresholdเหตุใดจึงต้องเรียนรู้การแทนข้อมูล
สิ่งสำคัญที่แท้จริงคือรหัสแฝง ซึ่งเป็นเวกเตอร์คุณลักษณะที่เรียนรู้ได้และสามารถนำไปใช้จัดกลุ่ม แสดงภาพ ตรวจจับความผิดปกติ หรือใช้เป็นข้อมูลนำเข้าสำหรับแบบจำลองอื่นได้ ทั้งหมดนี้เรียนรู้ได้โดยไม่ต้องใช้ป้ายกำกับ
ตรวจสอบความเข้าใจ
ทดสอบความเข้าใจเกี่ยวกับตัวเข้ารหัสอัตโนมัติ
สรุป: ตัวเข้ารหัสอัตโนมัติ
คุณได้สร้าง ตัวเข้ารหัส (784 ถึง 256 ถึง 64) และ ตัวถอดรหัส ที่มีโครงสร้างสะท้อนกัน แล้วฝึกด้วย ค่าความสูญเสียจากการสร้างคืนด้วย MSE โดยไม่ใช้ป้ายกำกับ คุณใช้รหัสแฝงเพื่อเรียนรู้การแทนข้อมูล แสดงรหัสนั้นด้วย t-SNE และตรวจจับความผิดปกติจากค่าความผิดพลาดในการสร้างคืนที่สูง
คำถามที่พบบ่อย
บทเรียน “ออโตเอนโคดเดอร์สำหรับการเรียนรู้การแทนค่า” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ออโตเอนโคดเดอร์สำหรับการเรียนรู้การแทนค่า” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn AI with Python ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ออโตเอนโคดเดอร์สำหรับการเรียนรู้การแทนค่า”
สถาปัตยกรรมตัวเข้ารหัส–ตัวถอดรหัส คอขวด ฟังก์ชันสูญเสียจากการสร้างกลับคืน และการประยุกต์ใช้ในการตรวจจับความผิดปกติ คุณปฏิบัติ Learn AI with Python ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn AI with Python หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn AI with Python บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “ออโตเอนโคดเดอร์สำหรับการเรียนรู้การแทนค่า” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Learn AI with Python นี้ได้ไหม
ได้ บทเรียน Learn AI with Python ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ออโตเอนโคดเดอร์สำหรับการเรียนรู้การแทนค่า
- ออโตเอนโคดเดอร์แบบแปรผัน (VAE)
- GAN: ตัวสร้างและตัวจำแนก
- GAN แบบมีเงื่อนไขและการถ่ายโอนสไตล์