RuntimeError: Cannot access data pointer of Tensor that doesn't have storage When I used the opacus package

[will-last]

Hello, I confused recently when i used the opacus package to apply differential privacy to my quantum model, when i used "loss.backward()", it happened RuntimeError: Cannot access data pointer of Tensor that doesn't have storage, which led me couldn't use the opacus, who can help me, thanks

[will-last]

import pennylane as qml
import torch
from opacus import PrivacyEngine
from pennylane.qnn.torch import TorchLayer
from torch import nn, optim
from qml_src.data import load_data

qubits = 10
dev = qml.device('default.qubit', wires=qubits)
@qml.qnode(dev, interface='torch')
def circuit(inputs, weights):
      qml.AmplitudeEmbedding(features=inputs, wires=range(qubits), normalize=True)
      qml.BasicEntanglerLayers(weights, wires=range(qubits))
      return qml.expval(qml.PauliZ(0))

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        weight_shapes = {"weights": (1, 10)}
        init_method = {"weights": torch.nn.init.xavier_normal_(torch.Tensor(1, 10), 0.1)}
        qnode = qml.QNode(circuit, dev, interface='torch', diff_method='backprop')
        self.qlayer_1 = TorchLayer(qnode, weight_shapes, init_method)
    def forward(self, x):
        x = self.flatten(x)
        x = self.qlayer_1(x)
        return x

train_loader, test_loader = load_data()

model = Model()
fn = nn.CrossEntropyLoss()
opt = optim.Adam(model.parameters(), 0.01)

privacy_engine = PrivacyEngine()
model, optimizer, train_loader = privacy_engine.make_private(
    module=model,
    optimizer=opt,
    data_loader=train_loader,
    noise_multiplier=1.1,
    max_grad_norm=1.0,
)

for datas, targets in train_loader:
    datas, targets = datas, targets.to(torch.float)
    break
output = model(datas)
loss = fn(output, targets)
loss.backward()
opt.step()

[daniela-angulo]

Hi!
From what I see, this might be more of a pytorch question than PennyLane. I tried searching information about this error and got several results from pytorch forums like https://stackoverflow.com/questions/78275784/runtimeerror-cannot-access-data-pointer-of-tensor-that-doesnt-have-storage-w and https://github.com/pytorch/pytorch/issues/96041 where they report it as a bug. I wonder if some of those entries could offer valuable hints for your problem.
I did try to replicate your error but wasn't able to because of the qml_src module. I could try again, but I would need to be able to install it, do you know of a way for me to do that?

[will-last]

I was very suprised to your reply, and thanks your advice, here is my code, I hope you can run it and see where the problem lies.
pennylane 0.40.0
python 3.12.0

    import torch
    import torchvision
    from sklearn.model_selection import train_test_split
    from torch.utils.data import DataLoader, TensorDataset
    from torchvision import datasets
    import pennylane as qml
    from pennylane import AmplitudeEmbedding
    from pennylane.qnn.torch import TorchLayer
    from torch.nn.functional import tanh
    from matplotlib import pyplot as plt
    from opacus import PrivacyEngine
    from torch import nn, optim
    from pennylane import numpy as np
    
    # 1. processing the datas
    def load_data():
    
        # download mnist dataset
        train_dataset = datasets.MNIST(root='../datasets', train=True, download=True)
        test_dataset = datasets.MNIST(root='../datasets', train=False, download=True)
    
        # extract samples 0 and 1
        train_mask = (train_dataset.targets == 1) | (train_dataset.targets == 0)
        train_images = train_dataset.data[train_mask]
        train_labels = train_dataset.targets[train_mask]
    
        test_mask = (test_dataset.targets == 1) | (test_dataset.targets == 0)
        test_images = test_dataset.data[test_mask]
        test_labels = test_dataset.targets[test_mask]
    
        all_images = torch.cat([train_images, test_images])
        all_labels = torch.cat([train_labels, test_labels])
    
        # train_dataset : test_dataset = 6 : 4
        random_state = 42
        X_train, X_test, y_train, y_test = train_test_split(all_images, all_labels, test_size=0.4,
                                                            random_state=random_state, stratify=all_labels)
        print(f"number of train_dataset: {len(X_train)}")
        print(f"number of test_dataset: {len(X_test)}")
    
        # preprocessing
        transform = torchvision.transforms.Compose([
            torchvision.transforms.Normalize(0.1307, 0.3081),
            torchvision.transforms.Pad(padding=2, fill=0)
        ])
        X_train = transform(X_train.float())
        X_test = transform(X_test.float())
    
        # transform to pytorch dataset
        train_dataset = TensorDataset(X_train, y_train)
        test_dataset = TensorDataset(X_test, y_test)
    
        # create DataLoader
        batch_size = 32
        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
        test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
    
        # check sample in DataLoader
        for images, labels in train_loader:
            print(f"type of train_dataset: {images.type()}")
            print(f"shape of train_dataset: {images.shape}")
            print(f"label of train_dataset: {labels}")
            break
    
        return train_loader, test_loader
    
    
    
    
    # 2. the model I used
    n_qubits_1 = 10
    block_1 = 3
    dev_1 = qml.device("default.qubit", wires=n_qubits_1)
    
    n_qubits_2 = 4
    block_2 = 1
    dev_2 = qml.device("default.qubit", wires=n_qubits_2)
    
    def circuit_1(inputs, weights):
        # amplitude encode
        AmplitudeEmbedding(features=inputs, wires=range(n_qubits_1), normalize=True)
    
        # training parameters / ansatz
        for layer in range(block_1):
    
            for wires in range(n_qubits_1):
                if wires == n_qubits_1 - 1:
                    qml.CNOT([wires, 0])
                else:
                    qml.CNOT([wires, wires + 1])
    
            params = weights[layer]
            for wires in range(n_qubits_1):
                qml.Rot(*params[wires], wires=wires)
    
        return [qml.expval(qml.Z(i)) for i in range(4)]
    def circuit_2(inputs, weights):
        # angle encode
        qml.AngleEmbedding(features=torch.arctan(inputs), wires=range(n_qubits_2), rotation='Y')
        qml.AngleEmbedding(features=torch.arctan(inputs**2), wires=range(n_qubits_2), rotation='Z')
    
        for layer in range(block_2):
    
            for wires in range(n_qubits_2):
                if wires == n_qubits_2-1:
                    qml.CNOT([wires, 0])
                else:
                    qml.CNOT([wires, wires+1])
    
            params = weights[layer]
            for wires in range(n_qubits_2):
                qml.Rot(*params[wires], wires=wires)
    
        return [qml.expval(qml.Z(i)) for i in range(2)]
    class QC_1(nn.Module):
        def __init__(self):
            super().__init__()
            weight_shapes = {"weights": (block_1, n_qubits_1, 3)}
            qnode = qml.QNode(circuit_1, dev_1, interface='torch', diff_method='backprop')
            self.qlayer_1 = TorchLayer(qnode, weight_shapes)
            torch.nn.init.xavier_normal_(self.qlayer_1.weights, 0.1)
        def forward(self, x):
            x = self.qlayer_1(x)
            return x
    class QC_2(nn.Module):
        def __init__(self):
            super().__init__()
            weight_shapes = {"weights": (block_2, n_qubits_2, 3)}
            qnode = qml.QNode(circuit_2, dev_2, interface='torch', diff_method='backprop')
            self.qlayer_2 = TorchLayer(qnode, weight_shapes)
            torch.nn.init.xavier_normal_(self.qlayer_2.weights, 0.1)
        def forward(self, x):
            x = self.qlayer_2(x)
            return x
    
    class QNN(nn.Module):
        def __init__(self):
            super().__init__()
            # torch.manual_seed(43)
            self.flatten = nn.Flatten()
            self.q1 = QC_1()
            self.q2 = QC_2()
            self.f1 = nn.Linear(4, 4)
            self.f2 = nn.Linear(2, 2)
    
        def forward(self, x):
            x = self.flatten(x)
            x = self.q1(x)
            x = tanh(self.f1(x))
            x = self.q2(x)
            x = tanh(self.f2(x))
            return x
    
    
    
    
    # 3. training
    train_loader, test_loader = load_data()
    
    model = QNN().to('cuda')
    loss_fn = nn.CrossEntropyLoss()
    optimizer = optim.RMSprop(model.parameters(), lr=0.02, momentum=0.5)
    
    epochs = 10
    avg_loss_list = []
    accuracy_list = []
    epo = np.arange(1, epochs+1)
    
    # Because I used it ,then using loss.backward(), causing the errors
    privacy_engine = PrivacyEngine()
    model, optimizer, train_loader = privacy_engine.make_private(
        module=model,
        optimizer=optimizer,
        data_loader=train_loader,
        noise_multiplier=1.1,
        max_grad_norm=1.0,
    )
    
    model.train()
    for epoch in range(epochs):
        train_loss = []
        correct = 0.0
        for datas, targets in train_loader:
            optimizer.zero_grad()
            datas, targets = datas.to('cuda'), targets.to('cuda')
            outputs = model(datas)
            loss = loss_fn(outputs, targets)
            loss.backward()
            optimizer.step()
            train_loss.append(loss.item())
            pred = outputs.argmax(dim=1, keepdim=True)
            correct += pred.eq(targets.view_as(pred)).sum().item()
    
        avg_loss = np.mean(train_loss)
        avg_loss_list.append(avg_loss)
        accuracy_list.append(correct / len(train_loader.dataset))
        print(f"Epoch {epoch + 1} Average Loss: {avg_loss:.4f}")
        print(f'train_accuracy: {100 * (correct / len(train_loader.dataset)):.4f}%')
    
    model.eval()
    with torch.no_grad():
        test_loss = []
        correct = 0.0
        for datas, targets in test_loader:
            datas, targets = datas.to('cuda'), targets.to('cuda')
            output = model(datas)
            loss = loss_fn(output, targets)
            test_loss.append(loss.item())
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(targets.view_as(pred)).sum().item()
        print(f'\n测试数据:\ntest_loss: {np.mean(test_loss):.4f}')
        print(f'test_accuracy: {100 * (correct / len(test_loader.dataset)):.4f}%')
    
    def drawer(avg_loss_list, accuracy_list):
        plt.figure(figsize=(6, 6))
        plt.subplot(1, 2, 1)
        plt.plot(avg_loss_list, label='Loss')
        plt.plot(accuracy_list, label='Accuracy')
        plt.xticks(ticks=np.arange(5, 20, 5))
        plt.yticks(ticks=np.arange(0.0, 1.2, 0.2))
        plt.xlabel("Epoch")
        plt.ylabel("Loss/Accuracy")
        plt.title("VQC for BINARY of 0 and 1")
        plt.legend()
        plt.show()
    drawer(avg_loss_list, accuracy_list)

[CatalinaAlbornoz]

Hi @will-last ,

I'm not being able to replicate your issue, probably due to some package version differences.

Can you please post:

• The output of qml.about()
• The versions of other libraries you're using such as Torch and Torchvision ?

Thanks!

[will-last]

I was so sorry for my carelessness, here are information

===================================

Name: PennyLane
Version: 0.40.0
Summary: PennyLane is a cross-platform Python library for quantum computing, quantum machine learning, and quantum chemistry. Train a quantum computer the same way as a neural network.
Home-page: https://github.com/PennyLaneAI/pennylane
Author:
Author-email:
License: Apache License 2.0
Location: D:\Program Files\Anaconda3\envs\torch\Lib\site-packages
Requires: appdirs, autograd, autoray, cachetools, diastatic-malt, networkx, numpy, packaging, pennylane-lightning, requests, rustworkx, scipy, tomlkit, typing-extensions
Required-by: PennyLane_Lightning

Platform info: Windows-10-10.0.18363-SP0
Python version: 3.12.0
Numpy version: 1.26.4
Scipy version: 1.15.0
Installed devices:

• default.clifford (PennyLane-0.40.0)
• default.gaussian (PennyLane-0.40.0)
• default.mixed (PennyLane-0.40.0)
• default.qubit (PennyLane-0.40.0)
• default.qutrit (PennyLane-0.40.0)
• default.qutrit.mixed (PennyLane-0.40.0)
• default.tensor (PennyLane-0.40.0)
• null.qubit (PennyLane-0.40.0)
• reference.qubit (PennyLane-0.40.0)
• lightning.qubit (PennyLane_Lightning-0.40.0)

========================================
absl-py 2.1.0
anyio 4.8.0
appdirs 1.4.4
argon2-cffi 23.1.0
argon2-cffi-bindings 21.2.0
arrow 1.3.0
asttokens 2.0.5
astunparse 1.6.3
async-lru 2.0.4
attrs 24.3.0
autograd 1.7.0
autoray 0.7.0
babel 2.16.0
beautifulsoup4 4.12.3
bleach 6.2.0
Brotli 1.0.9
cachetools 5.5.1
certifi 2024.12.14
cffi 1.17.1
charset-normalizer 3.3.2
colorama 0.4.6
comm 0.2.1
contourpy 1.3.1
cycler 0.11.0
d2l 0.15.1
debugpy 1.6.7
decorator 5.1.1
defusedxml 0.7.1
diastatic-malt 2.15.2
dill 0.3.9
executing 0.8.3
fastjsonschema 2.21.1
filelock 3.13.1
fonttools 4.51.0
fqdn 1.5.1
fsspec 2025.2.0
gast 0.6.0
grpcio 1.69.0
h11 0.14.0
httpcore 1.0.7
httpx 0.28.1
idna 3.7
iniconfig 2.0.0
ipykernel 6.29.5
ipython 8.30.0
ipywidgets 8.1.5
isoduration 20.11.0
jedi 0.19.2
Jinja2 3.1.4
joblib 1.4.2
json5 0.10.0
jsonpointer 3.0.0
jsonschema 4.23.0
jsonschema-specifications 2024.10.1
jupyter 1.1.1
jupyter_client 8.6.0
jupyter-console 6.6.3
jupyter_core 5.7.2
jupyter-events 0.11.0
jupyter-lsp 2.2.5
jupyter_server 2.15.0
jupyter_server_terminals 0.5.3
jupyterlab 4.3.4
jupyterlab_pygments 0.3.0
jupyterlab_server 2.27.3
jupyterlab_widgets 3.0.13
kiwisolver 1.4.4
Markdown 3.7
MarkupSafe 2.1.3
matplotlib 3.10.0
matplotlib-inline 0.1.6
mistune 3.1.0
mkl_fft 1.3.11
mkl_random 1.2.8
mkl-service 2.4.0
mpmath 1.3.0
nbclient 0.10.2
nbconvert 7.16.5
nbformat 5.10.4
nest-asyncio 1.6.0
networkx 3.2.1
notebook 7.3.2
notebook_shim 0.2.4
numpy 1.26.4
opacus 1.5.3
opencv-python 4.10.0.84
opt_einsum 3.4.0
overrides 7.7.0
packaging 24.2
pandas 2.2.3
pandocfilters 1.5.1
parso 0.8.4
pbr 6.1.1
PennyLane 0.40.0
PennyLane_Lightning 0.40.0
pillow 11.0.0
pip 24.2
platformdirs 3.10.0
pluggy 1.5.0
ply 3.11
prometheus_client 0.21.1
prompt-toolkit 3.0.43
protobuf 5.29.2
psutil 5.9.0
pure-eval 0.2.2
pycparser 2.22
Pygments 2.15.1
pylatexenc 2.10
pyparsing 3.2.0
PyQt5 5.15.10
PyQt5-sip 12.13.0
PySocks 1.7.1
pytest 8.3.5
python-dateutil 2.9.0.post0
python-json-logger 3.2.1
pytz 2024.2
pyvacy 0.0.32
pywin32 305.1
pywinpty 2.0.14
PyYAML 6.0.2
pyzmq 26.2.0
qiskit 1.4.0
qiskit-aer 0.16.1
qiskit-machine-learning 0.8.2
referencing 0.35.1
requests 2.32.3
rfc3339-validator 0.1.4
rfc3986-validator 0.1.1
rpds-py 0.22.3
rustworkx 0.16.0
scikit-learn 1.6.0
scipy 1.15.0
scipy-openblas32 0.3.29.0.0
Send2Trash 1.8.3
setuptools 75.1.0
sip 6.7.12
six 1.16.0
sniffio 1.3.1
soupsieve 2.6
stack-data 0.2.0
stevedore 5.4.1
symengine 0.13.0
sympy 1.13.1
tensorboard 2.18.0
tensorboard-data-server 0.7.2
termcolor 2.5.0
terminado 0.18.1
threadpoolctl 3.5.0
tinycss2 1.4.0
tomlkit 0.13.2
torch 2.5.1
torchaudio 2.5.1
torchsummary 1.5.1
torchvision 0.20.1
tornado 6.4.2
tqdm 4.67.1
traitlets 5.14.3
types-python-dateutil 2.9.0.20241206
typing_extensions 4.12.2
tzdata 2024.2
unicodedata2 15.1.0
uri-template 1.3.0
urllib3 2.2.3
wcwidth 0.2.13
webcolors 24.11.1
webencodings 0.5.1
websocket-client 1.8.0
Werkzeug 3.1.3
wheel 0.44.0
widgetsnbextension 4.0.13
win-inet-pton 1.1.0

[CatalinaAlbornoz]

Hi @will-last, I'm still having some issues replicating your error. Can you please share your full error traceback?

[will-last]

Traceback (most recent call last):
File "C:\Users\will last\Desktop\Pytorch\Rewrite\qml_src\train.py", line 38, in
loss.backward()
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_tensor.py", line 581, in backward
torch.autograd.backward(
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch\autograd_init_.py", line 347, in backward
_engine_run_backward(
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch\autograd\graph.py", line 825, in _engine_run_backward
return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch\nn\modules\module.py", line 98, in call
return self.hook(module, *args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\opacus\grad_sample\grad_sample_module.py", line 338, in capture_backprops_hook
grad_samples = grad_sampler_fn(module, activations, backprops)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\opacus\grad_sample\functorch.py", line 94, in ft_compute_per_sample_gradient
per_sample_grads = layer.ft_compute_sample_grad(
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_functorch\apis.py", line 203, in wrapped
return vmap_impl(
^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_functorch\vmap.py", line 331, in vmap_impl
return _flat_vmap(
^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_functorch\vmap.py", line 479, in _flat_vmap
batched_outputs = func(*batched_inputs, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_functorch\apis.py", line 399, in wrapper
return eager_transforms.grad_impl(func, argnums, has_aux, args, kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_functorch\eager_transforms.py", line 1449, in grad_impl
results = grad_and_value_impl(func, argnums, has_aux, args, kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_functorch\vmap.py", line 48, in fn
return f(*args, **kwargs)
^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_functorch\eager_transforms.py", line 1407, in grad_and_value_impl
output = func(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\opacus\grad_sample\functorch.py", line 71, in compute_loss_stateless_model
output = flayer(params, batched_activations)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\opacus\grad_sample\functorch.py", line 36, in fmodel
return torch.func.functional_call(stateless_mod, new_params_dict, args, kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch_functorch\functional_call.py", line 148, in functional_call
return nn.utils.stateless._functional_call(
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch\nn\utils\stateless.py", line 298, in _functional_call
return module(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch\nn\modules\module.py", line 1736, in _wrapped_call_impl
return self._call_impl(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\torch\nn\modules\module.py", line 1747, in _call_impl
return forward_call(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\qnn\torch.py", line 404, in forward
results = self._evaluate_qnode(inputs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\qnn\torch.py", line 430, in _evaluate_qnode
res = self.qnode(**kwargs)
^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\workflow\qnode.py", line 905, in call
return self._impl_call(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\workflow\qnode.py", line 881, in _impl_call
res = qml.execute(
^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\workflow\execution.py", line 232, in execute
results = run(tapes, device, config, inner_transform)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\workflow\run.py", line 287, in run
results = inner_execute(tapes)
^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\workflow\run.py", line 247, in inner_execute
results = device.execute(transformed_tapes, execution_config=execution_config)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\modifiers\simulator_tracking.py", line 30, in execute
results = untracked_execute(self, circuits, execution_config)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\modifiers\single_tape_support.py", line 32, in execute
results = batch_execute(self, circuits, execution_config)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\logging\decorators.py", line 61, in wrapper_entry
return func(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\default_qubit.py", line 630, in execute
return tuple(
^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\default_qubit.py", line 631, in
_simulate_wrapper(
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\default_qubit.py", line 918, in _simulate_wrapper
return simulate(circuit, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\logging\decorators.py", line 61, in wrapper_entry
return func(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\qubit\simulate.py", line 357, in simulate
state, is_state_batched = get_final_state(
^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\logging\decorators.py", line 61, in wrapper_entry
return func(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\qubit\simulate.py", line 190, in get_final_state
state = apply_operation(
^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\functools.py", line 909, in wrapper
return dispatch(args[0].class)(*args, **kw)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\qubit\apply_operation.py", line 231, in apply_operation
return _apply_operation_default(op, state, is_state_batched, debugger)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\qubit\apply_operation.py", line 241, in _apply_operation_default
return apply_operation_einsum(op, state, is_state_batched=is_state_batched)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\devices\qubit\apply_operation.py", line 80, in apply_operation_einsum
mat = op.matrix() + 0j
^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\operation.py", line 810, in matrix
canonical_matrix = self.compute_matrix(*self.parameters, **self.hyperparameters)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\ops\qubit\parametric_ops_single_qubit.py", line 308, in compute_matrix
return diags[:, :, np.newaxis] * qml.math.cast_like(qml.math.eye(2, like=diags), diags)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\math\utils.py", line 147, in cast_like
dtype = ar.to_numpy(tensor2).dtype.type
^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\autoray\autoray.py", line 1134, in to_numpy
return do("to_numpy", x)
^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\autoray\autoray.py", line 81, in do
return func(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^
File "D:\Program Files\Anaconda3\envs\torch\Lib\site-packages\pennylane\math\single_dispatch.py", line 540, in _to_numpy_torch
return x.detach().cpu().numpy()
^^^^^^^^^^^^^^^^^^^^^^^^
RuntimeError: Cannot access data pointer of Tensor that doesn't have storage

[CatalinaAlbornoz]

Hi @will-last , thanks for sharing your full error traceback.

From the error I can see that part of the process is being handled in the CPU while part of it is being handled on the GPU.

This seems similar to the error described in PennyLane Forum thread 4367. There you can see that the solution was to add .to("cuda") for the labels and .to("cpu") for the loss.

I noticed that you don't have .to("cpu") so this may be the cause for the issue. Let me know if this fixes the problem!

Edit: I noticed that this looks a lot like this PyTorch issue. So if using .to("cpu") doesn't fix the problem then this probably means that the cause is the issue with PyTorch 😢 .

[will-last]

Thanks your advice, I will try to find other solution.