Exercício – Introdução ao Avaliador de Recursos do Azure Quantum

  • 8 minutos

Vamos praticar com o Avaliador de Recursos do Azure Quantum. No exemplo a seguir, você avalia os recursos físicos de uma amostra de algoritmo Shor.

Instale qsharp e qsharp-widgets

Primeiro, instale os pacotes qsharp e qsharp-widgets mais recentes do Azure Quantum.

python -m pip install --upgrade qsharp qsharp-widgets

Criar o algoritmo quântico

  1. No Visual Studio Code, selecione Exibir > Paleta de comandos e selecione Criar: Novo Jupyter Notebook.

  2. Na primeira célula do notebook, importe o pacote qsharp:

    import qsharp
from qsharp_widgets import EstimateDetails

  3. Adicione uma nova célula e copie o código a seguir:

    %%qsharp
/// # Sample
/// Random Bit
///
/// # Description
/// This Q# program generates a random bit by setting a qubit in a superposition
/// of the computational basis states |0〉 and |1〉, and returning the measurement
/// result.

    operation RandomBit() : Result {
        // Qubits are only accesible for the duration of the scope where they
        // are allocated and are automatically released at the end of the scope.
        use qubit = Qubit();

        // Set the qubit in superposition by applying a Hadamard transformation.
        H(qubit);

        // Measure the qubit. There is a 50% probability of measuring either 
        // `Zero` or `One`.
        let result = M(qubit);

        // Reset the qubit so it can be safely released.
        Reset(qubit);
        return result;
    }

Estimar o algoritmo quântico

  1. Agora, avalie os recursos físicos da operação RandomBit usando as suposições padrão. Adicione uma nova célula e copie o código a seguir:

    result = qsharp.estimate("RandomBit()")
result

    A função qsharp.estimate cria um objeto de resultado, que pode ser usado para exibir uma tabela com as contagens gerais de recursos físicos. A primeira tabela mostra as principais estimativas do recurso físico. A operação RandomBit requer 300 qubits e leva dois microssegundos para ser executada em um computador quântico.

    Estimativas de recursos físicos Valor
    Runtime 2 microssegundos
    rQOPS 3.00M
    Qubits físicos 300

  2. Você pode inspecionar os detalhes de custos recolhendo os grupos que têm mais informações. Por exemplo, reduza o grupo Parâmetros de qubit lógico para ver que a distância do código é 5 e o número de qubits físicos por qubit lógico é 50.

    Parâmetro de qubit lógico Valor
    Esquema de QEC surface_code
    Distância de código 5
    Qubits físicos 50
    Tempo de ciclo lógico 2 microssegundos
    Taxa de erro de qubit lógico 3.00E-5
    Cruzamento de pré-fatores 0.03
    Limite de correção de erro 0,01
    Fórmula do tempo de ciclo lógico (4 x twoQubitGateTime + 2 x oneQubitMeasurementTime) x codeDistance
    Fórmula de qubits físicos 2 x codeDistance * codeDistance

  3. Você pode usar o campo jobParams para acessar todos os parâmetros de destino que podem ser passados para a execução do trabalho e ver quais valores padrão foram assumidos:

    result['jobParams']

    {'errorBudget': 0.001,
 'qecScheme': {'crossingPrefactor': 0.03,
  'errorCorrectionThreshold': 0.01,
  'logicalCycleTime': '(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance',
  'name': 'surface_code',
  'physicalQubitsPerLogicalQubit': '2 * codeDistance * codeDistance'},
 'qubitParams': {'instructionSet': 'GateBased',
  'name': 'qubit_gate_ns_e3',
  'oneQubitGateErrorRate': 0.001,
  'oneQubitGateTime': '50 ns',
  'oneQubitMeasurementErrorRate': 0.001,
  'oneQubitMeasurementTime': '100 ns',
  'tGateErrorRate': 0.001,
  'tGateTime': '50 ns',
  'twoQubitGateErrorRate': 0.001,
  'twoQubitGateTime': '50 ns'}}

    Você pode ver que o Avaliador de Recursos assume o modelo de qubit qubit_gate_ns_e3, o código de correção de erro surface_code e o orçamento de erro de 0,001 como valores padrão para a estimativa.

Alterar os valores padrão e estimar o algoritmo

Ao enviar uma solicitação de estimativa de recursos para o seu programa, você pode especificar alguns parâmetros opcionais. Estes são os parâmetros de destino que você pode personalizar:

  • errorBudget: O orçamento geral de erros permitidos para o algoritmo
  • qecScheme: O esquema de correção de erro quântico (QEC)
  • qubitParams: Os parâmetros físicos do qubit
  • constraints: As restrições no nível do componente
  • distillationUnitSpecifications: As especificações dos algoritmos de destilação de fábricas T
  • estimateType: Único ou de fronteira

Alterar o modelo de qubit

Você pode estimar o custo do mesmo algoritmo usando o parâmetro de qubit baseado em Majorana, qubitParams, qubit_maj_ns_e6.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                }})
EstimateDetails(result_maj)

Alterar o esquema de correção de erros quânticos

Você pode executar novamente o trabalho de estimativa de recursos para o mesmo exemplo nos parâmetros de qubit com base em Majorana com um esquema QEC flutuante, qecScheme.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                }})
EstimateDetails(result_maj)

Alterar o orçamento de erros

Em seguida, execute novamente o mesmo circuito quântico com um errorBudget de 10%.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                },
                "errorBudget": 0.1})
EstimateDetails(result_maj)