The Python Podcast.__init__

Share on social media:

[00:00:12] Unknown:

Hello, and welcome to podcast dot in it, the podcast about Python and the people who make it great. When you're ready to launch your next app or want to try a project you hear about on the show, you'll need somewhere to deploy it. So take a look at our friends over at Linode. With 200 gigabit in private networking, node balancers, a 40 gigabit public network, fast object storage, and a brand new managed Kubernetes platform, all controlled by a convenient API, you've got everything you need to scale up. And for your tasks that need fast computation, such as training machine learning models or running your CI and CD pipelines, they've got dedicated CPU and GPU instances.   Go to python podcast.com/linode,   that's l I n o d e, today to get a $20 credit and launch a new server in under a minute. And And don't forget to thank them for their continued support of this show.  

As a developer, maintaining a state of flow is key to your productivity.   Don't let something as simple as the wrong function ruin your day. Kite is the smartest completions engine available for Python, featuring a machine learning model trained by the brightest stars of GitHub.   Featuring ranked suggestions sorted by relevance, offering up to full lines of code, and a program in Copilot that offers up the documentation you need right when you need it.   Get Kite for free today at getkite.com   with integrations for top editors, including Atom, Versus Code, PyCharm, Spyder, Vim, and Sublime.   And you listen to this show to learn and stay up to date with the ways that Python is being used, including the latest in machine learning and data analysis.  

For even more opportunities to meet, listen, and learn from your peers, you don't want to miss out on this year's conference season.   We have partnered with organizations such as O'Reilly Media, Corinium Global Intelligence,   ODSC,   and Data Council.   Upcoming events include PyCon US in Pittsburgh.   Go to python podcast.com/conferences   to learn more about these and other events and take advantage of our partner discounts to save money when you register today. Your host as usual is Tobias Macy. And today, I'm interviewing Josh Isaac about how the work that he is doing at Xanadu AI to make it easier to build applications for quantum processors.   So, Josh, can you start by introducing yourself?  



[00:02:15] Unknown:

Sure. Okay. So I'm a, quantum physicist by trade. I spent a while at university, so I spent about 8 years at universities doing bachelor's in physics, then a PhD in quantum physics, and got my PhD in quantum computation.   And I finished at maybe the perfect time to finish a PhD in quantum computation industry because as soon as I finished, we had this version in quantum computing industry take off. You had huge,   companies like Google and IBM investing in quantum computing, and you also have this amazing new startup ecosystem where really innovative stuff is being done both on the hardware and software side. So almost as soon as finishing my PhD in quantum computation in Australia,   I, received a job offer to work at Zadu AI in   quantum computing and more specifically,   quantum software and quantum programming.  



[00:03:00] Unknown:

And so can you start by giving a bit of an overview for people who aren't familiar with it? Just some of the differences   in terms of the computational model that they should be thinking about when working with quantum processors as opposed to the classical systems systems that they're used to with their day to day? Okay. Sure. So quantum computing is it's a very, very, very different paradigm compared to classical computing.  

[00:03:23] Unknown:

So it's kind of underlied by the fact that in quantum computing,   we're doing something that is driven by a completely different,   set of physical laws. So we're working in the quantum regime   and in the quantum regime, things don't work quite as nicely as they tend to do in class. Coding. So simple things such as being able to copy and paste, which we can do on our PCs quite easily. This is something that can't be done in quantum computing, quantum mechanics. We have, no cloning theorem, which essentially says that if you have a quantum state, it's   not theoretically possible to make a perfect copy of that quantum state. So there are lots of,   large differences that you need to consider when working with quantum computing. As the industry has grown,   quantum computing,   especially, it's been seen as a bit of accelerator devices similar to how you would work with, GPUs and,   TPUs and ASICs and FPGAs.  

You don't tend to   think of a quantum computer as replacing classical computers completely. But there are certain algorithms that quantum computers are better at just because we're able to harness these rules and these, properties of quantum systems that allows them to enhance different algorithms in ways that we couldn't do classically. So you can always think of them as a,   accelerator for specific applications. So while most of your work in the future will still likely be done in the classical computer,   we should be able to outsource some specific time consuming algorithms to a quantum processing unit or a QPU, similarly to what we do with GPUs. Yeah. I've definitely heard it spoken about in that similar terms of thinking about it as a co processor rather than something that you're going to be developing a full blown application for. Yep. Exactly. So I think even even today, if you look online, there are people trying to envision what this quantum future looks like. And you hear things being thrown around like quantum operating systems, but that's definitely,   not in the space we currently are in. They're definitely devices that have very specific use cases at the moment and very specific algorithms we know they're best at.  



[00:05:16] Unknown:

And so can you give a bit of an overview about the approach that Xanadu is taking and some   of the hardware that you're building because I know that rather than working with the cubits that have become popularized with some of the other,   hardware that people are building. When I was looking through and preparing for this interview, I noticed that you're using quantum photonics, which is a different approach and has different use cases that it's prioritized for. So I'm wondering if you can just give a bit of an overview of that and some of the differences in the programming model for people who have done any work or done any research into programming for the qubit model? Okay. So as you as you know, we we do take a bit of a different approach here at Zaldu. So something that's become,  

[00:06:00] Unknown:

quite,   ubiquitous in quantum computing have been superconducting qubits. And,   that that's partly due to a lot of research done in the early 2000, mid 2000 by universities   trying to really amp up these superconducting   qubits and make them a scalable platform for quantum computing.   At the same time so there's a lot of hype and resources placed behind superconducting cubits. At the same time, there are a whole bunch of different quantum systems that also have shown a huge amount of,   a huge amount of potential for quantum computing.   So you have the standard superconducting cubits. You also have, trapped ions,   which have other pros and cons compared to superconducting cubits. So with trapped ions, you're taking,   ions and you're trapping them in a vacuum chamber, and then you're interacting them to perform these quantum,   computations.  

So compared to superconducting cubits, trapped ions can be they can have a significantly high fidelity,   so reduced error rate. At the same time, there are also cons compared to superconducting cubits. So the time required to perform the quantum operations is slightly longer with trapped ions   than with superconducting qubits. So you have these huge number of arrays of different potential,   hardware devices that can be used. Hardware systems can be leveraged for quantum computing.   The 1 that we're working with Xandr is quantum photonics. Quantum photonics is something that's been used a lot in it's been researched a lot in universities.   Huge number of research groups across the world in Europe and North America are working with quantum photonics.  

It hasn't   received as much interest so far as superconducting qubits, but it definitely has proxies that makes it very nice to use for in terms of scalability for quantum computing. So in particular with quantum photonics, what we're doing is we're leveraging off the rack quantum optics hardware, which is available far and wide due to its use in,   electronic systems. We're leveraging stuff like quantum lasers.   Like sorry. Just lasers. And the cool thing about lasers is they were created they've got quite a long history created in the fifties. We're able to   tune laser light and   really,   manipulate the quantum properties   of the optical light coming out of, lasers. And the really nice thing about quantum optics in this approach is that if you look at superconducting cubits, while   really maturing in terms of quantum technologies,   The issue with superconducting   qubits is that we tend to require   very, very low temperatures in order to get the superconducting property that allows us to use these quantum effects for quantum computation. With quantum photonics,   we're actually able to work room temperature. So as I was saying with trapped ions, there are definitely   pros and cons of these different quantum approaches.  

Photonics has this nice ability where we can use it at room temperature.   It also has other nice abilities in there. If you look outside of quantum computing, we have huge infrastructures already in the world using optics.   So things like fiber optics for communications,   things like that. Optics are very pervasive in the world.   So a really nice advantage with quantum photonics is that we're able to interface these classical systems that are already using optics with our quantum devices.   So it's very easy to couple   in a fiber optic cable with classical information into our quantum devices. So, maybe I can run you through what our actual hardware   infrastructure looks like at Xanadu. Yeah. That would be great. As Xanadu, we're using,   I mentioned this previously, but we're using lasers as our source of,   as our quantum resource. So the lasers are generating   coherent light. With these lasers, what we're then doing is we're squeezing the slate.  

So, something some people might be familiar with is the quantum uncertainty principle. In the quantum uncertainty principle, what we're saying is that, most quantum systems have various properties that we can observe, but we can never observe multiple properties at the same time with a very high degree of accuracy. There's always a bit of a trade off. So it's something that's often used to explain this is at a very high level. If you have a car driving down the highway, sort of analogous to this   uncertainty principle is you can know the position of the car or you can know the speed or the momentum of the car with a very high degree of accuracy, but you can never know both the same time. So this is 1 of those very standard,   effects that we try and use in quantum mechanics, but quantum computation, the Heisenberg uncertainty principle. 1 of the things we do at XANA do is we take this laser light, and we perform the squeezing operation. What the squeezing operation does is it places the light into a minimum uncertainty.  

So when we squeeze the light, we're making it a very, very useful quantum resource, and we're able to very,   precisely know its properties in sort of 1 quadrature of the light. But at the same time, in different quadratures of the light, we suddenly have a very high degree of uncertainty as to what's,   what state of the license is in. So for us, squeeze light is very, very important. It's 1 of our key resources for our quantum systems. So a a huge, part of what we do as Andrew has been working on very efficiently taking this laser light and   squeezing it to make a a quantum resource that we can use for quantum computation. So that's sort of the first process. We take the laser light. We squeeze the laser light. And, key to what we're doing is we're squeezing this laser light on chip. So we're taking the slides and rather than doing it in bulk optics. So I think if if you go to universities and you go to research labs, you'll see these huge optical tables with lenses and fiber optics spread across. This is typically how light is squeezed in the lab. What we're doing is significantly different and that we're trying to do this on a miniature optical chip. So this is something that hasn't really been done before. We're really pushing the technology in terms of doing on chip squeezing, which is what it's called. So the hardware team released a paper last year that talked about the technical achievements we've managed to make so far it sounded in terms of squeezing the sleigh's lights on chip. So that's really a huge part of the process, taking the sleigh's lights, squeezing it. And by doing that, we make a quantum resource that we can then manipulate.  

The next step is actually what happens on the chip. So we have these miniaturized optical chips, laser lice coupled to it, the laser light squeezed, and then once it's squeezed, we have various gates on this miniaturized optical chip.   These gates are things that are common in photonic systems like beam splinters and rotations.   Essentially, what these gates do is they take these, input squeeze light sources, and they entangle them. So the light is,   entangled and manipulated across the chip, and this is completely programmable.   So this is where the core of the quantum algorithm happens.  

The gates that are applied to the squeeze light sources on chip. Once the,   once all the gates have been applied on the chip, the light sources are measured at the end of the chip. So at this point, we're doing quantum photon number resolving detectors. So we actually got very high precision detectors taking the light off the chip and measuring how many photons are detected in each mode on the chip. So that's a very high level rundown of what the architecture looks like from a hardware point of view. And so for being able to write software and algorithms to take advantage of these  

[00:12:58] Unknown:

What are some what are some of the underlying principles that are necessary for developers to understand in terms of the actual   quantum mechanical aspects? And what are some of the software layers that you're building up to provide abstractions for people who don't have a PhD in quantum photonics to be able to  

[00:13:25] Unknown:

it so different from the qubit system is that when you're working with superconducting qubits or trapped ions and you're working with qubits, essentially, your each qubit has 2 states. It can be it can be in the grand state, the 0 states, or the excited states or sometimes called the 1 states. With quantum photonics,   we're working with a fundamentally different possible. We're working with photons rather than electrons or ions. And when you're working with photons, we have this proxy where you can have more than 1,   state per laser waveguide, per optical waveguide. So, essentially, the detectors that we have coming off the chip, if this was a a cubit system, each detector would be able to measure at most 0 or 1. But working with photons, we can have 0 photons coming off 1 waveguide, 1 photon, 2 photons, 3 photons, etcetera. And we can keep going as high as   our detectors have the ability to resolve, which I think is somewhere around, like, 14 or 15 photons. By that point, it gets trickier from a hardware point of view to say how many photons have been detected. But that's 1 of the key differences.  

And the reason this is such a key difference is because we essentially have we could even have as many photos as you want promote. So there's the potential to scale up to it. Very, very large number of photons. It allows us to do this mathematical trick where we can take the system and rather looking at it from a discrete point of view, so we can say,   oh, that's 7 photons here or 10 photons here. We can actually do a transformation and view this in a continuous   reference point, a continuous point of view. So rather than describing the system in terms of how many photons are, measure each detector, we can encode properties inside the continuous properties of light. So as you know, light has, this dual nature in a way. It can be represented as discrete particles, photons, or it can be represented as electromagnetic waveguides. So the cool thing about this is when you're using photonics, you can actually take advantage of both approaches in quantum computation.   So this is something that's called, continuous variable quantum computation, and it's really the what makes this system so different from the standard cubits or discrete quantum computation model. So not only can we think of it in terms of discrete quantum systems, we can actually take advantage of the continuous nature of light and encodes continuous   variables inside this quantum.  

So   because it is different, we are working with a system where we can encode continuous variables. The algorithms do look very different. So this is something you alluded to before.   So,   in terms of allowing users to program these devices, we have   our main software suite that we're developing. It's that it was called strawberry fields. And strawberry fields is a open source Python library. You can check it out on GitHub, contributions,   make PRs, make issues. And what's your refills allows you to do is it allows you to actually construct   these quantum circuits using   the the tonic gate model.  

So in short, refilled at the very low level,   you can,   create your quantum circuit by creating your input states of light, determining how much you want them squeezed, and then applying beam splitter gates, rotation gates, etcetera, and then performing measurements. So at a very low level, this allows you direct control to manipulate what's being happen what's happening on the chip and,   construct your quantum algorithm that way. If you are doing that way, however, it it as you were saying, it does require a bit of knowledge of quantum photonics   and how to construct a quantum photonics algorithm.  

So what we're also doing through a brief field is we're adding a applications layer. And this applications layer kind of abstracts away these quantum circuits so that you don't have to necessarily build these quantum these quantum circuits yourself. Instead, what the applications layer does is it sort of recast   everything into,   problems that you want to solve. So rather than having to manually put the gates on your circuit, say, these ones are to be measured. I want to perform a beam splitter with this operation on this mode. Instead, what happens is you provide   the problem that you want to solve, and then the quantum circuits are generated behind the scenes, deployed to the hardware. The results are post processed, and then the solution to your answers,   sent back to you. And,   I I guess going into more specifics,   the quantum photonics formulation of quantum computing, it's very, very good at graph problems. So that's kind of the niche that we're looking at as an attempt.  

There are variety of reasons for this. 1 of the reasons is that if you're working with superconducting cubits for trapped ions, you are kind of limited in how your cubits are connected. It could be that, for instance, cubit 1 and cubit 7 are connected, but cubit 4 isn't. So it makes the computations a bit harder to get full full connectivity. So if you want to entangle all all cubits together and perform some sort of arbitrary operation and all. With photonics, it's almost trivial to interfere all your photons together. So as I was saying, you have your, photonic chip. You have variety of gates you can apply. And on our photonic chips that we currently have, you can imply an arbitrary number of beam splices such that you can entangle all of your wave guides and all of your photons at once. And the reason that it's really nice and that we do have this ability to very easily   enable us to embed problems that have a high degree of interconnectivity.  

So things such as graph problems. So if you're able to model your problem as   a graph, so for instance, in model collection of websites as a graph, you can model,   social media   websites and connections and networks as a graph power systems can be models graphs.   It's used across chemistry to represent molecules and proteins. It's it's a very powerful model that's used in a lot and lots of disciplines. So what we can do in this application's layer of strawberry fields is we can take a graph that the users generated that encodes their problem. We can turn this into a quantum circuit behind the scenes, run it through our quantum hardware, take measurements,   probe the structure of this graph, and then post process this and return the results. So for instance, you might have a graph, and you might want to know what's the maximum clicks or the number of   connections,   on this graph,   other properties of this graph. So could you notice the number of sub graphs in this, the number of dense sub graphs in this graph? So that's the number of subgraphs in your overall graph structure that might be very highly connected. Maybe you want to identify those and classical algorithms are a bit too slow at doing that, then that's something you can deploy to our hardware. And we are actively developing algorithms that can utilize the quantum photonics nature of the the quantum computational power of quantum photonics to probe these infrastructures.  

So something that people from, Python might be familiar with when it comes to graphs,   is the network x library. The network x really is sort the biggest and the most ubiquitous library for working with graphs and graph problems in Python.   So in strawberry fields, we're actually very tightly integrated with network x. So you can define your graph problem in network x. The strawberry fields   provide this network x, graph to strawberry fields and define the problem you want to solve, and and then we can actually use the quantum photonics chips to attempt to solve the problem for you. And given that users are actually shipping their computation  

[00:20:12] Unknown:

off to your hardware,   I'm curious how you're handling issues such   as potential latencies, I'm sure, is probably the least   concerning aspect, but also things such as being able to handle data transport to make sure that there is enough data locality for the computations being done or setting the appropriate sampling so that they can submit the entire algorithm and the entire problem space to the quantum processor,   and being able to handle  

[00:20:40] Unknown:

the sort of segmentation of where the computation is getting done? Okay. So, I can't speak too much on the platform side. My role is actually mostly on the open source software. So it's Story Fields among some of the other, open source software that we're working on that I introduced a bit later. In terms of the platform, we are in very early,   beta access at the moment. So hardware access is still internal to Zandu. We're hoping to open that up place for the year. 1 of the advantages that we have with quantum atomic. So I mentioned previously that to perform the operations in the chip, we don't need a super cooling environment, so we can perform the quantum computation at room temperature. Another advantage we have is that the detectors that we use in quantum photonics, these photon number resolve resolving detectors have a very high sampling rate compared to,   what you see in superconducting qubit systems and trapped ion systems. So if you look at some other systems like,   maybe the IBM q experience by IBM,   where you're limited, I think, to 8, 000 shots, The number of and here are shots of the number of samples that you return from the quantum device. 1 of the greatest advantages for us is that because the sampling rate of our detectors is so high, we can potentially return millions of samples or shots for a single computation   within 1 second or so. So,   this is a huge advantage because with quantum computation, a lot of even though the quantum computation itself is deterministic, in order to extract the information from the system, you have to perform measurements which are stochastic. So you're essentially doing a lot of sampling. And the more sampling you can do,   the better you can resolve your results   and solve the problem that you're trying to solve. So we do provide a much a significantly larger number of samples compared to other systems. So this does avoid you having to break your job down into multiple sections, which I think you were mentioning previously. Currently, we are looking at a I I think this is common across the board in quantum computation because these are very specialized   devices that are accessible over the cloud. And the number of them is so few.  

Most systems for accessing these do require a queue system. So you submit your job, and you have to wait in the queue for an amount of time. Once you're at the top of the queue, that's when you have access to the device. We are seeing the industry change a bit. So something that Righetti has done with their, quantum cloud service because they're they allow you to reserve time on the device. So this is actually quite cool. I think it's still very experimental.   So   as the industry grows, we will see different companies trying different approaches for how to access the devices. But at the moment,   the queue system seems to be the 1 that works the best in terms of,   user experience and user access.  



[00:23:12] Unknown:

So you mentioned the strawberry fields layer as being the underpinning for the software platform that you're building out and having the option of going very low level and building out the specifics of the quantum optics circuits and the gates and everything.   But it also has higher levels and supports things like these graph problems and,   these   issues   molecule discovery. I'm wondering if you can outline some of the rest of the software components that you're building out in the libraries   and some of the primary use cases that you're targeting for your customers and your internal use cases?  

[00:23:51] Unknown:

Okay. So   in terms of our open source Python libraries that we have here, it sounds we   we have a variety and I guess,   page.   But the 3 main ones that tend to underpin the main software stack are,   storage fields, which is our that's our framework for simulating these quantum mechanics. So in addition to submitting to hardware, you can also perform simulations   on various, numeric back ends.   So these are back ends built using, CPaaS plus with siphon extensions   as well as,   a pretty neat 1 is a TensorFlow   back end for strawberry field. So you can perform your quantum simulation in a way that's end to end differentiable   and then actually optimize   over your,   your TensorFlow simulation in strawberry fields.  

And this is quite nice, and it allows you to determine various parameters for your quantum algorithm,   using machine learning algorithm. And then later on, once you have these parameters, deploy the star. So so story fields is really where the photonics applications plus the photonic circuit builders and the photonic   simulators   live. A bit below this, we have 1 of our libraries, which is called the Wallace.   And the Wallace   contains all of our,   high performance code. So a lot of the algorithms which are core to simulating quantum photonics.   So,   these live in the walls, and these are recent in, in c plus plus,   with Python interfaces.  

So it it at this point now, it's completely c plus plus. At some point, it was partially Fortran, partially c plus plus. But we've in the last couple of months, we've just finished the port to move everything away from Fortran into c plus plus. So that's sort of low level.   Most users will never directly use the wars, but it   that's where the high performance   code lives. In addition to story fields in the wars, we also have Penny Lane. So Penny Lane is our, quantum machine learning platform,   and we're doing something a bit different with Penny Lane. And then Penny Lane is not purely quantum optics. It has the quantum optics in there, so you can do your quantum machine learning with your quantum optics.   It also has accessibility to qubit devices.  

So these are qubit simulators and qubit actual qubit hardware devices provided by   IBM, provided by Righetti, and either qubit high performance simulators. So the cool thing about this in pain lane is it doesn't really tie you into a specific framework. You can have a single computational model in Penny Lane that connects a superconducting Cuba device from IBM. It connects a quantum atomic device from Zandu   and uses both of these devices almost in parallel in a single computation. And the cool thing about this is that,   at the moment,   when it comes to the quantum computing,   ecosystem, we're very much in this noisy intermediate scale quantum device territory.  

So when I say noisy intermediate quant scale quantum device,   why it means that the devices that we have, they're quite noisy.   So,   there's no fault tolerance yet. There's no proper error correction.   So,   this noise can permeate and affect your results. So while that might sound like a downside at the same time, it's actually a bit cool because it means that it very it very much distinguishes these different,   for these different formulations and hardware devices that we have. So in this noisy regime, quantum photonic devices will be very good. Some things not so good at other things, and this will complement very nicely what superconducting device will do. So superconducting device might be very good at certain,   certain variational algorithms, whereas a quantum device quantum trans device might be very good at doing other variational problems as well as the sonic molecular   problems, graph problems like I was discussing earlier. So by combining these 2 devices in a single computation, we can take advantage of both of these at the same time instead of locking ourselves into just a photonics device, just a cubit device. The other cool thing about Penny Lane is that it also doesn't lock you in to a framework. So what we really want to do is we wanted people to use the machine learning framework they were familiar with. So in this case, big ones like TensorFlow and PyTorch, and actually make these frameworks quantum aware. So you could take your existing TensorFlow code or your PyTorch code and using PennyWay, and you can create a quantum a device that abstracts away the quantum device and the quantum circuit and make it so that anyway, that PyTorch and TensorFlow can actually differentiate through this quantum device. So it's quite,   cool and sort of the power that it gives you to construct your model. You're not really tied down. You can sort of do anything that TensorFlow and PyTorch can normally do, except you can now add quantum devices and stuff. And you can actually add multiple quantum devices into your model and quantum devices from different providers using different formulations as well. And what's the story behind all of the Beatles references with Strawberry Fields and the Walrus and Penny Lane? And also, it seems like the   the Walrus library being written in c plus plus is a missed opportunity for using the new Walrus operator in Python 38. Yes. Yeah. That that's come up internally. So we named it the Wallace before the Wallace operator was suggested in that for Python 3.8.  

We were very excited about it, but unfortunately, we're still trying to target Python 3.5   until,   Python 3.5 loses support this year. So people are hanging on to start using the worst operation in the worst, but it might be some time before we're we're able to because we're both targeting Python 3.8 and above. The reason behind the resource references,   So our CEO is a big fan of the Beatles.   So we had the weird situation where a lot of these projects actually had really boring code names. And then once they were about to be ready for release, they got really cool. Beacels official name. So that's so that's actually quite cool.  

[00:29:23] Unknown:

So are are any of your applications   already  

[00:29:26] Unknown:

slated for being sergeant pepper? Oh, no. That's a good 1. I'll have to add that to the list.  

[00:29:31] Unknown:

So 1 of the other interesting aspects   of the work that you're doing in open source and some of the other   manufacturers of these quantum hardware   systems   is that everybody seems to be targeting Python as the primary   client interface. And so I'm wondering what it is about Python that is   so appealing   in terms of the   language itself or the community that it gives you access to. That that is the sort of first and foremost concern as far as building out these libraries and releasing them to the public?  

[00:30:02] Unknown:

So perhaps I'll I'll start a bit more personal with, sort of my relationship with Python and how I started with Python. So I didn't really program much throughout university,   high school, etcetera. I've always been into technology, but I was more,   more more into the sort of the pure science, mathematics,   the physics. So my first experience with program didn't really come until   I I was doing my on this project and my PhD. And if you come from an academic background,   especially in physics, 1 thing that's very, very common is that you start doing a research project with a supervisor who did their undergraduate or PhD project in the seventies or eighties. And you join that research group and you come across   a huge amount of code that the research group is using that is still using Fortran. In a lot of cases, among more than Fortrans or Fortran 90, you still come across research groups using legacy code using Fortran 77.  

So so that's exactly what happened to me. I started doing my PhD,   and my PhD includes a computational aspect. And the code I got given to work on was Fortran,   77.   So   Fortran is a very interesting language because it was designed for scientific computation. So I think that's the reason why it has lasted so long in academia.   I still have a bit of a soft spot for it because it was my first language, but it's not so much of a joy to use. It doesn't really spark much joy in general,   partly because it's so old and it isn't as modern as other languages that we have. So as I was doing my PhD, I started,   delving into Python just because Python does have this huge ecosystem in, in the sciences. So it has libraries such as NumPy, SciPy. Not only that, but it has also very specialized libraries that you'll find all over GitHub   that seek to use these other libraries we have, like, built upon NumPy and some SciPy   to,   to solve these very niche problems that you have in academia. So, in my particular case, I was solving the Schrodinger equation,   for a very specific system in a high performance computing environment. So I I discovered Python this way through the ability to do rapid process typing, but not only that, but the ability   to interface with this legacy   high performance c plus plus and Fortran code. So you still get the power behind   the sleek c code, but you can interface it in a way that does kind of spark drawing because you're using Python. It's super easy to plot things. It's easy to prototype, to quickly create arrays, test things in a interactive environment using IPython and Jupyter Notebooks. So that was my, introduction to Python.  

And I actually for my PhD, I produced the library which took our research group's legacy Fortran code, kept it, optimized it, but then wrapped it in a Python interface. And I think this code is still being used by my research group, and it just it makes it so much easier to use and deploy and to do research with. So that was my experience with Python.   And even though it wasn't my first language, it's still really it feels like my first language. It's it's the 1 that makes me happy. It's the 1 where if I have to prototype something and there's no library, there's no language requirement, I would just go straight to that. So I think that's kind of what you'll find a lot in academia.   And   as Xanadu, a lot of our software developers and our quantum software developers came from academia in the early days. So   we all have this familiarity with Python. We we recognize that power that hasn't it allows for that rapid prototyping. It's interactive, but then you can also interface it with high performance code. I think that's something we found, very attractive. It's something that makes it easy for us to   very rapidly build up these libraries and make them,   so futureful. The other advantage to Python, I I briefly touched on this, is the ecosystem.  

So we already have machine learning libraries that are, very, very big. So ones like TensorFlow,   PyTorch,   JAX, as well as sites come up. And there's a huge advantage to being part of this ecosystem. So having software like strawberry fields being able to interact with network x, having libraries like Penny Lane being able to interact with,   with PyTorch and TensorFlow.   So I definitely,   see the scientific Python community and the wider Python community as a whole as being very, very beneficial to this very early stage in quantum programming and quantum software. And also because of the fact that there are so many people in academia  

[00:34:14] Unknown:

who end up using Python, I think that it also   brings a lot of people who are interested in experimentation   with some of these more esoteric systems or who have the necessary   academic and scientific background to be able to understand some of the principles that they're working with for building out these algorithms.  

[00:34:32] Unknown:

Yep. Exactly right. It has this amazing mix of the ability to build out these production level libraries and systems,   but at the same time,   the access and the ability to do these, very,   very niche specific,   scientific problems.  

[00:34:46] Unknown:

And as far as your work of building out these open source libraries that are intended   to bring people in to experiment with these different quantum   processors and the algorithmic design of building out these systems,   what are some of the most challenging aspects that you're experiencing as far as designing interfaces   that are   accessible to developers and   understandable without   quantum aspects of what they're building while still being able to provide that lower level fundamental access for building out these the gate arrays and things like that for people who are so inclined? So  

[00:35:25] Unknown:

So this is something we've actually been thinking about a lot,   especially from Honeywell onwards.   So I think if you look at the wider Python,   quantum ecosystem,   it's very much objects oriented.   So,   lots of things exist   as objects. So a lot of,   the frameworks you have to create your circuits as an object or your program as an object, then the devices are objects. And there's lots of things you're carrying around. And it's not maybe so intuitive. You find yourself a lot of the time having to always go back to the documentation, seeing what methods are available, and how to do things. Another thing we noticed is that these libraries tend to be very low level, which makes sense at this point because, these devices are noisy. They all have their quirks, even different devices within the same vendor. So a lot of   particularly experimentalists   who want to run physics experiments on these devices. They want low level access to these devices, which is what these frameworks give them. With Penny Lane, though, we kind of wanted to do something different to sort of address what you were saying earlier. This ability for users to almost intuitively use quantum computing without having to   delve in, read the document documentation and really understand   the core physical principles behind it. So we did a lot of soul searching, and something we kept coming back to was that the NumPy interface was really powerful,   especially people in academia. We noticed that a lot of people who weren't familiar with Python, they were familiar with MATLAB or Mathematica. When they started using Python, the experience they had was that they really enjoyed using NumPy because of its interface.  

It's not very much object oriented. It's   more so structured with a lot of high level functions,   but these high level functions are almost all in 1 place. They're usually all in the main NumPy namespace.   They all have names that make them easy to find, and you can almost,   learn NumPy just from inside IPython or a Python terminal just by playing around and searching for functions. There's not this huge amount of going through the   documentation, try and find what methods are available,   trying to understand the actual numerical algorithms underpinning them. So for instance, if you're using NumPy and you want to solve for   a linear system or you solve for the eigenvalues,   you just call NumPy dot linage dot icloud. You don't tend to in most situations, so sometimes you do have to worry about what algorithm you're using under the hood. But in most situations, it's enough just to simply call that and get your eigenvalues   and not have to worry about the low level implementation. So this is something we really wanted to do when we started working on Penny Lane. We spent a long time thinking about the user interface. So what we wanted was we wanted something that was almost as intuitive as NumPy.  

It wasn't really object oriented like the other frameworks, but it was more,   more function based, more functional.   And that's what we strive to do with Penny Lane.   So with Penny Lane in particular, all quantum devices, they're just Python functions. So you define your Python function. Inside this function, you're restricted to only using quantum gates because this is all you can run-in your quantum device.   The function takes arguments, and these arguments of the parameters of the quantum gates, and it returns some result.   So usually, if you look at most quantum frameworks, these quantum devices will return samples,   then it's up to you to post process these samples yourself. Maybe there are some utility functions,   to get the actual, classical data or the solution that you want. So we try to abstract this all away. So it's something that we call the q nodes or quantum nodes, this quantum function. So it takes it takes just standard Python input type, so it can take NumPy arrays. It can take if you're using PyTorch or TensorFlow, it can take tensors. It performs the quantum   computation, and the return statement of the function specifies the essentially,   what you want to get out of the quantum function. So the measurement statistics. So you don't even have to worry about samples if you don't want to. It will automatically   sample the circuit, do the post processing for you, and return it. And   I guess a key feature in Penny Lane is that it returns in such a way that it's differentiable, so you can also differentiate through it. But in terms of the user interface, this is something we found that made quantum computing somewhat more accessible, somewhat more intuitive,   and it kinda makes sense. When you're running a quantum device, it's almost like executing a Python function that just happens to be executed remotely, in this case, on the quantum. With that core abstraction there, we then want people to be able to interact with it almost like they would if it was a NumPy function. So key to us was making it compatible with NumPy so you could call NumPy dot sign and then have your quantum   function as a argument. So we wanted this ability to do   lots of composition without having to even think which functions are quantum and which functions are classical. So that was the approach we took in Penny Lane. We're still trying to work out because you're right. This is a very this is a very complicated thing to do programming for. Quantum computing is still in some ways a very academic   topic even though we are trying to change that. Another thing we're trying to do as well is we're really trying to,   open up   the accessibility by producing tutorials. So if you go to the PayLink website, we have this quantum machine learning tab. And in this quantum machine learning tab, what we're doing is we're trying to build out a huge amount of,   live examples. So these are examples that using actual that we're using screen scouter in this case.  

So   it's a simple Python script that runs Penny Lane,   shows how the quantum circuits are defined, and how they can be, interact with using NumPy or PyTorch and TensorFlow, and it's automatically built and deployed to the website. So we always know these Python scripts will run,   and we want to build out a   a hub or online resource for people to think. If if someone wants to solve a particular problem, they can go to this website, have a look at the available demonstrations,   and really see what this looks like in terms of the classical quantum.  

[00:40:54] Unknown:

And   in terms of the work flow of somebody who is trying to build out an algorithm or an implementation that's targeting a quantum processor, given that they're not going to have unfettered access to it like they do the CPU on their laptop. What's actually involved in getting a project set up and validating that it's going to function at least roughly as intended before submitting it to the  

[00:41:18] Unknown:

platform service that you're providing. So in this case, the simulations really are key. So the simulations really allow you to prototype and make sure that what you're doing seems to be doing the right thing before you deploy to hardware. At the moment, we're quite lucky and that the quantum devices we have are quite small, so they can be simulated. In the future, as the quantum devices scale up and grow larger and larger, we we will reach a regime where you will no longer be able to simulate it before being able to deploy its hardware. In this case,   the approach seems to be   testing out your algorithm on a smaller on a small scale. So with a smaller number of cubits or a smaller number of photonic waveguides.  

Simulating that, make sure it seems to be doing what you want it to do. And then when you deploy it to hardware, you scale up. So you might simulate it with 4 cubits. And then when you deploy, you might scale up to 16 cubits. This seems to be the approach so far. It does have its drawbacks in that If something seems to be working with a small number of cubits, it might not necessarily work exactly as is just by scaling up the number of cubits.   So there is a bit of trial and error there. This is something that I think can definitely be improved in the quantum software stack from almost all vendors. There isn't really this notion of quantum debugging yet. So how do we properly   debug to make sure our quantum algorithm is working? Do we have,   how do we step through our quantum algorithm even when we're just using a simulator to make sure that each step it's doing what should be doing? And then, of course, this only applies to simulators. When we scale up and we can only run our quantum algorithms on hardware because it would just take too long to simulate them. How do we also scale up debugging so that you can debug while using hardware? So I think these are very important questions. And they're still questions that have to be solved. So these are 1 of the this is 1 of those topics where it's super, super useful and helpful to have people from outside of physics and quantum computing contributing to quantum software. By having people from   a very diverse   backgrounds contribute, it will slowly help us build and come together and coalesce around different debugging strategies to help people build their quantum algorithms.  



[00:43:13] Unknown:

And in terms of the use cases that you're powering and some of the ways that you've actually seen your hardware platform use, what are some of the most ambitious or exciting implementations or projects that you're aware of? In our particular case, so if you're looking, purely at quantum tons and the continuous variable implementation that Zandi is working on, I think some of the cool things include,  

[00:43:36] Unknown:

because it is a basonic system rather than a fermionic system, which is what you have when you're working with electrons or ions, it does allow our platform to simulate different kinds of molecular dynamics than you would be able to with, conducting cubits in this noisy regime.   So in this noisy regime, it's it's better at solving the sonic problems. So problems including simulating photonic systems, simulating,   molecules which have these bosonic properties that photons also have. So this is actually quite interesting. I think this is a,   this will be 1 of the big,   use cases of quantum computing in the near term. Things like calculating the vibrant structure of molecules is something that our system is very well suited for. And this is a problem that's, very important in in quantum chemistry. So you have large chemistry,   companies and corporations spending huge amounts of high performance compute time trying to simulate these masonic molecules and calculate the vibronic spectrum. And this is an exciting thing that we think, device should be able to do much more efficiently and much more easily. Oh, yeah. There's also outside of molecular dynamics. There's also   other applications, I believe, across optimization,   finance,   machine learning  

[00:44:42] Unknown:

that I'm slightly less familiar with these. And how are you using the computational   capabilities of your platform to actually feedback into the design of successive generations of hardware? I'm not entirely sure.  

[00:44:56] Unknown:

This is this is a question for the hardware team that's under which unfortunately I'm   I'm not part of. I know that we're using a lot of a lot of high performance simulation software and optimization techniques in order to design our photonic bits. But, unfortunately, I can't go into much more detail than that. Fair enough. So before joining Zadu, I actually didn't really have a background in quantum photonics. I was in a weird situation where the quantum photonics group at our university   defected to go to another university. So I missed out learning about quantum photonics until I came to. I think that was the exciting thing about what I found about quantum software and that not only, you producing these amazing open source libraries, but you're also learning some amazing new physics along the way. Absolutely.  

[00:45:34] Unknown:

And so in terms of the lessons that you have learned in the process, what have you found to be some of the most interesting or unexpected or useful  

[00:45:43] Unknown:

experiences that you've had? So definitely, I really enjoy getting user feedback for our quantum software libraries. It it's really changed the way we develop in a way. So originally,   we tried, I think, maybe too hard to sort of envision what a user would do when they had access to quantum machine learning or photonic quantum computation. And we would make a lot of assumptions based into the software, release it. And in a lot of cases, things we expected the users to do, no 1 would do. And we'd be a bit surprised by that. And then other cases, we would we would say, oh, no 1 would ever really want to do this with quantum machine learning or or with Penny Lane. So we'd place restrictions in.   And what I found really valuable was that it wasn't so much that people were asking us for this feature because they found they couldn't do it. The people would just try to do it. It would be almost intuitive that, hey, Penny Lane should work like this, and I should be able to do quantum machine learning like this. So I'm just going to try doing it. I think that's 1 of the it's almost 1 of the best, piece of user feedback you can get. So we had a huge number of for a specific example originally with Penny Lane. We restricted it so that inside your quantum nodes or your quantum function, you could only place a sequence of gates. We didn't allow any classical processing. Something we noticed though is that people people weren't making bug reports, but they were just making they were just asking for help because they kept trying to create that quantum function with classical processing inside. So they'd have a if statement inside that quantum function. So, like, if this Boolean variable is true, then apply this case. Help start to play this case, and they would have a keyword argument in their quantum function from the scales on and off. And we originally had a we had a big red warning box and documentation saying, don't do this. It won't work.  

That doesn't work, people will try to do it because this is new technology. It's exciting, and people are trying to use the same paradigms that they use when they use NumPy or PyTorch with quantum machine learning. So rather than people asking us to allow this, people were just trying to do it and couldn't get to work and we're getting frustrated. So we sat down and we saw some we had a look and we recognized that this was an intuitive thing. If we hadn't developed Penny Lane, we would also try to do this. So that was super valuable, and we sort of sat back and said, great. We should allow this now. So in the next version of Penny Lane, you can actually,   have the if statements and for loops inside your quantum functions and turn off turn on and off different gates, different gate sequences programmatically.  

So that was very valuable.   I think definitely the most valuable thing is use of feedback. So we have a Peyling discussion forum. It's just discussed those adu.ai,   and it's a it's a forum for users just to post their quantum machine learning models to ask us questions. And in a lot of cases, they'll   ask for specific features. And in retrospect, these very obvious features. And something we value very highly is the ability   to move fast and prototype rapidly.   So in a lot of these cases, what we're able to do is we're actually able to create a branch or pull request that implements this feature, provide the details to the user, get them installing PennyLane off this branch,   get feedback for this,   new feature as it's work in progress as a PR, and then get merged into master as an experimental feature, as a more full fledged feature as quickly as we can. And for somebody who's interested in experimenting with quantum computing  

[00:48:42] Unknown:

and trying to decide what are some useful   problems that they're trying to solve, what have you found to be valuable heuristics for determining whether a particular use case or a particular problem is actually well suited for quantum processors versus just using traditional   classical CPUs and GPUs and, being able to just approach things in the we using the standard set of libraries that we have. So that's a very good question.  

[00:49:07] Unknown:

I don't think anyone really has an answer to that yet.   It's something that we're all desperately trying to answer because it would be super valuable just for us even to have a heuristic to say, oh, straight away, this problem would be ideal for our quantum device. We are in the early days, and it is still such a active,   field of research that even still you'll have a huge flurry of papers coming out maybe over the summer saying, this looks like a very promising promising   application or promising technique. And then a couple of months, you'll have another flurry of papers delving more into the physics and the mathematics saying, well, actually, it only works in this very specific   edge case. And then all these other edge cases, it's best to do it classically. So it's still something that   we are,   investigating. So it's it's very important for us to be able to know,   the answer to this question. So we have a group of researchers internal at Zanu who are going through different applications and investigating this very thing, seeing what applications are best suited, and   are there any heuristics for porting over something  

[00:50:05] Unknown:

to be used in our quantum for time to place? So as you look forward, what do you have planned for the future of the Xanadu software ecosystem,   and what are some of your predictions that you have for the near to medium term of where quantum computing is going? So in terms of the quantum  

[00:50:23] Unknown:

stack that we have, the quantum software stack is Zadu.   We're definitely pushing hard in story fields. The story fields will be the place to access   the Xandr cloud and submit jobs to our hardware,   and,   this is something that will hopefully come out this year, I believe.   So expect to see a lot of new features there in terms of being able to access the platform, submit your jobs, use the quantum photonic hardware,   specifically with the applications layer so that you can define your problem and submit that directly and have that have the post processing, the preprocessing happen automatically.   We also plan to sort of build out the applications layer even more, add more   applications in the short term,   mostly graph based applications for our quantum device. So being able to characterize graph problems and specific features of graphs in ways that might be practically faster than you could possibly,   and then long term, add more things in terms of applications for quantum chemistry, applications for optimization, etcetera. At the same time, we're really building out Penny Lane to be the go to place for quantum machine. So it already integrates with, TensorFlow and PyTorch,   plus on the other end, it can be used with our device, our quantum hardware,   IBM's quantum hardware, we're getting some hardware. So we plan on adding,   more integrations in the future   and   really working on making it a, so almost sparking joy. So we want people who use Penny Lane to enjoy using Penny Lane because   it makes it fun to perform quantum machine learning. It makes it intuitive. So so and feature that we added actually relatively recently is that we're going to a point now where a vendor won't just have 1 device available, but they'll have multiple devices available. And so   you should be able to split your computation across multiple QPUs and run them in parallel, and   this can take something that is embarrassingly parallelizable. Instead of having to wait for each quantum computation to happen in serial, you can just asynchronously submit them. So that's actually something that we have support for now in PennyWay in version 0.8,   which was just released about a month ago now, actually. So that's very exciting. It's taken quantum algorithms that previously would take   it's it's taken quantum algorithms that, previously would run serial, and it's almost half the quarter of the time that it takes to run those same quantum algorithms just by asynchronously submitting them at once. So that's where we see our quantum stack going, with Penny Lane definitely as well. A big part of this will be expanding out pennylane.ai/qml.  

So really building out these tutorials   and making it so that someone who has a background in machine learning can can go and have a look at these demonstrations and see maybe like, oh, hey. How does a I I know how a variational classifier works, but how does a quantum variational classifier work? And they can have a look at the demonstration list and see 1 that uses, for instance, PyTorch to perform a variational classification problem, except at some point, this,  

[00:53:03] Unknown:

the PyTorch neural net is taking advantage of the quantum device. And are there any other aspects of the work that you're doing at Xanadu or your experience of building these open source libraries and working with the community to enable this new era of computation that we didn't discuss yet that you'd like to cover before we close out the show? I I think really what I would love to do is,  

[00:53:24] Unknown:

almost a call to arms to the extended Python community. So if you have a look at a majority of quantum software development at the moment,   it is being done by people with a background in quantum computation.   So originally, maybe 3 or 4 years ago, almost everyone worked on this had PhDs in quantum physics. Now we're getting to the point where the industry is growing, so people are being hired to work on quantum software with a bachelor's in science or bachelor in computer science. But there's a huge advantage to having people from outside quantum physics help and contribute to these quantum software libraries   because they provide a,   a worldview and a way of seeing things on the same things that might not be   as prevalent for people with a background in quantum business. So this is something that's very valuable and something that we're actively,   sourcing out. So if you do have a background in machine learning and you want to help contribute to quantum machine learning, I really encourage everyone to download any lane, play around with it, have a look at our demonstrations,   and then   let us know what we can do to make this work for your workflow or even,   we would love it if you contributed   to,  

[00:54:28] Unknown:

any lane to increase these integrations with PyTorch and TensorFlow and make it work even better than it does now. Well, for anybody who does want to get in touch with you and contribute or follow along with the work that you're doing, I'll have you add your preferred contact information to the show notes. And so with that, I'll move us into the picks. Okay. And this week, I'm going to choose the movie Knives Out, which I just watched recently. It's a really great who done it kind of film, sort of a mystery   in the the older style, but with a lot of really interesting and quirky,   antics and just a really well done storyline that keeps you guessing. And even about halfway through, you're starting to wonder, well, where is this going to end up? And by the end of it, it's it's just very satisfying. A lot of fun. Definitely recommend that for anybody who's looking for something to watch. So with that, I'll pass it to you. Josh, do you have any picks this week? I just want to say that I've really wanted to watch Knives Out. It's been on my to do list for a really long time, and I keep it keeps slipping. Thanks to your reminder. I might actually get to watching it tonight to remind. So on my side, I I haven't seen any,  

[00:55:29] Unknown:

any new films lately.   I've actually,   I've been so busy at work, but I've somehow found the time to get really into baking. So I've been doing a lot of baking at home before and after work and really into making sourdough. It's been quite therapeutic and giving me a   sort of a newfound appreciation for the work that bakers go through. So something very far removed from quantum physics.   That's something that   I'm really enjoying now and encouraging anyone   who's been curious about making bread. It's actually   much easier than you imagine. So,   feel free to give it a go and play around and experiment and have fun. Yeah. And and you have a delicious byproduct at the end of it? Exactly. I have 1 sitting on my counter right now, and I'm staring at it waiting for it to cool down so I can break into it.  



[00:56:14] Unknown:

Well, I won't hold you from that any longer. So thank you very much for taking the time today to join me and share the work that you're doing at Xanadu and enabling this new era of computation and bringing machine learning into that ecosystem. It's definitely very interesting and exciting   development   in the industry. So thank you for all of your time and effort on that front, and I hope you enjoy the rest of your day. Yep. Thank you. You too.   Thank you for listening. Don't forget to check out our other show, the Data Engineering Podcast at dataengineeringpodcast.com   for the latest on modern data management.  

And visit the site of pythonpodcast.com   to subscribe to the show, sign up for the mailing list, and read the show notes. And if you've learned something or tried out a project from the show, then tell us about it. Email host at podcastinit.com   with your story.   To help other people find the show, please leave a review on iTunes and tell your friends and coworkers.