LiteRT ile GPU hızlandırma

Grafik işleme birimleri (GPU'lar), CPU'lara kıyasla büyük paralel işleme kapasiteleri nedeniyle derin öğrenme hızlandırması için yaygın olarak kullanılır. LiteRT, derlenmiş bir model (CompiledModel) oluştururken kullanıcıların donanım hızlandırmayı parametre olarak belirtmesine olanak tanıyarak GPU hızlandırmayı kullanma sürecini basitleştirir.

LiteRT'nin GPU hızlandırması sayesinde GPU dostu giriş ve çıkış arabellekleri oluşturabilir, GPU belleğindeki verilerinizle sıfır kopya elde edebilir ve paralelliği en üst düzeye çıkarmak için görevleri eşzamansız olarak yürütebilirsiniz.

LiteRT GPU'nun örnek uygulamaları için aşağıdaki demo uygulamalarına bakın:

• Kotlin ile görüntü segmentasyonu
• C++ ile eşzamansız segmentasyon

GPU bağımlılığı ekleme

Kotlin veya C++ uygulamanıza GPU bağımlılığı eklemek için aşağıdaki adımları uygulayın.

Kotlin

Kotlin kullanıcıları için GPU hızlandırıcı yerleşiktir ve Başlangıç kılavuzunda belirtilen adımlar dışında ek adım gerektirmez.

C++

C++ kullanıcıları, uygulamanın bağımlılıklarını LiteRT GPU hızlandırmasıyla oluşturmalıdır. Temel uygulama mantığını paketleyen cc_binary kuralı (ör. main.cc) için aşağıdaki çalışma zamanı bileşenleri gerekir:

• LiteRT C API paylaşılan kitaplığı: data özelliği, LiteRT C API paylaşılan kitaplığını (//litert/c:litert_runtime_c_api_shared_lib) ve GPU'ya özel bileşenleri (@litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so) içermelidir.
• Özellik bağımlılıkları: deps özelliği genellikle GLES bağımlılıklarını gles_deps(), linkopts özelliği ise genellikle gles_linkopts() bağımlılıklarını içerir. LiteRT genellikle Android'de OpenGLES kullandığından her ikisi de GPU hızlandırma için son derece önemlidir.
• Model dosyaları ve diğer öğeler: data özelliği aracılığıyla eklenir.

Aşağıda bir cc_binary kuralı örneği verilmiştir:

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
)

Bu kurulum, derlenmiş ikilinizin hızlandırılmış makine öğrenimi çıkarımı için GPU'yu dinamik olarak yüklemesine ve kullanmasına olanak tanır.

CompiledModel API ile GPU kullanma

GPU hızlandırıcıyı kullanmaya başlamak için Derlenmiş Model'i (CompiledModel) oluştururken GPU parametresini iletin. Aşağıdaki kod snippet'inde tüm sürecin temel bir uygulaması gösterilmektedir:

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

Daha fazla bilgi için C++ ile Başlarken veya Kotlin ile Başlarken kılavuzlarına bakın.

GPU hızlandırmasıyla sıfır kopyalama

Sıfır kopyalama, CPU'nun bu verileri açıkça kopyalamasına gerek kalmadan bir GPU'nun kendi belleğindeki verilere doğrudan erişmesini sağlar. Verileri CPU belleğine ve CPU belleğinden kopyalamayarak sıfır kopyalama, uçtan uca gecikmeyi önemli ölçüde azaltabilir.

Aşağıdaki kod, vektör grafiklerin oluşturulması için kullanılan bir API olan OpenGL ile Sıfır Kopyalı GPU'nun örnek bir uygulamasıdır. Kod, OpenGL arabellek biçimindeki görüntüleri doğrudan LiteRT'ye iletir:

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

Eşzamansız yürütme

LiteRT'nin RunAsync() gibi eşzamansız yöntemleri, GPU çıkarımını planlamanıza olanak tanırken CPU veya NPU kullanarak diğer görevlere devam etmenizi sağlar. Karmaşık işlem hatlarında GPU genellikle CPU veya NPU'larla birlikte eşzamansız olarak kullanılır.

Aşağıdaki kod snippet'i, Zero-copy GPU acceleration örneğinde sağlanan kodu temel alır. Kod, hem CPU hem de GPU'yu eşzamansız olarak kullanır ve giriş arabelleğine bir LiteRT Event ekler. LiteRT Event farklı senkronizasyon temel öğelerini yönetmekten sorumludur ve aşağıdaki kod, LiteRtEventTypeEglSyncFence türünde yönetilen bir LiteRT Event nesnesi oluşturur. Bu Event nesnesi, GPU işlemi tamamlanana kadar giriş arabelleğinden okuma yapmamamızı sağlar. Tüm bu işlemler CPU kullanılmadan yapılır.

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

Desteklenen modeller

LiteRT, aşağıdaki modellerde GPU hızlandırmayı destekler. Karşılaştırma testinin sonuçları, Samsung Galaxy S24 cihazda yapılan testlere dayanmaktadır.