Comparative Analysis of Error Mitigation for Quantum Systems and Artificial Neural Networks Under Noisy Inputs
Advisor: Ms. Shahin
Internship Location: Google, 1600 Amphitheatre Pkwy, Mountain View, CA 94043
Onsite Mentor: Mr. Peng Xiang Li
Artificial Intelligence is increasingly vital to high-stakes industries like healthcare and finance, yet these systems often falter when processing the noisy, imperfect data found in real-world environments. While Convolutional Neural Networks (CNNs) are the standard for image classification, Quantum Neural Networks (QNNs) theoretically offer superior noise resilience through quantum properties such as superposition and entanglement. However, existing comparative research is often inconsistent, frequently pitting high-resolution classical models against hardware-limited, low-resolution quantum simulations. This research addresses that disparity by conducting a comparative analysis of error mitigation between QNNs and CNNs under Additive White Gaussian Noise (AWGN). My methodology involves developing three distinct models within TensorFlow Quantum using the MNIST dataset: a standard full-resolution CNN, a hybrid QNN, and a resolution-matched fair CNN to ensure a direct architectural comparison. All models will be trained on clean data and subsequently tested against noise-injected datasets to measure classification accuracy and loss. Through this research, I aim to quantify whether quantum architectures inherently outperform classical ones in signal-to-noise processing. Observing superior robustness in the QNN would validate the practical viability of quantum machine learning for critical applications where data integrity is compromised.
Project Blog
Week 0: It’s a Bit... It’s a Qubit... It’s a Computational Cage Match!
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!
Patrick Zhou, signing off.
Week 1: Building the Quantum and Classical Models
Welcome back to my senior project blog! If you read my Week 0 post, you know the mission: pit a quantum brain against a classical one and see which handles noisy data better. 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 28x28 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 4x4 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 4x4 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 4x4 input size is non-negotiable; scaling up to 28x28 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.
Patrick Zhou, signing off.
Week 2: The Speed Wall
Welcome back to my senior project blog! 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.
Week 3: My Qubits Can Count, Just Not to Ten
Welcome back to my senior project blog! Last week, I hit a major computational roadblock. I had to wait half of an entire day for the quantum simulations to finish. Oftentimes, they did not even work. However, I found my breakthrough with Amazon SageMaker. While I spent the final part of last week struggling with Google Colab's limitations, this week I decided to port my notebook to Amazon's machine learning platform: SageMaker. This gave me greater access to more powerful computational abilities. I had been spending hours training models on Colab, but now I could train models in only a fraction of that time. I could experiment, tweak, and retrain much more quickly than before, which is necessary for model development. With SageMaker, I could finally achieve what had been my goal for weeks: training all three models and getting preliminary accuracy numbers on the board.
I ran initial training jobs on all three of my models using the clean MNIST dataset from Keras. For the first time, I had actual figures to refer to. The full-resolution CNN was the strongest out of the three models, and this was honestly expected because it had the full 28x28 pixel images. To give you an idea of what this looks like, here's an example of the input the full CNN receives.
The fair CNN, my MLP running on the same 4x4 binarized input as the QNN, was less performant but still showed the ability of a simple classical neural network to squeeze a decent amount of data out of the compressed input. Here's what the compressed input looks like.
The QNN also produced its first accuracy figures. While the accuracy was nowhere near as good as the full CNN's, seeing the quantum circuit learning and improving its accuracy was still exciting. For the first time, my project was more like an actual experiment than a debugging exercise.
But then I got greedy. Feeling good about having working models, I wanted to try to push the limits. I tried to have the QNN classify all ten digits rather than just the simple subset the initial version was trained on. So, I reworked the output layer as well as the loss function and started the training. It was so painfully slow. While the new hardware Amazon SageMaker provides is great, every additional output class of the QNN means more parameters in the quantum circuit, more calculations using the parameter shift rule, and more simulated quantum operations. These simulated quantum operations stacked on top of one another and made the program extremely slow. I tried different learning rates and tweaked the number of entangling layers, but it was just too slow. By the time I realized the ten-class approach was not going to work, I had already wasted the better part of two days on it with very few results to show.
However, I am not discouraged by this setback because I believe that the preliminary results I achieved prior to the ten-digit experiment are promising. In the future, I'm planning to work on optimizing the quantum circuit architecture itself and exploring different combinations of quantum gates beyond just XX and ZZ. I want to see if reorganizing the quantum circuit can help increase the classification power of the same 16 qubits. Specifically, I aim to determine the sweet spot where I can confidently mitigate noise, which is the whole purpose of the project. Beyond that, I am also interested in exploring how the models can be applied to more meaningful datasets than just MNIST. While MNIST is a great benchmark, classifying handwritten digits does not fully capture the challenges of the noisy data that these systems would encounter in more practical applications, such as medical imaging and autonomous driving.
Week 4: The Dataset Dilemma
So, welcome back to another entry of my senior project blog! Last week ended on a pretty high note for me. After many days of frustration, I was finally able to get the ten-digit QNN classification working with Amazon SageMaker. I did this by optimizing batch sizes and being more aggressive with my learning rate schedule to make sure that my quantum circuit was able to converge before my patience gave in. Seeing all ten digit classes separate out in my predictions seemed like a small miracle to me. So, I was looking forward to continuing with more datasets in Week 4. But then, my datasets caused quite a lot of trouble.
After having MNIST in the bag, I was feeling quite confident with my project, so I decided to try to apply my project to some real-world problems beyond just recognizing handwritten digits. So, I decided to test my models out with something more challenging than MNIST. During the first half of this week, I was looking into using the Fashion MNIST dataset, which contains images of various clothing items such as shirts and shoes. I felt like replacing my MNIST data with this new, more complex set of visual data meant more.
The results were a disaster. The full CNN performed reasonably well with the Fashion-MNIST dataset and its full resolution images. However, the fair CNN and QNN plummeted. This was because compressing a t-shirt and a pullover into 16 pixels makes them almost indistinguishable. The loss of information was fine for the digit dataset but disastrous for clothing items with only subtle visual differences. My QNN was basically guessing.
I tried different binarization thresholds and only used visually distinct classes, such as distinguishing between shoes and bags. However, even these simple two-class problems were not reliable. After two days of failed experiments, I gave up and accepted that my 4x4 input resolution was a hard constraint dictated by the limits of quantum simulation. It was simply not capable of capturing enough information to classify more complex images. MNIST worked because of the simplicity of the digit images. Fashion-MNIST did not.
So, I made a decision. I'm temporarily abandoning the Fashion-MNIST dataset and going back to MNIST. But, I might search for some more datasets of traffic lights to experiment with. Looking back, my experiment was never about Fashion-MNIST anyways, it was more about determining whether quantum computing's properties provide noise resilience. I can still do this experiment with sufficient rigor using other datasets.
Next week, I'm also ready for more in-depth noise injection. Stay tuned.
Patrick Zhou, signing off.
Week 5: Traffic Lights
Welcome back to my blog! If you remember, last week concluded with me going back to the MNIST dataset after my disastrous attempt at working with the Fashion-MNIST dataset. I was talking about how I might consider working with traffic light datasets as something that might be more useful on a practical level. So, this week I'm glad to report that I did find a dataset that is more practical. The dataset is called the Bosch Small Traffic Lights Dataset, or BSTLD. This dataset is composed of many images of traffic lights taken by dashcams in real-world driving situations. I preprocessed these images the same way I did for the MNIST dataset, binarizing them and downscaling them to 4x4 resolution for the fair CNN and QNN. In doing this, I was able to successfully train all of my models as classifiers to determine whether an image was a red light or a green light. Unlike clothing items in the Fashion-MNIST dataset, there is now enough visual distinction in color, position and brightness distribution between red and green lights that even 16 pixels of resolution is enough to highlight this difference.
The results were quite exciting. After training all of my models on my new dataset, I was able to run noisy versions of my images of traffic lights through all of my models. The QNN was able to achieve better classification accuracy than my fair CNN in the classification of the noisy images. This is the first practical experiment in which I've been able to provide concrete proof of the quantum architecture's advantage in the real world. On a separate note, this week I also tested out a different noise injection algorithm called Binarized Gaussian Noise. It basically works by forcing every pixel to snap to pure black or pure white instead of anything in between. This will not show in the noisy images that I have displayed below because the binarization happens only right before the QNN and fair CNN actually evaluate the images. This is different from my previous approach of Additive White Gaussian Noise (AWGN). Here is a graph showing how my QNN compares to my fair CNN in classification accuracy of noisy traffic light images.
To give you a better idea of what these models were actually looking at, here is a comparison of clean traffic light samples and their corresponding noisy samples after Binarized Gaussian Noise is applied. As you can see, some features that a classical model may have relied on are obscured in the noisy samples, which is why I hypothesized that this quantum model would handle them better.
I think this week has been a turning point for my entire project. After weeks of debugging, server migrations, and slow quantum simulations, I have finally tested my theory on some actual data that points towards answering my original research question. While the BSTLD results do not necessarily prove anything alone, I think combined with my previous experiments with Noisy MNIST, I am seeing patterns that point towards a definitive advantage for the quantum architecture. Next week, I will compile all of this data into my final paper. I will also continue to work on more experiments and variations of quantum circuits. I will see you then!
Patrick Zhou, signing off.
Week 6: Ctrl+Z on the ZX Gates
Welcome back to my senior project blog! Last week, I had an amazing breakthrough on the traffic light dataset, so I had a lot of momentum going into this week. I had decided I was going to test different quantum circuit architectures to see if I could further improve the noise resistance of the QNN. I tried switching up the XX and ZZ entangling gates for other combinations like ZX, YY, and some other combinations I came across in some of the latest research on variational quantum circuits. I was hoping that different gate combinations could pick up on different correlations in the data, potentially further increasing the accuracy. Unfortunately, none of them really worked. Some of them did not converge at all. The loss simply plateaued right off the bat, and the model just started spitting out completely random predictions no matter what I did in terms of the learning rate or the number of entangling layers. One of them was working well for a little while but ultimately just started classifying every instance as the same class, which is called barren plateaus, where the gradients in the quantum circuits are so small that the model is essentially just stuck. I spent three days trying different combinations, watching training after training fail, which was really disappointing after last week's high.
Rather than continuing to throw circuit designs against the wall and hoping one sticks, I've decided to refocus my efforts on really making significant headway on my research paper. I've already been putting together pieces of my paper over the past week or so, but this week I've had a chance to sit down and really flesh out my introduction section now that I have hard data for both my MNIST and BSTLD experiments. Writing out my ideas forced me to really think critically about all of my design choices, from why my original XX and ZZ gate combination worked while all my other attempts didn't to why my 4x4 binarization threshold is important. I have to say, I've come to realize that while my design choices were probably good ones instinctively while I was writing my code, I really need to be able to justify those choices on paper. I've also had a chance to organize my accuracy and loss graphs, which has really given me a sense for the overall story my data is trying to tell. While my recent attempts at designing new circuits were unsuccessful, analyzing these runs for the paper has given me a much clearer direction for my next wave of testing. This is far from the end of my experimental phase. After Spring Break, I'll be diving right back into a new series of targeted experiments using these fresh insights, while continuing to refine my paper in parallel. Stay tuned!
Patrick Zhou, signing off.
Week 7: The Noise Sweep
And here we are with a new entry in the series, right back from my Spring Break hiatus! The looming deadline for the final exhibition of this senior project looms far closer than I would like to admit at the moment. After trying to implement my very own fancy quantum circuit right up until the spring break started, and failing miserably, I decided to take a step back and start experimenting with putting external stress on my QNN instead of tinkering with the circuit design. So far, I've only been running simulations where the QNN and fair classical model compete in the face of a single level of AWGN noise. While that was enough to convince me that my hypothesis was correct, the true proof would come from watching the classical system fail as the noise increases.
For this week's simulation run, I created a noise sweep test on Amazon SageMaker that progressively adds noise multipliers to the image of my traffic lights, starting from the slightest amount of fuzz all the way up to a full-blown whiteout of static on each of the images in my dataset, and then I ran those images through both networks. And guess what? Just as I hoped, the results showed a clear superiority of the quantum model even without any additional fancy modifications. At low noise levels, the QNN performed about the same as the fair CNN. However, once the noise multiplier grew above 3 or so, the performance of the classical model tanked, as the algorithm could no longer tell apart red from green because the pixel core got so corrupted by the added noise. On the contrary, the QNN degraded gracefully thanks to the fact that, since the qubits are entangled, they seem to evaluate the connection between all four pixels within the traffic light in their classification decision.
With this great progress made, my next task will be learning how to distill all these quantum physics equations into plain text for the discussion section of my research paper. Until next time!
Patrick Zhou, signing off.
Week 8: Frontend Magic, Backend Data
I must say, the euphoria of finally seeing your work compile successfully is pretty amazing, but sooner or later you have to step back from the coding process and actually explain it. Welcome back to my senior project week 8! I finally hung up the coder's hat and donned the author's hat. After experiencing a few adrenaline rushes during last week's noise sweep experiment runs, I found myself staring at a blinking cursor with the task of actually writing a full-fledged research paper based on my results. Even though my results' discussion and conclusion are not ready yet as I'm still processing the final batch of data, I've managed to do quite a bit of writing this week. First, I outlined my document in meticulous detail. Then, I carefully formatted my bibliography according to the ACS style guidelines. Finally, I edited both the Introduction and the Methodology chapters, so now I can proceed with my paper once I receive the final set of results.
While working on my paper, I realized one thing, there is no one other than researchers within my area of expertise who will want to look at a web page of nothing but raw TensorFlow code and console output screenshots. As the date of my senior capstone exhibition comes closer, it is time to stop caring about the process of creating models and start thinking hard about their audience reception. I need some sort of tangible way of presenting my theory to my potential readers. I decided I need an application which would allow me to show people first-hand the discrepancy in resistance of my models against static.
I have begun sketching the design of the website which would be used for my final demonstration. The main goal is to create an interface which would feature a slider where the audience would have to increase the Additive White Gaussian Noise (AWGN). As the level of static increases, graphs depicting my classical and quantum models' behavior against the same exact static level would appear on my website screen. The viewer would experience firsthand the moment when the classical architecture fails while the quantum one stays stable and accurate. Besides this interactive website, I have been pondering over the layout of my physical exhibition poster, considering ways of including the architectural diagram of my quantum gates and the underlying logic behind them.
Patrick Zhou, signing off.
Week 9: Lifting the Paper Weight
Hi everyone and welcome to Week 9 of my senior project blog! This entire week has been spent working on scientific communication. I drafted the full research paper, which was as mentally taxing as debugging my quantum circuits. I used the noise sweep experiment results to draw conclusions using principles of entanglement and superposition, and made sure to explain the theoretical advantages of quantum neural networks without overusing complex TensorFlow codes. The majority of my time was actually spent aligning my references to perfection, in ACS format, and trying to fix the problem of not having enough bolded years or italicized volume numbers.
As soon as the paper was done, I started planning out visuals for my Senior Project Exhibition. Transforming a large scientific paper into an attractive poster and a compelling presentation involves many different challenges. I decided to start with designing my poster and its hierarchy. I put the circuit architecture side by side with a graph of the model breaking down under Additive White Gaussian Noise: a visual contrast intended to help my audience grasp my argument. In parallel, I started outlining my presentation slides so that I could tell a clear story from my eureka moment about how qubits are disrupting cryptography and leading to accurate traffic light classification models.
Doing all this work, an even bigger revelation came to me: Commit Day is coming on Friday! It's crazy how, while discussing the future of quantum computing, I'm about to finalize my own plans for college. It's incredible how close we are to graduation, and working on this project makes me realize how everything is ending. This process is pretty emotional, but it's amazing how everything is falling into place. Next week, I'm going to concentrate on rehearsing my speech and finishing the last touches of my interactive web app demo.
Patrick Zhou, signing off.
Week 10: Pixels and Practice
Hello, and welcome back to Week 10 of my senior project blog! With Commit Day finally behind me, a huge weight has been lifted off my shoulders, and I now have the freedom to focus fully on preparing for my capstone exhibition. This week's major victory has definitely been completing my presentation slides, and the primary hurdle I had to overcome has been ensuring that I don't bore my audience to death with dry TensorFlow metrics and technicalities. Instead, I decided to craft a compelling narrative: a story of classical AI's inability to cope with the chaos inherent to real-life data, such as blurry dashcam footage, and how QNN entanglement acts as a natural buffer against errors.
While crafting my presentation, I have also been busy working on my exhibition poster. I am almost finished with it, but one final element still needs some work. At the moment, I find myself struggling immensely with the visual hierarchy, specifically placing two contrasting sets of clear, static-filled traffic light images precisely next to the degradation curves to highlight the difference in performance between my QNN and its classical counterpart. With only a couple more tweaks to the poster design, it'll be ready for printing.
I worked hard to make sure my visual deliverables look great. However, the true horror of capstone presentations is finally dawning on me. I actually have to verbalize and explain all of this content within a limited time to a live audience. While playing with circuit designs in Google Colab is certainly much more relaxing than presenting them aloud, I will be doing the latter next week.
Patrick Zhou, signing off.