quantum kernelとか

quant_kernel = TrainableFidelityQuantumKernel(feature_map=fm, training_parameters=training_params)

import numpy as np
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# データセットの読み込み
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# SPSA アルゴリズムの実装
def spsa(f, theta0, alpha, beta, gamma, max_iterations):
    theta = theta0
    for k in range(max_iterations):
        ck = gamma / (k + 1) ** beta
        delta = 2 * np.random.randint(0, 2, size=theta0.shape) - 1
        theta_plus = theta + ck * delta
        theta_minus = theta - ck * delta
        ghat = (f(theta_plus) - f(theta_minus)) / (2.0 * ck * delta)
        ak = alpha / (k + 1 + A) ** alpha
        theta = theta - ak * ghat
    return theta

# SVC スコアの計算関数
def svc_score(params):
    C, gamma = params
    model = SVC(C=C, gamma=gamma)
    model.fit(X_train, y_train)
    predictions = model.predict(X_test)
    return -accuracy_score(y_test, predictions)  # 最適化では最小化を行うため、スコアの符号を反転

# ハイパーパラメータの初期値
initial_params = np.array([1.0, 0.01])  # 初期 C と gamma
alpha = 0.602
beta = 0.101
gamma = 0.1
A = 50
max_iterations = 100

# SPSA 最適化の実行
optimal_params = spsa(svc_score, initial_params, alpha, beta, gamma, max_iterations)

# 最適化されたハイパーパラメータで SVC モデルをトレーニング
C_opt, gamma_opt = optimal_params
model_opt = SVC(C=C_opt, gamma=gamma_opt)
model_opt.fit(X_train, y_train)
predictions_opt = model_opt.predict(X_test)
score_opt = accuracy_score(y_test, predictions_opt)

print("Optimized Parameters: C =", C_opt, ", gamma =", gamma_opt)
print("Optimized Accuracy:", score_opt)

        if callable(self._optimizer):
            opt_results = self._optimizer(fun=loss_function, x0=self._initial_point)
        else:
            opt_results = self._optimizer.minimize(
                fun=loss_function,
                x0=self._initial_point,
            )

class SVCLoss(KernelLoss):
    r"""
    This class provides a kernel loss function for classification tasks by fitting an ``SVC`` model
    from scikit-learn. Given training samples, :math:`x_{i}`, with binary labels, :math:`y_{i}`,
    and a kernel, :math:`K_{θ}`, parameterized by values, :math:`θ`, the loss is defined as:

    .. math::

        SVCLoss = \sum_{i} a_i - 0.5 \sum_{i,j} a_i a_j y_{i} y_{j} K_θ(x_i, x_j)

    where :math:`a_i` are the optimal Lagrange multipliers found by solving the standard SVM
    quadratic program. Note that the hyper-parameter ``C`` for the soft-margin penalty can be
    specified through the keyword args.

    Minimizing this loss over the parameters, :math:`θ`, of the kernel is equivalent to maximizing a
    weighted kernel alignment, which in turn yields the smallest upper bound to the SVM
    generalization error for a given parameterization.

    See https://arxiv.org/abs/2105.03406 for further details.
    """

    def __init__(self, **kwargs):
        """
        Args:
            **kwargs: Arbitrary keyword arguments to pass to SVC constructor within
                      SVCLoss evaluation.
        """
        self.kwargs = kwargs

    def evaluate(
        self,
        parameter_values: Sequence[float],
        quantum_kernel: TrainableKernel,
        data: np.ndarray,
        labels: np.ndarray,
    ) -> float:
        # Bind training parameters
        quantum_kernel.assign_training_parameters(parameter_values)

        # Get estimated kernel matrix
        kmatrix = quantum_kernel.evaluate(np.array(data))

        # Train a quantum support vector classifier
        svc = SVC(kernel="precomputed", **self.kwargs)
        svc.fit(kmatrix, labels)

        # Get dual coefficients
        dual_coefs = svc.dual_coef_[0]

        # Get support vectors
        support_vecs = svc.support_

        # Prune kernel matrix of non-support-vector entries
        kmatrix = kmatrix[support_vecs, :][:, support_vecs]

        # Calculate loss
        loss = np.sum(np.abs(dual_coefs)) - (0.5 * (dual_coefs.T @ kmatrix @ dual_coefs))

        return loss

from functools import partial

def my_function(a, b, c):
    return a + b + c

# ここでpartialを使って、aとbを固定する
new_function = partial(my_function, a=1, b=2)

# new_functionを呼び出すときには、cのみを指定すれば良い
result = new_function(c=3)  # これは my_function(1, 2, 3)と同じ結果になる