Përshpejtimi i GPU-së me LiteRT

Njësitë e Përpunimit Grafik (GPU) përdoren zakonisht për përshpejtimin e të mësuarit të thellë për shkak të rendimentit të tyre masiv paralel krahasuar me CPU-të. LiteRT thjeshton procesin e përdorimit të përshpejtimit të GPU-së duke u lejuar përdoruesve të specifikojnë përshpejtimin e harduerit si një parametër kur krijojnë një Model të Kompiluar ( CompiledModel ).

Me përshpejtimin e GPU-së të LiteRT, ju mund të krijoni buffer-a hyrës dhe dalës miqësorë me GPU-në, të arrini zero kopje me të dhënat tuaja në memorien e GPU-së dhe të ekzekutoni detyra në mënyrë asinkrone për të maksimizuar paralelizmin.

Për shembull implementime të GPU-së LiteRT, referojuni aplikacioneve demo të mëposhtme:

• Segmentimi i imazhit me Kotlin
• Segmentimi asinkron me C++

Shto varësinë e GPU-së

Ndiqni hapat e mëposhtëm për të shtuar varësinë e GPU-së në aplikacionin tuaj Kotlin ose C++.

Kotlin

Për përdoruesit e Kotlin, përshpejtuesi i GPU-së është i integruar dhe nuk kërkon hapa shtesë përtej udhëzuesit "Fillimi" .

C++

Për përdoruesit e C++, duhet të ndërtoni varësitë e aplikacionit me përshpejtimin e GPU-së LiteRT. Rregulli cc_binary që paketon logjikën thelbësore të aplikacionit (p.sh., main.cc ) kërkon komponentët e mëposhtëm të kohës së ekzekutimit:

• Biblioteka e përbashkët e LiteRT C API : atributi i data duhet të përfshijë bibliotekën e përbashkët të LiteRT C API ( //litert/c:litert_runtime_c_api_shared_lib ) dhe komponentët specifikë të GPU-së ( @litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so ).
• Varësitë e atributeve : Atributi deps zakonisht përfshin varësitë GLES gles_deps() , dhe linkopts zakonisht përfshin gles_linkopts() . Të dyja janë shumë të rëndësishme për përshpejtimin e GPU-së, pasi LiteRT shpesh përdor OpenGLES në Android.
• Skedarët e modelit dhe asete të tjera : Përfshihen përmes atributit të data .

Më poshtë është një shembull i një rregulli 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
)

Ky konfigurim lejon që skedari juaj binar i kompiluar të ngarkohet në mënyrë dinamike dhe të përdorë GPU-në për përfundime të përshpejtuara të të mësuarit automatik.

Përdor GPU me API- CompiledModel

Për të filluar përdorimin e përshpejtuesit të GPU-së, kaloni parametrin GPU kur krijoni Modelin e Kompiluar ( CompiledModel ). Fragmenti i mëposhtëm i kodit tregon një implementim bazë të të gjithë procesit:

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

Për më shumë informacion, shihni udhëzuesit " Filloni me C++" ose "Filloni me Kotlin" .

Zero-kopje me përshpejtim GPU

Përdorimi i kopjes zero i mundëson një GPU-je të qaset në të dhënat direkt në memorien e vet pa pasur nevojë që CPU-ja t'i kopjojë në mënyrë të qartë ato të dhëna. Duke mos kopjuar të dhëna nga dhe në memorien e CPU-së, kopja zero mund ta zvogëlojë ndjeshëm vonesën nga fillimi në fund.

Kodi i mëposhtëm është një shembull implementimi i GPU-së Zero-Copy me OpenGL , një API për renderimin e grafikës vektoriale. Kodi i kalon imazhet në formatin e bufferit OpenGL direkt te 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());

Ekzekutim asinkron

Metodat asinkrone të LiteRT, si RunAsync() , ju lejojnë të planifikoni përfundimin e GPU-së ndërsa vazhdoni detyra të tjera duke përdorur CPU-në ose NPU-në. Në tubacione komplekse, GPU-ja shpesh përdoret në mënyrë asinkrone së bashku me CPU-në ose NPU-të.

Fragmenti i mëposhtëm i kodit ndërtohet mbi kodin e dhënë në shembullin e përshpejtimit të GPU-së me kopje zero . Kodi përdor si CPU-në ashtu edhe GPU-në në mënyrë asinkrone dhe bashkëngjit një Event LiteRT në buffer-in hyrës. Event LiteRT është përgjegjëse për menaxhimin e llojeve të ndryshme të primitivave të sinkronizimit, dhe kodi i mëposhtëm krijon një objekt të menaxhuar të Ngjarjes LiteRT të tipit LiteRtEventTypeEglSyncFence . Ky objekt Event siguron që ne të mos lexojmë nga buffer-i hyrës derisa GPU-ja të ketë mbaruar. E gjithë kjo bëhet pa përfshirë CPU-në.

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));

Modelet e mbështetura

LiteRT mbështet përshpejtimin e GPU-së me modelet e mëposhtme. Rezultatet e krahasimit bazohen në testet e kryera në një pajisje Samsung Galaxy S24.