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

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

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

উদাহরণস্বরূপ LiterRT GPU এর বাস্তবায়নের জন্য, নিম্নলিখিত ডেমো অ্যাপ্লিকেশনগুলি দেখুন:

• কোটলিনের সাথে ছবির বিভাজন
• C++ এর সাথে অ্যাসিনক্রোনাস সেগমেন্টেশন

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

আপনার Kotlin বা C++ অ্যাপ্লিকেশনে GPU নির্ভরতা যোগ করতে নিম্নলিখিত পদক্ষেপগুলি ব্যবহার করুন।

কোটলিন

কোটলিন ব্যবহারকারীদের জন্য, GPU অ্যাক্সিলারেটরটি অন্তর্নির্মিত এবং শুরু করার নির্দেশিকা ছাড়া অতিরিক্ত পদক্ষেপের প্রয়োজন হয় না।

সি++

C++ ব্যবহারকারীদের জন্য, আপনাকে LiterRT GPU ত্বরণের মাধ্যমে অ্যাপ্লিকেশনের নির্ভরতা তৈরি করতে হবে। cc_binary নিয়ম যা মূল অ্যাপ্লিকেশন লজিক (যেমন, main.cc ) প্যাকেজ করে তার জন্য নিম্নলিখিত রানটাইম উপাদানগুলির প্রয়োজন:

• LiterRT C API শেয়ার্ড লাইব্রেরি : data অ্যাট্রিবিউটে অবশ্যই LiterRT C API শেয়ার্ড লাইব্রেরি ( //litert/c:litert_runtime_c_api_shared_lib ) এবং GPU-নির্দিষ্ট উপাদান ( @litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so ) অন্তর্ভুক্ত থাকতে হবে।
• অ্যাট্রিবিউট ডিপেন্ডেন্সি : deps অ্যাট্রিবিউটে সাধারণত GLES ডিপেন্ডেন্সি gles_deps() থাকে এবং linkopts সাধারণত gles_linkopts() থাকে। GPU অ্যাক্সিলারেশনের জন্য উভয়ই অত্যন্ত প্রাসঙ্গিক, কারণ LiteRT প্রায়শই অ্যান্ড্রয়েডে OpenGLES ব্যবহার করে।
• মডেল ফাইল এবং অন্যান্য সম্পদ : data অ্যাট্রিবিউটের মাধ্যমে অন্তর্ভুক্ত।

নিচে cc_binary নিয়মের একটি উদাহরণ দেওয়া হল:

cc_binary(
    name = "your_application",
    srcs = [
        "main.cc",
    ],
    data = [
        ...
        # litert c api shared library
        "//litert/c:litert_runtime_c_api_shared_lib",
        # GPU accelerator shared library
        "@litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so",
    ],
    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
)

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

CompiledModel API সহ GPU ব্যবহার করুন

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

// 1. Load model
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));

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

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

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

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

// 6. 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()

আরও তথ্যের জন্য, C++ দিয়ে শুরু করুন অথবা Kotlin দিয়ে শুরু করুন নির্দেশিকা দেখুন।

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

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

নিচের কোডটি হল জিরো-কপি GPU-এর একটি উদাহরণ যা OpenGL সহ ব্যবহার করা হয়, যা ভেক্টর গ্রাফিক্স রেন্ডার করার জন্য একটি API। কোডটি 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 model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, 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());

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

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

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

LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, 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));

সমর্থিত মডেল

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