Keras va TensorFlow bilan chuqur o'rganishga kirish

Keras va TensorFlow bilan chuqur o'rganishga kirish
Chuqur o'rganish asoslarini tushunishga yordam berish uchun ushbu demo qo'lda yozilgan raqamlarni 95% dan yuqori aniqlik bilan tasniflash uchun ikkita o'yinchoq modelini yaratishning asosiy bosqichlaridan o'tadi. Birinchi model asosiy to'liq ulangan neyron tarmoq, ikkinchi model esa konvolyutsiya va birlashtirish tushunchalarini kiritadigan chuqurroq tarmoq bo'ladi.
SI uchun vazifa
Bizning maqsadimiz - qo'lda yozilgan raqamlarning minglab tasvirlarida sun'iy neyron tarmog'ini qurish va o'rgatish, shunda u taqdim etilganda boshqalarni muvaffaqiyatli aniqlashi mumkin. Kiritilgan ma'lumotlar MNIST ma'lumotlar bazasi bo'lib, unda o'qitish uchun 60 000 ta rasm va 10 000 ta sinov tasvirlari mavjud. Biz keras Python API-ni TensorFlow bilan fon sifatida ishlatamiz.

Python Modullar sharti
Birinchidan, ba'zi dasturlarni Python muhitiga yuklash kerak.
import numpy as np # kengaytirilgan matematik kutubxona
import matplotlib.pyplot as plt # MATLAB tartiblarni chizish
import random # tasodifiy sonlarni yaratish uchun

from keras.datasets import mnist # Kerasdagi MNIST ma'lumotlar to'plami

from keras.models import Sequential # Ishlatiladigan Model turi

from keras.layers.core import Dense, Dropout, Activation # Bizning

modelimizda ishlatiladigan qatlamlar turlari
from keras.utils import np_utils # NumPy bilan
bog'liq vositalar

Trening Ma'lumotlarini Yuklash

MNIST ma'lumotlar to'plami Keras ichida qulay tarzda to'plangan va biz Python-da uning ba'zi xususiyatlarini osongina tahlil qilishimiz mumkin.
# MNIST ma'lumotlar o'rtasida bo'lingan 60,000 28x28 pixel ta'lim tasvirlar va 10,000 28 x 28 pixel tasvirlar
(X_train, y_train), (X_test, y_test) = mnist.load_data()

print("X_train shape", X_train.shape)

print("y_train shape", y_train.shape)
print("X_test shape", X_test.shape)
print("y_test shape", y_test.shape)

Matplotlib yordamida biz ushbu Jupyter daftariga to'g'ridan-to'g'ri o'quv to'plamidan ba'zi namunaviy tasvirlarni chizishimiz mumkin.

plt.rcParams['figure.figsize'] = (9,9) # Raqamlarni biroz kattaroq qiling
for i in range(9):
plt.subplot(3,3,i+1)
num = random.randint(0, len(X_train))
plt.imshow(X_train[num], cmap='gray', interpolation='none')
plt.title("Class {}".format(y_train[num]))
plt.tight_layout()

Keling, bitta raqamni biroz yaqinroq ko'rib chiqamiz va oxirgi raqamni ifodalovchi qatorni chop etamiz.

# matritsani chiroyli chop etish uchun ozgina funktsiya
def matprint(mat, fmt="g"):
col_maxes = [max([len(("{:"+fmt+"}").format(x)) for x in col]) for col in mat.T]
for x in mat:
for i, y in enumerate(x):
print(("{:"+str(col_maxes[i])+fmt+"}").format(y), end=" ")
print("")

# endi chop eting!

matprint(X_train[num])

Har bir piksel 8 bit dan to 255 bitli butun sondir. 0 to'liq qora, 255 esa to'liq oq. Buni biz bitta kanalli piksel deb ataymiz. Bu monoxrom deb ataladi.

Kirish ma'lumotlar qatlamini formatlash
28x28 matritsa o'rniga biz 784 uzunlikdagi vektorni qabul qilish uchun tarmog'imizni quramiz. Keyin har bir tasvirni vektorga o'zgartirish (yoki tekislash) kerak. Shuningdek, biz [0-1] o'rniga [0-255] oralig'ida bo'lish uchun kirishni normallashtiramiz. Odatda kirishni normallashtirish tavsiya etiladi, shunda har qanday qo'shimcha o'lchamlar (boshqa tarmoq arxitekturalari uchun) bir xil miqyosda bo'ladi.

X_train = X_train.reshape(60000, 784) # 60,000 28 x 28 matritsalarni
60,000 784 uzunlikdagi vektorlarga aylantiring.
X_test = X_test.reshape(10000, 784) # 10,000 28 x 28 matritsalarni
10,000 784 uzunlikdagi vektorlarga aylantiring.
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, butun vector va 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)

Keyin biz sinflarimizni o'zgartiramiz (noyob raqamlar)

One-hot formatda bo'lish uchun, ya'ni
0 -> [1, 0, 0, 0, 0, 0, 0, 0, 0]
1 -> [0, 1, 0, 0, 0, 0, 0, 0, 0]
2 -> [0, 0, 1, 0, 0, 0, 0, 0, 0]
va h.k.
Agar bizning tarmog'imizning yakuniy chiqishi ushbu sinflardan biriga juda yaqin bo'lsa, unda bu sinf bo'lishi mumkin. Masalan, agar yakuniy chiqish quyidagicha bo'lsa:
[0, 0.94, 0, 0, 0, 0, 0.06, 0, 0]
unda rasm 1-raqamning tasviri bo'lishi ehtimoldan yiroq emas.
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)

3 qatlamli to'liq ulangan tarmoqni (FCN)qurish

# Ketma-ket model qatlamlarning chiziqli va juda keng tarqalgan to'plamidir.

model = Sequential()

Birinchi yashirin qatlam
# Birinchi yashirin qatlam 512 ta tugun (sun'iy neyronlar) to'plamidir.
# Har bir tugun har bir kirish vektoridan element oladi va unga bir oz og'irlik va tarafkashlikni qo'llaydi.
model.add(Dense(512, input_shape=(784,))) #(784,) 784 uzunlikdagi vektorni ifodalovchi xato emas!
# "Activation" - bu yuqoridagi qatlamning chiqishiga qo'llaniladigan chiziqli bo'lmagan funktsiya.
# U tugunning yangi qiymatini tekshiradi va bu sun'iy neyron ishdan chiqqanmi yoki yo'qligini hal qiladi.
# Rektifikatsiyalangan chiziqli birlik (ReLU) barcha salbiy kirishlarni keyingi qatlamdagi tugunlarda nolga aylantiradi.
# Keyin bu kirishlar ishdan bo'shatilgan deb hisoblanmaydi.
# Tugunning ijobiy qiymatlari o'zgarmaydi.
model.add(Activation('relu'))

# Dropout tasodifiy chiqishlar tanlovini nolga tenglashtiradi (ya'ni ularni faollashtirishni o'chiradi)
# Dropout yod yoki ta'lim ma'lumotlarni "overfitting" dan modelini himoya qilishga yordam beradi.
model.add(Dropout(0.2))
Ikkinchi yashirin qatlamni qo'shish
# Ikkinchi yashirin qatlam bizning birinchi qatlamimiz bilan bir xil ko'rinadi.
# Biroq, 512-tugunning har biri o'rniga kirish tasvir ma'lumotlaridan 784-kirishni qabul qiladi,
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.2))
Yakuniy Chiqish Qatlami
# Oldingi 10 tugunli qatlamga to'liq ulangan 512 neyronlarning oxirgi qatlami.
# FCN ning oxirgi qatlami kerakli sinflar soniga teng bo'lishi kerak (bu holda 10 ta).
model.add(Dense(10))
# "Softmax" aktivatsiyasi ehtimollik taqsimotini ifodalaydi K turli xil mumkin bo'lgan natijalar.
# Uning qiymatlari hammasi manfiy emas va yig'indisi 1 ga teng.
model.add(Activation('softmax'))
# Qurilgan modelni umumlashtiring

model.summary()

Modelni kompilyatsiya qilish
Yuqorida Kerasda qurilgan Theano va TensorFlow. Ikkala paket ham Python-da hisoblash grafigini aniqlashga imkon beradi, keyinchalik u Python tarjimonining yukisiz CPU yoki GPU-da samarali ishlaydi.

Modelni tuzishda Keras bizdan yo'qotish funktsiyasini va optimallashtiruvchini ko'rsatishimizni so'raydi. Biz bu yerda ishlatadigan yo'qotish funktsiya kategorik o'zaro faoliyat entropiya va ikkita ehtimollik taqsimotini taqqoslash uchun juda mos bo'lgan yo'qotish funktsiyasi.

Bizning bashoratlarimiz o'n xil raqam bo'yicha ehtimollik taqsimotidir (masalan, biz bu rasm 80% - 3 , 10% - 8, 5% - 2 va hokazo ekanligiga ishonchimiz komil) va maqsad-bu to'g'ri toifa uchun 100% va qolgan hamma narsa uchun 0 bilan ehtimollik taqsimoti. O'zaro faoliyat entropiya-bu sizning taxmin qilingan taqsimotingiz maqsadli taqsimotdan qanchalik farq qilishining o'lchovidir.

Optimallashtiruvchi model gradient tushish orqali qanchalik tez o'rganishini aniqlashga yordam beradi. Tushish tezligi a

Shunday qilib, kichikroq o'rganish stavkalari yaxshiroqmi? Unchalik emas! Optimizator uchun yo'qotish funktsiyasining global minimalini e'tiborsiz qoldirib, mahalliy minimalarga yopishib qolmaslik muhim. Ba'zan bu mahalliy minimal darajadan sakrash uchun ko'proq o'rganish tezligini sinab ko'rishni anglatadi.

# O'rganish uchun Adam optimizatoridan foydalanamiz
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
Modelni o'rgating!
Bu qiziqarli qism!
To'plam hajmi yo'qotish funktsiyasini, gradyanlarni va orqaga tarqalishini hisoblash uchun har bir qadam uchun qancha ma'lumot ishlatilishini aniqlaydi. Katta partiya o'lchamlari tarmoqqa mashg'ulotni tezroq bajarishga imkon beradi; ammo, mashg'ulot tezligidan tashqari boshqa omillarni ham hisobga olish kerak.

Partiya hajmining juda katta qismi yo'qotish funktsiyasining mahalliy minimalarini tekislaydi va optimallashtiruvchini bitta joyga joylashishiga olib keladi, chunki u global minimalni topdi deb o'ylaydi.

Partiya hajmining juda kichikligi juda shovqinli yo'qotish funktsiyasini yaratadi va optimallashtiruvchi hech qachon global minimalni topa olmaydi.

Shunday qilib, yaxshi partiya hajmini topish uchun sinov va xatoliklar talab qilinishi mumkin!

model.fit(X_train, Y_train,
batch_size=128, epochs=5,
verbose=1)

Ikkala raqam tartibda o'quv to'plamidagi tarmoqning yo'qotish funktsiyasining qiymatini va o'quv ma'lumotlari bo'yicha tarmoqning umumiy aniqligini anglatadi. Lekin u haqida o'rgatish emas, balki u ma'lumotlar ustida qandayligini aniqlash kerak.

Sinov ma'lumotlari bo'yicha modelning aniqligini baholang
score = model.evaluate(X_test, Y_test)
print('Test score:', score[0])
print('Test accuracy:', score[1])

Chiqishni tekshirish

Chiqishni tekshirish va hamma narsa to'g'ri ko'rinishiga ishonch hosil qilish har doim yaxshi fikr. Bu yerda biz ba'zi misollarni ko'rib chiqamiz. Bunda ba’zi misollar to'g'ri keladi va ba'zi misollar noto'g'ri bo'ladi.
# Predict_classes funktsiyasi eng yuqori ehtimollik sinfini chiqaradi
# har bir kiritish misol uchun ta'lim klassifikatori ko'ra.
predicted_classes = model.predict_classes(X_test)

# Biz to'g'ri / noto'g'ri bor qaysi mahsulot tekshiring correct_indices = np.nonzero(predicted_classes == y_test)[0]

incorrect_indices = np.nonzero(predicted_classes != y_test)[0]

plt.figure()
for i, correct in enumerate(correct_indices[:9]):
plt.subplot(3,3,i+1)
plt.imshow(X_test[correct].reshape(28,28), cmap='gray', interpolation='none')
plt.title("Predicted {}, Class {}".format(predicted_classes[correct], y_test[correct]))
plt.tight_layout()
plt.figure()
for i, incorrect in enumerate(incorrect_indices[:9]):
plt.subplot(3,3,i+1)
plt.imshow(X_test[incorrect].reshape(28,28), cmap='gray', interpolation='none')
plt.title("Predicted {}, Class {}".format(predicted_classes[incorrect], y_test[incorrect]))
plt.tight_layout()

Partiya hajmi bilan tajriba o'tkazishga harakat qiling!

Partiya hajmini 10 000 ga oshirish mashg'ulot vaqti va test aniqligiga qanday ta'sir qiladi?