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ıyla 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.

Başlayın

• Klasik makine öğrenimi modelleri için aşağıdaki demo uygulamalara bakın.

  • Görüntü segmentasyonu Kotlin uygulaması: CPU/GPU/NPU çıkarımı.
  • Görüntü segmentasyonu C++ uygulaması: Asenkron yürütme ile CPU/GPU/NPU çıkarımı.

• Üretken yapay zeka modelleri için aşağıdaki demoları ve kılavuzu inceleyin:

  • EmbeddingGemma semantik benzerlik C++ uygulaması: CPU/GPU/NPU çıkarımı.
  • LiteRT-LM kullanarak LLM'leri çalıştırma kılavuzu.

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 belirtilenler dışında ek adım gerektirmez.

C++

C++ kullanıcıları için uygulamanın bağımlılıklarını LiteRT GPU hızlandırmasıyla oluşturmanız gerekir. 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_accelerator_prebuilts) 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:

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
)

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.

Önceden Oluşturulmuş GPU Hızlandırıcılar

Yeni LiteRT GPU hızlandırıcı henüz açık kaynaklı değildir. Ancak hazır bilgisayarlar mevcuttur. Kotlin kullanıcıları için LiteRT Maven paketi zaten GPU Hızlandırıcıları içerir. C++ SDK kullanıcılarının, buradan ayrı olarak indirmesi gerekir.

Bazel'de, hedefinize bağımlılık eklemek için aşağıdaki kuralı kullanabilirsiniz. cpp load("//litert/build_common:special_rule.bzl", "litert_gpu_accelerator_prebuilts")

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

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, GPU'nun verileri kendi belleğinde doğrudan erişmesini sağlar. Bu durumda CPU'nun verileri açıkça kopyalaması gerekmez. 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 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());

Eşzamansız yürütme

LiteRT'nin RunAsync() gibi eşzamansız yöntemleri, CPU veya NPU kullanarak diğer görevlere devam ederken GPU çıkarımı planlamanıza olanak tanır. 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 verilen 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, "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));

Desteklenen arka uç

LiteRT, her platform için aşağıdaki GPU arka ucunu destekler.

Desteklenen modeller

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