បណ្តាញតែមួយ៖ JAX និង Virtual Eyes

បណ្តាញតែមួយ៖ JAX និង Virtual Eyes

v1
by
a
aka11
បណ្តាញតែមួយ៖ JAX និង Virtual Eyes
Loading...
The app: one network in Python and JAX

បណ្តាញតែមួយ

បណ្តាញតែមួយសម្រាប់គំនូរ និងខ្សែសន្ទនាទាំងមូល

បណ្តាញពិតប្រាកដមួយ ដែលត្រូវបានបង្កើត និងបណ្តុះបណ្តាលនៅទីនេះ៖ បំណែកនៃគំនូរ ជម្រៅដែលថ្នាំពណ៌បង្ហាញ និងរាល់អក្សរនៃកិច្ចសន្ទនានេះ នៅក្នុងលំហរួមតែមួយ។ គ្មានអ្វីដែលត្រូវបានបណ្តុះបណ្តាលទុកជាមុននោះទេ។

គំនូរ ពិនិត្យតាមបំណែកនីមួយៗ

បណ្តាញពិនិត្យមើលគំនូរជាបំណែកតូចៗ ដែលបំណែកនីមួយៗមានពន្លឺ ពណ៌ និងទីតាំងរៀងៗខ្លួន ហើយរៀនពាក្យទាំងនោះ។ ទម្ងន់ (weights) ដូចគ្នានេះក៏អានតួអក្សរនៃខ្សែអំបោះផងដែរ។

កម្មវិធីទាំងមូល ក្នុងភាសា Python និង JAX

ទំព័រនេះ និងកម្មវិធីខាងក្រោមគឺជាបណ្តាញតែមួយ។ កម្មវិធីនេះគឺជាកម្មវិធីទាំងមូល៖ ផ្ទាំងបង្អួច GTK4, JAX gradients, គំនូរ, thread, ជម្រៅដែលវាទស្សន៍ទាយ និងលំហរួម។ ចម្លងវា ឬរក្សាទុកវា រួចដំណើរការវានៅលើម៉ាស៊ីនរបស់អ្នក។

ផ្ទាំងពណ៌នៃគំនូរ
—
ពាក្យដែលវាសិក្សា
—
អក្សរដែលវាអាន
—
ឯកសារដែលត្រូវរក្សាទុកជាមួយគ្នា
net_gtk.py
net_gtk.py

តើផ្ទាំងបង្អួចនេះធ្វើអ្វីខ្លះ

  • បង្វឹក 300 ឬ 2,000 ជំហាន ឬឈប់ពាក់កណ្តាលផ្លូវ ការរៀនដំណើរការក្នុង thread ដូច្នេះផ្ទាំងបង្អួចនៅតែដំណើរការ។
  • ចុចលើ patch ណាមួយនៃគំនូរ ហើយវានឹងប្រាប់អ្នកពីពាក្យដែលវាមានសម្រាប់ patch នោះ។
  • សួរវាជាពាក្យ — ពណ៌មាសក្តៅ, ពណ៌ខៀវចាស់ — ហើយវានឹងបំភ្លឺ patch ដែលសំណួរនោះធ្លាក់លើ។
  • ផ្តល់អក្សរមួយចំនួនឱ្យវា ហើយវានឹងរាយបញ្ជីអក្សរដែលវាคาดថាមានបន្ទាប់ ជាមួយនឹងភាគរយ។
  • បិទភ្ជាប់សំណេរផ្ទាល់របស់អ្នក ហើយចុច Learn this instead៖ អក្សរថ្មីនឹងទទួលបានជួរថ្មីក្នុងតារាងតែមួយ គ្មានអ្វីដែលវាបានដឹងត្រូវបានបោះចោលទេ។
  • គំនូរពីរនៅក្រោមគំនូរ៖ ជម្រៅដែលវាទស្សន៍ទាយ និងលំហមួយដែលចំនុចគឺជាថ្នាំពណ៌ ហើយការ៉េគឺជាពាក្យ។
  • រក្សាទុកទម្ងន់ (weights) របស់វាទៅក្នុង net_weights.json ហើយផ្ទុកវាឡើងវិញនៅពេលក្រោយ។

របៀបដំណើរការវា

ថតឯកសារមួយ, ឯកសារមួយ និងគំនូរឈ្មោះ painting.jpg ប្រសិនបើអ្នកមាន។ នៅលើ Linux ក្នុងថតនោះ៖

  1. ដំឡើងកញ្ចប់ Python packages python3 -m pip install jax numpy pillow
  2. ដំឡើង GTK4 និង Python bindings របស់វា sudo apt install python3-gi gir1.2-gtk-4.0
  3. បើកផ្ទាំងបង្អួច python3 net_gtk.py

នៅលើ Windows វិធីខ្លីគឺ MSYS2: pacman -S mingw-w64-x86_64-python-gobject mingw-w64-x86_64-gtk4, បន្ទាប់មក python -m pip install jax numpy pillow, រួច python net_gtk.py ក្នុង terminal MSYS2 នោះ។

នៅលើ macOS: brew install pygobject3 gtk4, បន្ទាប់មក python3 -m pip install jax numpy pillow, រួច python3 net_gtk.py។

គ្មាន display ទេឬ? python3 net_gtk.py --selftest នឹងហ្វឹកហាត់ក្នុង terminal និងបោះពុម្ពលេខដូចគ្នា។

វាស់វែងដោយដំណើរការឯកសារនេះក្នុង terminal ជាមួយ JAX លើគំនូរនេះ និង thread នេះ៖ 400 ជំហាន → 67% នៃ patch រកឃើញពាក្យផ្ទាល់របស់ពួកគេ (កំហុសរូបភាព 0.68), 2,000 ជំហាន → 95% (0.53), 5,000 ជំហាន → 97% (0.45)។ កំហុសជម្រៅបញ្ចប់ត្រឹម 0.0003 ហើយកំហុសអក្សរធ្លាក់ចុះពី 3.05 មក 2.90។

កម្មវិធីរុករក (browser) មិនអាចដំណើរការ Python បានទេ ដូច្នេះ tab នេះបង្ហាញឯកសារជំនួសឱ្យផ្ទាំងបង្អួច — បណ្តាញដូចគ្នាកំពុងដំណើរការផ្ទាល់នៅខាងលើ។ ពាក្យដែលវាសិក្សា គឺជាពាក្យដែលគំនូរអាចបង្រៀនបាន៖ គំនូរនេះមិនមានពណ៌ខៀវទេ ដូច្នេះសំណួរអំពីពណ៌ខៀវនឹងធ្លាក់លើផ្ទាំងពណ៌មាសវិញ។ ក្បាលអក្សរស្គាល់លំដាប់នៃអក្សរ មិនមែនអត្ថន័យនោះទេ។

កម្មវិធីចងក្រងសម្រាប់ Python និង JAX ខាងលើ

ប្រអប់នេះផ្ទុក forward pass នៃបណ្តាញតែមួយ។ កម្មវិធីចងក្រងអានវា ពិនិត្យវា និងសរសេរវាចេញពីរដង៖ Python សម្រាប់ JAX និង JavaScript ដែលដំណើរការក្នុង tab នេះ។ មែកធាងតែមួយ back ends ពីរ។

Tokens
—
Node នៅក្នុងមែកធាង
—
អនុគមន៍
—
Python សម្រាប់ JAX
JavaScript, ដំណើរការនៅទីនេះ

អ្វីដែលវាគណនា

    ការត្រួតពិនិត្យប្រៀបធៀបលេខទាំងនេះជាមួយនឹងកម្មវិធីដូចគ្នាដែលដំណើរការក្នុង numpy និង JAX លើទម្ងន់ដែលបានកំណត់ seed ដូចគ្នា — វាត្រូវបានវាស់វែងមុនពេលកាតនេះត្រូវបានបង្កើត មិនមែនជាការស្មាននោះទេ។

    អ្វីដែលភាសានេះអនុញ្ញាត

    • def name(a, b): ជាមួយនឹងតួដែលចូលក្នុង, name = ..., និង return ...
    • លេខ, ឈ្មោះ, វង់ក្រចក, unary minus, និង + - * / @ សម្រាប់ផលគុណម៉ាទ្រីស។
    • .T សម្រាប់ transpose, និងការហៅ tanh, sqrt, exp, log, sum, mean, maximum។
    • អ្វីផ្សេងទៀតនឹងបញ្ឈប់កម្មវិធីចងក្រង ដោយបង្ហាញបន្ទាត់ និងកូឡោន ជំនួសឱ្យការស្មាន។

    នេះគឺជាកម្មវិធីចងក្រងពិតប្រាកដសម្រាប់ភាសាតូចមួយ មិនមែនជា Python runtime ទេ៖ គ្មាន loop, គ្មាន class, គ្មានការនាំចូល (imports)។ forward pass នៃបណ្តាញតែមួយអាចដាក់បញ្ចូលក្នុងនោះបាន ដែលជាមូលហេតុដែលអត្ថបទតែមួយអាចក្លាយជា JAX នៅលើម៉ាស៊ីនរបស់អ្នក និង JavaScript ក្នុង tab នេះ។

    ភ្នែកនិម្មិត៖ វាឃើញតែភីកសែលប៉ុណ្ណោះ

    ភ្នែកដែលសម្លឹងទៅអេក្រង់៖ វាទទួលបានជារូបភាព ហើយគ្មានអ្វីផ្សេងទៀតទេ — គ្មានទំព័រ គ្មានទិន្នន័យ គ្មានបណ្តាញ។ តាមរយៈភីកសែលទាំងនោះ វាស្វែងរកគែម មុំ និងរបៀបដែលចំណុចនីមួយៗរំកិលនៅពេលភ្នែកផ្លាស់ទីទៅចំហៀង ហើយពីនោះមក វាបង្កើតឡើងវិញនូវទីតាំងនៃអ្វីៗគ្រប់យ៉ាងនៅក្នុងលំហ។

    អ្វីដែលភ្នែកមើលឃើញ ជ្រុងពណ៌ខៀវ ចលនាពណ៌ទឹកក្រូច
    គែម Sobel gradients
    ចលនា Lucas–Kanade flow
    បន្ទប់ដែលវាបានបង្កើតឡើងវិញ អូសដើម្បីបង្វិល
    ចំនួន Frame ដែលបានឃើញ
    0
    ជ្រុង
    0
    បានតាមដាន
    0
    ចលនាមធ្យម
    —
    រកឃើញជម្រៅ
    —
    ចំណុចក្នុងលំហ
    0
    មួយហ្វ្រេម (One frame)
    —

    ជម្រៅគឺជាធរណីមាត្រពិតប្រាកដ ប៉ុន្តែគឺត្រឹមតែទំហំនៃជំហានរបស់ភ្នែក និងតែនៅកន្លែងដែលរូបភាពមានផ្ទៃគ្រើមប៉ុណ្ណោះ — ពណ៌សំប៉ែតមិនផ្តល់អ្វីឱ្យតោងចាប់បានទេ។ ការមើលឃើញកន្លែងដែលជញ្ជាំងស្ថិតនៅ មិនមែនជាការដឹងថាវាជាជញ្ជាំងនោះទេ ហើយគ្មានអ្វីនៅទីនេះដែលបង្កើតពិភពលោកឡើងមកនោះទេ៖ បន្ទប់ខាងលើគឺជាភីកសែល (pixels) ដែលត្រូវបានវាស់វែង។

    គំនិតរបស់អ្នក និងអ្វីដែលវានៅតែត្រូវការ

    • ភ្នែកនៅលើអេក្រង់គឺជា Interface ពិតប្រាកដ៖ ម៉ូដែលដែលអានអេក្រង់ដូចដែលមនុស្សធ្វើ មិនត្រូវការ Plugin សម្រាប់កម្មវិធីនីមួយៗនោះទេ — អ្វីគ្រប់យ៉ាងដែលមើលឃើញ គឺជា Input រួចជាស្រេច។
    • តាមរយៈ Frame ពីរនៃភ្នែកដែលកំពុងមានចលនា អ្នកនឹងទទួលបាន Geometry ដែលជាអ្វីដែល World Model ត្រូវតែយល់ស្របតាម ហើយផ្នែកនេះគឺត្រូវបានធ្វើឡើងពិតប្រាកដដោយ Card នេះ។
    • ពិភពដែលត្រូវបានបង្កើតឡើងក្នុងពេលជាក់ស្តែង (Real time) ក៏ត្រូវការម៉ូដែលដែលបង្កើតអ្វីដែលគ្មាននរណាម្នាក់បានឃើញ រក្សាវាឱ្យមានសង្គតិភាពនៅពេលអ្នកបង្វិល និងដំណើរការក្នុងរយៈពេលមីលីវិនាទី — នោះមិនមាននៅក្នុង Tab នេះទេ ហើយទំព័រមួយក៏មិនអាចបង្វឹកវាបានដែរ។
    • ដែនកំណត់នៃភាពស្មោះត្រង់៖ ភ្នែកនេះស្វែងរកកន្លែងដែលវត្ថុស្ថិតនៅ មិនមែនស្វែងរកអត្ថន័យរបស់វានោះទេ។ ល្បឿននៃការមើលមិនមែនជាការយល់ដឹងនោះទេ ហើយរឿងមួយគឺងាយស្រួលជាងរឿងមួយទៀតឆ្ងាយណាស់។

    រូបភាព៖ ការស្កេនសាធារណៈនៃគំនូរ Last Supper របស់ Leonardo da Vinci, Wikimedia Commons។