דלג לתוכן הראשי

Singularity Machine Learning - Classification: פונקציית Qiskit מאת Multiverse Computing

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

סקירה כללית​

עם פונקציית "Singularity Machine Learning - Classification", אתה יכול לפתור בעיות למידת מכונה מהעולם האמיתי על חומרה קוונטית מבלי שתידרש מומחיות קוונטית. פונקציית Application זו, המבוססת על שיטות אנסמבל, היא מסווג היברידי. היא מנצלת שיטות קלאסיות כמו boosting, bagging ו-stacking לאימון אנסמבל ראשוני. לאחר מכן, אלגוריתמים קוונטיים כגון variational quantum eigensolver (VQE) ו-quantum approximate optimization algorithm (QAOA) מוחלים כדי לשפר את הגיוון, יכולות ההכללה, והמורכבות הכוללת של האנסמבל המאומן.

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

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

הדוגמה הבאה מציגה את הפונקציונליות השונות שלה, כולל create, list, fit ו-predict, ומדגימה את השימוש בה בבעיה סינתטית המורכבת משני חצאי עיגולים משתלבים — בעיה ידועה לשמצה בגלל הגבול ההחלטה הלא-לינארי שלה.

תיאור הפונקציה​

פונקציית Qiskit זו מאפשרת למשתמשים לפתור בעיות סיווג בינארי באמצעות מסווג האנסמבל המשופר קוונטית של Singularity. מאחורי הקלעים, היא משתמשת בגישה היברידית לאימון קלאסי של אנסמבל מסווגים על סט הנתונים המתויג, ולאחר מכן לאופטימיזציה שלו לגיוון מרבי והכללה באמצעות Quantum Approximate Optimization Algorithm (QAOA) על IBM® QPUs. דרך ממשק ידידותי למשתמש, ניתן להגדיר מסווג בהתאם לדרישות שלך, לאמן אותו על סט הנתונים שתבחר, ולהשתמש בו לביצוע תחזיות על סט נתונים שלא נראה בעבר.

לפתרון בעיית סיווג גנרית:

  1. עבד מראש את סט הנתונים, וחלק אותו לסטי אימון ובדיקה. באופן אופציונלי, ניתן לחלק עוד יותר את סט האימון לסטי אימון ואימות. ניתן להשיג זאת באמצעות scikit-learn.
  2. אם סט האימון אינו מאוזן, ניתן לדגום אותו מחדש כדי לאזן את המחלקות באמצעות imbalanced-learn.
  3. העלה את סטי האימון, האימות והבדיקה בנפרד לאחסון הפונקציה באמצעות שיטת file_upload של הקטלוג, תוך העברת הנתיב הרלוונטי בכל פעם.
  4. אתחל את המסווג הקוונטי באמצעות פעולת create של הפונקציה, המקבלת hyperparameters כגון מספר סוגי הלומדים, הרגולריזציה (ערך lambda), ואפשרויות אופטימיזציה כולל מספר שכבות, סוג האופטימייזר הקלאסי, ה-Backend הקוונטי, וכן הלאה.
  5. אמן את המסווג הקוונטי על סט האימון באמצעות פעולת fit של הפונקציה, תוך העברת סט האימון המתויג, וסט האימות אם רלוונטי.
  6. בצע תחזיות על סט הבדיקה שלא נראה בעבר באמצעות פעולת predict של הפונקציה.

גישה מבוססת פעולות​

הפונקציה משתמשת בגישה מבוססת פעולות. ניתן לחשוב עליה כסביבה וירטואלית שבה אתה משתמש בפעולות לביצוע משימות או לשינוי מצבה. כרגע, היא מציעה את הפעולות הבאות: list, create, delete, fit, predict, fit_predict ו-create_fit_predict. הדוגמה הבאה מדגימה את פעולת create_fit_predict.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit-ibm-catalog scikit-learn
# Import QiskitFunctionsCatalog to load the
# "Singularity Machine Learning - Classification" function by Multiverse Computing
from qiskit_ibm_catalog import QiskitFunctionsCatalog

# Import the make_moons and the train_test_split functions from scikit-learn
# to create a synthetic dataset and split it into training and test datasets
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# authentication
# If you have not previously saved your credentials, follow instructions at
# /docs/guides/functions
# to authenticate with your API key.
catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# load "Singularity Machine Learning - Classification" function by Multiverse Computing
singularity = catalog.load("multiverse/singularity")

# generate the synthetic dataset
X, y = make_moons(n_samples=1000)

# split the data into training and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

job = singularity.run(
    action="create_fit_predict",
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
    X_train=X_train,
    y_train=y_train,
    X_test=X_test,
    options={"save": False},
)

# get job status and result
status = job.status()
result = job.result()

print("Job status: ", status)
print("Action result status: ", result["status"])
print("Action result message: ", result["message"])
print("Predictions (first five results): ", result["data"]["predictions"][:5])
print(
    "Probabilities (first five results): ",
    result["data"]["probabilities"][:5],
)
print("Usage metadata: ", result["metadata"]["resource_usage"])
Job status:  QUEUED
Action result status:  ok
Action result message:  Classifier created, fitted, and predicted.
Predictions (first five results):  [1, 0, 0, 1, 0]
Probabilities (first five results):  [[0.16849563539001172, 0.8315043646099888], [0.8726393386620336, 0.12736066133796647], [0.795344837290717, 0.20465516270928288], [0.36822585748882725, 0.6317741425111725], [0.6656662698604361, 0.3343337301395641]]
Usage metadata:  {'RUNNING: MAPPING': {'CPU_TIME': 7.945035696029663}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 82.41029238700867}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 77.3459484577179}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 71.27004957199097}}

1. List​

פעולת list מאחזרת את כל המסווגים המאוחסנים בפורמט *.pkl.tar מספריית הנתונים המשותפת. ניתן גם לגשת לתוכן הספרייה הזו באמצעות שיטת catalog.files(). בדרך כלל, פעולת ה-list מחפשת קבצים עם הסיומת *.pkl.tar בספריית הנתונים המשותפת ומחזירה אותם בפורמט רשימה.

קלט​

שםסוגתיאורחובה
actionstrשם הפעולה מבין create, list, fit, predict, fit_predict, create_fit_predict ו-delete.כן

שימוש​

job = singularity.run(action="list")

2. Create​

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

הערה

הפונקציה תומכת כרגע רק ב-QuantumEnhancedEnsembleClassifier.

קלט​

שםסוגתיאורחובהברירת מחדל
actionstrשם הפעולה מבין create, list, fit, predict, fit_predict, create_fit_predict ו-delete.כן-
namestrשם המסווג הקוונטי, למשל spam_classifier.כן-
instancestrמופע IBM.כן-
backend_namestrמשאב מחשוב IBM. ברירת המחדל היא None, כלומר ה-Backend עם הכי מעט משימות ממתינות ייבחר.לאNone
quantum_classifierstrסוג המסווג הקוונטי, כלומר QuantumEnhancedEnsembleClassifier.לאQuantumEnhancedEnsembleClassifier
num_learnersintegerמספר הלומדים באנסמבל.לא10
learners_typeslistסוגי הלומדים. בין הסוגים הנתמכים: DecisionTreeClassifier, GaussianNB, KNeighborsClassifier, MLPClassifier ו-LogisticRegression. פרטים נוספים על כל אחד ניתן למצוא בתיעוד scikit-learn.לא[DecisionTreeClassifier]
learners_proportionslistיחסי כל סוג לומד באנסמבל.לא[1.0]
learners_optionslistאפשרויות לכל סוג לומד באנסמבל. לרשימה מלאה של האפשרויות המתאימות לסוג הלומד שנבחר, עיין בתיעוד scikit-learn.לא[{"max_depth": 3, "splitter": "random", "class_weight": None}]
regularization_typestr או listסוג/ים של רגולריזציה לשימוש: onsite או alpha. onsite שולט בגורם ה-onsite כאשר ערכים גבוהים יותר מובילים לאנסמבלים דלילים יותר. alpha שולט בפשרה בין גורמי האינטראקציה וה-onsite כאשר ערכים נמוכים יותר מובילים לאנסמבלים דלילים יותר. אם מסופקת רשימה, מודלים יאומנו לכל סוג והמוצלח ביותר ייבחר.לאonsite
regularizationstr או float או listערך הרגולריזציה. מוגבל בין 0 ל-+inf אם regularization_type הוא onsite. מוגבל בין 0 ל-1 אם regularization_type הוא alpha. אם מוגדר ל-auto, נעשה שימוש ברגולריזציה אוטומטית — פרמטר הרגולריזציה האופטימלי נמצא בחיפוש בינארי עם יחס הסיווגים הנבחרים לסיווגים הכולל הרצוי (regularization_desired_ratio) והגבול העליון לפרמטר הרגולריזציה (regularization_upper_bound). אם מסופקת רשימה, מודלים יאומנו לכל ערך והמוצלח ביותר ייבחר.לא0.01
regularization_desired_ratiofloat או listיחס/ים רצויים של סיווגים נבחרים לסיווגים כולל לרגולריזציה אוטומטית. אם מסופקת רשימה, מודלים יאומנו לכל יחס והמוצלח ביותר ייבחר.לא0.75
regularization_upper_boundfloat או listגבול/ות עליון/ים לפרמטר הרגולריזציה בעת שימוש ברגולריזציה אוטומטית. אם מסופקת רשימה, מודלים יאומנו לכל גבול עליון והמוצלח ביותר ייבחר.לא200
weight_update_methodstrשיטה לעדכון משקלי דגימה מבין logarithmic ו-quadratic.לאlogarithmic
sample_scalingbooleanהאם להחיל קנה מידה על הדגימות.לאFalse
prediction_scalingfloatגורם קנה מידה לתחזיות.לאNone
optimizer_optionsdictionaryאפשרויות האופטימייזר של QAOA. רשימת האפשרויות הזמינות מוצגת בהמשך התיעוד.לא...
votingstrהשתמש בהצבעת רוב (hard) או ממוצע הסתברויות (soft) לאגרגציה של תחזיות/הסתברויות הלומדים.לאhard
prob_thresholdfloatסף הסתברות אופטימלי.לא0.5
random_stateintegerשליטה באקראיות לצורך ניתן לחזרה.לאNone
  • בנוסף, optimizer_options מפורטות כדלקמן:
שםסוגתיאורחובהברירת מחדל
num_solutionsintegerמספר הפתרונותלא1024
repsintegerמספר החזרותלא4
sparsifyfloatסף הדילוללא0.001
thetafloatהערך ההתחלתי של theta, פרמטר וריאציוני של QAOAלאNone
simulatorbooleanהאם להשתמש בסימולטור או ב-QPUלאFalse
classical_optimizerstrשם האופטימייזר הקלאסי ל-QAOA. כל ה-solvers המוצעים על ידי SciPy, כמפורט כאן, ניתנים לשימוש. יש להגדיר את classical_optimizer_options בהתאםלאCOBYLA
classical_optimizer_optionsdictionaryאפשרויות האופטימייזר הקלאסי. לרשימה מלאה של האפשרויות הזמינות, עיין בתיעוד SciPyלא{"maxiter": 60}
optimization_levelintegerעומק ה-Circuit של QAOAלא3
num_transpiler_runsintegerמספר ריצות ה-Transpilerלא30
pass_manager_optionsdictionaryאפשרויות ליצירת pass manager מוגדר מראשלא{"approximation_degree": 1.0}
estimator_optionsdictionaryאפשרויות Estimator. לרשימה מלאה של האפשרויות הזמינות, עיין בתיעוד Qiskit Runtime ClientלאNone
sampler_optionsdictionaryאפשרויות Sampler. לרשימה מלאה של האפשרויות הזמינות, עיין בתיעוד Qiskit Runtime ClientלאNone
  • ברירות המחדל של estimator_options הן:
שםסוגערך
default_shotsinteger1024
resilience_levelinteger2
twirlingdictionary{"enable_gates": True}
dynamical_decouplingdictionary{"enable": True}
resilience_optionsdictionary{"zne_mitigation": False, "zne": {"amplifier": "pea", "noise_factors": [1.0, 1.3, 1.6], "extrapolator": ["linear", "polynomial_degree_2", "exponential"],}}
  • ברירות המחדל של sampler_options הן:
שםסוגערך
default_shotsinteger1024
resilience_levelinteger1
twirlingdictionary{"enable_gates": True}
dynamical_decouplingdictionary{"enable": True}

שימוש​

job = singularity.run(
    action="create",
    name="classifier_name",  # specify your custom name for the classifier here
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
)

אימותים​

  • name:
    • השם חייב להיות ייחודי, מחרוזת באורך עד 64 תווים.
    • יכול לכלול רק תווים אלפאנומריים וקווים תחתונים.
    • חייב להתחיל באות ולא יכול להסתיים בקו תחתון.
    • אסור שמסווג עם אותו שם כבר יקיים בספריית הנתונים המשותפת.

3. Delete​

פעולת delete מסירה מסווג מספריית הנתונים המשותפת.

קלט​

שםסוגתיאורחובה
actionstrשם הפעולה. חייב להיות delete.כן
namestrשם המסווג למחיקה.כן

שימוש​

job = singularity.run(
    action="delete",
    name="classifier_name",  # specify the name of the classifier to delete here
)

אימותים​

  • name:
    • השם חייב להיות ייחודי, מחרוזת באורך עד 64 תווים.
    • יכול לכלול רק תווים אלפאנומריים וקווים תחתונים.
    • חייב להתחיל באות ולא יכול להסתיים בקו תחתון.
    • מסווג עם אותו שם חייב כבר לקיים בספריית הנתונים המשותפת.

4. Fit​

פעולת fit מאמנת מסווג באמצעות נתוני האימון שסופקו.

קלט​

שםסוגתיאורחובה
actionstrשם הפעולה. חייב להיות fit.כן
namestrשם המסווג לאימון.כן
Xarray או list או strנתוני האימון. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
yarray או list או strערכי היעד לאימון. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
fit_paramsdictionaryפרמטרים נוספים להעברה לשיטת fit של המסווג.לא
fit_params​
שםסוגתיאורחובהברירת מחדל
validation_datatupleנתוני האימות והתוויות.לאNone
pos_labelinteger או strתווית המחלקה שתמופה ל-1.לאNone
optimization_datastrסט נתונים לאופטימיזציה של האנסמבל עליו. יכול להיות אחד מ: train, validation, both.לאtrain

שימוש​

job = singularity.run(
    action="fit",
    name="classifier_name",  # specify the name of the classifier to train here
    X=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
)

אימותים​

  • name:
    • השם חייב להיות ייחודי, מחרוזת באורך עד 64 תווים.
    • יכול לכלול רק תווים אלפאנומריים וקווים תחתונים.
    • חייב להתחיל באות ולא יכול להסתיים בקו תחתון.
    • מסווג עם אותו שם חייב כבר לקיים בספריית הנתונים המשותפת.

5. Predict​

פעולת predict משמשת לקבלת תחזיות קשות ורכות (הסתברויות).

קלט​

שםסוגתיאורחובה
actionstrשם הפעולה. חייב להיות predict.כן
namestrשם המסווג לשימוש.כן
Xarray או list או strנתוני הבדיקה. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
options["out"]strשם קובץ JSON הפלט לשמירת התחזיות בספריית הנתונים המשותפת. אם לא סופק, התחזיות מוחזרות בתוצאת ה-job.לא

שימוש​

job = singularity.run(
    action="predict",
    name="classifier_name",  # specify the name of the classifier to use here
    X=X_test,  # or "X_test.npy" if you uploaded it to the shared data directory
    options={
        "out": "output.json",
    },
)

אימותים​

  • name:
    • השם חייב להיות ייחודי, מחרוזת באורך עד 64 תווים.
    • יכול לכלול רק תווים אלפאנומריים וקווים תחתונים.
    • חייב להתחיל באות ולא יכול להסתיים בקו תחתון.
    • מסווג עם אותו שם חייב כבר לקיים בספריית הנתונים המשותפת.
  • options["out"]:
    • שם הקובץ חייב להיות ייחודי, מחרוזת באורך עד 64 תווים.
    • יכול לכלול רק תווים אלפאנומריים וקווים תחתונים.
    • חייב להתחיל באות ולא יכול להסתיים בקו תחתון.
    • חייב לכלול את הסיומת .json.

6. Fit-predict​

פעולת fit_predict מאמנת מסווג באמצעות נתוני האימון ולאחר מכן משתמשת בו לקבלת תחזיות קשות ורכות (הסתברויות).

קלט​

שםסוגתיאורחובה
actionstrשם הפעולה. חייב להיות fit_predict.כן
namestrשם המסווג לשימוש.כן
X_trainarray או list או strנתוני האימון. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
y_trainarray או list או strערכי היעד לאימון. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
X_testarray או list או strנתוני הבדיקה. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
fit_paramsdictionaryפרמטרים נוספים להעברה לשיטת fit של המסווג.לא
options["out"]strשם קובץ JSON הפלט לשמירת התחזיות בספריית הנתונים המשותפת. אם לא סופק, התחזיות מוחזרות בתוצאת ה-job.לא

שימוש​

job = singularity.run(
    action="fit_predict",
    name="classifier_name",  # specify the name of the classifier to use here
    X_train=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y_train=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    X_test=X_test,  # or "X_test.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
    options={
        "out": "output.json",
    },
)

אימותים​

  • name:

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

  • options["out"]:

    • שם הקובץ חייב להיות ייחודי, מחרוזת באורך עד 64 תווים.
    • יכול לכלול רק תווים אלפאנומריים וקווים תחתונים.
    • חייב להתחיל באות ולא יכול להסתיים בקו תחתון.
    • חייב לכלול את הסיומת .json.

7. Create-fit-predict​

פעולת create_fit_predict יוצרת מסווג, מאמנת אותו באמצעות נתוני האימון שסופקו, ולאחר מכן משתמשת בו לקבלת תחזיות קשות ורכות (הסתברויות).

קלט​

שםסוגתיאורחובה
actionstrשם הפעולה מבין create, list, fit, predict, fit_predict, create_fit_predict ו-delete.כן
namestrשם המסווג לשימוש.כן
quantum_classifierstrסוג המסווג, כלומר QuantumEnhancedEnsembleClassifier. ברירת המחדל היא QuantumEnhancedEnsembleClassifier.לא
X_trainarray או list או strנתוני האימון. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
y_trainarray או list או strערכי היעד לאימון. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
X_testarray או list או strנתוני הבדיקה. יכול להיות מערך NumPy, רשימה, או מחרוזת המפנה לשם קובץ בספריית הנתונים המשותפת.כן
fit_paramsdictionaryפרמטרים נוספים להעברה לשיטת fit של המסווג.לא
options["save"]booleanהאם לשמור את המסווג המאומן בספריית הנתונים המשותפת. ברירת המחדל היא True.לא
options["out"]strשם קובץ JSON הפלט לשמירת התחזיות בספריית הנתונים המשותפת. אם לא סופק, התחזיות מוחזרות בתוצאת ה-job.לא

שימוש​

job = singularity.run(
    action="create_fit_predict",
    name="classifier_name",  # specify your custom name for the classifier here
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
    X_train=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y_train=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    X_test=X_test,  # or "X_test.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
    options={
        "save": True,
        "out": "output.json",
    },
)

אימותים​

  • name:

    • אם options["save"] מוגדר ל-True:
      • השם חייב להיות ייחודי, מחרוזת באורך עד 64 תווים.
      • יכול לכלול רק תווים אלפאנומריים וקווים תחתונים.
      • חייב להתחיל באות ולא יכול להסתיים בקו תחתון.
      • אסור שמסווג עם אותו שם כבר יקיים בספריית הנתונים המשותפת.

  • options["out"]:

    • שם הקובץ חייב להיות ייחודי, מחרוזת באורך עד 64 תווים.
    • יכול לכלול רק תווים אלפאנומריים וקווים תחתונים.
    • חייב להתחיל באות ולא יכול להסתיים בקו תחתון.
    • חייב לכלול את הסיומת .json.

התחלה​

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

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# load function
singularity = catalog.load("multiverse/singularity")

דוגמה​

בדוגמה זו, תשתמש בפונקציית "Singularity Machine Learning - Classification" כדי לסווג סט נתונים המורכב משני חצאי עיגולים בצורת ירח המשתלבים. סט הנתונים הוא סינתטי, דו-ממדי, ומתויג בתוויות בינאריות. הוא נוצר כך שיהיה מאתגר לאלגוריתמים כמו קיבוץ מבוסס-צנטרואיד וסיווג לינארי. סט נתוני ירחים במהלך תהליך זה, תלמד כיצד ליצור את המסווג, לאמן אותו על נתוני האימון, להשתמש בו לביצוע תחזיות על נתוני הבדיקה, ולמחוק את המסווג כשתסיים. לפני שתתחיל, עליך להתקין את scikit-learn. התקן אותו באמצעות הפקודה הבאה:

python3 -m pip install scikit-learn

בצע את השלבים הבאים:

  1. צור את סט הנתונים הסינתטי באמצעות פונקציית make_moons מ-scikit-learn.
  2. העלה את סט הנתונים הסינתטי שנוצר לספריית הנתונים המשותפת.
  3. צור את המסווג המשופר קוונטית באמצעות פעולת create.
  4. רשום את המסווגים שלך באמצעות פעולת list.
  5. אמן את המסווג על נתוני האימון באמצעות פעולת fit.
  6. השתמש במסווג המאומן לביצוע תחזיות על נתוני הבדיקה באמצעות פעולת predict.
  7. מחק את המסווג באמצעות פעולת delete.
  8. נקה לאחר שסיימת. שלב 1. ייבא את המודולים הדרושים וצור את סט הנתונים הסינתטי, לאחר מכן חלק אותו לסטי אימון ובדיקה.
# import the necessary modules for this example
import os
import tarfile
import numpy as np

# Import the make_moons and the train_test_split functions from scikit-learn
# to create a synthetic dataset and split it into training and test datasets
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# generate the synthetic dataset
X, y = make_moons(n_samples=10000)

# split the data into training and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# print the first 10 samples of the training dataset
print("Features:", X_train[:10, :])
print("Targets:", y_train[:10])
Features: [[-0.99958218  0.02890441]
 [ 0.03285169  0.24578719]
 [ 1.13127903 -0.49134546]
 [ 1.86951286  0.00608971]
 [ 0.20190413  0.97940529]
 [ 0.8831311   0.46912627]
 [-0.10819442  0.99412975]
 [-0.20005727  0.97978421]
 [-0.78775705  0.61598607]
 [ 1.82453236 -0.0658148 ]]
Targets: [0 1 1 1 0 0 0 0 0 1]

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

def make_tarfile(file_path, tar_file_name):
    with tarfile.open(tar_file_name, "w") as tar:
        tar.add(file_path, arcname=os.path.basename(file_path))

# save the training and test datasets on your local disk
np.save("X_train.npy", X_train)
np.save("y_train.npy", y_train)
np.save("X_test.npy", X_test)
np.save("y_test.npy", y_test)

# create tar files for the datasets
make_tarfile("X_train.npy", "X_train.npy.tar")
make_tarfile("y_train.npy", "y_train.npy.tar")
make_tarfile("X_test.npy", "X_test.npy.tar")
make_tarfile("y_test.npy", "y_test.npy.tar")

# upload the datasets to the shared data directory
catalog.file_upload("X_train.npy.tar", singularity)
catalog.file_upload("y_train.npy.tar", singularity)
catalog.file_upload("X_test.npy.tar", singularity)
catalog.file_upload("y_test.npy.tar", singularity)

# view/enlist the uploaded files in the shared data directory
print(catalog.files(singularity))
['X_test.npy.tar', 'X_train.npy.tar', 'y_test.npy.tar', 'y_train.npy.tar']

שלב 3. צור מסווג משופר קוונטית באמצעות פעולת create.

job = singularity.run(
    action="create",
    name="my_classifier",
    num_learners=10,
    learners_types=[
        "DecisionTreeClassifier",
        "KNeighborsClassifier",
    ],
    learners_proportions=[0.5, 0.5],
    learners_options=[{}, {}],
    regularization=0.01,
    weight_update_method="logarithmic",
    sample_scaling=True,
    optimizer_options={"simulator": True},
    voting="soft",
    prob_threshold=0.5,
)

print(job.result())
{'status': 'ok', 'message': 'Classifier created.', 'data': {}, 'metadata': {'resource_usage': {}}}
# list available classifiers using the list action
job = singularity.run(action="list")

print(job.result())

# you can also find your classifiers in the shared data directory with a *.pkl.tar extension
print(catalog.files(singularity))
{'status': 'ok', 'message': 'Classifiers listed.', 'data': {'classifiers': ['my_classifier']}, 'metadata': {'resource_usage': {}}}
['X_test.npy.tar', 'X_train.npy.tar', 'y_test.npy.tar', 'y_train.npy.tar', 'my_classifier.pkl.tar']

שלב 4. אמן את המסווג המשופר קוונטית באמצעות פעולת fit.

job = singularity.run(
    action="fit",
    name="my_classifier",
    X="X_train.npy",  # you do not need to specify the tar extension
    y="y_train.npy",  # you do not need to specify the tar extension
)

print(job.result())
{'status': 'ok', 'message': 'Classifier fitted.', 'data': {}, 'metadata': {'resource_usage': {'RUNNING: MAPPING': {'CPU_TIME': 8.45469617843628}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 69.4949426651001}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 73.01881957054138}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 75.4787163734436}}}}

שלב 5. קבל תחזיות והסתברויות מהמסווג המשופר קוונטית באמצעות פעולת predict.

job = singularity.run(
    action="predict",
    name="my_classifier",
    X="X_test.npy",  # you do not need to specify the tar extension
)

result = job.result()

print("Action result status: ", result["status"])
print("Action result message: ", result["message"])
print("Predictions (first five results):", result["data"]["predictions"][:5])
print(
    "Probabilities (first five results):", result["data"]["probabilities"][:5]
)
Action result status:  ok
Action result message:  Classifier predicted.
Predictions (first five results): [0, 1, 0, 0, 1]
Probabilities (first five results): [[1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 0.0], [0.0, 1.0]]

שלב 6. מחק את המסווג המשופר קוונטית באמצעות פעולת delete.

job = singularity.run(
    action="delete",
    name="my_classifier",
)

# or you can delete from the shared data directory
# catalog.file_delete("my_classifier.pkl.tar", singularity)

print(job.result())
{'status': 'ok', 'message': 'Classifier deleted.', 'data': {}, 'metadata': {'resource_usage': {}}}

שלב 7. נקה ספריות נתונים מקומיות ומשותפות.

# delete the numpy files from your local disk
os.remove("X_train.npy")
os.remove("y_train.npy")
os.remove("X_test.npy")
os.remove("y_test.npy")

# delete the tar files from your local disk
os.remove("X_train.npy.tar")
os.remove("y_train.npy.tar")
os.remove("X_test.npy.tar")
os.remove("y_test.npy.tar")

# delete the tar files from the shared data
catalog.file_delete("X_train.npy.tar", singularity)
catalog.file_delete("y_train.npy.tar", singularity)
catalog.file_delete("X_test.npy.tar", singularity)
catalog.file_delete("y_test.npy.tar", singularity)

מדדי ביצועים​

מדדי ביצועים אלו מראים שהמסווג יכול להשיג דיוקים גבוהים ביותר בבעיות מאתגרות. הם גם מראים שהגדלת מספר הלומדים באנסמבל (מספר Qubits) יכולה להוביל לדיוק מוגבר.

"דיוק קלאסי" מתייחס לדיוק המושג באמצעות ה-state of the art הקלאסי המקביל, שבמקרה זה הוא מסווג AdaBoost המבוסס על אנסמבל בגודל 75. "דיוק קוונטי", לעומת זאת, מתייחס לדיוק המושג באמצעות "Singularity Machine Learning - Classification".

בעיהגודל סט נתוניםגודל אנסמבלמספר Qubitsדיוק קלאסידיוק קוונטישיפור
יציבות רשת5000 דוגמאות, 12 תכונות555576%91%15%
יציבות רשת5000 דוגמאות, 12 תכונות656576%92%16%
יציבות רשת5000 דוגמאות, 12 תכונות757576%94%18%
יציבות רשת5000 דוגמאות, 12 תכונות858576%94%18%
יציבות רשת5000 דוגמאות, 12 תכונות10010076%95%19%

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

יומן שינויים​

4 ביוני 2025​

  • שדרוג QuantumEnhancedEnsembleClassifier עם העדכונים הבאים:
    • נוספה רגולריזציה onsite/alpha. ניתן לציין regularization_type כ-onsite או alpha
    • נוספה רגולריזציה אוטומטית. ניתן להגדיר regularization ל-auto לשימוש ברגולריזציה אוטומטית
    • נוסף פרמטר optimization_data לשיטת fit לבחירת נתוני אופטימיזציה לאופטימיזציה קוונטית. ניתן להשתמש באחת מהאפשרויות: train, validation, או both
    • שיפור ביצועים כולל
  • נוסף מעקב מצב מפורט לעבודות רצות

20 במאי 2025​

  • תקנון טיפול בשגיאות

18 במרץ 2025​

  • שדרוג qiskit-serverless ל-0.20.0 ו-base image ל-0.20.1

14 בפברואר 2025​

  • שדרוג base image ל-0.19.1

6 בפברואר 2025​

  • שדרוג qiskit-serverless ל-0.19.0 ו-base image ל-0.19.0

13 בנובמבר 2024​

  • שחרור Singularity Machine Learning - Classification

קבלת תמיכה​

לכל שאלה, פנה אל Multiverse Computing.

הקפד לכלול את המידע הבא:

  • מזהה ה-Job של פונקציית Qiskit (job.job_id)
  • תיאור מפורט של הבעיה
  • כל הודעות שגיאה או קודים רלוונטיים
  • שלבים לשחזור הבעיה

השלבים הבאים​

המלצות