Rotinas de compilação

qiskit.compiler.transpile(circuits, backend=None, basis_gates=None, coupling_map=None, initial_layout=None, layout_method=None, routing_method=None, translation_method=None, scheduling_method=None, dt=None, approximation_degree=1.0, seed_transpiler=None, optimization_level=None, callback=None, output_name=None, unitary_synthesis_method='default', unitary_synthesis_plugin_config=None, target=None, hls_config=None, init_method=None, optimization_method=None, ignore_backend_supplied_default_methods=False, num_processes=None, qubits_initially_zero=True)

Transpilar um ou mais circuitos, de acordo com algumas metas de transpilação desejadas.

A transpilação pode ser feita em paralelo usando multiprocessamento quando circuits é uma lista com > 1 QuantumCircuit dependendo do ambiente local e da configuração.

A priorização das restrições de destino de transpilação funciona da seguinte forma: se uma entrada target for fornecida, ela terá prioridade sobre qualquer entrada backend ou restrições soltas (basis_gates, coupling_map ou dt). Se o site backend for fornecido junto com qualquer restrição não obrigatória da lista acima, a restrição não obrigatória terá prioridade sobre a restrição de backend correspondente. Esse comportamento está resumido na tabela abaixo. A primeira coluna da tabela resume as possíveis restrições fornecidas pelo usuário, e cada célula mostra se a prioridade é atribuída a essa entrada de restrição específica ou a outra entrada (destino/backend( V2 )).

Parâmetros

• circuits (_CircuitT) – Circuito(s) a ser(em) transpilado(s)

• backend (Backend | None) – Se definido, o transpilador compilará o circuito de entrada para esse dispositivo de destino. Se qualquer outra opção for explicitamente definida (por exemplo, coupling_map), ela substituirá a do backend.

• basis_gates (list[str] | None) – Lista de nomes de portas de base para as quais se deve realizar o desenrolamento (por exemp g.:['u1', 'u2', 'u3', 'cx']). Se None, não realizar o desenrolamento.

• coupling_map (CouplingMap |list[list[int]] | None) –

  Mapa de acoplamento direcionado (talvez personalizado) para o alvo no mapeamento. Se o mapa de acoplamento for simétrico, ambas as direções precisarão ser especificadas.

  Vários formatos são suportados:

  1. CouplingMap instância
  2. A lista deve ser fornecida como uma matriz de adjacência, em que cada entrada especifica todas as interações direcionadas de dois qubits suportadas pelo backend, por exemp g.: [[0, 1], [0, 3], [1, 2], [1, 5], [2, 5], [4, 1], [5, 3]]

• initial_layout (Layout |dict |list | None) –

  Posição inicial dos qubits virtuais nos qubits físicos. Se esse layout tornar o circuito compatível com as restrições de coupling_map, ele será usado. Não é garantido que o layout final seja o mesmo, pois o transpilador pode permutar os qubits por meio de trocas ou outros meios. Vários formatos são suportados:

  1. Layout instância

  2. Dict * virtual para físico:

     {qr[0]: 0,
      qr[1]: 3,
      qr[2]: 5}

     • físico para virtual:

       {0: qr[0],
        3: qr[1],
        5: qr[2]}

  3. Lista

     • virtual para físico:

       [0, 3, 5]  # virtual qubits are ordered (in addition to named)

     • físico para virtual:

       [qr[0], None, None, qr[1], None, qr[2]]

• layout_method (str | None) – Nome da passagem de seleção de layout ('trivial', 'dense', 'sabre'). Esse também pode ser o nome do plug-in externo a ser usado no estágio layout . Você pode ver uma lista dos plug-ins instalados usando list_stage_plugins() com "layout" para o argumento stage_name .

• routing_method (str | None) – Nome do algoritmo de roteamento (‘básico’, ‘lookahead’, ‘estocástico’, ‘sabre’, ‘nenhum’). Esse também pode ser o nome do plug-in externo a ser usado para o routing estágio. Você pode ver uma lista dos plugins instalados usando list_stage_plugins() com "routing" como argumento stage_name .

• translation_method (str | None) – Nome do passe de tradução ("default", "translator" ou "synthesis"). Esse também pode ser o nome do plug-in externo a ser usado no estágio translation . Você pode ver uma lista dos plug-ins instalados usando list_stage_plugins() com "translation" para o argumento stage_name .

• scheduling_method (str | None) – Nome do passe de agendamento. * 'as_soon_as_possible': Programar instruções com avidez, o mais cedo possível em um recurso de qubit. (alias: 'asap') * 'as_late_as_possible': Programar as instruções com atraso, ou seja, manter os qubits no estado fundamental quando possível. (alias: 'alap') Se None, nenhum agendamento será feito. Esse também pode ser o nome do plug-in externo a ser usado no estágio scheduling . Você pode ver uma lista dos plug-ins instalados usando list_stage_plugins() com "scheduling" para o argumento stage_name .

• dt (float | None) – Tempo de amostragem (resolução) do backend em segundos. Se for None (padrão), será usado backend.dt .

• approximation_degree (float) – dial heurístico utilizado para aproximação de circuitos (aproximação de 1.0=no, aproximação de 0.0=maximal )

• seed_transpiler (int | None) – Define a semente aleatória para as partes estocásticas do transpilador

• optimization_level (int | None) –

  O grau de otimização a ser realizado nos circuitos. Níveis mais altos geram circuitos mais otimizados, à custa de um tempo de transpilação mais longo.

  • 0: sem otimização
  • 1: otimização da luz
  • 2: otimização pesada
  • 3: otimização ainda mais pesada

  Se None, o nível 2 será escolhido como padrão.

• callback (Callable[[BasePass, DAGCircuit, float, PropertySet, int], Any] | None) –

  Uma função de retorno de chamada que será chamada após a execução de cada passe. A função será chamada com 5 argumentos de palavra-chave, | pass_: a passagem que está sendo executada. | dag: a saída de dados da passagem. | time: o tempo para executar a passagem. | property_set: o conjunto de propriedades. | count: o índice para a execução da passagem. Os argumentos exatos passados expõem os componentes internos do gerenciador de passes e estão sujeitos a alterações à medida que os componentes internos do gerenciador de passes mudam. Se você pretende reutilizar uma função de retorno de chamada em várias versões, certifique-se de verificar se os argumentos passados são os mesmos. Para usar o recurso de retorno de chamada, defina uma função que receberá o dict de kwargs e acessará as variáveis. Por exemplo:

  def callback_func(**kwargs):
      pass_ = kwargs['pass_']
      dag = kwargs['dag']
      time = kwargs['time']
      property_set = kwargs['property_set']
      count = kwargs['count']
      ...
  transpile(circ, callback=callback_func)

• output_name (str |list[str] | None) – Uma lista com strings para identificar os circuitos de saída. O comprimento da lista deve ser exatamente igual ao comprimento do circuits parâmetro.

• unitary_synthesis_method (str) – O nome do método de síntese unitária a ser usado. Por padrão, 'default' é usado. Você pode ver uma lista dos plug-ins instalados com unitary_synthesis_plugin_names().

• unitary_synthesis_plugin_config (dict | None) – Um dicionário de configuração opcional que será passado diretamente para o plug-in de síntese unitária. Por padrão, essa configuração não terá efeito, pois o método de síntese unitária padrão não requer configuração personalizada. Isso só deve ser necessário quando um plug-in de síntese unitária for especificado com o argumento unitary_synthesis_method . Como isso é personalizado para cada plug-in de síntese unitária, consulte a documentação do plug-in para saber como usar essa opção.

• target (Target | None) – Um alvo de transpilador de backend. Normalmente, isso é especificado como parte do argumento backend , mas se você tiver construído manualmente um objeto Target poderá especificá-lo manualmente aqui. Isso substituirá o alvo de backend.

• hls_config (HLSConfig | None) – Uma classe de configuração HLSConfig opcional que será passada diretamente para a etapa HighLevelSynthesis de transformação. Esta classe de configuração permite especificar as listas de algoritmos de síntese e seus parâmetros para vários objetos de alto nível.

• init_method (str | None) – O nome do plug-in a ser usado no estágio init . Por padrão, um plug-in externo não é usado. Você pode ver uma lista dos plug-ins instalados usando list_stage_plugins() com "init" como argumento do nome do estágio.

• optimization_method (str | None) – O nome do plug-in a ser usado no estágio optimization . Por padrão, um plug-in externo não é usado. Você pode ver uma lista dos plug-ins instalados usando list_stage_plugins() com "optimization" para o argumento stage_name .

• ignore_backend_supplied_default_methods (bool) – Se definido como True , todos os métodos padrão especificados por um backend serão ignorados. Alguns backends especificam métodos padrão alternativos para dar suporte a passes/plugins específicos do alvo de compilação personalizados que dão suporte a técnicas de compilação específicas do backend. Se você preferir que esses padrões não sejam usados, essa opção é usada para desativar esses padrões específicos do backend.

• num_processes (int | None) – O número máximo de processos paralelos a serem iniciados para essa chamada ao transpile, se a execução paralela estiver ativada. Esse argumento substitui num_processes no arquivo de configuração do usuário e a variável de ambiente QISKIT_NUM_PROCS . Se definido como None , será usada a configuração padrão do sistema ou a configuração do usuário local.

• qubits_initially_zero (bool) – Indica se o circuito de entrada está inicializado com zero.

Retorna

O(s) circuito(s) transpilado(s).

Aumentos

TranspilerError - no caso de entradas incorretas para o transpilador (como parâmetros conflitantes) ou erros nas passagens

Tipo de retorno

_CircuitT