Keras va TensorFlow bilan chuqur o'rganishga kirish

Partiya hajmi 32 ga teng?
Konvolyutsiyani Joriy Etish! Bu nima?
Oldin biz har bir qiymatning normallashtirilgan piksel qiymatlarini qabul qiladigan va soley-ni ushbu qiymatlarda ishlaydigan tarmoq qurdik. Agar biz har bir tasvirning turli xil xususiyatlarini (masalan, egrilik, qirralar) tarmoqqa joylashtirsak va tarmoq tasvirni tasniflash uchun qaysi xususiyatlar muhimligini bilib olsak nima bo'ladi?

Bu konvolyutsiya orqali mumkin! Konvolyutsiya har bir rasm bo'ylab o'tadigan va xususiyat xaritalarini yaratadigan yadrolarni (filtrlarni) qo'llaydi.

Yuqoridagi misolda tasvir 5 x 5 matritsa va uning ustiga o'tadigan yadro 3 x 3 matritsa. Tasvir va yadro o'rtasida nuqta mahsuloti ishlashi sodir bo'ladi va konvektsiya xususiyati hosil bo'ladi. CNN-dagi har bir yadro tasvirning boshqa xususiyatlarini o'rganadi.

Yadrolar ko'pincha fotoediting dasturida loyqalanish, qirralarni aniqlash, o'tkirlash va hokazolarni qo'llash uchun ishlatiladi.

operatsion filtr o'ralgan rasm

Chuqur o'rganish tarmoqlaridagi yadrolar shunga o'xshash usullarda ishlatiladi, ya'ni. ba'zi xususiyatlarni ta'kidlash. Maks pooling deb nomlangan tizim bilan birgalikda ta'kidlanmagan elementlar har bir xususiyat xaritasidan chiqarib tashlanadi, faqat qiziqish xususiyatlarini qoldiradi, o'rganilgan parametrlar sonini kamaytiradi va hisoblash xarajatlarini kamaytiradi (masalan, tizim xotirasi).

Shuningdek, biz konvolyutsiyalarni qabul qilishimiz mumkin-agar yadroga mos keladigan piksellar etarli bo'lsa, biz xohlagancha konvolyutsiyalarni to'plashimiz mumkin.

Ogohlantirish: o'sha chuqur konvolyutsiyalarda topishingiz mumkin bo'lgan narsalar sizga tanish bo'lmasligi mumkin.

"Chuqur" Konvolyutsion neyron tarmog'ini qurish
# qo'shimcha vositalarni import qilish

from keras.preprocessing.image import ImageDataGenerator

from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D, GlobalAveragePooling2D, Flatten
from keras.layers.normalization import BatchNormalization
# Mnist ma'lumotlarini qayta yuklash
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Yana formatlashni bajaring

# Bundan tashqari, biz har bir tasvirni 784 uzunlikdagi vektorga tekislamaymiz, chunki biz avval konvolyutsiyalarni bajarishni xohlaymiz

X_train = X_train.reshape(60000, 28, 28, 1) # bitta kanalni ko'rsatish uchun qo'shimcha o'lcham qo'shing

X_test = X_test.reshape(10000, 28, 28, 1)

X_train = X_train.astype('float32') # butun sonlarni 32 bitli suzuvchi nuqta raqamlariga o'zgartiring

X_test = X_test.astype('float32')

X_train /= 255 # har bir kirish uchun butun vektor uchun har bir piksel uchun har bir qiymatni normallashtiring

X_test /= 255

print("Training matrix shape", X_train.shape)

print("Testing matrix shape", X_test.shape)

# bir-issiq format darslari

nb_classes = 10 # noyob raqamlar soni

Y_train = np_utils.to_categorical(y_train, nb_classes)

Y_test = np_utils.to_categorical(y_test, nb_classes)

model = Sequential() # Qatlamlarni chiziqli yig'ish

# Konvolyutsiya Qatlami 1

model.add(Conv2D(32, (3, 3), input_shape=(28,28,1))) # 32 turli xil 3x3 yadrolari-shuning uchun 32 xususiyat xaritalari
model.add(BatchNormalization(axis=-1)) # faollashtirishdan oldin har bir xususiyat xaritasini normallashtiring
convLayer01 = Activation('relu') # faollashtirish
model.add(convLayer01)

# Konvolyutsiya Qatlami 2

model.add(Conv2D(32, (3, 3))) # 32 turli xil 3x3 yadrolari-shuning uchun 32 xususiyat xaritalari
model.add(BatchNormalization(axis=-1)) # faollashtirishdan oldin har bir xususiyat xaritasini normallashtiring
model.add(Activation('relu')) # faollashtirish
convLayer02 = MaxPooling2D(pool_size=(2,2)) # Maksimal qiymatlarni 2x2 yadro ustiga qo'ying
model.add(convLayer02)

# Konvolyutsiya Qatlami 3

model.add(Conv2D(64,(3, 3))) # 64 turli xil 3x3 yadrolari - shuning uchun 64 xususiyat xaritalari
model.add(BatchNormalization(axis=-1)) # faollashtirishdan oldin har bir xususiyat xaritasini normallashtiring
convLayer03 = Activation('relu') # faollashtirish
model.add(convLayer03)

# Konvolyutsiya Qatlami 4

model.add(Conv2D(64, (3, 3))) # 64 turli xil 3x3 yadrolari - shuning uchun 64 xususiyat xaritalari

model.add(BatchNormalization(axis=-1)) # faollashtirishdan oldin har bir xususiyat xaritasini normallashtiring

model.add(Activation('relu')) # faollashtirish

convLayer04 = MaxPooling2D(pool_size=(2,2)) # Maksimal qiymatlarni 2x2 yadro ustiga qo'ying

model.add(convLayer04)

model.add(Flatten()) # Yakuniy 4x4x64 chiqish matritsasini 1024 uzunlikdagi vektorga tekislang

# To'liq Ulangan Qatlam 5

model.add(Dense(512)) # 512 FCN tugunlari
model.add(BatchNormalization()) # normallashtirish
model.add(Activation('relu')) # faollashtirish

# To'liq Ulangan Qatlam 6

model.add(Dropout(0.2)) # 20% tasodifiy tanlangan tugunlarni tark etish
model.add(Dense(10)) # yakuniy 10 FCN tugunlari
model.add(Activation('softmax')) # softmax faollashtirish

model.summary()

# biz bir xil optimallashtiruvchidan foydalanamiz

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

# data augmentation oz tasodifiy ma'lumotlarni o'zgartirib overfitting oldini oladi

# Keras avtomatik kattalashtirish uchun ajoyib o'rnatilgan xususiyatga ega

gen = ImageDataGenerator(rotation_range=8, width_shift_range=0.08, shear_range=0.3,

height_shift_range=0.08, zoom_range=0.08)

test_gen = ImageDataGenerator()

# Keyin biz kengaytirilgan ma'lumotlarni partiyalarda boqishimiz mumkin

# Avvalgidek yo'qotish funktsiyasini hisobga olishdan tashqari, bu usul aslida xotirani sezilarli darajada tejashga olib keladi
# chunki biz har bir partiyani qayta ishlashdan oldin ma'lumotlarni tarmoqqa partiyalarda yuklaymiz

# Ma'lumotlar oldin barcha xotiraga Yuklangan, lekin keyin partiyalarda qayta ishlangan.

train_generator = gen.flow(X_train, Y_train, batch_size=128)

test_generator = test_gen.flow(X_test, Y_test, batch_size=128)

# Endi biz ommaviy yuklagichimiz tomonidan ma'lumotlar bilan ta'minlangan modelimizni o'rgatishimiz mumkin

# Bir davr uchun qadamlar har doim to'plamning umumiy hajmi partiya hajmiga bo'linishi kerak

# Xotirani sezilarli darajada tejash (kattaroq, chuqurroq tarmoqlar uchun muhim)

model.fit_generator(train_generator, steps_per_epoch=60000//128, epochs=5, verbose=1,
validation_data=test_generator, validation_steps=10000//128)

score = model.evaluate(X_test, Y_test)

print('Test score:', score[0])
print('Test accuracy:', score[1])

Ajoyib natijalar!

Ammo model nimani ko'rayotganini ko'rishimiz uchun bu konvolyutsiyalarni tasavvur qilsak yaxshi bo'lmaydimi?

from keras import backend as K

# indeksni ko'rsatib, xohlagan rasmni tanlang

img = X_test[3]
img = np.expand_dims(img, axis=0) # Keras tasvirni 4d formatida bo'lishini talab qiladi, shuning uchun biz unga qo'shimcha o'lcham qo'shamiz.

# Ushbu funktsiya qanday ishlashini tushunish muhim emas-u faqat konvolyutsiya qatlamini tuzadi

def visualize(layer):
inputs = [K.learning_phase()] + model.inputs
_convout1_f = K.function(inputs, [layer.output])
def convout1_f(X):
# [0] o'quv bosqichi bayrog'ini o'chirishdir
return _convout1_f([0] + [X])

convolutions = convout1_f(img)

convolutions = np.squeeze(convolutions)

print ('Shape of conv:', convolutions.shape)

m = convolutions.shape[2]
n = int(np.ceil(np.sqrt(m)))
# Qatlamning har bir filtrini vizualizatsiya qilish
fig = plt.figure(figsize=(15,12))
for i in range(m):
ax = fig.add_subplot(n,n,i+1)
ax.imshow(convolutions[:,:,i], cmap='gray')

plt.figure()

plt.imshow(X_test[3].reshape(28,28), cmap='gray', interpolation='none')

visualize(convLayer01) # xususiyat xaritalarining birinchi to'plamini tasavvur qiling

visualize(convLayer02) # xususiyat xaritalarining ikkinchi to'plamini tasavvur qiling

visualize(convLayer03) # xususiyat xaritalarining uchinchi to'plamini tasavvur qiling

visualize(convLayer04) # xususiyat xaritalarining to'rtinchi to'plamini tasavvur qiling

Juda o'xshash tarmoqni 3D vizualizatsiya qilish uchun tashrif buyuring

http://scs.ryerson.ca/~aharley/vis/conv/