Ini adalah artikel kedua tentang analisis dan studi bahan dari kompetisi untuk mencari kapal di laut. Tapi sekarang kita akan mempelajari sifat-sifat urutan pelatihan. Mari kita coba mencari informasi berlebih, redundansi dalam sumber data dan menghapusnya.
Artikel ini juga semata-mata hasil dari rasa ingin tahu dan ketertarikan kosong, tidak ada yang ditemui dalam praktik, dan untuk tugas-tugas praktis hampir tidak ada apa pun untuk copy-paste. Ini adalah studi kecil tentang sifat-sifat urutan pelatihan - alasan dan kode penulis disajikan, Anda dapat memeriksa / menambah / mengubah semuanya sendiri.
Kompetisi pencarian laut yang menakjubkan baru-baru ini berakhir. Airbus mengusulkan menganalisis citra satelit laut dengan dan tanpa kapal. Total 192555 gambar 768x768x3 - itu adalah 340 720 680 960 byte jika uint8 dan ini adalah sejumlah besar informasi dan ada kecurigaan yang tidak jelas bahwa tidak semua gambar diperlukan untuk melatih jaringan dan dalam begitu banyak informasi pengulangan dan redundansi jelas. Saat melatih suatu jaringan, merupakan kebiasaan untuk memisahkan beberapa data dan tidak menggunakannya dalam pelatihan, tetapi menggunakannya untuk memverifikasi kualitas pelatihan. Dan jika satu dan bagian yang sama dari laut jatuh ke dalam dua gambar yang berbeda dan satu gambar jatuh ke dalam urutan pelatihan dan yang lainnya ke dalam urutan verifikasi, maka verifikasi akan kehilangan artinya dan jaringan akan dilatih kembali, kami tidak akan memeriksa kemampuan jaringan untuk menggeneralisasi informasi, karena datanya sama. Pertarungan melawan fenomena ini membutuhkan banyak waktu dan upaya GPU peserta. Seperti biasa, pemenang dan pemenang hadiah tidak terburu-buru untuk menunjukkan kepada para penggemar mereka rahasia penguasaan dan menyusun kode, dan tidak ada cara untuk belajar dan mempelajarinya, jadi kami akan mengambil teorinya.
Pemeriksaan visual sederhana menunjukkan bahwa benar-benar ada terlalu banyak data, bentangan laut yang sama jatuh ke dalam gambar yang berbeda, lihat contohnya
Karena alasan inilah kami tidak tertarik pada data nyata, ada banyak ketergantungan palsu, koneksi yang tidak perlu kepada kami, markup yang buruk, dan kekurangan lainnya.
Pada
artikel pertama, kami melihat gambar dengan elips dan noise, dan kami akan terus mempelajarinya. Keuntungan dari pendekatan ini adalah bahwa jika Anda menemukan fitur menarik dari jaringan yang dilatih pada set gambar yang sewenang-wenang, tidak jelas apakah ini adalah properti jaringan atau properti dari set pelatihan. Parameter statistik urutan yang diambil dari dunia nyata tidak diketahui. Baru-baru ini, Grandmaster Pleskov Pavel
paske57 berbicara tentang bagaimana kadang-kadang mudah untuk memenangkan segmentasi / klasifikasi klasifikasi gambar jika baik untuk menggali data sendiri, misalnya, lihat foto metadata. Dan tidak ada jaminan bahwa dalam data nyata tidak ada dependensi seperti itu, tanpa sadar pergi. Oleh karena itu, untuk mempelajari sifat-sifat jaringan, kami mengambil gambar dengan elips dan persegi panjang, dan menentukan tempat dan warna serta parameter lainnya menggunakan generator bilangan acak dari komputer (yang memiliki generator pseudo-acak, yang memiliki generator berdasarkan algoritma non-digital lainnya dan sifat fisik zat tersebut, Tetapi kami tidak akan membahas ini di artikel ini).
Jadi, ambil
np.random.sample laut
() * 0,75 , kita tidak perlu gelombang, angin, pantai dan pola dan wajah tersembunyi lainnya. Kapal / elips juga akan dicat dengan warna yang sama, dan untuk membedakan laut dari kapal dan gangguan, tambahkan 0,25 ke laut atau kapal / jammer, dan mereka semua akan memiliki bentuk yang sama - elips dengan ukuran dan orientasi yang berbeda. Gangguan juga akan hanya persegi panjang dengan warna yang sama dengan elips - ini penting, informasi dan gangguan dengan warna yang sama dengan latar belakang kebisingan. Kami hanya akan membuat perubahan kecil pada pewarnaan dan kami akan menjalankan
np.random.sample () untuk setiap gambar dan untuk setiap elips / persegi panjang, mis. Baik latar belakang maupun warna elips / persegi panjang tidak diulang. Lebih lanjut dalam teks ada kode program untuk membuat gambar / topeng dan contoh dari sepuluh pasangan yang dipilih secara acak.
Ambil versi yang sangat umum dari jaringan (Anda dapat mengambil jaringan favorit Anda) dan mencoba mengidentifikasi dan menunjukkan redundansi dari urutan pelatihan besar, untuk mendapatkan setidaknya beberapa jenis karakteristik redundansi kualitatif dan kuantitatif. Yaitu penulis percaya bahwa banyak gigabytes urutan pelatihan pada dasarnya berlebihan, ada banyak gambar yang tidak perlu, tidak perlu memuat lusinan GPU dan melakukan perhitungan yang tidak perlu. Redundansi data dimanifestasikan tidak hanya dan tidak begitu banyak dalam kenyataan bahwa bagian yang sama ditampilkan dalam gambar yang berbeda, tetapi juga dalam redundansi informasi dalam data ini. Data mungkin berlebihan bahkan jika tidak diulangi dengan tepat. Harap dicatat bahwa ini bukan definisi informasi dan kecukupan atau redundansi yang ketat. Kami hanya ingin mengetahui berapa banyak Anda dapat mengurangi kereta, gambar apa yang dapat Anda buang dari urutan pelatihan, dan berapa banyak gambar yang cukup untuk pelatihan yang dapat diterima (kami akan mengatur sendiri keakuratannya dalam program). Ini adalah program khusus, dataset tertentu, dan ada kemungkinan bahwa pada elips dengan segitiga, sebagai penghalang, tidak ada yang akan bekerja serta pada elips dengan persegi panjang (hipotesis saya adalah bahwa semuanya akan sama dan sama. Tapi kami tidak memeriksanya sekarang. , kami tidak melakukan analisis dan tidak membuktikan teorema).
Jadi, diberikan:
- urutan pembelajaran pasangan gambar / topeng. Kami dapat menghasilkan sejumlah pasang gambar / topeng. Saya akan langsung menjawab pertanyaan - mengapa warna dan latar belakangnya acak? Saya akan menjawab secara sederhana, singkat, jelas dan komprehensif bahwa saya sangat menyukainya, entitas tambahan dalam bentuk perbatasan tidak diperlukan;
- jaringannya biasa, U-net biasa, sedikit dimodifikasi dan banyak digunakan untuk segmentasi.
Gagasan untuk menguji:
- dalam urutan yang dibangun, seperti dalam tugas nyata, gigabyte data digunakan. Penulis percaya bahwa ukuran urutan pelatihan tidak begitu kritis dan tidak boleh ada banyak data, tetapi mereka harus mengandung "banyak" informasi. Jumlah seperti itu, sepuluh ribu pasang gambar / topeng, tidak perlu dan jaringan akan belajar dari jumlah data yang jauh lebih kecil.
Mari kita mulai, pilih 10.000 pasangan dan pertimbangkan dengan cermat. Kami akan memeras semua air, semua bit yang tidak perlu dari urutan pelatihan ini dan menggunakan dan mempraktikkan semua residu kering.
Anda sekarang dapat memeriksa intuisi Anda dan mengasumsikan berapa banyak pasangan dari 10.000 cukup untuk melatih dan memprediksi yang lain, tetapi juga menciptakan urutan 10.000 pasangan dengan akurasi lebih dari 0,98. Tulis di selembar kertas, setelah membandingkan.
Untuk penggunaan praktis, harap perhatikan bahwa baik laut dan kapal dengan gangguan dipilih secara buatan, ini adalah
np.random.sample () .
Kami memuat perpustakaan, kami menentukan ukuran array gambarimport numpy as np import matplotlib.pyplot as plt %matplotlib inline import math from tqdm import tqdm from skimage.draw import ellipse, polygon from keras import Model from keras.optimizers import Adam from keras.layers import Input,Conv2D,Conv2DTranspose,MaxPooling2D,concatenate from keras.layers import BatchNormalization,Activation,Add,Dropout from keras.losses import binary_crossentropy from keras import backend as K import tensorflow as tf import keras as keras w_size = 128 train_num = 10000 radius_min = 10 radius_max = 20
menentukan fungsi kerugian dan akurasi def dice_coef(y_true, y_pred): y_true_f = K.flatten(y_true) y_pred = K.cast(y_pred, 'float32') y_pred_f = K.cast(K.greater(K.flatten(y_pred), 0.5), 'float32') intersection = y_true_f * y_pred_f score = 2. * K.sum(intersection) / (K.sum(y_true_f) + K.sum(y_pred_f)) return score def dice_loss(y_true, y_pred): smooth = 1. y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) intersection = y_true_f * y_pred_f score = (2. * K.sum(intersection) + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth) return 1. - score def bce_dice_loss(y_true, y_pred): return binary_crossentropy(y_true, y_pred) + dice_loss(y_true, y_pred) def get_iou_vector(A, B):
Kami akan menggunakan metrik dari
artikel pertama . Biarkan saya mengingatkan pembaca bahwa kami akan memprediksi topeng piksel - ini adalah "laut" atau "kapal" dan mengevaluasi kebenaran atau kepalsuan prediksi. Yaitu Keempat opsi berikut dimungkinkan - kami memperkirakan dengan benar bahwa suatu piksel adalah "laut", dengan benar memperkirakan bahwa suatu piksel adalah "kapal" atau membuat kesalahan dalam memprediksi "laut" atau "kapal". Jadi, untuk semua gambar dan semua piksel, kami memperkirakan jumlah keempat opsi dan menghitung hasilnya - ini akan menjadi hasil dari jaringan. Dan semakin sedikit prediksi yang salah dan semakin benar, semakin akurat hasilnya dan semakin baik jaringannya.
Dan untuk penelitian, mari kita ambil pilihan dari U-net yang dipelajari dengan baik, yang merupakan jaringan yang sangat baik untuk segmentasi gambar. Pilihan U-net yang tidak terlalu klasik dipilih, tetapi idenya sama, jaringan melakukan operasi yang sangat sederhana dengan gambar - ini mengurangi dimensi gambar dengan beberapa transformasi langkah demi langkah dan kemudian mencoba untuk memulihkan topeng dari gambar yang dikompresi. Yaitu dimensi gambar dalam kasus kami dibawa ke 16x16 dan kemudian kami mencoba untuk mengembalikan topeng menggunakan data dari semua lapisan kompresi sebelumnya.
Kami memeriksa jaringan sebagai "kotak hitam", kami tidak akan melihat apa yang terjadi dengan jaringan di dalamnya, bagaimana bobot berubah dan bagaimana gradien dipilih - ini adalah topik penelitian lain.
U-net dengan blok def convolution_block(x, filters, size, strides=(1,1), padding='same', activation=True): x = Conv2D(filters, size, strides=strides, padding=padding)(x) x = BatchNormalization()(x) if activation == True: x = Activation('relu')(x) return x def residual_block(blockInput, num_filters=16): x = Activation('relu')(blockInput) x = BatchNormalization()(x) x = convolution_block(x, num_filters, (3,3) ) x = convolution_block(x, num_filters, (3,3), activation=False) x = Add()([x, blockInput]) return x
Fungsi menghasilkan pasangan gambar / topeng. Pada gambar berwarna 128x128 diisi dengan noise acak dengan yang dipilih secara acak dari dua rentang, baik 0,0 ... 0,75 atau 0,25..1.0. Tempatkan elips yang diorientasikan secara acak dalam gambar dan letakkan kotak di tempat yang sama. Kami memeriksa bahwa mereka tidak berpotongan dan, jika perlu, geser persegi panjang ke samping. Setiap kali kami menghitung ulang nilai-nilai pewarnaan laut / perahu. Untuk kesederhanaan, kami akan menempatkan topeng dengan gambar dalam satu array, sebagai warna keempat, yaitu Merah.Green.Blue.Mask, lebih mudah.
def next_pair(): img_l = (np.random.sample((w_size, w_size, 3))* 0.75).astype('float32') img_h = (np.random.sample((w_size, w_size, 3))* 0.75 + 0.25).astype('float32') img = np.zeros((w_size, w_size, 4), dtype='float') p = np.random.sample() - 0.5 r = np.random.sample()*(w_size-2*radius_max) + radius_max c = np.random.sample()*(w_size-2*radius_max) + radius_max r_radius = np.random.sample()*(radius_max-radius_min) + radius_min c_radius = np.random.sample()*(radius_max-radius_min) + radius_min rot = np.random.sample()*360 rr, cc = ellipse( r, c, r_radius, c_radius, rotation=np.deg2rad(rot), shape=img_l.shape ) p1 = np.rint(np.random.sample()* (w_size-2*radius_max) + radius_max) p2 = np.rint(np.random.sample()* (w_size-2*radius_max) + radius_max) p3 = np.rint(np.random.sample()* (2*radius_max - radius_min) + radius_min) p4 = np.rint(np.random.sample()* (2*radius_max - radius_min) + radius_min) poly = np.array(( (p1, p2), (p1, p2+p4), (p1+p3, p2+p4), (p1+p3, p2), (p1, p2), )) rr_p, cc_p = polygon(poly[:, 0], poly[:, 1], img_l.shape) in_sc_rr = list(set(rr) & set(rr_p)) in_sc_cc = list(set(cc) & set(cc_p)) if len(in_sc_rr) > 0 and len(in_sc_cc) > 0: if len(in_sc_rr) > 0: _delta_rr = np.max(in_sc_rr) - np.min(in_sc_rr) + 1 if np.mean(rr_p) > np.mean(in_sc_rr): poly[:,0] += _delta_rr else: poly[:,0] -= _delta_rr if len(in_sc_cc) > 0: _delta_cc = np.max(in_sc_cc) - np.min(in_sc_cc) + 1 if np.mean(cc_p) > np.mean(in_sc_cc): poly[:,1] += _delta_cc else: poly[:,1] -= _delta_cc rr_p, cc_p = polygon(poly[:, 0], poly[:, 1], img_l.shape) if p > 0: img[:,:,:3] = img_l.copy() img[rr, cc,:3] = img_h[rr, cc] img[rr_p, cc_p,:3] = img_h[rr_p, cc_p] else: img[:,:,:3] = img_h.copy() img[rr, cc,:3] = img_l[rr, cc] img[rr_p, cc_p,:3] = img_l[rr_p, cc_p] img[:,:,3] = 0. img[rr, cc,3] = 1. return img
Mari kita buat urutan latihan pasangan, lihat acak 10
_txy = [next_pair() for idx in range(train_num)] f_imgs = np.array(_txy)[:,:,:,:3].reshape(-1,w_size ,w_size ,3) f_msks = np.array(_txy)[:,:,:,3:].reshape(-1,w_size ,w_size ,1) del(_txy)
Langkah pertama. Mari kita coba berlatih dengan set minimal
Langkah pertama percobaan kami sederhana, kami mencoba melatih jaringan untuk memprediksi hanya 11 gambar pertama.
batch_size = 10 val_len = 11 precision = 0.85 m0_select = np.zeros((f_imgs.shape[0]), dtype='int') for k in range(val_len): m0_select[k] = 1 t = tqdm() while True: fit = model.fit(f_imgs[m0_select>0], f_msks[m0_select>0], batch_size=batch_size, epochs=1, verbose=0 ) current_accu = fit.history['my_iou_metric'][0] current_loss = fit.history['loss'][0] t.set_description("accuracy {0:6.4f} loss {1:6.4f} ".\ format(current_accu, current_loss)) t.update(1) if current_accu > precision: break t.close()
accuracy 0.8636 loss 0.0666 : : 47it [00:29, 5.82it/s]Kami memilih 11 pertama dari urutan awal dan melatih jaringan pada mereka. Sekarang tidak masalah apakah jaringan menghafal gambar-gambar ini secara khusus atau meringkas, yang utama adalah bahwa ia dapat mengenali 11 gambar ini seperti yang kita butuhkan. Bergantung pada dataset dan akurasi yang dipilih, pelatihan jaringan dapat bertahan lama, sangat lama. Tetapi kami hanya memiliki beberapa iterasi. Saya ulangi bahwa itu tidak penting bagi kami sekarang bagaimana dan apa yang dipelajari atau dipelajari jaringan, yang utama adalah bahwa ia telah mencapai akurasi prediksi yang ditetapkan.
Sekarang mulailah eksperimen utama
Kami akan mengambil pasangan gambar / topeng baru dari urutan yang dibuat dan akan mencoba untuk memprediksi mereka dengan jaringan terlatih pada urutan yang sudah dipilih. Pada awalnya, itu hanya 11 pasang gambar / topeng dan jaringannya dilatih, mungkin tidak terlalu benar. Jika dalam pasangan baru topeng dari gambar diprediksi dengan akurasi yang dapat diterima, maka kami membuang pasangan ini, itu tidak memiliki informasi baru untuk jaringan, ia sudah tahu dan dapat menghitung topeng dari gambar ini. Jika akurasi prediksi tidak mencukupi, maka kami menambahkan gambar ini dengan mask ke urutan kami dan mulai melatih jaringan sampai hasil akurasi yang dapat diterima tercapai pada urutan yang dipilih. Yaitu Gambar ini berisi informasi baru dan kami menambahkannya ke urutan pelatihan kami dan mengekstrak informasi yang terkandung di dalamnya dengan pelatihan.
batch_size = 50 t_batch_size = 1024 raw_len = val_len t = tqdm(-1) id_train = 0
Accuracy 0.9830 loss 0.0287 selected img 271 tested img 9949 : : 1563it [14:16, 1.01it/s]
Di sini akurasi digunakan dalam arti "akurasi", dan bukan sebagai metrik keras standar, dan subrutin "my_iou_metric" digunakan untuk menghitung akurasi. Sangat menarik untuk mengamati akurasi dan jumlah gambar yang diselidiki dan ditambahkan. Pada awalnya, hampir semua pasangan gambar / topeng ditambahkan oleh jaringan, dan sekitar 70 pasangan mulai membuangnya. Lebih dekat ke 8000 melempar hampir semua pasangan.
Periksa pasangan acak secara visual yang dipilih oleh jaringan:
fig, axes = plt.subplots(2, 10, figsize=(20, 5)) t_imgs = f_imgs[m0_select>0] t_msks = f_msks[m0_select>0] for k in range(10): kk = np.random.randint(t_msks.shape[0]) axes[0,k].set_axis_off() axes[0,k].imshow(t_imgs[kk]) axes[1,k].set_axis_off() axes[1,k].imshow(t_msks[kk].squeeze())
Tidak ada yang istimewa atau supranatural:
Ini adalah pasangan yang dipilih oleh jaringan pada berbagai tahap pelatihan. Ketika jaringan menerima pasangan input dari urutan ini, itu tidak bisa menghitung topeng dengan akurasi yang ditentukan dan pasangan ini termasuk dalam urutan pelatihan. Tapi tidak ada yang istimewa, gambar biasa.
Verifikasi hasil dan akurasi
Mari kita periksa kualitas program pelatihan jaringan, pastikan bahwa kualitasnya tidak secara signifikan tergantung pada urutan urutan awal, untuk yang mana kita mencampur urutan awal pasangan gambar / topeng, ambil 11 lainnya pertama dengan cara yang sama, latih jaringan dan potong kelebihannya.
sh = np.arange(train_num) np.random.shuffle(sh) f0_imgs = f_imgs[sh] f0_msks = f_msks[sh] model.compile(loss=bce_dice_loss, optimizer="adam", metrics=[my_iou_metric]) model.summary()
Kode Latihan batch_size = 10 val_len = 11 precision = 0.85 m0_select = np.zeros((f_imgs.shape[0]), dtype='int') for k in range(val_len): m0_select[k] = 1 t = tqdm() while True: fit = model.fit(f0_imgs[m0_select>0], f0_msks[m0_select>0], batch_size=batch_size, epochs=1, verbose=0 ) current_accu = fit.history['my_iou_metric'][0] current_loss = fit.history['loss'][0] t.set_description("accuracy {0:6.4f} loss {1:6.4f} ".\ format(current_accu, current_loss)) t.update(1) if current_accu > precision: break t.close()
accuracy 0.8636 loss 0.0710 : : 249it [01:03, 5.90it/s]
batch_size = 50 t_batch_size = 1024 raw_len = val_len t = tqdm(-1) id_train = 0
Accuracy 0.9890 loss 0.0224 selected img 408 tested img 9456 : : 1061it [21:13, 2.16s/it]
Hasilnya tidak tergantung secara signifikan pada urutan pasangan dari urutan asli. Dalam kasus sebelumnya, jaringan memilih 271, sekarang 408, jika Anda mencampurnya, jaringan dapat memilih jumlah yang berbeda. Kami tidak akan memeriksa, penulis percaya bahwa akan selalu ada kurang dari 10.000.
Periksa keakuratan prediksi jaringan pada urutan independen baru
_txy = [next_pair() for idx in range(train_num)] test_imgs = np.array(_txy)[:,:,:,:3].reshape(-1,w_size ,w_size ,3) test_msks = np.array(_txy)[:,:,:,3:].reshape(-1,w_size ,w_size ,1) del(_txy) test_pred_0 = model.predict(test_imgs) t_val_0 = get_iou_vector(test_msks,test_pred_0) t_val_0
0.9927799999999938
Ringkasan dan Kesimpulan
Jadi, kami dapat memeras kurang dari tiga atau empat ratus yang dipilih dari 10.000 pasangan, akurasi prediksi adalah 0,99278, kami mengambil semua pasangan yang mengandung setidaknya beberapa informasi yang berguna dan membuang sisanya. Kami tidak menyelaraskan parameter statistik dari urutan pelatihan, menambah pengulangan informasi, dll. dan sama sekali tidak menggunakan metode statistik. Kami mengambil gambar yang berisi informasi yang masih tidak diketahui oleh jaringan dan memeras semuanya menjadi bobot jaringan. Jika jaringan memenuhi setidaknya satu gambar "misterius", maka itu akan menggunakan semuanya dalam bisnis.
Sebanyak 271 pasangan gambar / topeng berisi informasi untuk memprediksi 10.000 pasangan dengan akurasi setidaknya 0,8075 pada setiap pasangan, yaitu, akurasi total atas seluruh urutan lebih tinggi, tetapi dalam setiap gambar tidak kurang dari 0,8075, kami tidak memiliki gambar yang tidak kami miliki. kita bisa memprediksi dan kita tahu batas bawah prediksi ini. (di sini, tentu saja, penulis menyombongkan diri, bagaimana tanpa ini, artikel tidak memverifikasi pernyataan ini, sekitar 0,8075, atau bukti, tetapi kemungkinan besar ini benar)
Untuk melatih jaringan, tidak perlu memuat GPU dengan semua yang ada di tangan, Anda dapat menarik inti kereta dan melatih jaringan di atasnya sebagai awal pelatihan. Saat Anda mendapatkan gambar baru, Anda dapat secara manual menandai gambar-gambar yang tidak dapat diprediksi oleh jaringan dan menambahkannya ke inti kereta, melatih kembali jaringan untuk memeras semua informasi dari gambar-gambar baru. Dan tidak perlu untuk memilih urutan validasi, kita dapat mengasumsikan bahwa segala sesuatu yang lain, kecuali yang dipilih, adalah urutan validasi.
Satu lagi secara matematis tidak ketat, tetapi komentar yang sangat penting. Aman untuk mengatakan bahwa setiap pasangan gambar / topeng berisi "banyak" informasi. Setiap pasangan berisi "banyak" informasi, meskipun di sebagian besar gambar / topeng memasangkan informasi yang berpotongan atau berulang. Masing-masing pasangan gambar / topeng 271 berisi informasi yang penting untuk prediksi, dan pasangan ini tidak dapat dibuang begitu saja.
Nah, komentar kecil tentang lipatan, banyak ahli dan penipu membagi urutan pelatihan menjadi lipatan dan melatihnya secara terpisah, menggabungkan hasil yang diperoleh dengan cara yang lebih rumit. Dalam kasus kami, Anda juga dapat membaginya menjadi lipatan, jika Anda menghapus 271 pasangan dari 10.000, maka Anda dapat membuat urutan root baru di yang tersisa, yang jelas akan memberikan hasil yang berbeda tetapi sebanding. Anda cukup mencampur dan mengambil 11 inisial lainnya, seperti ditunjukkan di atas.
Artikel ini menyediakan kode dan menunjukkan cara melatih U-net untuk segmentasi gambar. Ini adalah contoh konkret, dan dalam artikel yang sengaja tidak ada generalisasi ke jaringan lain, ke urutan lain, tidak ada matematika yang ketat, semuanya diceritakan dan ditampilkan "dengan jari". Hanya contoh bagaimana Anda dapat mempelajari jaringan sambil mencapai akurasi yang dapat diterima.