Microsoft.Windows.AIの最新API活用事例とサンプルコード：Windows Copilot Runtimeの深淵を探る

1
2
3
4
5
6

<!-- .csproj の設定例 -->
<ItemGroup>
  <PackageReference Include="Microsoft.Windows.AI" Version="1.0.0-preview1" />
  <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.5.240311000" />
  <PackageReference Include="Microsoft.ML.OnnxRuntime.DirectML" Version="1.17.1" />
</ItemGroup>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Windows.AI.Generative;

namespace WindowsAI.Sample
{
    public class LocalLanguageModelService
    {
        private LanguageModel _languageModel;
        private bool _isInitialized = false;

        /// <summary>
        /// 言語モデルの初期化を行います。NPUの利用可能性をチェックし、最適なデバイスにモデルをロードします。
        /// </summary>
        public async Task InitializeAsync()
        {
            if (_isInitialized) return;

            Console.WriteLine("ローカルAIモデル（Phi-Silica）のシステム要件と可用性を確認しています...");
            
            // モデルがシステムで利用可能かチェック (非対応の場合はダウンロードが促される場合あり)
            var availability = await LanguageModel.CheckAvailabilityAsync();
            if (availability != LanguageModelAvailability.Available)
            {
                throw new InvalidOperationException($"ローカルAIモデルが現在利用できません。状態: {availability}");
            }

            // モデルのインスタンスを作成（このタイミングでメモリ空間へのマッピングとNPUの初期化が行われる）
            _languageModel = await LanguageModel.CreateAsync();
            _isInitialized = true;
            
            Console.WriteLine("言語モデルの初期化が完了しました。DirectMLを介したハードウェアアクセラレーションがアクティブです。");
        }

        /// <summary>
        /// ユーザーのプロンプトを受け取り、ストリーミングで応答を生成します。
        /// </summary>
        public async Task GenerateResponseStreamAsync(string prompt, CancellationToken cancellationToken)
        {
            if (!_isInitialized) await InitializeAsync();

            Console.WriteLine($"\n[ユーザー入力]: {prompt}\n[AIアシスタント]: ");

            // 生成時のハイパーパラメータを設定
            var options = new LanguageModelOptions
            {
                Temperature = 0.7f,
                TopP = 0.9f,
                MaxTokens = 2048,
                RepetitionPenalty = 1.1f
            };

            // 会話コンテキストの構築
            var context = new LanguageModelContext();
            context.AddSystemMessage("あなたはWindowsのローカルNPU上で直接動作している高度なAIアシスタントです。ステップバイステップで論理的に思考し、簡潔に回答してください。");
            context.AddUserMessage(prompt);

            try
            {
                // ストリーミング推論APIの呼び出し
                var responseStream = _languageModel.GenerateResponseStreamAsync(context, options);

                // IAsyncEnumerableとして返されるチャンクを非同期で反復処理
                await foreach (var chunk in responseStream.WithCancellation(cancellationToken))
                {
                    // 生成されたトークン（チャンク）をリアルタイムにコンソールへ出力
                    // UIアプリケーションの場合は、ここでDispatcherQueueを用いてTextBox等に反映する
                    Console.Write(chunk.Text);
                }
                Console.WriteLine();
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("\n[ユーザーまたはシステムによって生成がキャンセルされました]");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"\n[致命的なエラーが発生しました: {ex.Message}]");
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include <onnxruntime_cxx_api.h>
#include <dml_provider_factory.h>

class CustomVisionAIProcessor {
private:
    Ort::Env env;
    Ort::Session session{nullptr};
    Ort::AllocatorWithDefaultOptions allocator;
    
public:
    CustomVisionAIProcessor(const std::wstring& modelPath) 
        : env(ORT_LOGGING_LEVEL_WARNING, "VisionAIProcessor") {
        
        Ort::SessionOptions sessionOptions;
        // スレッド数の最適化
        sessionOptions.SetIntraOpNumThreads(1);
        // グラフの最適化レベルを最大に設定
        sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);

        // 1. DirectML Execution Provider (DML EP) の追加
        // device_id = 0 はシステムのデフォルト推奨アダプタ（NPUまたは高性能GPU）
        const OrtApi& ortApi = Ort::GetApi();
        OrtDmlApi* dmlApi = nullptr;
        OrtStatus* status = ortApi.GetExecutionProviderApi("DML", ORT_API_VERSION, reinterpret_cast<void**>(&dmlApi));
        
        if (status == nullptr && dmlApi != nullptr) {
            Ort::ThrowOnError(dmlApi->SessionOptionsAppendExecutionProvider_DML(sessionOptions, 0));
            std::cout << "[Info] DirectML Execution Provider を正常にアタッチしました。" << std::endl;
        } else {
            std::cerr << "[Warning] DirectML API の取得に失敗しました。CPUフォールバックモードで実行します。" << std::endl;
            if (status != nullptr) ortApi.ReleaseStatus(status);
        }

        // 2. モデルのロードとセッションの作成
        try {
            session = Ort::Session(env, modelPath.c_str(), sessionOptions);
            std::cout << "[Info] ONNXモデルのロードに成功し、計算グラフがコンパイルされました。" << std::endl;
        } catch (const Ort::Exception& e) {
            std::cerr << "[Error] モデルロード失敗: " << e.what() << std::endl;
            throw;
        }
    }

    void RunInference(const std::vector<float>& imageTensor, const std::vector<int64_t>& inputShape) {
        // 3. 入力テンソルのバッファ作成
        Ort::MemoryInfo memoryInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
        Ort::Value inputTensor = Ort::Value::CreateTensor<float>(
            memoryInfo, 
            const_cast<float*>(imageTensor.data()), 
            imageTensor.size(), 
            inputShape.data(), 
            inputShape.size()
        );

        // 4. 入出力ノード名の動的取得
        auto inputNamePtr = session.GetInputNameAllocated(0, allocator);
        auto outputNamePtr = session.GetOutputNameAllocated(0, allocator);
        const char* inputNames[] = { inputNamePtr.get() };
        const char* outputNames[] = { outputNamePtr.get() };

        // 5. 推論の実行 (DirectMLを介してNPU/GPUにオフロードされる)
        std::cout << "[Info] 推論エンジンの実行を開始します..." << std::endl;
        auto startTime = std::chrono::high_resolution_clock::now();

        auto outputTensors = session.Run(Ort::RunOptions{nullptr}, inputNames, &inputTensor, 1, outputNames, 1);

        auto endTime = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

        // 6. 結果テンソルの取得と解析
        float* outputData = outputTensors.front().GetTensorMutableData<float>();
        size_t outputSize = outputTensors.front().GetTensorTypeAndShapeInfo().GetElementCount();
        
        std::cout << "[Result] 推論完了: " << duration.count() << " ms" << std::endl;
        std::cout << "[Result] 出力テンソルの要素数: " << outputSize << std::endl;
        // ※この後、出力テンソルに対してNMS（Non-Maximum Suppression）やバウンディングボックスの描画処理を実装する
    }
};

int main() {
    try {
        // 実行するONNXモデルのパス
        CustomVisionAIProcessor processor(L"models/yolov8n_quantized.onnx");
        
        // 推論用のダミー画像データ (バッチサイズ1 x 3チャンネル x 640 x 640)
        std::vector<int64_t> inputShape = {1, 3, 640, 640};
        std::vector<float> dummyImage(1 * 3 * 640 * 640, 0.5f);
        
        processor.RunInference(dummyImage, inputShape);
    } catch (const std::exception& e) {
        std::cerr << "プログラムが異常終了しました: " << e.what() << std::endl;
        return -1;
    }
    return 0;
}