The Senior Project is an independent, student-led culmination of our high school experience. After three years of academic preparation, our seniors are ready to spend the last trimester of their high school careers applying the skills and knowledge they have gained to develop a project that is insightful, academically rigorous, and professional in nature. This year, we are proud to showcase a senior from one of our neighboring campuses, BASIS Independent Fremont, Patrick Z.

Week 0: It’s a Bit… It’s a Qubit… It’s a Computational Cage Math!

Hi everyone! My name is Patrick Zhou, and welcome to the very first entry of my Senior Project blog. Over the next few months, I invite you to join me as I dive into the complex and often invisible war between classical computing and the emerging frontier of quantum mechanics. My project, formally titled Comparative Analysis of Error Mitigation for Quantum Systems and Artificial Neural Networks under Additive White Gaussian Noise, is a bit of a mouthful, but the core mission is actually quite simple: I want to find out if a quantum brain is sturdier than a classical one when the world gets messy.

My journey into this high-tech rabbit hole didn’t actually start with a love for physics, but rather through a study of cybersecurity and encryption. It was during a high school class on qubits that I had a sudden, slightly frightening realization: quantum algorithms have the theoretical power to render our existing security measures obsolete. That fear quickly turned into fascination. I needed to understand the future of computation before it arrived, which led me to a summer research program at UCSB where I coded my first quantum circuits using Python and Qiskit. Now, I am systematically expanding that experience to answer a burning question about how these systems handle noise.

In the context of machine learning, noise isn’t just loud sounds; it’s static, corruption, and interference that ruins data. Think of a grainy photo taken in low light or a fuzzy MRI scan. Classical Convolutional Neural Networks (CNNs), the kind of AI currently running on your phone, are great at reading clean data, but they often stumble when the picture gets blurry. My project pits these classical networks against a Quantum Neural Network (QNN). The theory is that quantum properties like superposition (being in two states at once) and entanglement (where parts of the system are linked across space) might allow the QNN to see the big picture better than a classical computer, making it more robust against errors.

To test this, I am designing a computational cage match. I will be building three distinct models: a standard high-resolution CNN, a fair low-resolution CNN, and a hybrid QNN. I will first train all three on the famous MNIST dataset, essentially the Hello World of machine learning consisting of handwritten digits, and then bombard them with Additive White Gaussian Noise. By forcing both the classical and quantum models to look at low-quality, pixelated inputs, I aim to level the playing field. This ensures that if the quantum model wins, it’s not because it had superior data, but because its architecture is genuinely smarter at filling in the gaps.

This matters because the real world is rarely noise-free. From autonomous vehicles driving through rain to financial algorithms parsing corrupted data, we need AI that doesn’t break when conditions aren’t perfect. If my research shows that QNNs are naturally more resilient to noise, it could validate the theoretical benefits of quantum computing for industries like healthcare and defense. I have a long road of coding in Google Colab ahead of me, complete with the challenges of simulating quantum hardware on classical machines, but I am ready to see if the future of AI really is quantum. Stay tuned for the results!

Week 1: Building the Quantum and Classical Models

This week, the theoretical planning phase ended and the real construction began. I spent the bulk of my time in Google Colab building the three neural network models that will eventually go head-to-head, and I quickly learned that designing an experiment on paper is a very different beast from wiring it up in code.

The first model I tackled was the full-resolution CNN, which is the heavyweight of this experiment. This is a LeNet-style Convolutional Neural Network that takes in the full 28×28 pixel MNIST images, meaning it gets to see every detail of each handwritten digit. I built it with two convolutional layers, pooling layers to compress the spatial information, and dropout layers to prevent overfitting, which is essentially when a model memorizes the training data instead of actually learning patterns. Getting this one up and running was the smoothest part of the week because classical CNNs are extremely well-documented and the TensorFlow library makes the architecture almost plug-and-play. Think of this model as the student who gets to read the textbook with perfect lighting and a magnifying glass; it has every advantage in terms of input quality, and it will serve as my performance ceiling.

The second model, the fair CNN, was where things got more conceptually interesting. This is a much simpler Multi-Layer Perceptron with just one hidden layer, and the critical twist is that it only receives 4×4 pixel binarized images, the exact same degraded input that the quantum model will see. I talked in my last post about how previous studies comparing QNNs and CNNs often gave the classical model a full high-definition image while the quantum model worked with a pixelated thumbnail, which is hardly a fair fight. This fair CNN is my solution to that problem. By stripping the classical model down to the same resolution, I am isolating the variable of architecture itself. If the quantum model outperforms this one, it won’t be because of an unfair data advantage; it will be because the quantum design is genuinely better at extracting meaning from limited information.

The third and most challenging model is the QNN, the hybrid quantum-classical network that sits at the heart of this entire experiment. Building it required me to dive into TensorFlow Quantum, which is a framework that lets you design quantum circuits and integrate them into a standard machine learning pipeline. The idea is to take each 4×4 binarized image and encode it onto 16 qubits, where each pixel maps to one qubit. From there, a Parameterized Quantum Circuit uses XX and ZZ entangling gates to create correlations between the qubits, theoretically allowing the model to capture global patterns in the data that a classical network might miss. If superposition lets each qubit exist in multiple states at once and entanglement links those states together, then in theory this circuit should be able to see relationships across the entire image simultaneously rather than scanning it piece by piece. In practice, however, setting up the circuit encoding and making sure the data pipeline correctly binarizes and maps each image to the quantum layer took a significant chunk of my week and a lot of debugging.

The biggest challenge I ran into this week was honestly just the sheer difference in workflow between classical and quantum model building. With the classical CNNs, errors were usually straightforward: a mismatched tensor shape here, a wrong activation function there. With the QNN, debugging felt like navigating in the dark because the abstraction layer between the quantum circuit and the classical optimizer made it harder to pinpoint where things were going wrong. I also had a minor scare when I realized how long even a simple quantum simulation takes on a classical machine, which is a reminder that I am not running on an actual quantum computer but rather simulating one, and that simulation cost grows fast. This is why the 4×4 input size is non-negotiable; scaling up to 28×28 would require 784 qubits and an astronomical runtime that my laptop and Google Colab would simply refuse to handle.

Looking ahead to next week, my goal is to finalize the architecture of all three models and begin the training phase on the clean MNIST dataset. I plan to train each model for 10 epochs and start logging the baseline accuracy and loss metrics before any noise is introduced. If all goes well, by the end of next week I will have three trained models sitting in my notebook, ready to be thrown into the noisy gauntlet. Stay tuned for the results, and wish my qubits luck.

Week 2: The Speed Wall

Last week I finished constructing all three models and was eager to jump straight into the training phase. My plan was to start with the QNN first since it is the most complex and unpredictable of the three, get it working well, and then breeze through the two classical CNNs afterward. That plan sounded great on paper. In practice, the quantum model decided to humble me.

When I first attempted to train the QNN on the full 10-digit MNIST classification task, the accuracy was, to put it politely, rough. The model was struggling to meaningfully distinguish between all ten digit classes when each image is compressed down to a 4×4 binarized grid mapped onto 16 qubits. The loss curves were not converging the way I needed them to, and the predictions felt almost random for several of the digit classes. This was not entirely shocking given how much information is lost when you crush a handwritten digit into 16 binary pixels, but it still meant I could not just accept the results and move on. I started experimenting with adjustments to the circuit, tweaking the number of entangling layers, adjusting the learning rate, and modifying how the Parameter Shift Rule interacts with the optimizer to update the quantum circuit’s trainable parameters.

Here is where the real problem hit. Every single one of those adjustments requires retraining the model from scratch, and each training run on the QNN is agonizingly slow. The fundamental issue is that I am simulating a quantum computer on classical hardware, so every quantum gate operation, every state vector update, and every gradient calculation has to be brute-forced through classical linear algebra. A single epoch takes orders of magnitude longer than it would for either CNN. When I was just building and testing the circuit with small batches during Week 1, the slowness was manageable. Now that I am trying to iterate rapidly on a real training set, each failed experiment costs me hours of waiting. I would tweak a hyperparameter, start a run, watch a progress bar crawl, and then discover the change did not help. That debugging loop I described last week is exponentially more painful when every attempt takes half a day to evaluate.

Because of this bottleneck, I have not yet trained the two classical CNNs either. There is no point in collecting their baseline numbers until I have a QNN that actually works well enough to make the comparison meaningful, and I cannot get the QNN to that point when every iteration takes this long. The solution I am currently pursuing is procuring access to a faster server. Google Colab, even with GPU acceleration, is not cutting it for the volume of quantum simulation I need. I have been working on getting access to a more powerful machine that can handle the computational overhead more efficiently, compressing those multi-hour runs into something manageable so I can actually iterate at a reasonable pace.

Despite the frustration, this week has been a grounding reminder of why the quantum computing field is pouring billions into building real quantum hardware. Simulating even 16 qubits at scale already pushes classical machines to their limits. Next week, I am hoping to have the new server set up so I can break through this wall and finally get all three models trained on clean data. Stay tuned.

BASIS Independent Dublin is a Grades 6 – 12 private school, providing students with an internationally benchmarked liberal arts and sciences curriculum, with advanced STEM offerings. Considering joining the BASIS Independent Dublin community? To join our interest list for the next school year and receive admissions updates and more, please click here.