Dalam posting ini, Anda akan belajar bagaimana mengimplementasikan arsitektur UNET di TensorFlow menggunakan Keras API. Postingan ini membantu Anda mempelajari UNET, dan cara menggunakannya untuk penelitian Anda.

UNET adalah salah satu arsitektur segmentasi semantik yang paling populer. Olaf Ronneberger dkk. mengembangkan jaringan ini untuk Segmentasi Citra Biomedis pada tahun 2015.

Untuk mengetahui lebih lanjut, baca artikel: Apa itu UNET?

Impor

Di bagian pertama posting ini, Anda perlu mengimpor semua kelas yang diperlukan untuk implementasi arsitektur UNET.

from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation, MaxPool2D, Conv2DTranspose, Concatenate, Input
from tensorflow.keras.models import Model

Untuk menghubungkan lapisan masukan dan keluaran dari arsitektur UNET, kami mengimpor kelas Model .

Blok Konvolusi

Seluruh arsitektur UNET terdiri dari penggunaan berulang dari dua konvolusi 3 x 3, masing-masing diikuti oleh aktivasi ULT.

Di sini, kami menulis kode untuk membangun blok konvolusi.

def conv_block(input, num_filters):
    x = Conv2D(num_filters, 3, padding="same")(input)
    x = BatchNormalization()(x)
    x = Activation("relu")(x)

    x = Conv2D(num_filters, 3, padding="same")(x)
    x = BatchNormalization()(x)
    x = Activation("relu")(x)

    return x

1. masukan: The masukan mewakili peta fitur dari blok sebelumnya.
2. num_filters: The num_filters mengacu pada jumlah saluran fitur output untuk lapisan convolutional hadir dalam conv_block fungsi.

Normalisasi batch membantu membuat jaringan neural dalam lebih cepat dan lebih stabil dengan menormalkan lapisan masukan.

Blok Encoder

def encoder_block(input, num_filters):
    x = conv_block(input, num_filters)
    p = MaxPool2D((2, 2))(x)
    return x, p

1. masukan: The masukan mewakili peta fitur dari blok sebelumnya.
2. num_filters: The num_filters mengacu pada jumlah saluran fitur output.

1. x: Ini mewakili keluaran dari conv_block. Ini bertindak sebagai koneksi lewati untuk blok decoder yang sesuai.
2. p: Ini mewakili peta fitur yang dikurangi yang diteruskan ke blok berikutnya sebagai input.

Blok Dekoder

def decoder_block(input, skip_features, num_filters):
    x = Conv2DTranspose(num_filters, (2, 2), strides=2, padding="same")(input)
    x = Concatenate()([x, skip_features])
    x = conv_block(x, num_filters)
    return x

1. masukan: The masukan mewakili peta fitur dari blok sebelumnya.
2. skip_features: skip_features mewakili peta fitur dari blok encoder yang diambil melalui koneksi skip.
3. num_filters: num_filters mewakili jumlah saluran fitur keluaran.

Jika ukuran input (16 x 16 x 32) dan num_filters 64 maka output dari konvolusi transpose adalah (32 x 32 x 64).

Selanjutnya, kami menggabungkan peta fitur yang disubsampelkan dengan peta fitur lewati koneksi. Koneksi lewati ini membawa peta fitur dari lapisan sebelumnya yang membantu jaringan untuk menghasilkan peta fitur semantik yang lebih baik.

Setelah penggabungan, sebuah conv_block digunakan.

Hingga saat ini, kami telah mempelajari encoder dan blok decoder dari arsitektur UNET. Sekarang, kami mulai membangun arsitektur UNET yang lengkap.

Arsitektur UNET

def build_unet(input_shape):
    inputs = Input(input_shape)

    s1, p1 = encoder_block(inputs, 64)
    s2, p2 = encoder_block(p1, 128)
    s3, p3 = encoder_block(p2, 256)
    s4, p4 = encoder_block(p3, 512)

    b1 = conv_block(p4, 1024)

    d1 = decoder_block(b1, s4, 512)
    d2 = decoder_block(d1, s3, 256)
    d3 = decoder_block(d2, s2, 128)
    d4 = decoder_block(d3, s1, 64)

    outputs = Conv2D(1, 1, padding="same", activation="sigmoid")(d4)

    model = Model(inputs, outputs, name="U-Net")
    return model

Fungsi build_unet mengembalikan objek Model , yang berisi semua lapisan.

inputs = Input(input_shape)

s1, p1 = encoder_block(inputs, 64) 
s2, p2 = encoder_block(p1, 128) 
s3, p3 = encoder_block(p2, 256) 
s4, p4 = encoder_block(p3, 512)

b1 = conv_block(p4, 1024)

d1 = decoder_block(b1, s4, 512) 
d2 = decoder_block(d1, s3, 256) 
d3 = decoder_block(d2, s2, 128) 
d4 = decoder_block(d3, s1, 64)

outputs = Conv2D(1, 1, padding="same", activation="sigmoid")(d4)

Untuk segmentasi biner, kami menggunakan 1 saluran fitur keluaran dengan aktivasi sigmoid. Sedangkan pada segmentasi multikelas, kami menggunakan jumlah kelas sebagai saluran fitur keluaran dengan fungsi aktivasi softmax.

model = Model(inputs, outputs, name="U-Net") 
return model

Jalankan UNET

if __name__ == "__main__":
    input_shape = (512, 512, 3)
    model = build_unet(input_shape)
    model.summary()

Berikut adalah ringkasan dari arsitektur UNET.

Awalnya diterbitkan di https://idiotdeveloper.com pada 15 Februari 2021.