អត្ថបទនេះបកប្រែពីភាសាអង់គ្លេសដោយ AI។ អានអត្ថបទដើមជាភាសាអង់គ្លេស →
របៀបដែល AI បង្កើតរូបភាពដំណើរការ៖ ខ្ញុំបានបង្វឹក Diffusion Model មួយពីចំណុចសូន្យនៅលើកុំព្យូទ័រយួរដៃ
ខ្ញុំបានបង្វឹក AI មួយឱ្យចេះគូររូបនៅលើកុំព្យូទ័រយួរដៃរបស់ខ្ញុំ តាំងពីចំណុចសូន្យ។ ដំបូងឡើយ វាបង្កើតបានតែ noise រញ៉េរញ៉ៃគ្មានរូបរាងប៉ុណ្ណោះ ប៉ុន្តែប្រហែល 35 នាទីក្រោយមក វាក៏អាចគូរចេញជារូបរ៉ូបូតថ្មីៗដែលមិនធ្លាប់មានពីមុនមក។
វាដំណើរការតាមរបៀបដូចគ្នាទៅនឹង Stable Diffusion និង Midjourney ដែរ ពោលគឺម៉ូដែលរៀនបំប្លែង noise ឱ្យក្លាយជារូបភាព។ បន្ទាប់មក ខ្ញុំបានបណ្តោយឱ្យវារៀនបន្តពីរូបគំនូរដែលស្អាតបំផុតរបស់វាផ្ទាល់ រហូតដល់វាចេះលួចបន្លំតែម្តង។
អត្ថបទនេះនឹងបង្ហាញអ្នកទាំងអស់គ្នាឱ្យបានក្បោះក្បាយ៖ ទាំងកូដ រូបមន្តគណិតវិទ្យា និងទិន្នន័យលេខជាក់ស្តែងពីការដំណើរការតេស្តរបស់ខ្ញុំ។ អ្នកអាចមើលវីដេអូបង្រៀនពេញលេញនៅទីនេះ៖ https://youtu.be/19Omz2cwFuY
▶ WATCH ON YOUTUBEWatch the video
ការរៀបចំ៖ កូដ Python + PyTorch ប្រហែល 120 បន្ទាត់ ម៉ូដែល U-Net តូចមួយដែលមាន 2,142,851 weights និងបង្វឹកនៅលើ Mac GPU។
1. រូបភាពគ្រាន់តែជាទិន្នន័យលេខប៉ុណ្ណោះ
កុំព្យូទ័រមិនអាចមើលឃើញរូបភាពដូចភ្នែកយើងទេ គឺវាឃើញតែលេខប៉ុណ្ណោះ។ រូបរ៉ូបូតនីមួយៗក្នុងទិន្នន័យរបស់ខ្ញុំមានទំហំ 64 × 64 ភីកសែល ហើយភីកសែលនីមួយៗមានតម្លៃបី (ក្រហម បៃតង ខៀវ)។ ដូច្នេះរូបរ៉ូបូតតូចមួយ គឺស្មើនឹង 12,288 លេខ។
មុនពេលចាប់ផ្តើមបង្វឹក លេខទាំងអស់ត្រូវបានបំប្លែងពីចន្លោះ 0–255 មកនៅចន្លោះ −1 ដល់ 1 វិញ៖
imgs = torch.tensor(np.load("data/robots64.npy")).permute(0, 3, 1, 2) # 8000 × 3 × 64 × 64
data = imgs.float() / 127.5 - 1 # pixels 0..255 -> -1..1
split = int(0.9 * len(data))
train, val = data[:split], data[split:] # 10% held back to test honestlyហេតុអ្វីត្រូវបំប្លែងមកនៅចន្លោះ −1 ដល់ 1? បណ្តាញណឺរ៉ូន (neural networks) ដំណើរការរៀនបានល្អបំផុតនៅពេលដែលទិន្នន័យលេខស្ថិតនៅក្បែរសូន្យ ហើយវាក៏ស្ថិតក្នុងកម្រិតដូចគ្នាទៅនឹង random noise ដែលយើងនឹងបន្ថែមនៅពេលក្រោយដែរ។ ភីកសែលដែលមានពណ៌ក្រហម = 75 នឹងក្លាយជា −0.412។
បន្ទាប់មក ខ្ញុំបានលាក់រូបភាព 10% ទុកសម្រាប់ធ្វើតេស្តផ្ទៀងផ្ទាត់សមត្ថភាពពិតប្រាកដ៖ រូបរ៉ូបូត 7,200 សម្រាប់បង្វឹក និង 800 ទៀតម៉ូដែលមិនដែលបានឃើញទាល់តែសោះ។
2. តើរូបរ៉ូបូតទាំង 8,000 បានមកពីណា?
ខ្ញុំបានគូររូបទាំងនោះដោយខ្លួនឯងតាមរយៈកូដ។ រ៉ូបូតនីមួយៗត្រូវបានកំណត់ទំហំ ឥរិយាបថ ពណ៌ អារម្មណ៍ និងផ្ទៃខាងក្រោយដោយចៃដន្យ (random) ដោយគូរឡើងជាមួយបណ្ណាល័យរូបភាពរបស់ Python៖ រូបចតុកោណកែងមូលគែមសម្រាប់ក្បាលនិងដងខ្លួន និងរង្វង់មូលសម្រាប់ភ្នែក។ គ្មានរូបពីរណាដូចគ្នាឡើយ ដូច្នេះម៉ូដែលមិនអាចលួចចម្លងរូបណាមួយបានទេ គឺវាត្រូវតែរៀនយល់ឱ្យច្បាស់ថាតើរ៉ូបូតពិតប្រាកដ ជាអ្វី។ លើសពីនេះ វាក៏មានន័យថាយើងមិនបានយករូបភាពរបស់អ្នកដទៃមកប្រើសូម្បីតែមួយសន្លឹក។
3. បំផ្លាញរូបភាពដោយបន្ថែម noise (ដំណើរការទៅមុខ - the forward process)
នេះជាគំនិតប្លែកមួយនៅពីក្រោយ diffusion៖ ដំបូង យើងបំផ្លាញរូបភាពចោលសិន។ យើងបន្ថែម random noise បន្តិចម្តងៗម្តងហើយម្តងទៀត រហូតដល់ 1,000 ជំហាន ទាល់តែសល់តែ noise សុទ្ធសាធគ្មានសល់រូបរាងអ្វីទាំងអស់។
ជំហាននីមួយៗបន្ថែម noise បន្តិចបន្តួចហៅថា β ដែលកើនឡើងពី 0.0001 នៅជំហានទី 1 ទៅដល់ 0.02 នៅជំហានទី 1,000។ យកតម្លៃ (1 − β) ទាំងអស់គុណបញ្ចូលគ្នា អ្នកនឹងទទួលបាន ᾱ (alpha bar) ដែលបង្ហាញពីកម្រិតនៃរូបភាពដើមដែលនៅសេសសល់។
រូបមន្តគន្លឹះ៖
x_t = √ᾱ_t · x₀ + √(1 − ᾱ_t) · εx₀ ជារូបភាពដើមច្បាស់ស្អាត ហើយ ε គឺជា random noise។ នៅពេលលើកជាការ៉េ ផលបូកនៃរ៉ាឌីកាល់ការ៉េទាំងពីរតែងតែស្មើនឹងមួយជានិច្ច ដូច្នេះរូបភាពដើមនឹងរសាត់បាត់ទៅក្នុងល្បឿនស្មើគ្នាបេះបិទទៅនឹងកំណើននៃ noise ហើយទិន្នន័យលេខក៏មិនកើនឡើងហួសប្រមាណនោះដែរ។
តម្លៃជាក់ស្តែងពីកាលវិភាគបន្ថែម noise របស់ខ្ញុំ៖
- ជំហានទី 250៖ នៅសល់រូបរ៉ូបូតប្រហែល 72%
- ជំហានទី 500៖ នៅសល់ត្រឹមតែ 28% ប៉ុណ្ណោះ
- ជំហានទី 999៖ √ᾱ ធ្លាក់មកសល់ត្រឹម 0.006 ពោលគឺរូបរ៉ូបូតបានរសាត់បាត់ស្រមោលទាំងស្រុង
ចំណុចពិសេសបំផុតនោះគឺ រូបមន្តនេះអាចលោតផ្លោះទៅកាន់ជំហានណាមួយភ្លាមៗតែម្តង ដោយមិនបាច់រត់ loop ឡើយ។ នៅក្នុងកូដ វាជាអនុគមន៍ខ្លីមួយប៉ុណ្ណោះ៖
T = 1000 # 1,000 small noise steps
beta = torch.linspace(1e-4, 0.02, T) # how much noise each step adds
alpha_bar = torch.cumprod(1 - beta, dim=0) # how much of the image survives after t steps
def add_noise(x0, t, eps): # x_t = √ᾱ_t · x0 + √(1 − ᾱ_t) · ε
a = alpha_bar.to(x0.device)[t].view(-1, 1, 1, 1)
return a.sqrt() * x0 + (1 - a).sqrt() * epsការកំណត់ទាំងនេះគឺដូចគ្នាទៅនឹងការកំណត់ក្នុងឯកសារស្រាវជ្រាវ DDPM ដើម (Ho et al., 2020) ទាំងស្រុង។
4. ភារកិច្ចចម្បង៖ ទាយរក noise
យើងយករូបរ៉ូបូតដែលពោរពេញដោយ noise ទៅបង្ហាញម៉ូដែល រួចសួរសំណួរមួយថា៖ តើខ្ញុំបានបន្ថែម noise អ្វីខ្លះចូល? យើងដឹងចម្លើយយ៉ាងច្បាស់ព្រោះយើងជាអ្នកបន្ថែមវាដោយផ្ទាល់ដៃ ដូច្នេះយើងមិនបាច់ចំណាយកម្លាំងមនុស្សទៅដាក់ស្លាកសម្គាល់ (label) ទិន្នន័យអ្វីឡើយ។
ហេតុអ្វីបានជាឱ្យទាយរក noise ទៅវិញ មិនឱ្យទាយយករូបភាពតែម្តង? តាមស្ថិតិ noise មើលទៅដូចគ្នាស្ទើរគ្រប់ជំហាន ហើយឯកសារស្រាវជ្រាវ DDPM បានរកឃើញថា ការកំណត់គោលដៅសាមញ្ញបែបនេះផ្តល់លទ្ធផលល្អបំផុត។ ក្នុងពេលបង្វឹក រូបភាពនីមួយៗត្រូវបានកំណត់កម្រិតជំហានដោយចៃដន្យ ដូច្នេះម៉ូដែលបានហាត់រៀនគ្រប់កម្រិត noise ទាំងអស់ ចាប់តាំងពីស្រាលស្រទន់ដូចអ័ព្ទ រហូតដល់កម្រិតខ្លាំងដូចព្យុះសង្ឃរា។
តម្លៃលម្អៀង (loss) គណនាតាម mean squared error៖ ជាមធ្យមភាគនៃ (real noise − guess)²។
ឧទាហរណ៍ជាក់ស្តែង៖ សម្រាប់រូបរ៉ូបូតមួយនៅជំហានទី 500 តម្លៃ noise ពិតប្រាកដត្រង់ចំណុចភីកសែលមួយគឺ −1.065 ហើយម៉ូដែលដែលបានបង្វឹកហើយទាយឃើញ −1.14។ គិតជាមធ្យមលើរូបភាពទាំងមូល កម្រិតលម្អៀងមានត្រឹមតែ 0.0028 ប៉ុណ្ណោះ។
ប្រសិនបើម៉ូដែលមួយអាចទាយដឹងថា noise មានអ្វីខ្លះ នោះវាក៏អាចលុប noise នោះចេញបានដែរ។ ហើយនៅពេលដែលវាអាចលុប noise ចេញបាន នោះវានឹងអាចគូររូបបានហើយ។
5. ម៉ូដែលដែលប្រើ៖ U-Net
def forward(s, x, t):
te = s.tmlp(time_embed(t))
h1 = s.d1(s.inp(x), te) # 64×64
h2 = s.d2(F.avg_pool2d(h1, 2), te) # 32×32
m = s.mid(F.avg_pool2d(h2, 2), te) # 16×16
u = s.u2(torch.cat([F.interpolate(m, scale_factor=2), h2], 1), te)
u = s.u1(torch.cat([F.interpolate(u, scale_factor=2), h1], 1), te)
return s.out(u) # the predicted noise ε̂U-Net បង្រួមទំហំរូបភាពពី 64 → 32 → 16 ភីកសែល ដើម្បីមើលទិដ្ឋភាពជារួម បន្ទាប់មកពង្រីកវាឡើងវិញទៅ 64 ភីកសែល ដើម្បីរៀបចំផ្នែកលម្អិត។ ខ្សែភ្ជាប់កាត់ (shortcut connections) ជួយបញ្ជូនព័ត៌មានលម្អិតឆ្លងកាត់រាងអក្សរ "U" ធ្វើឱ្យគ្មានអ្វីត្រូវបាត់បង់ឡើយ។ នៅក្នុងកូដ៖ avg_pool2d ប្រើសម្រាប់បង្រួម interpolate ប្រើសម្រាប់ពង្រីក ហើយ torch.cat ប្រើសម្រាប់ភ្ជាប់ shortcut នោះចូលគ្នា។
សមាសភាគគ្រឹះរបស់វាគឺ convolution៖ ជាផ្ទាំង window ទំហំ 3 × 3 រំកិលកាត់លើផ្ទៃរូបភាព។ តម្លៃលទ្ធផលនីមួយៗបានមកពីទម្ងន់ប៉ារ៉ាម៉ែត្រប្រាំបួនគុណនឹងភីកសែលទាំងប្រាំបួនដែលនៅក្រោម window នោះ រួចបូកបន្ថែម bias។ convolution ដំបូងគេបំប្លែងពណ៌ចំនួន 3 channels ឱ្យទៅជា 64 feature maps ដែលជាគំរូទម្រង់ចំនួន 64 ផ្សេងៗគ្នាដែលវាអាចចាប់យកបាន ដូចជាគែម ជ្រុង និងភ្នែក។
ម៉ូដែលក៏ត្រូវដឹងដែរថារូបភាពនោះមាន noise កម្រិតណា ដូច្នេះលេខសម្គាល់ជំហានត្រូវបានបំប្លែងទៅជាវ៉ិចទ័រនៃរលក sine និង cosine រួចបញ្ចូលទៅក្នុង block នីមួយៗ។ block នីមួយៗផ្សំឡើងពី convolution ពីរ layer កម្រិតស្មើ (normalisation layer) មួយ និងអនុគមន៍ SiLU activation។
សរុបទាំងអស់៖ 2,142,851 weights។ ចំណែក U-Net របស់ Stable Diffusion វិញមានរហូតដល់ប្រហែល 860 លាន ដែលធំជាងនេះប្រហែល 400× ដង។
6. ដំណើរការបង្វឹក មួយបន្ទាត់ម្តងៗ
វាដំណើរការតាមជំហានស្នូលទាំងបួន ដូចបណ្តាញណឺរ៉ូនដទៃទៀតដែរ៖
opt = torch.optim.AdamW(model.parameters(), lr=2e-4)
for step in range(STEPS):
x0 = train[torch.randint(len(train), (32,))].to(dev) # 32 real robots
t = torch.randint(T, (32,), device=dev) # a random noise level for each
eps = torch.randn_like(x0) # the noise we add (the answer key)
loss = F.mse_loss(model(add_noise(x0, t, eps), t), eps) # how wrong was the guess?
opt.zero_grad()
loss.backward() # how should each weight change?
opt.step() # nudge all of them a littleគោលការណ៍គ្រឹះគឺ gradient descent៖ w ← w − η · ∂L/∂w ជាមួយនឹង learning rate 0.0002 (ក្នុងកូដនេះប្រើ AdamW ដែលជាប្រភេទទំនើបនិងឆ្លាតវៃជាងនៃគោលការណ៍ដដែលនេះ)។
ការរត់ 10,000 ជំហាន ចំណាយពេលប្រហែល 35 នាទី នៅលើ Mac GPU ដោយក្នុងមួយជំហានចំណាយពេលប្រហែលមួយភាគប្រាំនៃវិនាទីប៉ុណ្ណោះ។ កម្រិតលម្អៀងលើរូបរ៉ូបូត 800 ដែលលាក់ទុក បានធ្លាក់ចុះពី 1.1 មកនៅត្រឹមប្រហែល 0.0064 ហើយ test loss ធ្លាក់ចុះស្របគ្នាជាមួយ training loss យ៉ាងល្អ។ ជាមួយនឹងរូបរ៉ូបូត 7,200 វាពិតជារៀនយល់ដឹងមែន មិនមែនទន្ទេញចាំមាត់នោះឡើយ។
ការអង្គុយមើលរូបគំរូដែលបង្កើតឡើង (ចេញពី noise ដដែលរាល់លើក) គឺជាផ្នែកដែលជក់ចិត្តបំផុត។ នៅជំហានទី 1,000 វាគូរចេញជាគំនូសរញ៉េរញ៉ៃ។ នៅជំហានទី 3,000 វាចាប់ផ្តើមគូរចេញជាគ្រឿងបន្លាស់រ៉ូបូតរាយប៉ាយ ច្របូកច្របល់ រួមទាំងរ៉ូបូតខ្លះមានភ្នែកបីទៀតផង។ លុះដល់ជំហានទី 10,000 វាអាចគូរចេញជារូបរ៉ូបូតពិតប្រាកដតែម្តង។ វាបានរៀនស្គាល់ផ្នែកតូចៗនីមួយៗ មុនពេលវាចេះផ្គុំចេញជារូបរាងពេញលេញ។
7. គូររូបថ្មីស្រឡាងចេញពី noise សុទ្ធ
ដើម្បីគូររូប យើងដំណើរការបញ្ច្រាសមកវិញ។ ចាប់ផ្តើមចេញពី random noise សុទ្ធសាធ។ បន្ទាប់មក ធ្វើដដែលៗចំនួន 1,000 ដង៖ ម៉ូដែលទាយរក noise ហើយយើងកាត់បន្ថយ noise នោះចេញបន្តិចម្តងៗ។
ជំហាននីមួយៗរំកិលថយក្រោយពី t ទៅ t − 1៖ ភាគច្រើនជារូបភាពបច្ចុប្បន្ន បូកផ្សំជាមួយការទាយរបស់ម៉ូដែលចំពោះរូបភាពស្អាតបន្តិចបន្តួច រួមទាំងបន្ថែម noise ថ្មីស្រាលៗមួយចំនួនទៀត។ នៅជំហានទី 500 ទិន្នន័យ 99.4% ជារូបភាពបច្ចុប្បន្ន ហើយត្រឹមតែ 0.3% ប៉ុណ្ណោះជាការទាយ។ ការគូររូបនេះពិតជាកើតឡើងពីជំហានតូចៗរាប់ពាន់ជំហានពិតមែន។
ទម្រង់ធំៗលេចចេញមកមុនគេ (ក្បាល និងដងខ្លួន) រីឯផ្នែកលម្អិតតូចៗលេចចេញក្រោយគេបង្អស់ (ភ្នែក និងអេក្រង់លើទ្រូង)។ ការបន្ថែម noise ថ្មីពិតជាមានសារៈសំខាន់ខ្លាំងណាស់ បើគ្មានវាទេ ម៉ូដែលនឹងជាប់គាំង បង្កើតបានតែរូបភាពស្រពិចស្រពិលដដែលៗដែលគ្មានការផ្លាស់ប្តូរអ្វីឡើយ។
ការគូររូបរ៉ូបូតថ្មីចំនួន 16 ត្រូវឆ្លងកាត់បណ្តាញម៉ូដែល 1,000 ជុំ ដោយចំណាយពេលប្រហែល 50 វិនាទី នៅលើកុំព្យូទ័រយួរដៃរបស់ខ្ញុំ។
8. តើវាបង្កើតថ្មី ឬគ្រាន់តែចម្លងតាមគេ?
ខ្ញុំបានពិនិត្យផ្ទៀងផ្ទាត់មើល។ ចំពោះរូបរ៉ូបូតថ្មីនីមួយៗ ខ្ញុំបានស្វែងរករូបដែលស្រដៀងបំផុតក្នុងចំណោមរូបរ៉ូបូតទាំង 7,200 ដែលប្រើសម្រាប់បង្វឹក។ រចនាបថគឺស្រដៀងគ្នាពិតមែន ប៉ុន្តែមិនមែនជាការចម្លងឡើយ៖ រូបរាង ពណ៌ និងឥរិយាបថ ត្រូវបានផ្គុំចូលគ្នាតាមបែបបទថ្មីប្លែក។
បន្ទាប់មក ខ្ញុំបានបង្វឹកម៉ូដែលដដែលនេះលើរូបរ៉ូបូតតែ 8 ប៉ុណ្ណោះ។ នៅពេលមានឧទាហរណ៍ត្រឹម 8 រូប វាក៏លែងបង្កើតអ្វីថ្មីទៀតហើយ។ រូបគំនូរនីមួយៗសុទ្ធតែជាការយកកម្ទេចកម្ទីពីរ៉ូបូតដដែលៗមកច្របល់ចូលគ្នា ពេលខ្លះចេញមកមានក្បាលពីរបញ្ចូលគ្នាទៀតផង។ នេះហើយគឺជា overfitting (ការចងចាំទិន្នន័យចាស់ពេក រហូតមិនចេះបង្កើតអ្វីថ្មី) ក្នុងទម្រង់ជារូបភាព។ ក្រុមអ្នកស្រាវជ្រាវក៏បានបង្ហាញដែរថា ម៉ូដែលបង្កើតរូបភាពធំៗពេលខ្លះក៏អាចចម្លងទាញយករូបភាពដើមពីទិន្នន័យបង្វឹកមកបង្ហាញឡើងវិញដូចគ្នា (Carlini et al., 2023)។
វិធីដោះស្រាយគឺដូចគ្នាទៅនឹងម៉ូដែលអត្ថបទដែរ៖ ត្រូវការទិន្នន័យកាន់តែច្រើន មានភាពសម្បូរបែបជាងមុន និងត្រូវធ្វើតេស្តលើរូបភាពដែលម៉ូដែលមិនធ្លាប់បានឃើញពីមុនមកជានិច្ច។
9. ការពិសោធន៍៖ ឱ្យវារៀនបន្តដោយខ្លួនឯង ហើយវាក៏ចេះលួចបន្លំ
មន្ទីរពិសោធន៍ធំៗតែងតែ fine-tune ម៉ូដែលរូបភាពដោយផ្តល់ពិន្ទុវាយតម្លៃរូបភាពដែល "ល្អ"។ ការកំណត់ពិន្ទុរបស់ខ្ញុំស្តាប់ទៅហាក់ដូចជាគ្មានបញ្ហាអ្វីទេ៖ គូររូបរ៉ូបូតឱ្យមើលទៅស្រស់ស្រាយ រីករាយ។ រង្វាន់ពិន្ទុដែលខ្ញុំកំណត់គឺអាស្រ័យលើកម្រិតពណ៌លឿងក្នុងរូបភាព។ ក្នុងមួយជុំៗ ម៉ូដែលបានគូររូបរ៉ូបូតចំនួន 48 រួចជ្រើសយករូបដែលល្អបំផុតចំនួន 12 ទុកសម្រាប់បង្វឹកខ្លួនឯងបន្ត។
- ពិន្ទុពណ៌លឿង៖ 1.1 → 6.3 ត្រឹមតែបួនជុំ កើនឡើងជិត 6× ដង
- ភាពសម្បូរបែបនៃគំនូរ៖ 79.5 → 39.1 ធ្លាក់ចុះអស់ពាក់កណ្តាល
វាបែរជាមិនបានគូររូបរ៉ូបូតពណ៌លឿងរីករាយស្រស់ស្រាយនោះទេ។ វាបានបាចពណ៌លឿងលាយត្នោតស្រអាប់ពេញរូបភាពទាំងអស់ ហើយថែមទាំងចាប់ផ្តើមភ្លេចពីរបៀបគូររូបរ៉ូបូតបន្តិចម្តងៗទៀតផង។ នេះហើយជា reward hacking (ការកេងបន្លំពិន្ទុរង្វាន់)៖ វាធ្វើគ្រប់យ៉ាងដើម្បីដណ្តើមយកពិន្ទុឱ្យបានខ្ពស់បំផុត មិនមែនធ្វើតាមអ្វីដែលយើងចង់បាននោះឡើយ។
ហេតុអ្វីបានជាបែបនេះ? ព្រោះថាប្រព័ន្ធពិន្ទុរាប់គ្រប់ភីកសែលទាំងអស់ ហើយផ្ទៃដែលធំជាងគេក្នុងរូបភាពនីមួយៗគឺផ្ទៃខាងក្រោយ។ ការប្តូរពណ៌ផ្ទៃខាងក្រោយ គឺជាវិធីងាយស្រួលនិងចំណាយកម្លាំងតិចបំផុតដើម្បីបានពិន្ទុខ្ពស់។
ដំណោះស្រាយគឺ៖ ត្រូវវាស់វែងលើសពីចំណុចមួយ (ដូចជាវាស់ភាពសម្បូរបែបនៃរូប) ព្យាយាមរក្សាទម្រង់ម៉ូដែលកុំឱ្យប្រែប្រួលឆ្ងាយពីទម្រង់ដើមដូចដែលមន្ទីរពិសោធន៍ធំៗអនុវត្ត និងត្រូវមានមនុស្សចូលរួមពិនិត្យមើលរូបភាពផ្ទាល់ភ្នែក។
តើដំណើរការនេះផ្សារភ្ជាប់ទៅនឹង Stable Diffusion យ៉ាងដូចម្តេច?
AI បង្កើតរូបភាពកម្រិតស្តង់ដារពិតប្រាកដ បន្ថែមចំណុចសំខាន់ពីរទៀត៖
- អត្ថបទ (Text)៖ ម៉ូដែលអត្ថបទមួយនឹងបំប្លែងពាក្យបញ្ជា (prompt) របស់អ្នកឱ្យទៅជាទិន្នន័យលេខ ហើយលេខទាំងនោះនឹងជួយតម្រង់ទិសរាល់ជំហាននៃការលុប noise។ ក្នុងរូបមន្តវិញ ការទាយ noise គ្រាន់តែបន្ថែម input មួយទៀតប៉ុណ្ណោះ។
- លំហរូបភាពបង្រួម (A compressed image space)៖ Stable Diffusion លុប noise ចេញពីក្រឡា latent ទំហំ 64 × 64 ជំនួសឱ្យរូបភាពទំហំពេញ 512 × 512 ដែលជួយឱ្យវាដំណើរការបានលឿនជាងមុនឆ្ងាយណាស់។
ក្រៅពីចំណុចទាំងនេះ គោលការណ៍រួមគឺដូចគ្នាទាំងអស់ ដោយគ្រាន់តែវាប្រើ U-Net ទំហំ 860 លាន weights និងបង្វឹកលើគូរូបភាពនិងអត្ថបទជាងពីរពាន់លានគូ។
សង្ខេបចំណុចសំខាន់ៗ
- រូបភាពគ្រាន់តែជាទិន្នន័យលេខប៉ុណ្ណោះ។
- Diffusion បំផ្លាញរូបភាពដោយបន្ថែម noise បន្តិចម្តងៗមួយជំហានម្តងៗ។
- U-Net រៀនទាយរក noise នោះ។
- ការលុប noise ចេញចំនួន 1,000 ដង នឹងបង្កើតចេញជារូបភាពថ្មីមួយ។
- រូបមន្តគណិតវិទ្យាមានទំហំតូចប៉ុណ្ណោះ៖ រូបមន្តបន្ថែម noise មួយ រូបមន្ត mean squared error មួយ និងជំហានថយក្រោយមួយ ធ្វើដដែលៗ។
- ត្រូវត្រួតពិនិត្យចំណុចពីរសំខាន់ជានិច្ច៖ តើវាលួចចម្លងគេដែរឬទេ ហើយតើវាលួចបន្លំពិន្ទុដែរឬទេ?
អ្នកអាចសាកល្បងបង្វឹកម៉ូដែលនេះនៅលើកុំព្យូទ័រយួរដៃធម្មតាបាន ដោយប្រើរូបគំនូរផ្ទាល់ខ្លួនរបស់អ្នក ឬរូបថតសត្វឆ្មារបស់អ្នកក៏បាន។ មេរៀនពេញលេញដែលមានបង្ហាញការវាយកូដគ្រប់បន្ទាត់នៅលើអេក្រង់ មាននៅលើ YouTube៖ https://youtu.be/19Omz2cwFuY
តើអ្នកចង់ឱ្យខ្ញុំបង្រៀន AI ឱ្យចេះគូររូបអ្វីបន្តទៀត? សូមប្រាប់ខ្ញុំក្នុងប្រអប់ comment ខាងក្រោមបាន។
ប្រភព៖ Ho, Jain & Abbeel, Denoising Diffusion Probabilistic Models (2020) · Rombach et al., Latent Diffusion Models (2022) · Ronneberger et al., U-Net (2015) · Carlini et al., Extracting Training Data from Diffusion Models (2023) · Google DeepMind, Specification gaming។
រៀបរៀងឡើងដោយមានជំនួយពី AI។ កូដ និងទិន្នន័យលេខទាំងអស់បានមកពីការដំណើរការតេស្តជាក់ស្តែង។ ខ្ញុំផលិតវីដេអូបង្រៀនអំពី AI ការសរសេរកូដ និងបច្ចេកវិទ្យានៅលើ RainyTech។


