NVIDIA ACE AI Karakterlerini Oyunlara Taşıyan Yeni Oyun İçi Inference SDK’sı

NVIDIA ACE, oyuncu karakterlerini ve dijital asistanları hayatımıza getiren bir dijital insan teknolojileri paketidir. ACE’in yerel modelleri, bağımsız oyun karakterleri için otonom iş akışları oluşturarak, çevrelerini algılayabilen, çoklu modlu girdileri anlayan, stratejik bir dizi eylem planlayabilen ve bunları gerçek zamanlı olarak gerçekleştirebilen dinamik deneyimler sunar.

Bu modelleri oyun motorlarıyla birlikte çalıştırmak için NVIDIA In-Game Inferencing (NVIGI) SDK, AI çıkarımını doğrudan C++ oyunlarına ve uygulamalarına entegre etmenizi sağlar ve böylece optimal performans ve düşük gecikme sağlar.

Bu yazıda, NVIGI’nin ACE ile nasıl entegre olduğunu, oyun geliştirme sürecinde AI çıkarımını nasıl sağladığını, NVIGI mimarisini, temel özelliklerini ve NVIDIA ACE yerel modelleri ile otonom karakterler oluşturmayı öğrenmeye nasıl başlayacağınızı keşfedeceğiz.

NVIDIA ACE Yerel Modelleri

NVIDIA ACE, konuşma, zeka ve animasyonu üretken yapay zeka ile güçlendirir. Oyun karakterlerinin gerçek zamanlı olarak oyuncu etkileşimlerine dayanarak algılama, akıl yürütme ve eyleme geçme yetenekleri sunan bir dizi AI modeli sağlar:

• Algılama: Yakında gelecek olan NeMoAudio-4B-Instruct modeli, karakter etkileşimlerine daha fazla bağlamsal farkındalık kazandırır. Daha fazla çok modlu model entegre ederek bu yetenekleri genişletebilirsiniz.
• Akıl yürütme:Mistral-Nemo-Minitron-Instruct modeli, karakterlerin doğru bir şekilde rol yapabilmesi için talimat takip etme yetenekleri açısından üst sıralarda yer alır.
• Hafıza:E5-Large-Unsupervised gibi gömme modelleri, karakterlerin geçmiş etkileşimleri hatırlamasını sağlayarak sürükleyiciliği artırır.
• Animasyon:Audio2Face gibi gerçek zamanlı AI destekli animasyon, duygusal ifadeler için doğru dudak senkronizasyonu sağlar.
• Eylem: Basit arabirimler ve özel mantık, karakterlerin stratejik planları yürüterek anlamlı eylemler almasını sağlar.

NVIDIA In-Game Inferencing SDK Nedir?

NVIGI SDK, ACE modellerinin oyun ve etkileşimli uygulamalara entegrasyonunu kolaylaştırmak için tasarlanmış, GPU’ya optimize edilmiş, eklenti tabanlı bir çıkarım yöneticisidir. Aşağıdaki işlevselliği sunar:

• Eklenti esnekliği: AI eklentilerini (ASR, dil modelleri, gömme) kolayca ekleyin, güncelleyin ve yönetin.
• Windows yerel DLL’leri: C++ oyunları ve uygulamaları için çalışma akışlarını basitleştirin.
• GPU optimizasyonu: Renderleme görevleriyle birlikte verimli AI çıkarımı için compute-in-graphics (CIG) teknolojisini kullanın.

NVIGI ve ACE birleşimi ile, oyun içindeki NPC diyalogları, bağlamsal hafıza ve gerçekçi animasyonlar gibi gelişmiş üretken AI yeteneklerine sahip otonom karakterler oluşturabilirsiniz.

NVIGI Nasıl Çalışır?

NVIGI mimarisi, çeşitli AI işlevlerinin esnek entegrasyonunu sağlayan modüler eklenti temellidir:

• Temel eklentiler: Otomatik konuşma tanıma (ASR), üretken akıl yürütme ve gömme erişimi gibi AI yeteneklerini sağlar.
• Yardımcı eklentiler: GPU zamanlama ve ağ iletişimi gibi yardımcı işlevleri yönetir.
• Birleşik API’ler: Eklenti yönetimini basitleştirir ve kod karmaşasını azaltır.
• Yerel ve bulut ejecución: Hem cihaz içi çıkarım (CPU/GPU) hem de bulut tabanlı AI iş akışlarını destekler.

Bu bileşenler, AI destekli bir oyun deneyimi sağlamak için birlikte çalışır. Örneğin, bir oyuncunun bir NPC’ye soru sorduğunu hayal edin. NVIGI, bu temsilci iş akışını düzenleyerek karakterlerin dinleme, akıl yürütme, konuşma ve animasyon yapma yeteneklerini gerçek zamanlı olarak gerçekleştirir.

Bu süreç belirli adımları izler:

1. Kullanıcıları dinleme: NPC, oyuncu konuşmasını işleyerek, söylenenleri metne dönüştürür.
2. Yanıt oluşturma: Transkribe edilen metin, bağlamsal olarak uygun bir yanıt oluşturmak için bir küçük dil modeline (SLM) aktarılır.
3. Karakterlere ses verme: Oluşturulan yanıt gerçekçi sesler olarak sentezlenir.
4. Etkin animasyon oluşturma: Konuşulan yanıt, gerçek zamanlı animasyon için yüz hareketlerini yönlendirir.

Tüm bu süreç boyunca GPU zamanlaması ve CIG, AI çıkarım iş yüklerinin renderleme görevleri ile birlikte çalışmasını sağlarken, kare hızlarını minimize eder.

ACE Yerel Çıkarım ile Başlamak

Bu bölüm, NVIGI’yi ACE küçük dil modelleri ile kullanarak renderleme iş yüklerinizle birlikte AI çıkarımını etkinleştirmenizi sağlar.

NVIGI, NVIDIA NGC ve Huggingface gibi depolardan modelleri almayı kolaylaştıran toplu dosyalar içerir. Bu, ilk indirmenin minimumda kalmasını ve yalnızca çalışmak istediğiniz modellerin indirilmesini sağlar.

İlk adım, NVIGI çerçevesini başlatmaktır. Bu işlem, NVIGI’nin oyununuzda işlevini sürdürebilmesi için gerekli eklenti yollarını, günlüğü ve temel yapılandırmaları ayarlar.

Aşağıda, oyununuzda NVIGI’yi başlatmanın bir örneğini bulabilirsiniz:

nvigi::Preferences preferences{};
preferences.logLevel = nvigi::LogLevel::eVerbose; // Ayrıntılı günlüğü etkinleştirin
preferences.utf8PathsToPlugins = {"path/to/plugins"}; // Eklenti yolunu ayarlayın
preferences.utf8PathToLogsAndData = "path/to/logs";    // Günlük yolu tanımlayın

if (nvigiInit(preferences, nullptr, nvigi::kSDKVersion) != nvigi::kResultOk) {
    std::cerr << "NVIGI'yi başlatma başarısız oldu." << std::endl;
}

NVIGI mimarisi, modülerlik ve esneklik sunan bir eklenti sistemine dayanır. Her eklenti, benzer bir arka plan ve temel API’yi paylaşan birden fazla modeli desteklemek üzere tasarlanmıştır. NVIGI, yaygın arka uçlar olan GGML ile birlikte yerel çıkarım eklentileri içerir.

Örnek olarak, NVIGI’deki bir GPT eklentisini yükleme işlemini inceleyelim:

// GPT eklenti arayüzünü yükle
nvigi::IGeneralPurposeTransformer* gpt = nullptr;
nvigiGetInterfaceDynamic(nvigi::plugin::gpt::ggml::cuda::kId, &gpt, ptr_nvigiLoadInterface);

NVIGI, başlamanız için önceden yüklenmiş bir dizi model içermektedir. Diğer GGUF modellerini NGC veya Huggingface’den de temin edebilirsiniz. Eklenti için model parametrelerini tanımlayan bir örnek aşağıda verilmiştir:

// Model parametrelerini yapılandır
nvigi::CommonCreationParameters common{};
common.utf8PathToModels = "path/to/models";
common.numThreads = 8;                    // CPU iş parçacığı sayısı
common.vramBudgetMB = vram;               // VRAM tahsisi (MB cinsinden)
common.modelGUID = "{YOUR_MODEL_GUID}";   // Model GUID

Arayüz ve model parametreleri yüklendikten sonra bir örnek oluşturun veya süreç içi çıkarımı yapılandırın:

// GPT örneğini oluştur
nvigi::InferenceInstance* gptInstance = nullptr;
if (gpt->createInstance(common, &gptInstance) != nvigi::kResultOk || !gptInstance) {
    std::cerr << "GPT örneğini oluşturma başarısız oldu." << std::endl;
}

// GPT örneğini çıkarım için kullanın

Çalışma Konfigürasyonu ve Çıkarım Oluşturma

InferenceInstance arayüzü, çıkarım görevlerini yürütmek için API sunar ve InferenceExecutionContext aracılığıyla yapılandırılır. Bu arayüz, giriş slotlarının, çalışma parametrelerinin ayarlanmasına ve model yanıtlarını alacak geri çağırma mekanizmalarının kurulmasına olanak tanır.

Çıkarım görevleri, oyuncu metni veya sesi gibi giriş verileri ile birlikte çalışma yapılandırmalarına dayanır. Bir oyun karakterinin kişiliği ve rolü nvigi::kGPTDataSlotSystem slotu ile tanımlanabilir:

// NPC rolünü sistem istemi ile tanımlayın
std::string npcPrompt = "Sen, bir fantezi oyununda yardımcı bir NPC'sin.";
nvigi::CpuData systemPromptData(npcPrompt.length() + 1, npcPrompt.c_str());
nvigi::InferenceDataText systemPromptSlot(systemPromptData);

// Çalışma parametrelerini ayarlayın
nvigi::GPTRuntimeParameters runtime{};
runtime.tokensToPredict = 200;  // Tahmin edilecek token sayısını 200 ile sınırlayın
runtime.interactive = true;     // Çok turlu konuşmaları etkinleştirin
std::vector<nvigi::InferenceDataSlot> slots = {
    {nvigi::kGPTDataSlotSystem, &systemPromptSlot}
};

// Çıkarım bağlamı
nvigi::InferenceExecutionContext gptExecCtx{};
gptExecCtx.instance = gptInstance;
gptExecCtx.runtimeParameters = runtime;
gptExecCtx.inputs = slots.data();

Oyuncu ile oyun karakterinin etkileşimini yönetmek için aşağıdaki şekilde devam edin:

std::string userInput = "Adın ne?"; // Örnek kullanıcı girişi
nvigi::CpuData userInputData(userInput.length() + 1, userInput.c_str());
nvigi::InferenceDataText userInputSlot(userInputData);

slots = {{nvigi::kGPTDataSlotUser, &userInputSlot}};
gptExecCtx.inputs = slots.data();

Yanıtın asenkron bir şekilde çıkarımını çalıştırın ve işleyin:

if (gptExecCtx.instance->evaluate(&gptExecCtx) == nvigi::kResultOk) {
    std::cout << "Çıkarım başarıyla tamamlandı!" << std::endl;
}

Her bir konuşma turu, çok turlu diyalog için bağlamı koruyarak nvigi::kGPTDataSlotUser giriş slotu aracılığıyla işlenir.

Ayrıca, karakter yanıtını oyunda görüntülemek için bir geri çağırma işlevi uygulayabilirsiniz.

GPU Zamanlamasını Etkinleştirin ve Render Entegrasyonu

Oyundaki AI iş yükleri, renderleme görevleri ile birlikte çalışır ve etkili GPU zamanlaması, kare hızlarını korumak için önemlidir. NVIGI, AI çıkarım iş yüklerinin verimli bir şekilde zamanlamasını sağlamak için compute-in-graphics (CIG) teknolojisini kullanır.

GPU zamanlamasını etkinleştirmek için, oyununuzun grafik için kullandığı D3D doğrudan kuyruğunu almak önemlidir. D3D12Parameters yapısı, NVIGI’nin renderleme pipeline’ı ile direkt entegrasyonunu sağlar.

Aşağıda, NVIGI IHWICuda arayüzü kullanılarak AI çıkarımı için CIG’yi etkinleştirmekle ilgili bir örnek verilmiştir:

// Compute-in-Graphics (CIG) etkinleştir
nvigi::IHWICuda* icig = nullptr;
if (nvigiGetInterface(nvigi::plugin::hwi::cuda::kId, &icig) != nvigi::kResultOk || !icig) {
    std::cerr << "CIG arayüzünü yüklemek başarısız oldu." << std::endl;
    return;
}

// D3D12 parametrelerini ayarlayın
nvigi::D3D12Parameters d3d12Params{};
d3d12Params.device = myD3D12Device;            // Renderleme için kullanılan D3D12 cihazı
d3d12Params.queue = myD3D12CommandQueue;      // Grafik komut kuyruğu

// Hem çıkarım hem de renderleme için GPU zamanlamasını etkinleştir
if (icig->enableComputeInGraphics(d3d12Params) != nvigi::kResultOk) {
    std::cerr << "Compute-in-Graphics etkinleştirmek başarısız oldu." << std::endl;
    return;
}
std::cout << "Compute-in-Graphics başarıyla etkinleştirildi." << std::endl;

NVIGI GPU zamanlamasını Unreal Engine 5 (UE5) içerisinde ayarlamak için, oyunun D3D cihazına ve komut kuyruğuna erişmek için küresel dinamik render donanım arayüzünü kullanın.

UE5’te CIG’yi yapılandırmak oldukça basittir:

// UE5 için D3D12 kaynaklarını alma kodu
#include "ID3D12DynamicRHI.h"

ID3D12DynamicRHI* RHI = nullptr;
if (GDynamicRHI && GDynamicRHI->GetInterfaceType() == ERHIInterfaceType::D3D12)
{
    RHI = static_cast<ID3D12DynamicRHI*>(GDynamicRHI);
}

ID3D12CommandQueue* CmdQ = nullptr;
ID3D12Device* D3D12Device = nullptr;

if (RHI) {
    CmdQ = RHI->RHIGetCommandQueue();  // Grafik komut kuyrukını al
    int DeviceIndex = 0;
    D3D12Device = RHI->RHIGetDevice(DeviceIndex);  // D3D12 cihazını al
}

// IGI için D3D12 parametrelerini yapılandır
nvigi::D3D12Parameters d3d12Params{};
d3d12Params.device = D3D12Device;
d3d12Params.queue = CmdQ;

// Parametreleri IGI örneklerine geçirin
nvigi::CommonCreationParameters commonParams{};
commonParams.chain(d3d12Params);

// CIG ile bir ASR örneği oluşturma örneği
nvigi::ASRCreationParameters asrParams{};
asrParams.common = &commonParams;

nvigi::InferenceInstance* asrInstance = nullptr;
iasr->createInstance(asrParams, &asrInstance);

Çıkarımı Çalıştırma

NVIGI’de çıkarım görevleri, bir konuşma bağlamı oluşturmayı, kullanıcı girdilerini işlemeyi ve dinamik yanıtlar üretmeyi içerir. İşte oyun ortamınızda çıkarım görevlerini etkin bir şekilde çalıştırmanın adımları:

• Giriş slotları: Kullanıcı metni veya ses verilerini, modelin işleyebileceği biçimde hazırlayın.
• Çalışma parametreleri: Çıkarım davranışını tanımlayın (örneğin, tahmin edilecek token sayısı veya etkileşim ayarları).
• Geri çağırma mekanizmaları: Çıktı sonuçlarını işlemek için nasıl işlev göreceğini belirleyin.

Çıkarım bağlamı, girdilerin ve çıktılarının nasıl işleneceğini tanımlar. Etkileşimli modu etkinleştirin ve çalışma parametrelerini hazırlayın:

// GPT için çalışma parametrelerini yapılandır
nvigi::GPTRuntimeParameters runtime{};
runtime.tokensToPredict = 200;  // 200'den fazla token tahmini yapılmasını engelleyin
runtime.interactive = true;     // Etkileşimli modu etkinleştir

// Çıkarım bağlamını ayarlayın
nvigi::InferenceExecutionContext gptExecCtx{};
gptExecCtx.instance = gptInstance;   // Önceden oluşturulan GPT örneğini kullanın
gptExecCtx.runtimeParameters = runtime;

gptExecCtx.callback = [](const nvigi::InferenceExecutionContext* execCtx, nvigi::InferenceExecutionState state, void* userData) {
    if (state == nvigi::kInferenceExecutionStateDone && execCtx->outputs){
        const nvigi::InferenceDataText* responseText = nullptr;
        execCtx->outputs->findAndValidateSlot(nvigi::kGPTDataSlotResponse, &responseText);
        if (responseText) {
            std::cout << "NPC Yanıtı: " << responseText->getUtf8Text() << std::endl;
        }
    }
    return state;
};

Konuşmayı başlatmak için, NPC’nin kişiliğini tanımlayan bir sistem istemi sağlayın. nvigi::kGPTDataSlotSystem slotunu kullanarak bunu yapın:

// Konuşma bağlamını ayarlayın
std::string npcPrompt = "Sen, bir fantezi oyununda yardımcı bir NPC'sin. Oyuncuların sorularına düşünceli yanıtlar ver.";

nvigi::CpuData systemPromptData(npcPrompt.length() + 1, npcPrompt.c_str());
nvigi::InferenceDataText systemPromptSlot(systemPromptData);

std::vector<nvigi::InferenceDataSlot> slots = {
    {nvigi::kGPTDataSlotSystem, &systemPromptSlot}  // Sistem istemini ayarlayın
};

gptExecCtx.inputs = slots.data();
gptExecCtx.numInputs = slots.size();

// Konuşma bağlamını başlatmak için yürütün
if (gptExecCtx.instance->evaluate(&gptExecCtx) != nvigi::kResultOk) {
    std::cerr << "Konuşma bağlamını başlatmada başarısız oldu." << std::endl;
    return;
}

Kullanıcı İhtiyarlarını Yanıtlamak

NPC’nin oyuncu sorularına yanıt vermesi için bir sistem istemi kullanarak konuşmayı başlatın ve oyuncu girdilerini tanımlayın. Yanıtların alınmasını sağlamak ve etkili bir kullanıcı deneyimi yaratmak için sürekliliği koruyarak yanıtların asenkron bir şekilde işlenmesine dikkat edin.

Oyun karakterlerinin sürükleyici ve dinamik tepkiler verebilmesi için, yapay zekanın sunduğu bu fırsatları değerlendirin. Bunun sayesinde, istenilen etkileşimi sağlama ve kullanıcı deneyimini geliştirme şansı elde edersiniz.

Mümkün Olan NVIGI Eklenteleri Listesi

Bugün, ses ve zeka modelleri için aşağıdaki NVIGI eklentileri ile cihaz içi çıkarım için ajans çerçeveleri oluşturabilirsiniz:

Sonuç

NVIDIA ACE ve NVIGI, AI destekli oyun geliştirmede yeni bir adım temsil ediyor. ACE’in gelişmiş üretken AI modellerini NVIGI’nin sorunsuz entegrasyonu ve GPU’ya optimize edilmiş performansıyla birleştirerek, etkileşim ve sürükleyicilik açısından yeni seviyeler açabilirsiniz.

Dolaşık NPC diyalogları, gerçek zamanlı konuşma tanıma, gerçekçi animasyonlar ve bağlamsal hafıza ile ACE ve NVIGI, zeki, otonom karakterler yaratmak için maliyet etkin ve ölçeklenebilir bir çözüm sunmaktadır.

NVIDIA ACE ve NVIGI ile projelerinize başlamak için harekete geçin!