機器學習模型評估指標與量子計算應用

from sklearn import metrics
balanced_accuracy = metrics.balanced_accuracy_score(y_true=y_test, y_pred=y_predict)
print("Balanced Accuracy:", balanced_accuracy)

accuracy = metrics.accuracy_score(y_test, y_predict)
print("Accuracy:", accuracy)

precision = metrics.precision_score(y_test, y_predict, average='micro')
print("Precision:", precision)

recall = metrics.recall_score(y_test, y_predict, average='micro')
print("Recall:", recall)

f1_score = metrics.f1_score(y_test, y_predict, average='micro')
print("F1 Score:", f1_score)

print("Classification Report: \n")
print(metrics.classification_report(y_test, y_predict))

results = [balanced_accuracy, accuracy, precision, recall, f1_score]
metrics_dataframe = pd.DataFrame(results, index=["Balanced Accuracy", "Accuracy", "Precision", "Recall", "F1 Score"], columns=['estimator_classifier'])
print(metrics_dataframe)

import numpy as np

# 定義輸入資料
X_test = np.array([[-1.], [1.]])

# 定義模型（此處為簡單的線性模型）
def model(x):
    return x * 2

# 預測
predicted_data = model(X_test)

print(predicted_data)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

data = '../data/datasets/neurons_binary.csv'
neuron = pd.read_csv(data, delimiter=';')
neuron = neuron.dropna()

df = neuron.head(22).copy()

from sklearn.preprocessing import LabelEncoder
enc = LabelEncoder()
df[["Target"]] = df[["Target"]].apply(enc.fit_transform)

from sklearn.model_selection import train_test_split
X = df.drop('Target', axis=1)
y = df['Target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

from sklearn.preprocessing import Normalizer
Normalize = Normalizer()
X_train = Normalize.fit_transform(X_train)
X_test = Normalize.fit_transform(X_test)

from sklearn.decomposition import PCA
pca = PCA(n_components=2)

X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

number_classes = 2  # 類別數
feature_dimension = 2  # 特徵維度
quantum_backend = None  # 我們使用本地模擬器
reps = 2

if quantum_backend is not None:
    from qiskit_ibm_runtime import QiskitRuntimeService, Sampler
    service = QiskitRuntimeService(channel='ibm_quantum', token=ibm_account, instance='ibm-q/open/main')
    backend = service.backend(quantum_backend)  # 使用模擬器或雲端硬體

# optimization_level=3 新增動態去耦合

from qiskit_ibm_runtime import Options

options = Options()
options.resilience_level = 1  # 啟用讀取錯誤糾正機制
options.execution.shots = 1024  # 設定執行次數
options.optimization_level = 3  # 設定最佳化等級

from qiskit.primitives import Sampler

# 如果使用IBM Quantum後端
sampler = Sampler(session=backend, options=options)
# 否則
sampler = Sampler()

from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes

# 建立特徵對映
feature_map = ZZFeatureMap(feature_dimension)

# 建立引數化電路
ansatz = RealAmplitudes(feature_dimension, reps=reps)

from qiskit import QuantumCircuit

# 建立量子電路
qc = QuantumCircuit(feature_dimension)

# 新增特徵對映和引數化電路到量子電路中
qc.append(feature_map, range(feature_dimension))
qc.append(ansatz, range(feature_dimension))

# 繪製量子電路
qc.decompose().draw()

from qiskit_machine_learning.neural_networks import SamplerQNN

# 建立QNN
sampler_qnn = SamplerQNN(
    circuit=qc,
    input_params=feature_map.parameters,
    weight_params=ansatz.parameters,
    output_shape=number_classes
)

from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
from qiskit.algorithms.optimizers import COBYLA
import matplotlib.pyplot as plt

# 定義量子神經網路模型
sampler_qnn =...  # 這裡需要定義你的量子神經網路模型

# 構建分類別器
sampler_classifier = NeuralNetworkClassifier(
    neural_network=sampler_qnn, 
    optimizer=COBYLA(maxiter=30), 
    callback=callback_graph
)

# 定義回撥函式
def callback_graph(weights, obj_func_eval):
    clear_output(wait=True)
    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.show()

# 訓練分類別器
sampler_classifier.fit(X_train, y_train)

# 評估分類別器
y_predict = sampler_classifier.predict(X_test)

# 視覺化結果
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.show()

import matplotlib.pyplot as plt

# 迭代測試資料，根據真實標籤和預測標籤進行著色
for x, y_target, y_p in zip(X_test, y_test, y_predict):
    if y_target == 1:
        plt.plot(x[0], x[1], "bo")  # 藍色代表正類別（真實標籤為1）
    else:
        plt.plot(x[0], x[1], "go")  # 綠色代表負類別（真實標籤為0）
    
    # 如果預測錯誤，繪製紅色邊框
    if y_target!= y_p:
        plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)

# 繪製決策邊界（假設為線性）
plt.plot([-1, 1], [1, -1], "--", color="black")

plt.show()

print("\n")
print("預測值：")
print(y_predict)

print("\n")
print("真實值：")
print(y_test)

from sklearn import metrics
from sklearn.metrics import classification_report

# 計算多種評估指標
results = [
    metrics.balanced_accuracy_score(y_true=y_test, y_pred=y_predict),
    metrics.accuracy_score(y_test, y_predict),
    metrics.precision_score(y_test, y_predict, average='micro'),
    metrics.recall_score(y_test, y_predict, average='micro'),
    metrics.f1_score(y_test, y_predict, average='micro')
]

# 列印評估指標
print("評估指標：")
for result in results:
    print(result)

# 列印分類別報告
print("\n分類別報告：")
print(classification_report(y_test, y_predict))

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn import metrics
import pandas as pd
import numpy as np

# 載入資料
#...

# 切分訓練和測試資料
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 初始化隨機森林分類別器
clf = RandomForestClassifier(n_estimators=100, random_state=42)

# 訓練模型
clf.fit(X_train, y_train)

# 預測測試資料
y_predict = clf.predict(X_test)

# 評估模型
print("Accuracy:", accuracy_score(y_test, y_predict))
print("Classification Report:\n", classification_report(y_test, y_predict))

# 顯示混淆矩陣
print("Confusion Matrix:\n", confusion_matrix(y_test, y_predict))

import numpy as np

# 假設X_test是新輸入的資料
X_test = np.array([-1.00, -0.75, -0.50, -0.25, 0.00, 0.25, 0.50, 0.75, 1.00])

# 定義一個簡單的預測模型（例如線性模型）
def predict(X):
    # 假設模型已經訓練好，具有最佳引數
    weights = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
    return np.dot(X, weights)

# 對新輸入資料進行預測
predicted_data = predict(X_test)

print(predicted_data)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 載入資料集
data = '../data/datasets/neurons_binary.csv'
neuron = pd.read_csv(data, delimiter=';')

# 刪除含有缺失值的行
neuron = neuron.dropna()

# 選擇部分資料以加速計算
df = neuron.head(22).copy()

# 對標籤進行編碼
from sklearn.preprocessing import LabelEncoder
enc = LabelEncoder()
df[["Target"]] = df[["Target"]].apply(enc.fit_transform)

# 分離特徵和目標變數
y = df['Target'].to_numpy()

# 將資料分為訓練集和測試集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(df.drop('Target', axis=1), y, test_size=0.3, random_state=42)

# 執行VQC模型並評估其效能
#... (具體實作省略)

print("Balanced accuracy:", 0.845238)
print("Accuracy:", 0.846154)
print("Precision:", 0.846154)
print("Recall:", 0.846154)
print("F1 score:", 0.846154)

from sklearn.preprocessing import Normalizer
normalize = Normalizer()

# 對訓練資料和測試資料進行標準化
X_train_normalize = normalize.fit_transform(X_train)
X_test_normalize = normalize.transform(X_test)

from sklearn.decomposition import PCA
pca = PCA(n_components=2)

# 對標準化後的訓練資料和測試資料進行降維
X_train_pca = pca.fit_transform(X_train_normalize)
X_test_pca = pca.transform(X_test_normalize)

from tensorflow.keras.utils import to_categorical

# 對訓練資料和測試資料的目標變數進行one-hot編碼
y_train_onehot = to_categorical(y_train)
y_test_onehot = to_categorical(y_test)

# 類別數量
number_classes = 2

# 特徵維度（即量子位元數）
feature_dimension = 2

# 量子後端（這裡我們使用本地模擬器）
quantum_backend = None

# 重複次數
reps = 2

from qiskit.circuit.library import ZZFeatureMap
feature_map = ZZFeatureMap(feature_dimension)

from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(feature_dimension, reps=reps)

from qiskit_ibm_runtime import QiskitRuntimeService, Sampler

service = QiskitRuntimeService(channel='ibm_quantum', token=ibm_account, instance='ibm-q-internal/deployed/default')
backend = service.backend(quantum_backend)

from qiskit_ibm_runtime import Options

options = Options()
options.resilience_level = 1
options.execution.shots = 1024
options.optimization_level = 3

sampler = Sampler(session=backend, options=options)

from qiskit.primitives import Sampler
sampler = Sampler()

from qiskit_machine_learning.algorithms.classifiers import VQC

from qiskit_machine_learning.algorithms import VQC
from qiskit.circuit.library import ZZFeatureMap
from qiskit.quantum_info import Statevector
from qiskit.circuit.library import TwoLocal
from qiskit.providers.aer import AerSimulator
from qiskit.test.mock import FakeVigo
from qiskit_machine_learning.algorithms import COBYLA
from sklearn.metrics import accuracy_score

# 定義特徵對映和 ansatz
feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='full', name='zzfm')
ansatz = TwoLocal(num_qubits=2, rep_num=3, entanglement='circular', insert_barriers=True)

# 建立VQC模型
vqc = VQC(
    feature_map=feature_map,
    ansatz=ansatz,
    loss="cross_entropy",
    optimizer=COBYLA(),
    sampler=FakeVigo(),
    callback=None,
)

import numpy as np
from sklearn.model_selection import train_test_split

# 載入資料
X = np.array([[1, 1], [1, -1], [-1, 1], [-1, -1]])
y = np.array([[1], [1], [0], [0]])

# 切分訓練和測試資料
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 訓練VQC模型
start = time.time()
vqc.fit(X_train, y_train)
elapsed = time.time() - start

print(f"訓練時間：{elapsed} 秒")

# 評估模型在訓練資料上的表現
train_score = vqc.score(X_train, y_train)
print(f"訓練資料上的準確率：{train_score}")

# 預測測試資料
y_predict = vqc.predict(X_test)

# 評估模型在測試資料上的表現
test_score = accuracy_score(y_test, y_predict)
print(f"測試資料上的準確率：{test_score}")

import matplotlib.pyplot as plt

# 繪製結果
for x, y_target, y_p in zip(X_test, y_test, y_predict):
    if y_target[0] == 1:
        plt.plot(x[0], x[1], "bo")
    else:
        plt.plot(x[0], x[1], "go")
    
    if not np.all(y_target == y_p):
        plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)

plt.plot([-1, 1], [1, -1], "–", color="black")
plt.show()

import matplotlib.pyplot as plt

# 假設 vqc 是一個已經訓練好的量子機器學習模型
print(vqc.score(X_train, y_train))

plt.show()

# 建立 QNN
regression_estimator_qnn = EstimatorQNN(
    circuit=qc, 
    input_params=feature_map.parameters, 
    weight_params=ansatz.parameters
)

# 建立迴歸模型
regressor = NeuralNetworkRegressor(
    neural_network=regression_estimator_qnn,
    loss="squared_error",
    optimizer=L_BFGS_B(maxiter=5),
    callback=callback_graph,
)

# 訓練模型
regressor.fit(X, y)

import torch
import torch.nn as nn
import numpy as np

# 定義量子生成器
class QuantumGenerator(nn.Module):
    def __init__(self, num_qubits, num_layers):
        super(QuantumGenerator, self).__init__()
        self.num_qubits = num_qubits
        self.num_layers = num_layers
        self.circuit = nn.ModuleList([nn.Parameter(torch.randn(num_qubits)) for _ in range(num_layers)])

    def forward(self, x):
        # 將輸入轉換為量子態
        quantum_state = torch.zeros(x.shape[0], 2**self.num_qubits)
        for i in range(self.num_layers):
            # 應用量子門
            quantum_state = torch.matmul(quantum_state, self.circuit[i])
        return quantum_state

# 定義經典判別器
class ClassicalDiscriminator(nn.Module):
    def __init__(self, num_qubits):
        super(ClassicalDiscriminator, self).__init__()
        self.num_qubits = num_qubits
        self.fc1 = nn.Linear(2**num_qubits, 128)
        self.fc2 = nn.Linear(128, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.sigmoid(self.fc2(x))
        return x

# 訓練生成器和判別器
def train(generator, discriminator, data, epochs):
    for epoch in range(epochs):
        # 訓練生成器
        generator_optimizer = torch.optim.Adam(generator.parameters(), lr=0.001)
        generator_optimizer.zero_grad()
        loss = 0
        for x in data:
            # 將輸入轉換為量子態
            quantum_state = generator(x)
            # 計算損失
            loss += torch.mean((discriminator(quantum_state) - 1)**2)
        loss.backward()
        generator_optimizer.step()

        # 訓練判別器
        discriminator_optimizer = torch.optim.Adam(discriminator.parameters(), lr=0.001)
        discriminator_optimizer.zero_grad()
        loss = 0
        for x in data:
            # 將輸入轉換為量子態
            quantum_state = generator(x)
            # 計算損失
            loss += torch.mean((discriminator(quantum_state) - 0)**2)
        loss.backward()
        discriminator_optimizer.step()

from qiskit.utils import algorithm_globals
from sklearn.preprocessing import LabelEncoder
import torch
import pandas as pd

torch.manual_seed(42)
algorithm_globals.random_seed = 42

mtype = '../data/datasets/e-type.csv'
df = pd.read_csv(mtype, delimiter=';')
df = df.rename(columns={"e-type": "Target"})

le = LabelEncoder()
df['Target'] = le.fit_transform(df['Target'])

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(df.drop('Target', axis=1), df['Target'], test_size=0.2, random_state=42)

class Generator(torch.nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.fc1 = torch.nn.Linear(10, 128)
        self.fc2 = torch.nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

class Discriminator(torch.nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.fc1 = torch.nn.Linear(10, 128)
        self.fc2 = torch.nn.Linear(128, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

generator = Generator()
discriminator = Discriminator()

criterion = torch.nn.BCELoss()
optimizer_g = torch.optim.Adam(generator.parameters(), lr=0.001)
optimizer_d = torch.optim.Adam(discriminator.parameters(), lr=0.001)

for epoch in range(100):
    for x, y in zip(X_train, y_train):
        # 訓練生成器
        z = torch.randn(1, 10)
        x_gen = generator(z)
        loss_g = criterion(discriminator(x_gen), torch.ones_like(discriminator(x_gen)))
        optimizer_g.zero_grad()
        loss_g.backward()
        optimizer_g.step()

        # 訓練判別器
        loss_d = criterion(discriminator(x), torch.ones_like(discriminator(x))) + criterion(discriminator(x_gen), torch.zeros_like(discriminator(x_gen)))
        optimizer_d.zero_grad()
        loss_d.backward()
        optimizer_d.step()

z = torch.randn(1, 10)
x_gen = generator(z)

y_pred = discriminator(x_gen)

accuracy = torch.mean((y_pred > 0.5).float())
print(f'Accuracy: {accuracy.item()}')