{
"cells": [
{
"cell_type": "markdown",
"id": "fe74e692",
"metadata": {},
"source": [
"---\n",
"title: \"Singularidade Machine Learning - Classificação por Computação Multiversal\"\n",
"description: \"Uma função Qiskit para criar e treinar um classificador híbrido de conjunto quântico a partir de vários aprendizes e otimizá-los para diversidade e generalização com QAOA\"\n",
"---\n",
"\n",
"{/* cspell:ignore hyperparameters, sparsify, sparsification, Leclerc */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dde95705",
"metadata": {},
"source": [
"\n",
"\n",
"# Machine Learning de singularidade - Classificação: uma função Qiskit da Multiverse Computing\n",
"\n",
"*Consulte a [referência da 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",
" O código desta página foi desenvolvido com base nos seguintes requisitos.\n",
" Recomendamos usar essas versões ou versões mais recentes.\n",
"\n",
" ```\n",
" scikit-learn~=1.8.0\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "9985b8f4",
"metadata": {},
"source": [
"\n",
" * As funções do Qiskit são um recurso experimental disponível apenas para usuários dos planos IBM Quantum® Premium Plan, Flex Plan e On-Prem (via IBM Quantum Platform API). Eles estão no status de versão prévia e estão sujeitos a alterações.\n",
"\n",
"\n",
"\n",
"\n",
"## Visão geral\n",
"\n",
"Com a função \"Singularity Machine Learning - Classification\", você pode resolver problemas de aprendizado de máquina do mundo real em hardware quântico sem precisar de conhecimento quântico. Essa função de aplicativo, baseada em métodos de conjunto, é um classificador híbrido. Ele utiliza métodos clássicos como boosting, bagging e stacking para o treinamento inicial do conjunto. Posteriormente, os algoritmos quânticos, como o eigensolver quântico variacional (VQE) e o algoritmo de otimização aproximada quântica (QAOA), são empregados para aumentar a diversidade, os recursos de generalização e a complexidade geral do conjunto treinado.\n",
"\n",
"Ao contrário de outras soluções de aprendizado de máquina quântica, essa função é capaz de lidar com conjuntos de dados em grande escala com milhões de exemplos e recursos sem ser limitada pelo número de qubits na QPU de destino. O número de qubits determina apenas o tamanho do conjunto que pode ser treinado. Também é altamente flexível e pode ser usada para resolver problemas de classificação em uma ampla gama de domínios, incluindo finanças, assistência médica e segurança cibernética.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "353e72a4",
"metadata": {},
"source": [
"Ele alcança consistentemente altas precisões em problemas classicamente desafiadores que envolvem conjuntos de dados de alta dimensão, com ruído e desequilibrados.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "339c5737",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0639e5e5",
"metadata": {},
"source": [
"Ele foi desenvolvido para:\n",
"\n",
"1. Engenheiros e cientistas de dados de empresas que buscam aprimorar suas ofertas de tecnologia integrando o aprendizado de máquina quântico em seus produtos e serviços,\n",
"2. Pesquisadores de laboratórios de pesquisa quântica que exploram aplicativos de aprendizado de máquina quântica e procuram aproveitar a computação quântica para tarefas de classificação, e\n",
"3. Alunos e professores de instituições educacionais em cursos como aprendizado de máquina e que estejam procurando demonstrar as vantagens da computação quântica.\n",
"\n",
"O exemplo a seguir apresenta suas várias funcionalidades, incluindo `create`, `list`, `fit` e `predict`, e demonstra seu uso em um problema sintético que compreende dois semicírculos intercalados, um problema notoriamente desafiador devido ao seu limite de decisão não linear.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ccf056e3",
"metadata": {},
"source": [
"{/* cspell:ignore quantumly */}\n",
"\n",
"\n",
"\n",
"## Descrição da função\n",
"\n",
"Essa função Qiskit permite que os usuários resolvam problemas de classificação binária usando o classificador de conjunto aprimorado por quantum da Singularity. Nos bastidores, ele usa uma abordagem híbrida para treinar classicamente um conjunto de classificadores no conjunto de dados rotulados e, em seguida, otimizá-lo para obter o máximo de diversidade e generalização usando o QAOA (Quantum Approximate Optimization Algorithm) em IBM® QPUs. Por meio de uma interface fácil de usar, os usuários podem configurar um classificador de acordo com seus requisitos, treiná-lo no conjunto de dados de sua escolha e usá-lo para fazer previsões em um conjunto de dados não visto anteriormente.\n",
"\n",
"Para resolver um problema de classificação genérico:\n",
"\n",
"1. Pré-processar o conjunto de dados e dividi-lo em conjuntos de treinamento e teste. Opcionalmente, você pode dividir ainda mais o conjunto de treinamento em conjuntos de treinamento e validação. Isso pode ser feito usando [o scikit-learn](https://scikit-learn.org/1.5/modules/generated/sklearn.model_selection.train_test_split.html).\n",
"2. Se o conjunto de treinamento for desequilibrado, você poderá reamostrá-lo para equilibrar as classes usando o [imbalanced-learn](https://imbalanced-learn.org/stable/introduction.html#problem-statement-regarding-imbalanced-data-sets).\n",
"3. Faça upload dos conjuntos de treinamento, validação e teste separadamente para o armazenamento da função usando o método `file_upload` do catálogo, passando o caminho relevante a cada vez.\n",
"4. Inicialize o classificador quântico usando a ação `create` da função, que aceita hiperparâmetros, como o número e os tipos de alunos, a regularização (valor lambda) e as opções de otimização, incluindo o número de camadas, o tipo de otimizador clássico, o backend quântico e assim por diante.\n",
"5. Treine o classificador quântico no conjunto de treinamento usando a ação `fit` da função, passando a ele o conjunto de treinamento rotulado e o conjunto de validação, se aplicável.\n",
"6. Faça previsões sobre o conjunto de testes não vistos anteriormente usando a ação `predict` da função.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "26472870",
"metadata": {},
"source": [
"***\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "73390a19",
"metadata": {},
"source": [
"\n",
"\n",
"## Introdução\n",
"\n",
"Autentique-se usando sua [chave de API do IBM Quantum Platform](http://quantum.cloud.ibm.com/) e selecione a função Qiskit da seguinte forma:\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",
"## Exemplos\n",
"\n",
"\n",
"\n",
"### Classificar um conjunto de dados\n",
"\n",
"Neste exemplo, você usará a função \"Singularity Machine Learning - Classification\" para classificar um conjunto de dados que consiste em dois semicírculos intercalados em forma de lua. O conjunto de dados é sintético, bidimensional e rotulado com rótulos binários. Ele foi criado para ser um desafio para algoritmos como clustering baseado em centroides e classificação linear.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b12f9ee4",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b3cedca5",
"metadata": {},
"source": [
"Por meio desse processo, você aprenderá a criar o classificador, ajustá-lo aos dados de treinamento, usá-lo para fazer previsões nos dados de teste e excluir o classificador quando terminar.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dba5a40e",
"metadata": {},
"source": [
"Antes de começar, você precisa instalar [o scikit-learn](https://scikit-learn.org/). Instale-o usando o seguinte comando:\n",
"\n",
"```sh\n",
"python3 -m pip install scikit-learn\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ba982810",
"metadata": {},
"source": [
"Execute as seguintes etapas:\n",
"\n",
"1. Crie o conjunto de dados sintético usando a [`make_moons`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) função do [scikit-learn](https://scikit-learn.org/).\n",
"2. Carregue o conjunto de dados sintéticos gerado no [diretório de dados compartilhados](https://qiskit.github.io/qiskit-serverless/function_features/experimental/manage_data_directory.html).\n",
"3. Crie o classificador otimizado quântico usando a [`create`](/docs/api/functions/multiverse-computing-singularity#create) ação.\n",
"4. Registre seus classificadores usando a [`list`](/docs/api/functions/multiverse-computing-singularity#list) ação.\n",
"5. Treine o classificador com os dados de treinamento usando a [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) ação.\n",
"6. Use o classificador treinado para fazer previsões nos dados de teste usando a [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) ação.\n",
"7. Exclua o classificador usando a [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) ação.\n",
"8. Limpe tudo depois de terminar.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c1877f96",
"metadata": {},
"source": [
"**Etapa 1.** Importe os módulos necessários e gere o conjunto de dados sintético e, em seguida, divida-o em conjuntos de dados de treinamento e teste.\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": [
"**Etapa 2.** Salve os conjuntos de dados de treinamento e teste rotulados no seu disco local e, em seguida, envie-os para o [diretório de dados compartilhado](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": [
"**Etapa 3.** Crie um classificador otimizado por computação quântica usando a [`create`](/docs/api/functions/multiverse-computing-singularity#create) ação.\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": [
"**Etapa 4.** Treine o classificador otimizado quântico usando a [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) ação.\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": [
"**Etapa 5.** Obtenha previsões e probabilidades do classificador aprimorado quântico usando a [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) ação.\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": [
"**Etapa 6.** Exclua o classificador otimizado quântico usando a [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) ação.\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": [
"**Etapa 7.** Limpe os diretórios de dados locais e compartilhados.\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",
"### `create_fit_predict`exemplo\n",
"\n",
"O exemplo a seguir ilustra a [`create_fit_predict`](/docs/api/functions/multiverse-computing-singularity#create_fit_predict) ação.\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",
"## Referências\n",
"\n",
"Esses benchmarks mostram que o classificador pode atingir precisões extremamente altas em problemas desafiadores. Eles também mostram que o aumento do número de alunos no conjunto (número de qubits) pode levar a uma maior precisão.\n",
"\n",
"\"Precisão clássica\" refere-se à precisão obtida usando o estado da arte clássico correspondente que, neste caso, é um classificador AdaBoost baseado em um conjunto de tamanho 75. a \"precisão quântica\", por outro lado, refere-se à precisão obtida usando a \"Singularidade Machine Learning - Classificação\".\n",
"\n",
"| Problema | Tamanho do conjunto de dados | Tamanho do conjunto | Número de Qubits | Precisão clássica | Precisão quântica | Melhoria |\n",
"| -------------------- | ---------------------------- | ------------------- | ---------------- | ----------------- | ----------------- | -------- |\n",
"| Estabilidade da rede | 5000 exemplos, 12 recursos | 56 | 56 | 76% | 91% | 15% |\n",
"| Estabilidade da rede | 5000 exemplos, 12 recursos | 65 | 65 | 76% | 92% | 16% |\n",
"| Estabilidade da rede | 5000 exemplos, 12 recursos | 75 | 75 | 76% | 94% | 18% |\n",
"| Estabilidade da rede | 5000 exemplos, 12 recursos | 85 | 85 | 76% | 94% | 18% |\n",
"| Estabilidade da rede | 5000 exemplos, 12 recursos | 100 | 100 | 76% | 95% | 19% |\n",
"\n",
"***\n",
"\n",
"À medida que o hardware quântico evolui e se expande, as implicações para nosso classificador quântico se tornam cada vez mais significativas. Embora o número de qubits imponha limitações ao tamanho do conjunto que pode ser utilizado, ele não restringe o volume de dados que pode ser processado. Esse recurso avançado permite que o classificador manipule com eficiência conjuntos de dados que contêm milhões de pontos de dados e milhares de recursos. É importante ressaltar que as restrições relacionadas ao tamanho do conjunto podem ser resolvidas por meio da implementação de uma versão em grande escala do classificador. Ao aproveitar uma abordagem iterativa de loop externo, o conjunto pode ser expandido dinamicamente, aumentando a flexibilidade e o desempenho geral. No entanto, vale a pena observar que esse recurso ainda não foi implementado na versão atual do classificador.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "cddff465",
"metadata": {},
"source": [
"\n",
"\n",
"## Log de mudanças\n",
"\n",
"\n",
"\n",
"### 4 de junho de 2025\n",
"\n",
"* Atualizado `QuantumEnhancedEnsembleClassifier` com as seguintes atualizações:\n",
" * Adição de regularização no local/alfa. Você pode especificar `regularization_type` para ser `onsite` ou `alpha`\n",
" * Adicionada a regularização automática. Você pode definir `regularization` como `auto` para usar a regularização automática\n",
" * Adicionado o parâmetro `optimization_data` ao método `fit` para escolher dados de otimização para otimização quântica. Você pode usar uma destas opções: `train`, `validation`, ou `both`\n",
" * Melhoria do desempenho geral\n",
"* Adição do rastreamento detalhado do status dos trabalhos em execução\n",
"\n",
"\n",
"\n",
"### 20 de maio de 2025\n",
"\n",
"* Tratamento de erros padronizado\n",
"\n",
"\n",
"\n",
"### 18 de março de 2025\n",
"\n",
"* Atualizou o qiskit-serverless para 0.20.0 e a imagem base para 0.20.1\n",
"\n",
"\n",
"\n",
"### 14 de fevereiro de 2025\n",
"\n",
"* Imagem base atualizada para 0.19.1\n",
"\n",
"\n",
"\n",
"### 6 de fevereiro de 2025\n",
"\n",
"* Atualizou o qiskit-serverless para 0.19.0 e a imagem base para 0.19.0\n",
"\n",
"\n",
"\n",
"### 13 de novembro de 2024\n",
"\n",
"* Lançamento do Singularity Machine Learning - Classificação\n",
"\n",
"\n",
"\n",
"## Obtenha suporte\n",
"\n",
"Em caso de dúvidas, entre [em contato com a Multiverse Computing](mailto:singularity@multiversecomputing.com).\n",
"\n",
"Certifique-se de incluir as seguintes informações:\n",
"\n",
"* A função Qiskit ID do trabalho (`job.job_id`)\n",
"* Uma descrição detalhada do problema\n",
"* Quaisquer mensagens ou códigos de erro relevantes\n",
"* Etapas para reproduzir o problema\n",
"\n",
"\n",
"\n",
"## Próximas etapas\n",
"\n",
"\n",
" * Solicite acesso à [função de classificação da Singularity Machine Learning da Multiverse Computing](/functions?id=multiverse-singularity).\n",
" * Consulte a [referência da API](/docs/api/functions/multiverse-computing-singularity) para esta função do Qiskit.\n",
" * Revisão [Leclerc, L., et al. (2023). Gestão de risco financeiro em um processador quântico de átomo neutro. Pesquisa em Revisão Física, 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
}