Artificial Intelligence (AI) ទទួលបានប្រជាប្រិយភាពយ៉ាងខ្លាំងក្នុងប៉ុន្មានឆ្នាំថ្មីៗនេះ។
ប្រសិនបើអ្នកជាវិស្វករផ្នែកទន់ អ្នកវិទ្យាសាស្ត្រកុំព្យូទ័រ ឬអ្នកចូលចិត្តវិទ្យាសាស្ត្រទិន្នន័យ ជាទូទៅអ្នកប្រហែលជាចាប់អារម្មណ៍នឹងកម្មវិធីដ៏អស្ចារ្យនៃដំណើរការរូបភាព ការស្គាល់លំនាំ និងការរកឃើញវត្ថុដែលផ្តល់ដោយវាលនេះ។
វាលរងដ៏សំខាន់បំផុតនៃ AI ដែលអ្នកប្រហែលជាធ្លាប់បានលឺអំពីគឺ Deep Learning ។ វាលនេះផ្តោតលើក្បួនដោះស្រាយដ៏មានអានុភាព (ការណែនាំអំពីកម្មវិធីកុំព្យូទ័រ) ដែលយកគំរូតាមមុខងារខួរក្បាលរបស់មនុស្សដែលគេស្គាល់ថាជា បណ្តាញសរសៃប្រសាទ.
នៅក្នុងអត្ថបទនេះ យើងនឹងនិយាយអំពីគោលគំនិតនៃបណ្តាញសរសៃប្រសាទ និងរបៀបបង្កើត ចងក្រង បំពាក់ និងវាយតម្លៃគំរូទាំងនេះដោយប្រើ ពស់ថ្លាន់.
បណ្តាញសរសៃប្រសាទ
បណ្តាញសរសៃប្រសាទ ឬ NNs គឺជាស៊េរីនៃក្បួនដោះស្រាយដែលត្រូវបានយកគំរូតាមសកម្មភាពជីវសាស្រ្តនៃខួរក្បាលមនុស្ស។ បណ្តាញសរសៃប្រសាទមានថ្នាំងដែលហៅថាណឺរ៉ូនផងដែរ។
ការប្រមូលផ្តុំនៃថ្នាំងបញ្ឈរត្រូវបានគេស្គាល់ថាជាស្រទាប់។ ម៉ូដែលនេះមានធាតុបញ្ចូលមួយ ទិន្នផលមួយ និងស្រទាប់លាក់មួយចំនួន។ ស្រទាប់នីមួយៗមានថ្នាំងដែលហៅថាណឺរ៉ូនដែលការគណនាកើតឡើង។
នៅក្នុងដ្យាក្រាមខាងក្រោម រង្វង់តំណាងឱ្យថ្នាំង ហើយបណ្តុំថ្នាំងបញ្ឈរតំណាងឱ្យស្រទាប់។ ម៉ូដែលនេះមានបីស្រទាប់។
ថ្នាំងនៃស្រទាប់មួយត្រូវបានភ្ជាប់ទៅស្រទាប់បន្ទាប់តាមរយៈខ្សែបញ្ជូន ដូចដែលបានឃើញខាងក្រោម។
សំណុំទិន្នន័យរបស់យើងរួមមានទិន្នន័យដែលមានស្លាក។ នេះមានន័យថាអង្គភាពទិន្នន័យនីមួយៗត្រូវបានផ្តល់តម្លៃឈ្មោះជាក់លាក់។
ដូច្នេះសម្រាប់សំណុំទិន្នន័យចំណាត់ថ្នាក់សត្វ យើងនឹងមានរូបភាពឆ្មា និងឆ្កែជាទិន្នន័យរបស់យើង ដោយមាន 'ឆ្មា' និង 'ឆ្កែ' ជាស្លាករបស់យើង។
វាជារឿងសំខាន់ក្នុងការកត់សម្គាល់ថាស្លាកត្រូវបំប្លែងទៅជាតម្លៃលេខសម្រាប់គំរូរបស់យើងដើម្បីឱ្យយល់អំពីពួកវា ដូច្នេះស្លាកសត្វរបស់យើងក្លាយជា '0' សម្រាប់ឆ្មា និង '1' សម្រាប់ឆ្កែ។ ទាំងទិន្នន័យ និងស្លាកសញ្ញាត្រូវបានឆ្លងកាត់គំរូ។
សិក្សា
ទិន្នន័យត្រូវបានបញ្ចូលទៅអង្គភាពគំរូមួយក្នុងពេលតែមួយ។ ទិន្នន័យនេះត្រូវបានបំបែកជាកំណាត់ៗ ហើយឆ្លងកាត់ថ្នាំងនីមួយៗនៃគំរូ។ ថ្នាំងអនុវត្តប្រតិបត្តិការគណិតវិទ្យាលើកំណាត់ទាំងនេះ។
អ្នកមិនចាំបាច់ដឹងពីមុខងារគណិតវិទ្យា ឬការគណនាសម្រាប់ការបង្រៀននេះទេ ប៉ុន្តែវាជារឿងសំខាន់ក្នុងការមានគំនិតទូទៅអំពីរបៀបដែលគំរូទាំងនេះដំណើរការ។ បន្ទាប់ពីការគណនាជាបន្តបន្ទាប់ក្នុងស្រទាប់មួយ ទិន្នន័យត្រូវបានបញ្ជូនទៅស្រទាប់បន្ទាប់ ហើយបន្តបន្ទាប់ទៀត។
នៅពេលបញ្ចប់ គំរូរបស់យើងព្យាករណ៍ស្លាកទិន្នន័យនៅស្រទាប់លទ្ធផល (ឧទាហរណ៍ ក្នុងបញ្ហាចំណាត់ថ្នាក់សត្វ យើងទទួលបានការព្យាករណ៍ '0' សម្រាប់ឆ្មា)។
បន្ទាប់មក គំរូបន្តដើម្បីប្រៀបធៀបតម្លៃដែលបានព្យាករណ៍នេះជាមួយនឹងតម្លៃស្លាកពិតប្រាកដ។
ប្រសិនបើតម្លៃត្រូវគ្នា ម៉ូដែលរបស់យើងនឹងយកធាតុបញ្ចូលបន្ទាប់ ប៉ុន្តែប្រសិនបើតម្លៃខុសគ្នា ម៉ូដែលនឹងគណនាភាពខុសគ្នារវាងតម្លៃទាំងពីរ ហៅថា ការបាត់បង់ និងកែតម្រូវការគណនាថ្នាំងដើម្បីបង្កើតស្លាកដែលត្រូវគ្នានៅពេលក្រោយ។
ក្របខ័ណ្ឌសិក្សាជ្រៅជ្រះ
ដើម្បីបង្កើត Neural Networks ក្នុងកូដ យើងត្រូវនាំចូល ក្របខ័ណ្ឌសិក្សាជ្រៅជ្រះ គេស្គាល់ថាជាបណ្ណាល័យដោយប្រើបរិស្ថានអភិវឌ្ឍន៍រួមបញ្ចូលគ្នា (IDE) របស់យើង។
ក្របខ័ណ្ឌទាំងនេះគឺជាបណ្តុំនៃមុខងារដែលបានសរសេរជាមុន ដែលនឹងជួយយើងក្នុងការបង្រៀននេះ។ យើងនឹងប្រើក្របខណ្ឌ Keras ដើម្បីបង្កើតគំរូរបស់យើង។
Keras គឺជាបណ្ណាល័យ Python ដែលប្រើកម្មវិធីជំនួយការរៀនសូត្រជ្រៅជ្រះ និងផ្នែកខាងក្រោយនៃបញ្ញាសិប្បនិម្មិតហៅថា ភាពតានតឹង ដើម្បីបង្កើត NNs ក្នុងទម្រង់ជាគំរូបន្តបន្ទាប់ដ៏សាមញ្ញដោយភាពងាយស្រួល។
Keras ក៏មានភ្ជាប់មកជាមួយនូវម៉ូដែលដែលមានស្រាប់របស់វា ដែលអាចប្រើបានផងដែរ។ សម្រាប់មេរៀននេះ យើងនឹងបង្កើតគំរូផ្ទាល់ខ្លួនរបស់យើងដោយប្រើ Keras ។
អ្នកអាចស្វែងយល់បន្ថែមអំពីក្របខ័ណ្ឌ Deep Learning នេះពី គេហទំព័រ Keras.
ការកសាងបណ្តាញសរសៃប្រសាទ (ការបង្រៀន)
ចូរបន្តទៅការបង្កើតបណ្តាញសរសៃប្រសាទដោយប្រើ Python ។
សេចក្តីថ្លែងការណ៍បញ្ហា។
បណ្តាញសរសៃប្រសាទគឺជាប្រភេទនៃដំណោះស្រាយចំពោះបញ្ហាដែលមានមូលដ្ឋានលើ AI ។ សម្រាប់ការបង្រៀននេះ យើងនឹងនិយាយអំពីទិន្នន័យជំងឺទឹកនោមផ្អែម Pima Indians ដែលអាចរកបាន នៅទីនេះ.
អាយស៊ី Machine Learning បានចងក្រងសំណុំទិន្នន័យនេះ។ និងមានកំណត់ត្រាវេជ្ជសាស្រ្តរបស់អ្នកជំងឺឥណ្ឌា។ គំរូរបស់យើងត្រូវទស្សន៍ទាយថាតើអ្នកជំងឺមានជំងឺទឹកនោមផ្អែមក្នុងរយៈពេល 5 ឆ្នាំឬអត់។
កំពុងផ្ទុកសំណុំទិន្នន័យ
សំណុំទិន្នន័យរបស់យើងគឺជាឯកសារ CSV តែមួយដែលហៅថា 'diabetes.csv' ដែលអាចត្រូវបានរៀបចំយ៉ាងងាយស្រួលដោយប្រើ Microsoft Excel ។
មុនពេលបង្កើតគំរូរបស់យើង យើងត្រូវនាំចូលសំណុំទិន្នន័យរបស់យើង។ ដោយប្រើកូដខាងក្រោម អ្នកអាចធ្វើដូចនេះបាន៖
នាំចូលខ្លាឃ្មុំផេនដាជាផ
ទិន្នន័យ = pd.read_csv('diabetes.csv')
x = data.drop("លទ្ធផល")
y = ទិន្នន័យ["លទ្ធផល"]
នៅទីនេះយើងកំពុងប្រើឯកសារ ផេនដាស បណ្ណាល័យ ដើម្បីអាចរៀបចំទិន្នន័យឯកសារ CSV របស់យើង read_csv() គឺជាមុខងារដែលភ្ជាប់មកជាមួយរបស់ Pandas ដែលអនុញ្ញាតឱ្យយើងរក្សាទុកតម្លៃនៅក្នុងឯកសាររបស់យើងទៅជាអថេរហៅថា 'data'។
អថេរ x មានសំណុំទិន្នន័យរបស់យើងដោយគ្មានលទ្ធផល (ស្លាក) ទិន្នន័យ។ យើងសម្រេចបានវាជាមួយនឹងមុខងារ data.drop() ដែលលុបស្លាកសម្រាប់ x ខណៈដែល y មានទិន្នន័យលទ្ធផល (ស្លាក) ប៉ុណ្ណោះ។
ការកសាងគំរូតាមលំដាប់លំដោយ
ជំហានទី 1: នាំចូលបណ្ណាល័យ
ជាដំបូង យើងត្រូវនាំចូល TensorFlow និង Keras រួមជាមួយនឹងប៉ារ៉ាម៉ែត្រជាក់លាក់ដែលត្រូវការសម្រាប់ម៉ូដែលរបស់យើង។ កូដខាងក្រោមអនុញ្ញាតឱ្យយើងធ្វើដូចនេះ៖
នាំចូលតង់ស៊ីតេជា tf
ពី tensorflow keras នាំចូល
ពី tensorflow.keras.models នាំចូលតាមលំដាប់លំដោយ
ពី tensorflow.keras.layers នាំចូលធ្វើឱ្យសកម្ម, ក្រាស់
ពី tensorflow.keras.optimizers នាំចូលអាដាម
ពី tensorflow.keras.metrics នាំចូល categorical_crossentropy
សម្រាប់ម៉ូដែលរបស់យើងយើងកំពុងនាំចូលស្រទាប់ក្រាស់។ ទាំងនេះគឺជាស្រទាប់ដែលបានតភ្ជាប់យ៉ាងពេញលេញ; ពោលគឺថ្នាំងនីមួយៗក្នុងស្រទាប់មួយត្រូវបានភ្ជាប់យ៉ាងពេញលេញជាមួយថ្នាំងផ្សេងទៀតនៅក្នុងស្រទាប់បន្ទាប់។
យើងក៏កំពុងនាំចូលផងដែរ។ ការធ្វើឱ្យសកម្ម មុខងារដែលត្រូវការសម្រាប់ការធ្វើមាត្រដ្ឋានទិន្នន័យដែលបានផ្ញើទៅថ្នាំង។ សុទិដ្ឋិនិយម ក៏ត្រូវបាននាំចូលផងដែរ ដើម្បីកាត់បន្ថយការបាត់បង់។
អាដាមគឺជាកម្មវិធីបង្កើនប្រសិទ្ធភាពដ៏ល្បីល្បាញដែលធ្វើឱ្យការគណនាថ្នាំងធ្វើបច្ចុប្បន្នភាពគំរូរបស់យើងកាន់តែមានប្រសិទ្ធភាព រួមជាមួយនឹង categorical_crossentropy ដែលជា ប្រភេទនៃមុខងារបាត់បង់ (គណនាភាពខុសគ្នារវាងតម្លៃជាក់ស្តែង និងតម្លៃស្លាកដែលបានព្យាករណ៍) ដែលយើងនឹងប្រើប្រាស់។
ជំហានទី 2: ការរចនាម៉ូដរបស់យើង។
គំរូដែលខ្ញុំកំពុងបង្កើតមានធាតុបញ្ចូលមួយ (មាន 16 ឯកតា) មួយលាក់ (មាន 32 ឯកតា) និងស្រទាប់ទិន្នផលមួយ (មាន 2 ឯកតា) ។ លេខទាំងនេះមិនត្រូវបានជួសជុលទេ ហើយនឹងពឹងផ្អែកទាំងស្រុងលើបញ្ហាដែលបានផ្តល់ឱ្យ។
ការកំណត់ចំនួនឯកតា និងស្រទាប់ត្រឹមត្រូវ គឺជាដំណើរការដែលអាចត្រូវបានកែលម្អបន្ថែមម៉ោងតាមរយៈការអនុវត្ត។ ការធ្វើឱ្យសកម្មត្រូវគ្នាទៅនឹងប្រភេទនៃការធ្វើមាត្រដ្ឋានដែលយើងនឹងអនុវត្តលើទិន្នន័យរបស់យើង មុនពេលឆ្លងកាត់វាតាមរយៈថ្នាំង។
Relu និង Softmax គឺជាមុខងារធ្វើឱ្យសកម្មដ៏ល្បីល្បាញសម្រាប់កិច្ចការនេះ។
គំរូ = បន្តបន្ទាប់ ([
ដង់ស៊ីតេ(ឯកតា = 16, បញ្ចូល_រាង = (1,), ការធ្វើឱ្យសកម្ម = 'relu'),
ដង់ស៊ីតេ (ឯកតា = 32, ការធ្វើឱ្យសកម្ម = 'relu'),
ដង់ស៊ីតេ(ឯកតា = 2, ការធ្វើឱ្យសកម្ម = 'softmax')
])
នេះគឺជាអ្វីដែលសង្ខេបនៃគំរូគួរមើលទៅដូច:
បណ្តុះបណ្តាលគំរូ
គំរូរបស់យើងនឹងត្រូវបានបណ្តុះបណ្តាលជាពីរជំហាន ទីមួយគឺការចងក្រងគំរូ (ការដាក់គំរូជាមួយគ្នា) និងបន្ទាប់គឺការបំពាក់គំរូនៅលើសំណុំទិន្នន័យដែលបានផ្តល់ឱ្យ។
នេះអាចត្រូវបានធ្វើដោយប្រើមុខងារ model.compile() បន្តដោយមុខងារ model.fit() ។
model.compile(អ្នកបង្កើនប្រសិទ្ធភាព = អាដាម(អត្រាការរៀន = 0.0001), ការបាត់បង់ = 'binary_crossentropy', ម៉ែត្រ = ['ភាពត្រឹមត្រូវ'])
model.fit(x, y, epochs = 30, batch_size = 10)
ការបញ្ជាក់ម៉ែត្រ 'ភាពត្រឹមត្រូវ' អនុញ្ញាតឱ្យយើងសង្កេតមើលភាពត្រឹមត្រូវនៃគំរូរបស់យើងអំឡុងពេលហ្វឹកហាត់។
ដោយសារស្លាករបស់យើងមានទម្រង់ 1's និង 0's យើងនឹងប្រើមុខងារបាត់បង់ប្រព័ន្ធគោលពីរ ដើម្បីគណនាភាពខុសគ្នារវាងស្លាកពិតប្រាកដ និងដែលបានព្យាករណ៍។
សំណុំទិន្នន័យក៏កំពុងត្រូវបានបំបែកជាបាច់នៃ 10 (batch_size) ហើយនឹងត្រូវបានឆ្លងកាត់គំរូ 30 ដង (សម័យកាល)។ សម្រាប់សំណុំទិន្នន័យដែលបានផ្តល់ឱ្យ x ជាទិន្នន័យ ហើយ y ជាស្លាកដែលត្រូវគ្នានឹងទិន្នន័យ។
គំរូសាកល្បងដោយប្រើការទស្សន៍ទាយ
ដើម្បីវាយតម្លៃគំរូរបស់យើង យើងធ្វើការព្យាករណ៍លើទិន្នន័យសាកល្បងដោយប្រើមុខងារព្យាករណ៍()។
ការព្យាករណ៍ = model.predict(x)
ហើយនោះហើយជាវា!
ឥឡូវនេះអ្នកគួរតែមានការយល់ដឹងល្អអំពី ការសិក្សាស៊ីជម្រៅ។ កម្មវិធី, បណ្តាញសរសៃប្រសាទ, របៀបដែលពួកគេធ្វើការជាទូទៅ និងរបៀបបង្កើត បណ្តុះបណ្តាល និងសាកល្បងគំរូនៅក្នុងកូដ Python ។
ខ្ញុំសង្ឃឹមថាការបង្រៀននេះផ្តល់ឱ្យអ្នកនូវការចាប់ផ្តើមដើម្បីបង្កើត និងប្រើប្រាស់គំរូ Deep Learning ផ្ទាល់ខ្លួនរបស់អ្នក។
អនុញ្ញាតឱ្យយើងដឹងនៅក្នុងមតិយោបល់ប្រសិនបើអត្ថបទមានប្រយោជន៍។
សូមផ្ដល់យោបល់