Encoding a multi-dimensional vector using amplitude encoding

PennyLane Help
1

Hello,

Currently I want to use amplitude encoding for my project. Since for amplitude encoding, it only accepts normalized vector (basically a direction), this would have the problem that for vectors in the same direction with different magnitude, it would result in the same embedding which is not wanted.

I want to know if there are possible ways to also encode the amplitude into the circuit in some clever way provided by Pennylane?

Thank you

2

Hey @Daniel_Wang! AmplitudeEmbedding has a keyword argument called normalize that normalizes the state automatically for you.

@qml.qnode(dev)
def circuit(f=None):
    qml.AmplitudeEmbedding(features=f, wires=range(2), normalize=True)
    return qml.expval(qml.PauliZ(0)), qml.state()

res, state = circuit(f=[15, 15, 15, 15])

>>> state
tensor([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j], requires_grad=True)

Let me know if this helps!

3

Hi,

Thx for the soln! I know it can normalize this for me. My question is actually that, after the normalization, the magnitude information is lost in this process. Think that I have two data: 1) (3, 3) 2) (1, 1), after normalization they are all mapped to the same statevector with the magnitude information lost. I want to know if there is any provided way that could preserve this magnitude information.

Thank you

4

Thank you for clarifying!

Think that I have two data: 1) (3, 3) 2) (1, 1), after normalization they are all mapped to the same statevector with the magnitude information lost.

I’m not sure that I understand your example here. But, if you want to maintain the magnitude of the feature that you provide AmplitudeEmbedding, you’ll have to compute the normalization yourself:

import pennylane as qml
from pennylane import numpy as np

def random_state():
    """Creates a random 1-qubit state: |psi> = a|0> + phase * b |1>"""
    a = np.random.uniform(-1, 1)
    b = np.random.uniform(-1, 1)
    phase = np.random.uniform(0, 2 * np.pi)
    norm = np.sqrt(a**2 + b**2)

    return np.array([a, np.exp(1j * phase) * b]) / norm, norm

state, normalization = random_state()

dev = qml.device("default.qubit")

@qml.qnode(dev)
def circuit(state):
    qml.AmplitudeEmbedding(state, wires=0)
    return qml.state()

print(circuit(state), normalization)

[-0.92610976+0.j        -0.37080329-0.0694668j] 0.9712434279874106

To your question of embedding the normalization in the circuit somehow, you can try using the normalization as an angle of rotation to a rotation gate:

@qml.qnode(dev)
def circuit(state, normalization):
    qml.AmplitudeEmbedding(state, wires=0)
    qml.RX(normalization, wires=0)
    return qml.state()

Other than that, I’m not sure that there’s a more obvious / clever way to do it :thinking:. Of course, angles of rotation are modulo \pi. So if your normalization is larger than \pi, that information gets lost. Let me know if that helps!

5

Hi!

Thank you for the answer. That helps.

1 Like
6

Awesome! Glad I could help :grin: