IonQ-leverantör

IonQ:s kvantdatorer utför beräkningar genom att manipulera hyperfina energitillstånd i Ytterbium-joner med lasrar. Atomer är naturens kvantbitar – varje qubit är identisk inom och mellan program. Logiska åtgärder kan också utföras på godtyckliga par kvantbitar, vilket möjliggör komplexa kvantprogram som inte hindras av fysisk anslutning. Vill du lära dig mer? Läs IonQ:s översikt över den fångade kvantdatortekniken för joner.

• Utgivare: IonQ
• Provider-ID: ionq

Följande targets är tillgängliga från den här providern:

IonQ motsvarar targets en QIR Base profil. Mer information om den här target profilen och dess begränsningar finns i Förstå target profiltyper i Azure Quantum.

Kvantsimulator

GPU-accelererad idealiserad simulator med stöd för upp till 29 kvantbitar, med samma uppsättning portar som IonQ tillhandahåller på kvantmaskinvaran – en bra plats att förbelysa jobb innan du kör dem på en verklig kvantdator.

• Jobbtyp: Simulation
• Dataformat: ionq.circuit.v1
• Target ID: ionq.simulator
• Target Körningsprofil: QIR Base

IonQ Aria-kvantdator

IonQ Aria är flaggskeppet i IonQ:s kvantdatorer med fångade joner, med ett 25-qubit dynamiskt omkonfigurerbart system. Mer information finns i IonQ Aria (ionq.com).

• Jobbtyp: Quantum Program
• Dataformat: ionq.circuit.v1
• Target ID: ionq.qpu.aria-1, ionq.qpu.aria-2
• Target Körningsprofil: QIR Base

Systemtidsinställning

Systemåtergivning

* Förberedelse och mätning av tillstånd (SPAM): Den här mätningen avgör hur exakt en kvantdator kan ange en kvantbit i sitt ursprungliga tillstånd och sedan mäta resultatet i slutet.

IonQ Aria är tillgängligt via Azure Quantum Credits-plan och en separat faktureringsplan. Mer information finns i Priser för Azure Quantum.

IonQ Forte-kvantdator

IonQ Forte är IonQ:s mest högpresterande, kommersiellt tillgängliga kvantdator med fångade joner. Med ett 32-qubit programvarukonfigurerbart system är IonQ Forte tillgängligt i Privat förhandsversion på Azure Quantum. Mer information finns i IonQ Forte (ionq.com).

• Jobbtyp: Quantum Program
• Dataformat: ionq.circuit.v1
• Target ID: ionq.qpu.forte
• Target Körningsprofil: QIR Base

Indataformat

I Q#är utdata från en kvantmätning ett värde av typen Result, som bara kan ta värdena Zero och One. När du definierar en Q#-åtgärd kan den bara skickas till IonQ-maskinvaran om returtypen är en samling Resultav s, dvs. om utdata från åtgärden är resultatet av en kvantmätning. Anledningen till detta är att IonQ skapar ett histogram från de returnerade värdena, så det begränsar returtypen till för att Result förenkla skapandet av histogrammet.

IonQ motsvarar targets QIR Base profile. Den här profilen kan inte köra kvantåtgärder som kräver användning av resultaten från kvantbitsmätningar för att styra programflödet.

Utdataformat

När du skickar ett kvantprogram till IonQ-simulatorn returneras histogrammet som skapats av måtten. IonQ-simulatorn samplar inte sannolikhetsfördelningen som skapats av ett kvantprogram, utan returnerar i stället fördelningen som skalas till antalet skott. Detta är mest uppenbart när du skickar en enda skott krets. Du ser flera mätresultat i histogrammet för ett skott. Det här beteendet är en naturlig del av IonQ-simulatorn, medan IonQ QPU faktiskt kör programmet och aggregerar resultatet.

Ytterligare funktioner

Ytterligare funktioner som stöds av IonQ-maskinvara visas här.

Användare kan dra nytta av dessa ytterligare funktioner via direktparametrar i Azure Quantum Q# och Qiskit-leverantörerna.

Felreducering

IonQ ger möjlighet att aktivera kvantfelreducering när jobb skickas till IonQ-maskinvara. Felreducering är en process på kompilatornivå som kör och kör flera symmetriska varianter av en krets och sedan aggregerar resultatet samtidigt som effekten av maskinvarufel och kvantbitsdekoherence minimeras. Till skillnad från kvantfelkorrigeringstekniker kräver felreducering inte stora kostnader för grind och kvantbit.

Debiasing är processen att skapa små variationer av en viss krets som bör vara identisk på en idealisk brusfri dator, med hjälp av tekniker som olika kvantbitstilldelningar, gate nedbrytningar och pulslösningar och sedan köra dessa variationer.

Vässning och genomsnitt är alternativ för att aggregera resultatet av variationerna. Medelvärdet baseras på alla variantresultat, medan Sharpening filtrerar bort felaktiga resultat och kan vara mer tillförlitligt för vissa typer av algoritmer.

Mer information finns i Debiasing och Sharpening. Priser för felreducering finns i Priser för IonQ.

Aktivera felreducering

I Azure Quantum kan felreducering aktiveras eller inaktiveras för jobb som skickas med Q# eller med Qiskit.

Om du vill aktivera felreducering lägger du till en valfri parameter för target datorn:

option_params = {
    "error-mitigation": {
        "debias": True
    }
}

Om du vill inaktivera felreducering anger du parametern till False:

option_params = {
    "error-mitigation": {
        "debias": False
    }
}

option_params = {
    "error-mitigation": {
        "debias": False
    },
    "noise": {
    "model": "aria-1",
    "seed": 100
    }
}

Köra ett jobb på Azure Quantum med felreducering

I det här exemplet används en enkel slumptalsgenerator.

Importera först de nödvändiga paketen och starta basprofilen:

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

Definiera sedan funktionen.

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

and compile the operation:

```python
MyProgram = qsharp.compile("GenerateRandomBit()")

Anslut till Azure Quantum, välj target datorn och konfigurera brusparametrarna för emulatorn:

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("ionq.qpu.aria-1")

Ange konfigurationen error-mitigation

option_params = {
    "error-mitigation": {
        "debias": True
    }
}

Skicka in konfigurationen för felreducering när du skickar jobbet:

job = MyTarget.submit(MyProgram, "Experiment with error mitigation", shots = 10, input_params = option_params)
job.get_results()

I Qiskit skickar du de valfria parametrarna till target datorkonfigurationen innan du skickar jobbet:

circuit.name = "Single qubit random - Debias: True"
backend.options.update_options(**option_params)
job = backend.run(circuit, shots=500)

Stöd och användning av interna grindar

Med IonQ kan du som standard ange en kvantkrets med hjälp av en abstrakt uppsättning kvantgrindar, kallad qis, som möjliggör flexibilitet och portabilitet när du skriver en algoritm utan att behöva bekymra dig om optimering för maskinvaran.

Men i vissa avancerade användningsfall kanske du vill definiera en krets direkt på interna portar för att komma närmare maskinvaran och kringgå optimeringen. Den inbyggda gateuppsättningen är uppsättningen kvantgrindar som körs fysiskt i kvantprocessorn, och de mappar kretsen till dem som en del av körningen.

Mer information finns i Komma igång med inbyggda portar (ionq.com).

För att kunna använda den inbyggda grinduppsättningen när du skickar Qiskit-jobb till Azure Quantum anger du parametern gateset när du initierar serverdelen som i exemplet nedan:

# Here 'provider' is an instance of AzureQuantumProvider
backend = provider.get_backend("ionq.qpu.aria-1", gateset="native")

Mer information om Qiskit-jobb finns i Skicka en krets med Qiskit.

Simulering av brusmodell

Även det bästa av dagens kvantmaskinvara har inbyggd brus, och att känna till systemets brusegenskaper target kan hjälpa dig att förfina dina algoritmer och få en mer realistisk förutsägelse av resultat när du kör kretsen på maskinvara. IonQ tillhandahåller en ljudmodellsimulering som introducerar brus i kretsen med hjälp av ett "brus fingeravtryck" som är specifikt för maskinvaran target . Mer information finns i Kom igång med simulering av maskinvarubrusmodell.

Parametrar för brusmodell

Skottmedvetenhet

Simulering av brusmodell är skottmedveten, det vill säga att den tar exempel på mätningar från utdatatillståndet baserat på antalet skott som tillhandahålls. I Azure Quantum skickas parametern shots med jobbet och krävs för aria-1 brusmodeller. Om inget shot värde anges används ett standardvärde 1000 för. ideal Om brusmodellen används ignoreras parameternshots.

Qubit-kapacitet

ideal Med brusmodellen kan du simulera upp till 29 kvantbitar med kvantsimulatorn IonQ, men maskinvaruspecifika brusmodeller är begränsade till maskinvarans faktiska kvantbitskapacitettarget, vilket är 25 kvantbitar för aria-1 brusmodellen.

Aktivera simulering av brusmodell

I Azure Quantum kan simulering av brusmodell aktiveras eller inaktiveras för jobb som skickas med Q# eller med Qiskit.

Om du vill aktivera simulering av brusmodell lägger du till en valfri parameter för target datorn, till exempel:

option_params = {
    "noise": {
        "model": "aria-1",   # targets the Aria quantum computer
        "seed" : 1000         # If seed isn't specified, a random value is used  
    }
}

option_params = {
    "error-mitigation": {
        "debias": False
    },
    "noise": {
    "model": "aria-1",
    "seed": 1000
    }
}

Köra ett jobb med simulering av brusmodell

Du kan använda samma exempelprogram som visades tidigare i felreducering och lägga till eller ersätta konfigurationen av brusmodellen i option_params.

option_params = {
    "error-mitigation": {
        "debias": True
    },
    "noise": {
    "model": "aria",
    "seed": 1000
    }
}

Skicka sedan de valfria parametrarna när du skickar jobbet:

job = MyTarget.submit(MyProgram, "Experiment with noise model simulation", shots = 10, input_params = option_params)
job.get_results()

I Qiskit skickar du de valfria parametrarna till target datorkonfigurationen innan du skickar jobbet:

circuit.name = "Single qubit random - Debias: True"
backend.options.update_options(**option_params)
job = backend.run(circuit, shots=500)

Prissättning

Om du vill se faktureringsplanen för IonQ går du till Priser för Azure Quantum.

Begränsningar och kvoter

IonQ-kvoter spåras baserat på QPU-användningsenheten, som är qubit-gate-shot (QGS). Resursanvändningen krediteras mot ditt konto.

Varje kvantprogram består av $N$ logiska kvantgrindar för en eller flera kvantbitar och körs för ett visst antal skott. Antalet gate-shots beräknas med följande formel:

$$ QGS = N · C $$

där:

• $N$ är antalet en- eller två qubit-portar som skickas
• $C$ är antalet begärda körningsskott

Kvoter baseras på val av plan och kan ökas med en supportbegäran. Om du vill se dina aktuella gränser och kvoter går du till bladet Krediter och kvoter och väljer fliken Kvoter på arbetsytan på Azure Portal. Mer information finns i Azure Quantum-kvoter.

IonQ-status

Information om fördröjningar i IonQ QPU-jobbbearbetning finns på sidan IonQ-status.

Metodtips och anslutningsdiagram för IonQ

Mer information om rekommenderade metodtips för IonQ QPU finns i IonQ Best Practices (ionq.com).