squlearn.qnn.QNNRegressor

class squlearn.qnn.QNNRegressor(encoding_circuit: EncodingCircuitBase, operator: ObservableBase | list[ObservableBase], executor: Executor, loss: LossBase, optimizer: OptimizerBase, param_ini: ndarray = None, param_op_ini: ndarray = None, batch_size: int = None, epochs: int = None, shuffle: bool = None, opt_param_op: bool = True, variance: float | Callable = None, shot_control: ShotControlBase = None, parameter_seed: int | None = 0, caching: bool = True, pretrained: bool = False, callback: Callable | str | None = 'pbar', primitive: str | None = None, **kwargs)

Quantum Neural Network for Regression.

This class implements a quantum neural network (QNN) for regression with a scikit-learn interface. A parameterized quantum circuit and a possibly parameterized operator are used as a ML model. They are trained according to a specified loss using the specified optimizer. Mini-batch training is possible.

Parameters:

  • encoding_circuit (EncodingCircuitBase) – The parameterized quantum circuit (PQC) part of the QNN. For a list of encoding circuits, check this list of implemented Encoding Circuits.

  • operator (Union[ObservableBase, list[ObservableBase]]) – The operator that is used in the expectation value of the QNN. Can be a list for multiple outputs. For a list of operators, check this list of implemented Operators.

  • executor (Executor) – Executor instance.

  • loss (LossBase) – The loss function to be optimized. Can also be combination of multiple loss functions.

  • optimizer (OptimizerBase) – The optimizer instance that is used to minimize the loss function.

  • param_ini (np.ndarray, default=None) – Initial values of the parameters of the PQC.

  • param_op_ini (np.ndarray, default=None) – Initial values of the parameters of the operator.

  • batch_size (int, default=None) – Number of data points in each batch in mini-batch training. Will only be used if optimizer is of type SGDMixin.

  • epochs (int, default=None) – Number of epochs of SGD to perform. Will only be used if optimizer is of type SGDMixin.

  • shuffle (bool, default=None) – If True, data points get shuffled before each epoch. Will only be used if optimizer is of type SGDMixin.

  • opt_param_op (bool, default=True) – If True, the operators parameters get optimized.

  • variance (Union[float, Callable], default=None) – The variance factor to be used. If it is None, the variance regularization will not be used. Else this determines the strength of the variance regularization.

  • parameter_seed (Union[int, None], default=0) – Seed for the random number generator for the parameter initialization, if param_ini or param_op_ini is None.

  • caching (bool, default=True) – If True, the results of the QNN are cached.

  • pretrained (bool, default=False) – Set to true if the supplied parameters are already trained.

  • callback (Union[Callable, str, None], default=None) – A callback for the optimization loop. Can be either a Callable, “pbar” (which uses a tqdm.tqdm process bar) or None. If None, the optimizers (default) callback will be used.

  • primitive (Union[str,None], default=None) – The primitive that is utilized in the qnn. Default primitive is the one specified in the executor initialization, if nothing is specified, the estimator will used. Possible values are "estimator" or "sampler".

See also

squlearn.qnn.QNNClassifier

Quantum Neural Network for Classification.

Example

import numpy as np
from squlearn import Executor
from squlearn.encoding_circuit import ChebyshevRx
from squlearn.observables import IsingHamiltonian
from squlearn.qnn import QNNRegressor, SquaredLoss
from squlearn.optimizers import SLSQP
from sklearn.model_selection import train_test_split

X, y = np.arange(0.1, 0.9, 0.01), np.log(np.arange(0.1, 0.9, 0.01))
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=42
)
reg = QNNRegressor(
    ChebyshevRx(4, 1, 2),
    IsingHamiltonian(4, I="S", Z="S", ZZ="S"),
    Executor(),
    SquaredLoss(),
    SLSQP(),
    np.random.rand(16),
    np.random.rand(5)
)
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test[:5])

Differential Evolution Solver Example

import numpy as np
import sympy as sp
import matplotlib.pyplot as plt
from squlearn import Executor
from squlearn.encoding_circuit import KyriienkoEncodingCircuit
from squlearn.observables import SummedPaulis
from squlearn.qnn import QNNRegressor, ODELoss, get_lr_decay
from squlearn.optimizers import Adam


t, y, dydt, = sp.symbols("t y dydt")
eq = 20 * sp.exp(-20 * t * 0.1) * sp.sin(20 * t) + 20 * 0.1 * y  + dydt
initial_values = [1.0]

loss_ODE = ODELoss(
    eq,
    symbols_involved_in_ODE=[t, y, dydt],
    initial_values=initial_values,
    boundary_handling="pinned",
)

circuit = KyriienkoEncodingCircuit(
    num_qubits=6,
    encoding_style="chebyshev_tower",
    variational_arrangement="HEA",
    num_features=1,
    num_encoding_layers=1,
    num_variational_layers=5,
)
observable = SummedPaulis(6, include_identity=False)

param_observable = observable.generate_initial_parameters(seed=1)
param_initial = circuit.generate_initial_parameters(seed=1)

ode_regressor = QNNRegressor(
    circuit,
    observable,
    Executor("pennylane"),
    loss_ODE,
    Adam(options={"maxiter": 150, "tol": 0.00009, "lr": get_lr_decay(0.05, 0.02, 150)}),
    param_initial,
    param_observable,
    opt_param_op=False,
)

Methods:

fit(X, y, weights: ndarray = None) → None

Fit a new model to data.

This method will reinitialize the models parameters and fit it to the provided data.

Parameters:

  • X – array-like or sparse matrix of shape (n_samples, n_features) Input data

  • y – array-like of shape (n_samples,) Labels

  • weights – Weights for each data point

get_metadata_routing()

Get metadata routing of this object.

Please check User Guide on how the routing mechanism works.

Returns:

routing – A MetadataRequest encapsulating routing information.

Return type:

MetadataRequest

get_params(deep: bool = True) → dict

Returns a dictionary of parameters for the current object.

Parameters:

deep – If True, includes the parameters from the base class.

Returns:

A dictionary of parameters for the current object.

Return type:

dict

partial_fit(X, y, weights: ndarray = None) → None

Fit a model to data.

This method will update the models parameters to fit the provided data. It won’t reinitialize the models parameters.

Parameters:

  • X – array-like or sparse matrix of shape (n_samples, n_features) Input data

  • y – array-like or sparse matrix of shape (n_samples,) Labels

  • weights – Weights for each data point

predict(X: ndarray) → ndarray

Predict using the QNN.

Parameters:

X – The input data.

Returns:

The predicted values.

Return type:

np.ndarray

score(X, y, sample_weight=None)

Return the coefficient of determination of the prediction.

The coefficient of determination \(R^2\) is defined as \((1 - \frac{u}{v})\), where \(u\) is the residual sum of squares ((y_true - y_pred)** 2).sum() and \(v\) is the total sum of squares ((y_true - y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a \(R^2\) score of 0.0.

Parameters:

  • X (array-like of shape (n_samples, n_features)) – Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead with shape (n_samples, n_samples_fitted), where n_samples_fitted is the number of samples used in the fitting for the estimator.

  • y (array-like of shape (n_samples,) or (n_samples, n_outputs)) – True values for X.

  • sample_weight (array-like of shape (n_samples,), default=None) – Sample weights.

Returns:

score – \(R^2\) of self.predict(X) w.r.t. y.

Return type:

float

Notes

The \(R^2\) score used when calling score on a regressor uses multioutput='uniform_average' from version 0.23 to keep consistent with default value of r2_score(). This influences the score method of all the multioutput regressors (except for MultiOutputRegressor).

set_fit_request(*, weights: bool | None | str = '$UNCHANGED$') → QNNRegressor

Request metadata passed to the fit method.

Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config()). Please see User Guide on how the routing mechanism works.

The options for each parameter are:

  • True: metadata is requested, and passed to fit if provided. The request is ignored if metadata is not provided.

  • False: metadata is not requested and the meta-estimator will not pass it to fit.

  • None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.

  • str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Note

This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline. Otherwise it has no effect.

Parameters:

weights (str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED) – Metadata routing for weights parameter in fit.

Returns:

self – The updated object.

Return type:

object

set_params(**params) → BaseQNN

Sets the hyper-parameters of the BaseQNN.

Parameters:

params – Hyper-parameters of the BaseQNN.

Returns:

updated BaseQNN

set_partial_fit_request(*, weights: bool | None | str = '$UNCHANGED$') → QNNRegressor

Request metadata passed to the partial_fit method.

Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config()). Please see User Guide on how the routing mechanism works.

The options for each parameter are:

  • True: metadata is requested, and passed to partial_fit if provided. The request is ignored if metadata is not provided.

  • False: metadata is not requested and the meta-estimator will not pass it to partial_fit.

  • None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.

  • str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Note

This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline. Otherwise it has no effect.

Parameters:

weights (str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED) – Metadata routing for weights parameter in partial_fit.

Returns:

self – The updated object.

Return type:

object

set_score_request(*, sample_weight: bool | None | str = '$UNCHANGED$') → QNNRegressor

Request metadata passed to the score method.

Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config()). Please see User Guide on how the routing mechanism works.

The options for each parameter are:

  • True: metadata is requested, and passed to score if provided. The request is ignored if metadata is not provided.

  • False: metadata is not requested and the meta-estimator will not pass it to score.

  • None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.

  • str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Note

This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline. Otherwise it has no effect.

Parameters:

sample_weight (str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED) – Metadata routing for sample_weight parameter in score.

Returns:

self – The updated object.

Return type:

object