QFI Calculation With PyTorch #194
Replies: 1 comment · 7 replies
-
|
will code in this tutorial helpful? https://tensorcircuit.readthedocs.io/en/latest/tutorials/imag_time_evo.html (Note that the lhs matrix in imaginary time evolution is the same thing as QFI) The only subtlety is that you have to use pytorch backend, which lacks jit feature for now and might be not that efficient |
Beta Was this translation helpful? Give feedback.
-
|
what is your pytorch version? could you attached a runnable minimal demo to reproduce the bug? |
Beta Was this translation helpful? Give feedback.
-
|
I have PyTorch 2.1.0. I think that posting this here would be too large - the "m" instance in the above code snippet is its own class which inherits from torch.nn.Module and depends on many other functions. |
Beta Was this translation helpful? Give feedback.
-
|
sure, this is why I want a "minimal demo" to reproduce where you need to keep only the necessary ingredients for the module, say, if the module is only a Linear layer, will you have the same error? |
Beta Was this translation helpful? Give feedback.
-
|
Hi @refraction-ray. I've been messing with the code to understand it. I'm getting a new error message, so I'll post everything here and hopefully you can help me out! My general class is defined as import tensorly as tl
import tlquantum as tlq
from tensorly.tt_matrix import TTMatrix
import torch
from torch import randint, rand, arange, complex128
from torch.optim import Adam
import matplotlib.pyplot as plt
from math import factorial, sqrt
import os
import numpy as np
class Metrology(torch.nn.Module):
def __init__(self,nqubits,L,dt,approx,ncontraq,ncontral,axes=['x'],scale=0.1,dtype=complex128,device=None):
super().__init__()
self.nqubits, self.L, self.dt = nqubits, L, dt
self.approx, self.ncontraq, self.ncontral, self.axes = approx, ncontraq, ncontral, axes
self.dtype, self.device = dtype, device
self.scale=scale
self.Js = torch.nn.Parameter(scale*rand([L])).to(device)
self.ths = torch.nn.Parameter(scale*rand([L,len(axes)])).to(device)
self.O = torch.tensor([1.0], device=device)
self.W = torch.nn.Linear(1,1, device=None, bias=False).double()
self.sz = Flip(self.nqubits,ncontraq,device=device,dtype=dtype)
self.state = make_state(self.nqubits)
self.state = tlq.qubits_contract(self.state,self.ncontraq)
self.make_U1()
self.make_U2()
self.Op = make_Sy(self.nqubits)
def concatenate_parameters(self):
parameters = []
for param in self.parameters():
parameters.append(param.view(-1))
return torch.cat(parameters)
def get_concatenated_shape(self):
concatenated_parameters = self.concatenate_parameters()
return concatenated_parameters.shape
def make_U1(self):
self.U1=[]
for i in range(self.L):
self.U1+=get_global_perceptron(self.nqubits, self.ncontraq, self.approx, dt=self.dt, device=self.device, J=self.Js[i])
for a in range(len(self.axes)):
self.U1+=get_global_rotation(self.nqubits, self.ncontraq, axis=self.axes[a], param=self.ths[i,a])
return
def make_U2(self):
self.U2=[self.sz]
cnt=0
for l in range(len(self.U1)):
mod1 = self.U1[l]
if cnt%(len(self.axes)+1)==0: #We have a perceptron
for p in mod1.parameters(): J = p.data
mod2 = get_global_perceptron(self.nqubits,self.ncontraq,self.approx,grad=False,J=J)
self.U2 += mod2
else: #We have an rotation. The axis is given by
a = self.axes[l%(len(self.axes)+1)-1]
for p in mod1.parameters(): theta = -p.data
mod2 = get_global_rotation(self.nqubits,self.ncontraq,axis=a,grad=False,param=theta)
self.U2 += mod2
cnt+=1
return
def forward(self, phi):
P = perturbation(self.nqubits,phi)
c = tlq.TTCircuit(self.U1+P+self.U2, self.ncontraq, self.ncontral)
#return c.forward_expectation_value(self.state, self.Op).real/(self.nqubits/2)
return self.W(c.forward_expectation_value(self.state, self.Op).real/(self.nqubits/2))
def forward_ket(self, phi):
def wrapper(params, phi=phi):
params = params
P = perturbation(self.nqubits,phi)
c = tlq.TTCircuit(self.U1+P+self.U2, self.ncontraq, self.ncontral)
state = c.to_ket(self.state)
return state
return wrapperI'm using tensorly-quantum for quantum simulation. Now, when I try to create an instance of this quantum circuit and calculate the QFI after one pass of my circuit I do import tensorcircuit as tc
import torch
import numpy as np
import tensorflow as tf
Nqubits=10
Ntrails=30
L = 10
Nepochs=50
batchsize=20
axes=['x']
Phis = torch.tensor(np.linspace(-0.5,0.5,100), dtype=torch.float32)
Phis_train = 0.5*(2*torch.rand(100)-1)
m = Metrology(Nqubits,L,0.05,1,2,2,scale=0.5,axes=axes)
from tensorcircuit.experimental import qng, qng2
tc.set_backend('pytorch')
# Concatenate parameters
params_generator = m.parameters()
params_pytorch = [torch.Tensor(param.detach().numpy()) for param in params_generator]
# Convert each tensor in the list to the desired dtype
# params_pytorch = [param.type(torch.FloatTensor) for param in params_pytorch]
params_pytorch[1] = params_pytorch[1].squeeze()
params_pytorch[2] = params_pytorch[2].squeeze(dim=1)
params_pytorch = torch.cat(params_pytorch, dim=0)
state = m.forward_ket(Phis[0]) # Should be a Callable which returns a Tensor
qfi_fun = qng(state)
qfi_value = qfi_fun(params_pytorch)After doing this I get Is this enough to understand the problem I'm having? I simply want to calculate the QFI of the output state of my quantum circuit with respect to the variational parameters. I didn't begin doing this with TensorCircuit or else I wouldn't be running into these problems! As I said before, I used tensorly-quantum to simulate my circuit, and I don't necessarily have the time to write a function that does this for me in the other package. My thought process is that if i get the output of my tensorly-quantum simulated circuit in the right format ( |
Beta Was this translation helpful? Give feedback.
-
|
the error message is even different from the previous one, so I guess the main reason is the implementation of tensorly is not very compatible with pytorch function transformations, I suggest to use tensorcircuit for the whole pipeline or you need to dig into the incompatibility |
Beta Was this translation helpful? Give feedback.
Uh oh!
There was an error while loading. Please reload this page.
-
Hello,
I'm trying to use TensorCircuit to perform a QFI calculation. I'm trying to do this on what is essentially a PyTorch module. I know that TensorCircuit has backend support for PyTorch, but I'm unsure of the specifics of how to actually do the calculation. Any help would be appreciated!
Beta Was this translation helpful? Give feedback.
All reactions