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

הערה

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

סקירה כללית

עם 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 קוונטיים דחוסים מאוד על חומרה קוונטית. דחיסה זו מושגת על ידי הכנסת מושגים counterdiabatic לאבולוציה בזמן של המערכת הקוונטית. האלגוריתם מבצע מספר איטרציות של ריצות חומרה כדי לקבל את הפתרונות הסופיים ומשלב אותן עם עיבוד לאחר. שלבים אלה משולבים בצורה חלקה בתהליך העבודה של ה-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 עם עיבוד לאחר קלאסי. לאחר מדידת התפלגות המצבים, מתבצע חיפוש מקומי. במהלך החיפוש המקומי, הסיביות של הפתרון הנמדד מתהפכות באופן אקראי. לאחר ההיפוך, האנרגיה של המחרוזת הבינארית החדשה מוערכת. אם האנרגיה נמוכה יותר, המחרוזת הבינארית נשמרת כפתרון החדש. החיפוש המקומי מתרחב רק ליניארית עם מספר ה-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 — required packages for this notebook
!pip install -q PyGithub networkx qiskit-ibm-catalog

# ruff: noqa: F821

הערה

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

from qiskit_ibm_catalog import QiskitFunctionsCatalog

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

# 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,  # Using higher transpilation level for circuit optimization
    "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. הרצת המייעל

פותרים את הבעיה על ידי הרצת המייעל. מאחר ש- $(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)

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

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

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. הרצת המייעל

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

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_28_nodes.json'
'maxcut/maxcut_30_nodes.json'
'maxcut/maxcut_32_nodes.json'
'maxcut/maxcut_80_nodes.json'
'maxcut/maxcut_100_nodes.json'
'maxcut/maxcut_120_nodes.json'

HUBO:

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

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

from github import Github
import urllib
import json
import ast

repo = "Kipu-Quantum-GmbH/benchmark-instances"
path = "maxcut/maxcut_32_nodes.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": "ibm_brisbane",
    "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. הרצת המייעל​

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

דוגמה 2: MaxCut​

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

2. הרצת המייעל​

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

דוגמה 3: מקרי בנצ'מארק​

מקרי שימוש​

קבלת תמיכה​

צעדים הבאים​

מידע נוסף​

סקירה כללית

תיאור

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

תהליך עבודה

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

התחלה

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

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

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

2. הרצת המייעל

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

דוגמה 2: MaxCut

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

2. הרצת המייעל

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

דוגמה 3: מקרי בנצ'מארק

מקרי שימוש

קבלת תמיכה

צעדים הבאים

מידע נוסף