Gunakan AICompiler untuk mengoptimalkan model - Platform For AI

AICompiler adalah komponen optimasi kompiler AI yang terintegrasi dengan Platform for AI (PAI)-Blade. AICompiler menyediakan penyandi bentuk statis dan dinamis. Anda dapat menggunakan AICompiler untuk meningkatkan kinerja inferensi model secara transparan dan universal tanpa perlu mengonfigurasi pengaturan tambahan. Topik ini menjelaskan cara menggunakan AICompiler untuk mengoptimalkan model TensorFlow dan PyTorch.

Informasi latar belakang

Saat ini, struktur model AI telah berkembang pesat, lebih banyak perangkat keras komputasi tingkat rendah digunakan, dan kebiasaan pengguna semakin beragam. Hal ini membuat sulit untuk secara manual meningkatkan kinerja dan efisiensi model AI. Oleh karena itu, pengembangan optimasi kompiler AI menjadi topik yang populer.

Kompiler tradisional menggunakan kode yang ditulis dalam bahasa tingkat tinggi sebagai input dan tidak memerlukan penulisan kode mesin secara manual. Kompiler pembelajaran mendalam memiliki fitur serupa dengan kompiler tradisional dan menggunakan graf komputasi fleksibel dengan tingkat abstraksi yang lebih tinggi sebagai input. Output dari kompiler pembelajaran mendalam mencakup kode mesin tingkat rendah serta mesin eksekusi platform perangkat keras seperti CPU atau GPU. AICompiler dikembangkan sebagai kompiler umum untuk meningkatkan kinerja tugas komputasi AI. Saat menggunakan AICompiler, Anda hanya perlu fokus pada pengembangan model tingkat atas, sehingga mengurangi upaya optimasi manual dan memanfaatkan sepenuhnya kinerja perangkat keras.

Selama dua tahun terakhir, tim PAI telah menginvestasikan banyak waktu dan sumber daya dalam mengembangkan optimasi kompiler AI. Sebagai salah satu komponen optimasi, AICompiler telah terintegrasi dengan PAI-Blade untuk membantu Anda mengoptimalkan dan menerapkan model untuk inferensi secara transparan dan universal.

AICompiler menyediakan penyandi bentuk statis dan dinamis. Penyandi bentuk dinamis cocok untuk semua jenis tugas, termasuk tugas inferensi model di mana bentuk graf komputasi berubah secara drastis. Penyandi bentuk statis cocok untuk tugas di mana bentuk graf komputasi bersifat statis atau sedikit berubah untuk mencapai kinerja optimal. Tabel berikut membandingkan kedua penyandi tersebut.

Kompiler	TensorFlow	PyTorch	Skenario
Penyandi bentuk statis	Didukung	Tidak didukung	Cocok untuk tugas di mana bentuk graf komputasi bersifat statis atau sedikit berubah untuk membantu mencapai kinerja optimal.
Penyandi bentuk dinamis	Didukung	Didukung	Cocok untuk semua jenis tugas.

Secara default, PAI-Blade secara otomatis menentukan apakah penyandi bentuk dinamis cocok untuk model Anda. Anda tidak perlu memberikan informasi tambahan sebagai input. Jika bentuk graf komputasi dalam tugas Anda bersifat statis atau sedikit berubah, PAI-Blade menggunakan penyandi bentuk statis untuk memastikan kinerja yang lebih baik. Bagian berikut memberikan contoh penggunaan penyandi bentuk statis dan dinamis untuk mengoptimalkan model yang berbeda.

Gunakan penyandi bentuk dinamis untuk mengoptimalkan model TensorFlow

Dalam contoh ini, model pengenalan suara otomatis (ASR) sumber terbuka digunakan untuk demonstrasi.

Unduh model dan data uji.

# Unduh model sampel dan data uji.
wget https://pai-blade.cn-hangzhou.oss.aliyun-inc.com/test_public_model/bbs/tf_aicompiler_demo/frozen.pb
wget https://pai-blade.cn-hangzhou.oss.aliyun-inc.com/test_public_model/bbs/tf_aicompiler_demo/test_bc4.npy

Muat model dan data uji, lalu panggil metode blade.optimize. Anda tidak perlu mengonfigurasi pengaturan tambahan.

import numpy as np
import tensorflow as tf
import blade

# Muat model dan data uji.
graph_def = tf.GraphDef()
with open('./frozen.pb', 'rb') as f:
    graph_def.ParseFromString(f.read())
test_data = np.load('test_bc4.npy', allow_pickle=True, encoding='bytes',).item()

# Optimalkan model.
optimized_model, opt_spec, report = blade.optimize(
    graph_def,  # Model asli, di sini adalah TF GraphDef.
    'o1',  # Tingkat optimasi o1 atau o2.
    device_type='gpu',  # Perangkat target untuk menjalankan model yang dioptimalkan.
    config=blade.Config(),
    inputs=['encoder_memory_placeholder', 'encoder_memory_length_placeholder'],
    outputs=['score', 'seq_id'],
    test_data=[test_data]
    #verbose=True
)

# Simpan hasil optimasi.
tf.train.write_graph(optimized_model, "./", "optimized.pb", as_text=False)
print("Laporan: {}".format(report))

Setelah model dioptimalkan, metode blade.optimize mengembalikan laporan optimasi. Anda dapat melihat efek optimasi yang dicapai oleh AICompiler dari laporan tersebut. Dalam contoh laporan optimasi berikut, kinerja Tesla T4 ditingkatkan sebesar 2,23 kali lipat secara transparan dan universal. Untuk informasi lebih lanjut tentang bidang-bidang dalam laporan, lihat Laporan Optimasi.
```
    {
      "name": "TfAicompilerGpu",
      "status": "effective",
      "speedup": "2.23",
      "pre_run": "120.54 ms",
      "post_run": "53.99 ms"
    }
```

Gunakan penyandi bentuk statis untuk mengoptimalkan model TensorFlow

Jika bentuk graf komputasi dalam tugas Anda bersifat statis atau sedikit berubah, Anda dapat mengatur parameter input config dari metode blade.optimize untuk menentukan penyandi bentuk statis untuk model Anda. Contoh kode berikut memberikan sebuah ilustrasi:

optimized_model, opt_spec, report = blade.optimize(
    graph_def,  # Model asli, di sini adalah TF GraphDef.
    'o1',  # Tingkat optimasi o1 atau o2.
    device_type='gpu',  # Perangkat target untuk menjalankan model yang dioptimalkan.
    # Berikan konfigurasi tambahan di sini untuk mencoba Kompilasi Bentuk Statis:
    config=blade.Config(enable_static_shape_compilation_opt = True), 
    inputs=['encoder_memory_placeholder', 'encoder_memory_length_placeholder'],
    outputs=['score', 'seq_id'],
    test_data=[test_data]
    #verbose=True
)

Untuk informasi lebih lanjut tentang konfigurasi lanjutan dari parameter input config, lihat blade.Config.

Setelah model dioptimalkan, metode blade.optimize mengembalikan laporan optimasi. Anda dapat melihat efek optimasi yang dicapai oleh AICompiler dari laporan tersebut. Dalam contoh ini, kinerja Tesla T4 ditingkatkan sebesar 2,35 kali lipat. Untuk informasi lebih lanjut tentang bidang-bidang dalam laporan, lihat Laporan Optimasi.

    {
      "name": "TfAicompilerGpu",
      "status": "effective",
      "speedup": "2.35",
      "pre_run": "114.91 ms",
      "post_run": "48.86 ms"
    }

Gunakan penyandi bentuk dinamis untuk mengoptimalkan model PyTorch

Dalam contoh ini, model ASR sumber terbuka digunakan untuk demonstrasi.

Unduh model.

# PyTorch 1.6.0
# Python3.6
wget https://pai-blade.cn-hangzhou.oss.aliyun-inc.com/test_public_model/bbs/pt_aicompiler_demo/orig_decoder_v2.pt

Muat model dan data uji, lalu panggil metode blade.optimize. Anda tidak perlu mengonfigurasi pengaturan tambahan.

import os
import time
import torch
# Untuk menggunakan blade, cukup impor.
import blade

# Muat model.
pt_file = 'orig_decoder_v2.pt'
batch = 8
model = torch.jit.load(pt_file)

# Persiapkan data uji.
def get_test_data(batch_size=1):
    decoder_input_t = torch.LongTensor([1] * batch_size).cuda()
    decoder_hidden_t = torch.rand(batch_size, 1, 256).cuda()
    decoder_hidden_t = decoder_hidden_t * 1.0
    decoder_hidden_t = torch.tanh(decoder_hidden_t)
    output_highfeature_t = torch.rand(batch_size, 448, 4, 50).cuda()
    attention_sum_t = torch.rand(batch_size, 1, 4, 50).cuda()
    decoder_attention_t = torch.rand(batch_size, 1, 4, 50).cuda()
    et_mask = torch.rand(batch_size, 4, 50).cuda()

    return (decoder_input_t, decoder_hidden_t, output_highfeature_t, attention_sum_t, decoder_attention_t, et_mask)

dummy = get_test_data(batch)

# Optimalkan model.
optimized_model, opt_spec, report = blade.optimize(
    model,  # Model asli, di sini adalah model skrip torch.
    'o1',  # Tingkat optimasi o1 atau o2.
    device_type='gpu',  # Perangkat target untuk menjalankan model yang dioptimalkan.
    test_data=[dummy],  # Untuk PyTorch, data input adalah daftar tupel.
    config=blade.Config()
)

print("spesifikasi: {}".format(opt_spec))
print("laporan: {}".format(report))

# Simpan hasil optimasi.
torch.jit.save(optimized_model, 'optimized_decoder.pt')

Setelah model dioptimalkan, metode blade.optimize mengembalikan laporan optimasi. Anda dapat melihat efek optimasi yang dicapai oleh AICompiler dari laporan tersebut. Dalam contoh laporan optimasi berikut, kinerja Tesla T4 ditingkatkan sebesar 2,45 kali lipat secara transparan dan universal. Untuk informasi lebih lanjut tentang bidang-bidang dalam laporan, lihat Laporan Optimasi.
```
  "optimizations": [
    {
      "name": "PyTorchMlir",
      "status": "effective",
      "speedup": "2.45",
      "pre_run": "1.99 ms",
      "post_run": "0.81 ms"
    }
  ],
```