TddPy

基于决策图的张量计算后端，特别适用于量子电路模拟。

TDD（张量网络决策图）的介绍可以在以下位置找到：

• 基于张量网络的量子电路表示决策图

安装

• 平台：Windows、Linux
• Python 版本：Python 3.9

pip3 install tddpy

TddPy 中的绘图方法依赖于 graphviz 包，无法自动安装。请在此处下载并手动安装。

TddPy 支持 CUDA 设备进行计算。要启用此功能，请在安装 TddPy 后按照说明进行操作：

• 需要NVIDIA CUDA Toolkit，安装包可以在这里下载。
• 卸载原始 CPU 版本 PyTorch

pip3 uninstall torch

• 安装对应的 CUDA 版本的 PyTorch

pip3 install torch --extra-index-url https://download.pytorch.org/whl/cu113

注意安装后，有时需要手动设置库路径。具体来说，库路径可以是：

.../anaconda3/lib
.../anaconda3/lib/python3.9/site-packages/torch/lib

文档

要写...

教程

TDD建设

在这里，我们将 CZ（受控 Z）门转换为 TDD，以 trival存储顺序，并输出图形图片。

import numpy as np
import tddpy

cz = np.array([[1., 0., 0., 0.],
               [0., 1., 0., 0.],
               [0., 0., 1., 0.],
               [0., 0., 0., -1.]]).reshape((2,2,2,2))

cz_tdd = tddpy.TDD.as_tensor(cz)
print(cz_tdd.numpy())
cz_tdd.show("cz_tdd")

指定存储顺序

然后我们尝试以配对存储顺序存储 CZ 门以获得更紧凑的 TDD。请注意，（张量，并行索引号，存储顺序）的元组作为参数传入。存储顺序只会影响 TDD 中的内部存储，而不影响表示的张量。

import numpy as np
import tddpy

cz = np.array([[1., 0., 0., 0.],
               [0., 1., 0., 0.],
               [0., 0., 1., 0.],
               [0., 0., 0., -1.]]).reshape((2,2,2,2))

cz_tdd = tddpy.TDD.as_tensor((cz, 0, [0,2,1,3]))
print(cz_tdd.numpy())
cz_tdd.show("cz_tdd_compact")

结果TDD是：

追踪

跟踪和收缩（tensordot）的接口与 Numpy 或 PyTorch 的接口几乎相同。例如，我们跟踪 CZ 的第二个和第三个索引：

import numpy as np
import tddpy

cz = np.array([[1., 0., 0., 0.],
               [0., 1., 0., 0.],
               [0., 0., 1., 0.],
               [0., 0., 0., -1.]]).reshape((2,2,2,2))

cz_tdd = tddpy.TDD.as_tensor((cz, 0, [0,2,1,3]))
res_trace = cz_tdd.trace([[1],[2]])
print(res_trace.numpy())
res_trace.show("cz_tdd_traced")

收缩

两个 CZ 门的连续应用导致身份门。这可以通过 TDD 形式的 CZ 张量的收缩来观察：

import numpy as np
import tddpy

cz = np.array([[1., 0., 0., 0.],
               [0., 1., 0., 0.],
               [0., 0., 1., 0.],
               [0., 0., 0., -1.]]).reshape((2,2,2,2))

cz_tdd = tddpy.TDD.as_tensor((cz, 0, [0,2,1,3]))
res_cont = tddpy.TDD.tensordot(cz_tdd, cz_tdd, [[2,3],[0,1]])
print(res_cont.numpy())
res_cont.show("cz_tdd_cont")

结果 TDD 是：

收缩的重排

TDD A和 B 的剩余指标在收缩后的重新排列，可以指定以获得更好的内部存储。在最后一个示例中，我们可以指定重新排列以获取配对存储顺序：

import numpy as np
import tddpy

cz = np.array([[1., 0., 0., 0.],
               [0., 1., 0., 0.],
               [0., 0., 1., 0.],
               [0., 0., 0., -1.]]).reshape((2,2,2,2))

cz_tdd = tddpy.TDD.as_tensor((cz, 0, [0,2,1,3]))
rearrangement = [True, False, True, False]
res_cont = tddpy.TDD.tensordot(cz_tdd, cz_tdd, [[2,3],[0,1]], rearrangement)
print(res_cont.numpy())
res_cont.show("cz_tdd_cont_rearranged")

结果将变得更加紧凑：

张量权重 TDD

对于相同图结构的 TDD，我们可以将它们“堆叠”在一起，得到张量权重 TDD。例如，下一个示例中的 TDD 表示张量 $$ [R_x(\theta_1)\R_x(\theta_2)\R_x(\theta_3)]。$$

import torch
import tddpy
from tddpy.CUDAcpl import quantum_circ

theta = torch.rand((3,), dtype = torch.double)
layer1 = quantum_circ.Rx(theta)
layer1_tdd = tddpy.TDD.as_tensor((layer1, 1, []))
print(layer1_tdd.numpy())
layer1_tdd.show("tensor_weight")

张量权重 TDD 看起来像

混合收缩

可以在标量权重或张量权重 TDD 之间进行收缩。例如，我们可以在多个 $R_x(\theta_i)$ 门（张量权重 TDD）之后应用 Hadamard 门（标量权重 TDD）。

import torch
import tddpy
from tddpy.CUDAcpl import quantum_circ

h_tdd = tddpy.TDD.as_tensor(quantum_circ.hadamard())
theta = torch.tensor([0.1, 0.2, 0.3], dtype = torch.double)
layer1 = quantum_circ.Rx(theta)
layer1_tdd = tddpy.TDD.as_tensor((layer1, 1, []))
res_cont = tddpy.TDD.tensordot(h_tdd, layer1_tdd, [[1],[0]])
print(res_cont.numpy())
res_cont.show("hybrid_cont_res")

结果看起来像

订单协调员

Order coordinator是 TDD 之上的一个额外设计，它提供了接口来指定存储顺序和重新排列的策略。它旨在用于张量网络框架中的自动收缩。

设置

tddpy 包的运行时设置可以通过方法调整

tddpy.reset(thread_num, device_cuda, dtype_double, eps, gc_check_period, vmem_limit_MB)

它指定并行线程数、张量权重计算设备、浮点数类型、浮点比较 EPS 和垃圾收集设置。

接触

如果您有任何问题，请随时联系lucianoxu@foxmail.com