Platform For AI:Optimalkan ResNet50 berbentuk dinamis dengan Blade

Batasan

Prosedur

Langkah 1: Persiapan

1. Unduh parameter model pra-latih dan data uji.

   Parameter pra-latih berasal dari torchvision dan telah disimpan di Object Storage Service (OSS) untuk mempercepat unduhan. Data uji dipilih secara acak dari set validasi ImageNet-1k. Data tersebut telah diproses sebelumnya dan siap digunakan setelah diunduh.

   wget http://pai-blade.oss-cn-zhangjiakou.aliyuncs.com/share/dynamic_ranges_pratice/resnet50-19c8e357.pth -O resnet50-19c8e357.pth
   wget http://pai-blade.oss-cn-zhangjiakou.aliyuncs.com/share/dynamic_ranges_pratice/imagenet_val_example.pt -O imagenet_val_example.pt

2. Definisikan model, muat parameter model dan data uji, lalu hasilkan TorchScript.

   import torch
   import torchvision
   
   # Bangun Resnet50.
   model = torchvision.models.resnet50().eval().cuda()
   # Muat parameter pra-latih.
   ckpt = torch.load('resnet50-19c8e357.pth')
   model.load_state_dict(ckpt)
   # Muat data uji.
   example_input = torch.load('imagenet_val_example.pt').cuda()
   # Hasilkan TorchScript.
   traced_model = torch.jit.trace(model, example_input).cuda().eval()

Langkah 2: Konfigurasi config untuk optimasi

Konfigurasikan config Blade berdasarkan rentang bentuk dinamis. Blade mendukung rentang dinamis di dimensi apa pun. Topik ini menggunakan dimensi batch untuk menunjukkan konfigurasi.

1. Definisikan rentang bentuk dinamis.

   Rentang dinamis yang valid harus mencakup tiga bidang berikut:

   • min: Batas bawah bentuk dinamis.

   • max: Batas atas bentuk dinamis.

   • opts: Bentuk-bentuk yang memerlukan optimasi khusus. Anda dapat menetapkan beberapa bentuk. Rasio akselerasi inferensi biasanya lebih tinggi untuk bentuk-bentuk ini pada model yang telah dioptimalkan.

   Ketiga bidang ini harus mengikuti aturan berikut:

   • Panjang setiap kelompok bentuk dalam min, max, dan opts harus sama dengan jumlah input jaringan.

   • Nilai pada posisi yang sesuai dalam setiap kelompok bentuk untuk min, max, dan opts harus memenuhi min_num <= opt_num <= max_num.

   Sebagai contoh, buat rentang bentuk dinamis berikut.

   shapes = {
       "min": [[1, 3, 224, 224]],
       "max": [[10, 3, 224, 224]],
       "opts": [
           [[5, 3, 224, 224]],
           [[8, 3, 224, 224]],
       ]
   }

   Selain itu, Blade mendukung penyetelan beberapa rentang dinamis. Jika rentang antara batas atas dan bawah bentuk dinamis terlalu besar, akselerasi model mungkin tidak signifikan. Anda dapat membagi rentang besar menjadi beberapa rentang kecil untuk mencapai akselerasi yang lebih baik. Untuk informasi tentang cara menyetel beberapa rentang dinamis, lihat Lampiran: Menyetel beberapa rentang dinamis.

2. Bangun config Blade dari rentang bentuk dinamis yang telah ditentukan.

   import blade
   import blade.torch as blade_torch
   
   # Config Blade Torch untuk menyetel bentuk dinamis.
   blade_torch_cfg = blade_torch.Config()
   blade_torch_cfg.dynamic_tuning_shapes = shapes
   
   # Config Blade untuk menonaktifkan pemeriksaan presisi FP16 demi akselerasi terbaik.
   gpu_config = {
       "disable_fp16_accuracy_check": True,
   }
   blade_config = blade.Config(
       gpu_config=gpu_config
   )

Langkah 3: Panggil Blade untuk mengoptimalkan model

1. Panggil blade.optimize untuk mengoptimalkan model. Kode berikut memberikan contohnya. Untuk informasi lebih lanjut tentang antarmuka ini, lihat dokumentasi antarmuka Python.

   with blade_torch_cfg:
       optimized_model, _, report = blade.optimize(
           traced_model,          # Path model.
           'o1',                  # o1 untuk optimasi tanpa kehilangan.
           config=blade_config,
           device_type='gpu',     # Optimalkan untuk perangkat GPU.
           test_data=[(example_input,)]  # Data uji.
       )

   Saat mengoptimalkan model, perhatikan hal-hal berikut:

   • Nilai kembali pertama dari blade.optimize adalah model yang telah dioptimalkan. Tipe datanya sama dengan model input. Dalam contoh ini, input berupa TorchScript, dan nilai kembalinya adalah TorchScript yang telah dioptimalkan.

   • Pastikan bahwa input test_data berada dalam rentang bentuk dinamis yang telah ditentukan.

2. Setelah optimasi selesai, cetak laporan optimasi.

   print("Report: {}".format(report))

   Laporan optimasi yang dicetak mirip dengan output berikut.

   Report: {
     "software_context": [
       {
         "software": "pytorch",
         "version": "1.7.1+cu110"
       },
       {
         "software": "cuda",
         "version": "11.0.0"
       }
     ],
     "hardware_context": {
       "device_type": "gpu",
       "microarchitecture": "T4"
     },
     "user_config": "",
     "diagnosis": {
       "model": "unnamed.pt",
       "test_data_source": "user provided",
       "shape_variation": "undefined",
       "message": "Unable to deduce model inputs information (data type, shape, value range, etc.)",
       "test_data_info": "0 shape: (1, 3, 224, 224) data type: float32"
     },
     "optimizations": [
       {
         "name": "PtTrtPassFp16",
         "status": "effective",
         "speedup": "4.06",
         "pre_run": "6.55 ms",
         "post_run": "1.61 ms"
       }
     ],
     "overall": {
       "baseline": "6.54 ms",
       "optimized": "1.61 ms",
       "speedup": "4.06"
     },
     "model_info": {
       "input_format": "torch_script"
     },
     "compatibility_list": [
       {
         "device_type": "gpu",
         "microarchitecture": "T4"
       }
     ],
     "model_sdk": {}
   }

   Laporan optimasi menunjukkan bahwa dalam contoh ini, optimasi PtTrtPassFp16 efektif. Optimasi ini memberikan percepatan sekitar 4,06 kali, mengurangi waktu inferensi model pada data uji dari 6,55 ms menjadi 1,61 ms. Hasil optimasi ini hanya berlaku untuk contoh ini. Hasil aktual Anda mungkin berbeda. Untuk informasi lebih lanjut tentang bidang-bidang dalam laporan optimasi, lihat Laporan optimasi.

3. Panggil fungsi PyTorch terkait untuk menyimpan dan memuat model TorchScript yang telah dioptimalkan.

   file_name = "resnet50_opt.pt"
   # Simpan model yang telah dioptimalkan secara lokal.
   torch.jit.save(optimized_model, file_name)
   # Muat model yang telah dioptimalkan dari disk.
   optimized_model = torch.jit.load(file_name)

Langkah 4: Verifikasi kinerja dan kebenaran

Setelah optimasi, gunakan skrip Python untuk memverifikasi informasi dalam laporan optimasi.

1. Definisikan metode benchmark. Lakukan pemanasan model sebanyak 10 kali, jalankan 100 kali, lalu ambil rata-rata waktu inferensi sebagai kecepatan inferensi.

   import time
   
   @torch.no_grad()
   def benchmark(model, test_data):
       # Alihkan model ke mode evaluasi.
       model = model.eval()
       
       # Pemanasan.
       for i in range(0, 10):
           model(test_data)
           
       # Mulai pengujian berwaktu.
       num_runs = 100
       start = time.time()
       for i in range(0, num_runs):
           model(test_data)
       torch.cuda.synchronize()
       elapsed = time.time() - start
       rt_ms = elapsed / num_runs * 1000.0
       
       # Cetak hasilnya.
       print("{:.2f} ms.".format(rt_ms))
       return rt_ms

2. Definisikan serangkaian data uji dengan bentuk berbeda.

   dummy_inputs = []
   batch_num = [1, 3, 5, 7, 9]
   for n in batch_num:
       dummy_inputs.append(torch.randn(n, 3, 224, 224).cuda())

3. Iterasi setiap kelompok data uji. Panggil metode benchmark untuk menguji model asli dan model yang telah dioptimalkan, lalu cetak hasilnya.

   for inp in dummy_inputs:
       print(f'--------------test with shape {list(inp.shape)}--------------')
       print("  Origin model inference cost:     ", end='')
       origin_rt = benchmark(traced_model, inp)
       print("  Optimized model inference cost:  ", end='')
       opt_rt = benchmark(optimized_model, inp)
       speedup = origin_rt / opt_rt
       print('  Speed up: {:.2f}'.format(speedup))
       print('')

   Sistem mengembalikan hasil yang mirip dengan berikut.

   --------------test with shape [1, 3, 224, 224]--------------
     Origin model inference cost:     6.54 ms.
     Optimized model inference cost:  1.66 ms.
     Speed up: 3.94
   
   --------------test with shape [3, 3, 224, 224]--------------
     Origin model inference cost:     10.79 ms.
     Optimized model inference cost:  2.40 ms.
     Speed up: 4.49
   
   --------------test with shape [5, 3, 224, 224]--------------
     Origin model inference cost:     16.27 ms.
     Optimized model inference cost:  3.25 ms.
     Speed up: 5.01
   
   --------------test with shape [7, 3, 224, 224]--------------
     Origin model inference cost:     22.62 ms.
     Optimized model inference cost:  4.39 ms.
     Speed up: 5.16
   
   --------------test with shape [9, 3, 224, 224]--------------
     Origin model inference cost:     28.83 ms.
     Optimized model inference cost:  5.25 ms.
     Speed up: 5.49

   Hasil menunjukkan bahwa untuk data uji dengan bentuk berbeda, kecepatan inferensi model yang telah dioptimalkan 3,94 hingga 5,49 kali lebih cepat daripada model asli. Hasil optimasi ini hanya berlaku untuk contoh ini. Hasil aktual Anda mungkin berbeda.

4. Gunakan data uji nyata example_input dari langkah persiapan untuk memverifikasi kebenaran model yang telah dioptimalkan.

   origin_output = traced_model(example_input)
   _, pred = origin_output.topk(1, 1, True, True)
   print("origin model output: {}".format(pred))
   opt_output = optimized_model(example_input)
   _, pred = origin_output.topk(1, 1, True, True)
   print("optimized model output: {}".format(pred))

   Sistem mengembalikan hasil yang mirip dengan berikut.

   origin model output: tensor([[834]], device='cuda:0')
   optimized model output: tensor([[834]], device='cuda:0')

   Hasil menunjukkan bahwa baik model asli maupun model yang telah dioptimalkan memprediksi kelas 834 untuk data uji example_input.

Langkah 5: Muat dan jalankan model yang telah dioptimalkan

Setelah verifikasi, Anda perlu menerapkan model tersebut. Blade menyediakan SDK untuk Python dan C++ guna integrasi. Untuk informasi tentang cara menggunakan SDK C++, lihat Gunakan SDK untuk menerapkan model TensorFlow untuk inferensi. Bagian berikut menjelaskan cara menggunakan SDK Python untuk menerapkan model.

1. Opsi: Selama masa percobaan, tambahkan pengaturan variabel lingkungan berikut untuk mencegah program berhenti mendadak akibat kegagalan otentikasi:

   export BLADE_AUTH_USE_COUNTING=1

2. Lakukan otentikasi untuk menggunakan PAI-Blade.

   export BLADE_REGION=<region>
   export BLADE_TOKEN=<token>

   Konfigurasikan parameter berikut sesuai kebutuhan bisnis Anda:

   • <region>: wilayah tempat Anda menggunakan PAI-Blade. Anda dapat bergabung dengan grup DingTalk pengguna PAI-Blade untuk memperoleh wilayah tempat PAI-Blade dapat digunakan. Untuk informasi tentang kode QR grup DingTalk, lihat Instal PAI-Blade.

   • <token>: token otentikasi yang diperlukan untuk menggunakan PAI-Blade. Anda dapat bergabung dengan grup DingTalk pengguna PAI-Blade untuk memperoleh token otentikasi. Untuk informasi tentang kode QR grup DingTalk, lihat Instal PAI-Blade.

3. Muat dan jalankan model yang telah dioptimalkan.

   Anda tidak perlu menulis kode tambahan untuk mengintegrasikan Blade, selain menambahkan baris import blade.runtime.torch. Kode inferensi asli tidak perlu diubah.

   import torch
   import blade.runtime.torch
   # Ganti <your_optimized_model_path> dengan path model yang telah dioptimalkan.
   opt_model_dir = <your_optimized_model_path>
   # Ganti <your_infer_data> dengan data untuk inferensi.
   infer_data = <your_infer_data>
   
   model = torch.jit.load(opt_model_dir)
   output = model(infer_data)

Lampiran: Menyetel beberapa rentang dinamis

shapes1 = {
    "min": [[1, 3, 224, 224]],
    "max": [[5, 3, 224, 224]],
    "opts": [
        [[5, 3, 224, 224]],
    ]
}
shapes2 = {
    "min": [[5, 3, 224, 224]],
    "max": [[10, 3, 224, 224]],
    "opts": [
        [[8, 3, 224, 224]],
    ]
}
shapes = [shapes1, shapes2]