Gerenciador de senhas

qiskit.passmanager

Visão geral

O gerenciador de passagens Qiskit é inspirado no compilador LLVM, mas foi projetado para receber um objeto Python como entrada em vez de código-fonte simples.

O gerenciador de passes converte o objeto Python de entrada em uma representação intermediária (IR), que pode ser otimizada e reduzida com uma variedade de transformações em vários passes. A estrutura do gerenciador de passes pode empregar vários IRs com passes de conversão intercalados, dependendo do contexto da otimização.

Os passes podem consumir as restrições de hardware que o backend do Qiskit pode fornecer. Por fim, o IR é convertido novamente em um objeto Python. Observe que o tipo de entrada e o tipo de saída não são necessariamente os mesmos.

A compilação no gerenciador de passes é uma cadeia de execuções do Task que recebe um IR e gera um novo IR com alguma otimização ou análise de dados. Uma tarefa atômica é uma passagem que é uma subclasse de GenericPass que implementa um método run() que executa algum trabalho no IR recebido. Um conjunto de passagens pode formar um controlador de fluxo, que é uma subclasse de BaseControllerque pode implementar uma lógica arbitrária dependente do estado de compilação para decidir qual passe será executado em seguida. Passa dados intermediários de compartilhamento por meio do objeto PropertySet que é um dicionário de forma livre. Um passe pode preencher o dicionário de conjunto de propriedades durante a execução da tarefa. Um controlador de fluxo também pode consumir o conjunto de propriedades para controlar a execução do passe, mas esse acesso deve ser somente de leitura. 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 WorkflowStatus estrutura de dados. Esse objeto é inicializado quando o gerenciador de passes é executado e entregue às tarefas subjacentes. O status é atualizado depois que cada passagem é executada 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 status PropertySetque contém informações sobre o IR que está sendo otimizado.

Um gerenciador de passes é um invólucro do controlador de fluxo, com responsabilidades de

• Agendamento de tarefas de otimização,
• Conversão de um objeto de entrada Python em um Qiskit IR específico,
• Inicialização de um conjunto de propriedades e status de fluxo de trabalho,
• Execução de tarefas agendadas para aplicar uma série de transformações ao IR,
• Converter o IR novamente em um objeto de saída Python.

Isso indica que o controlador de fluxo em si é independente de tipo, e o desenvolvedor deve implementar uma subclasse do controlador de fluxo BasePassManager para gerenciar as etapas de conversão de dados. Esse véu de ignorância nos permite escolher a representação de dados mais eficiente para uma tarefa específica do gerenciador de passagens, enquanto podemos reutilizar o mecanismo de controle de fluxo para diferentes tipos de entrada e saída.

Um único controlador de fluxo sempre recebe um único objeto IR e retorna um único objeto IR. O paralelismo para vários objetos de entrada é suportado pelo BasePassManager transmitindo o controlador de fluxo por meio da função parallel_map() função.

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 a função ConditionalController que executa as tarefas armazenadas somente quando a condição é 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

classes base

Controladores de fluxo

Estado da compilação

Exceções

PassManagerError