Quantum Learning Machine (QLM)¶
What is QLM?¶
The Quantum Learning Machine is a quantum computing platform developed by Atos/Eviden that provides a software environment to program, compile, and execute quantum programs. It comes with a Python software stack called the Quantum Application Toolset (QAT), available under the qat namespace.
QLM supports a wide range of quantum workflows — from basic circuit simulation to noisy simulation, variational algorithms, quantum annealing, and more. On PERUN, QLM is accessible as a JupyterHub environment with a full set of tutorial notebooks included.
GPU Acceleration
GPU-accelerated simulation is not currently available on PERUN QLM. Simulations run on the QLM hardware without GPU acceleration. Tutorial notebooks covering the GPU acceleration feature are included for reference but cannot be executed on this system.
Accessing QLM¶
Requirements¶
VPN
VPN is required to access QLM.
URL¶
Open the following address in your browser:
Credentials¶
Log in using your PERUN username and password (e.g. aabbcc123).
Requesting Access¶
Access Request
QLM access is not enabled by default. To get access, you need to be registered on PERUN and submit a request through a dedicated QLM access call. There are no quotas — once access is granted you can use the system freely.
Getting Started¶
When you log in you will find the following in your home directory:
| File / Folder | Description |
|---|---|
getting_started.ipynb |
A brief introduction — start here |
overview.ipynb |
Index of all available tutorial notebooks by topic |
commands.ipynb |
Reference for all QLM command-line tools |
tutorials/ |
Full collection of tutorial notebooks |
We recommend opening getting_started.ipynb first, then using overview.ipynb to navigate to the topics relevant to your work.
Basic Example¶
The following example is taken from getting_started.ipynb and demonstrates the core QLM workflow: writing a quantum program, compiling it to a circuit, and submitting it to a simulator.
1. Create a Bell state circuit¶
from qat.lang.AQASM import Program, H, CNOT
# Create a program and allocate qubits
qprog = Program()
qbits = qprog.qalloc(2)
# Apply gates to create a Bell state
qprog.apply(H, qbits[0])
qprog.apply(CNOT, qbits[0], qbits[1])
# Compile to a circuit and display it
circuit = qprog.to_circ()
circuit.display()
2. Simulate the circuit¶
from qat.qpus import LinAlg
# Create a simulator and submit the job
linalgqpu = LinAlg()
job = circuit.to_job()
result = linalgqpu.submit(job)
# Print the final state vector
for sample in result:
print("State %s amplitude %s" % (sample.state, sample.amplitude))
3. Sample the circuit¶
# Run with a fixed number of shots
job = circuit.to_job(nbshots=10)
result = linalgqpu.submit(job)
for sample in result:
print("State {} probability {} amplitude {}".format(
sample.state, sample.probability, sample.amplitude))
More examples
The above covers only the basics. Open overview.ipynb in JupyterHub for a full index of tutorials covering noisy simulation, variational algorithms, quantum annealing, and more.
Command-Line Tools¶
QLM includes a set of command-line tools for compiling, running, and inspecting quantum circuits outside of Jupyter. See commands.ipynb in your home directory for the full reference.
Compiler Commands¶
aqasm2circ¶
Compiles an AQASM source file into a .circ circuit file that can be run by QLM simulators.
# Output will be test1.aqasm.circ
aqasm2circ test1.aqasm
# Specify output filename explicitly
aqasm2circ test1.aqasm test.circ
circ2aqasm¶
Decompiles a .circ circuit file back into AQASM source. Useful for inspecting or modifying an existing circuit.
Simulator Commands¶
qat-jobrun / qat-batchrun¶
Run a serialized job or batch of jobs from the command line. QPUs and plugins are referenced using the namespace:class_name convention.
# Run a single job with the LinAlg simulator
qat-jobrun --qpu qat.qpus:LinAlg test.job
# Save results to a file instead of stdout
qat-jobrun --qpu qat.qpus:LinAlg test.job -o results.res
# Run a batch of jobs
qat-batchrun --qpu qat.qpus:LinAlg test.batch
qat-resprint¶
Display the results from a previously saved result file.
# Display a single job result (2 qubits)
qat-resprint results.res -N 2
# Display a batch result
qat-resprint -b batchres.res -N 2
Inspecting Circuits¶
qat-circstat¶
Displays statistics about a serialized circuit — qubit count, gate count, measurements, and more. Useful for getting an overview of a circuit's resource requirements before running it.
Example output:
Circuit of length 3 over 2 qubits (2 quantum gates)
== Quantum gates ==
custom gate : 0
H : 1
X : 1
== Other ==
nbqbits : 2
measurements : 1
resets : 0
logic : 0
breaks : 0
remaps : 0
Using Python Libraries¶
The QLM environment is a standard Python environment, so you are not limited to QAT libraries. Regular Python packages can be imported and used alongside your quantum code directly in the notebooks. For example, psutil can be used to check resource usage during a simulation:
import psutil
print(f"Memory used: {psutil.virtual_memory().percent}%")
print(f"CPU usage: {psutil.cpu_percent()}%")
Other common libraries such as numpy, matplotlib, or scipy can be used the same way, for example to post-process or visualize simulation results.
Intended Use
These libraries are provided to complement your quantum workflows — for example to post-process or visualize simulation results. The QLM is not intended for general-purpose computation. For that, use the standard PERUN HPC environment.