# Windows AI and AI PC Capabilities

**Last updated:** 2026-02
**Status:** GA
**Category:** Hybrid Cloud & Edge AI

---

## Introduksjon

Windows AI-plattformen representerer Microsofts satsing pa lokal AI-inferens direkte pa klientenheter. Med Windows ML (Machine Learning), ONNX Runtime integrert i OS, og Neural Processing Units (NPU) i Copilot+ PC-er, kan AI-modeller kjores lokalt med full datakontroll, ingen nettverkslatens, og forutsigbar ytelse.

For norsk offentlig sektor er Windows AI relevant for klientbaserte AI-funksjoner som dokumentklassifisering, oppsummering, og informasjonsuttrekking — alt uten at data forlater enheten. Ansatte kan bruke AI-stoettede verktoy for daglige oppgaver uten bekymring for at sensitive data sendes til skytjenester. Phi-4 Mini, innebygd i Microsoft Edge som lokal SLM, demonstrerer denne tilnaermingen.

Windows ML er den anbefalte veien for a deploye ONNX-modeller pa Windows, med automatisk Execution Provider-discovery som velger beste tilgjengelige akselerator — NPU, GPU eller CPU — uten at utviklere trenger a kode for spesifikk hardware.

---

## Kjernekomponenter

| Komponent | Formal | Teknologi |
|-----------|--------|-----------|
| Windows ML | ONNX Runtime integrert i Windows | Windows App SDK |
| ONNX Runtime | Inferensmotor for AI-modeller | Open source |
| DirectML | GPU/NPU-akselerasjon (legacy) | Windows |
| Execution Providers | Hardware-spesifikke akseleratorer | QNN, OpenVINO, DML |
| Phi-4 Mini | Innebygd SLM i Microsoft Edge | Lokal inferens |
| AI Dev Gallery | Eksempler og modellkatalog | Open source |
| Foundry Local | Klare-til-bruk AI-modeller | Microsoft |
| Windows AI APIs | Innebygde AI-funksjoner | Windows SDK |

---

## Windows ML og ONNX Runtime

### Hvordan Windows ML fungerer

Windows ML inkluderer en kopi av ONNX Runtime og muliggjor dynamisk nedlasting av leverandorspesifikke Execution Providers (EP):

```
[ONNX-modell] → [Windows ML] → [EP Discovery] → [Inferens]
                                      ↓
                        ┌─────────────┼─────────────┐
                        ↓             ↓             ↓
                   [Qualcomm QNN]  [Intel OpenVINO] [DirectML]
                   (Snapdragon NPU) (Intel NPU)    (GPU/CPU)
```

### Kodeeksempel: Windows ML-inferens i C#

```csharp
// Windows ML-inferens med automatisk EP-discovery
using Microsoft.ML.OnnxRuntime;

public class WindowsMLService
{
    private InferenceSession _session;

    public async Task<bool> InitializeAsync(string modelPath)
    {
        try
        {
            var options = new SessionOptions();

            // Windows ML velger automatisk beste EP:
            // 1. NPU (Qualcomm QNN / Intel OpenVINO) - lavest energibruk
            // 2. GPU (DirectML) - hoeyest ytelse
            // 3. CPU - alltid tilgjengelig fallback
            // EP-er lastes ned automatisk via Windows Update
            options.AppendExecutionProvider_WindowsML();

            _session = new InferenceSession(modelPath, options);
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Kunne ikke initialisere modell: {ex.Message}");
            return false;
        }
    }

    public float[] Classify(float[] input, int[] shape)
    {
        var tensor = new DenseTensor<float>(input, shape);
        var inputs = new List<NamedOnnxValue>
        {
            NamedOnnxValue.CreateFromTensor("input", tensor)
        };

        using var results = _session.Run(inputs);
        return results.First().AsTensor<float>().ToArray();
    }
}
```

### Kodeeksempel: Python med Windows ML

```python
# Windows ML-inferens i Python
import onnxruntime as ort
import numpy as np

# Opprett session med Windows ML EP
session_options = ort.SessionOptions()
session = ort.InferenceSession(
    "model.onnx",
    sess_options=session_options,
    providers=["WindowsMLExecutionProvider", "CPUExecutionProvider"]
)

# Kjor inferens
input_data = np.random.randn(1, 3, 224, 224).astype(np.float32)
result = session.run(None, {"input": input_data})
print(f"Output shape: {result[0].shape}")
```

### Modellkompilering for optimal ytelse

```csharp
// Kompiler modell for optimal EP-ytelse (forhands-optimalisering)
using Microsoft.ML.OnnxRuntime;

// Kompilering kan ta flere minutter — gjor dette i bakgrunnen
var compileOptions = new OrtModelCompilationOptions(sessionOptions);
compileOptions.SetInputModelPath(modelPath);
compileOptions.SetOutputModelPath(compiledModelPath);

// Kompiler modellen (optimal for enhetens hardware)
await Task.Run(() => compileOptions.CompileModel());

// Bruk kompilert modell for raskere inferens
var session = new InferenceSession(compiledModelPath, sessionOptions);
```

---

## Neural Processing Unit (NPU)

### Hva er en NPU?

En Neural Processing Unit er en dedikert AI-brikke designet spesifikt for a utfore AI-oppgaver som moenstergjenkjenning, klassifisering og naturlig sprakbehandling. I motsetning til CPU (generelle beregninger) og GPU (parallellprosessering for grafikk), er NPU-er optimalisert for nevrale nettverksoperasjoner med lavt energiforbruk.

### NPU-landskap i Copilot+ PC-er

| Leverandoer | Chip | TOPS | Prosess | Plattform |
|-------------|------|------|---------|-----------|
| Qualcomm | Snapdragon X Elite | 45 TOPS | 4nm | ARM64 |
| Qualcomm | Snapdragon X Plus | 45 TOPS | 4nm | ARM64 |
| Intel | Core Ultra 200V | 48 TOPS | Intel 4 | x64 |
| AMD | Ryzen AI 300 | 50 TOPS | 4nm | x64 |

### NPU vs GPU vs CPU for AI

| Aspekt | NPU | GPU | CPU |
|--------|-----|-----|-----|
| Energiforbruk | Lavest | Hoeyest | Medium |
| AI-ytelse | Hoey (spesialisert) | Hoeyest (generell) | Lavest |
| Tilgjengelighet | Nye PC-er | Diskret/integrert | Alle |
| Modellstoette | INT4/INT8 | FP16/FP32 | Alle formater |
| Best for | Alltid-pa AI | Tunge oppgaver | Fallback |

### Tilgang til NPU via Windows ML

```csharp
// Automatisk NPU-bruk via Windows ML
// Ingen eksplisitt NPU-koding nodvendig — Windows ML velger beste EP

// For avansert kontroll: Sjekk tilgjengelig hardware
public void CheckAICapabilities()
{
    var session = new InferenceSession("model.onnx");
    var providers = session.GetAvailableProviders();

    foreach (var provider in providers)
    {
        Console.WriteLine($"Tilgjengelig EP: {provider}");
        // Eksempel output:
        // QNNExecutionProvider (Qualcomm NPU)
        // OpenVINOExecutionProvider (Intel NPU)
        // DmlExecutionProvider (GPU)
        // CPUExecutionProvider (CPU)
    }
}
```

---

## Copilot+ PC Specifications

### Minimumskrav for Copilot+ PC

| Krav | Spesifikasjon |
|------|---------------|
| NPU | Minimum 40 TOPS |
| RAM | 16 GB eller mer |
| Lagring | 256 GB SSD eller mer |
| OS | Windows 11 24H2 eller nyere |

### Windows AI APIs (innebygde funksjoner)

| API | Funksjon | Krav | Status |
|-----|----------|------|--------|
| OCR | Tekstgjenkjenning i bilder | Copilot+ PC | GA |
| Image Description | Bildebeskrivelese med AI | Copilot+ PC | GA |
| Text Summarization | Oppsummering av tekst | Copilot+ PC | GA |
| Object Erase | Fjern objekter fra bilder | Copilot+ PC | GA |
| Image Segmentation | Segmentering av bilder | Copilot+ PC | GA |
| Phi Silica | Innebygd SLM i Windows | Copilot+ PC | GA |

### Bruk av Windows AI APIs

```csharp
// Windows AI API: Tekstoppsummering
using Windows.AI;

public async Task<string> SummarizeText(string text)
{
    var summarizer = await TextSummarizer.CreateAsync();

    var result = await summarizer.SummarizeAsync(text, new SummarizerOptions
    {
        MaxSentences = 3,
        Language = "no"  // Norsk stoette
    });

    return result.Summary;
}
```

---

## Local LLM Inference on Device

### Phi-4 Mini i Microsoft Edge

Microsoft Edge inkluderer Phi-4 Mini som lokal SLM, tilgjengelig via Web AI API-er:

```javascript
// Prompt API i Microsoft Edge (Phi-4 Mini lokal inferens)
// Ingen nettverkskall — alt skjer pa enheten

async function localAIClassification(text) {
    // Sjekk tilgjengelighet
    const availability = await ai.languageModel.capabilities();
    if (availability.available === 'no') {
        console.log('Lokal AI ikke tilgjengelig pa denne enheten');
        return null;
    }

    // Opprett session med system-prompt
    const session = await ai.languageModel.create({
        systemPrompt: `Du er en dokumentklassifiserer for norsk offentlig sektor.
Klassifiser dokumenter i en av disse kategoriene:
- Vedtak
- Klage
- Henvendelse
- Intern notat
- Hoeringssvar
Svar KUN med kategorinavnet.`
    });

    // Kjor lokal inferens
    const result = await session.prompt(
        `Klassifiser dette dokumentet: "${text.substring(0, 500)}"`
    );

    session.destroy();
    return result.trim();
}
```

```javascript
// Writing Assistance API: Oppsummering i Edge
async function summarizeDocument(text) {
    const summarizer = await ai.summarizer.create({
        type: 'key-points',
        length: 'short',
        format: 'markdown'
    });

    const summary = await summarizer.summarize(text);
    summarizer.destroy();
    return summary;
}
```

### Foundry Local for rikere modeller

```bash
# Installer Foundry Local for lokale AI-modeller
# Gir tilgang til storre modeller enn de innebygde

# List tilgjengelige modeller
foundry model list

# Last ned Phi-3.5 for lokal bruk
foundry model download phi-3.5-mini

# Start inferens-server
foundry model serve phi-3.5-mini --port 11434

# Bruk via OpenAI-kompatibelt API
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "phi-3.5-mini",
    "messages": [
      {"role": "system", "content": "Du er en hjelpsom assistent for norsk offentlig sektor."},
      {"role": "user", "content": "Oppsummer folgende utredning..."}
    ]
  }'
```

---

## Norsk offentlig sektor

### Brukstilfeller for Windows AI i offentlig sektor

| Brukstilfelle | Windows AI-losning | Fordel |
|---------------|-------------------|--------|
| E-post-triage | Phi-4 Mini (Edge Prompt API) | Klassifiser innkommende post uten sky |
| Dokumentoppsummering | Windows AI Summarizer API | Rask oversikt over lange dokumenter |
| Skjema-lesing | Windows AI OCR | Digitalisering av papirskjemaer |
| Intern Q&A | Foundry Local + Phi-3.5 | Svar basert pa lokale dokumenter |
| Referat-skriving | Edge Writing Assistance | Utkast til moetereferater |

### Sikkerhetshensyn

- Alle data forblir pa enheten — ingen nettverkskall for AI-inferens
- Phi-4 Mini-modellen er innebygd i Edge, ikke nedlastet fra sky per session
- Windows ML-modeller lagres lokalt og krever ingen sky-autentisering
- IT-administratorer kan kontrollere AI-API-tilgjengelighet via Group Policy

---

## Beslutningsrammeverk

| Scenario | Anbefaling | Begrunnelse |
|----------|------------|-------------|
| Enkel tekst-AI pa klient | Edge Prompt API (Phi-4 Mini) | Innebygd, ingen oppsett |
| Oppsummering/skriving | Edge Writing Assistance APIs | Spesialisert, hoey kvalitet |
| Custom ONNX-modell | Windows ML med automatisk EP | Best hardware-utnyttelse |
| Storre SLM lokalt | Foundry Local | OpenAI-kompatibelt API |
| Enterprise-utrulling | Windows ML + Intune-administrasjon | Sentralisert styring |
| NPU-optimalisert | Copilot+ PC med Windows ML | Best ytelse/watt |

---

## For Cosmo

- **Windows ML er den anbefalte veien for lokal AI pa Windows** — det erstatter DirectML og gir automatisk hardware-deteksjon og EP-nedlasting, noe som forenkler deployment dramatisk
- **Copilot+ PC-er med NPU muliggjor always-on AI** med lavt energiforbruk — anbefal dette for klientbaserte AI-oppgaver som dokumentklassifisering og oppsummering
- **Edge Prompt API (Phi-4 Mini) er den laveste terskelen for lokal AI** — utviklere kan bruke JavaScript-API-er for a integrere AI uten modellnedlasting eller kompleks oppsett
- **For norsk offentlig sektor: Lokal AI pa klientenheter eliminerer behovet for a sende sensitive data til sky** — dette forenkler DPIA og Schrems II-compliance for enklere AI-brukstilfeller
- **Modellkompilering er viktig for produksjonsytelse** — kompiler ONNX-modeller for target-hardware for a oppna opptil 2-3x forbedring i inferenshastighet etter forste kjoring
