Contoh algoritma rangkaian saraf konvolusi dalam Python

Convolutional Neural Network (CNN) ialah algoritma rangkaian saraf yang digunakan secara meluas dalam pengecaman imej, pengecaman pertuturan, pemprosesan bahasa semula jadi dan bidang lain. Ia menggunakan struktur neuron biologi, memproses struktur spatial dua dimensi data input, dan menggunakan kaedah perkongsian berat dalam lapisan konvolusi dan lapisan pengumpulan, yang mengurangkan bilangan parameter yang perlu dioptimumkan, dengan itu meningkatkan Kebolehan generalisasi dan kecekapan model.

Python ialah bahasa pengaturcaraan yang digunakan secara meluas dalam bidang pengkomputeran saintifik, pembelajaran mesin dan pembelajaran mendalam. Ia mempunyai kelebihan kerana mudah digunakan, sumber terbuka dan percuma serta kaya dengan perpustakaan pihak ketiga digunakan oleh semakin ramai penyelidik dan pilihan jurutera sebagai alat pembangunan. Dalam Python, kita boleh menggunakan pelbagai rangka kerja pembelajaran mendalam untuk melaksanakan algoritma rangkaian saraf konvolusi, termasuk Keras, TensorFlow, PyTorch, dsb.

Di bawah, kami akan menggunakan contoh untuk memperkenalkan cara menggunakan rangka kerja Keras untuk melaksanakan algoritma rangkaian saraf konvolusi dalam Python.

Pengenalan Set Data

Contoh ini menggunakan set data CIFAR-10, yang mengandungi 60,000 imej berwarna 32x32 dalam 10 kategori, dan bilangan imej dalam setiap kategori ialah 6,000. Imej ini dibahagikan kepada set latihan dan set ujian, dengan 50,000 imej dalam set latihan dan 10,000 imej dalam set ujian.

Dalam Python, kita boleh menggunakan fungsi cifar10.load_data yang disediakan oleh perpustakaan Keras untuk memuatkan set data CIFAR-10, seperti yang ditunjukkan di bawah:

from keras.datasets import cifar10

(x_train, y_train), (x_test, y_test) = cifar10.load_data()

di mana x_train dan x_test ialah set latihan dan x_test masing-masing Data imej set ujian, y_train dan y_test ialah label set latihan dan set ujian masing-masing.

Pembinaan model

Model rangkaian saraf konvolusi yang digunakan dalam contoh ini mengandungi berbilang lapisan konvolusi, lapisan gabungan dan lapisan bersambung sepenuhnya. Struktur khusus adalah seperti berikut:

1. Lapisan input: Saiz imej input ialah 32x32x3, di mana 3 mewakili tiga saluran RGB.
2. Lapisan konvolusi 1: Gunakan 32 biji lilitan bersaiz 3x3, langkahnya ialah 1, dan fungsi pengaktifan ialah ReLU.
3. Lapisan konvolusi 2: Gunakan 64 biji lilitan bersaiz 3x3, langkahnya ialah 1, dan fungsi pengaktifan ialah ReLU.
4. Lapisan penyatuan 1: Gunakan kernel pengumpul bersaiz 2x2 dengan langkah 2.
5. Lapisan konvolusi 3: Gunakan 128 biji lilitan bersaiz 3x3, langkahnya ialah 1, dan fungsi pengaktifan ialah ReLU.
6. Lapisan penggabungan 2: Gunakan inti penggabungan bersaiz 2x2 dengan langkah 2.
7. Lapisan 1 bersambung sepenuhnya: mengandungi 128 neuron, dan fungsi pengaktifan ialah ReLU.
8. Lapisan 2 bersambung sepenuhnya: mengandungi 10 neuron, sepadan dengan 10 kategori, dan fungsi pengaktifan ialah Softmax.

Dalam Python, kita boleh membina model lapisan demi lapisan melalui kelas Sequential yang disediakan oleh perpustakaan Keras, seperti yang ditunjukkan di bawah:

from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=(32, 32, 3)))
model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Flatten())
model.add(Dense(units=128, activation='relu'))
model.add(Dense(units=10, activation='softmax'))

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

Antaranya, kelas Conv2D mewakili konvolusi lapisan dan kelas MaxPooling2D Mewakili lapisan pengumpulan, kelas Flatten mewakili input multidimensi satu dimensi, dan kelas Padat mewakili lapisan yang bersambung sepenuhnya. Fungsi model.compile digunakan untuk menyusun model dan menentukan algoritma pengoptimuman, fungsi kehilangan, indeks penilaian, dsb.

Latihan dan penilaian model

Selepas model dibina, kita boleh menggunakan data set latihan untuk melatih model. Dalam Python, kita boleh menggunakan fungsi fit untuk melaksanakan latihan model, seperti berikut:

from keras.utils import np_utils

y_train = np_utils.to_categorical(y_train, 10)
y_test = np_utils.to_categorical(y_test, 10)

model.fit(x_train, y_train, epochs=10, batch_size=64, validation_data=(x_test, y_test))

Antaranya, fungsi np_utils.to_categorical digunakan untuk menukar label kepada pengekodan satu-panas. Fungsi muat digunakan untuk melatih model, menyatakan bilangan pusingan latihan, saiz kelompok, data set pengesahan, dsb. Selepas latihan selesai, kita boleh menggunakan fungsi menilai untuk menilai model, seperti yang ditunjukkan di bawah:

loss, accuracy = model.evaluate(x_test, y_test)

Dalam contoh ini, selepas 10 pusingan latihan, ketepatan model pada set ujian ialah 0.7318.

Ringkasan

Artikel ini memperkenalkan contoh penggunaan rangka kerja Keras untuk melaksanakan algoritma rangkaian saraf konvolusi dalam Python. Dengan menggunakan set data CIFAR-10 dan struktur model tertentu, kita boleh belajar cara membina, melatih dan menilai rangkaian saraf konvolusi dalam Python. Selain itu, prestasi model boleh dipertingkatkan lagi dengan melaraskan struktur dan parameter model.

Atas ialah kandungan terperinci Contoh algoritma rangkaian saraf konvolusi dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!