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 執行提供者 (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 執行提供者。" << 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（非極大值抑制）或繪製邊界方塊的處理
    }
};

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