Azure Quantum QIR Perfis-alvo no QDK

A computação quântica ainda é uma tecnologia emergente. Nem todo o hardware quântico consegue executar todos os programas quânticos. Por exemplo, apenas certo hardware pode realizar medições de circuitos intermédios, o que é necessário para executar programas com ramificações condicionais baseadas nos resultados das medições de qubits.

Quando submetes um programa para correr em Azure Quantum, o teu programa é convertido para o formato de representação intermédia quântica (QIR). QIR Não depende da linguagem de programação ou do tipo de hardware quântico em que o teu programa corre. O MicrosoftQuantum Development Kit (QDK) suporta vários QIR perfis de alvo para diferentes capacidades de hardware.

Para mais informações sobre QIR, veja Representação intermédia quântica.

Visão geral dos perfis-alvo

Azure Quantum e o QDK suportam vários QIR perfis de destino. O tipo de perfil alvo que escolhe determina quais dos seguintes construtos de programação o seu programa pode utilizar.

Ramificações condicionais com if instruções baseadas em resultados de medição de qubits
Operações aritméticas em números de ponto flutuante calculadas a partir de resultados de medição de qubits
Laços fixos e ilimitados baseados em resultados de medição de qubits

A tabela seguinte lista todos os perfis alvo QIR na QDK e as construções de programação que os perfis alvo suportam, por ordem do mais restritivo para o menos restritivo.

QIR Perfil do alvo	Ramificações condicionais	Operações de ponto flutuante	Loops
Base	❌	❌	❌
Adaptive RI	✅	❌	❌
Adaptive RIF	✅	✅	❌
Adaptive	✅	✅	✅
Unrestricted	✅	✅	✅

Definir perfis-alvo no QDK

Para executar um programa nos simuladores QDK ou no alvo Azure Quantum, é necessário definir um perfil de destino QIR. Se não definires manualmente um perfil de alvo, tenta QDK definir automaticamente o perfil apropriado para o alvo escolhido.

Ao submeter programas para serem executados pelo Azure Quantum serviço, tenta QDK selecionar automaticamente o perfil apropriado para o alvo de execução escolhido.

Base QIR perfil

O perfil base QIR do alvo é o mais restritivo. Use o perfil base para programas mais simples que não usem estruturas clássicas de programação como ramos e loops. Se o teu alvo de hardware quântico não consegue realizar medições a meio do circuito, então provavelmente precisas de usar o perfil base.

Os seguintes Azure Quantum alvos podem executar programas que utilizam o perfil base QIR .

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

Para saber mais sobre estes Azure Quantum prestadores, consulte o fornecedor IonQ e o fornecedor Rigetti.

Definir o perfil base

Para definir o perfil de alvo base QIR na QDK extensão para Visual Studio Code (VS Code), escolha uma das seguintes opções.

Se configurares um projeto Q#, adiciona o seguinte comando ao ficheiro do qsharp.json teu projeto.
```
{
  "targetProfile": "base"
}
```
Se estiveres a trabalhar num .qs ficheiro que não faz parte de um projeto Q#, define o perfil alvo diretamente no teu código Q#. Para isso, adicione @EntryPoint(Base) na linha anterior à operação de ponto de entrada do seu programa.
```
@EntryPoint(Base)
operation Main() : Unit {

...

}
```

Para definir o perfil de destino base na QDK biblioteca Python, execute o seguinte código.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Base)

Limitações aos programas Q# com perfil básico

O perfil alvo base pode executar uma grande variedade de programas Q#. A principal restrição é que os programas Q# não conseguem realizar comparações lógicas com Result valores de tipo provenientes de operações de medição.

Por exemplo, não pode executar a seguinte FlipQubitOnZero operação num alvo base porque o programa contém uma if instrução que utiliza um resultado de medição.

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

Adaptive RI QIR perfil

O perfil alvo adaptativo do RI pode executar uma variedade maior de programas do que o perfil base, mas ainda apresenta algumas limitações. Adaptive RI Os alvos suportam programas que utilizam medições de meio circuito em instruções condicionais if . Se o teu hardware quântico consegue realizar medições de meio circuito e o teu programa usa if instruções baseadas em resultados de medição, então provavelmente precisas de usar o perfil adaptativo RI.

Por exemplo, o seguinte programa Q# pode ser executado num alvo adaptativo de RI.

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

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

Os seguintes Azure Quantum alvos podem executar programas que utilizam o perfil de alvo adaptativo RI.

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

Para mais informações sobre o Quantinuum em Azure Quantum, consulte Fornecedor Quantinuum.

Defina o perfil RI adaptativo

Para definir o perfil de destino adaptativo do RI QIR na QDK extensão do VS Code, escolha uma das seguintes opções.

Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto:
```
{
  "targetProfile": "adaptive_ri"
}
```
Se estiveres a trabalhar num .qs ficheiro que não faz parte de um projeto Q#, define o perfil alvo diretamente no teu código Q#. Para isso, adicione @EntryPoint(Adaptive_RI) na linha antes da operação de ponto de entrada no seu programa.
```
@EntryPoint(Adaptive_RI)
operation Main() : Unit {

...

}
```

Para definir o perfil de destino adaptativo do RI na QDK biblioteca Python, execute o seguinte código.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)

Adaptive RIF QIR perfil

O perfil alvo adaptativo RIF tem as mesmas capacidades que o perfil adaptativo RI, mas também suporta programas que contêm operações aritméticas de ponto flutuante. Se o seu hardware quântico consegue realizar medições a meio do circuito, e o seu programa usa instruções if e números em vírgula flutuante calculados a partir dos resultados das medições, então provavelmente precisa de usar o perfil RIF adaptativo.

Por exemplo, o seguinte programa Q# pode correr num alvo RIF adaptativo.

@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 não tem alvos RIF adaptativos neste momento, mas podes executar programas para alvos RIF adaptativos nos simuladores locais QDK . Para mais informações sobre simuladores no QDK, veja Visão Geral dos simuladores quânticos no QDK.

Definir o perfil RIF adaptativo

Para definir o perfil alvo RIF QIR adaptativo na QDK extensão para VS Code, escolha uma das seguintes opções.

Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto:
```
{
  "targetProfile": "adaptive_rif"
}
```
Se estiveres a trabalhar num .qs ficheiro que não faz parte de um projeto Q#, define o perfil alvo diretamente no teu código Q#. Para isso, adicione @EntryPoint(Adaptive_RIF) na linha antes da operação de ponto de entrada no seu programa.
```
@EntryPoint(Adaptive_RIF)
operation Main() : Unit {

...

}
```

Para definir o perfil de alvo RIF adaptativo na QDK biblioteca Python, execute o seguinte código.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RIF)

Adaptive QIR perfil

O perfil alvo adaptativo tem as mesmas capacidades do perfil RIF adaptativo, mas também suporta programas que utilizam ciclos baseados nos resultados das medições. Adaptive os programas podem usar ciclos com um número definido de iterações, e ciclos de repetição até ao sucesso (RUS).

Azure Quantum Não tem alvos adaptativos neste momento, mas podes executar programas para alvos adaptativos nos simuladores locais QDK . Para mais informações sobre simuladores no QDK, veja Visão Geral dos simuladores quânticos no QDK.

Definir o perfil adaptativo

Para definir o perfil de alvo adaptativo QIR na QDK extensão do VS Code, escolha uma das seguintes opções.

Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto:
```
{
  "targetProfile": "adaptive"
}
```
Se estiveres a trabalhar num .qs ficheiro que não faz parte de um projeto Q#, define o perfil alvo diretamente no teu código Q#. Para isso, adicione @EntryPoint(Adaptive) na linha anterior à operação de ponto de entrada no seu programa.
```
@EntryPoint(Adaptive)
operation Main() : Unit {

...

}
```

Para definir o perfil de alvo adaptativo na QDK biblioteca Python, execute o seguinte código.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive)

Unrestricted QIR perfil

O perfil alvo irrestrito pode executar todos os programas quânticos. Atualmente, nenhum destino quântico suporta QIR sem restrições, mas pode utilizar o perfil irrestrito para executar programas complexos nos simuladores QDK para o desenvolvimento quântico.

Definir o perfil sem restrições

Para definir o perfil alvo irrestrito QIR na QDK extensão do VS Code, escolha uma das seguintes opções.

Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto:
```
{
  "targetProfile": "unrestricted"
}
```
Se estiveres a trabalhar num .qs ficheiro que não faz parte de um projeto Q#, define o perfil alvo diretamente no teu código Q#. Para isso, adicione @EntryPoint(Unrestricted) na linha anterior à operação de ponto de entrada do seu programa.
```
@EntryPoint(Unrestricted)
operation Main() : Unit {

...

}
```

Para definir o perfil alvo irrestrito na QDK biblioteca Python, execute o seguinte código.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Unrestricted)

Comentários

Esta página foi útil?

Last updated on 2026-07-02