Iskay Quantum Optimizer - פונקציית Qiskit מבית Kipu Quantum

הערה

Qiskit Functions הן תכונה ניסיונית הזמינה רק למשתמשי IBM Quantum® Premium Plan, Flex Plan, ו-On-Prem (דרך IBM Quantum Platform API) Plan. הן במעמד גרסת תצוגה מקדימה וכפופות לשינויים.

סקירה כללית

עם Iskay Quantum Optimizer מבית Kipu Quantum, אפשר להתמודד עם בעיות אופטימיזציה מורכבות באמצעות מחשבים קוונטיים של IBM®. הפותר הזה מנצל את האלגוריתם החדשני bf-DCQO של Kipu, שדורש רק את פונקציית המטרה כקלט ומספק אוטומטית פתרונות לבעיה. הוא מסוגל לטפל בבעיות אופטימיזציה הכוללות עד 156 qubit, מה שמאפשר שימוש בכל ה-Qubit של מכשירי הקוונטום של IBM. ה-Optimizer משתמש במיפוי 1-ל-1 בין משתנים קלאסיים ל-Qubit, מה שמאפשר לך להתמודד עם בעיות אופטימיזציה עם עד 156 משתנים בינאריים.

ה-Optimizer מאפשר פתרון בעיות אופטימיזציה בינארית ללא אילוצים. בנוסף לפורמולציה הנפוצה QUBO (Quadratic Unconstrained Binary Optimization), הוא תומך גם בבעיות אופטימיזציה מסדר גבוה יותר (HUBO). הפותר מנצל אלגוריתם קוונטי לא-וריאציוני, שמבצע את רוב החישוב על מכשירים קוונטיים.

להלן פרטים נוספים על האלגוריתם שבו נעשה שימוש ומדריך קצר כיצד להשתמש בפונקציה, כמו גם תוצאות ביצועים השוואתיות על מגוון מופעי בעיות בגדלים ומורכבויות שונות.

תיאור

ה-Optimizer הוא מימוש מוכן לשימוש של אלגוריתמי אופטימיזציה קוונטית חדשניים. הוא פותר בעיות אופטימיזציה על ידי הרצת Circuit קוונטיים דחוסים מאוד על חומרה קוונטית. דחיסה זו מושגת על ידי הוספת איברים קונטר-אדיאבטיים לאבולוציה בזמן של המערכת הקוונטית. האלגוריתם מבצע מספר איטרציות של ריצות חומרה כדי לקבל את הפתרונות הסופיים ומשלב אותן עם עיבוד-המשך קלאסי (post-processing). שלבים אלה משולבים בצורה חלקה בתהליך העבודה של ה-Optimizer ומבוצעים אוטומטית.

איך עובד ה-Quantum Optimizer?

סעיף זה מתאר את הבסיס של אלגוריתם bf-DCQO המיושם. מבוא לאלגוריתם ניתן למצוא גם בערוץ YouTube של Qiskit.

האלגוריתם מבוסס על האבולוציה בזמן של מערכת קוונטית שמשתנה לאורך זמן, כאשר פתרון הבעיה מקודד במצב היסוד של המערכת הקוונטית בסוף האבולוציה. לפי משפט האדיאבטי, אבולוציה זו חייבת להיות איטית כדי להבטיח שהמערכת נשארת במצב היסוד שלה. דיגיטציה של אבולוציה זו היא הבסיס של חישוב קוונטי אדיאבטי דיגיטלי (DQA) ואלגוריתם QAOA המפורסם. עם זאת, האבולוציה האיטית הנדרשת אינה ישימה עבור גדלי בעיות הולכים וגדלים מכיוון שהיא מביאה לעומק Circuit הולך וגדל. על ידי שימוש בפרוטוקולים counterdiabatic, אפשר לדכא עירורים לא רצויים המתרחשים במהלך זמני אבולוציה קצרים תוך כדי שמירה על מצב היסוד. כאן, דיגיטציה של זמן אבולוציה קצר יותר זה מביאה ל-Circuit קוונטיים בעומק קצר יותר ועם פחות שערי קשירה.

ה-Circuit של אלגוריתמי bf-DCQO משתמשים בדרך כלל בעד עשר פעמים פחות שערי קשירה מאשר DQA, ובשלוש עד ארבע פעמים פחות שערי קשירה מאשר מימושי QAOA סטנדרטיים. בגלל מספר שערים קטן יותר, מתרחשות פחות שגיאות במהלך ביצוע ה-Circuit על חומרה. לכן, ה-Optimizer לא דורש שימוש בטכניקות כמו דיכוי שגיאות או מיתון שגיאות. יישום שלהן בגרסאות עתידיות יכול לשפר עוד יותר את איכות הפתרון.

למרות שאלגוריתם bf-DCQO משתמש באיטרציות, הוא לא-וריאציוני. לאחר כל איטרציה של האלגוריתם נמדדת התפלגות המצבים. ההתפלגות שהתקבלה משמשת לחישוב מה שנקרא "שדה הטיה". שדה ההטיה מאפשר להתחיל את האיטרציה הבאה ממצב אנרגיה קרוב לפתרון שנמצא קודם. בדרך זו, האלגוריתם עובר עם כל איטרציה לפתרונות של אנרגיה נמוכה יותר. בדרך כלל כעשר איטרציות מספיקות כדי להתכנס לפתרון, כך שבסך הכול נדרשות הרבה פחות איטרציות מאשר באלגוריתמים וריאציוניים, שבהם נדרשות בסדר גודל של 100 איטרציות.

ה-Optimizer משלב את אלגוריתם bf-DCQO עם עיבוד-המשך (post-processing) קלאסי. לאחר מדידת התפלגות המצבים, מתבצע חיפוש מקומי. במהלך החיפוש המקומי, הסיביות של הפתרון הנמדד מתהפכות באופן אקראי. לאחר ההיפוך, האנרגיה של המחרוזת הבינארית החדשה מוערכת. אם האנרגיה נמוכה יותר, המחרוזת הבינארית נשמרת כפתרון החדש. החיפוש המקומי גדל רק ליניארית עם מספר ה-Qubit; לכן, הוא זול מבחינה חישובית. מכיוון שעיבוד-ההמשך מתקן היפוכי סיביות מקומיים, הוא מפצה על שגיאות היפוך סיבית שלעיתים קרובות הן תוצאה של פגמי חומרה ושגיאות קריאה.

תהליך עבודה

להלן סכמה של תהליך העבודה של ה-Quantum Optimizer.

Workflow

על ידי שימוש ב-Quantum Optimizer, פתרון בעיית אופטימיזציה על חומרה קוונטית ניתן לצמצם ל:

ניסוח פונקציית המטרה של הבעיה
גישה ל-Optimizer דרך Qiskit Functions
הרצת ה-Optimizer ואיסוף התוצאה

ביצועים השוואתיים

כתב ויתור

הביצועים עשויים להיות תלויים הן במופע הבעיה והן בשלבי העיבוד הבאים. במקרים מסוימים, דגימות קלאסיות ודגימות שנוצרו קוונטית עשויות להשיג איכות פתרון סופית דומה לאחר עיבוד שווה-ערך. לכן, בהערכת הביצועים יש להביא בחשבון את תהליך האופטימיזציה המלא.

מדדי הביצועים ההשוואתיים שלהלן מראים שה-Optimizer מטפל ביעילות בבעיות הכוללות עד 156 qubit ומציעים סקירה כללית של דיוק ה-Optimizer ויכולת ההרחבה שלו על פני סוגי בעיות שונים. שים לב שמדדי הביצועים בפועל עשויים להשתנות בהתאם למאפייני הבעיה הספציפיים, כגון מספר המשתנים, הצפיפות והמקומיות של האיברים בפונקציית המטרה, והסדר הפולינומי.

הטבלה הבאה כוללת את יחס הקירוב (AR), מדד המוגדר כדלקמן:

AR = \frac{C^{*} - C_\textrm{max}}{C_{\textrm{min}} - C_{\textrm{max}}},

כאשר $C$ היא פונקציית המטרה, $C_{\textrm{min}}$ , $C_{\textrm{max}}$ הם הערכים המינימלי והמקסימלי שלה, ו- $C^{*}$ הוא העלות של הפתרון הטוב ביותר שנמצא, בהתאמה. לכן, AR=100% אומר שמצב היסוד של הבעיה הושג.

דוגמה	מספר qubit	יחס קירוב	זמן כולל (שניות)	שימוש בזמן ריצה (שניות)	מספר כולל של shots	מספר איטרציות
Unweighted MaxCut	28	100%	180	30	30k	5
Unweighted MaxCut	30	100%	180	30	30k	5
Unweighted MaxCut	32	100%	180	30	30k	5
Unweighted MaxCut	80	100%	480	60	90k	9
Unweighted MaxCut	100	100%	330	60	60k	6
Unweighted MaxCut	120	100%	370	60	60k	6
HUBO 1	156	100%	600	70	100k	10
HUBO 2	156	100%	600	70	100k	10

מופעי MaxCut עם 28, 30 ו-32 qubit הורצו על ibm_sherbrooke. מופעים עם 80, 100 ו-120 הורצו על מעבד Heron r2.
מופעי HUBO גם הם הורצו על מעבד Heron r2.

כל מופעי הביצועים ההשוואתיים נגישים ב-GitHub (ראה מופעי ביצועים של Kipu). דוגמה להרצת מופעים אלה ניתן למצוא בדוגמה 3: מופעי ביצועים.

התחלה

בתיעוד הזה נעבור על השלבים של שימוש ב-Iskay Quantum Optimizer. בתהליך נראה בקצרה איך לטעון את הפונקציה מהקטלוג ואיך להמיר את הבעיה שלך לקלט תקין, תוך כדי הדגמת אפשרויות הניסוי עם פרמטרים אופציונליים שונים.

לדוגמה מפורטת יותר, כדאי לבדוק את המדריך פתרון בעיית פיצול השוק עם Iskay Quantum Optimizer של Kipu Quantum, שם עוברים על כל התהליך של שימוש ב-Iskay Solver לטיפול בבעיית פיצול השוק — אתגר הקצאת משאבים מהעולם האמיתי שבו שווקים צריכים להתחלק לאזורי מכירה מאוזנים כדי לעמוד ביעדי ביקוש מדויקים.

מתחברים עם מפתח ה-API שלך, שנמצא בלוח המחוונים של IBM Quantum Platform, ובוחרים את Qiskit Function כך:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"github": "PyGithub", "networkx": "networkx", "qiskit_ibm_catalog": "qiskit-ibm-catalog"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

# ruff: noqa: F821

הערה

הקוד הבא מניח שכבר שמרת את פרטי ההתחברות שלך. אם לא עשית זאת, עקוב אחר ההוראות בשמירת חשבון IBM Cloud שלך כדי לאמת עם מפתח ה-API שלך.

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
    instance="INSTANCE_CRN",
    # For `token`, use the 44-character API_KEY you created
    # and saved from the IBM Quantum Platform Home dashboard
    token="YOUR_API_KEY",
)

# verify that you have access to the function
catalog.list()

[QiskitFunction(qunova/hivqe-chemistry),
 QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),
 QiskitFunction(algorithmiq/tem),
 QiskitFunction(qedma/qesem),
 QiskitFunction(multiverse/singularity),
 QiskitFunction(ibm/circuit-function),
 QiskitFunction(q-ctrl/optimization-solver),
 QiskitFunction(colibritd/quick-pde),
 QiskitFunction(q-ctrl/performance-management),
 QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]

# Access Function
optimizer = catalog.load("kipu-quantum/iskay-quantum-optimizer")

דוגמת תצורה מותאמת אישית

כך ניתן להגדיר את Iskay עם הגדרות שונות:

custom_options = {
    "shots": 15_000,  # Higher shot count for better statistics
    "num_iterations": 12,  # More iterations for solution refinement
    "preprocessing_level": 1,  # Light preprocessing for problem simplification
    "postprocessing_level": 2,  # Maximum postprocessing for solution quality
    "transpilation_level": 3,  # Use higher transpilation level to optimize circuit
    "seed_transpiler": 42,  # Fixed seed for reproducible results
    "job_tags": ["custom_config"],  # Custom tracking tags
}

אופטימיזציית seed: שים לב ש-seed_transpiler מוגדר ל-None כברירת מחדל. זה מאפשר את תהליך האופטימיזציה האוטומטי של ה-Transpiler. כאשר None, המערכת תתחיל ניסיון עם seeds מרובים ותבחר את זה המייצר את עומק ה-Circuit הטוב ביותר, תוך ניצול מלוא העוצמה של פרמטר max_trials עבור כל רמת טרנספילציה.

ביצועי רמת טרנספילציה: הגדלת מספר max_trials עם ערכים גבוהים יותר עבור transpilation_level תגדיל בהכרח את זמן הטרנספילציה, אך ייתכן שלא תמיד ישנה את ה-Circuit הסופי — זה תלוי מאוד במבנה ה-Circuit הספציפי ובמורכבותו. עבור חלק מה-Circuit/בעיות, עם זאת, ההבדל בין 10 ניסיונות (רמה 1) ל-50 ניסיונות (רמה 5) יכול להיות דרמטי, לכן חקירת פרמטרים אלה עשויה להיות המפתח למציאת פתרון בהצלחה.

דוגמה 1: פונקציית עלות פשוטה

נתבונן בפונקציית העלות בניסוח ספין:

C(x_0, x_1, x_2, x_3, x_4) = 1 + 1.5x_0 + 2x_1 + 1.3x_2 + 2.5x_0x_3 + 3.5x_1x_4 + 4x_0x_1x_2

כאשר $(x_0, ..., x_4) \in \{-1, 1\}^5$ .

הפתרון לפונקציית העלות הפשוטה הזו הוא

(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)

עם ערך מינימלי $C^{*} = -6$

1. יצירת פונקציית המטרה

מתחילים ביצירת מילון עם המקדמים של פונקציית המטרה כך:

objective_func = {
    "()": 1,
    "(0,)": 1.5,
    "(1,)": 2,
    "(2,)": 1.3,
    "(0, 3)": 2.5,
    "(1, 4)": 3.5,
    "(0, 1, 2)": 4,
}

2. הרצת ה-Optimizer

פותרים את הבעיה על ידי הרצת ה-Optimizer. מאחר ש- $(x_0, ..., x_4) \in \{-1, 1\}^5$ צריך להגדיר problem_type=spin.

# Setup options to run the optimizer
options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

# Print the ID so you can use it later, if necessary
print(job.job_id)

3. שליפת התוצאה

הפתרון לבעיית האופטימיזציה מתקבל ישירות מה-Optimizer.

print(job.result())

זה יציג מילון בצורה הבאה:

{'solution': {'0': -1, '1': -1, '2': -1, '3': 1, '4': 1},
 'solution_info': {'bitstring': '11100',
  'cost': -13.8,
  'seed_transpiler': 42,
  'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}},
 'prob_type': 'spin'}

שים לב שהמילון solution מציג את וקטור התוצאה $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$ .

דוגמה 2: MaxCut

בעיות גרף רבות כמו MaxCut או Maximum independent set הן בעיות NP-hard ומועמדות אידיאליות לבדיקת אלגוריתמים קוונטיים וחומרה. הדוגמה הזו מדגימה פתרון בעיית MaxCut של גרף 3-רגולרי עם Quantum Optimizer.

כדי להריץ את הדוגמה הזו צריך להתקין את חבילת networkx בנוסף ל-qiskit-ibm-catalog. כדי להתקין אותה, מריצים את הפקודה הבאה:

# %pip install networkx numpy

1. יצירת פונקציית המטרה

מתחילים ביצירת גרף 3-רגולרי אקראי. עבור הגרף הזה מגדירים את פונקציית המטרה של בעיית MaxCut.

import networkx as nx

# Create a random 3-regular graph
G = nx.random_regular_graph(3, 10, seed=42)

# Create the objective function for MaxCut in Ising formulation
def graph_to_ising_maxcut(G):
    """
    Convert a NetworkX graph to an Ising Hamiltonian for the max-cut problem.
    Args:
        G (networkx.Graph): The input graph.
    Returns:
        dict: The objective function of the Ising model
    """
    # Initialize the linear and quadratic coefficients
    objective_func = {}
    # Populate the coefficients
    for i, j in G.edges:
        objective_func[f"({i}, {j})"] = 0.5
    return objective_func

objective_func = graph_to_ising_maxcut(G)

2. הרצת ה-Optimizer

פותרים את הבעיה על ידי הרצת ה-Optimizer.

options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. שליפת התוצאה

שולפים את התוצאה וממפים את מחרוזת הביטים של הפתרון בחזרה לצמתים המקוריים של הגרף.

print(job.result())

הפתרון לבעיית MaxCut כלול ישירות במילון המשנה solution של אובייקט התוצאה

maxcut_solution = job.result()["solution"]

דוגמה 3: מופעי ביצועים השוואתיים

מופעי הביצועים ההשוואתיים זמינים ב-GitHub: מופעי ביצועים השוואתיים של Kipu.

אפשר לטעון את המקרים באמצעות הספרייה pygithub. כדי להתקין אותה, הרץ את הפקודה הבאה:

# %pip install pygithub

הנתיבים למופעי הביצועים ההשוואתיים הם:

Maxcut:

'maxcut/maxcut_regular_3_100_nodes_weighted.json'
'maxcut/maxcut_regular_3_140_nodes_weighted.json'
'maxcut/maxcut_regular_3_150_nodes_weighted.json'
'maxcut/maxcut_regular_4_130_nodes_weighted.json'

HUBO:

'HUBO/hubo1_marrakesh.json'
'HUBO/hubo2_marrakesh.json'

כדי לשחזר את ביצועי הבנצ'מארק עבור מופעי ה-HUBO, בחר את ה-Backend‏ ibm_marrakesh והגדר את direct_qubit_mapping לערך True בתת-מילון options. הדוגמה הבאה מריצה את מופע ה-Maxcut עם 150 צמתים.

from github import Github
import urllib
import json
import ast

repo = "Kipu-Quantum-GmbH/benchmark-instances"
path = "maxcut/maxcut_regular_3_150_nodes_weighted.json"
gh = Github()
repo = gh.get_repo(repo)
branch = "main"
file = repo.get_contents(urllib.parse.quote(path), ref=branch)

# load json file with benchmark problem
problem_json = json.loads(file.decoded_content)

# convert objective function to compatible format
objective_func = {
    key: ast.literal_eval(value) for key, value in problem_json.items()
}

# Setup configuration to run the optimizer
options = {
    "shots": 5_000,
    "num_iterations": 5,
    "use_session": True,
    "direct_qubit_mapping": False,
}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": "<BACKEND-NAME>",
    "options": options,
}

job = optimizer.run(**arguments)

result = job.result()

מקרי שימוש

מקרי שימוש טיפוסיים עבור פותר האופטימיזציה הם בעיות אופטימיזציה קומבינטורית. אפשר לפתור בעיות ממגוון תעשיות כמו פיננסים, תרופות או לוגיסטיקה. הנה כמה דוגמאות.

אופטימיזציית תיק השקעות (QUBO): פרסום מדעי ונייר עמדה
קיפול חלבונים (HUBO): פרסום מדעי
תזמון לוגיסטי (QUBO): פרסום מדעי
אופטימיזציית רשתות: וובינר
פיצול שוק (QUBO): מדריך

אם אתה מעוניין להתמודד עם מקרה שימוש ספציפי ולפתח מיפוי ייעודי, נוכל לסייע לך. צור קשר.

קבלת תמיכה

לקבלת תמיכה, פנה אל support@kipu-quantum.com.

צעדים הבאים

בקש גישה ל-Quantum Optimizer מאת Kipu Quantum.
בקר בהפניית ה-API עבור Qiskit Function זו.
נסה את המדריך פתרון בעיית פיצול השוק עם Iskay Quantum Optimizer של Kipu Quantum.
ראה ב-Romero, S. V., et al. (2025). Bias-Field Digitized Counterdiabatic Quantum Algorithm for Higher-Order Binary Optimization. arXiv preprint arXiv:2409.04477.
ראה ב-Cadavid, A. G., et al. (2024). Bias-field digitized counterdiabatic quantum optimization. arXiv preprint arXiv:2405.13898.
ראה ב-Chandarana, P., et al. (2025). Runtime Quantum Advantage with Digital Quantum Optimization. arXiv preprint arXiv:2505.08663.

מידע נוסף

Iskay, כמו שם החברה שלנו Kipu Quantum, היא מילה פרואנית. למרות שאנחנו סטארטאפ מגרמניה, המילים האלו מגיעות ממולדתו של אחד ממייסדי-השותפים שלנו, שם ה-Quipu היה אחד ממכשירי החישוב הראשונים שפיתחה האנושות, כבר בסביבות שנת 2000 לפני הספירה.

סקירה כללית​

תיאור​

איך עובד ה-Quantum Optimizer?​

תהליך עבודה​

ביצועים השוואתיים​

התחלה​

דוגמת תצורה מותאמת אישית​

דוגמה 1: פונקציית עלות פשוטה​

1. יצירת פונקציית המטרה​

2. הרצת ה-Optimizer​

3. שליפת התוצאה​

דוגמה 2: MaxCut​

1. יצירת פונקציית המטרה​

2. הרצת ה-Optimizer​

3. שליפת התוצאה​

דוגמה 3: מופעי ביצועים השוואתיים​

מקרי שימוש​

קבלת תמיכה​

צעדים הבאים​

מידע נוסף​

סקירה כללית

תיאור

איך עובד ה-Quantum Optimizer?

תהליך עבודה

ביצועים השוואתיים

התחלה

דוגמת תצורה מותאמת אישית

דוגמה 1: פונקציית עלות פשוטה

1. יצירת פונקציית המטרה

2. הרצת ה-Optimizer

3. שליפת התוצאה

דוגמה 2: MaxCut

1. יצירת פונקציית המטרה

2. הרצת ה-Optimizer

3. שליפת התוצאה

דוגמה 3: מופעי ביצועים השוואתיים

מקרי שימוש

קבלת תמיכה

צעדים הבאים

מידע נוסף