Wolfram Language Paclet Repository
Community-contributed installable additions to the Wolfram Language
Quantum Machine Learning in Phase Space
Quantum Machine Learning in Phase Space
A quantum circuit is a tensor network, and a tensor network contraction is a sequence of array products - the computation a neural net performs. The framework closes that loop: a compiles to a tensor network, and contracts that network into a rather than an array, with every circuit tensor held in a . The circuit becomes the model. Nothing about the forward computation is assembled by hand; the only layer added here is the loss.
QuantumCircuitOperator
Wolfram`TensorNetworks`
The net framework computes over real numbers, and that is not an obstacle: in the phase-space picture a state is a Wigner quasi-probability vector and every circuit tensor is real, so the whole pipeline stays inside what a net can represent. This tutorial compiles a circuit to a net, differentiates through it, and trains a gate until gradient descent recovers a rotation angle.
In[1]:=
<<Wolfram`QuantumFramework`
A Circuit Is the Model
A Circuit Is the Model
A circuit can carry its own initial state, so the whole computation - prepare, then rotate - is one object:
In[2]:=
qc=
["0"],"RY"[0.7]
 | QuantumCircuitOperator |
 | QuantumState |
Its diagram shows the state feeding the gate:
In[3]:=
qc["Diagram"]
QuantumPhaseSpaceTransform
In[4]:=
ps=
[qc]
| QuantumPhaseSpaceTransform |
The Circuit as a Tensor Network
The Circuit as a Tensor Network
The property compiles the circuit into a network of one tensor per element. keeps the tensors in the phase-space frame, where they are real; without it, basis-change tensors in the computational frame enter and are complex:
"TensorNetwork"
"Computational"->False
In[5]:=
tn=ps["TensorNetwork","Computational"False]
The largest imaginary part across every entry of every tensor is exactly zero:
In[6]:=
Max[Max[Abs[Im[N[Flatten[Normal[#]]]]]]&/@TensorNetworkTensors[tn]]
The network is a graph, with the state and the gate as its two nodes:
In[7]:=
ps["TensorNetworkGraph","Computational"False]
Contracting to a Net
Contracting to a Net
Wolfram`TensorNetworks`
In[8]:=
path=GreedyContractionPath[tn]
TensorNetworkContraction
Method->"NetGraph"
In[9]:=
net=TensorNetworkContraction[tn,path,Method"NetGraph"]
The net takes no input and its output is the state the circuit produces, so running it gives the Wigner vector directly - no separate state extraction:
In[10]:=
net[]
That is the Wigner vector of the state an RY rotation by 0.7 produces from the initial one:
In[11]:=
ChopNormalN
[{Cos[0.35],Sin[0.35]}]["StateVector"]
| QuantumPhaseSpaceTransform |
 | QuantumState |
Because the net is a source net, it is also an array container: its shape reads off the output port with nothing evaluated:
In[12]:=
ArrayDimensions[net]
The Gate as a Trainable Parameter
The Gate as a Trainable Parameter
To train a gate rather than a state, compile the gate alone. With no initial state is attached, and the net's output is the gate's own phase-space kernel:
"PrependInitial"->False
In[13]:=
gate[theta_]:=Blockp=
[{"RY"[theta]}],t,t=p["TensorNetwork","Computational"False,"PrependInitial"False];TensorNetworkContraction[t,GreedyContractionPath[t],Method"NetGraph"];gate[0.7][]
| QuantumPhaseSpaceTransform |
| QuantumCircuitOperator |
The kernel is a rotation by the angle in its middle block, so the angle can be read straight off it:
In[14]:=
ArcTan@@Chop[gate[0.7][]]〚2,{2,3}〛
Learning the Angle
Learning the Angle
Take the circuit at 0.7 as the target and a circuit at 0 as the model. The only thing built by hand is the loss: the compiled circuit becomes one node of a net whose other node is a .
In[15]:=
target=gate[0.7][];lossNet=NetGraph["circuit"gate[0.],"loss"MeanAbsoluteLossLayer[],{"circuit"NetPort["loss","Input"],NetPort["Target"]NetPort["loss","Target"]}]
Compiling the circuit made the gate a learnable parameter of the net. It is the only one:
In[16]:=
Keys[Information[lossNet,"Arrays"]]
The target enters through an input port, and the loss comes out of an output port, which is all needs:
In[17]:=
Information[lossNet,"InputPorts"]
The model starts at the identity, an angle of zero:
In[18]:=
ArcTan@@Chop[Normal[NetExtract[lossNet,{"circuit","tensor","Array"}]]]〚2,{2,3}〛
In[19]:=
lossNet["Target"target]
Training is then ordinary : one example, the net's own port as the objective, and the gate array is what gets updated.
"Loss"
In[20]:=
trained=NetTrain[lossNet,"Target"{target},LossFunction"Loss",MaxTrainingRounds2000,TrainingProgressReportingNone];trained["Target"target]
Training through the compiled circuit recovered the rotation angle:
In[21]:=
ArcTan@@Chop[Normal[NetExtract[trained,{"circuit","tensor","Array"}]]]〚2,{2,3}〛
Details
Details
◼
"NetGraph"
Method
TensorNetworkContraction
Wolfram`TensorNetworks`$TensorNetworkContractionMethods
◼
A compiled circuit is a source net: no input ports, and an output port carrying the shape. That is what makes it an array container in the sense, and what lets it be a node inside a larger net.
Wolfram`Arrays`
◼
The gate array sits at in a gate-only circuit; a multi-tensor circuit names its leaves , and so on, which lists.
{"tensor","Array"}
"tensor1"
"tensor2"
NetExtract[net,All]
Possible Issues
Possible Issues
Without the compiled tensors carry basis-change factors from the computational frame and are complex, and complex arrays cannot be lifted into net layers, so the contraction names the offending tensor and fails:
"Computational"->False
In[22]:=
tnComputational=ps["TensorNetwork"];TensorNetworkContraction[tnComputational,GreedyContractionPath[tnComputational],Method"NetGraph"]
A contraction path belongs to the network it was derived from. That network has five tensors where the phase-space one has two, so reusing the earlier reports the arity mismatch before it ever reaches the complex tensors:
path
In[23]:=
TensorNetworkContraction[tnComputational,{{1,2}},Method"NetGraph"]
reports a final loss rather than an exact zero, so these are converged numbers rather than a closed form. The individual entries of the trained kernel are not stable between runs - they drift along a scaling that leaves their ratio fixed - while the angle read from that ratio is, which is why the angle is what the example reports.
Training a gate against a single input state does not determine it. The gate above is trained against its whole kernel, which pins every column; fitting only the circuit's output vector would leave the gate's action on the rest of the space free, and the recovered angle would mean nothing.
 |
|
 |
|
""