{
"cells": [
{
"cell_type": "markdown",
"id": "fe74e692",
"metadata": {},
"source": [
"---\n",
"title: \"Singularity Machine Learning - Clasificación mediante computación multiversal\"\n",
"description: \"Una función Qiskit para crear y entrenar un clasificador cuántico híbrido a partir de múltiples aprendices y optimizarlos para la diversidad y la generalización con QAOA\"\n",
"---\n",
"\n",
"{/* cspell:ignore hyperparameters, sparsify, sparsification, Leclerc */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dde95705",
"metadata": {},
"source": [
"\n",
"\n",
"# Singularity Machine Learning - Clasificación: una función Qiskit de Multiverse Computing\n",
"\n",
"*Consulte la [referencia de la API](/docs/api/functions/multiverse-computing-singularity)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "99db0bb4",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"{/*\n",
" DO NOT EDIT THIS CELL!!!\n",
" This cell's content is generated automatically by a script. Anything you add\n",
" here will be removed next time the notebook is run. To add new content, create\n",
" a new cell before or after this one.\n",
" */}\n",
"\n",
"\n",
" \n",
" El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos.\n",
" Recomendamos utilizar estas versiones o posteriores.\n",
"\n",
" ```\n",
" scikit-learn~=1.8.0\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "9985b8f4",
"metadata": {},
"source": [
"\n",
" * Las funciones Qiskit son una función experimental disponible únicamente para los usuarios de los planes IBM Quantum® Premium Plan, Flex Plan y On-Prem (a través de IBM Quantum Platform API). Se trata de versiones preliminares sujetas a cambios.\n",
"\n",
"\n",
"\n",
"\n",
"## Visión general\n",
"\n",
"Con la función \"Singularity Machine Learning - Clasificación\", puede resolver problemas de aprendizaje automático del mundo real en hardware cuántico sin necesidad de conocimientos cuánticos. Esta función de aplicación, basada en métodos ensemble, es un clasificador híbrido. Aprovecha métodos clásicos como boosting, bagging y stacking para el entrenamiento inicial de conjuntos. Posteriormente, se emplean algoritmos cuánticos como el eigensolver cuántico variacional (VQE) y el algoritmo de optimización aproximada cuántica (QAOA) para mejorar la diversidad, la capacidad de generalización y la complejidad general del conjunto entrenado.\n",
"\n",
"A diferencia de otras soluciones de aprendizaje automático cuántico, esta función es capaz de manejar conjuntos de datos a gran escala con millones de ejemplos y características sin estar limitada por el número de qubits de la QPU de destino. El número de qubits sólo determina el tamaño del conjunto que se puede entrenar. También es muy flexible y puede utilizarse para resolver problemas de clasificación en una amplia gama de ámbitos, incluidos las finanzas, la sanidad y la ciberseguridad.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "353e72a4",
"metadata": {},
"source": [
"Consigue sistemáticamente altas precisiones en problemas clásicos que implican conjuntos de datos de alta dimensión, ruidosos y desequilibrados.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "339c5737",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0639e5e5",
"metadata": {},
"source": [
"Está construido para:\n",
"\n",
"1. Ingenieros y científicos de datos de empresas que buscan mejorar su oferta tecnológica integrando el aprendizaje automático cuántico en sus productos y servicios,\n",
"2. Investigadores de laboratorios de investigación cuántica que exploran aplicaciones de aprendizaje automático cuántico y buscan aprovechar la computación cuántica para tareas de clasificación, y\n",
"3. Estudiantes y profesores de instituciones educativas en cursos como aprendizaje automático, y que buscan demostrar las ventajas de la computación cuántica.\n",
"\n",
"El siguiente ejemplo muestra sus diversas funcionalidades, incluyendo `create`, `list`, `fit`, y `predict`, y demuestra su uso en un problema sintético que comprende dos medios círculos intercalados, un problema notoriamente desafiante debido a su límite de decisión no lineal.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ccf056e3",
"metadata": {},
"source": [
"{/* cspell:ignore quantumly */}\n",
"\n",
"\n",
"\n",
"## Descripción de la función\n",
"\n",
"Esta función de Qiskit permite a los usuarios resolver problemas de clasificación binaria utilizando el clasificador conjunto mejorado cuánticamente de Singularity. Entre bastidores, utiliza un enfoque híbrido para entrenar de forma clásica un conjunto de clasificadores en el conjunto de datos etiquetados y, a continuación, optimizarlo para obtener la máxima diversidad y generalización mediante el algoritmo de optimización aproximada cuántica (QAOA) en las QPU de IBM®. A través de una interfaz fácil de usar, los usuarios pueden configurar un clasificador según sus requisitos, entrenarlo en el conjunto de datos de su elección y utilizarlo para hacer predicciones en un conjunto de datos no visto previamente.\n",
"\n",
"Resolver un problema genérico de clasificación:\n",
"\n",
"1. Preprocese el conjunto de datos y divídalo en conjuntos de entrenamiento y de prueba. Opcionalmente, puede dividir el conjunto de entrenamiento en conjuntos de entrenamiento y validación. Esto puede lograrse utilizando [scikit-learn](https://scikit-learn.org/1.5/modules/generated/sklearn.model_selection.train_test_split.html).\n",
"2. Si el conjunto de entrenamiento está desequilibrado, puede volver a muestrearlo para equilibrar las clases utilizando [imbalanced-learn](https://imbalanced-learn.org/stable/introduction.html#problem-statement-regarding-imbalanced-data-sets).\n",
"3. Cargue los conjuntos de entrenamiento, validación y prueba por separado en el almacenamiento de la función utilizando el método `file_upload` del catálogo, pasándole cada vez la ruta correspondiente.\n",
"4. Inicialice el clasificador cuántico utilizando la acción de la función `create` , que acepta hiperparámetros como el número y tipos de aprendices, la regularización (valor lambda), y opciones de optimización incluyendo el número de capas, el tipo de optimizador clásico, el backend cuántico, etc.\n",
"5. Entrene el clasificador cuántico en el conjunto de entrenamiento utilizando la acción `fit` de la función, pasándole el conjunto de entrenamiento etiquetado y el conjunto de validación si procede.\n",
"6. Realiza predicciones sobre el conjunto de pruebas no visto previamente utilizando la acción `predict` de la función.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "26472870",
"metadata": {},
"source": [
"***\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "73390a19",
"metadata": {},
"source": [
"\n",
"\n",
"## Cómo empezar\n",
"\n",
"Autentícate utilizando tu [clave API de IBM Quantum Platform](http://quantum.cloud.ibm.com/), y selecciona la Función Qiskit como se indica a continuación:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "95a715d2",
"metadata": {},
"outputs": [],
"source": [
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
"\n",
"# load function\n",
"singularity = catalog.load(\"multiverse/singularity\")"
]
},
{
"cell_type": "markdown",
"id": "e8837f5f",
"metadata": {},
"source": [
"\n",
"\n",
"## Ejemplos\n",
"\n",
"\n",
"\n",
"### Clasificar un conjunto de datos\n",
"\n",
"En este ejemplo, utilizará la función \"Singularidad Machine Learning - Clasificación\" para clasificar un conjunto de datos formado por dos semicírculos intercalados con forma de luna. El conjunto de datos es sintético, bidimensional y con etiquetas binarias. Está creado para ser un reto para algoritmos como la agrupación basada en centroides y la clasificación lineal.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b12f9ee4",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b3cedca5",
"metadata": {},
"source": [
"A través de este proceso, aprenderás a crear el clasificador, ajustarlo a los datos de entrenamiento, utilizarlo para predecir en los datos de prueba y eliminar el clasificador cuando hayas terminado.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dba5a40e",
"metadata": {},
"source": [
"Antes de empezar, es necesario instalar [scikit-learn](https://scikit-learn.org/). Instálelo utilizando el siguiente comando:\n",
"\n",
"```sh\n",
"python3 -m pip install scikit-learn\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ba982810",
"metadata": {},
"source": [
"Siga los pasos siguientes:\n",
"\n",
"1. Crea el conjunto de datos sintéticos utilizando la [`make_moons`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) función de [scikit-learn](https://scikit-learn.org/).\n",
"2. Sube el conjunto de datos sintéticos generado al [directorio de datos compartido](https://qiskit.github.io/qiskit-serverless/function_features/experimental/manage_data_directory.html).\n",
"3. Crea el clasificador mejorado cuánticamente utilizando la [`create`](/docs/api/functions/multiverse-computing-singularity#create) acción.\n",
"4. Incorpora tus clasificadores mediante la [`list`](/docs/api/functions/multiverse-computing-singularity#list) acción.\n",
"5. Entrena el clasificador con los datos de entrenamiento utilizando la [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) acción.\n",
"6. Utiliza el clasificador entrenado para realizar predicciones sobre los datos de prueba mediante la [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) acción.\n",
"7. Elimina el clasificador mediante la [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) acción.\n",
"8. Limpia cuando termines.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c1877f96",
"metadata": {},
"source": [
"**Paso 1.** Importe los módulos necesarios y genere el conjunto de datos sintéticos; a continuación, divídalo en conjuntos de datos de entrenamiento y de prueba.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "731db300",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Features: [[ 0.84757037 -0.48831433]\n",
" [ 0.98132552 0.19235443]\n",
" [-0.71626723 0.6978261 ]\n",
" [ 1.18957848 -0.48186557]\n",
" [ 0.52118982 -0.37791846]\n",
" [ 0.81115408 0.58483251]\n",
" [ 0.48706462 0.87336593]\n",
" [-0.81880144 0.57407682]\n",
" [ 1.67335408 -0.23932015]\n",
" [ 0.50181306 0.8649761 ]]\n",
"Targets: [1 0 0 1 1 0 0 0 1 0]\n"
]
}
],
"source": [
"# import the necessary modules for this example\n",
"import os\n",
"import tarfile\n",
"import numpy as np\n",
"\n",
"# Import the make_moons and the train_test_split functions from scikit-learn\n",
"# to create a synthetic dataset and split it into training and test datasets\n",
"from sklearn.datasets import make_moons\n",
"from sklearn.model_selection import train_test_split\n",
"\n",
"# generate the synthetic dataset\n",
"X, y = make_moons(n_samples=10000)\n",
"\n",
"# split the data into training and test datasets\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
"\n",
"# print the first 10 samples of the training dataset\n",
"print(\"Features:\", X_train[:10, :])\n",
"print(\"Targets:\", y_train[:10])"
]
},
{
"cell_type": "markdown",
"id": "639f459f",
"metadata": {},
"source": [
"**Paso 2.** Guarda los conjuntos de datos de entrenamiento y de prueba etiquetados en tu disco local y, a continuación, súbelos al [directorio de datos compartido](https://qiskit.github.io/qiskit-serverless/function_features/experimental/manage_data_directory.html).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "7265965f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['X_test.npy.tar', 'X_train.npy.tar', 'y_test.npy.tar', 'y_train.npy.tar']\n"
]
}
],
"source": [
"def make_tarfile(file_path, tar_file_name):\n",
" with tarfile.open(tar_file_name, \"w\") as tar:\n",
" tar.add(file_path, arcname=os.path.basename(file_path))\n",
"\n",
"\n",
"# save the training and test datasets on your local disk\n",
"np.save(\"X_train.npy\", X_train)\n",
"np.save(\"y_train.npy\", y_train)\n",
"np.save(\"X_test.npy\", X_test)\n",
"np.save(\"y_test.npy\", y_test)\n",
"\n",
"# create tar files for the datasets\n",
"make_tarfile(\"X_train.npy\", \"X_train.npy.tar\")\n",
"make_tarfile(\"y_train.npy\", \"y_train.npy.tar\")\n",
"make_tarfile(\"X_test.npy\", \"X_test.npy.tar\")\n",
"make_tarfile(\"y_test.npy\", \"y_test.npy.tar\")\n",
"\n",
"# upload the datasets to the shared data directory\n",
"catalog.file_upload(\"X_train.npy.tar\", singularity)\n",
"catalog.file_upload(\"y_train.npy.tar\", singularity)\n",
"catalog.file_upload(\"X_test.npy.tar\", singularity)\n",
"catalog.file_upload(\"y_test.npy.tar\", singularity)\n",
"\n",
"# view/enlist the uploaded files in the shared data directory\n",
"print(catalog.files(singularity))"
]
},
{
"cell_type": "markdown",
"id": "f52caa63",
"metadata": {},
"source": [
"**Paso 3.** Crea un clasificador mejorado cuánticamente utilizando la [`create`](/docs/api/functions/multiverse-computing-singularity#create) acción.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "d56e1440",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'status': 'ok', 'message': 'Classifier created.', 'data': {}, 'metadata': {'resource_usage': {}}}\n"
]
}
],
"source": [
"job = singularity.run(\n",
" action=\"create\",\n",
" name=\"my_classifier\",\n",
" num_learners=10,\n",
" learners_types=[\n",
" \"DecisionTreeClassifier\",\n",
" \"KNeighborsClassifier\",\n",
" ],\n",
" learners_proportions=[0.5, 0.5],\n",
" learners_options=[{}, {}],\n",
" regularization=0.01,\n",
" weight_update_method=\"logarithmic\",\n",
" sample_scaling=True,\n",
" optimizer_options={\"simulator\": True},\n",
" voting=\"soft\",\n",
" prob_threshold=0.5,\n",
")\n",
"\n",
"print(job.result())"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "f5a54432",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'status': 'ok', 'message': 'Classifiers listed.', 'data': {'classifiers': ['my_classifier']}, 'metadata': {'resource_usage': {}}}\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"['X_test.npy.tar', 'X_train.npy.tar', 'my_classifier.pkl.tar', 'y_test.npy.tar', 'y_train.npy.tar']\n"
]
}
],
"source": [
"# list available classifiers using the list action\n",
"job = singularity.run(action=\"list\")\n",
"\n",
"print(job.result())\n",
"\n",
"# you can also find your classifiers in the shared data directory with a *.pkl.tar extension\n",
"print(catalog.files(singularity))"
]
},
{
"cell_type": "markdown",
"id": "504ddc09",
"metadata": {},
"source": [
"**Paso 4.** Entrena el clasificador mejorado cuánticamente utilizando la [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) acción.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "13699d25",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'status': 'ok', 'message': 'Classifier fitted.', 'data': {}, 'metadata': {'resource_usage': {'RUNNING: MAPPING': {'CPU_TIME': 13.655871629714966}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 54.688621282577515}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 56.92286920547485}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 57.92738223075867}}}}\n"
]
}
],
"source": [
"job = singularity.run(\n",
" action=\"fit\",\n",
" name=\"my_classifier\",\n",
" X=\"X_train.npy\", # you do not need to specify the tar extension\n",
" y=\"y_train.npy\", # you do not need to specify the tar extension\n",
")\n",
"\n",
"print(job.result())"
]
},
{
"cell_type": "markdown",
"id": "76ef149b",
"metadata": {},
"source": [
"**Paso 5.** Obtén predicciones y probabilidades del clasificador mejorado cuánticamente mediante la [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) acción.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "92f35d5a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Action result status: ok\n",
"Action result message: Classifier predicted.\n",
"Predictions (first five results): [0, 0, 1, 0, 1]\n",
"Probabilities (first five results): [[1.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 1.0]]\n"
]
}
],
"source": [
"job = singularity.run(\n",
" action=\"predict\",\n",
" name=\"my_classifier\",\n",
" X=\"X_test.npy\", # you do not need to specify the tar extension\n",
")\n",
"\n",
"result = job.result()\n",
"\n",
"print(\"Action result status: \", result[\"status\"])\n",
"print(\"Action result message: \", result[\"message\"])\n",
"print(\"Predictions (first five results):\", result[\"data\"][\"predictions\"][:5])\n",
"print(\n",
" \"Probabilities (first five results):\", result[\"data\"][\"probabilities\"][:5]\n",
")"
]
},
{
"cell_type": "markdown",
"id": "1980104c",
"metadata": {},
"source": [
"**Paso 6.** Elimina el clasificador mejorado cuánticamente mediante la [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) acción.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "c4705154",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'status': 'ok', 'message': 'Classifier deleted.', 'data': {}, 'metadata': {'resource_usage': {}}}\n"
]
}
],
"source": [
"job = singularity.run(\n",
" action=\"delete\",\n",
" name=\"my_classifier\",\n",
")\n",
"\n",
"# or you can delete from the shared data directory\n",
"# catalog.file_delete(\"my_classifier.pkl.tar\", singularity)\n",
"\n",
"print(job.result())"
]
},
{
"cell_type": "markdown",
"id": "30b34179",
"metadata": {},
"source": [
"**Paso 7.** Limpia los directorios de datos locales y compartidos.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "6c64ea2b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Requested file was deleted.'"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# delete the numpy files from your local disk\n",
"os.remove(\"X_train.npy\")\n",
"os.remove(\"y_train.npy\")\n",
"os.remove(\"X_test.npy\")\n",
"os.remove(\"y_test.npy\")\n",
"\n",
"# delete the tar files from your local disk\n",
"os.remove(\"X_train.npy.tar\")\n",
"os.remove(\"y_train.npy.tar\")\n",
"os.remove(\"X_test.npy.tar\")\n",
"os.remove(\"y_test.npy.tar\")\n",
"\n",
"# delete the tar files from the shared data\n",
"catalog.file_delete(\"X_train.npy.tar\", singularity)\n",
"catalog.file_delete(\"y_train.npy.tar\", singularity)\n",
"catalog.file_delete(\"X_test.npy.tar\", singularity)\n",
"catalog.file_delete(\"y_test.npy.tar\", singularity)"
]
},
{
"cell_type": "markdown",
"id": "f25d06ee",
"metadata": {},
"source": [
"\n",
"\n",
"### Ejemplo de `create_fit_predict`\n",
"\n",
"El siguiente ejemplo muestra cómo funciona la [`create_fit_predict`](/docs/api/functions/multiverse-computing-singularity#create_fit_predict) acción.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "79cdedc0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Job status: QUEUED\n",
"Action result status: ok\n",
"Action result message: Classifier created, fitted, and predicted.\n",
"Predictions (first five results): [0, 0, 1, 0, 0]\n",
"Probabilities (first five results): [[0.87119766531518, 0.1288023346848197], [0.87119766531518, 0.1288023346848197], [0.24470328446479797, 0.7552967155352032], [0.820524432250189, 0.17947556774981072], [0.6847610293419495, 0.31523897065805173]]\n",
"Usage metadata: {'RUNNING: MAPPING': {'CPU_TIME': 10.967791318893433}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 59.91712307929993}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 59.097386837005615}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 56.93338203430176}}\n"
]
}
],
"source": [
"# Import QiskitFunctionsCatalog to load the\n",
"# \"Singularity Machine Learning - Classification\" function by Multiverse Computing\n",
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"# Import the make_moons and the train_test_split functions from scikit-learn\n",
"# to create a synthetic dataset and split it into training and test datasets\n",
"from sklearn.datasets import make_moons\n",
"from sklearn.model_selection import train_test_split\n",
"\n",
"# authentication\n",
"# If you have not previously saved your credentials, follow instructions at\n",
"# /docs/guides/functions\n",
"# to authenticate with your API key.\n",
"catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
"\n",
"# load \"Singularity Machine Learning - Classification\" function by Multiverse Computing\n",
"singularity = catalog.load(\"multiverse/singularity\")\n",
"\n",
"# generate the synthetic dataset\n",
"X, y = make_moons(n_samples=1000)\n",
"\n",
"# split the data into training and test datasets\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
"\n",
"job = singularity.run(\n",
" action=\"create_fit_predict\",\n",
" num_learners=10,\n",
" regularization=0.01,\n",
" optimizer_options={\"simulator\": True},\n",
" X_train=X_train,\n",
" y_train=y_train,\n",
" X_test=X_test,\n",
" options={\"save\": False},\n",
")\n",
"\n",
"# get job status and result\n",
"status = job.status()\n",
"result = job.result()\n",
"\n",
"print(\"Job status: \", status)\n",
"print(\"Action result status: \", result[\"status\"])\n",
"print(\"Action result message: \", result[\"message\"])\n",
"print(\"Predictions (first five results): \", result[\"data\"][\"predictions\"][:5])\n",
"print(\n",
" \"Probabilities (first five results): \",\n",
" result[\"data\"][\"probabilities\"][:5],\n",
")\n",
"print(\"Usage metadata: \", result[\"metadata\"][\"resource_usage\"])"
]
},
{
"cell_type": "markdown",
"id": "5cc6f2b3",
"metadata": {},
"source": [
"\n",
"\n",
"## Referencias comparativas\n",
"\n",
"Estas pruebas demuestran que el clasificador puede alcanzar precisiones extremadamente altas en problemas difíciles. También muestran que aumentar el número de aprendices en el conjunto (número de qubits) puede conducir a una mayor precisión.\n",
"\n",
"\"Precisión clásica\" se refiere a la precisión obtenida utilizando el correspondiente estado clásico de la técnica que, en este caso, es un clasificador AdaBoost basado en un conjunto de tamaño 75. \"Precisión cuántica\", por su parte, se refiere a la precisión obtenida utilizando la \"Singularidad Machine Learning - Clasificación\".\n",
"\n",
"| Problema | Tamaño del conjunto de datos | Tamaño del conjunto | Número de Qubits | Precisión clásica | Precisión cuántica | Mejora |\n",
"| --------------------- | ---------------------------- | ------------------- | ---------------- | ----------------- | ------------------ | ------ |\n",
"| Estabilidad de la red | 5000 ejemplos, 12 funciones | 55 | 55 | 76% | 91 % | 15 % |\n",
"| Estabilidad de la red | 5000 ejemplos, 12 funciones | 65 | 65 | 76% | 92% | 16% |\n",
"| Estabilidad de la red | 5000 ejemplos, 12 funciones | 75 | 75 | 76% | 94% | 18% |\n",
"| Estabilidad de la red | 5000 ejemplos, 12 funciones | 85 | 85 | 76% | 94% | 18% |\n",
"| Estabilidad de la red | 5000 ejemplos, 12 funciones | 100 | 100 | 76% | 95% | 19 % |\n",
"\n",
"***\n",
"\n",
"A medida que el hardware cuántico evoluciona y se amplía, las implicaciones para nuestro clasificador cuántico son cada vez más significativas. Aunque el número de qubits impone limitaciones al tamaño del conjunto que puede utilizarse, no restringe el volumen de datos que pueden procesarse. Esta potente capacidad permite al clasificador manejar con eficacia conjuntos de datos que contienen millones de puntos de datos y miles de características. Es importante destacar que las limitaciones relacionadas con el tamaño del conjunto pueden abordarse mediante la aplicación de una versión a gran escala del clasificador. Al aprovechar un enfoque iterativo de bucle externo, el conjunto puede ampliarse dinámicamente, lo que mejora la flexibilidad y el rendimiento general. Sin embargo, cabe señalar que esta función aún no se ha implementado en la versión actual del clasificador.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "cddff465",
"metadata": {},
"source": [
"\n",
"\n",
"## Registro de cambios\n",
"\n",
"\n",
"\n",
"### 4 de junio de 2025\n",
"\n",
"* Actualizado `QuantumEnhancedEnsembleClassifier` con las siguientes actualizaciones:\n",
" * Añadida regularización in situ/alfa. Puede especificar que `regularization_type` sea `onsite` o `alpha`\n",
" * Añadida la autorregularización. Puede configurar `regularization` en `auto` para utilizar la autorregularización\n",
" * Añadido el parámetro `optimization_data` al método `fit` para elegir los datos de optimización para la optimización cuántica. Puede utilizar una de estas opciones: `train`, `validation`, o `both`\n",
" * Mejora del rendimiento general\n",
"* Se ha añadido un seguimiento detallado del estado de los trabajos en ejecución\n",
"\n",
"\n",
"\n",
"### 20 de mayo de 2025\n",
"\n",
"* Gestión de errores estandarizada\n",
"\n",
"\n",
"\n",
"### 18 de marzo de 2025\n",
"\n",
"* Actualizado qiskit-serverless a 0.20.0 y la imagen base a 0.20.1\n",
"\n",
"\n",
"\n",
"### 14 de febrero de 2025\n",
"\n",
"* Imagen base actualizada a 0.19.1\n",
"\n",
"\n",
"\n",
"### 6 de febrero de 2025\n",
"\n",
"* Actualizado qiskit-serverless a 0.19.0 y la imagen base a 0.19.0\n",
"\n",
"\n",
"\n",
"### 13 de noviembre de 2024\n",
"\n",
"* Publicación de Singularity Machine Learning - Clasificación\n",
"\n",
"\n",
"\n",
"## Obtener soporte\n",
"\n",
"Si tiene alguna pregunta, póngase en [contacto con Multiverse Computing](mailto:singularity@multiversecomputing.com).\n",
"\n",
"Asegúrese de incluir la siguiente información:\n",
"\n",
"* La función Qiskit ID del puesto (`job.job_id`)\n",
"* Descripción detallada del problema\n",
"* Cualquier mensaje o código de error relevante\n",
"* Pasos para reproducir el problema\n",
"\n",
"\n",
"\n",
"## Próximos pasos\n",
"\n",
"\n",
" * Solicite acceso a [la función de clasificación de singularidades de Multiverse Computing Machine Learning](/functions?id=multiverse-singularity).\n",
" * Consulta la [referencia](/docs/api/functions/multiverse-computing-singularity) de la API de esta función de Qiskit.\n",
" * Reseña [Leclerc, L., et al. (2023). Gestión de riesgos financieros en un procesador cuántico de átomos neutros. Physical Review Research, 5, 043117](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.043117).\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
}
},
"nbformat": 4,
"nbformat_minor": 5
}