Qiskit за пределами Python: Fortran, C++ и Julia

Основные выводы:

• C API для Qiskit позволяет работать с Qiskit напрямую из Fortran, C++ и Julia — без использования Python — за счет предоставления доступа к высокопроизводительному ядру SDK на языке Rust.
• Начиная с Qiskit v2.0, единый интерфейс C связывает ядро SDK на Rust практически с любым языком программирования, используемым в высокопроизводительных вычислениях (HPC) и научных расчетах.
• Поскольку все языковые привязки используют одну и ту же библиотеку Qiskit, они совместимы между собой: вы можете создать схему на Fortran и передать ее в C++.
• Нативные привязки упрощают интеграцию Qiskit в гибридные квантово-классические рабочие процессы HPC, способствуя развитию квантовых вычислений для задач оптимизации, машинного обучения и научного моделирования.

Qiskit — самый популярный в мире комплект средств разработки программного обеспечения для квантовых вычислений, и большинство людей знакомятся с ним через язык программирования Python. Но Python — не единственная точка входа.

Начиная с Qiskit v2.0, SDK предоставляет C API для своей базовой модели данных — того же высокопроизводительного ядра на Rust, на котором работает Python SDK. Поскольку C взаимодействует практически с любым языком программирования, этот единый интерфейс открывает двери для многих других. Три из них — Fortran, C++ и Julia — теперь позволяют работать с квантовыми схемами на том же языке, который вы используете для всего остального. В результате вы получаете квантовые вычисления, которые можно встроить непосредственно в ваш существующий код без уровня Python.

Важно отметить, что, поскольку каждая языковая привязка опирается на одну и ту же общую библиотеку Qiskit, они также являются интероперабельными. В принципе, вы можете создать схему на Fortran и передать ее в C++. Она должна работать без проблем, так как обе языковые привязки указывают на один и тот же объект.

Эти интерфейсы важны, потому что мы верим, что квантовые вычисления станут революционной парадигмой для научных вычислений. Как мы видели на недавних демонстрациях IBM и ее партнеров, квантовые вычисления приносят пользу в сочетании с классическими ресурсами, а не отдельно от них.

Исследователи годами изучали квантовые методы для оптимизации, машинного обучения и моделирования сложных квантовых систем и динамики. Большая часть этой работы происходит на языках, отличных от Python.

Даже когда Python управляет рабочим процессом, вычислительно интенсивные ядра многих симуляционных кодов в физике, химии и инженерии обычно написаны на Fortran и C++, а все чаще и на Julia. И во многих сообществах HPC именно эти языки несут на себе основную научную нагрузку, в то время как скрипты на оболочке или Python лишь координируют отдельные части.

Эксперименты с квантовыми вычислениями не должны заставлять исследователей классических приложений прикручивать интерпретатор Python к существующему коду. Чтобы помочь исследовательскому сообществу полностью раскрыть потенциал квантовых вычислений, мы должны обеспечить простую интеграцию Qiskit в гибридные квантово-классические рабочие процессы — независимо от используемого языка.

Готовы увидеть, что нативный код Qiskit может сделать для ваших исследований? Создайте бесплатную учетную запись на IBM Quantum Platform, чтобы запускать эксперименты на реальном квантовом оборудовании, и изучите документацию, чтобы внедрить Qiskit в свои рабочие процессы на Fortran, C++ и Julia.

Три пути в Qiskit: Fortran, C++ и Julia

Три пути в Qiskit могут различаться, но у них общая основа: каждый из них связывается с C API и взаимодействует напрямую с ядром Qiskit на Rust. Что, возможно, еще важнее, каждый из них стремится соответствовать потребностям исследовательского сообщества. Вот как это выглядит на практике:

Fortran

Fortran — один из старейших языков программирования высокого уровня. Изначально он был представлен как «система трансляции формул», позволяющая ученым записывать численные выражения напрямую и компилировать их в быстрый машинный код.

Спустя десятилетия он по-прежнему лежит в основе огромных пластов сообществ HPC и научных вычислений. Основные библиотеки линейной алгебры, такие как BLAS и LAPACK, реализованы на Fortran, как и рабочие коды квантовой химии, такие как Gaussian, VASP, Quantum ESPRESSO, CP2K, GAMESS, NWChem, а также инструменты ядерной физики, такие как KSHELL, BIGSTICK и MFDn.

Чтобы приблизить квантовые вычисления к этим прикладным областям, мы создали qiskit-fortran, интерфейс Fortran для создания и манипулирования квантовыми схемами. Его дизайн был сформирован в ходе активного обсуждения с сообществом разработчиков Fortran, что помогло гарантировать, что интерфейс естественным образом вписывается в существующие рабочие процессы Fortran.

«Под капотом» он связывается с C API Qiskit через стандартный интерфейс внешних функций Fortran (iso_c_binding), вызывая функции C API напрямую, поэтому вам не нужно писать привязки самостоятельно. Эти вызовы достигают того же ядра Rust, которое питает Python SDK, не проходя через Python ни на каком этапе.

В qiskit-fortran QuantumCircuit является производным типом с деструктором FINAL, что означает, что схема освобождает память, когда переменная выходит из области видимости. Вы можете сосредоточиться на физике: гамильтониан активного пространства FCIDUMP из GAMESS, уже находящийся в памяти Fortran, передается в процедуру построения схемы Qiskit как прямой указатель — без копирования в объекты Python, без GIL, без перераспределения.

Сохраняя рабочий процесс нативным, мы устраняем необходимость в промежуточном слое Python, создавая возможности для более тесной и производительной интеграции с существующими приложениями на Fortran.

Подробный пример рабочего процесса можно найти в нашем руководстве по qiskit-fortran.

C++

Язык программирования C++ начинался как расширение C с классами, добавляя высокоуровневую абстракцию без накладных расходов во время выполнения. Это делает его «рабочей лошадкой» для критически важных по производительности симуляций, от программ молекулярной динамики, таких как LAMMPS и GROMACS, до уровней ускорителей, таких как CUDA и Kokkos, на которых программируются современные экзафлопсные машины.

Впервые анонсированный в прошлом году, qiskit-cpp представляет собой C++ интерфейс только с заголовочными файлами для C API Qiskit. Добавьте его заголовки в путь включения, скомпонуйте свою программу с библиотекой C Qiskit и скомпилируйте один раз из исходного кода Qiskit.

Здесь QuantumCircuit — это объект C++ с синтаксисом, близким к тому, что мы используем в Python, и он сам освобождает свою память, когда выходит из области видимости. Выполнение гибкое: схемы могут быть отправлены через клиент qiskit-ibm-runtime C, через QRMI или через SQC.

Пример рабочего процесса можно найти в руководстве по qiskit-cpp.

Julia

Julia — это язык программирования, разработанный для сочетания скорости компилируемого языка с простотой динамического. Во многих отношениях он предлагает самый мягкий вход в использование Qiskit вне Python. Нет необходимости собирать код из исходников, и он работает в Jupyter notebooks, поэтому вы можете работать интерактивно так же, как в Python.

Qiskit.jl оборачивает C API Qiskit и предоставляет его как нативные типы Julia, поэтому вам не нужно беспокоиться об управлении указателями C самостоятельно. Построение схем похоже на синтаксис в Python, но пакет также предлагает идиоматический стиль Julia, если вы предпочитаете его. Та же стратегия привязки распространяется на выполнение схем: QiskitIBMRuntime.jl, легкая обертка для C-клиента qiskit-ibm-runtime, отправляет схемы на оборудование IBM Quantum и получает результаты.

С помощью этих двух пакетов вы теперь можете выполнять полный квантовый рабочий процесс в Julia и подключать его к остальной экосистеме Julia. Эта экосистема предлагает множество полезных инструментов для научных вычислений, включая решатели дифференциальных уравнений, такие как DifferentialEquations.jl, и библиотеки оптимизации, такие как Optimization.jl.

Экосистема Julia также предлагает множество инструментов, актуальных для квантовых вычислений, включая инструменты моделирования тензорных сетей, такие как ITensors.jl и TensorNetworkQuantumSimulator.jl — ценные ресурсы, которые можно использовать для проверки квантовых результатов на основе приближенных классических симуляций.

Начало работы: моделирование квантовой динамики на 100 кубитах

Чтобы дать вам лучшее представление о том, каково работать с Qiskit вне Python, давайте углубимся в Qiskit.jl с помощью краткого руководства. Мы пройдем через процесс построения схемы и выполнения на оборудовании, используя квантовый подход к уравнению Шрёдингера, которое описывает, как квантовая система эволюционирует во времени под действием своего гамильтониана — математического объекта, который описывает систему и генерирует ее временную эволюцию.

Квантовые компьютеры естественным образом подходят для решения уравнения Шрёдингера; они могут просто изменять квантовое состояние, закодированное в их кубитах. Поскольку эта эволюция должна осуществляться с помощью дискретных квантовых вентилей, мы аппроксимируем ее с помощью процесса, называемого троттеризацией, где мы разбиваем динамику на небольшие шаги. Меньшие шаги дают нам меньшую ошибку дискретизации, но требуют более глубоких схем для запуска.

Тестовой системой является модель Изинга в поперечном поле — одномерная цепочка спинов с взаимодействием ближайших соседей, развивающаяся из начального состояния Нееля |0101…⟩. С этого момента рабочий процесс следует тем же четырем шагам, что и большинство квантовых рабочих процессов: (1) отображение задачи на схему, (2) оптимизация этой схемы для оборудования, (3) выполнение на оборудовании и (4) постобработка результатов.

Единственная разница заключается в том, что здесь каждый шаг выполняется в Julia.

Шаг 1: Отображение задачи на схемы. Каждый шаг Троттера становится слоем однокубитных Rx-поворотов и двухкубитных Rzz-вентилей. В Qiskit.jl схема является нативным объектом Julia, а API построения использует идиоматическую Julia, мутирующие функции с суффиксом !, которые принимают схему в качестве первого аргумента, при этом все еще соответствуя Python SDK практически строка в строку:

using Qiskit using Qiskit.Operations function make_trotter_circuit(h, J, n, δt, steps) qc = QuantumCircuit(n, n) for i in 1:2:n x!(qc, i) end # prepare the Néel state |0101…⟩ for _ in 1:steps # one second-order Trotter step for i in 1:n rx!(qc, h[i] * δt, i) end for i in 1:n-1 rzz!(qc, 2J[i] * δt, i, i+1) end for i in 1:n rx!(qc, h[i] * δt, i) end end for i in 1:n measure!(qc, i, i) end return qc end

Если вы строили схемы с помощью Qiskit на Python, rx!(qc, θ, i) и rzz!(qc, θ, i, j) напрямую отображаются на qc.rx(θ, i) и qc.rz(θ, i, j). Единственное, на что стоит обратить внимание, — это индексация: Julia считает кубиты с 1, как принято в Julia, тогда как Python считает с 0.

Шаг 2: Оптимизация для оборудования. Прежде чем схема может быть запущена, она должна быть транспилирована для конкретного бэкенда — отображена на физические кубиты, переписана в нативные вентили устройства и оптимизирована по глубине. Qiskit.jl предоставляет тот же транспилятор:

using QiskitIBMRuntime service = Service() backend = least_busy(backend_search(service)) target = target_from_backend(backend, service) tqc = transpile(qc, target)[1] # map onto physical qubits and optimize depth

Шаг 3: Выполнение. QiskitIBMRuntime.jl отправляет транспилированную схему на бэкенд в качестве задания Sampler и извлекает результаты — не нужно покидать Julia, чтобы получить доступ к оборудованию:

job = run_sampler_job(service, backend, tqc, shots) samples = get_job_results(job, service) # blocks until the job completes

Шаг 4: Постобработка. Наконец, мы превращаем измеренные битовые строки обратно в физические величины — здесь, намагниченность узла ⟨Zi⟩, усредненную по запускам — с помощью обычного кода Julia в той же сессии:

using Statistics z_expval(samples, i) = mean((-1)^s[i] for s in samples)

В небольшом масштабе, скажем, 20 кубитов, вы можете проверить результаты оборудования по классическому эталону. Решатель ОДУ OrdinaryDiffEq.jl предоставляет точное решение, в то время как симуляция тензорной сети без шумов предлагает вторую проверку. Квантовые результаты тесно коррелируют с обоими.

На 100 кубитах точное решение недостижимо — только для вектора состояния потребовалось бы 2 ≈ 10 амплитуд, поэтому симуляция тензорной сети без шумов становится эталоном. Этот эталон заслуживает доверия только тогда, когда состояние остается слабо запутанным, обычно на ранних этапах эволюции. По мере того как динамика создает больше запутанности, чем тензорная сеть может достоверно представить, ее ошибка быстро накапливается, и симуляция больше не может служить надежным эталоном.

Именно здесь квантовый подход показывает свою ценность. Классически каждый дополнительный спин удваивает размер вектора состояния, необходимого для представления системы. На квантовом оборудовании каждый дополнительный спин отображается на один дополнительный кубит, поэтому 100-спиновая система отображается на 100 кубитов. Кроме того, оборудование несет запутанность, вместо того чтобы усекать ее для соответствия анзацу. Это смещает вопрос точности с того, сколько корреляции может позволить себе классическое представление, на ошибку Троттера и аппаратный шум.

Запуск на 100 кубитах демонстрирует этот компромисс: уменьшение шага Троттера снижает ошибку дискретизации, но углубляет схему, и как только шаг становится достаточно малым, чтобы добавленная глубина вносила больше шума, чем удаляет более мелкий шаг в ошибке Троттера, дальнейшие сокращения больше не улучшают точность. Размер шага должен быть выбран так, чтобы сбалансировать эти два фактора.

Решение динамических уравнений с высокой точностью считается одной из тех задач, где квантовые компьютеры со временем превзойдут классические. Это руководство — отличное место, чтобы начать экспериментировать уже сегодня, используя Julia в качестве интерфейса.

Обязательно ознакомьтесь с полным руководством, в котором каждый шаг представлен в виде исполняемого блокнота Julia.

Почему это важно для квантово-ориентированных суперкомпьютеров

Тесная связь между классическим кодом и квантовыми инструкциями, которую мы видим в приведенном выше примере, — это именно то, что делает C API Qiskit привлекательным для квантово-ориентированных суперкомпьютеров (QCSC) — развивающейся структуры, которая позволила продемонстрировать первые преимущества квантовых вычислений. Квантовый вызов становится связанной подпрограммой внутри существующего кода симуляции, а не отдельным процессом или под-интерпретатором Python для оркестрации.

Все три пути, описанные в этом блоге, обладают этим свойством. Fortran, C++ и Julia обращаются к ядру Qiskit на Rust через прямой нативный вызов, без интерпретатора между ними. Это означает, что вы можете написать свою собственную часть рабочего процесса — пользовательское разложение Троттера, новый анзац, специфичный для задачи оценщик смягчения ошибок или целевую функцию, которую оптимизатор оценивает на квантовом оборудовании тысячи раз — на языке, на котором уже говорит остальная часть вашего кода.

Создавайте вместе с нами

Если вы исследователь и работаете над приложениями, которые могут выиграть от использования квантовых вычислений на Fortran, C++ или Julia, мы надеемся, что вы найдете время изучить руководство, соответствующее вашей области. Попробуйте и выполните свой квантовый рабочий процесс на реальном оборудовании. Затем сделайте следующий шаг и подумайте, какую задачу вы больше всего хотели бы решить на квантовом компьютере.

Все эти привязки, отличные от Python, находятся в активной разработке. Если у вас есть отзывы или вы хотите внести свой вклад, пожалуйста, откройте issue или pull request. Мы создаем эти пути для вашего сообщества и надеемся, что вы присоединитесь к нам в этой работе.

Внедрите квантовые вычисления в свою кодовую базу уже сегодня. Посетите IBM Quantum Platform, чтобы создать бесплатную учетную запись, провести эксперименты на реальном квантовом оборудовании и изучить документацию по C API, руководства и привязки для Fortran, C++ и Julia.