Klasifikasi Gambar Tensorflow 2.0: Memasang, Memuat Data, Membangun & Melatih Model

Klasifikasi citra merupakan salah satu kategori pengenalan pola. Ini mengklasifikasikan gambar sesuai dengan hubungan antara piksel tetangga. Dengan kata lain, ia menggunakan informasi kontekstual untuk mengatur gambar dan cukup populer di antara teknologi yang berbeda. Ini adalah topik yang menonjol dalam Pembelajaran Mendalam, dan jika Anda mempelajarinya, Anda pasti akan menikmati artikel ini.

Di sini, kita akan melakukan klasifikasi gambar TensorFlow. Kami akan membuat model, melatihnya, dan kemudian meningkatkan akurasinya untuk mengklasifikasikan gambar kaktus. TensorFlow adalah platform pembelajaran mesin sumber terbuka dan produk Google.

Mari kita mulai.

Instal TensorFlow 2.0

Pertama, Anda harus menginstal TensorFlow di Google Colab. Anda dapat menginstalnya melalui pip:

!pip install tensorflow-gpu==2.0.0-alpha0

Kemudian kami akan memverifikasi instalasi:

impor tensorflow sebagai tf

cetak(tf.__version)

# Keluaran: 2.0.0-alpha0

Sumber

Pelajari: 5 Proyek TensorFlow Paling Populer untuk Pemula

Muat Data

Setelah verifikasi, kita dapat memuat data dengan menggunakan tf.data.dataset. Kami akan membuat pengklasifikasi yang menentukan apakah suatu gambar mengandung kaktus atau tidak. Kaktus harus berbentuk kolom. Kita dapat menggunakan kumpulan data Cactus Aerial Photos untuk tujuan ini. Sekarang, kami akan memuat jalur file bersama dengan labelnya:

train_csv = pd.read_csv('data/kereta.csv')

# Tambahkan nama file gambar di kereta/ dengan jalur relatif

filenames = ['train/' + fname untuk fname di train_csv['id'].tolist()]

labels = train_csv['has_cactus'].tolist()

train_filenames, val_filenames, train_labels, val_labels =

train_test_split(nama file,

label,

ukuran_kereta=0.9,

random_state=42)

Setelah kita memiliki label dan nama file, kita siap untuk membuat objek tf.data.Dataset:

train_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(train_filenames), tf.constant(train_labels))

)

val_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(val_filenames), tf.constant(val_labels))

)

Sumber

Saat ini, kumpulan data kami tidak memiliki gambar yang sebenarnya. Itu hanya memiliki nama file mereka. Kami akan membutuhkan fungsi untuk memuat gambar yang diperlukan dan memprosesnya sehingga kami dapat melakukan pengenalan gambar TensorFlow pada gambar tersebut.

IMAGE_SIZE = 96 # Ukuran gambar minimum untuk digunakan dengan MobileNetV2

BATCH_SIZE = 32

# Berfungsi untuk memuat dan memproses setiap gambar

def _parse_fn(nama file, label):

img = tf.io.read_file(img)

img = tf.image.decode_jpeg(img)

img = (tf.cast(img, tf.float32)/127.5) – 1

img = tf.image.resize(img, (IMAGE_SIZE, IMAGE_SIZE))

kembalikan img, label

# Jalankan _parse_fn pada setiap contoh di set data kereta dan val

# Juga mengocok dan membuat kumpulan

train_data = (train_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

val_data = (val_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

Sumber

Membangun Model

Dalam contoh klasifikasi gambar TensorFlow ini, kita akan membuat model pembelajaran transfer. Model ini cepat karena dapat menggunakan model klasifikasi citra yang sudah ada yang telah melalui pelatihan sebelumnya. Mereka hanya perlu melatih kembali lapisan atas jaringan mereka karena lapisan ini menentukan kelas gambar yang diperlukan.

Kami akan menggunakan Keras API dari TensorFlow 2.0 untuk membuat model klasifikasi gambar kami. Dan untuk tujuan pembelajaran transfer, kami akan menggunakan MobileNetV2 sebagai pendeteksi atribut. Ini adalah versi kedua dari MobileNet dan merupakan produk dari Google. Bobotnya lebih ringan daripada model lain seperti Inception dan ResNet dan dapat berjalan di perangkat seluler. Kami akan memuat model ini di ImageNet, membekukan bobot, menambahkan kepala klasifikasi dan menjalankannya tanpa lapisan atasnya.

IMG_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3)

# Model terlatih dengan MobileNetV2

base_model = tf.keras.applications.MobileNetV2(

masukan_bentuk=IMG_BENTUK,

include_top=Salah,

bobot = 'imagenet'

)

# Bekukan bobot model yang telah dilatih sebelumnya

base_model.trainable = Salah

# Kepala klasifikasi yang dapat dilatih

maxpool_layer = tf.keras.layers.GlobalMaxPooling2D()

prediksi_layer = tf.keras.layers.Dense(1, activation='sigmoid')

# Kepala klasifikasi lapisan dengan detektor fitur

model = tf.keras.Sequential([

model_dasar,

maxpool_layer,

prediksi_lapisan

])

learning_rate = 0,0001

# Kompilasi modelnya

model.compile(optimizer=tf.keras.optimizers.Adam(lr=learning_rate),

rugi='binary_crossentropy',

metrik=['akurasi']

)

Sumber

Anda harus menggunakan pengoptimal TensorFlow jika Anda akan melatih model tf.keras. Pengoptimal di tf.keras.optimizers dan tf.train API digabungkan dalam tf.keras.optimizers TensorFlow 2.0. Di TensorFlow 2.0, banyak pengoptimal asli tf.keras telah menerima peningkatan dan penggantian untuk kinerja yang lebih baik. Mereka memungkinkan kami untuk menerapkan pengoptimal tanpa mengorbankan kinerja dan juga menghemat waktu.

Baca: Tutorial Deteksi Objek TensorFlow Untuk Pemula

Pelajari kursus ilmu data dari Universitas top dunia. Dapatkan Program PG Eksekutif, Program Sertifikat Tingkat Lanjut, atau Program Magister untuk mempercepat karier Anda.

Melatih Model

Setelah kita membangun modelnya, kita bisa mengajarkannya. API tf.keras dari TensorFlow 2.0 mendukung API tf.data, jadi Anda harus menggunakan objek tf.data.Dataset untuk tujuan ini. Itu dapat melakukan pelatihan secara efisien, dan kami tidak perlu berkompromi dengan kinerjanya.

jumlah_zaman = 30

langkah_per_zaman = putaran(angka_kereta)//BATCH_SIZE

val_steps = 20

model.fit(train_data.repeat(),

zaman = jumlah_ zaman,

step_per_Epoch = langkah_per_Epoch,

validasi_data=val_data.repeat(),

validasi_langkah=val_langkah)

Sumber

Setelah 30 epoch, akurasi model meningkat secara substansial, tetapi kami dapat meningkatkannya lebih jauh. Ingat, kami menyebutkan membekukan bobot selama pembelajaran transfer? Nah, sekarang setelah kita melatih kepala klasifikasi, kita dapat mencairkan lapisan tersebut dan menyempurnakan dataset kita lebih lanjut:

# Cairkan semua lapisan MobileNetV2

base_model.trainable = Benar

# Bekukan kembali lapisan hingga lapisan yang ingin kita sempurnakan

untuk lapisan di base_model.layers[:100]:

layer.trainable = Salah

# Gunakan kecepatan belajar yang lebih rendah

lr_finetune = learning_rate / 10

# Kompilasi ulang modelnya

model.compile(loss='binary_crossentropy',

pengoptimal = tf.keras.optimizers.Adam(lr=lr_finetune),

metrik=['akurasi'])

# Tingkatkan periode pelatihan untuk fine-tuning

fine_tune_epochs = 30

total_epochs = num_epochs + fine_tune_epochs

# Model fine-tune

# Catatan: Atur initial_epoch untuk memulai pelatihan setelah epoch 30 sejak kita

# sebelumnya dilatih selama 30 zaman.

model.fit(train_data.repeat(),

step_per_Epoch = langkah_per_Epoch,

zaman=total_zaman,

initial_epoch = jumlah_epochs,

validasi_data=val_data.repeat(),

validasi_langkah=val_langkah)

Sumber

30 epoch kemudian, akurasi model semakin meningkat. Dengan lebih banyak zaman, kami melihat lebih banyak peningkatan dalam akurasi model. Sekarang, kami memiliki model pengenalan gambar TensorFlow yang tepat yang dapat mengenali kaktus kolumnar dalam gambar dengan akurasi tinggi.

Baca Juga: Ide Proyek Tensorflow untuk Pemula

Pelajari Lebih Lanjut Tentang Klasifikasi Gambar TensorFlow

API TensorFlow yang sangat fungsional dan kemampuannya menjadikannya teknologi yang kuat untuk digunakan oleh programmer mana pun. API tingkat tingginya juga menghilangkan kerumitan umumnya, membuatnya lebih mudah digunakan.

Apakah Anda tertarik untuk mempelajari lebih lanjut tentang TensorFlow, klasifikasi gambar, dan topik terkait? Maka kami menyarankan Anda untuk memeriksa Diploma PG IIIT-B & upGrad dalam Pembelajaran Mesin & AI yang dirancang untuk profesional yang bekerja dan menawarkan 450+ jam pelatihan yang ketat, 30+ studi kasus & tugas, status Alumni IIIT-B, 5+ praktik proyek batu penjuru langsung & bantuan pekerjaan dengan perusahaan-perusahaan top.