Home Artificial Intelligence Quantum Machine Learning with Python: Kernel Methods and Neural Networks Introduction First, install qiskit Quantum Kernel Methods Quantum Kernel with ZZFeatureMaps Quantum Kernel Training Quantum Neural Networks Conclusion

Quantum Machine Learning with Python: Kernel Methods and Neural Networks Introduction First, install qiskit Quantum Kernel Methods Quantum Kernel with ZZFeatureMaps Quantum Kernel Training Quantum Neural Networks Conclusion

0
Quantum Machine Learning with Python: Kernel Methods and Neural Networks
Introduction
First, install qiskit
Quantum Kernel Methods
Quantum Kernel with ZZFeatureMaps
Quantum Kernel Training
Quantum Neural Networks
Conclusion

Towards Data Science
Photo by Annamária Borsos (used with permission)

Quantum Machine Learning (QML) represents an interesting convergence of quantum computing and machine learning technologies. With quantum computing’s potential in mathematics and data processing with complex structure, QML could revolutionize areas like drug discovery, finance, and beyond. This blog delves into the progressive realms of quantum neural networks (QNNs) and quantum kernel techniques, showcasing their unique capabilities through practical Python examples. The blog is not going to detail the mathematical concepts. For more information don’t hesitate to read my latest book Machine Learning Theory and Applications: Hands-on Use Cases with Python on Classical and Quantum Machines, Wiley, 2024.

Quantum kernel methods, introduce a quantum-enhanced way of processing data. By mapping classical data into quantum feature space, these methods utilize the superposition and entanglement properties of quantum mechanics to perform classifications or regression tasks. Using quantum kernel estimator and quantum variational classifier examples illustrates the sensible application of those concepts. QNNs, leveraging quantum states for computation, offer a novel approach to neural network architecture. The Qiskit framework facilitates the implementation of each quantum kernel methods and QNNs, enabling the exploration of quantum algorithms’ efficiency in learning and pattern recognition.

Incorporating Python code examples, this blog goals to offer comprehensive code examples of QML for readers to explore its promising applications, and the challenges it faces. Through these examples, readers can start practicing and gain an appreciation for the transformative potential of quantum computing in machine learning and the exciting possibilities that lie ahead.

We are going to use the open-source SDK Qiskit (https://qiskit.org) which allows working with quantum computers. Qiskit supports Python version 3.6 or later.

In the environment, we are able to install Qiskit with pip:

pip install qiskit

We may install qiskit-machine-learning using pip:

pip install qiskit-machine-learning

Documentation will be found on GitHub: https://github.com/Qiskit/qiskit-machine-learning/.

To run our code, we are able to use either simulators or real hardware even when I strongly recommend using hardware or push the bounds of simulators to enhance research on this field. While studying the Qiskit documentation, you’ll encounter references to the Qiskit Runtime primitives, which function implementations of the Sampler and Estimator interfaces present in the qiskit.primitives module. These interfaces facilitate the seamless interchangeability of primitive implementations with minimal code modifications. The initial release of Qiskit Runtime comprises two essential primitives:

  • Sampler: This primitive generates quasi-probabilities based on input circuits.
  • Estimator: This primitive calculates expectation values derived from input circuits and observables.

For more comprehensive insights, detailed information is obtainable in the next resource: https://qiskit.org/ecosystem/ibm-runtime/tutorials/how-to-getting-started-with-sampler.html.

Venturing into quantum approaches for supervised machine learning poses a novel research direction. Classical machine learning extensively utilizes kernel methods, amongst which the support vector machine (SVM) for classification stands out for its widespread application.

SVMs, known for his or her role in binary classification, have increasingly been applied to multiclass problems. The essence of binary SVM involves devising a hyperplane to linearly separate n-dimensional data points into two groups, aiming for an optimal margin that distinctively classifies the information into its respective categories. This hyperplane, effective in either the unique feature space or a transformed higher-dimensional kernel space, is chosen for its capability to maximise the separation between classes, which involves an optimization problem to maximise the margin, defined as the gap from the closest data point to the hyperplane on either side. This results in the formulation of a maximum-margin classifier. The critical data points on the boundary are termed support vectors, and the margin represents a zone typically devoid of information points. An optimal hyperplane too proximate to the information points, indicating a slender margin, undermines the model’s predictive robustness and generalization capability.

To navigate multiclass SVM challenges, methods just like the all-pair strategy, which conducts a binary classification for every pair of classes, have been introduced. Beyond straightforward linear classification, nonlinear classifications will be achieved through the kernel trick. This system employs a kernel function to raise inputs right into a more expansive, higher-dimensional feature space, facilitating the separation of information that is just not linearly separable within the input space. The kernel function essentially performs an inner product in a potentially vast Euclidian space, often called the feature space. The goal of nonlinear SVM is to attain this separation by mapping data to a better dimension using an appropriate mapping. Choosing an appropriate feature map becomes crucial for data that can’t be addressed by linear methods alone. That is where quantum can jump into it. Quantum kernel methods, mixing classical kernel strategies with quantum innovations, carve out recent avenues in machine learning. Early quantum kernel approaches have focused on encoding data points into inner products or amplitudes in Hilbert space through quantum feature maps. The complexity of the quantum circuit implementing the feature map scales linearly or polylogarithmically with the dataset size.

In this primary example, we are going to use the ZZFeatureMap with linear entanglement, we are going to repeat the information encoding step two times, and we are going to use feature reduction with principal component evaluation. You may after all use other feature reduction, data rescaling or feature selection techniques to enhance the accuracy of your models. We are going to use the breast cancer dataset you can find here: https://github.com/xaviervasques/hephaistos/blob/foremost/data/datasets/breastcancer.csv

Let’s describe the steps of the Python script below. This Python script demonstrates an application of integrating quantum computing techniques with traditional machine learning to categorise breast cancer data. It represents a hybrid approach, where quantum-enhanced features are used inside a classical machine learning workflow. The goal is to predict breast cancer diagnosis (benign or malignant) based on a set of features extracted from the breast mass characteristics.

The way in which of doing quantum kernel machine learning may be very just like what we do classically as data scientists. We import the crucial libraries (Pandas, NumPy, scikit-learn) and Qiskit for quantum computing and kernel estimation, we load the information, preprocess the information and separate the information into features (X) and goal labels (y). A particular step is the quantum feature mapping. The script sets up a quantum feature map using the ZZFeatureMap from Qiskit, configured with specified parameters for feature dimension, repetitions, and entanglement type. Quantum feature maps are critical for translating classical data into quantum states, enabling the appliance of quantum computing principles for data evaluation. Then, the quantum kernel setup consists in configuring a quantum kernel with a fidelity-based approach. It serves as a brand new method to compute the similarity between data points within the feature space defined by quantum states and potentially capturing complex patterns. The last step comes back to a classic machine learning pipeline with data rescaling with standard scaler, dimension reduction using principal component evaluation and using support vector classifier (SVC) which utilizes the quantum kernel for classification. We evaluate the model using 5-fold cross-validation.

Let’s code.

# Import crucial libraries for data manipulation, machine learning, and quantum computing
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# Load the dataset using pandas, specifying the file location and delimiter
breastcancer = './breastcancer.csv'
df = pd.read_csv(breastcancer, delimiter=';')

# Remove the 'id' column because it is just not useful for prediction, to simplify the dataset
df = df.drop(["id"], axis=1)

# Separate the dataset into features (X) and goal label (y)
y = df['diagnosis'] # Goal label: diagnosis
X = df.drop('diagnosis', axis=1) # Features: all other columns

# Convert the diagnosis string labels into numeric values to be utilized by machine learning models
label_encoder = LabelEncoder()
y = label_encoder.fit_transform(y)

# Quantum computing sections start here
# Set parameters for the quantum feature map
feature_dimension = 2 # Variety of features utilized in the quantum feature map
reps = 2 # Variety of repetitions of the feature map circuit
entanglement = 'linear' # Form of entanglement within the quantum circuit

# Import quantum feature mapping utilities from Qiskit
from qiskit.circuit.library import ZZFeatureMap
qfm = ZZFeatureMap(feature_dimension=feature_dimension, reps=reps, entanglement=entanglement)

# Arrange a neighborhood simulator for quantum computation
from qiskit.primitives import Sampler
sampler = Sampler()

# Configure quantum kernel using ZZFeatureMap and a fidelity-based quantum kernel
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit_machine_learning.kernels import FidelityQuantumKernel
fidelity = ComputeUncompute(sampler=sampler)
quantum_zz = FidelityQuantumKernel(fidelity=fidelity, feature_map=qfm)

# Create a machine learning pipeline integrating standard scaler, PCA for dimensionality reduction,
# and a Support Vector Classifier using the quantum kernel
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
pipeline = make_pipeline(StandardScaler(), PCA(n_components=2), SVC(kernel=quantum_zz.evaluate))

# Evaluate the model using cross-validation to evaluate its performance
from sklearn.model_selection import cross_val_score
cv = cross_val_score(pipeline, X, y, cv=5, n_jobs=1) # n_jobs=1 specifies that the computation will use 1 CPU
mean_score = np.mean(cv) # Calculate the mean of the cross-validation scores

# Print the mean cross-validation rating to judge the model's performance
print(mean_score)

We are going to obtain a mean rating validation rating of 0.63.

This code is executed with the local simulator. To run on real hardware, replace the next lines:

# Arrange a neighborhood simulator for quantum computation
from qiskit.primitives import Sampler
sampler = Sampler()

by

# Import crucial classes from qiskit_ibm_runtime for accessing IBM Quantum services
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler

# Initialize the QiskitRuntimeService together with your IBM Quantum credentials
# 'channel', 'token', and 'instance' are placeholders to your actual IBM Quantum account details
service = QiskitRuntimeService(channel='YOUR CHANNEL', token='YOUR TOKEN FROM IBM QUANTUM', instance='YOUR INSTANCE')

# Specify the backend you would like to make use of. This might be a simulator or an actual quantum computer available through IBM Quantum
# 'quantum_backend' ought to be replaced with the name of the quantum backend you would like to make use of
backend = service.backend('quantum_backend')

# Import the Options class to customize the execution of quantum programs
from qiskit_ibm_runtime import Options
options = Options() # Create an instance of Options

# Set the resilience level. Level 1 typically implies some level of error mitigation or resilience against errors
options.resilience_level = 1

# Set the variety of shots, which is the variety of times the quantum circuit can be executed to assemble statistics
# More shots can result in more accurate results but take longer to execute
options.execution.shots = 1024

# Set the optimization level for compiling the quantum circuit
# Higher optimization levels attempt to scale back the circuit's complexity, which may improve execution but may take longer to compile
options.optimization_level = 3

# Initialize the Sampler, which is used to run quantum circuits and acquire samples from their measurement outcomes
# The Sampler is configured with the required backend and options
sampler = Sampler(session=backend, options=options)

This part will explore the tactic of Quantum Kernel Alignment (QKA) for the aim of binary classification. QKA iteratively adjusts a quantum kernel that’s parameterized to suit a dataset, aiming for the most important possible margin in Support Vector Machines (SVM). For further details on QKA, reference is made to the preprint titled “Covariant quantum kernels for data with group structure.” The Python script below is a comprehensive example of integrating traditional machine learning techniques with quantum computing for the prediction accuracy in classifying breast cancer diagnosis. It employs a dataset of breast cancer characteristics to predict the diagnosis (benign or malignant).

The machine learning pipeline is analogous to the one utilized in the quantum kernel with ZZFeatureMaps section. The difference is that we’ll constructs a custom quantum circuit, integrating a rotational layer with a ZZFeatureMap, to arrange the quantum state representations of the information. The quantum kernel estimation step utilizes Qiskit primitives and algorithms for optimizing the quantum kernel’s parameters using a quantum kernel trained (QKT) and an optimizer.

Let’s code.

# Import crucial libraries for data manipulation, machine learning, and quantum computing
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# Load the dataset using pandas, specifying the file location and delimiter
breastcancer = './breastcancer.csv'
df = pd.read_csv(breastcancer, delimiter=';')

# Remove the 'id' column because it is just not useful for prediction, to simplify the dataset
df = df.drop(["id"], axis=1)

# Reduce the dataframe size by sampling 1/3 of the information
df = df.sample(frac=1/3, random_state=1) # random_state for reproducibility

# Separate the dataset into features (X) and goal label (y)
y = df['diagnosis'] # Goal label: diagnosis
X = df.drop('diagnosis', axis=1) # Features: all other columns

# Convert the diagnosis string labels into numeric values to be utilized by machine learning models
label_encoder = LabelEncoder()
y = label_encoder.fit_transform(y)

# Quantum computing sections start here
# Set parameters for the quantum feature map
feature_dimension = 2 # Variety of features utilized in the quantum feature map
reps = 2 # Variety of repetitions of the feature map circuit
entanglement = 'linear' # Form of entanglement within the quantum circuit

# Define a custom rotational layer for the quantum feature map
from qiskit import QuantumCircuit
from qiskit.circuit import ParameterVector
training_params = ParameterVector("θ", 1)
fm0 = QuantumCircuit(feature_dimension)
for qubit in range(feature_dimension):
fm0.ry(training_params[0], qubit)

# Use ZZFeatureMap to represent input data
from qiskit.circuit.library import ZZFeatureMap
fm1 = ZZFeatureMap(feature_dimension=feature_dimension, reps=reps, entanglement=entanglement)

# Compose the custom rotational layer with the ZZFeatureMap to create the feature map
fm = fm0.compose(fm1)

# Initialize the Sampler, a Qiskit primitive for sampling from quantum circuits
from qiskit.primitives import Sampler
sampler = Sampler()

# Arrange the ComputeUncompute fidelity object for quantum kernel estimation
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit_machine_learning.kernels import TrainableFidelityQuantumKernel
fidelity = ComputeUncompute(sampler=sampler)

# Instantiate the quantum kernel with the feature map and training parameters
quant_kernel = TrainableFidelityQuantumKernel(fidelity=fidelity, feature_map=fm, training_parameters=training_params)

# Callback class for tracking optimization progress
class QKTCallback:
# Callback wrapper class
def __init__(self):
self._data = [[] for i in range(5)]

def callback(self, x0, x1=None, x2=None, x3=None, x4=None):
#Capture callback data for evaluation
for i, x in enumerate([x0, x1, x2, x3, x4]):
self._data[i].append(x)

def get_callback_data(self):
#Get captured callback data
return self._data

def clear_callback_data(self):
#Clear captured callback data
self._data = [[] for i in range(5)]

# Setup and instantiate the optimizer for the quantum kernel
from qiskit.algorithms.optimizers import SPSA
cb_qkt = QKTCallback()
spsa_opt = SPSA(maxiter=10, callback=cb_qkt.callback, learning_rate=0.01, perturbation=0.05)

# Quantum Kernel Trainer (QKT) for optimizing the kernel parameters
from qiskit_machine_learning.kernels.algorithms import QuantumKernelTrainer
qkt = QuantumKernelTrainer(
quantum_kernel=quant_kernel, loss="svc_loss", optimizer=spsa_opt, initial_point=[np.pi / 2]
)

# Reduce dimensionality of the information using PCA
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_ = pca.fit_transform(X)

# Train the quantum kernel with the reduced dataset
qka_results = qkt.fit(X_, y)
optimized_kernel = qka_results.quantum_kernel

# Use the quantum-enhanced kernel in a Quantum Support Vector Classifier (QSVC)
from qiskit_machine_learning.algorithms import QSVC
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
qsvc = QSVC(quantum_kernel=optimized_kernel)
pipeline = make_pipeline(StandardScaler(), PCA(n_components=2), qsvc)

# Evaluate the performance of the model using cross-validation
from sklearn.model_selection import cross_val_score
cv = cross_val_score(pipeline, X, y, cv=5, n_jobs=1)
mean_score = np.mean(cv)

# Print the mean cross-validation rating
print(mean_score)

We are going to obtain the next output: 0.6526315789473685

As you actually observed, there may be time differences in execution between QKT and using a quantum kernel with a predefined feature map like ZZFeatureMap even when we reduced the dataframe size by sampling 1/3 of the information and setting the utmost iteration for SPSA to 10. QKT involves not only using a quantum kernel but in addition the optimization of parameters throughout the quantum feature map or the kernel itself to enhance model performance. This optimization process requires iterative adjustments to the parameters, where each iteration involves running quantum computations to judge the performance of the present parameter set. This iterative nature significantly increases computational time. When using a predefined quantum kernel just like the ZZFeatureMap, the feature mapping is fixed, and there’s no iterative optimization of quantum parameters involved. The quantum computations are performed to judge the kernel between data points, but without the added overhead of adjusting and optimizing quantum circuit parameters. This approach is more straightforward and requires fewer quantum computations, making it faster. Each step of the optimization process in QKT requires evaluating the model’s performance with the present quantum kernel, which depends upon the quantum feature map parameters at that step. This implies multiple evaluations of the kernel matrix, each of which requires a considerable variety of quantum computations.

This Python script below incorporates quantum neural networks (QNNs) right into a machine learning pipeline. Within the script, we’d like to configure the quantum feature map and ansatz (a quantum circuit structure), construct a quantum circuit by appending the feature map and ansatz to a base quantum circuit (this setup is crucial for creating quantum neural networks that process input data quantum mechanically) and create a QNN using the quantum circuit designed for binary classification. Before coming back to the classic machine learning pipeline with data rescaling, data reduction and model evaluation, we employ a quantum classifier which integrates the QNN with a classical optimization algorithm (COBYLA) for training. A callback function is defined to visualise the optimization process, tracking the target function value across iterations.

Let’s code.

# Importing essential libraries for handling data, machine learning, and integrating quantum computing
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
import matplotlib.pyplot as plt # For data visualization

# Load and prepare the dataset
breastcancer = './breastcancer.csv'
df = pd.read_csv(breastcancer, delimiter=';') # Load dataset from CSV file
df = df.drop(["id"], axis=1) # Remove the 'id' column as it is not crucial for evaluation

# Splitting the information into features (X) and the goal variable (y)
y = df['diagnosis'] # Goal variable: diagnosis result
X = df.drop('diagnosis', axis=1) # Feature matrix: all data except the diagnosis

# Encoding string labels in 'y' into numerical form for machine learning models
label_encoder = LabelEncoder()
y = label_encoder.fit_transform(y) # Transform labels to numeric

# Quantum feature map and circuit configuration
feature_dimension = 2 # Dimensionality for the feature map (matches PCA reduction later)
reps = 2 # Variety of repetitions of the ansatz circuit for depth
entanglement = 'linear' # Form of qubit entanglement within the circuit

# Initialize an array to store evaluations of the target function during optimization
objective_func_vals = []

# Define a callback function for visualization of the optimization process
def callback_graph(weights, obj_func_eval):
"""Updates and saves a plot of the target function value after each iteration."""
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.savefig('Objective_function_value_against_iteration.png') # Save plot to file

# Example function circuitously utilized in the foremost workflow, demonstrating a utility function
def parity(x):
"""Example function to calculate parity of an integer."""
return "{:b}".format(x).count("1") % 2

# Initializing the quantum sampler from Qiskit
from qiskit.primitives import Sampler
sampler = Sampler() # Used for sampling from quantum circuits

# Constructing the quantum feature map and ansatz for the quantum circuit
from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
feature_map = ZZFeatureMap(feature_dimension)
ansatz = RealAmplitudes(feature_dimension, reps=reps) # Quantum circuit ansatz

# Composing the quantum circuit with the feature map and ansatz
from qiskit import QuantumCircuit
qc = QuantumCircuit(feature_dimension)
qc.append(feature_map, range(feature_dimension)) # Apply feature map to circuit
qc.append(ansatz, range(feature_dimension)) # Apply ansatz to circuit
qc.decompose().draw() # Draw and decompose circuit for visualization

# Making a Quantum Neural Network (QNN) using the configured quantum circuit
from qiskit_machine_learning.neural_networks import SamplerQNN
sampler_qnn = SamplerQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
output_shape=2, # For binary classification
sampler=sampler
)

# Configuring the quantum classifier with the COBYLA optimizer
from qiskit.algorithms.optimizers import COBYLA
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
sampler_classifier = NeuralNetworkClassifier(
neural_network=sampler_qnn, optimizer=COBYLA(maxiter=100), callback=callback_graph)

# Establishing K-Fold Cross Validation to evaluate model performance
from sklearn.model_selection import KFold
k_fold = KFold(n_splits=5) # 5-fold cross-validation
rating = np.zeros(5) # Array to store scores for every fold
i = 0 # Index counter for scores array
for indices_train, indices_test in k_fold.split(X):
X_train, X_test = X.iloc[indices_train], X.iloc[indices_test]
y_train, y_test = y[indices_train], y[indices_test]

# Applying PCA to scale back the dimensionality of the dataset to match the quantum feature map
from sklearn.decomposition import PCA
pca = PCA(n_components=2) # Reduce to 2 dimensions for the quantum circuit
X_train = pca.fit_transform(X_train) # Transform training set
X_test = pca.fit_transform(X_test) # Transform test set

# Training the quantum classifier with the training set
sampler_classifier.fit(X_train, y_train)

# Evaluating the classifier's performance on the test set
rating[i] = sampler_classifier.rating(X_test, y_test) # Store rating for this fold
i += 1 # Increment index for next rating

# Calculating and displaying the outcomes of cross-validation
import math
print("Cross-validation scores:", rating)
cross_mean = np.mean(rating) # Mean of cross-validation scores
cross_var = np.var(rating) # Variance of scores
cross_std = math.sqrt(cross_var) # Standard deviation of scores

print("Mean cross-validation rating:", cross_mean)
print("Standard deviation of cross-validation scores:", cross_std)

We obtain the next results:

Cross-validation scores: [0.34210526 0.4122807 0.42982456 0.21929825 0.50442478]

Mean cross-validation rating: 0.3815867101381773

Standard deviation of cross-validation scores: 0.09618163326986424

As we are able to see, on this specific dataset, QNN doesn’t provide a excellent classification rating.

This concept of this blog is to make it easy to begin using quantum machine learning. Quantum Machine Learning is an emerging field on the intersection of quantum computing and machine learning that holds the potential to revolutionize how we process and analyze vast datasets by leveraging the inherent benefits of quantum mechanics. As we showed in our paper Application of quantum machine learning using quantum kernel algorithms on multiclass neuron M-type classification published in Nature Scientific Report, an important aspect of optimizing QML models, including Quantum Neural Networks (QNNs), involves pre-processing techniques corresponding to feature rescaling, feature extraction, and have selection.

These techniques are usually not only essential in classical machine learning but in addition present significant advantages when applied throughout the quantum computing framework, enhancing the performance and efficiency of quantum machine learning algorithms. Within the quantum realm, feature extraction techniques like Principal Component Evaluation (PCA) will be quantum-enhanced to scale back the dimensionality of the information while retaining most of its significant information. This reduction is significant for QML models resulting from the limited variety of qubits available on current quantum hardware.

Quantum feature extraction can efficiently map high-dimensional data right into a lower-dimensional quantum space, enabling quantum models to process complex datasets with fewer resources. Choosing essentially the most relevant features can be a way for optimizing quantum circuit complexity and resource allocation. In quantum machine learning, feature selection helps in identifying and utilizing essentially the most informative features, reducing the necessity for extensive quantum resources.

This process not only simplifies the quantum models but in addition enhances their performance by focusing the computational efforts on the features that contribute essentially the most to the predictive accuracy of the model.

Sources

Machine Learning Theory and Applications: Hands-on Use Cases with Python on Classical and Quantum Machines, Wiley, 2024

Vasques, X., Paik, H. & Cif, L. Application of quantum machine learning using quantum kernel algorithms on multiclass neuron M-type classification. Sci Rep 13, 11541 (2023). https://doi.org/10.1038/s41598-023-38558-z

This dataset used is licensed under a Creative Commons Attribution 4.0 International (CC BY 4.0) license.

LEAVE A REPLY

Please enter your comment!
Please enter your name here