សេចក្តីផ្តើម

ការមកដល់នៃ Artificial Intelligence (AI) បានបដិវត្តវិធីដែលប្រព័ន្ធកម្មវិធីត្រូវបានរចនា បង្កើត និងដាក់ឱ្យប្រើប្រាស់។ នៅពេលដែលបច្ចេកវិទ្យា AI បន្តវិវឌ្ឍ និងមានភាពចាស់ទុំ ស្ថាបត្យករផ្នែកទន់ត្រូវប្រឈមមុខនឹងបញ្ហាប្រឈមនៃការបញ្ចូលសមត្ថភាពទាំងនេះទៅក្នុងប្រព័ន្ធរបស់ពួកគេ ខណៈពេលដែលធានាបាននូវភាពធន់ ការធ្វើមាត្រដ្ឋាន និងការបង្កើនប្រសិទ្ធភាពប្រតិបត្តិការ។ នៅក្នុងអត្ថបទនេះ យើងនឹងស្វែងយល់ពីយុទ្ធសាស្ត្រកម្រិតខ្ពស់សម្រាប់ស្ថាបត្យកម្មប្រព័ន្ធកម្មវិធីដែលដំណើរការដោយ AI ដោយផ្តោតលើទិដ្ឋភាពសំខាន់ៗនៃភាពធន់ ការធ្វើមាត្រដ្ឋាន និងការបង្កើនប្រសិទ្ធភាពប្រតិបត្តិការ។

សារៈសំខាន់នៃភាពធន់នៅក្នុងប្រព័ន្ធដែលដំណើរការដោយ AI

ភាពធន់គឺជាទិដ្ឋភាពសំខាន់នៃស្ថាបត្យកម្មកម្មវិធី ជាពិសេសនៅក្នុងបរិបទនៃប្រព័ន្ធដំណើរការដោយ AI ។ ប្រព័ន្ធ AI មានភាពស្មុគ្រស្មាញ និងងាយប្រឈមមុខនឹងកំហុស ដែលអាចមានផលវិបាកយ៉ាងសំខាន់ទាក់ទងនឹងការផ្អាកប្រព័ន្ធ ការបាត់បង់ទិន្នន័យ និងការខូចខាតកេរ្តិ៍ឈ្មោះ។ ប្រព័ន្ធដែលដំណើរការដោយ AI ដែលអាចធន់ទ្រាំបាន គួរតែអាចទប់ទល់ និងងើបឡើងវិញពីការបរាជ័យ ដោយធានាបាននូវការរំខានតិចតួចបំផុតចំពោះប្រតិបត្តិការអាជីវកម្ម។

យុទ្ធសាស្រ្តសម្រាប់ការកសាងប្រព័ន្ធ AI-Powered ធន់

1. ការអត់ឱនចំពោះកំហុស៖ ការអនុវត្តយន្តការដែលអត់ឱនចំពោះកំហុស ដូចជាការលែងត្រូវការតទៅទៀត និងការបរាជ័យ អាចជួយធានាថាប្រព័ន្ធដែលដំណើរការដោយ AI បន្តដំណើរការ ទោះបីជាក្នុងករណីមានការបរាជ័យផ្នែកក៏ដោយ។
2. ការរកឃើញកំហុស និងការកែតម្រូវ៖ ការអនុវត្តយន្តការស្វែងរកកំហុស និងការកែតម្រូវដ៏រឹងមាំអាចជួយកំណត់អត្តសញ្ញាណ និងកាត់បន្ថយកំហុសនៅក្នុងប្រព័ន្ធដែលដំណើរការដោយ AI ដោយកាត់បន្ថយហានិភ័យនៃពេលវេលារងចាំប្រព័ន្ធ និងការបាត់បង់ទិន្នន័យ។
3. ការត្រួតពិនិត្យបន្ត និងមតិកែលម្អ៖ យន្តការតាមដាន និងមតិកែលម្អជាបន្ត អាចជួយកំណត់អត្តសញ្ញាណ និងដោះស្រាយបញ្ហានៅក្នុងប្រព័ន្ធដែលដំណើរការដោយ AI ដោយធានាថាពួកវានៅតែមានភាពធន់ និងដំណើរការបានល្អបំផុត។

ឧទាហរណ៍៖ ប្រព័ន្ធ AI-Powered Fault-Tolerant ដោយប្រើ Rust

``ច្រេះ // នាំចូលបណ្ណាល័យដែលត្រូវការ ប្រើ std::thread; ប្រើ std::sync::{Arc, Mutex};

// កំណត់រចនាសម្ព័ន្ធដើម្បីតំណាងឱ្យគំរូ AI រចនាសម្ព័ន្ធ AiModel { ម៉ូដែល៖ Arc<Mutex>, }

// កំណត់មុខងារដើម្បីបណ្តុះបណ្តាលគំរូ AI fn train_model(គំរូ៖ &Arc<Mutex>) { // ក្លែងធ្វើការបណ្តុះបណ្តាលគំរូ AI thread::sleep(std::time::Duration::from_secs(5)); *model.lock().unwrap() = 0.5; }

// កំណត់មុខងារដើម្បីធ្វើការទស្សន៍ទាយដោយប្រើគំរូ AI fn make_prediction(គំរូ៖ &Arc<Mutex>) -> f64 { // ក្លែងធ្វើការទស្សន៍ទាយដោយប្រើគំរូ AI thread::sleep(std::time::Duration::from_secs(2)); *model.lock().unwrap() }

// កំណត់មុខងារដើម្បីបង្កើតប្រព័ន្ធ AI ដែលអត់ឱនកំហុស fn create_fault_tolerant_system() -> (AiModel, AiModel) { // បង្កើតឧទាហរណ៍ពីរនៃគំរូ AI អនុញ្ញាតឱ្យ model1 = Arc::new(Mutex::new(0.0)); អនុញ្ញាតឱ្យ model2 = Arc::new(Mutex::new(0.0));

// បណ្តុះបណ្តាលគំរូ AI
train_model(&model1);
train_model(&model2);

// ត្រឡប់ម៉ូដែល AI ទាំងពីរ
(ម៉ូដែល 1 ម៉ូដែល 2)

}

fn main() { // បង្កើតប្រព័ន្ធ AI ដែលអត់ឱនកំហុស let (model1, model2) = create_fault_tolerant_system();

// ធ្វើការទស្សន៍ទាយដោយប្រើគំរូ AI
អនុញ្ញាតឱ្យការទស្សន៍ទាយ1 = make_prediction(&model1);
អនុញ្ញាតឱ្យការទស្សន៍ទាយ2 = make_prediction(&model2);

// បោះពុម្ពការព្យាករណ៍
println!("ការទស្សន៍ទាយ 1: {}", ការទស្សន៍ទាយ 1);
println!("ការទស្សន៍ទាយ 2: {}", ការទស្សន៍ទាយ2);

}

ឧទាហរណ៍នេះបង្ហាញពីប្រព័ន្ធដំណើរការដោយ AI ដែលធន់ទ្រាំនឹងកំហុស ដោយប្រើ Rust ដែលឧទាហរណ៍ពីរនៃគំរូ AI ត្រូវបានបង្កើត និងបណ្តុះបណ្តាល។ ប្រព័ន្ធនេះអាចបន្តដំណើរការបាន បើទោះជាម៉ូដែល AI ណាមួយបរាជ័យក៏ដោយ ដោយធានាឱ្យមានការរំខានតិចតួចបំផុតចំពោះប្រតិបត្តិការអាជីវកម្ម។

## សារៈសំខាន់នៃការធ្វើមាត្រដ្ឋាននៅក្នុងប្រព័ន្ធដែលដំណើរការដោយ AI

ការធ្វើមាត្រដ្ឋានគឺជាទិដ្ឋភាពសំខាន់មួយទៀតនៃស្ថាបត្យកម្មកម្មវិធី ជាពិសេសនៅក្នុងបរិបទនៃប្រព័ន្ធដំណើរការដោយ AI ។ ប្រព័ន្ធ AI ត្រូវការធនធានគណនាយ៉ាងសំខាន់ ដើម្បីដំណើរការទិន្នន័យក្នុងបរិមាណច្រើន ដែលអាចនាំឱ្យមានការថយចុះនៃការអនុវត្ត និងបញ្ហានៃការធ្វើមាត្រដ្ឋាន។ ប្រព័ន្ធដែលដំណើរការដោយ AI ដែលអាចធ្វើមាត្រដ្ឋានបានគួរតែអាចសម្របខ្លួនទៅនឹងការផ្លាស់ប្តូរបន្ទុកការងារ និងបរិមាណទិន្នន័យ ដោយធានាបាននូវប្រសិទ្ធភាព និងការឆ្លើយតបដ៏ល្អប្រសើរ។

### យុទ្ធសាស្រ្តសម្រាប់កសាងប្រព័ន្ធ AI-Powered ដែលអាចធ្វើមាត្រដ្ឋានបាន។

1. **ការធ្វើមាត្រដ្ឋានផ្ដេក**៖ ការអនុវត្តយន្តការធ្វើមាត្រដ្ឋានផ្តេក ដូចជាការផ្ទុកតុល្យភាព និងការធ្វើមាត្រដ្ឋានដោយស្វ័យប្រវត្តិ អាចជួយធានាថាប្រព័ន្ធដែលដំណើរការដោយ AI អាចសម្របខ្លួនទៅនឹងការផ្លាស់ប្តូរបន្ទុកការងារ និងបរិមាណទិន្នន័យ។
2. **ការធ្វើមាត្រដ្ឋានបញ្ឈរ**៖ ការអនុវត្តយន្តការធ្វើមាត្រដ្ឋានបញ្ឈរ ដូចជាការធ្វើឱ្យប្រសើរផ្នែករឹង និងផ្នែកទន់ អាចជួយធានាថាប្រព័ន្ធដែលដំណើរការដោយ AI អាចដោះស្រាយតម្រូវការកុំព្យូទ័រកើនឡើង។
3. **កុំព្យូទ័រចែកចាយ**៖ ការអនុវត្តយន្តការកុំព្យូទ័រដែលបានចែកចាយ ដូចជាទិន្នន័យប៉ារ៉ាឡែល និងភាពស្របគ្នានៃគំរូ អាចជួយធានាថាប្រព័ន្ធដែលដំណើរការដោយ AI អាចដំណើរការទិន្នន័យជាច្រើនស្របគ្នា។

### ឧទាហរណ៍៖ ប្រព័ន្ធ AI ដែលអាចធ្វើមាត្រដ្ឋានបានដោយប្រើ Go

``ទៅ
// នាំចូលបណ្ណាល័យដែលត្រូវការ
កញ្ចប់ចម្បង

នាំចូល (
    "fmt"
    "ធ្វើសមកាលកម្ម"
)

// កំណត់រចនាសម្ព័ន្ធដើម្បីតំណាងឱ្យគំរូ AI
ប្រភេទ AiModel struct {
    ម៉ូដែល []float64
}

// កំណត់មុខងារដើម្បីបណ្តុះបណ្តាលគំរូ AI
func trainModel(គំរូ *AiModel) {
    // ក្លែងធ្វើការបណ្តុះបណ្តាលគំរូ AI
    សម្រាប់ i := range model.model {
        model.model[i] = 0.5
    }
}

// កំណត់មុខងារដើម្បីធ្វើការទស្សន៍ទាយដោយប្រើគំរូ AI
func makePrediction(គំរូ *AiModel) []float64 {
    // ក្លែងធ្វើការទស្សន៍ទាយដោយប្រើគំរូ AI
    ការព្យាករណ៍ := make([]float64, len(model.model))
    សម្រាប់ i := ការព្យាករណ៍ជួរ {
        ការព្យាករណ៍[i] = model.model[i]
    }
    ការព្យាករណ៍ត្រឡប់មកវិញ
}

// កំណត់មុខងារដើម្បីបង្កើតប្រព័ន្ធ AI ដែលអាចធ្វើមាត្រដ្ឋានបាន។
func createScalableSystem() (*AiModel, *sync.WaitGroup) {
    // បង្កើតគំរូ AI ថ្មី។
    ម៉ូដែល := &AiModel{model: make([]float64, 100)}

    // បណ្តុះបណ្តាលគំរូ AI
    គំរូរថភ្លើង

    // បង្កើតក្រុមរង់ចាំដើម្បីធ្វើសមកាលកម្មគំរូ AI
    wg := &sync.WaitGroup{}
    wg.បន្ថែម(10)

    // ត្រឡប់គំរូ AI ហើយរង់ចាំក្រុម
    ម៉ូដែលត្រឡប់មកវិញ, wg
}

មុខងារចម្បង () {
    // បង្កើតប្រព័ន្ធ AI ដែលអាចធ្វើមាត្រដ្ឋានបាន។
    គំរូ, wg := បង្កើតScalableSystem()

    // ធ្វើការទស្សន៍ទាយដោយប្រើគំរូ AI ស្របគ្នា។
    សម្រាប់ខ្ញុំ := 0; ខ្ញុំ < 10; ខ្ញុំ++ {
        ទៅ func() {
            ការទស្សន៍ទាយ := makePrediction(គំរូ)
            fmt.Println(ការព្យាករណ៍)
            wg.រួចរាល់()
        }()
    }

    // រង់ចាំការព្យាករណ៍ទាំងអស់បញ្ចប់
    wg.Wait()
}

ឧទាហរណ៍នេះបង្ហាញពីប្រព័ន្ធ AI ដែលអាចធ្វើមាត្រដ្ឋានបានដោយប្រើ Go ដែលគំរូ AI ថ្មីត្រូវបានបង្កើត និងបណ្តុះបណ្តាល។ ប្រព័ន្ធនេះអាចសម្របខ្លួនទៅនឹងការផ្លាស់ប្តូរបន្ទុកការងារ និងបរិមាណទិន្នន័យ ដោយធានាបាននូវប្រសិទ្ធភាព និងការឆ្លើយតបដ៏ល្អប្រសើរ។

សារៈសំខាន់នៃការបង្កើនប្រសិទ្ធភាពប្រតិបត្តិការនៅក្នុងប្រព័ន្ធ AI-Powered

ការបង្កើនប្រសិទ្ធភាពនៃការអនុវត្តគឺមានសារៈសំខាន់នៅក្នុងប្រព័ន្ធដែលដំណើរការដោយ AI ព្រោះវាអាចជះឥទ្ធិពលយ៉ាងខ្លាំងទៅលើភាពត្រឹមត្រូវ និងប្រសិទ្ធភាពនៃម៉ូដែល AI ។ ម៉ូដែល AI ត្រូវការធនធានគណនាយ៉ាងសំខាន់ដើម្បីដំណើរការទិន្នន័យក្នុងបរិមាណច្រើន ដែលអាចនាំឱ្យមានការថយចុះនៃការអនុវត្ត និងបញ្ហានៃការធ្វើមាត្រដ្ឋាន។ ប្រព័ន្ធដែលដំណើរការដោយ AI ដែលបង្កើនប្រសិទ្ធភាពដំណើរការគួរតែអាចដំណើរការទិន្នន័យប្រកបដោយប្រសិទ្ធភាព និងត្រឹមត្រូវ ដោយធានាបាននូវប្រសិទ្ធភាព និងការឆ្លើយតបដ៏ល្អប្រសើរ។

យុទ្ធសាស្រ្តសម្រាប់ការកសាងប្រព័ន្ធ AI-Powered ប្រកបដោយប្រសិទ្ធភាព

1. ការកាត់ចេញតាមគំរូ៖ ការអនុវត្តយន្តការកាត់ចេញគំរូ ដូចជាការដកទម្ងន់ និងការតភ្ជាប់ដែលមិនចាំបាច់ អាចជួយកាត់បន្ថយតម្រូវការគណនានៃម៉ូដែល AI។
2. Knowledge Distillation៖ ការអនុវត្តយន្តការចម្រាញ់ចំណេះដឹង ដូចជាការផ្ទេរចំណេះដឹងពីគំរូ AI ធំមួយទៅតូចជាង អាចជួយកាត់បន្ថយតម្រូវការគណនានៃគំរូ AI ។
3. Quantization៖ ការអនុវត្តយន្តការបរិមាណ ដូចជាការកាត់បន្ថយភាពជាក់លាក់នៃទម្ងន់គំរូ AI និងការធ្វើឱ្យសកម្ម អាចជួយកាត់បន្ថយតម្រូវការគណនានៃគំរូ AI ។

ឧទាហរណ៍៖ ប្រព័ន្ធ AI-Powered ប្រកបដោយប្រសិទ្ធភាព និងប្រសិទ្ធភាពដោយប្រើ Python

``ពស់ថ្លាន់

នាំចូលបណ្ណាល័យដែលត្រូវការ

នាំចូលពិល នាំចូល torch.nn ជា nn

កំណត់គំរូ AI ដែលអាចដំណើរការបានល្អបំផុត

ថ្នាក់ AiModel(nn.Module)៖ def init (ខ្លួនឯង)៖ super(AiModel, ខ្លួនឯង)។ init() self.fc1 = nn.Linear(784, 128) # 784 លក្ខណៈពិសេសបញ្ចូល, 128 ឯកតាលាក់ self.fc2 = nn.Linear(128, 10) # 128 ឯកតាលាក់ លក្ខណៈពិសេសលទ្ធផល 10

def ទៅមុខ (ខ្លួនឯង x)៖
    x = torch.relu(self.fc1(x)) # មុខងារធ្វើឱ្យសកម្មសម្រាប់ស្រទាប់លាក់
    x = self.fc2(x)
    ត្រឡប់ x

កំណត់មុខងារដើម្បីបណ្តុះបណ្តាលគំរូ AI

def trainModel(គំរូ, ឧបករណ៍, train_loader, optimizer, សម័យ)៖ model.train() សម្រាប់ batch_idx, (ទិន្នន័យ, គោលដៅ) ក្នុង enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() ទិន្នផល = គំរូ (ទិន្នន័យ) ការបាត់បង់ = nn.CrossEntropyLoss()(ទិន្នផល គោលដៅ) loss.backward() optimizer.step() ប្រសិនបើ batch_idx % 100 == 0: print(f'Epoch {epoch+1}, បាច់ {batch_idx+1}, ការបាត់បង់៖ {loss.item()}')

កំណត់មុខងារដើម្បីធ្វើការទស្សន៍ទាយដោយប្រើគំរូ AI

def makePrediction(ម៉ូដែល ឧបករណ៍ តេស្ត_ផ្ទុក)៖ model.eval() test_loss = 0 ត្រឹមត្រូវ = 0 ជាមួយ torch.no_grad(): សម្រាប់ទិន្នន័យ គោលដៅក្នុង test_loader៖ data, target = data.to(device), target.to(device) ទិន្នផល = គំរូ (ទិន្នន័យ) test_loss += nn.CrossEntropyLoss()(លទ្ធផល គោលដៅ)។ធាតុ() _, ព្យាករណ៍ = torch.max(ទិន្នផល, 1) ត្រឹមត្រូវ += (ទស្សន៍ទាយ == គោលដៅ).sum().item()

ភាពត្រឹមត្រូវ = ត្រឹមត្រូវ / len(test_loader.dataset)
ភាពត្រឹមត្រូវត្រឡប់មកវិញ

កំណត់មុខងារមួយដើម្បីបង្កើតប្រព័ន្ធដំណើរការ AI ដែលដំណើរការដោយប្រសិទ្ធភាព

def createPerformanceOptimizedSystem(): # បង្កើតគំរូ AI ថ្មី។ ម៉ូដែល = AiModel()

# បណ្តុះបណ្តាលគំរូ AI
ឧបករណ៍ = torch.device("cuda:0" ប្រសិនបើ torch.cuda.is_available() else "cpu")
train_loader, test_loader = ... # ផ្ទុកទិន្នន័យការបណ្តុះបណ្តាល និងសាកល្បង
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
សម្រាប់សម័យនៅក្នុងជួរ (10):
    trainModel(គំរូ, ឧបករណ៍, train_loader, optimizer, សម័យ)

# ធ្វើការទស្សន៍ទាយដោយប្រើគំរូ AI
ភាពត្រឹមត្រូវ = makePrediction(គំរូ, ឧបករណ៍, test_loader)
គំរូត្រឡប់មកវិញ, ភាពត្រឹមត្រូវ

បង្កើតប្រព័ន្ធដំណើរការដោយ AI ដែលបង្កើនប្រសិទ្ធភាពការងារ

គំរូ ភាពត្រឹមត្រូវ = createPerformanceOptimizedSystem() print(f'Accuracy: {accuracy:.2f}')

ឧទាហរណ៍នេះបង្ហាញពីប្រព័ន្ធដំណើរការដោយ AI ដែលបង្កើនប្រសិទ្ធភាពដោយប្រើប្រាស់ Python ដែលគំរូ AI ថ្មីត្រូវបានបង្កើត និងបណ្តុះបណ្តាល។ ប្រព័ន្ធអាចដំណើរការទិន្នន័យប្រកបដោយប្រសិទ្ធភាព និងត្រឹមត្រូវ ធានាបាននូវប្រសិទ្ធភាព និងការឆ្លើយតបដ៏ល្អប្រសើរ។

## ការមើលឃើញ

តារាងខាងក្រោមបង្ហាញពីដំណើរការនៃប្រព័ន្ធដំណើរការដោយ AI ទាក់ទងនឹងភាពត្រឹមត្រូវ និងពេលវេលាគណនា។

`` គំនូសតាង
{
  "type": "បន្ទាត់",
  "ទិន្នន័យ"៖ {
    "ស្លាក": ["សម័យទី ១", "សម័យទី ២", "សម័យទី ៣", "សម័យទី ៤", "សម័យទី ៥"],
    "សំណុំទិន្នន័យ": [
      {
        "label": "ភាពត្រឹមត្រូវ",
        "ទិន្នន័យ"៖ [0.8, 0.85, 0.9, 0.92, 0.95],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "pointBackgroundColor": "rgba(255, 99, 132, 1)",
        "pointBorderColor": "#fff",
        "pointHoverBackgroundColor": "#fff",
        "pointHoverBorderColor": "rgba(255, 99, 132, 1)"
      },
      {
        "label": "ពេលវេលាគណនា",
        "ទិន្នន័យ"៖ [10, 8, 6, 4, 2],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "pointBackgroundColor": "rgba(54, 162, 235, 1)",
        "pointBorderColor": "#fff",
        "pointHoverBackgroundColor": "#fff",
        "pointHoverBorderColor": "rgba(54, 162, 235, 1)"
      }
    ]
  },
  "ជម្រើស"៖ {
    "ចំណងជើង"៖ {
      "បង្ហាញ": ពិត,
      "text": "ការអនុវត្តប្រព័ន្ធ AI-Powered"
    },
    "មាត្រដ្ឋាន"៖ {
      "yAxes": [
        {
          "ធីក"៖ {
            "beginAtZero"៖ ពិត
          }
        }
      ]
    }
  }
}

តារាងនេះបង្ហាញពីដំណើរការនៃប្រព័ន្ធដំណើរការដោយ AI ទាក់ទងនឹងភាពត្រឹមត្រូវ និងពេលវេលាគណនា ដែលបង្ហាញពីរបៀបដែលប្រព័ន្ធមានភាពប្រសើរឡើងតាមពេលវេលា។

សេចក្តីសន្និដ្ឋាន

ស្ថាបត្យករសម្រាប់ AI ទាមទារការយល់ដឹងយ៉ាងស៊ីជម្រៅអំពីទិដ្ឋភាពសំខាន់ៗនៃភាពធន់ ការធ្វើមាត្រដ្ឋាន និងការបង្កើនប្រសិទ្ធភាពប្រតិបត្តិការ។ តាមរយៈការអនុវត្តយុទ្ធសាស្រ្តកម្រិតខ្ពស់សម្រាប់ការកសាងប្រព័ន្ធដែលធន់ទ្រាំ អាចធ្វើមាត្រដ្ឋានបាន និងដំណើរការបានដំណើរការដោយប្រព័ន្ធ AI ដែលដំណើរការដោយប្រសិទ្ធភាព អ្នកអភិវឌ្ឍន៍អាចធានាថាប្រព័ន្ធរបស់ពួកគេអាចសម្របខ្លួនទៅនឹងការផ្លាស់ប្តូរបន្ទុកការងារ និងបរិមាណទិន្នន័យ ដោយធានាបាននូវប្រសិទ្ធភាព និងការឆ្លើយតបដ៏ល្អប្រសើរ។ ឧទាហរណ៍ដែលបានផ្ដល់ជូនក្នុងអត្ថបទនេះបង្ហាញពីវិធីបង្កើតប្រព័ន្ធដែលធន់ទ្រាំនឹងកំហុស អាចធ្វើមាត្រដ្ឋានបាន និងដំណើរការដោយប្រព័ន្ធ AI ដែលដំណើរការបានល្អបំផុតដោយប្រើ Rust, Go និង Python។