Cara Menghasilkan Gambar menggunakan Autoencoder

Anda tahu apa yang keren? Jika kita tidak memerlukan semua data berlabel tersebut untuk melatih model kita. Maksud saya, memberi label dan mengkategorikan data membutuhkan terlalu banyak pekerjaan. Sayangnya, sebagian besar model yang ada mulai dari mesin vektor dukungan hingga jaringan saraf konvolusional tidak dapat dilatih tanpanya.

Kecuali sekelompok kecil algoritma yang mereka bisa. Penasaran? Itu disebut Pembelajaran Tanpa Pengawasan. Pembelajaran Tanpa Pengawasan menyimpulkan sendiri suatu fungsi dari data yang tidak berlabel. Algoritme tanpa pengawasan yang paling terkenal adalah K-Means, yang telah digunakan secara luas untuk mengelompokkan data ke dalam kelompok dan PCA, yang merupakan solusi tepat untuk pengurangan dimensi. K-Means dan PCA mungkin adalah dua algoritma pembelajaran mesin terbaik yang pernah dibuat. Dan yang membuat mereka lebih baik adalah kesederhanaannya. Maksud saya, jika Anda memahaminya, Anda akan berpikir: “Mengapa saya tidak memikirkannya lebih awal?”

Pertanyaan berikutnya yang muncul di benak kita adalah: “Apakah ada jaringan saraf tanpa pengawasan?”. Anda mungkin tahu jawabannya dari judul postingan.

Pembuat enkode otomatis.

Untuk pemahaman yang lebih baik tentang autoencoder, saya akan menyajikan beberapa kode beserta penjelasannya. Perhatikan bahwa kita akan menggunakan Pytorch untuk membangun dan melatih model kita.

import torch
from torch import nn, optim
from torch.autograd import Variable
from torch.nn import functional as F

Autoencoder adalah jaringan saraf sederhana yang keluarannya adalah masukannya. Sesederhana itu. Tujuan mereka adalah mempelajari cara merekonstruksi data masukan. Tapi apa manfaatnya? Triknya adalah strukturnya. Bagian pertama dari jaringan inilah yang kami sebut sebagai Encoder. Ia menerima masukan dan mengkodekannya dalam ruang laten dari dimensi yang lebih rendah. Bagian kedua (Decoder) mengambil vektor itu dan mendekodekannya untuk menghasilkan masukan asli.

Jaringan Neural Autoencoder untuk Koreksi Outlier pada Identifikasi Biometrik Berbasis EKG

Vektor laten di tengah adalah yang kita inginkan, karena a terkompresi
representasi masukan. Dan aplikasinya banyak sekali seperti :

• Kompresi

• Pengurangan Dimensi

Selain itu, jelas bahwa kita dapat menerapkannya untuk mereproduksi data yang sama tetapi sedikit berbeda atau bahkan lebih baik. Contohnya adalah:

• Penolakan Data: Beri mereka gambar yang berisik dan latih mereka untuk mengeluarkan gambar yang sama tetapi tanpa noise

• Augmentasi data pelatihan

• Deteksi Anomali: Latih mereka dalam satu kelas sehingga setiap anomali menghasilkan kesalahan rekonstruksi yang besar.

Namun autoencoder menghadapi beberapa masalah yang sama seperti kebanyakan jaringan neural. Mereka cenderung mengenakan pakaian yang berlebihan dan mengalami masalah gradien yang hilang. Apakah ada solusinya?

Autoencoder Variasi (VAE)

Autoencoder variasional adalah upaya yang cukup bagus dan elegan. Ini pada dasarnya menambah keacakan tetapi tidak persis.

Mari kita jelaskan lebih lanjut. Autoencoder variasional dilatih untuk mempelajari distribusi probabilitas yang memodelkan data masukan dan bukan fungsi yang memetakan masukan dan keluaran. Lalu sampel poin dari distribusi ini dan memasukkannya ke decoder untuk menghasilkan sampel data masukan baru. Tapi tunggu sebentar. Ketika saya mendengar tentang distribusi probabilitas, hanya satu hal yang terlintas dalam pikiran saya: Bayes. Dan ya, aturan Bayesian sekali lagi menjadi prinsip utama. Ngomong-ngomong, saya tidak bermaksud melebih-lebihkan, tapi rumus Bayes adalah persamaan terbaik yang pernah dibuat. Dan saya tidak bercanda. Itu ada dimana-mana. Jika Anda tidak tahu apa itu, silakan mencarinya. Tinggalkan artikel itu dan pelajari apa itu Bayes. aku akan memaafkanmu.

Kembali ke autoencoder variasional. Saya pikir gambar berikut menjelaskan segalanya:

Sintesis Tekstur dengan Auto-Encoder Variasi Berulang

Itu dia. Jaringan saraf stokastik. Sebelum kita membuat contoh kita sendiri yang menghasilkan gambar baru, ada baiknya kita membahas beberapa detail lebih lanjut.

Salah satu aspek kunci VAE adalah fungsi kerugian. Paling umum, ini terdiri dari dua komponen. Kerugian rekonstruksi mengukur seberapa berbeda data yang direkonstruksi dari data asli (misalnya biner lintas entropi). Itu Divergensi KL mencoba mengatur proses dan menjaga data yang direkonstruksi seberagam mungkin.

def loss_function(recon_x, x, mu, logvar) -> Variable:
    BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784))
    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    KLD /= BATCH_SIZE * 784
    return BCE + KLD

Aspek penting lainnya adalah cara melatih model. Kesulitan terjadi karena variabelnya bersifat deterministik tetapi penurunan acak dan gradien biasanya tidak bekerja seperti itu. Untuk mengatasinya, kami menggunakan reparameterisasi. Vektor laten (z) akan sama dengan mean yang dipelajari (μ) dari distribusi kita ditambah deviasi standar yang dipelajari (σ) dikali epsilon (ε), di mana ε mengikuti distribusi normal. Kami melakukan parameterisasi ulang sampel sehingga keacakan tidak bergantung pada parameter.

def reparameterize(self, mu: Variable, logvar: Variable) -> Variable:
        if self.training:
            std = logvar.mul(0.5).exp_()  
            eps = Variable(std.data.new(std.size()).normal_())
            return eps.mul(std).add_(mu)
        else:
            return mu

Pembuatan Gambar dengan AutoEncoder

Dalam contoh kita, kita akan mencoba menghasilkan gambar baru menggunakan encoder otomatis variasional. Kami akan menggunakan kumpulan data MNIST dan gambar yang direkonstruksi akan berupa angka numerik tulisan tangan. Seperti yang sudah saya katakan, saya menggunakan Pytorch sebagai kerangka kerja, tanpa alasan tertentu, selain sosialisasi. Pertama, kita harus mendefinisikan layer kita.

def __init__(self):
        super(VAE, self).__init__()
        self.fc1 = nn.Linear(784, 400)
        self.relu = nn.ReLU()
        self.fc21 = nn.Linear(400, 20)  
        self.fc22 = nn.Linear(400, 20)  
        self.fc3 = nn.Linear(20, 400)
        self.fc4 = nn.Linear(400, 784)
        self.sigmoid = nn.Sigmoid()

Seperti yang Anda lihat, kita akan menggunakan jaringan yang sangat sederhana hanya dengan lapisan Padat (Linear dalam kasus pytorch). Langkah selanjutnya adalah membangun fungsi yang menjalankan encoder dan decoder.

def encode(self, x: Variable) -> (Variable, Variable):
        h1 = self.relu(self.fc1(x))
        return self.fc21(h1), self.fc22(h1)
 def decode(self, z: Variable) -> Variable:
        h3 = self.relu(self.fc3(z))
        return self.sigmoid(self.fc4(h3))
def forward(self, x: Variable) -> (Variable, Variable, Variable):
    mu, logvar = self.encode(x.view(-1, 784))
    z = self.reparameterize(mu, logvar)
    return self.decode(z), mu, logvar

Itu hanya beberapa baris kode python. Bukan masalah besar. Akhirnya kita bisa melatih model kita dan melihat gambar yang kita hasilkan.

Pengingat cepat: Pytorch memiliki grafik dinamis berbeda dengan tensorflow, yang berarti kode berjalan dengan cepat. Tidak perlu membuat grafik lalu mengkompilasi dan mengeksekusinya, Tensorflow baru-baru ini memperkenalkan fungsionalitas di atas dengan mode eksekusi yang bersemangat.

optimizer = optim.Adam(model.parameters(), lr=1e-3)
def train(epoch):
    model.train()
    train_loss = 0
    for batch_idx, (data, _) in enumerate(train_loader):
        data = Variable(data)
        optimizer.zero_grad()
        recon_batch, mu, logvar = model(data)
        loss = loss_function(recon_batch, data, mu, logvar)
        loss.backward()
        train_loss += loss.data(0)
        optimizer.step()
def test(epoch):
    model.eval()
    test_loss = 0
    for i, (data, _) in enumerate(test_loader):
        data = Variable(data, volatile=True)
        recon_batch, mu, logvar = model(data)
        test_loss += loss_function(recon_batch, data, mu, logvar).data(0)
for epoch in range(1, EPOCHS + 1):
    train(epoch)
    test(epoch)

Ketika pelatihan selesai, kami menjalankan fungsi pengujian untuk memeriksa seberapa baik model bekerja. Faktanya, ini cukup bagus dan gambar yang dibuat hampir identik dengan aslinya dan saya yakin tidak ada yang bisa membedakannya tanpa mengetahui keseluruhan cerita.

Gambar di bawah menunjukkan foto asli pada baris pertama dan hasil produksi pada baris kedua.

Cukup bagus, bukan?

Untuk detail selengkapnya tentang AutoEncoder, Anda harus memeriksa modul 5 kursus Pembelajaran Mendalam dengan Tensorflow oleh edX.

Sebelum kita menutup postingan ini, saya ingin memperkenalkan satu topik lagi. Seperti yang kita lihat, autoencoder variasional mampu menghasilkan gambar baru. Itu adalah perilaku klasik model generatif. Model generatif menghasilkan data baru. Sedangkan model diskriminatif adalah mengklasifikasikan atau mendiskriminasikan data yang ada ke dalam kelas atau kategori.

Untuk memparafrasekannya dengan beberapa istilah matematika: Model generatif mempelajari distribusi probabilitas gabungan p(x,y) sedangkan model diskriminatif mempelajari distribusi probabilitas bersyarat p(y|x).

Menurut pendapat saya, model generatif jauh lebih menarik karena membuka pintu bagi banyak kemungkinan mulai dari augmentasi data hingga simulasi kemungkinan keadaan di masa depan. Namun lebih lanjut tentang itu di beberapa posting berikutnya. Mungkin di postingan tentang jenis model generatif yang relatif baru yang disebut jaringan Generative Adversarial.

Sampai saat itu tiba, teruslah belajar AI.

* Pengungkapan: Harap dicatat bahwa beberapa tautan di atas mungkin merupakan tautan afiliasi, dan tanpa biaya tambahan kepada Anda, kami akan mendapat komisi jika Anda memutuskan untuk melakukan pembelian setelah mengklik.