PauliFeatureMap

class qiskit.circuit.library.PauliFeatureMap(feature_dimension=None, reps=2, entanglement='full', alpha=2.0, paulis=None, data_map_func=None, parameter_prefix='x', insert_barriers=False, name='PauliFeatureMap')

GitHub

Bases: NLocal

O circuito de expansão de Pauli.

O circuito de expansão de Pauli é um circuito de codificação de dados que transforma os dados de entrada $\vec{x} \in \mathbb{R}^n$ , em que n é o feature_dimension, como

U_{\Phi(\vec{x})}=\exp\left(i\sum_{S \in \mathcal{I}} \phi_S(\vec{x})\prod_{i\in S} P_i\right).

Aqui, $S$ é um conjunto de índices de qubit que descreve as conexões no mapa de recursos, $\mathcal{I}$ é um conjunto que contém todos esses conjuntos de índices e $P_i \in \{I, X, Y, Z\}$ . Por padrão, o mapeamento de dados $\phi_S$ é

\phi_S(\vec{x}) = \begin{cases} x_i \text{ if } S = \{i\} \\ \prod_{j \in S} (\pi - x_j) \text{ if } |S| > 1 \end{cases}.

As conexões possíveis podem ser definidas usando os argumentos entanglement e paulis . Por exemplo, para rotações de um único qubit $Z$ e interações de dois qubits $YY$ entre todos os pares de qubits, podemos definir:

feature_map = PauliFeatureMap(..., paulis=["Z", "YY"], entanglement="full")

que produzirá blocos do tipo

┌───┐┌─────────────┐┌──────────┐                                            ┌───────────┐
┤ H ├┤ P(2.0*x[0]) ├┤ RX(pi/2) ├──■──────────────────────────────────────■──┤ RX(-pi/2) ├
├───┤├─────────────┤├──────────┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐├───────────┤
┤ H ├┤ P(2.0*x[1]) ├┤ RX(pi/2) ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├┤ RX(-pi/2) ├
└───┘└─────────────┘└──────────┘└───┘└────────────────────────────────┘└───┘└───────────┘

O circuito contém reps repetições dessa transformação.

Consulte ZFeatureMap para o caso das rotações de Pauli- $Z$ de um único qubit e para ZZFeatureMap para as rotações de Pauli- $Z$ de um e dois qubits.

Exemplos

>>> prep = PauliFeatureMap(2, reps=1, paulis=['ZZ'])
>>> print(prep.decompose())
     ┌───┐
q_0: ┤ H ├──■──────────────────────────────────────■──
     ├───┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐
q_1: ┤ H ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
     └───┘└───┘└────────────────────────────────┘└───┘

>>> prep = PauliFeatureMap(2, reps=1, paulis=['Z', 'XX'])
>>> print(prep.decompose())
     ┌───┐┌─────────────┐┌───┐                                            ┌───┐
q_0: ┤ H ├┤ P(2.0*x[0]) ├┤ H ├──■──────────────────────────────────────■──┤ H ├
     ├───┤├─────────────┤├───┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐├───┤
q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ H ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├┤ H ├
     └───┘└─────────────┘└───┘└───┘└────────────────────────────────┘└───┘└───┘

>>> prep = PauliFeatureMap(2, reps=1, paulis=['ZY'])
>>> print(prep.decompose())
     ┌───┐┌──────────┐                                            ┌───────────┐
q_0: ┤ H ├┤ RX(pi/2) ├──■──────────────────────────────────────■──┤ RX(-pi/2) ├
     ├───┤└──────────┘┌─┴─┐┌────────────────────────────────┐┌─┴─┐└───────────┘
q_1: ┤ H ├────────────┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├─────────────
     └───┘            └───┘└────────────────────────────────┘└───┘

>>> from qiskit.circuit.library import EfficientSU2
>>> prep = PauliFeatureMap(3, reps=3, paulis=['Z', 'YY', 'ZXZ'])
>>> wavefunction = EfficientSU2(3)
>>> classifier = prep.compose(wavefunction)
>>> classifier.num_parameters
27
>>> classifier.count_ops()
OrderedDict([('cx', 39), ('rx', 36), ('u1', 21), ('h', 15), ('ry', 12), ('rz', 12)])

Referências

[1] Havlicek et al. Aprendizagem supervisionada com espaços de recursos aprimorados por quantum, Nature 567, 209-212 (2019).

Descontinuado desde a versão 2.1

A classe qiskit.circuit.library.data_preparation.pauli_feature_map.PauliFeatureMap está obsoleta desde o Qiskit 2.1. Ele será removido no Qiskit 3.0. Use a função pauli_feature_map como substituta. Observe que isso não retornará mais um BlueprintCircuit,, mas apenas um QuantumCircuit simples.

Parâmetros

feature_dimension (int | None) – Número de qubits no circuito.
reps (int) – O número de vezes que as camadas de evolução são repetidas.
entanglement (str |dict[int, list[tuple[int]]] | Callable[[int], str |dict[int, list[tuple[int]]]]) – Especifica a estrutura de entrelaçamento. Pode ser uma string ('full', 'linear', 'reverse_linear', 'circular' ou 'sca') ou um dicionário em que as chaves representam o número de qubits e os valores são listas de pares de inteiros que especificam os índices dos qubits entrelaçados entre si, por exemplo: {1: [(0,), (2,)], 2: [(0,1), (2,0)]} ou pode ser um Callable[[int], Union[str | Dict[...]]] para retornar um entrelaçamento específico para uma repetição
alpha (float) – O fator de rotação de Pauli, multiplicativo para as rotações de Pauli
paulis (list[str] | None) – Uma lista de strings para os paulis a serem utilizados. Se nenhum for fornecido, ['Z', 'ZZ'] será usado.
data_map_func (Callable[[np.ndarray], float] | None) – Uma função de mapeamento para os dados x que pode ser fornecida para substituir o mapeamento padrão.
parameter_prefix (str) – O prefixo usado se forem gerados parâmetros padrão.
insert_barriers (bool) – Nesse caso True, são inseridas barreiras entre as instruções de evolução e as camadas de Hadamard.
name (str) – Nome do circuito.

Atributos

alpha

O fator de rotação de Pauli (alfa).

Retorna

O fator de rotação de Pauli.

entanglement_blocks

Os blocos nas camadas de emaranhamento.

Retorna

Os blocos nas camadas de emaranhamento.

feature_dimension

Retorna a dimensão do recurso (que é igual ao número de qubits).

Retorna

A dimensão do recurso desse mapa de recursos.

num_parameters_settable

O número de parâmetros distintos.

paulis

As cadeias de Pauli usadas no emaranhamento dos qubits.

Retorna

As cadeias de Pauli como lista.

name

Tipo: str

Um nome legível por humanos para o circuito.

Exemplo

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2, name="my_circuit")
print(qc.name)

my_circuit

Métodos

get_entangler_map

get_entangler_map(rep_num, block_num, num_block_qubits)

GitHub

Obtenha o mapa de emaranhamento para a repetição rep_num e o bloco block_num.

O mapa de emaranhamento do bloco atual é derivado do valor de self.entanglement. Abaixo estão listados os diferentes casos, onde i e j denotam o número de repetição e o número do bloco, respectivamente, e n o número de qubits no bloco.

tipo de emaranhamento	mapa de emaranhamento
`None`	`[[0, ..., n - 1]]`
`str` (por exemplo `'full'`)	a conectividade especificada nos `n` qubits
`List[int]`	[`entanglement`]
`List[List[int]]`	`entanglement`
`List[List[List[int]]]`	`entanglement[i]`
`List[List[List[List[int]]]]`	`entanglement[i][j]`
`List[str]`	a conectividade especificada em `entanglement[i]`
`List[List[str]]`	a conectividade especificada em `entanglement[i][j]`
`Callable[int, str]`	mesmo que `List[str]`
`Callable[int, List[List[int]]]`	mesmo que `List[List[List[int]]]`

Observe que todos os índices devem ser tomados no módulo do comprimento da matriz em que atuam, ou seja, nenhum erro de índice fora dos limites será gerado, mas repetiremos a iteração desde o início da lista.

Parâmetros