RandAugment untuk Klasifikasi Gambar dengan Keras/TensorFlow

Augmentasi data, untuk waktu yang lama, telah berfungsi sebagai sarana untuk mengganti set data "statis" dengan varian yang diubah, memperkuat invarian Jaringan Saraf Konvolusi (CNN), dan biasanya mengarah pada kekokohan input.

Sementara augmentasi data dalam bentuk yang telah kami gunakan, itu mengkodekan kekurangan pengetahuan tentang varians translasi, yang penting untuk deteksi objek, segmentasi semantik dan instance, dll. – the invarian yang diberikan seringkali menguntungkan untuk model klasifikasi, dan dengan demikian, augmentasi lebih umum dan lebih agresif diterapkan pada model klasifikasi.

Jenis Augmentasi

Augmentasi mulai menjadi sangat sederhana – rotasi kecil, pembalikan horizontal dan vertikal, fluktuasi kontras atau kecerahan, dll. Dalam beberapa tahun terakhir, metode yang lebih rumit telah dirancang, termasuk Memotong (dropout spasial memperkenalkan kotak hitam secara acak di gambar input) dan campur aduk (mencampur sebagian gambar dan memperbarui proporsi label), dan kombinasinya – Potong Campuran. Metode augmentasi yang lebih baru sebenarnya memperhitungkan label, dan metode seperti CutMix mengubah proporsi label menjadi sama dengan proporsi gambar yang diambil oleh bagian dari setiap kelas yang dicampur.

Dengan bertambahnya daftar kemungkinan augmentasi, beberapa telah mulai menerapkannya secara acak (atau setidaknya beberapa subset dari mereka), dengan gagasan bahwa set augmentasi acak akan meningkatkan kekokohan model, dan mengganti set asli dengan yang jauh lebih besar. ruang gambar masukan. Di sinilah RandAugment tendangan masuk!

KerasCV dan RandAugment

KerasCV adalah paket terpisah, tetapi masih merupakan tambahan resmi untuk Keras, yang dikembangkan oleh tim Keras. Ini berarti bahwa ia mendapatkan jumlah polesan dan intuisi yang sama dari paket utama, tetapi juga terintegrasi dengan mulus dengan model Keras biasa, dan lapisannya. Satu-satunya perbedaan yang akan Anda perhatikan adalah menelepon keras_cv.layers... alih-alih keras.layers....

KerasCV masih dalam pengembangan pada saat penulisan, dan sudah menyertakan 27 lapisan prapemrosesan baru, RandAugment, CutMix, dan MixUp menjadi beberapa dari mereka. Mari kita lihat seperti apa penerapannya RandAugment ke gambar, dan bagaimana kita dapat melatih pengklasifikasi dengan dan tanpa augmentasi acak.

Pertama, instal keras_cv:

$ pip install keras_cv

Sekarang, mari impor TensorFlow, Keras dan KerasCV, bersama dengan kumpulan data TensorFlow untuk akses mudah ke Imagenette:

import tensorflow as tf
from tensorflow import keras
import keras_cv
import tensorflow_datasets as tfds

Mari kita memuat gambar dan menampilkannya dalam bentuk aslinya:

import matplotlib.pyplot as plt
import cv2

cat_img = cv2.cvtColor(cv2.imread('cat.jpg'), cv2.COLOR_BGR2RGB)
cat_img = cv2.resize(cat_img, (224, 224))
plt.imshow(cat_img)

Sekarang, mari melamar RandAugment untuk itu, beberapa kali dan lihat hasilnya:

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4,4,i+1)
    aug_img = keras_cv.layers.RandAugment(value_range=(0, 255))(cat_img)
    
    ax.imshow(aug_img.numpy().astype('int'))

Lapisan memiliki magnitude argumen, yang defaultnya adalah 0.5 dan dapat diubah untuk menambah atau mengurangi efek augmentasi:

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4,4,i+1)
    aug_img = keras_cv.layers.RandAugment(value_range=(0, 255), magnitude=0.1)(cat_img)
    ax.imshow(aug_img.numpy().astype('int'))

Ketika diatur ke nilai rendah seperti 0.1 – Anda akan melihat augmentasi yang jauh lebih tidak agresif:

Menjadi lapisan – dapat digunakan di dalam model atau di tf.data pipeline saat membuat kumpulan data. Ini membuat RandAugment cukup fleksibel! Argumen tambahan adalah augmentations_per_image dan rate argumen, yang bekerja sama.

Untuk 0...augmentations_per_image, lapisan menambahkan lapisan prapemrosesan acak ke saluran untuk diterapkan ke gambar. Dalam kasus default 3 – tiga operasi berbeda ditambahkan ke pipa. Kemudian, nomor acak diambil sampelnya untuk setiap augmentasi dalam pipeline – dan jika lebih rendah dari rate (default ke sekitar 0.9) – augmentasi diterapkan.

Intinya – ada kemungkinan 90% dari setiap augmentasi (acak) dalam pipeline yang diterapkan pada gambar.

Ini secara alami berarti bahwa tidak semua augmentasi harus diterapkan, terutama jika Anda menurunkan rate. Anda juga dapat menyesuaikan operasi mana yang diizinkan melalui a RandomAugmentationPipeline lapisan, yang RandAugment adalah kasus khusus dari. Panduan terpisah tentang RandomAugmentationPipeline akan segera diterbitkan.

Melatih Pengklasifikasi dengan dan tanpa RandAugment

Untuk menyederhanakan aspek persiapan/pemuatan data dan fokus pada RandAugment, mari kita gunakan tfds untuk memuat sebagian dari Imagenette:

(train, valid_set, test_set), info = tfds.load("imagenette", 
                                           split=["train[:70%]", "validation", "train[70%:]"],
                                           as_supervised=True, with_info=True)

class_names = info.features["label"].names
n_classes = info.features["label"].num_classes
print(f'Class names: {class_names}') 
print('Num of classes:', n_classes) 

print("Train set size:", len(train)) 
print("Test set size:", len(test_set)) 
print("Valid set size:", len(valid_set)) 

Kami hanya memuat sebagian dari data pelatihan, untuk membuatnya lebih mudah untuk menyesuaikan set data dalam waktu yang lebih sedikit (membuat eksperimen kami berjalan lebih cepat, pada dasarnya). Karena gambar di Imagenette memiliki ukuran yang berbeda, mari kita buat preprocess() fungsi yang mengubah ukurannya untuk memetakan kumpulan data, serta augment() fungsi yang menambah gambar dalam a tf.data.Dataset:

def preprocess(images, labels):
  return tf.image.resize(images, (224, 224)), tf.one_hot(labels, 10)
  
def augment(images, labels):
  inputs = {"images": images, "labels": labels}
  outputs = keras_cv.layers.RandAugment(value_range=(0, 255))(inputs)
  return outputs['images'], outputs['labels']

Sekarang – kami menyandikan label dengan sekali pakai. Kami tidak harus melakukannya, tetapi untuk augmentasi seperti CutMix yang merusak label dan proporsinya, Anda harus melakukannya. Karena Anda mungkin ingin menerapkannya juga RandAugment bekerja sangat baik dengan mereka untuk membuat pengklasifikasi yang kuat – mari kita tinggalkan enkode one-hot. Selain itu, RandAugment mengambil kamus dengan gambar dan label persis karena ini – beberapa augmentasi yang dapat Anda tambahkan sebenarnya akan mengubah label, jadi itu wajib. Anda dapat mengekstrak gambar dan label yang diperbesar dari outputs kamus dengan mudah, jadi ini adalah langkah ekstra, namun sederhana, yang harus diambil selama augmentasi.

Mari kita petakan kumpulan data yang ada yang dikembalikan dari tfds pada pengatur terkenal. Pengatur ini menawarkan bantuan hukum kepada traderapabila trader berselisih dengan broker yang terdaftar dengan mereka. preprocess() fungsi, batch mereka dan tambahkan hanya set pelatihan:

valid_set = valid_set.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
train_set = train.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
train_set_aug = train.map(preprocess).map(augment_data, 
                                          num_parallel_calls=tf.data.AUTOTUNE).batch(32).prefetch(tf.data.AUTOTUNE)

Mari melatih jaringan! keras_cv.models memiliki beberapa jaringan bawaan, mirip dengan keras.applications. Meskipun daftarnya masih pendek – daftar ini akan bertambah seiring waktu dan mengambil alih keras.applications. API sangat mirip, jadi kode porting akan cukup mudah bagi sebagian besar praktisi:

effnet = keras_cv.models.EfficientNetV2B0(include_rescaling=True, include_top=True, classes=10)
          
effnet.compile(
    loss='categorical_crossentropy',
    optimizer='adam',
    metrics=['accuracy']
)

history = effnet.fit(train_set, epochs=25, validation_data = valid_set)

Atau, Anda dapat menggunakan arus keras.applications:

effnet = keras.applications.EfficientNetV2B0(weights=None, classes=10)

effnet.compile(
  loss='categorical_crossentropy',
  optimizer='adam',
  metrics=['accuracy']
)

history1 = effnet.fit(train_set, epochs=50, validation_data=valid_set)

Ini menghasilkan model yang tidak terlalu baik:

Epoch 1/50
208/208 [==============================] - 60s 238ms/step - loss: 2.7742 - accuracy: 0.2313 - val_loss: 3.2200 - val_accuracy: 0.3085
...
Epoch 50/50
208/208 [==============================] - 48s 229ms/step - loss: 0.0272 - accuracy: 0.9925 - val_loss: 2.0638 - val_accuracy: 0.6887

Sekarang, mari kita latih pengaturan jaringan yang sama pada kumpulan data yang ditambah. Setiap batch ditambah secara individual, jadi setiap kali batch gambar yang sama (di zaman berikutnya) muncul – mereka akan memiliki augmentasi yang berbeda:

effnet = keras.applications.EfficientNetV2B0(weights=None, classes=10)
effnet.compile(
  loss='categorical_crossentropy',
  optimizer='adam',
  metrics=['accuracy']
)

history2 = effnet.fit(train_set_aug, epochs=50, validation_data = valid_set)

Epoch 1/50
208/208 [==============================] - 141s 630ms/step - loss: 2.9966 - accuracy: 0.1314 - val_loss: 2.7398 - val_accuracy: 0.2395
...
Epoch 50/50
208/208 [==============================] - 125s 603ms/step - loss: 0.7313 - accuracy: 0.7583 - val_loss: 0.6101 - val_accuracy: 0.8143

Jauh lebih baik! Meskipun Anda masih ingin menerapkan augmentasi lain, seperti CutMix dan MixUp, di samping teknik pelatihan lainnya untuk memaksimalkan akurasi jaringan – adil RandAugment sangat membantu dan dapat dibandingkan dengan pipa augmentasi yang lebih panjang.

Jika Anda membandingkan kurva pelatihan, termasuk pelatihan dan kurva validasi – menjadi jelas berapa banyak RandAugment membantu:

Pada pipeline non-augmented, overfit jaringan (akurasi pelatihan mencapai batas tertinggi) dan akurasi validasi tetap rendah. Dalam pipa yang diperbesar, akurasi pelatihan tetap lebih rendah dari akurasi validasi dari awal hingga akhir.

Dengan kehilangan pelatihan yang lebih tinggi, jaringan jauh lebih sadar akan kesalahan yang masih dibuatnya, dan lebih banyak pembaruan dapat dilakukan untuk membuatnya tidak berubah terhadap transformasi. Yang pertama melihat tidak perlu memperbarui, sedangkan yang kedua melakukannya dan meningkatkan batas potensi.

Kesimpulan

KerasCV adalah paket terpisah, tetapi masih merupakan tambahan resmi untuk Keras, yang dikembangkan oleh tim Keras, yang bertujuan untuk menghadirkan CV berkekuatan industri ke proyek Keras Anda. KerasCV masih dalam pengembangan pada saat penulisan, dan sudah menyertakan 27 lapisan prapemrosesan baru, RandAugment, CutMix, dan MixUp menjadi beberapa dari mereka.

Dalam panduan singkat ini, kami telah melihat bagaimana Anda dapat menggunakan RandAugment untuk menerapkan sejumlah transformasi acak dari daftar transformasi terapan yang diberikan, dan betapa mudahnya memasukkannya ke dalam alur pelatihan Keras apa pun.

Melangkah Lebih Jauh – Pembelajaran Mendalam Praktis untuk Visi Komputer

Sifat ingin tahu Anda membuat Anda ingin melangkah lebih jauh? Kami merekomendasikan untuk memeriksa kami Kelas: “Pembelajaran Mendalam Praktis untuk Visi Komputer dengan Python”.

Kursus Computer Vision lainnya?

Kami tidak akan melakukan klasifikasi digit MNIST atau mode MNIST. Mereka melayani bagian mereka sejak lama. Terlalu banyak sumber belajar yang berfokus pada kumpulan data dasar dan arsitektur dasar sebelum membiarkan arsitektur kotak hitam tingkat lanjut memikul beban kinerja.

Kami ingin fokus pada demistifikasi, kepraktisan, pemahaman, intuisi dan proyek nyata. Mau belajar bagaimana Anda dapat membuat perbedaan? Kami akan membawa Anda dalam perjalanan dari cara otak kami memproses gambar hingga menulis pengklasifikasi pembelajaran mendalam tingkat penelitian untuk kanker payudara hingga jaringan pembelajaran mendalam yang "berhalusinasi", mengajari Anda prinsip dan teori melalui kerja praktik, membekali Anda dengan pengetahuan dan alat untuk menjadi ahli dalam menerapkan pembelajaran mendalam untuk memecahkan visi komputer.

Apa yang ada di dalam?

• Prinsip pertama visi dan bagaimana komputer dapat diajarkan untuk "melihat"
• Berbagai tugas dan aplikasi visi komputer
• Alat perdagangan yang akan membuat pekerjaan Anda lebih mudah
• Menemukan, membuat, dan memanfaatkan kumpulan data untuk visi komputer
• Teori dan penerapan Jaringan Saraf Konvolusi
• Menangani pergeseran domain, kejadian bersama, dan bias lainnya dalam kumpulan data
• Transfer Belajar dan memanfaatkan waktu pelatihan dan sumber daya komputasi orang lain untuk keuntungan Anda
• Membangun dan melatih pengklasifikasi kanker payudara yang canggih
• Bagaimana menerapkan dosis skeptisisme yang sehat untuk mengarusutamakan gagasan dan memahami implikasi dari teknik yang diadopsi secara luas
• Memvisualisasikan "ruang konsep" ConvNet menggunakan t-SNE dan PCA
• Studi kasus tentang bagaimana perusahaan menggunakan teknik visi komputer untuk mencapai hasil yang lebih baik
• Evaluasi model yang tepat, visualisasi ruang laten dan mengidentifikasi perhatian model
• Melakukan penelitian domain, memproses kumpulan data Anda sendiri, dan membuat pengujian model
• Arsitektur mutakhir, perkembangan ide, apa yang membuatnya unik dan bagaimana menerapkannya
• KerasCV – perpustakaan WIP untuk menciptakan saluran pipa dan model yang canggih
• Cara mengurai dan membaca makalah dan menerapkannya sendiri
• Memilih model tergantung pada aplikasi Anda
• Membuat pipeline machine learning ujung ke ujung
• Lanskap dan intuisi pada deteksi objek dengan R-CNN, RetinaNet, SSD, dan YOLO yang Lebih Cepat
• Instance dan segmentasi semantik
• Pengenalan Objek Real-Time dengan YOLOv5
• Melatih Detektor Objek YOLOv5
• Bekerja dengan Transformers menggunakan KerasNLP (perpustakaan WIP kekuatan industri)
• Mengintegrasikan Transformer dengan ConvNets untuk menghasilkan keterangan gambar
• Deepdream
• Optimalisasi model Deep Learning untuk visi komputer