Pertempuran sebenar penggunaan berskala besar model Bytedance

1. Pengenalan latar belakang

Dalam ByteDance, aplikasi berdasarkan pembelajaran mendalam berkembang di mana-mana Walaupun jurutera memfokuskan pada kesan model, mereka juga perlu memberi perhatian kepada perkhidmatan dalam talian konsisten dan prestasi , pada masa awal, ini biasanya memerlukan pembahagian kerja dan kerjasama yang erat antara pakar algoritma dan pakar kejuruteraan Model ini mempunyai kos yang agak tinggi seperti penyelesaian masalah dan pengesahan.

Dengan populariti rangka kerja PyTorch/TensorFlow, latihan model pembelajaran mendalam dan penaakulan dalam talian telah disatukan Pembangun hanya perlu memberi perhatian kepada logik algoritma tertentu dan memanggil API Python untuk menyelesaikan latihan proses pengesahan Selepas itu, model boleh Sangat mudah untuk bersiri dan mengeksport, dan kerja penaakulan diselesaikan oleh enjin C++ berprestasi tinggi yang bersatu. Pengalaman pembangun yang dipertingkatkan daripada latihan kepada penggunaan.

Walau bagaimanapun, perkhidmatan yang lengkap biasanya juga mengandungi sejumlah besar pra-pemprosesan/pasca-pemprosesan dan logik perniagaan lain ini biasanya memproses pelbagai input dan menukarkannya kepada Tensor, kemudian memasukkannya ke dalam model , dan kemudian model menghasilkan Tensor kemudian diproses ke dalam format sasaran Beberapa senario biasa adalah seperti berikut:

• Bert
• Resnet

Matlamat kami adalah untuk menyediakan penyelesaian latihan dan inferens yang automatik dan bersatu untuk proses hujung ke hujung di atas, mengurangkan satu siri masalah seperti pembangunan manual proses inferens dan penjajaran berbeza, dan mencapai penyelesaian penggunaan bersatu berskala besar.

2. Isu teras

PyTorch/TensorFlow dan rangka kerja lain secara relatifnya telah menyelesaikan masalah latihan/inferens model bersatu, jadi pengiraan model itu sendiri tidak mempunyai masalah mengintegrasikan latihan dan inferens ( prestasi operator) Pengoptimuman adalah di luar skop perbincangan ini).

Masalah teras yang perlu diselesaikan ialah: pra-pemprosesan dan pasca-pemprosesan perlu menyediakan latihan berprestasi tinggi dan menyelesaikan penyelesaian bersepadu.

Untuk logik jenis ini, TensorFlow 2.x menyediakan tf.function (belum lengkap), dan PyTorch menyediakan TorchScript, yang tanpa pengecualian memilih subset sintaks Python asli. Tetapi walaupun ia sangat berkuasa, masih terdapat masalah yang tidak boleh diabaikan:

Prestasi: Kebanyakan penyelesaian ini berdasarkan pelaksanaan mesin maya Penyelesaian mesin maya adalah fleksibel dan sangat terkawal, tetapi kebanyakan mesin maya dalam rangka kerja pembelajaran mendalam biasanya Prestasi tidak cukup baik. Sebagai tambahan, rangka kerja telah direka untuk pengkomputeran Tensor pada hari-hari awal Kos setiap operator dalam pengkomputeran tatasusunan adalah sangat tinggi, dan kos penghantaran dan penjadualan mesin maya boleh diabaikan. Walau bagaimanapun, overhed porting ke pengaturcaraan bahasa pengaturcaraan adalah sukar untuk diabaikan, dan menulis terlalu banyak kod akan menjadi hambatan prestasi. Menurut ujian, prestasi penterjemah TorchScript hanya kira-kira 1/5 daripada Python, dan prestasi tf.function adalah lebih teruk lagi.
• Fungsi tidak lengkap: Malah, apabila digunakan pada senario sebenar, kami masih boleh menemui banyak fungsi penting yang tf.function/TorchScript tidak menyokong, seperti: sumber tersuai tidak boleh dibungkus dan hanya boleh bersiri terbina dalam jenis; String hanya boleh diproses oleh bait, dan unicode seperti bahasa Cina akan menyebabkan diff; tugas pembelajaran bukan mendalam, Contohnya, masih terdapat banyak aplikasi pembelajaran tidak mendalam atau subtugas dalam pemprosesan bahasa semula jadi, seperti anotasi jujukan, penyahkodan model bahasa, pembinaan ciri buatan model pokok, dll. Ini biasanya mempunyai paradigma ciri yang lebih fleksibel , tetapi pada masa yang sama mereka tidak dilaksanakan sepenuhnya Penyelesaian latihan dan promosi bersepadu hujung ke hujung masih memerlukan banyak kerja pembangunan dan pengesahan ketepatan.
• Untuk menyelesaikan masalah di atas, kami telah membangunkan penyelesaian prapemprosesan berasaskan kompilasi: MATXScript!

3. MATXScript

Dalam pembangunan algoritma pembelajaran mendalam, pembangun biasanya menggunakan Python untuk lelaran dan percubaan pantas, dan menggunakan C++ untuk membangunkan perkhidmatan dalam talian berprestasi tinggi, termasuk checksum ketepatan Pembangunan perkhidmatan akan menjadi beban yang lebih berat!

MatxScript (https://github.com/bytedance/matxscript) ialah pengkompil AOT untuk sub-bahasa Python, yang boleh menterjemah Python secara automatik ke dalam C++ dan menyediakan fungsi pembungkusan dan penerbitan satu klik. Menggunakan MATXScript membolehkan pembangun melakukan lelaran pada model dengan cepat sambil menggunakan perkhidmatan berprestasi tinggi pada kos yang lebih rendah.

Seni bina teras adalah seperti berikut:

• Lapisan paling rendah ialah perpustakaan asas C++/CUDA tulen, dibangunkan oleh pakar pengendali berprestasi tinggi.
• Di atas perpustakaan asas, perpustakaan Python dikapsulkan mengikut konvensyen dan boleh digunakan dalam proses latihan.
• Apabila inferens diperlukan, MATXScript boleh digunakan untuk menterjemah kod Python ke dalam kod C++ yang setara, menyusunnya ke dalam perpustakaan pautan dinamik, menambah model dan sumber bergantung lain serta membungkus dan menerbitkannya bersama-sama.

Antaranya, peranan penyusun adalah sangat kritikal, dan proses terasnya adalah seperti berikut:

Melalui proses di atas, proses kod pra-pemprosesan yang ditulis oleh pengguna boleh Ia disusun ke dalam JitOp dalam Talian Paip Untuk menghubungkan pra dan pasca pemprosesan dengan model, kami juga membangunkan sistem pengesanan (merujuk kepada PyTorch dalam reka bentuk antara muka). adalah seperti berikut:

Berdasarkan MATXScript, kami boleh menggunakan set kod yang sama untuk latihan dan inferens, yang sangat mengurangkan kos penggunaan model. Pada masa yang sama, seni bina dan algoritma dipisahkan, dan pelajar algoritma boleh bekerja sepenuhnya dalam Python pelajar Senibina menumpukan pada pembangunan pengkompil dan pengoptimuman masa jalan Dalam ByteDance, penyelesaian ini telah disahkan oleh penggunaan berskala besar.

4. Ujian kecil

Di sini kami mengambil prapemprosesan teks Inggeris yang paling mudah sebagai contoh untuk menunjukkan cara menggunakan MATXScript.

Matlamat: Menukar sekeping teks Bahasa Inggeris ke dalam indeks

1. Tulis logik carian kamus asas

class Text2Ids:
def __init__(self) -> None:
self.table: Dict[str, int] = {
"hello": 0,
"world": 1,
"[UNK]": 2,
}

def lookup(self, word: str)
return self.table.get(word, 2)

def__call__ (self, words: List[str])
return [self.lookup(w) for w in words]

2. Tulis Pipeline

import matx

class WorkFlow:
def __init__(self):
# 此处会进行代码编译，Python 代码自动编译封装为 Callable 对象
self.text2ids = matx.script(Text2Ids)()

def process(self, texts):
ids = self.text2ids(texts)
return ids

# test
handler = WorkFlow()
print(handler.process("hello world unknown"))
# output: [0, 1, 2]

3. Jejak eksport ke cakera

# dump
mod = matx.trace(handler.process, "hello world")
print(mod.run({"texts": "hello world"}))
mod.save('./my_dir')
# load
mod = matx.load('./my_dir', -1)
print(mod.run({"texts": "hello world"}))

4. C++ beban

#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <matxscript/pipeline/tx_session.h>
using namespace ::matxscript::runtime;
int main()
{
// test case
std::unordered_map<std::string, RTValue> feed_dict;
feed_dict.emplace("texts", Unicode(U"hello world"));
std::vector<std::pair<std::string, RTValue>> result;
const char* module_path = "./my_dir";
const char* module_name = "model.spec.json";
{
// -1 mean cpu
auto sess = TXSession::Load(module_path, module_name, -1);
auto result = sess->Run(feed_dict);
for (auto& r : result) {
std::cout << "key: " << r.first << ", value: " << r.second << std::endl;
}
}
return 0;
}

Kod lengkap Lihat : https://github.com/bytedance/matxscript/tree/main/examples/text2ids

Ringkasan: Di atas ialah logik prapemprosesan yang sangat mudah dilaksanakan dalam Python tulen, dan boleh digunakan oleh C++ umum kod dimuatkan dan dijalankan Di bawah kami menggabungkan model untuk menunjukkan kes hujung ke hujung berbilang modal sebenar!

5. Kes berbilang modal

Di sini kami mengambil pelbagai mod grafik dan teks (Bert+Resnet) sebagai contoh Model ditulis menggunakan PyTorch untuk menunjukkan kerja sebenar dalam latihan dan penempatan.

1. Persekitaran konfigurasi
   a. Konfigurasikan gcc/cuda dan infrastruktur lain (biasanya pelajar operasi dan penyelenggaraan telah melakukan ini)
   b Pasang MATXScript dan perpustakaan asas yang dibangunkan berdasarkannya ( teks, penglihatan dsb.)
2. Tulis kod model
   a Dikecualikan di sini, anda boleh merujuk kepada kertas kerja atau pelaksanaan sumber terbuka lain untuk melakukannya sendiri
3. Tulis kod prapemprosesan
<. 🎜>

a . teks

from typing import List, Dict, Tuple
import libcut
import matx
class Vocabulary:
...
def utf8_decoder(s: List[bytes]):
return [x.decode() for x in s]
class TextNDArrayBuilder:
...
class TextPipeline:
def __init__(self, mode: str = "eval"):
self.mode = mode
self.cut_engine = libcut.Cutter('/path/to/cut_models', ...)
self.vocab = matx.script(Vocabulary)('/path/to/vocab.txt')
self.decoder = matx.script(utf8_decoder)
self.input_builder = matx.script(TextNDArrayBuilder)(self.vocab)
def process(self, text: List[bytes]):
# List[bytes] 是对齐 C++ 的 vector<string>
text: List[str] = self.decoder(text)
words: List[List[str]] = self.cut_engine(text)
batch_ids: List[List[int]] = self.vocab(words)
input_ids, segment_ids, mask_ids = self.input_builder(batch_ids, 32)
if self.mode == "train":
return input_ids.torch(), segment_ids.torch(), mask_ids.torch()
return input_ids, segment_ids, mask_ids

b disambungkan kepada Set Data

b. VisionPipeline melibatkan prapemprosesan GPU dan lebih sesuai untuk diproses secara berkelompok Anda perlu membina DataLoader yang berasingan dengan sendiri (kuburkan satu titik di sini, kami akan membuka DataLoader berbilang benang dalaman nanti)

from typing import List, Dict, Tuple
import matx
from matx import vision
class VisionPipeline:
def __init__(self,
 device_id: int = 0,
 mode: str = "eval",
 image_size: int = 224,):
self.is_training = mode == 'train'
self.mode = mode
...
def process(self, image,):
if self.is_training:
decode_nds = self.random_crop_decode(image)
flip_nds = self.random_flip(decode_nds)
resize_nds = self.resize(flip_nds)
transpose_nd = self.transpose_norm(resize_nds, vision.SYNC)
else:
decode_nds = self.decode(image)
resize_nds = self.resize(decode_nds)
crop_nds = self.center_crop(resize_nds)
transpose_nd = self.transpose_norm(crop_nds, vision.SYNC)
if self.mode == "trace":
return transpose_nd
return transpose_nd.torch()

Tambahkan kod model, mulakan latihan

4. Eksport Model Inferens hujung ke hujung
   
   
5. Ringkasan: Selepas langkah di atas, kita boleh melengkapkan penamat -to-end latihan & kerja pelepasan, dan keseluruhan proses Ia dilengkapkan dengan kod Python tulen dan boleh dikawal sepenuhnya oleh pelajar algoritma itu sendiri. Sudah tentu, jika terdapat masalah prestasi dalam pengiraan model itu sendiri, ia juga boleh diselesaikan di belakang tabir melalui pengubahsuaian dan pengoptimuman imej automatik.
6. Nota: Untuk contoh kod lengkap, lihat https://github.com/bytedance/matxscript/tree/main/examples/e2e_multi_modal

6 sebelumnya Dalam bab ini, kami mendapat pakej model yang dikeluarkan oleh rakan sekelas algoritma Bab ini membincangkan cara memuatkan dan menjalankannya menggunakan perkhidmatan bersatu.

class MultimodalEvalPipeline:
def __init__(self):
self.text_pipe = TextPipeline(mode="eval", ...)
self.vision_pipe = VisionPipeline(mode="eval", ...)
self.torch_model = torch.jit.load('/path/to/multimodal.jit', map_locatinotallow='cuda:0')
self.tx_model_op = matx.script(self.torch_model, device=0)

def eval(self, texts: List[bytes], images: List[bytes])
input_ids, segment_ids, mask_ids = self.text_pipe.process(texts)
images = self.vision_pipe.process(images)
scores = self.tx_model_op(input_ids, segment_ids, mask_ids, images)
return scores
# examples
example_batch_size = 8
text_examples = ['hello, world'.encode()] * example_batch_size
with open('/path/image.jpg', 'rb') as f:
image_example = f.read()
image_examples = [image_example] * example_batch_size
# pipeline instance
pipe = MultimodalEvalPipeline(...)
mod = matx.trace(pipe.eval, text_examples, image_examples)
# test
print(mod.run({"texts": text_examples, "images": image_examples}))
# save
mod.save('/path/to/my_multimodal')

Pelayan lengkap termasuk: Protokol IDL, Strategi Batching, penjadualan dan susunan benang/benang, penaakulan model...

Di sini, kita hanya membincangkan penaakulan model, selebihnya Ia boleh dibangunkan seperti yang dipersetujui. Kami menggunakan fungsi utama untuk menggambarkan proses memuatkan dan menjalankan model:

Kod di atas ialah kes paling mudah memuatkan model berbilang mod dalam C++ Bagi pelajar yang membangunkan Pelayan, lakukan sahaja Dengan abstraksi dan konvensyen mudah, kod di atas boleh diubah menjadi rangka kerja perkhidmatan model C++ bersatu.

7. Maklumat lanjut

Kami adalah pasukan sistem pembelajaran mesin Bytedance-AML, komited untuk menyediakan syarikat dengan rangka kerja bersepadu latihan berprestasi tinggi dan promosi, dan juga Ia akan memberi perkhidmatan kepada syarikat rakan kongsi melalui Platform Pembelajaran Mesin Volcano Engine Platform Pembelajaran Mesin Volcano dijangka menyediakan sokongan berkaitan MATX mulai 2023, termasuk persekitaran cermin pratetap, sampel awam senario biasa dan sokongan teknikal semasa akses dan penggunaan perusahaan. dsb., yang boleh mencapai pecutan kos rendah dan penyepaduan latihan dan senario inferens. Selamat datang untuk mengetahui lebih lanjut tentang produk kami di https://www.volcengine.com/product/ml-platform.

Atas ialah kandungan terperinci Pertempuran sebenar penggunaan berskala besar model Bytedance. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!