Azure Quantum QIR målprofiler i QDK

Kvantberäkning är fortfarande en ny teknik. Alla kvantmaskinvara kan inte köra alla kvantprogram. Till exempel kan endast viss maskinvara utföra mätningar i mitten av kretsen, vilket krävs för att köra program med villkorsstyrda grenar baserat på qubitmätningsresultat.

När du skickar ett program som ska köras på Azure Quantumkonverteras programmet till mellanliggande kvantrepresentationsformat (QIR). QIR är inte beroende av programmeringsspråket eller typen av kvantmaskinvara som programmet körs på. Microsoft Quantum Development Kit (QDK) stöder flera QIR målprofiler för olika maskinvarufunktioner.

Mer information om QIRfinns i Mellanliggande kvantrepresentation.

Översikt över målprofiler

Azure Quantum och QDK stöder flera QIR målprofiler. Vilken typ av målprofil du väljer avgör vilken av följande programmeringskonstruktioner som programmet kan använda.

Villkorliga grenar med if satser baserade på resultat från qubitmätningar
Aritmetiska åtgärder på flyttalsnummer som beräknas från qubitmätningsresultat
Fasta och obundna loopar baserat på qubitmätningsresultat

I följande tabell visas alla QIR målprofiler i QDK och de programmeringskonstruktioner som målprofilerna stöder, i ordning från de flesta till minst restriktiva.

QIR målprofil	Villkorsstyrda grenar	Flyttalsåtgärder	Loops
Base	❌	❌	❌
Adaptive RI	✅	❌	❌
Adaptive RIF	✅	✅	❌
Adaptive	✅	✅	✅
Unrestricted	✅	✅	✅

Ange målprofiler i QDK

Om du vill köra ett program på QDK simulatorerna eller Azure Quantum målet måste du ange en QIR målprofil. Om du inte anger en målprofil QDK manuellt försöker du automatiskt ange lämplig profil för det valda målet.

när du skickar program för att köras via tjänsten Azure Quantum, försöker QDK automatiskt välja lämplig profil för det valda körningsmålet.

Base QIR profil

Den grundläggande QIR målprofilen är den mest restriktiva. Använd basprofilen för enklare program som inte använder klassiska programmeringsstrukturer som grenar och loopar. Om målmaskinvaran för kvantdatorn inte kan utföra mätningar mitt i kretsen behöver du förmodligen använda basprofilen.

Följande Azure Quantum mål kan köra program som använder basprofilen QIR .

Provider	Simulator	QPU
IonQ	`ionq.simulator`	`ionq.qpu.*`
Rigetti	`rigetti.sim.*`	`rigetti.qpu.*`

Mer information om dessa Azure Quantum leverantörer finns i IonQ-providern och Rigetti-providern.

Ställ in basprofilen

Om du vill ange basmålprofilen QIRQDK i tillägget för Visual Studio Code (VS Code) väljer du något av följande alternativ.

Om du konfigurerar ett Q#-projekt lägger du till följande kommando i projektets qsharp.json fil.
```
{
  "targetProfile": "base"
}
```
Om du arbetar i en .qs fil som inte ingår i ett Q#-projekt anger du målprofilen direkt i Q#-koden. Det gör du genom att lägga till @EntryPoint(Base) på raden före startpunktsåtgärden i programmet.
```
@EntryPoint(Base)
operation Main() : Unit {

...

}
```

Kör följande kod för att ange basmålprofilen QDK i Python-paketet.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Base)

Begränsningar för Q#-program med basprofil

Den grundläggande målprofilen kan köra ett brett urval av Q#-program. Den huvudsakliga begränsningen är att Q#-program inte kan utföra logiska jämförelser med Result typvärden från mätåtgärder.

Du kan till exempel inte köra följande FlipQubitOnZero åtgärd på ett basmål eftersom programmet innehåller en if instruktion som använder ett mätresultat.

    @EntryPoint(Base)
    operation FlipQubitOnZero() : Unit {
        use q = Qubit();
        if M(q) == Zero {
            X(q);
        }
    }

Adaptive RI QIR profil

Den anpassningsbara RI-målprofilen kan köra en större mängd olika program än basprofilen, men har fortfarande vissa begränsningar. Adaptive RI syftar till att stödja program som använder mid-circuit-mätningar i villkorsstyrda if-satser. Om kvantmaskinvaran kan utföra mätningar mitt i kretsen och programmet använder if-satser baserat på mätresultat, måste du förmodligen använda den adaptiva RI-profilen.

Följande Q#-program kan till exempel köras på ett anpassningsbart RI-mål.

@EntryPoint(Adaptive_RI)
operation MeasureQubit(q : Qubit) : Result { 
    return M(q); 
}

operation SetToZero(q : Qubit) : Unit {
     if MeasureQubit(q) == One { X(q); }
}

Följande Azure Quantum mål kan köra program som använder den adaptiva RI-målprofilen.

Provider	Simulator	QPU
Quantinuum	`quantinuum.sim.h2-1e`	`quantinuum.qpu.h2-1`
Quantinuum	`quantinuum.sim.h2-2e`	`quantinuum.qpu.h2-2`

Mer information om Quantinuum i Azure Quantum, se leverantören Quantinuum.

Ange den anpassningsbara RI-profilen

Om du vill ange den anpassningsbara RI-målprofilen QIRQDK i tillägget för VS Code väljer du något av följande alternativ.

Om du konfigurerar ett Q#-projekt lägger du till följande kommando i projektets qsharp.json fil:
```
{
  "targetProfile": "adaptive_ri"
}
```
Om du arbetar i en .qs fil som inte ingår i ett Q#-projekt anger du målprofilen direkt i Q#-koden. Det gör du genom att lägga till @EntryPoint(Adaptive_RI) på raden före startpunktsåtgärden i programmet.
```
@EntryPoint(Adaptive_RI)
operation Main() : Unit {

...

}
```

Kör följande kod för att ange den anpassningsbara RI-målprofilen QDK i Python-paketet.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)

Adaptive RIF QIR profil

Den anpassningsbara RIF-målprofilen har samma funktioner som den anpassningsbara RI-profilen, men har även stöd för program som innehåller flyttalsaritmetiska åtgärder. Om din kvantmaskinvara kan utföra mätningar mitt i kretsen, och ditt program använder if-satser och flyttal som beräknas från mätresultat, måste du förmodligen använda den adaptiva RIF-profilen.

Följande Q#-program kan till exempel köras på ett anpassningsbart RIF-mål.

@EntryPoint(Adaptive_RIF)
operation DynamicFloat() : Double {
    use q = Qubit();
    H(q);
    mutable f = 0.0;
    if M(q) == One {
        f = 0.5;
    }
    Reset(q);
    return f;
}

Azure Quantum har för närvarande inte anpassningsbara RIF-mål, men du kan köra program för anpassningsbara RIF-mål på de lokala QDK simulatorerna. Mer information om simulatorer i finns i QDKÖversikt över kvantsimulatorer i QDK.

Ange den anpassningsbara RIF-profilen

Om du vill ange den anpassningsbara RIF-målprofilen QIRQDK i tillägget för VS Code väljer du något av följande alternativ.

Om du konfigurerar ett Q#-projekt lägger du till följande kommando i projektets qsharp.json fil:
```
{
  "targetProfile": "adaptive_rif"
}
```
Om du arbetar i en .qs fil som inte ingår i ett Q#-projekt anger du målprofilen direkt i Q#-koden. Det gör du genom att lägga till @EntryPoint(Adaptive_RIF) på raden före startpunktsåtgärden i programmet.
```
@EntryPoint(Adaptive_RIF)
operation Main() : Unit {

...

}
```

Kör följande kod för att ange den anpassningsbara RIF-målprofilen QDK i Python-paketet.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RIF)

Adaptive QIR profil

Den anpassningsbara målprofilen har samma funktioner som den anpassningsbara RIF-profilen, men har även stöd för program som använder loopar baserat på mätresultat. Adaptive program kan använda slingor med ett fast antal iterationer, och upprepa-tills-framgång-slingor (RUS).

Azure Quantum har för närvarande inte anpassningsbara mål, men du kan köra program för anpassningsbara mål på de lokala QDK simulatorerna. Mer information om simulatorer i finns i QDKÖversikt över kvantsimulatorer i QDK.

Ange den anpassningsbara profilen

Om du vill ange den anpassningsbara QIR målprofilen QDK i tillägget för VS Code väljer du något av följande alternativ.

Om du konfigurerar ett Q#-projekt lägger du till följande kommando i projektets qsharp.json fil:
```
{
  "targetProfile": "adaptive"
}
```
Om du arbetar i en .qs fil som inte ingår i ett Q#-projekt anger du målprofilen direkt i Q#-koden. Det gör du genom att lägga till @EntryPoint(Adaptive) på raden före startpunktsåtgärden i programmet.
```
@EntryPoint(Adaptive)
operation Main() : Unit {

...

}
```

Om du vill ange den anpassningsbara målprofilen i Python-paketet QDK kör du följande kod.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive)

Unrestricted QIR profil

Den obegränsade målprofilen kan köra alla kvantprogram. Inget aktuellt kvantmål QIR stöder obegränsat läge, men du kan använda den obegränsade profilen för att köra komplexa program på simulatorerna QDK för kvantutveckling.

Ange den obegränsade profilen

Om du vill ange den obegränsade QIR målprofilen QDK i tillägget för VS Code väljer du något av följande alternativ.

Om du konfigurerar ett Q#-projekt lägger du till följande kommando i projektets qsharp.json fil:
```
{
  "targetProfile": "unrestricted"
}
```
Om du arbetar i en .qs fil som inte ingår i ett Q#-projekt anger du målprofilen direkt i Q#-koden. Det gör du genom att lägga till @EntryPoint(Unrestricted) på raden före startpunktsåtgärden i programmet.
```
@EntryPoint(Unrestricted)
operation Main() : Unit {

...

}
```

Kör följande kod för att ange den obegränsade målprofilen QDK i Python-paketet.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Unrestricted)

Feedback

Var den här sidan till hjälp?

Last updated on 2026-07-02