typo

Author: mhjensen

doc/Programs/QuantumML/data/MNIST/raw/t10k-images-idx3-ubyte

@@ -0,0 +1,213 @@
+"""
+MIT License
+
+Copyright (c) 2020-present TorchQuantum Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+"""
+use 2 qubit to perform 4 class classification,
+We can choose four different observables to measure the qubit state:
+    1. XX
+    2. YY
+    3. ZZ
+    4. XY
+"""
+
+import torch
+import torch.nn.functional as F
+import torch.optim as optim
+import argparse
+
+import torchquantum as tq
+import torchquantum.functional as tqf
+
+from torchquantum.measurement import expval_joint_analytical
+
+from torchquantum.dataset import MNIST
+from torch.optim.lr_scheduler import CosineAnnealingLR
+
+import random
+import numpy as np
+
+
+class QFCModel(tq.QuantumModule):
+    class QLayer(tq.QuantumModule):
+        def __init__(self):
+            super().__init__()
+            self.n_wires = 2
+            self.random_layer = tq.RandomLayer(
+                n_ops=50, wires=list(range(self.n_wires))
+            )
+
+            # gates with trainable parameters
+            self.rx0 = tq.RX(has_params=True, trainable=True)
+            self.ry0 = tq.RY(has_params=True, trainable=True)
+            self.rz0 = tq.RZ(has_params=True, trainable=True)
+            self.crx0 = tq.CRX(has_params=True, trainable=True)
+
+        def forward(self, qdev: tq.QuantumDevice):
+            self.random_layer(qdev)
+
+            # some trainable gates (instantiated ahead of time)
+            self.rx0(qdev, wires=0)
+            self.ry0(qdev, wires=1)
+            self.rz0(qdev, wires=0)
+            self.crx0(qdev, wires=[0, 1])
+
+    def __init__(self):
+        super().__init__()
+        self.n_wires = 2
+        # the encoder here is just for illustration purpose, may not be the best choice
+        self.encoder = tq.GeneralEncoder(
+            tq.encoder_op_list_name_dict["2x8_rxryrzrxryrzrxry"]
+        )
+
+        self.q_layer = self.QLayer()
+
+    def forward(self, x, use_qiskit=False):
+        qdev = tq.QuantumDevice(
+            n_wires=self.n_wires, bsz=x.shape[0], device=x.device, record_op=True
+        )
+
+        bsz = x.shape[0]
+        x = F.avg_pool2d(x, 6).view(bsz, 16)
+
+        self.encoder(qdev, x)
+        self.q_layer(qdev)
+        obs_xx = expval_joint_analytical(qdev, "XX")
+        obs_yy = expval_joint_analytical(qdev, "YY")
+        obs_zz = expval_joint_analytical(qdev, "ZZ")
+        obs_xy = expval_joint_analytical(qdev, "XY")
+
+        x = torch.stack([obs_xx, obs_yy, obs_zz, obs_xy], dim=1)
+        x = F.log_softmax(x, dim=1)
+
+        return x
+
+
+def train(dataflow, model, device, optimizer):
+    for feed_dict in dataflow["train"]:
+        inputs = feed_dict["image"].to(device)
+        targets = feed_dict["digit"].to(device)
+
+        outputs = model(inputs)
+        loss = F.nll_loss(outputs, targets)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        print(f"loss: {loss.item()}", end="\r")
+
+
+def valid_test(dataflow, split, model, device, qiskit=False):
+    target_all = []
+    output_all = []
+    with torch.no_grad():
+        for feed_dict in dataflow[split]:
+            inputs = feed_dict["image"].to(device)
+            targets = feed_dict["digit"].to(device)
+
+            outputs = model(inputs, use_qiskit=qiskit)
+
+            target_all.append(targets)
+            output_all.append(outputs)
+        target_all = torch.cat(target_all, dim=0)
+        output_all = torch.cat(output_all, dim=0)
+
+    _, indices = output_all.topk(1, dim=1)
+    masks = indices.eq(target_all.view(-1, 1).expand_as(indices))
+    size = target_all.shape[0]
+    corrects = masks.sum().item()
+    accuracy = corrects / size
+    loss = F.nll_loss(output_all, target_all).item()
+
+    print(f"{split} set accuracy: {accuracy}")
+    print(f"{split} set loss: {loss}")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--static", action="store_true", help="compute with " "static mode"
+    )
+    parser.add_argument("--pdb", action="store_true", help="debug with pdb")
+    parser.add_argument(
+        "--wires-per-block", type=int, default=2, help="wires per block int static mode"
+    )
+    parser.add_argument(
+        "--epochs", type=int, default=5, help="number of training epochs"
+    )
+
+    args = parser.parse_args()
+
+    if args.pdb:
+        import pdb
+
+        pdb.set_trace()
+
+    seed = 0
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+
+    dataset = MNIST(
+        root="./mnist_data",
+        train_valid_split_ratio=[0.9, 0.1],
+        digits_of_interest=[0, 1, 2, 3],
+        n_test_samples=100,
+    )
+
+    dataflow = dict()
+
+    for split in dataset:
+        sampler = torch.utils.data.RandomSampler(dataset[split])
+        dataflow[split] = torch.utils.data.DataLoader(
+            dataset[split],
+            batch_size=256,
+            sampler=sampler,
+            num_workers=8,
+            pin_memory=True,
+        )
+
+    use_cuda = torch.cuda.is_available()
+    device = torch.device("cuda" if use_cuda else "cpu")
+
+    model = QFCModel().to(device)
+
+    n_epochs = args.epochs
+    optimizer = optim.Adam(model.parameters(), lr=5e-3, weight_decay=1e-4)
+    scheduler = CosineAnnealingLR(optimizer, T_max=n_epochs)
+
+    for epoch in range(1, n_epochs + 1):
+        # train
+        print(f"Epoch {epoch}:")
+        train(dataflow, model, device, optimizer)
+        print(optimizer.param_groups[0]["lr"])
+
+        # valid
+        valid_test(dataflow, "valid", model, device)
+        scheduler.step()
+
+    # test
+    valid_test(dataflow, "test", model, device, qiskit=False)
+
+
+if __name__ == "__main__":
+    main()

doc/Programs/QuantumML/data/MNIST/raw/t10k-images-idx3-ubyte.gz

@@ -0,0 +1,63 @@
+import torch
+import torchvision.transforms as transforms
+from torchvision import datasets
+from torch.utils.data import DataLoader
+import pennylane as qml
+
+# Load MNIST Dataset
+transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
+train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
+train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
+
+# Define Quantum Device
+dev = qml.device('default.qubit', wires=4)
+
+@qml.qnode(dev)
+def circuit(inputs):
+    # Encode classical data into quantum states
+    for i in range(len(inputs)):
+        qml.RY(inputs[i], wires=i)
+    
+    # Example: Apply some gates (you can modify this part)
+    qml.CNOT(wires=[0, 1])
+    qml.CNOT(wires=[2, 3])
+
+    return [qml.expval(qml.PauliZ(i)) for i in range(4)]
+
+class QuantumMLP(torch.nn.Module):
+    def __init__(self):
+        super(QuantumMLP, self).__init__()
+        self.fc1 = torch.nn.Linear(28 * 28, 128)  # Input layer to hidden layer
+        
+    def forward(self, x):
+        x = x.view(-1, 28 * 28)  # Flatten the input image
+        x = torch.relu(self.fc1(x))
+        
+        # Pass through the quantum circuit - adjust inputs accordingly.
+        outputs = []
+        for i in range(len(x)):
+            output = circuit(x[i].detach().numpy())
+            outputs.append(output)
+        
+        return torch.tensor(outputs)
+
+# Initialize Model and Optimizer
+model = QuantumMLP()
+optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+criterion = torch.nn.CrossEntropyLoss()
+
+# Training Loop
+for epoch in range(5):  # Number of epochs
+    for images, labels in train_loader:
+        optimizer.zero_grad()
+        
+        outputs = model(images.float())
+        
+        loss = criterion(outputs.view(-1), labels) 
+        loss.backward()
+        
+        optimizer.step()
+    
+    print(f'Epoch [{epoch+1}/5], Loss: {loss.item():.4f}')
+
+print("Training Complete")