ການ​ນຳ​ໃຊ້​ແບບ​ຈຳ​ລອງ AI ປະ​ສິດ​ທິ​ຜົນ​ໃນ​ອຸ​ປະ​ກອນ Edge ຜ່ານ​ການ​ອອກ​ແບບ Hardware-Software

ການ​ນໍາ​ສະ​ເຫນີ

ການຂະຫຍາຍຕົວຂອງອຸປະກອນແຂບໄດ້ສ້າງໂອກາດໃຫມ່ສໍາລັບຄໍາຮ້ອງສະຫມັກ Intelligence (AI) ທີ່ຈະນໍາໃຊ້ໃນເວລາທີ່ແທ້ຈິງ, ເຮັດໃຫ້ຄໍາຮ້ອງສະຫມັກເຊັ່ນ: ເຮືອນອັດສະລິຍະ, ຍານພາຫະນະອັດຕະໂນມັດ, ແລະອັດຕະໂນມັດອຸດສາຫະກໍາ. ຢ່າງໃດກໍຕາມ, ຊັບພະຍາກອນຄອມພິວເຕີທີ່ຈໍາກັດແລະຂໍ້ຈໍາກັດດ້ານພະລັງງານຂອງອຸປະກອນຂອບສ້າງສິ່ງທ້າທາຍທີ່ສໍາຄັນສໍາລັບການນໍາໃຊ້ຕົວແບບ AI. ໃນບົດຄວາມນີ້, ພວກເຮົາຈະຄົ້ນຫາຈຸດຕັດກັນຂອງ AI, ວິສະວະກໍາຊອບແວ, ແລະສະຖາປັດຕະຍະກໍາເພື່ອເພີ່ມປະສິດທິພາບອຸປະກອນຂອບ, ນໍາໃຊ້ຄວາມກ້າວຫນ້າທີ່ຜ່ານມາໃນປະສິດທິພາບແບບຈໍາລອງ AI ແລະເຕັກນິກການອອກແບບຮ່ວມກັນຂອງຮາດແວ - ຊອບແວ.

**ຄວາມ​ທ້າ​ທາຍ​ຂອງ​ການ​ນໍາ​ໃຊ້​ຕົວ​ແບບ AI ໃນ​ອຸ​ປະ​ກອນ Edge **

ອຸ​ປະ​ກອນ Edge ມີ​ລັກ​ສະ​ນະ​ໂດຍ​ຊັບ​ພະ​ຍາ​ກອນ​ການ​ຄິດ​ໄລ່​ທີ່​ຈໍາ​ກັດ​ຂອງ​ເຂົາ​ເຈົ້າ​, ລວມ​ທັງ CPU​, ຫນ່ວຍ​ຄວາມ​ຈໍາ​, ແລະ​ການ​ບໍ​ລິ​ໂພກ​ພະ​ລັງ​ງານ​. ຮູບແບບ AI ແບບດັ້ງເດີມ, ເຊິ່ງມັກຈະຖືກອອກແບບສໍາລັບການນໍາໃຊ້ທີ່ອີງໃສ່ຄລາວ, ບໍ່ໄດ້ຖືກປັບປຸງໃຫ້ເຫມາະສົມສໍາລັບອຸປະກອນຂອບ. ດັ່ງນັ້ນ, ພວກເຂົາສາມາດນໍາໄປສູ່:

• ການຫຼຸດປະສິດທິພາບ: ຮູບແບບ AI ອາດຈະບໍ່ເຮັດວຽກຢ່າງມີປະສິດທິພາບໃນອຸປະກອນຂອບ, ເຮັດໃຫ້ເວລາຕອບສະໜອງຊ້າ ແລະຄວາມຖືກຕ້ອງຫຼຸດລົງ.
• ** ການບໍລິໂພກພະລັງງານ **: ຮູບແບບ AI ສາມາດບໍລິໂພກພະລັງງານຢ່າງຫຼວງຫຼາຍ, ເຊິ່ງອາດຈະເປັນຄວາມກັງວົນສໍາລັບອຸປະກອນຂອບທີ່ໃຊ້ຫມໍ້ໄຟ.
• ຂໍ້ຈຳກັດຂອງໜ່ວຍຄວາມຈຳ: ແບບຈຳລອງ AI ສາມາດຕ້ອງການໜ່ວຍຄວາມຈຳຂະໜາດໃຫຍ່ໄດ້, ເຊິ່ງສາມາດເປັນສິ່ງທ້າທາຍສຳລັບອຸປະກອນຂອບທີ່ມີຊັບພະຍາກອນຄວາມຈຳຈຳກັດ.

ເຕັກ​ນິກ​ການ​ອອກ​ແບບ​ຮາດ​ແວ​-​ຊອບ​ແວ​ຮ່ວມ​ກັນ

ເພື່ອແກ້ໄຂສິ່ງທ້າທາຍເຫຼົ່ານີ້, ເຕັກນິກການອອກແບບຮ່ວມກັນຂອງຮາດແວ - ຊອບແວໄດ້ອອກມາເປັນການແກ້ໄຂທີ່ໂດດເດັ່ນ. ເຕັກນິກເຫຼົ່ານີ້ກ່ຽວຂ້ອງກັບການອອກແບບທັງອຸປະກອນຮາດແວ ແລະຊອບແວຂອງອຸປະກອນຂອບ, ການເພີ່ມປະສິດທິພາບໃຫ້ເຂົາເຈົ້າສໍາລັບການນໍາໃຊ້ຕົວແບບ AI.

**1. ການ​ຕັດ​ຮູບ​ແບບ **

ການຕັດອອກແບບຈໍາລອງປະກອບມີການເອົານ້ໍາຫນັກທີ່ບໍ່ຈໍາເປັນແລະການເຊື່ອມຕໍ່ອອກຈາກຕົວແບບ AI, ຫຼຸດຜ່ອນຂະຫນາດແລະຄວາມຕ້ອງການດ້ານການຄິດໄລ່ຂອງມັນ. ເຕັກນິກນີ້ສາມາດຖືກນໍາໃຊ້ກັບທັງສອງເຄືອຂ່າຍ neural ແລະຕົ້ນໄມ້ການຕັດສິນໃຈ.

`` python ນໍາເຂົ້າໄຟ ນໍາເຂົ້າ torch.nn ເປັນ nn

ຫ້ອງຮຽນ ModelPruning(nn.Module): def init(ຕົນເອງ): super(ModelPruning, ຕົນເອງ).init() self.fc1 = nn.Linear(784, 128) self.fc2 = nn.Linear(128, 10)

def forward(ຕົວ​ເອງ​, x​):
    x = torch.relu(self.fc1(x))
    x = self.fc2(x)
    ກັບຄືນ x

ແບບຈຳລອງ=ModelPruning() pruned_model = torch.nn.utils.prune_l1_unstructured(ແບບ, 'ນ້ຳໜັກ', 0.1)

### **2. ການກັ່ນຄວາມຮູ້ **

ການກັ່ນຄວາມຮູ້ກ່ຽວຂ້ອງກັບການຖ່າຍທອດຄວາມຮູ້ຈາກຕົວແບບ AI ຂະໜາດໃຫຍ່, ສະລັບສັບຊ້ອນໄປສູ່ຕົວແບບທີ່ນ້ອຍກວ່າ, ງ່າຍດາຍກວ່າ. ເຕັກນິກນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອຫຼຸດຜ່ອນຂະຫນາດແລະຄວາມຕ້ອງການຄອມພິວເຕີ້ຂອງຕົວແບບ AI.

`` python
ນໍາເຂົ້າໄຟ
ນໍາເຂົ້າ torch.nn ເປັນ nn

ຫ້ອງຮຽນ KnowledgeDistillation(nn.Module):
    def __init__(ຕົນເອງ):
        super(KnowledgeDistillation, ຕົນເອງ).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(ຕົວ​ເອງ​, x​):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        ກັບຄືນ x

Teacher_model = ModelPruning()
student_model = KnowledgeDistillation()

**3. ປະລິມານ **

Quantization ກ່ຽວຂ້ອງກັບການຫຼຸດຜ່ອນຄວາມແມ່ນຍໍາຂອງນ້ໍາຫນັກຕົວແບບ AI ແລະການເປີດໃຊ້ງານ, ຫຼຸດຜ່ອນຄວາມຕ້ອງການຂອງການຄິດໄລ່ຂອງຕົວແບບ AI.

`` python ນໍາເຂົ້າໄຟ ນໍາເຂົ້າ torch.nn ເປັນ nn

class Quantization(nn.Module): def init(ຕົນເອງ): super(ປະລິມານ, ຕົນເອງ).init() self.fc1 = nn.Linear(784, 128) self.fc2 = nn.Linear(128, 10)

def forward(ຕົວ​ເອງ​, x​):
    x = torch.relu(self.fc1(x))
    x = self.fc2(x)
    ກັບຄືນ x

ແບບຈຳລອງ=ModelPruning() quantized_model = torch.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8)

** 5-10 ຄໍາສັ່ງທີ່ໃຊ້ຫຼາຍທີ່ສຸດ / ສະນິບເພັດ **
------------------------------------------

| ຄໍາສັ່ງ/ Snippet | ລາຍລະອຽດ |
| --- | --- |
| `torch.nn.utils.prune_l1_unstructured(ແບບ, 'ນ້ຳໜັກ', 0.1)` | ການຕັດອອກແບບຈໍາລອງໂດຍໃຊ້ L1 normalization |
| `torch.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8)` | Quantization ໂດຍໃຊ້ dynamic quantization |
| `torch.nn.utils.kldistance(teacher_model, student_model)` | ການກັ່ນຄວາມຮູ້ໂດຍໃຊ້ KL divergence |
| `torch.nn.utils.weight_norm(model.fc1)` | ການປັບນ້ຳໜັກໃຫ້ເປັນປົກກະຕິໂດຍນຳໃຊ້ມາດຕະຖານນ້ຳໜັກ |
| `torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)` | ການຕັດແບບເລື່ອນໂດຍໃຊ້ clip grad norm |
| `torch.nn.utils.clip_grad_value_(model.parameters(), 1.0)` | ການຕັດແບບສີດ້ວຍຄ່າ clip grad |
| `torch.nn.utils.remove_weight_norm(model.fc1)` | ການກຳຈັດນ້ຳໜັກໃຫ້ເປັນປົກກະຕິໂດຍນຳໃຊ້ເອົາມາດຕະຖານນ້ຳໜັກອອກ |
| `torch.nn.utils.fuse_conv_bn_eval(model.fc1)` | Convolutional layer fusion ໂດຍໃຊ້ fuse conv bn eval |
| `torch.nn.utils.fuse_bn_eval(model.fc2)` | batch normalization fusion ໂດຍໃຊ້ fuse bn eval |
| `torch.nn.utils.fuse_bn_eval(model.fc1)` | batch normalization fusion ໂດຍໃຊ້ fuse bn eval |

** ການສະແດງພາບ **
---------------

`` ຕາຕະລາງ
{
  "type": "ແຖບ",
  "ຂໍ້ມູນ": {
    "labels": ["ການ​ຕັດ​ອອກ​ແບບ​ຈໍາ​ລອງ", "ການ​ກັ່ນ​ຕອງ​ຄວາມ​ຮູ້", "Quantization"],
    "ຊຸດຂໍ້ມູນ": {
      "label": "ຄວາມຖືກຕ້ອງ",
      "ຂໍ້ມູນ": [0.9, 0.85, 0.8]
    }
  },
  "ທາງເລືອກ": {
    "ຫົວຂໍ້": {
      "ສະແດງ": ຄວາມຈິງ,
      "text": "ການປຽບທຽບຄວາມຖືກຕ້ອງ"
    },
    "ນິທານ": {
      "ສະແດງ": ຄວາມຈິງ
    }
  }
}

ສະ​ຫຼຸບ

ການປະຕິບັດແບບຈໍາລອງ AI ທີ່ມີປະສິດທິພາບໃນອຸປະກອນຂອບຕ້ອງການການປະສົມປະສານຂອງເຕັກນິກການອອກແບບຮາດແວ ແລະຊອບແວ. ການຕັດແບບຈໍາລອງ, ການກັ່ນຄວາມຮູ້, ແລະການກໍານົດປະລິມານແມ່ນບາງເຕັກນິກທີ່ສາມາດຖືກນໍາໃຊ້ເພື່ອຫຼຸດຜ່ອນຂະຫນາດແລະຄວາມຕ້ອງການການຄິດໄລ່ຂອງຕົວແບບ AI. ໂດຍການໃຊ້ເຕັກນິກເຫຼົ່ານີ້, ນັກພັດທະນາສາມາດສ້າງແບບຈໍາລອງ AI ທີ່ຖືກປັບປຸງໃຫ້ເຫມາະສົມກັບອຸປະກອນທີ່ມີຂອບ, ເຮັດໃຫ້ແອັບພລິເຄຊັນທີ່ໃຊ້ເວລາທີ່ແທ້ຈິງເຊັ່ນ: ເຮືອນອັດສະລິຍະ, ຍານພາຫະນະອັດຕະໂນມັດ, ແລະອັດຕະໂນມັດອຸດສາຫະກໍາ.

ວຽກ​ງານ​ໃນ​ອະ​ນາ​ຄົດ

ວຽກງານໃນອະນາຄົດໃນຂົງເຂດນີ້ປະກອບມີ:

• ** ການພັດທະນາເຕັກນິກການອອກແບບຮ່ວມກັນຂອງຮາດແວ-ຊອບແວ**: ນັກຄົ້ນຄວ້າ ແລະຜູ້ພັດທະນາສາມາດຄົ້ນຫາເຕັກນິກໃໝ່ສໍາລັບການເພີ່ມປະສິດທິພາບແບບຈໍາລອງ AI ສໍາລັບອຸປະກອນຂອບ.
• ** ການປັບປຸງລະບົບການຕັດອອກແບບຈໍາລອງ ແລະ ສູດການກັ່ນຄວາມຮູ້ **: ການພັດທະນາສູດການຄິດໄລ່ທີ່ມີປະສິດທິພາບຫຼາຍຂຶ້ນສໍາລັບການຕັດຕົວແບບ ແລະ ການກັ່ນຄວາມຮູ້ສາມາດນໍາໄປສູ່ການປະຕິບັດ ແລະຄວາມຖືກຕ້ອງທີ່ດີກວ່າ.
• ** ການສືບສວນການນໍາໃຊ້ແບບຈໍາລອງ AI ອື່ນໆ**: ຮູບແບບ AI ອື່ນໆ, ເຊັ່ນ: ຕົ້ນໄມ້ການຕັດສິນໃຈແລະປ່າໄມ້ແບບສຸ່ມ, ສາມາດຖືກຄົ້ນຫາສໍາລັບການຕິດຕັ້ງອຸປະກອນຂອບ.

ໂດຍການສືບຕໍ່ກ້າວຫນ້າທາງດ້ານການອອກແບບຮ່ວມກັນຂອງຮາດແວ - ຊອບແວ, ພວກເຮົາສາມາດສ້າງແບບຈໍາລອງ AI ທີ່ມີປະສິດທິພາບແລະມີປະສິດທິພາບຫຼາຍຂື້ນສໍາລັບອຸປະກອນຂອບ, ເຮັດໃຫ້ຄໍາຮ້ອງສະຫມັກແລະກໍລະນີການນໍາໃຊ້ຢ່າງກວ້າງຂວາງ.