LiterRT এর সাথে GPU ত্বরণ

সিপিইউ-এর তুলনায় বিপুল সমান্তরাল থ্রুপুটের কারণে ডিপ লার্নিং অ্যাক্সিলারেশনের জন্য গ্রাফিক্স প্রসেসিং ইউনিট (GPU) সাধারণত ব্যবহৃত হয়। LiteRT, কম্পাইলড মডেল ( CompiledModel ) তৈরির সময় ব্যবহারকারীদের হার্ডওয়্যার অ্যাক্সিলারেশনকে একটি প্যারামিটার হিসেবে নির্দিষ্ট করার সুযোগ দিয়ে GPU অ্যাক্সিলারেশন ব্যবহারের প্রক্রিয়াকে সহজ করে তোলে।

LiteRT-এর GPU অ্যাক্সিলারেশনের সাহায্যে, আপনি GPU-বান্ধব ইনপুট ও আউটপুট বাফার তৈরি করতে পারেন, GPU মেমরিতে আপনার ডেটার জিরো-কপি অর্জন করতে পারেন, এবং প্যারালেলিজম সর্বোচ্চ করতে অ্যাসিঙ্ক্রোনাসভাবে টাস্ক সম্পাদন করতে পারেন।

শুরু করুন

• ক্লাসিক্যাল এমএল মডেলগুলোর জন্য , নিম্নলিখিত ডেমো অ্যাপগুলো দেখুন।

  • ইমেজ সেগমেন্টেশন কোটলিন অ্যাপ : সিপিইউ/জিপিইউ/এনপিইউ ইনফারেন্স।
  • ইমেজ সেগমেন্টেশন সি++ অ্যাপ : অ্যাসিঙ্ক এক্সিকিউশন সহ সিপিইউ/জিপিইউ/এনপিইউ ইনফারেন্স।

• GenAI মডেলগুলোর জন্য , নিম্নলিখিত ডেমো এবং নির্দেশিকা দেখুন:

  • এমবেডিংজেমা সিমান্টিক সিমিলারিটি সি++ অ্যাপ : সিপিইউ/জিপিইউ/এনপিইউ ইনফারেন্স।
  • LiteRT-LM ব্যবহার করে LLM চালানোর নির্দেশিকা।

GPU নির্ভরতা যোগ করুন

Use the following steps to add GPU dependency to your Kotlin or C++ application.

কোটলিন

For Kotlin users, the GPU accelerator is built-in and does not require additional steps beyond the Get Started guide.

সি++

C++ ব্যবহারকারীদের অবশ্যই LiteRT GPU অ্যাক্সিলারেশন সহ অ্যাপ্লিকেশনটির ডিপেন্ডেন্সিগুলো বিল্ড করতে হবে। cc_binary রুলটি, যা অ্যাপ্লিকেশনের মূল লজিক (যেমন, main.cc ) প্যাকেজ করে, তার জন্য নিম্নলিখিত রানটাইম কম্পোনেন্টগুলোর প্রয়োজন হয়:

• LiteRT C API শেয়ার্ড লাইব্রেরি : data অ্যাট্রিবিউটে অবশ্যই LiteRT C API শেয়ার্ড লাইব্রেরি ( //litert/c:litert_runtime_c_api_shared_lib ) এবং GPU-নির্দিষ্ট উপাদানসমূহ ( litert_gpu_accelerator_prebuilts ) অন্তর্ভুক্ত থাকতে হবে।
• অ্যাট্রিবিউট নির্ভরতা : deps অ্যাট্রিবিউটে সাধারণত GLES নির্ভরতা gles_deps() অন্তর্ভুক্ত থাকে, এবং linkopts সাধারণত gles_linkopts() অন্তর্ভুক্ত থাকে। GPU অ্যাক্সিলারেশনের জন্য উভয়ই অত্যন্ত প্রাসঙ্গিক, কারণ LiteRT প্রায়শই অ্যান্ড্রয়েডে OpenGLES ব্যবহার করে।
• Model files and other assets : Included through the data attribute.

নিম্নলিখিতটি একটি cc_binary নিয়মের উদাহরণ:

load("//litert/build_common:special_rule.bzl", "litert_gpu_accelerator_prebuilts")

cc_binary(
    name = "your_application",
    srcs = [
        "main.cc",
    ],
    data = [
        ...
        # litert c api shared library
        "//litert/c:litert_runtime_c_api_shared_lib",
    ] + litert_gpu_accelerator_prebuilts(),
    linkopts = select({
        "@org_tensorflow//tensorflow:android": ["-landroid"],
        "//conditions:default": [],
    }) + gles_linkopts(), # gles link options
    deps = [
        ...
        "//litert/cc:litert_tensor_buffer", # litert cc library
        ...
    ] + gles_deps(), # gles dependencies
)

এই সেটআপটি আপনার কম্পাইল করা বাইনারিকে ত্বরান্বিত মেশিন লার্নিং ইনফারেন্সের জন্য ডাইনামিকভাবে জিপিইউ লোড ও ব্যবহার করার সুযোগ দেয়।

প্রি-বিল্ট জিপিইউ অ্যাক্সিলারেটর

নতুন LiteRT GPU Accelerator এখনও ওপেন সোর্স করা হয়নি। তবে প্রি-বিল্ট সংস্করণ পাওয়া যাচ্ছে। Kotlin ব্যবহারকারীদের জন্য, LiteRT Maven প্যাকেজেই GPU Accelerator অন্তর্ভুক্ত রয়েছে। C++ SDK ব্যবহারকারীদের এটি আলাদাভাবে ডাউনলোড করতে হবে।

Bazel-এ, আপনার টার্গেটে ডিপেন্ডেন্সি যোগ করতে আপনি নিম্নলিখিত রুলটি ব্যবহার করতে পারেন। cpp load("//litert/build_common:special_rule.bzl", "litert_gpu_accelerator_prebuilts")

CompiledModel API-এর সাথে GPU ব্যবহার করুন

GPU অ্যাক্সিলারেটর ব্যবহার শুরু করতে, কম্পাইল্ড মডেল ( CompiledModel ) তৈরি করার সময় GPU প্যারামিটারটি পাস করুন। নিম্নলিখিত কোড স্নিপেটটি সম্পূর্ণ প্রক্রিয়াটির একটি প্রাথমিক বাস্তবায়ন দেখায়:

// 1. Create a compiled model targeting GPU
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model, CompiledModel::Create(env, "mymodel.tflite", kLiteRtHwAcceleratorGpu));

// 2. Prepare input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// 3. Fill input data (if you have CPU-based data)
input_buffers[0].Write<float>(absl::MakeConstSpan(cpu_data, data_size));

// 4. Execute
compiled_model.Run(input_buffers, output_buffers);

// 5. Access model output
std::vector<float> data(output_data_size);
output_buffers.Read<float>(absl::MakeSpan(data));

// Load model and initialize runtime
val  model =
    CompiledModel.create(
        context.assets,
        "mymodel.tflite",
        CompiledModel.Options(Accelerator.GPU),
        env,
    )

// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

আরও তথ্যের জন্য, Get Started with C++ অথবা Get Started with Kotlin গাইডগুলো দেখুন।

জিপিইউ ত্বরণ সহ জিরো-কপি

জিরো-কপি ব্যবহারের মাধ্যমে জিপিইউ তার নিজের মেমরি থেকে সরাসরি ডেটা অ্যাক্সেস করতে পারে, যার জন্য সিপিইউ-কে সেই ডেটা আলাদাভাবে কপি করার প্রয়োজন হয় না। সিপিইউ মেমরিতে ডেটা কপি না করার ফলে, জিরো-কপি এন্ড-টু-এন্ড ল্যাটেন্সি উল্লেখযোগ্যভাবে কমাতে পারে।

নিম্নলিখিত কোডটি ভেক্টর গ্রাফিক্স রেন্ডার করার একটি এপিআই, OpenGL ব্যবহার করে জিরো-কপি জিপিইউ-এর একটি উদাহরণ বাস্তবায়ন। কোডটি ছবিগুলোকে OpenGL বাফার ফরম্যাটে সরাসরি LiteRT-এ পাঠায়:

// Suppose you have an OpenGL buffer consisting of:
// target (GLenum), id (GLuint), size_bytes (size_t), and offset (size_t)
// Load model and compile for GPU
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, "mymodel.tflite", kLiteRtHwAcceleratorGpu));

// Create a TensorBuffer that wraps the OpenGL buffer.
LITERT_ASSIGN_OR_RETURN(auto tensor_type, model.GetInputTensorType("input_tensor_name"));
LITERT_ASSIGN_OR_RETURN(auto gl_input_buffer, TensorBuffer::CreateFromGlBuffer(env,
    tensor_type, opengl_buffer.target, opengl_buffer.id, opengl_buffer.size_bytes, opengl_buffer.offset));
std::vector<TensorBuffer> input_buffers{gl_input_buffer};
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Execute
compiled_model.Run(input_buffers, output_buffers);

// If your output is also GPU-backed, you can fetch an OpenCL buffer or re-wrap it as an OpenGL buffer:
LITERT_ASSIGN_OR_RETURN(auto out_cl_buffer, output_buffers[0].GetOpenClBuffer());

অ্যাসিঙ্ক্রোনাস এক্সিকিউশন

LiteRT-এর RunAsync() এর মতো অ্যাসিঙ্ক্রোনাস মেথডগুলো আপনাকে CPU বা NPU ব্যবহার করে অন্যান্য কাজ চালিয়ে যাওয়ার পাশাপাশি GPU ইনফারেন্স শিডিউল করার সুযোগ দেয়। জটিল পাইপলাইনে, GPU প্রায়শই CPU বা NPU-এর পাশাপাশি অ্যাসিঙ্ক্রোনাসভাবে ব্যবহৃত হয়।

The following code snippet builds on the code provided in the Zero-copy GPU acceleration example. The code uses both CPU and GPU asynchronously and attaches a LiteRT Event to the input buffer. LiteRT Event is responsible for managing different types of synchronization primitives, and the following code creates a managed LiteRT Event object of type LiteRtEventTypeEglSyncFence . This Event object ensures that we don't read from the input buffer until the GPU is done. All this is done without involving the CPU.

LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, "mymodel.tflite", kLiteRtHwAcceleratorGpu));

// 1. Prepare input buffer (OpenGL buffer)
LITERT_ASSIGN_OR_RETURN(auto gl_input,
    TensorBuffer::CreateFromGlBuffer(env, tensor_type, opengl_tex));
std::vector<TensorBuffer> inputs{gl_input};
LITERT_ASSIGN_OR_RETURN(auto outputs, compiled_model.CreateOutputBuffers());

// 2. If the GL buffer is in use, create and set an event object to synchronize with the GPU.
LITERT_ASSIGN_OR_RETURN(auto input_event,
    Event::CreateManagedEvent(env, LiteRtEventTypeEglSyncFence));
inputs[0].SetEvent(std::move(input_event));

// 3. Kick off the GPU inference
compiled_model.RunAsync(inputs, outputs);

// 4. Meanwhile, do other CPU work...
// CPU Stays busy ..

// 5. Access model output
std::vector<float> data(output_data_size);
outputs[0].Read<float>(absl::MakeSpan(data));

সমর্থিত ব্যাকএন্ড

LiteRT প্রতিটি প্ল্যাটফর্মের জন্য নিম্নলিখিত GPU ব্যাকএন্ড সমর্থন করে।

সমর্থিত মডেল

LiteRT নিম্নলিখিত মডেলগুলিতে GPU অ্যাক্সিলারেশন সমর্থন করে। বেঞ্চমার্কের ফলাফল একটি Samsung Galaxy S24 ডিভাইসে চালানো পরীক্ষার উপর ভিত্তি করে তৈরি।