index 1 is out of bounds for dimension 0 with size 1

[MirandaCarou]

Hi again 👋🏼 !

Right now I am trying to develop a model that consists of a circuit with a series of gates RX, RY, RZ and CNOT similar (for the moment) to your example of the classifier (The circuit is similar but in my case I am not making a classifier, I am making a generator with qutrits dim=3). The thing is that I have encountered a problem that no matter what I do I can't solve. When applying the gates RX, RY and RZ I get the following error:

[/usr/local/lib/python3.11/dist-packages/quforge/quforge.py](https://localhost:8080/#) in forward(self, x, param)
    628                 values = torch.zeros(4, dtype=torch.complex64, device=x.device)
    629                 if param is False:
--> 630                     values[0] = torch.cos(self.angle[i]/2)
    631                     values[1] = torch.cos(self.angle[i]/2)
    632                     values[2] = -1j*torch.sin(self.angle[i]/2)

IndexError: index 1 is out of bounds for dimension 0 with size 1

I have consulted your code base and tried passing an angle that is a torch.nn.Parameter(torch.randn(wires, dtype=torch.float)) and nothing. I have tried inside the generator before the self.layers = ... to put a self.angle=torch.nn.Parameter(torch.randn(wires, dtype=torch.float)) and nothing. Whatever I do I always seem to get the same error.

I don´t really know what is happening 😥. I consulted your iris_classifier example and i think that you don't have nothing different (in the circuit of course). I so sorry if maybe I am misunderstanding something very important 😫. I still trying to learn more deeper how to work with your library 🤓.

This is my code :

# Load and preprocess the Iris dataset
from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler
import numpy as np
import quforge.quforge as qf
from quforge.quforge import State
import torch
from torch import nn
from torch.optim import Adam
from scipy.stats import gaussian_kde
device = 'cpu'
# Set random seed for reproducibility
torch.manual_seed(123456)

# Load the Iris dataset
iris = load_iris()
data = iris.data

# Normalize the features
scaler = MinMaxScaler(feature_range=(0, 1))
data_normalized = scaler.fit_transform(data)

# Define Qudit dimensions and discretization
num_dim = data.shape[1]  # Number of features
num_discrete_values = 3  # Using qutrits
num_qutrits = num_dim
print("numero de dimensions: ",  num_dim)
print("numero de valores discretos: ", num_discrete_values)
print("numero de qutrits: ", num_qutrits)

# Discretize dataset
grid_elements = np.array(np.meshgrid(*[np.linspace(0, 1, num_discrete_values)] * num_dim)).T.reshape(-1, num_dim)
kde = gaussian_kde(data_normalized.T)
prob_data = kde(grid_elements.T)
prob_data /= np.sum(prob_data)

# Define Quantum Generator
class QuantumGenerator(qf.Module):
    def __init__(self, dim, wires):
        super(QuantumGenerator, self).__init__()
        self.dim = dim
        self.init = qf.H(dim=dim, index=range(wires))
        self.device = device 
        self.encoder = qf.RZ(dim=dim, index=range(wires))
        self.layers = qf.Sequential(
            qf.RX(dim=dim, j=0, k=1, index=range(wires)),
            qf.RX(dim=dim, j=1, k=2, index=range(wires)),
            qf.RX(dim=dim, j=0, k=2, index=range(wires)),
            qf.RY(dim=dim, j=0, k=1, index=range(wires)),
            qf.RY(dim=dim, j=1, k=2, index=range(wires)),
            qf.RY(dim=dim, j=0, k=2,  index=range(wires)),
            qf.RZ(dim=dim, j=1, index=range(wires)),
            qf.RZ(dim=dim, j=2, index=range(wires)),
            qf.CNOT(dim=dim, wires=wires, index=[0,1]),
            qf.CNOT(dim=dim, wires=wires, index=[0,2]),
            qf.CNOT(dim=dim, wires=wires, index=[0,3]),
        )
    angle = torch.randn(num_qutrits, dtype=torch.float)
    def forward(self, x):
        y = State('0-0-0-0', dim=self.dim, device='cpu')
        y = self.init(y)
        for i in range(num_qutrits):
            y = self.encoder(y, param=x[:, i])
        y = self.layers(y)
        return y

# Define Classical Discriminator
class Discriminator(nn.Module):
    def __init__(self, input_size):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_size, 20),
            nn.LeakyReLU(0.2),
            nn.Linear(20, 1),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        return self.model(x)

# Instantiate models
angle_generator = torch.randn(num_qutrits, dtype=torch.float)
generator = QuantumGenerator(dim=3, wires=num_qutrits).to(device)
discriminator = Discriminator(num_dim)

# Define loss function and optimizers
def adversarial_loss(input, target, w):
    loss = target * torch.log(input) + (1 - target) * torch.log(1 - input)
    return -torch.sum(w * loss)

generator_optimizer = qf.optim.Adam(generator.parameters(), lr=0.01, betas=(0.7, 0.999), weight_decay=0.005)
discriminator_optimizer = Adam(discriminator.parameters(), lr=0.01, betas=(0.7, 0.999), weight_decay=0.005)

# Training loop
n_epochs = 100
num_qnn_outputs = num_discrete_values**num_dim

for epoch in range(n_epochs):
    valid = torch.ones(num_qnn_outputs, 1, dtype=torch.float)
    fake = torch.zeros(num_qnn_outputs, 1, dtype=torch.float)
    
    real_dist = torch.tensor(prob_data, dtype=torch.float).reshape(-1, 1)
    samples = torch.tensor(grid_elements, dtype=torch.float)
    noise = torch.randn(num_qnn_outputs, num_qutrits)
    output = generator(noise)
    _, gen_dist = qf.measure(output, index=[0, 1, 2], dim=dim, wires=wires)
    
    generator_optimizer.zero_grad()
    generator_loss = adversarial_loss(discriminator(samples), valid, gen_dist)
    generator_loss.backward()
    generator_optimizer.step()
    
    discriminator_optimizer.zero_grad()
    real_loss = adversarial_loss(discriminator(samples), valid, real_dist)
    fake_loss = adversarial_loss(discriminator(samples), fake, gen_dist.detach())
    discriminator_loss = (real_loss + fake_loss) / 2
    discriminator_loss.backward()
    discriminator_optimizer.step()
    
    print(f"Epoch {epoch+1}/{n_epochs} - Generator Loss: {generator_loss.item():.4f} - Discriminator Loss: {discriminator_loss.item():.4f}")

Thank you for your attention and sorry for the inconvenience ❤️🙏🏼

[tiago939]

Hi Miranda!

This error happens because when you call explicitly a gate you need to inform the total number of qudits (wires).
In your code, your QuantumGenerator class has the self.layers as:

qf.RX(dim=dim, j=0, k=1, index=range(wires))

You need to tell the number of wires as:

qf.RX(dim=dim, j=0, k=1, index=range(wires), wires=wires)

The same for all other gates in the self.layers. If you don't want to do this, alternatively, you can declare your self.layers as a circuit, then the library will know the correct number of wires and the dimension of the qudit, for instance:

self.layers = qf.Circuit(dim=dim, wires=wires)
self.layers.RX(j=0, k=1, index=range(wires))
self.layers.RX(j=1, k=2, index=range(wires))
self.layers.RX(j=0, k=2, index=range(wires))
self.layers.RY(j=0, k=1, index=range(wires))
self.layers.RY(j=1, k=2, index=range(wires))
self.layers.RY(j=0, k=2,  index=range(wires))
self.layers.RZ(j=1, index=range(wires))
self.layers.RZ(j=2, index=range(wires))
self.layers.CNOT(index=[0,1])
self.layers.CNOT(index=[0,2])
self.layers.CNOT(index=[0,3])

should lead to the same results.

Also, in your code you will have an error on the measure function:

_, gen_dist = qf.measure(output, index=[0, 1, 2], dim=dim, wires=wires)

Since dim and wires are not defined here. You just need to change for the dimension and wires you defined previously (I guess num_dim and num_qutrits in your case).

Please don't hesitate if you have any other question!

Best regards!