Gerenciador de senhas

qiskit.passmanager

Visão geral

O gerenciador de passagens do Qiskit é inspirado no compilador LLVM. A infraestrutura do compilador divide as responsabilidades em três componentes principais: tarefas, controladores de fluxo e gerenciadores de passagens.

Um pipeline de compilação executa uma sequência de objetos Task , cada um dos quais recebe uma representação intermediária (IR) como entrada, realiza um processamento e retorna uma IR — possivelmente diferente — como saída. Onde define Task a interface, uma tarefa atômica é uma passagem, que é uma subclasse de GenericPass e implementa seu run() método abstrato. Esta é a classe que deve ser usada como classe base ao implementar uma etapa personalizada do compilador.

Os controladores de fluxo fornecem modelos de execução para um conjunto de tarefas. O controlador de fluxo mais simples é um FlowControllerLinear, que simplesmente executa um conjunto de tarefas em uma sequência linear. Controladores de fluxo mais avançados incluem loops ou execução condicional. Elas são utilizadas, por exemplo, nos pipelines de transpiladores predefinidos do Qiskit para níveis mais elevados de otimização, nos quais as otimizações são executadas até que um critério de convergência seja atingido.

Os gerenciadores de passagem são responsáveis por gerenciar as tarefas, incluindo o agendamento das análises necessárias e a permissão para que o usuário altere a sequência das tarefas. O Qiskit oferece dois gerenciadores de passagens genéricos para IR neste módulo, além de um gerenciador de passagens especializado para servir DAGCircuit como IR em qiskit.transpiler. Os genéricos de IR são:

• BasePassManager: um gerenciador de passes com IR fixo. Este gerenciador de passagens permite modificar o conjunto de tarefas a serem executadas e oferece suporte à execução paralela de várias entradas por meio de parallel_map(). Essa classe oferece suporte à conversão adicional da representação de um programa de entrada para o IR interno, bem como à conversão para um formato de programa de saída.

  A é BasePassManager a classe base para os gerenciadores de passagens predefinidos do Qiskit para DAGCircuit transpilagem, como os retornados por generate_preset_pass_manager(). Nesse caso, são utilizadas conversões implícitas de e para o formato de QuantumCircuit entrada e saída do programa.

• MultiStagePassManager: um gerenciador de passagens em etapas, no qual cada etapa pode preservar ou reduzir o IR. Uma etapa é definida por um ou Task um iterável dele, que também pode ser agrupado dentro de um BasePassManager. Os estágios devem ser configurados de forma que a resistência de saída (IR) do estágio atual corresponda à resistência de entrada (IR) do próximo estágio; não há (atualmente) nenhuma conversão automática.

Os gerenciadores de pass também fornecem uma infraestrutura para passar um PropertySet com informações de contexto por todas as tarefas e uma função de retorno de chamada para introspecção. O é PropertySet um dicionário de formato livre, que pode ser preenchido e lido por uma passagem durante a execução, ou lido por um controlador de fluxo para controlar a execução da passagem. O conjunto de propriedades é portátil e é transferido de uma passagem para outra durante a execução. Além do conjunto de propriedades, as tarefas também recebem uma estrutura de dados WorkflowStatus . Este objeto é inicializado quando o gerenciador de passagens é executado e é repassado às tarefas subjacentes. O status é atualizado após a execução de cada passagem e contém informações sobre o estado do pipeline (número de passagens executadas, estado de falha e assim por diante), ao contrário do PropertySet, que contém informações sobre o IR que está sendo otimizado.

A função de retorno é chamada por instâncias GenericPass que esperam a seguinte assinatura:

def callback(
    *,
    task: Task[IR_IN, IR_OUT],
    passmanager_ir: IR_OUT,
    property_set: PropertySet,
    running_time: float,
    count: int
) -> None:
    ...

Observe que essa assinatura difere ligeiramente para passes e gerenciadores de passes definidos no módulo qiskit.transpiler .

Exemplos

Analisamos uma tarefa de otimização simples, que consiste em preparar uma sequência de números e remover um dígito sempre que o número for cinco. Essa tarefa pode ser facilmente realizada convertendo os números de entrada em cadeias de caracteres. Aqui, utilizamos a estrutura do gerenciador de passos, deixando a eficiência de lado por um momento para aprender a criar um compilador Qiskit personalizado.

from qiskit.passmanager import BasePassManager, GenericPass, ConditionalController

class ToyPassManager(BasePassManager):

    def _passmanager_frontend(self, input_program: int, **kwargs) -> str:
        return str(input_program)

    def _passmanager_backend(self, passmanager_ir: str, in_program: int, **kwargs) -> int:
        return int(passmanager_ir)

Esse gerenciador de passagens entra e sai de um número inteiro, enquanto executa as tarefas de otimização em uma string de dados. Portanto, os tipos de entrada, IR e saída são inteiro, string e inteiro, respectivamente. O método _passmanager_frontend() define a conversão dos dados de entrada para IR, e _passmanager_backend() define a conversão do IR para os dados de saída. O backend do gerenciador de passes também recebe um parâmetro in_program que contém o input_program original para o front end, para fazer referência a qualquer metadado original do programa de entrada para a conversão final.

Em seguida, implementamos uma passagem que remove um dígito quando o número é cinco.

class RemoveFive(GenericPass):

    def run(self, passmanager_ir: str):
        return passmanager_ir.replace("5", "")

task = RemoveFive()

Por fim, instanciamos um gerenciador de passagens e agendamos a tarefa com ele. Ao executar o gerenciador de senhas com uma sequência aleatória de números, são gerados novos números que não contêm o número cinco.

pm = ToyPassManager()
pm.append(task)

pm.run([123456789, 45654, 36785554])

Saída:

[12346789, 464, 36784]

Agora consideramos o caso da execução condicional. Evitamos a execução da tarefa "remover cinco" quando o número de entrada tem seis dígitos ou menos. Esse controle pode ser implementado por um controlador de fluxo. Começamos com uma passagem de análise que fornece ao controlador de fluxo informações sobre o número de dígitos.

class CountDigits(GenericPass):

    def run(self, passmanager_ir: str):
        self.property_set["ndigits"] = len(passmanager_ir)

analysis_task = CountDigits()

Em seguida, envolvemos a tarefa “remover cinco” com o ConditionalController que executa as tarefas armazenadas somente quando a condição for atendida.

def digit_condition(property_set):
    # Return True when condition is met.
    return property_set["ndigits"] > 6

conditional_task = ConditionalController(
    tasks=[RemoveFive()],
    condition=digit_condition,
)

Como antes, agendamos esses passes com o gerenciador de passes e os executamos.

pm = ToyPassManager()
pm.append(analysis_task)
pm.append(conditional_task)

pm.run([123456789, 45654, 36785554])

Saída:

[12346789, 45654, 36784]

A tarefa "remover cinco" é acionada somente para o primeiro e o terceiro valores de entrada, que têm mais de seis dígitos.

Com a estrutura do gerenciador de passagens, um desenvolvedor pode personalizar com flexibilidade a tarefa de otimização, combinando várias passagens e controladores de fluxo. Consulte os detalhes na documentação da API da classe a seguir.

Interface

Aprovações

Gerentes de passes

Controladores de fluxo

Estado da compilação

Exceções

PassManagerError